/* Generic frame functions.
- Copyright (C) 1993, 1994, 1995, 1997, 1999, 2000, 2001
+ Copyright (C) 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2003
Free Software Foundation.
This file is part of GNU Emacs.
#ifdef HAVE_WINDOW_SYSTEM
#include "fontset.h"
#endif
+#include "blockinput.h"
+#include "systty.h" /* For emacs_tty in termchar.h */
+#include "termchar.h"
#include "termhooks.h"
#include "dispextern.h"
#include "window.h"
#include "dosfns.h"
#endif
-Lisp_Object Qframep;
-Lisp_Object Qframe_live_p;
-Lisp_Object Qheight;
-Lisp_Object Qicon;
-Lisp_Object Qminibuffer;
-Lisp_Object Qmodeline;
-Lisp_Object Qname;
+
+#ifdef HAVE_WINDOW_SYSTEM
+
+/* The name we're using in resource queries. Most often "emacs". */
+
+Lisp_Object Vx_resource_name;
+
+/* The application class we're using in resource queries.
+ Normally "Emacs". */
+
+Lisp_Object Vx_resource_class;
+
+#endif
+
+Lisp_Object Qframep, Qframe_live_p;
+Lisp_Object Qicon, Qmodeline;
Lisp_Object Qonly;
-Lisp_Object Qunsplittable;
-Lisp_Object Qmenu_bar_lines;
-Lisp_Object Qtool_bar_lines;
-Lisp_Object Qwidth;
-Lisp_Object Qx;
-Lisp_Object Qw32;
-Lisp_Object Qpc;
-Lisp_Object Qmac;
+Lisp_Object Qx, Qw32, Qmac, Qpc;
Lisp_Object Qvisible;
-Lisp_Object Qbuffer_predicate;
-Lisp_Object Qbuffer_list;
-Lisp_Object Qtitle;
Lisp_Object Qdisplay_type;
Lisp_Object Qbackground_mode;
Lisp_Object Qinhibit_default_face_x_resources;
-Lisp_Object Qleft_fringe;
-Lisp_Object Qright_fringe;
+
+Lisp_Object Qx_frame_parameter;
+Lisp_Object Qx_resource_name;
+
+/* Frame parameters (set or reported). */
+
+Lisp_Object Qauto_raise, Qauto_lower;
+Lisp_Object Qborder_color, Qborder_width;
+Lisp_Object Qcursor_color, Qcursor_type;
+Lisp_Object Qgeometry; /* Not used */
+Lisp_Object Qheight, Qwidth;
+Lisp_Object Qleft, Qright;
+Lisp_Object Qicon_left, Qicon_top, Qicon_type, Qicon_name;
+Lisp_Object Qinternal_border_width;
+Lisp_Object Qmouse_color;
+Lisp_Object Qminibuffer;
+Lisp_Object Qscroll_bar_width, Qvertical_scroll_bars;
+Lisp_Object Qvisibility;
+Lisp_Object Qscroll_bar_foreground, Qscroll_bar_background;
+Lisp_Object Qscreen_gamma;
+Lisp_Object Qline_spacing;
+Lisp_Object Quser_position, Quser_size;
+Lisp_Object Qwait_for_wm;
+Lisp_Object Qwindow_id;
+#ifdef HAVE_X_WINDOWS
+Lisp_Object Qouter_window_id;
+#endif
+Lisp_Object Qparent_id;
+Lisp_Object Qtitle, Qname;
+Lisp_Object Qunsplittable;
+Lisp_Object Qmenu_bar_lines, Qtool_bar_lines;
+Lisp_Object Qleft_fringe, Qright_fringe;
+Lisp_Object Qbuffer_predicate, Qbuffer_list;
Lisp_Object Qtty_color_mode;
+Lisp_Object Qtty, Qtty_type;
+
+Lisp_Object Qfullscreen, Qfullwidth, Qfullheight, Qfullboth;
+
+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;
struct window *w = XWINDOW (window);
XSETFASTINT (w->last_modified, 0);
- XSETFASTINT (w->top, XFASTINT (w->top) + n);
- XSETFASTINT (w->height, XFASTINT (w->height) - n);
-
- if (INTEGERP (w->orig_top))
- XSETFASTINT (w->orig_top, XFASTINT (w->orig_top) + n);
- if (INTEGERP (w->orig_height))
- XSETFASTINT (w->orig_height, XFASTINT (w->orig_height) - n);
+ XSETFASTINT (w->top_line, XFASTINT (w->top_line) + n);
+ XSETFASTINT (w->total_lines, XFASTINT (w->total_lines) - n);
+
+ if (INTEGERP (w->orig_top_line))
+ XSETFASTINT (w->orig_top_line, XFASTINT (w->orig_top_line) + n);
+ if (INTEGERP (w->orig_total_lines))
+ XSETFASTINT (w->orig_total_lines, XFASTINT (w->orig_total_lines) - n);
/* Handle just the top child in a vertical split. */
if (!NILP (w->vchild))
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 ();
f->tool_bar_items = Qnil;
f->desired_tool_bar_string = f->current_tool_bar_string = Qnil;
f->n_tool_bar_items = 0;
+ f->left_fringe_width = f->right_fringe_width = 0;
+ f->fringe_cols = 0;
+ f->scroll_bar_actual_width = 0;
+ f->border_width = 0;
+ f->internal_border_width = 0;
+ f->column_width = 1; /* !FRAME_WINDOW_P value */
+ f->line_height = 1; /* !FRAME_WINDOW_P value */
+ f->x_pixels_diff = f->y_pixels_diff = 0;
+#ifdef HAVE_WINDOW_SYSTEM
+ f->want_fullscreen = FULLSCREEN_NONE;
+#endif
+ f->size_hint_flags = 0;
+ f->win_gravity = 0;
root_window = make_window ();
if (mini_p)
just so that there is "something there."
Correct size will be set up later with change_frame_size. */
- SET_FRAME_WIDTH (f, 10);
- f->height = 10;
+ SET_FRAME_COLS (f, 10);
+ FRAME_LINES (f) = 10;
- XSETFASTINT (XWINDOW (root_window)->width, 10);
- XSETFASTINT (XWINDOW (root_window)->height, (mini_p ? 9 : 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)->width, 10);
- XSETFASTINT (XWINDOW (mini_window)->top, 9);
- XSETFASTINT (XWINDOW (mini_window)->height, 1);
+ XSETFASTINT (XWINDOW (mini_window)->total_cols, 10);
+ XSETFASTINT (XWINDOW (mini_window)->top_line, 9);
+ XSETFASTINT (XWINDOW (mini_window)->total_lines, 1);
}
/* Choose a buffer for the frame's root window. */
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);
+ set_window_buffer (root_window, buf, 0, 0);
f->buffer_list = Fcons (buf, Qnil);
}
(NILP (Vminibuffer_list)
? get_minibuffer (0)
: Fcar (Vminibuffer_list)),
- 0);
+ 0, 0);
}
f->root_window = root_window;
a newly-created, never-selected window. */
XSETFASTINT (XWINDOW (f->selected_window)->use_time, ++window_select_count);
+ f->default_face_done_p = 0;
+
return f;
}
\f
call1 (intern ("make-initial-minibuffer-frame"), display);
UNGCPRO;
}
-
+
mini_window = XFRAME (kb->Vdefault_minibuffer_frame)->minibuffer_window;
}
Fset_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
- : Fcar (Vminibuffer_list)));
+ : Fcar (Vminibuffer_list)), Qnil);
return f;
}
Fset_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
- : Fcar (Vminibuffer_list)));
+ : Fcar (Vminibuffer_list)), Qnil);
return f;
}
#endif /* HAVE_WINDOW_SYSTEM */
\f
-/* Construct a frame that refers to the terminal (stdin and stdout). */
+/* Construct a frame that refers to a terminal. */
static int terminal_frame_count;
struct frame *
-make_terminal_frame ()
+make_terminal_frame (tty_name, tty_type)
+ char *tty_name;
+ char *tty_type;
{
register struct frame *f;
Lisp_Object frame;
char name[20];
-
+
#ifdef MULTI_KBOARD
if (!initial_kboard)
{
#else
#ifdef WINDOWSNT
f->output_method = output_termcap;
- f->output_data.x = &tty_display;
+ f->output_data.x = &tty_display; /* XXX */
#else
#ifdef MAC_OS8
make_mac_terminal_frame (f);
#else
- f->output_data.x = &tty_display;
+ {
+ struct tty_display_info *tty;
+ f->output_method = output_termcap;
+
+ f->output_data.tty = (struct tty_output *) xmalloc (sizeof (struct tty_output));
+ bzero (f->output_data.tty, sizeof (struct tty_output));
+
+ FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
+ FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
+
+ if (initialized)
+ {
+ /* Note that term_init may signal an error, but then it is its
+ responsibility to make sure this frame is deleted. */
+ f->output_data.tty->display_info = term_init (frame, tty_name, tty_type);
+ }
+ else
+ {
+ /* init_display() will reinitialize the terminal with correct values after dump. */
+ f->output_data.tty->display_info = term_dummy_init ();
+ }
+ FRAME_TTY (f)->reference_count++;
+ }
+
#ifdef CANNOT_DUMP
FRAME_FOREGROUND_PIXEL(f) = FACE_TTY_DEFAULT_FG_COLOR;
FRAME_BACKGROUND_PIXEL(f) = FACE_TTY_DEFAULT_BG_COLOR;
DEFUN ("make-terminal-frame", Fmake_terminal_frame, Smake_terminal_frame,
1, 1, 0,
- doc: /* Create an additional terminal frame.
-You can create multiple frames on a text-only terminal in this way.
-Only the selected terminal frame is actually displayed.
+ doc: /* Create an additional terminal frame, possibly on another terminal.
This function takes one argument, an alist specifying frame parameters.
-In practice, generally you don't need to specify any parameters.
+
+You can create multiple frames on a single text-only 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.
+In that case, the `tty' parameter specifies the device file to open,
+and the `tty-type' parameter specifies the terminal type. Example:
+
+ (make-terminal-frame '((tty . "/dev/pts/5") (tty-type . "xterm")))
+
Note that changing the size of one terminal frame automatically affects all. */)
(parms)
Lisp_Object parms;
#endif
#endif /* not MSDOS */
- f = make_terminal_frame ();
+ {
+ Lisp_Object tty, tty_type;
+ char *name = 0, *type = 0;
+
+ /* XXX Ugh, there must be a better way to do this. */
+ tty = Fassq (Qtty, parms);
+ if (EQ (tty, Qnil))
+ tty = Fassq (Qtty, XFRAME (selected_frame)->param_alist);
+ if (EQ (tty, Qnil))
+ tty = Fassq (Qtty, Vdefault_frame_alist);
+ if (! EQ (tty, Qnil))
+ tty = XCDR (tty);
+ if (EQ (tty, Qnil) || !STRINGP (tty))
+ tty = Qnil;
+
+ tty_type = Fassq (Qtty_type, parms);
+ if (EQ (tty_type, Qnil))
+ tty_type = Fassq (Qtty_type, Vdefault_frame_alist);
+ if (EQ (tty_type, Qnil))
+ tty_type = Fassq (Qtty, XFRAME (selected_frame)->param_alist);
+ if (! EQ (tty_type, Qnil))
+ tty_type = XCDR (tty_type);
+ if (EQ (tty_type, Qnil) || !STRINGP (tty_type))
+ tty_type = Qnil;
+
+ if (! EQ (tty, Qnil))
+ {
+ name = (char *) alloca (SBYTES (tty) + 1);
+ strncpy (name, SDATA (tty), SBYTES (tty));
+ name[SBYTES (tty)] = 0;
+ }
+
+ if (! EQ (tty_type, Qnil))
+ {
+ type = (char *) alloca (SBYTES (tty_type) + 1);
+ strncpy (type, SDATA (tty_type), SBYTES (tty_type));
+ type[SBYTES (tty_type)] = 0;
+ }
+
+ f = make_terminal_frame (name, type);
+ }
- change_frame_size (f, FRAME_HEIGHT (sf),
- FRAME_WIDTH (sf), 0, 0, 0);
+ {
+ int width, height;
+ get_tty_size (fileno (TTY_INPUT (FRAME_TTY (f))), &width, &height);
+ change_frame_size (f, height, width, 0, 0, 0);
+ }
+
adjust_glyphs (f);
calculate_costs (f);
XSETFRAME (frame, f);
int track, for_deletion;
{
struct frame *sf = SELECTED_FRAME ();
-
+
/* If FRAME is a switch-frame event, extract the frame we should
switch to. */
if (CONSP (frame)
if (!for_deletion && FRAME_HAS_MINIBUF_P (sf))
resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf)), 1);
+ if (FRAME_TERMCAP_P (XFRAME (selected_frame))
+ && FRAME_TERMCAP_P (XFRAME (frame))
+ && FRAME_TTY (XFRAME (selected_frame)) == FRAME_TTY (XFRAME (frame)))
+ {
+ XFRAME (selected_frame)->async_visible = 2; /* obscured */
+ XFRAME (frame)->async_visible = 1;
+ FRAME_TTY (XFRAME (frame))->top_frame = frame;
+ }
+
selected_frame = frame;
if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
last_nonminibuf_frame = XFRAME (selected_frame);
- Fselect_window (XFRAME (frame)->selected_window);
+ Fselect_window (XFRAME (frame)->selected_window, Qnil);
#ifndef WINDOWSNT
/* Make sure to switch the tty color mode to that of the newly
DEFUN ("ignore-event", Fignore_event, Signore_event, 0, 0, "",
doc: /* Do nothing, but preserve any prefix argument already specified.
-This is a suitable binding for iconify-frame and make-frame-visible. */)
+This is a suitable binding for `iconify-frame' and `make-frame-visible'. */)
()
{
current_kboard->Vprefix_arg = Vcurrent_prefix_arg;
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;
}
Lisp_Object frame;
{
Lisp_Object window;
-
+
if (NILP (frame))
window = SELECTED_FRAME ()->selected_window;
else
{
if (NILP (frame))
frame = selected_frame;
-
+
CHECK_LIVE_FRAME (frame);
CHECK_LIVE_WINDOW (window);
error ("In `set-frame-selected-window', WINDOW is not on FRAME");
if (EQ (frame, selected_frame))
- return Fselect_window (window);
+ return Fselect_window (window, Qnil);
return XFRAME (frame)->selected_window = window;
}
f = XCAR (tail);
if (passed
- && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
+ && ((!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. */
if (EQ (frame, f) && !NILP (prev))
return prev;
- if (FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
+ 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 (frame))
frame = selected_frame;
-
+
CHECK_LIVE_FRAME (frame);
return next_frame (frame, miniframe);
}
{
FOR_EACH_FRAME (tail, frame1)
{
- if (! EQ (frame, frame1))
+ if (! EQ (frame, frame1) && FRAME_LIVE_P (XFRAME (frame1)))
break;
}
}
if (EQ (f->minibuffer_window, minibuf_window))
{
Fset_window_buffer (sf->minibuffer_window,
- XWINDOW (minibuf_window)->buffer);
+ 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);
+ Fselect_window (minibuf_window, Qnil);
}
/* Don't let echo_area_window to remain on a deleted frame. */
x_clear_frame_selections (f);
#endif
- /* Free glyphs.
- This function must be called before the window tree of the
+ /* Free glyphs.
+ This function must be called before the window tree of the
frame is deleted because windows contain dynamically allocated
memory. */
free_glyphs (f);
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))
x_destroy_window (f);
#endif
- f->output_data.nothing = 0;
+ if (FRAME_TERMCAP_P (f))
+ {
+ int delete = 1;
+ struct tty_display_info *tty = FRAME_TTY (f);
+
+ if (! --tty->reference_count)
+ {
+ /* delete_tty would call us recursively if we don't kill the
+ frame now. */
+ xfree (f->output_data.tty);
+ f->output_data.nothing = 0;
+ delete_tty (tty);
+ }
+ }
+ else
+ {
+ f->output_data.nothing = 0;
+ }
/* If we've deleted the last_nonminibuf_frame, then try to find
another one. */
{
struct frame *sf = XFRAME (selected_frame);
Fset_window_buffer (sf->minibuffer_window,
- XWINDOW (minibuf_window)->buffer);
+ XWINDOW (minibuf_window)->buffer, Qnil);
minibuf_window = sf->minibuffer_window;
}
{
if (NILP (frame))
frame = selected_frame;
-
+
CHECK_LIVE_FRAME (frame);
#if 0 /* This isn't logically necessary, and it can do GC. */
{
struct frame *sf = XFRAME (selected_frame);
Fset_window_buffer (sf->minibuffer_window,
- XWINDOW (minibuf_window)->buffer);
+ XWINDOW (minibuf_window)->buffer, Qnil);
minibuf_window = sf->minibuffer_window;
}
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
-
+
if (frame_raise_lower_hook)
(*frame_raise_lower_hook) (XFRAME (frame), 0);
if (frame_rehighlight_hook)
(*frame_rehighlight_hook) (XFRAME (frame));
-
+
return Qnil;
}
/* Update some other special parameters in their special places
in addition to the alist. */
-
+
if (EQ (prop, Qbuffer_predicate))
f->buffer_predicate = val;
if (EQ (prop, Qminibuffer) && WINDOWP (val))
{
if (! MINI_WINDOW_P (XWINDOW (val)))
- error ("Surrogate minibuffer windows must be minibuffer windows.");
+ error ("Surrogate minibuffer windows must be minibuffer windows");
if ((FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
&& !EQ (val, f->minibuffer_window))
alist = Fcopy_alist (f->param_alist);
GCPRO1 (alist);
-
+
if (!FRAME_WINDOW_P (f))
{
int fg = FRAME_FOREGROUND_PIXEL (f);
:"tty"));
}
store_in_alist (&alist, Qname, f->name);
- height = (FRAME_NEW_HEIGHT (f) ? FRAME_NEW_HEIGHT (f) : FRAME_HEIGHT (f));
+ height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
store_in_alist (&alist, Qheight, make_number (height));
- width = (FRAME_NEW_WIDTH (f) ? FRAME_NEW_WIDTH (f) : FRAME_WIDTH (f));
+ 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,
else
CHECK_FRAME (frame);
CHECK_SYMBOL (parameter);
-
+
f = XFRAME (frame);
value = Qnil;
-
+
if (FRAME_LIVE_P (f))
{
/* Avoid consing in frequent cases. */
else
value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
}
-
+
return value;
}
-DEFUN ("modify-frame-parameters", Fmodify_frame_parameters,
+DEFUN ("modify-frame-parameters", Fmodify_frame_parameters,
Smodify_frame_parameters, 2, 2, 0,
doc: /* Modify the parameters of frame FRAME according to ALIST.
If FRAME is nil, it defaults to the selected frame.
return make_number (1);
}
-DEFUN ("frame-pixel-height", Fframe_pixel_height,
+DEFUN ("frame-pixel-height", Fframe_pixel_height,
Sframe_pixel_height, 0, 1, 0,
doc: /* Return a FRAME's height in pixels.
This counts only the height available for text lines,
return make_number (x_pixel_height (f));
else
#endif
- return make_number (FRAME_HEIGHT (f));
+ return make_number (FRAME_LINES (f));
}
-DEFUN ("frame-pixel-width", Fframe_pixel_width,
+DEFUN ("frame-pixel-width", Fframe_pixel_width,
Sframe_pixel_width, 0, 1, 0,
doc: /* Return FRAME's width in pixels.
For a terminal frame, the result really gives the width in characters.
return make_number (x_pixel_width (f));
else
#endif
- return make_number (FRAME_WIDTH (f));
+ return make_number (FRAME_COLS (f));
}
\f
DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
{
- if (XINT (lines) != f->height)
- x_set_window_size (f, 1, f->width, XINT (lines));
+ if (XINT (lines) != FRAME_LINES (f))
+ x_set_window_size (f, 1, FRAME_COLS (f), XINT (lines));
do_pending_window_change (0);
}
else
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
{
- if (XINT (cols) != f->width)
- x_set_window_size (f, 1, XINT (cols), f->height);
+ if (XINT (cols) != FRAME_COLS (f))
+ x_set_window_size (f, 1, XINT (cols), FRAME_LINES (f));
do_pending_window_change (0);
}
else
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
{
- if (XINT (rows) != f->height || XINT (cols) != f->width
- || FRAME_NEW_HEIGHT (f) || FRAME_NEW_WIDTH (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);
}
return Qnil;
}
-DEFUN ("set-frame-position", Fset_frame_position,
+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.
}
\f
+/***********************************************************************
+ Frame Parameters
+ ***********************************************************************/
+
+/* Connect the frame-parameter names for X frames
+ to the ways of passing the parameter values to the window system.
+
+ The name of a parameter, as a Lisp symbol,
+ has an `x-frame-parameter' property which is an integer in Lisp
+ that is an index in this table. */
+
+struct frame_parm_table {
+ char *name;
+ Lisp_Object *variable;
+};
+
+static struct frame_parm_table frame_parms[] =
+{
+ {"auto-raise", &Qauto_raise},
+ {"auto-lower", &Qauto_lower},
+ {"background-color", 0},
+ {"border-color", &Qborder_color},
+ {"border-width", &Qborder_width},
+ {"cursor-color", &Qcursor_color},
+ {"cursor-type", &Qcursor_type},
+ {"font", 0},
+ {"foreground-color", 0},
+ {"icon-name", &Qicon_name},
+ {"icon-type", &Qicon_type},
+ {"internal-border-width", &Qinternal_border_width},
+ {"menu-bar-lines", &Qmenu_bar_lines},
+ {"mouse-color", &Qmouse_color},
+ {"name", &Qname},
+ {"scroll-bar-width", &Qscroll_bar_width},
+ {"title", &Qtitle},
+ {"unsplittable", &Qunsplittable},
+ {"vertical-scroll-bars", &Qvertical_scroll_bars},
+ {"visibility", &Qvisibility},
+ {"tool-bar-lines", &Qtool_bar_lines},
+ {"scroll-bar-foreground", &Qscroll_bar_foreground},
+ {"scroll-bar-background", &Qscroll_bar_background},
+ {"screen-gamma", &Qscreen_gamma},
+ {"line-spacing", &Qline_spacing},
+ {"left-fringe", &Qleft_fringe},
+ {"right-fringe", &Qright_fringe},
+ {"wait-for-wm", &Qwait_for_wm},
+ {"fullscreen", &Qfullscreen},
+};
+
+#ifdef HAVE_WINDOW_SYSTEM
+
+extern Lisp_Object Qbox;
+extern Lisp_Object Qtop;
+
+/* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
+ wanted positions of the WM window (not emacs window).
+ Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
+ window (FRAME_X_WINDOW).
+ */
+
void
-syms_of_frame ()
+x_fullscreen_adjust (f, width, height, top_pos, left_pos)
+ struct frame *f;
+ int *width;
+ int *height;
+ int *top_pos;
+ int *left_pos;
{
- 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);
- Qname = intern ("name");
- staticpro (&Qname);
- Qonly = intern ("only");
- staticpro (&Qonly);
- Qunsplittable = intern ("unsplittable");
- staticpro (&Qunsplittable);
- Qmenu_bar_lines = intern ("menu-bar-lines");
- staticpro (&Qmenu_bar_lines);
- Qtool_bar_lines = intern ("tool-bar-lines");
- staticpro (&Qtool_bar_lines);
- Qwidth = intern ("width");
- staticpro (&Qwidth);
- 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);
- Qtitle = intern ("title");
- staticpro (&Qtitle);
- Qdisplay_type = intern ("display-type");
- staticpro (&Qdisplay_type);
- Qbackground_mode = intern ("background-mode");
- staticpro (&Qbackground_mode);
- Qleft_fringe = intern ("left-fringe");
- staticpro (&Qleft_fringe);
- Qright_fringe = intern ("right-fringe");
- staticpro (&Qright_fringe);
- Qtty_color_mode = intern ("tty-color-mode");
- staticpro (&Qtty_color_mode);
+ int newwidth = FRAME_COLS (f);
+ int newheight = FRAME_LINES (f);
- DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
- doc: /* Alist of default values for frame creation.
-These may be set in your init file, like this:
- (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1))
-These override values given in window system configuration data,
- including X Windows' defaults database.
-For values specific to the first Emacs frame, see `initial-frame-alist'.
-For values specific to the separate minibuffer frame, see
- `minibuffer-frame-alist'.
-The `menu-bar-lines' element of the list controls whether new frames
- have menu bars; `menu-bar-mode' works by altering this element.
-Setting this variable does not affect existing frames, only new ones. */);
- Vdefault_frame_alist = Qnil;
+ *top_pos = f->top_pos;
+ *left_pos = f->left_pos;
- Qinhibit_default_face_x_resources
- = intern ("inhibit-default-face-x-resources");
- staticpro (&Qinhibit_default_face_x_resources);
+ if (f->want_fullscreen & FULLSCREEN_HEIGHT)
+ {
+ int ph;
- DEFVAR_LISP ("terminal-frame", &Vterminal_frame,
- doc: /* The initial frame-object, which represents Emacs's stdout. */);
+ 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;
+ }
- DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified,
- doc: /* Non-nil if all of emacs is iconified and frame updates are not needed. */);
- Vemacs_iconified = Qnil;
+ if (f->want_fullscreen & FULLSCREEN_WIDTH)
+ {
+ int pw;
- DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function,
- doc: /* If non-nil, function to transform normal value of `mouse-position'.
-`mouse-position' calls this function, passing its usual return value as
-argument, and returns whatever this function returns.
-This abnormal hook exists for the benefit of packages like `xt-mouse.el'
-which need to do mouse handling at the Lisp level. */);
- Vmouse_position_function = Qnil;
+ 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;
+ }
- DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight,
- doc: /* If non-nil, clickable text is highlighted when mouse is over it.
-If the value is an integer, highlighting is only shown after moving the
-mouse, while keyboard input turns off the highlight even when the mouse
-is over the clickable text. However, the mouse shape still indicates
-when the mouse is over clickable text. */);
- Vmouse_highlight = Qt;
+ *width = newwidth;
+ *height = newheight;
+}
- DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions,
- doc: /* Functions to be run before deleting a frame.
-The functions are run with one arg, the frame to be deleted.
-See `delete-frame'. */);
- Vdelete_frame_functions = Qnil;
- DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame,
- doc: /* Minibufferless frames use this frame's minibuffer.
+/* Change the parameters of frame F as specified by ALIST.
+ If a parameter is not specially recognized, do nothing special;
+ otherwise call the `x_set_...' function for that parameter.
+ Except for certain geometry properties, always call store_frame_param
+ to store the new value in the parameter alist. */
-Emacs cannot create minibufferless frames unless this is set to an
-appropriate surrogate.
+void
+x_set_frame_parameters (f, alist)
+ FRAME_PTR f;
+ Lisp_Object alist;
+{
+ Lisp_Object tail;
-Emacs consults this variable only when creating minibufferless
-frames; once the frame is created, it sticks with its assigned
-minibuffer, no matter what this variable is set to. This means that
-this variable doesn't necessarily say anything meaningful about the
-current set of frames, or where the minibuffer is currently being
-displayed.
+ /* If both of these parameters are present, it's more efficient to
+ set them both at once. So we wait until we've looked at the
+ entire list before we set them. */
+ int width, height;
-This variable is local to the current terminal and cannot be buffer-local. */);
+ /* Same here. */
+ Lisp_Object left, top;
- staticpro (&Vframe_list);
+ /* Same with these. */
+ Lisp_Object icon_left, icon_top;
- defsubr (&Sactive_minibuffer_window);
- defsubr (&Sframep);
- defsubr (&Sframe_live_p);
- defsubr (&Smake_terminal_frame);
- defsubr (&Shandle_switch_frame);
- defsubr (&Signore_event);
- defsubr (&Sselect_frame);
- defsubr (&Sselected_frame);
- defsubr (&Swindow_frame);
- defsubr (&Sframe_root_window);
- defsubr (&Sframe_first_window);
- defsubr (&Sframe_selected_window);
- defsubr (&Sset_frame_selected_window);
- defsubr (&Sframe_list);
- defsubr (&Snext_frame);
- defsubr (&Sprevious_frame);
- defsubr (&Sdelete_frame);
- defsubr (&Smouse_position);
- defsubr (&Smouse_pixel_position);
- defsubr (&Sset_mouse_position);
- defsubr (&Sset_mouse_pixel_position);
-#if 0
- defsubr (&Sframe_configuration);
- defsubr (&Srestore_frame_configuration);
-#endif
- defsubr (&Smake_frame_visible);
- defsubr (&Smake_frame_invisible);
- defsubr (&Siconify_frame);
- defsubr (&Sframe_visible_p);
- defsubr (&Svisible_frame_list);
- defsubr (&Sraise_frame);
- defsubr (&Slower_frame);
- defsubr (&Sredirect_frame_focus);
- defsubr (&Sframe_focus);
- defsubr (&Sframe_parameters);
- defsubr (&Sframe_parameter);
- defsubr (&Smodify_frame_parameters);
- defsubr (&Sframe_char_height);
- defsubr (&Sframe_char_width);
- defsubr (&Sframe_pixel_height);
- defsubr (&Sframe_pixel_width);
- defsubr (&Sset_frame_height);
- defsubr (&Sset_frame_width);
- defsubr (&Sset_frame_size);
- defsubr (&Sset_frame_position);
-}
+ /* Record in these vectors all the parms specified. */
+ Lisp_Object *parms;
+ Lisp_Object *values;
+ int i, p;
+ int left_no_change = 0, top_no_change = 0;
+ int icon_left_no_change = 0, icon_top_no_change = 0;
+ int fullscreen_is_being_set = 0;
+
+ struct gcpro gcpro1, gcpro2;
+
+ i = 0;
+ for (tail = alist; CONSP (tail); tail = Fcdr (tail))
+ i++;
+
+ parms = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
+ values = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
+
+ /* Extract parm names and values into those vectors. */
+
+ i = 0;
+ for (tail = alist; CONSP (tail); tail = Fcdr (tail))
+ {
+ Lisp_Object elt;
+
+ elt = Fcar (tail);
+ parms[i] = Fcar (elt);
+ values[i] = Fcdr (elt);
+ i++;
+ }
+ /* TAIL and ALIST are not used again below here. */
+ alist = tail = Qnil;
+
+ GCPRO2 (*parms, *values);
+ gcpro1.nvars = i;
+ gcpro2.nvars = i;
+
+ /* There is no need to gcpro LEFT, TOP, ICON_LEFT, or ICON_TOP,
+ because their values appear in VALUES and strings are not valid. */
+ top = left = Qunbound;
+ icon_left = icon_top = Qunbound;
+
+ /* Provide default values for HEIGHT and WIDTH. */
+ width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
+ height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
+
+ /* Process foreground_color and background_color before anything else.
+ They are independent of other properties, but other properties (e.g.,
+ cursor_color) are dependent upon them. */
+ /* Process default font as well, since fringe widths depends on it. */
+ /* Also, process fullscreen, width and height depend upon that */
+ for (p = 0; p < i; p++)
+ {
+ Lisp_Object prop, val;
+
+ prop = parms[p];
+ val = values[p];
+ if (EQ (prop, Qforeground_color)
+ || EQ (prop, Qbackground_color)
+ || EQ (prop, Qfont)
+ || EQ (prop, Qfullscreen))
+ {
+ register Lisp_Object param_index, old_value;
+
+ old_value = get_frame_param (f, prop);
+ fullscreen_is_being_set |= EQ (prop, Qfullscreen);
+
+ if (NILP (Fequal (val, old_value)))
+ {
+ store_frame_param (f, prop, val);
+
+ param_index = Fget (prop, Qx_frame_parameter);
+ if (NATNUMP (param_index)
+ && (XFASTINT (param_index)
+ < sizeof (frame_parms)/sizeof (frame_parms[0]))
+ && rif->frame_parm_handlers[XINT (param_index)])
+ (*(rif->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
+ }
+ }
+ }
+
+ /* Now process them in reverse of specified order. */
+ for (i--; i >= 0; i--)
+ {
+ Lisp_Object prop, val;
+
+ prop = parms[i];
+ val = values[i];
+
+ if (EQ (prop, Qwidth) && NUMBERP (val))
+ width = XFASTINT (val);
+ else if (EQ (prop, Qheight) && NUMBERP (val))
+ height = XFASTINT (val);
+ else if (EQ (prop, Qtop))
+ top = val;
+ else if (EQ (prop, Qleft))
+ left = val;
+ else if (EQ (prop, Qicon_top))
+ icon_top = val;
+ else if (EQ (prop, Qicon_left))
+ icon_left = val;
+ else if (EQ (prop, Qforeground_color)
+ || EQ (prop, Qbackground_color)
+ || EQ (prop, Qfont)
+ || EQ (prop, Qfullscreen))
+ /* Processed above. */
+ continue;
+ else
+ {
+ register Lisp_Object param_index, old_value;
+
+ old_value = get_frame_param (f, prop);
+
+ store_frame_param (f, prop, val);
+
+ param_index = Fget (prop, Qx_frame_parameter);
+ if (NATNUMP (param_index)
+ && (XFASTINT (param_index)
+ < sizeof (frame_parms)/sizeof (frame_parms[0]))
+ && rif->frame_parm_handlers[XINT (param_index)])
+ (*(rif->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
+ }
+ }
+
+ /* Don't die if just one of these was set. */
+ if (EQ (left, Qunbound))
+ {
+ left_no_change = 1;
+ if (f->left_pos < 0)
+ left = Fcons (Qplus, Fcons (make_number (f->left_pos), Qnil));
+ else
+ XSETINT (left, f->left_pos);
+ }
+ if (EQ (top, Qunbound))
+ {
+ top_no_change = 1;
+ if (f->top_pos < 0)
+ top = Fcons (Qplus, Fcons (make_number (f->top_pos), Qnil));
+ else
+ XSETINT (top, f->top_pos);
+ }
+
+ /* If one of the icon positions was not set, preserve or default it. */
+ if (EQ (icon_left, Qunbound) || ! INTEGERP (icon_left))
+ {
+ icon_left_no_change = 1;
+ icon_left = Fcdr (Fassq (Qicon_left, f->param_alist));
+ if (NILP (icon_left))
+ XSETINT (icon_left, 0);
+ }
+ if (EQ (icon_top, Qunbound) || ! INTEGERP (icon_top))
+ {
+ icon_top_no_change = 1;
+ icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
+ if (NILP (icon_top))
+ XSETINT (icon_top, 0);
+ }
+
+#ifndef HAVE_CARBON
+ /* MAC_TODO: fullscreen */
+ if (FRAME_VISIBLE_P (f) && fullscreen_is_being_set)
+ {
+ /* If the frame is visible already and the fullscreen parameter is
+ being set, it is too late to set WM manager hints to specify
+ size and position.
+ Here we first get the width, height and position that applies to
+ fullscreen. We then move the frame to the appropriate
+ position. Resize of the frame is taken care of in the code after
+ this if-statement. */
+ int new_left, new_top;
+
+ x_fullscreen_adjust (f, &width, &height, &new_top, &new_left);
+ if (new_top != f->top_pos || new_left != f->left_pos)
+ x_set_offset (f, new_left, new_top, 1);
+ }
+#endif
+
+ /* Don't set these parameters unless they've been explicitly
+ specified. The window might be mapped or resized while we're in
+ this function, and we don't want to override that unless the lisp
+ code has asked for it.
+
+ Don't set these parameters unless they actually differ from the
+ window's current parameters; the window may not actually exist
+ yet. */
+ {
+ Lisp_Object frame;
+
+ check_frame_size (f, &height, &width);
+
+ XSETFRAME (frame, f);
+
+ if (width != FRAME_COLS (f)
+ || height != FRAME_LINES (f)
+ || f->new_text_lines || f->new_text_cols)
+ Fset_frame_size (frame, make_number (width), make_number (height));
+
+ if ((!NILP (left) || !NILP (top))
+ && ! (left_no_change && top_no_change)
+ && ! (NUMBERP (left) && XINT (left) == f->left_pos
+ && NUMBERP (top) && XINT (top) == f->top_pos))
+ {
+ int leftpos = 0;
+ int toppos = 0;
+
+ /* Record the signs. */
+ f->size_hint_flags &= ~ (XNegative | YNegative);
+ if (EQ (left, Qminus))
+ f->size_hint_flags |= XNegative;
+ else if (INTEGERP (left))
+ {
+ leftpos = XINT (left);
+ if (leftpos < 0)
+ f->size_hint_flags |= XNegative;
+ }
+ else if (CONSP (left) && EQ (XCAR (left), Qminus)
+ && CONSP (XCDR (left))
+ && INTEGERP (XCAR (XCDR (left))))
+ {
+ leftpos = - XINT (XCAR (XCDR (left)));
+ f->size_hint_flags |= XNegative;
+ }
+ else if (CONSP (left) && EQ (XCAR (left), Qplus)
+ && CONSP (XCDR (left))
+ && INTEGERP (XCAR (XCDR (left))))
+ {
+ leftpos = XINT (XCAR (XCDR (left)));
+ }
+
+ if (EQ (top, Qminus))
+ f->size_hint_flags |= YNegative;
+ else if (INTEGERP (top))
+ {
+ toppos = XINT (top);
+ if (toppos < 0)
+ f->size_hint_flags |= YNegative;
+ }
+ else if (CONSP (top) && EQ (XCAR (top), Qminus)
+ && CONSP (XCDR (top))
+ && INTEGERP (XCAR (XCDR (top))))
+ {
+ toppos = - XINT (XCAR (XCDR (top)));
+ f->size_hint_flags |= YNegative;
+ }
+ else if (CONSP (top) && EQ (XCAR (top), Qplus)
+ && CONSP (XCDR (top))
+ && INTEGERP (XCAR (XCDR (top))))
+ {
+ toppos = XINT (XCAR (XCDR (top)));
+ }
+
+
+ /* Store the numeric value of the position. */
+ f->top_pos = toppos;
+ f->left_pos = leftpos;
+
+ f->win_gravity = NorthWestGravity;
+
+ /* Actually set that position, and convert to absolute. */
+ x_set_offset (f, leftpos, toppos, -1);
+ }
+
+ if ((!NILP (icon_left) || !NILP (icon_top))
+ && ! (icon_left_no_change && icon_top_no_change))
+ x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
+ }
+
+ UNGCPRO;
+}
+
+
+/* Insert a description of internally-recorded parameters of frame X
+ into the parameter alist *ALISTPTR that is to be given to the user.
+ Only parameters that are specific to the X window system
+ and whose values are not correctly recorded in the frame's
+ param_alist need to be considered here. */
+
+void
+x_report_frame_params (f, alistptr)
+ struct frame *f;
+ Lisp_Object *alistptr;
+{
+ char buf[16];
+ Lisp_Object tem;
+
+ /* Represent negative positions (off the top or left screen edge)
+ in a way that Fmodify_frame_parameters will understand correctly. */
+ XSETINT (tem, f->left_pos);
+ if (f->left_pos >= 0)
+ store_in_alist (alistptr, Qleft, tem);
+ else
+ store_in_alist (alistptr, Qleft, Fcons (Qplus, Fcons (tem, Qnil)));
+
+ XSETINT (tem, f->top_pos);
+ if (f->top_pos >= 0)
+ store_in_alist (alistptr, Qtop, tem);
+ else
+ store_in_alist (alistptr, Qtop, Fcons (Qplus, Fcons (tem, Qnil)));
+
+ store_in_alist (alistptr, Qborder_width,
+ make_number (f->border_width));
+ store_in_alist (alistptr, Qinternal_border_width,
+ make_number (FRAME_INTERNAL_BORDER_WIDTH (f)));
+ store_in_alist (alistptr, Qleft_fringe,
+ make_number (FRAME_LEFT_FRINGE_WIDTH (f)));
+ store_in_alist (alistptr, Qright_fringe,
+ make_number (FRAME_RIGHT_FRINGE_WIDTH (f)));
+ store_in_alist (alistptr, Qscroll_bar_width,
+ (! FRAME_HAS_VERTICAL_SCROLL_BARS (f)
+ ? make_number (0)
+ : FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0
+ ? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
+ /* nil means "use default width"
+ for non-toolkit scroll bar.
+ ruler-mode.el depends on this. */
+ : Qnil));
+ sprintf (buf, "%ld", (long) FRAME_X_WINDOW (f));
+ store_in_alist (alistptr, Qwindow_id,
+ build_string (buf));
+#ifdef HAVE_X_WINDOWS
+#ifdef USE_X_TOOLKIT
+ /* Tooltip frame may not have this widget. */
+ if (FRAME_X_OUTPUT (f)->widget)
+#endif
+ sprintf (buf, "%ld", (long) FRAME_OUTER_WINDOW (f));
+ store_in_alist (alistptr, Qouter_window_id,
+ build_string (buf));
+#endif
+ store_in_alist (alistptr, Qicon_name, f->icon_name);
+ FRAME_SAMPLE_VISIBILITY (f);
+ store_in_alist (alistptr, Qvisibility,
+ (FRAME_VISIBLE_P (f) ? Qt
+ : FRAME_ICONIFIED_P (f) ? Qicon : Qnil));
+ store_in_alist (alistptr, Qdisplay,
+ XCAR (FRAME_X_DISPLAY_INFO (f)->name_list_element));
+
+#ifndef HAVE_CARBON
+/* A Mac Window is identified by a struct, not an integer. */
+ if (FRAME_X_OUTPUT (f)->parent_desc == FRAME_X_DISPLAY_INFO (f)->root_window)
+ tem = Qnil;
+ else
+ XSETFASTINT (tem, FRAME_X_OUTPUT (f)->parent_desc);
+ store_in_alist (alistptr, Qparent_id, tem);
+#endif
+}
+
+
+/* Change the `fullscreen' frame parameter of frame F. OLD_VALUE is
+ the previous value of that parameter, NEW_VALUE is the new value. */
+
+void
+x_set_fullscreen (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+{
+#ifndef HAVE_CARBON
+ if (NILP (new_value))
+ f->want_fullscreen = FULLSCREEN_NONE;
+ else if (EQ (new_value, Qfullboth))
+ f->want_fullscreen = FULLSCREEN_BOTH;
+ else if (EQ (new_value, Qfullwidth))
+ f->want_fullscreen = FULLSCREEN_WIDTH;
+ else if (EQ (new_value, Qfullheight))
+ f->want_fullscreen = FULLSCREEN_HEIGHT;
+#endif
+}
+
+
+/* Change the `line-spacing' frame parameter of frame F. OLD_VALUE is
+ the previous value of that parameter, NEW_VALUE is the new value. */
+
+void
+x_set_line_spacing (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+{
+ if (NILP (new_value))
+ f->extra_line_spacing = 0;
+ else if (NATNUMP (new_value))
+ f->extra_line_spacing = XFASTINT (new_value);
+ else
+ Fsignal (Qerror, Fcons (build_string ("Invalid line-spacing"),
+ Fcons (new_value, Qnil)));
+ if (FRAME_VISIBLE_P (f))
+ redraw_frame (f);
+}
+
+
+/* Change the `screen-gamma' frame parameter of frame F. OLD_VALUE is
+ the previous value of that parameter, NEW_VALUE is the new value. */
+
+void
+x_set_screen_gamma (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+{
+ if (NILP (new_value))
+ f->gamma = 0;
+ else if (NUMBERP (new_value) && XFLOATINT (new_value) > 0)
+ /* The value 0.4545 is the normal viewing gamma. */
+ f->gamma = 1.0 / (0.4545 * XFLOATINT (new_value));
+ else
+ Fsignal (Qerror, Fcons (build_string ("Invalid screen-gamma"),
+ Fcons (new_value, Qnil)));
+
+ clear_face_cache (0);
+}
+
+
+void
+x_set_font (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+{
+ Lisp_Object result;
+ Lisp_Object fontset_name;
+ Lisp_Object frame;
+ int old_fontset = FRAME_FONTSET(f);
+
+ CHECK_STRING (arg);
+
+ fontset_name = Fquery_fontset (arg, Qnil);
+
+ BLOCK_INPUT;
+ result = (STRINGP (fontset_name)
+ ? x_new_fontset (f, SDATA (fontset_name))
+ : x_new_font (f, SDATA (arg)));
+ UNBLOCK_INPUT;
+
+ if (EQ (result, Qnil))
+ error ("Font `%s' is not defined", SDATA (arg));
+ else if (EQ (result, Qt))
+ error ("The characters of the given font have varying widths");
+ else if (STRINGP (result))
+ {
+ if (STRINGP (fontset_name))
+ {
+ /* Fontset names are built from ASCII font names, so the
+ names may be equal despite there was a change. */
+ if (old_fontset == FRAME_FONTSET (f))
+ return;
+ }
+ else if (!NILP (Fequal (result, oldval)))
+ return;
+
+ store_frame_param (f, Qfont, result);
+ recompute_basic_faces (f);
+ }
+ else
+ abort ();
+
+ do_pending_window_change (0);
+
+ /* Don't call `face-set-after-frame-default' when faces haven't been
+ initialized yet. This is the case when called from
+ Fx_create_frame. In that case, the X widget or window doesn't
+ exist either, and we can end up in x_report_frame_params with a
+ null widget which gives a segfault. */
+ if (FRAME_FACE_CACHE (f))
+ {
+ XSETFRAME (frame, f);
+ call1 (Qface_set_after_frame_default, frame);
+ }
+}
+
+
+void
+x_set_fringe_width (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+{
+ compute_fringe_widths (f, 1);
+}
+
+void
+x_set_border_width (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+{
+ CHECK_NUMBER (arg);
+
+ if (XINT (arg) == f->border_width)
+ return;
+
+#ifndef HAVE_CARBON
+ if (FRAME_X_WINDOW (f) != 0)
+ error ("Cannot change the border width of a window");
+#endif /* MAC_TODO */
+
+ f->border_width = XINT (arg);
+}
+
+void
+x_set_internal_border_width (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+{
+ int old = FRAME_INTERNAL_BORDER_WIDTH (f);
+
+ CHECK_NUMBER (arg);
+ FRAME_INTERNAL_BORDER_WIDTH (f) = XINT (arg);
+ if (FRAME_INTERNAL_BORDER_WIDTH (f) < 0)
+ FRAME_INTERNAL_BORDER_WIDTH (f) = 0;
+
+#ifdef USE_X_TOOLKIT
+ if (FRAME_X_OUTPUT (f)->edit_widget)
+ widget_store_internal_border (FRAME_X_OUTPUT (f)->edit_widget);
+#endif
+
+ if (FRAME_INTERNAL_BORDER_WIDTH (f) == old)
+ return;
+
+ if (FRAME_X_WINDOW (f) != 0)
+ {
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ SET_FRAME_GARBAGED (f);
+ do_pending_window_change (0);
+ }
+ else
+ SET_FRAME_GARBAGED (f);
+}
+
+void
+x_set_visibility (f, value, oldval)
+ struct frame *f;
+ Lisp_Object value, oldval;
+{
+ Lisp_Object frame;
+ XSETFRAME (frame, f);
+
+ if (NILP (value))
+ Fmake_frame_invisible (frame, Qt);
+ else if (EQ (value, Qicon))
+ Ficonify_frame (frame);
+ else
+ Fmake_frame_visible (frame);
+}
+
+void
+x_set_autoraise (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+{
+ f->auto_raise = !EQ (Qnil, arg);
+}
+
+void
+x_set_autolower (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+{
+ f->auto_lower = !EQ (Qnil, arg);
+}
+
+void
+x_set_unsplittable (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+{
+ f->no_split = !NILP (arg);
+}
+
+void
+x_set_vertical_scroll_bars (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+{
+ if ((EQ (arg, Qleft) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
+ || (EQ (arg, Qright) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
+ || (NILP (arg) && FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+ || (!NILP (arg) && ! FRAME_HAS_VERTICAL_SCROLL_BARS (f)))
+ {
+ FRAME_VERTICAL_SCROLL_BAR_TYPE (f)
+ = (NILP (arg)
+ ? vertical_scroll_bar_none
+ : EQ (Qleft, arg)
+ ? vertical_scroll_bar_left
+ : EQ (Qright, arg)
+ ? vertical_scroll_bar_right
+ : EQ (Qleft, Vdefault_frame_scroll_bars)
+ ? vertical_scroll_bar_left
+ : EQ (Qright, Vdefault_frame_scroll_bars)
+ ? vertical_scroll_bar_right
+ : vertical_scroll_bar_none);
+
+ /* We set this parameter before creating the X window for the
+ frame, so we can get the geometry right from the start.
+ However, if the window hasn't been created yet, we shouldn't
+ call x_set_window_size. */
+ if (FRAME_X_WINDOW (f))
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ do_pending_window_change (0);
+ }
+}
+
+void
+x_set_scroll_bar_width (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+{
+ int wid = FRAME_COLUMN_WIDTH (f);
+
+ if (NILP (arg))
+ {
+ x_set_scroll_bar_default_width (f);
+
+ if (FRAME_X_WINDOW (f))
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ do_pending_window_change (0);
+ }
+ else if (INTEGERP (arg) && XINT (arg) > 0
+ && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
+ {
+ if (XFASTINT (arg) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM)
+ XSETINT (arg, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM + 1);
+
+ FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg);
+ FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + wid-1) / wid;
+ if (FRAME_X_WINDOW (f))
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ do_pending_window_change (0);
+ }
+
+ change_frame_size (f, 0, FRAME_COLS (f), 0, 0, 0);
+ XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
+ XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
+}
+
+
+
+/* Return non-nil if frame F wants a bitmap icon. */
+
+Lisp_Object
+x_icon_type (f)
+ FRAME_PTR f;
+{
+ Lisp_Object tem;
+
+ tem = assq_no_quit (Qicon_type, f->param_alist);
+ if (CONSP (tem))
+ return XCDR (tem);
+ else
+ return Qnil;
+}
+
+\f
+/* Subroutines of creating an X frame. */
+
+/* Make sure that Vx_resource_name is set to a reasonable value.
+ Fix it up, or set it to `emacs' if it is too hopeless. */
+
+void
+validate_x_resource_name ()
+{
+ int len = 0;
+ /* Number of valid characters in the resource name. */
+ int good_count = 0;
+ /* Number of invalid characters in the resource name. */
+ int bad_count = 0;
+ Lisp_Object new;
+ int i;
+
+ if (!STRINGP (Vx_resource_class))
+ Vx_resource_class = build_string (EMACS_CLASS);
+
+ if (STRINGP (Vx_resource_name))
+ {
+ unsigned char *p = SDATA (Vx_resource_name);
+ int i;
+
+ len = SBYTES (Vx_resource_name);
+
+ /* Only letters, digits, - and _ are valid in resource names.
+ Count the valid characters and count the invalid ones. */
+ for (i = 0; i < len; i++)
+ {
+ int c = p[i];
+ if (! ((c >= 'a' && c <= 'z')
+ || (c >= 'A' && c <= 'Z')
+ || (c >= '0' && c <= '9')
+ || c == '-' || c == '_'))
+ bad_count++;
+ else
+ good_count++;
+ }
+ }
+ else
+ /* Not a string => completely invalid. */
+ bad_count = 5, good_count = 0;
+
+ /* If name is valid already, return. */
+ if (bad_count == 0)
+ return;
+
+ /* If name is entirely invalid, or nearly so, use `emacs'. */
+ if (good_count == 0
+ || (good_count == 1 && bad_count > 0))
+ {
+ Vx_resource_name = build_string ("emacs");
+ return;
+ }
+
+ /* Name is partly valid. Copy it and replace the invalid characters
+ with underscores. */
+
+ Vx_resource_name = new = Fcopy_sequence (Vx_resource_name);
+
+ for (i = 0; i < len; i++)
+ {
+ int c = SREF (new, i);
+ if (! ((c >= 'a' && c <= 'z')
+ || (c >= 'A' && c <= 'Z')
+ || (c >= '0' && c <= '9')
+ || c == '-' || c == '_'))
+ SSET (new, i, '_');
+ }
+}
+
+
+extern char *x_get_string_resource P_ ((XrmDatabase, char *, char *));
+extern Display_Info *check_x_display_info P_ ((Lisp_Object));
+
+
+/* Get specified attribute from resource database RDB.
+ See Fx_get_resource below for other parameters. */
+
+static Lisp_Object
+xrdb_get_resource (rdb, attribute, class, component, subclass)
+ XrmDatabase rdb;
+ Lisp_Object attribute, class, component, subclass;
+{
+ register char *value;
+ char *name_key;
+ char *class_key;
+
+ CHECK_STRING (attribute);
+ CHECK_STRING (class);
+
+ if (!NILP (component))
+ CHECK_STRING (component);
+ if (!NILP (subclass))
+ CHECK_STRING (subclass);
+ if (NILP (component) != NILP (subclass))
+ error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
+
+ validate_x_resource_name ();
+
+ /* Allocate space for the components, the dots which separate them,
+ and the final '\0'. Make them big enough for the worst case. */
+ name_key = (char *) alloca (SBYTES (Vx_resource_name)
+ + (STRINGP (component)
+ ? SBYTES (component) : 0)
+ + SBYTES (attribute)
+ + 3);
+
+ class_key = (char *) alloca (SBYTES (Vx_resource_class)
+ + SBYTES (class)
+ + (STRINGP (subclass)
+ ? SBYTES (subclass) : 0)
+ + 3);
+
+ /* Start with emacs.FRAMENAME for the name (the specific one)
+ and with `Emacs' for the class key (the general one). */
+ strcpy (name_key, SDATA (Vx_resource_name));
+ strcpy (class_key, SDATA (Vx_resource_class));
+
+ strcat (class_key, ".");
+ strcat (class_key, SDATA (class));
+
+ if (!NILP (component))
+ {
+ strcat (class_key, ".");
+ strcat (class_key, SDATA (subclass));
+
+ strcat (name_key, ".");
+ strcat (name_key, SDATA (component));
+ }
+
+ strcat (name_key, ".");
+ strcat (name_key, SDATA (attribute));
+
+ value = x_get_string_resource (rdb, name_key, class_key);
+
+ if (value != (char *) 0)
+ return build_string (value);
+ else
+ return Qnil;
+}
+
+
+DEFUN ("x-get-resource", Fx_get_resource, Sx_get_resource, 2, 4, 0,
+ doc: /* Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.
+This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
+class, where INSTANCE is the name under which Emacs was invoked, or
+the name specified by the `-name' or `-rn' command-line arguments.
+
+The optional arguments COMPONENT and SUBCLASS add to the key and the
+class, respectively. You must specify both of them or neither.
+If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
+and the class is `Emacs.CLASS.SUBCLASS'. */)
+ (attribute, class, component, subclass)
+ Lisp_Object attribute, class, component, subclass;
+{
+#ifdef HAVE_X_WINDOWS
+ check_x ();
+#endif
+
+ return xrdb_get_resource (check_x_display_info (Qnil)->xrdb,
+ attribute, class, component, subclass);
+}
+
+/* Get an X resource, like Fx_get_resource, but for display DPYINFO. */
+
+Lisp_Object
+display_x_get_resource (dpyinfo, attribute, class, component, subclass)
+ Display_Info *dpyinfo;
+ Lisp_Object attribute, class, component, subclass;
+{
+ return xrdb_get_resource (dpyinfo->xrdb,
+ attribute, class, component, subclass);
+}
+
+/* Used when C code wants a resource value. */
+
+char *
+x_get_resource_string (attribute, class)
+ char *attribute, *class;
+{
+ char *name_key;
+ char *class_key;
+ struct frame *sf = SELECTED_FRAME ();
+
+ /* Allocate space for the components, the dots which separate them,
+ and the final '\0'. */
+ name_key = (char *) alloca (SBYTES (Vinvocation_name)
+ + strlen (attribute) + 2);
+ class_key = (char *) alloca ((sizeof (EMACS_CLASS) - 1)
+ + strlen (class) + 2);
+
+ sprintf (name_key, "%s.%s", SDATA (Vinvocation_name), attribute);
+ sprintf (class_key, "%s.%s", EMACS_CLASS, class);
+
+ return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf)->xrdb,
+ name_key, class_key);
+}
+
+
+/* Return the value of parameter PARAM.
+
+ First search ALIST, then Vdefault_frame_alist, then the X defaults
+ database, using ATTRIBUTE as the attribute name and CLASS as its class.
+
+ Convert the resource to the type specified by desired_type.
+
+ If no default is specified, return Qunbound. If you call
+ x_get_arg, make sure you deal with Qunbound in a reasonable way,
+ and don't let it get stored in any Lisp-visible variables! */
+
+Lisp_Object
+x_get_arg (dpyinfo, alist, param, attribute, class, type)
+ Display_Info *dpyinfo;
+ Lisp_Object alist, param;
+ char *attribute;
+ char *class;
+ enum resource_types type;
+{
+ register Lisp_Object tem;
+
+ tem = Fassq (param, alist);
+ if (EQ (tem, Qnil))
+ tem = Fassq (param, Vdefault_frame_alist);
+ if (EQ (tem, Qnil))
+ {
+ if (attribute)
+ {
+ tem = display_x_get_resource (dpyinfo,
+ build_string (attribute),
+ build_string (class),
+ Qnil, Qnil);
+
+ if (NILP (tem))
+ return Qunbound;
+
+ switch (type)
+ {
+ case RES_TYPE_NUMBER:
+ return make_number (atoi (SDATA (tem)));
+
+ case RES_TYPE_FLOAT:
+ return make_float (atof (SDATA (tem)));
+
+ case RES_TYPE_BOOLEAN:
+ tem = Fdowncase (tem);
+ if (!strcmp (SDATA (tem), "on")
+ || !strcmp (SDATA (tem), "true"))
+ return Qt;
+ else
+ return Qnil;
+
+ case RES_TYPE_STRING:
+ return tem;
+
+ case RES_TYPE_SYMBOL:
+ /* As a special case, we map the values `true' and `on'
+ to Qt, and `false' and `off' to Qnil. */
+ {
+ Lisp_Object lower;
+ lower = Fdowncase (tem);
+ if (!strcmp (SDATA (lower), "on")
+ || !strcmp (SDATA (lower), "true"))
+ return Qt;
+ else if (!strcmp (SDATA (lower), "off")
+ || !strcmp (SDATA (lower), "false"))
+ return Qnil;
+ else
+ return Fintern (tem, Qnil);
+ }
+
+ default:
+ abort ();
+ }
+ }
+ else
+ return Qunbound;
+ }
+ return Fcdr (tem);
+}
+
+Lisp_Object
+x_frame_get_arg (f, alist, param, attribute, class, type)
+ struct frame *f;
+ Lisp_Object alist, param;
+ char *attribute;
+ char *class;
+ enum resource_types type;
+{
+ return x_get_arg (FRAME_X_DISPLAY_INFO (f),
+ alist, param, attribute, class, type);
+}
+
+/* Like x_frame_get_arg, but also record the value in f->param_alist. */
+
+Lisp_Object
+x_frame_get_and_record_arg (f, alist, param, attribute, class, type)
+ struct frame *f;
+ Lisp_Object alist, param;
+ char *attribute;
+ char *class;
+ enum resource_types type;
+{
+ Lisp_Object value;
+
+ value = x_get_arg (FRAME_X_DISPLAY_INFO (f), alist, param,
+ attribute, class, type);
+ if (! NILP (value))
+ store_frame_param (f, param, value);
+
+ return value;
+}
+
+
+/* Record in frame F the specified or default value according to ALIST
+ of the parameter named PROP (a Lisp symbol).
+ If no value is specified for PROP, look for an X default for XPROP
+ on the frame named NAME.
+ If that is not found either, use the value DEFLT. */
+
+Lisp_Object
+x_default_parameter (f, alist, prop, deflt, xprop, xclass, type)
+ struct frame *f;
+ Lisp_Object alist;
+ Lisp_Object prop;
+ Lisp_Object deflt;
+ char *xprop;
+ char *xclass;
+ enum resource_types type;
+{
+ Lisp_Object tem;
+
+ tem = x_frame_get_arg (f, alist, prop, xprop, xclass, type);
+ if (EQ (tem, Qunbound))
+ tem = deflt;
+ x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
+ return tem;
+}
+
+
+
+\f
+DEFUN ("x-parse-geometry", Fx_parse_geometry, Sx_parse_geometry, 1, 1, 0,
+ doc: /* Parse an X-style geometry string STRING.
+Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
+The properties returned may include `top', `left', `height', and `width'.
+The value of `left' or `top' may be an integer,
+or a list (+ N) meaning N pixels relative to top/left corner,
+or a list (- N) meaning -N pixels relative to bottom/right corner. */)
+ (string)
+ Lisp_Object string;
+{
+ int geometry, x, y;
+ unsigned int width, height;
+ Lisp_Object result;
+
+ CHECK_STRING (string);
+
+ geometry = XParseGeometry ((char *) SDATA (string),
+ &x, &y, &width, &height);
+
+#if 0
+ if (!!(geometry & XValue) != !!(geometry & YValue))
+ error ("Must specify both x and y position, or neither");
+#endif
+
+ result = Qnil;
+ if (geometry & XValue)
+ {
+ Lisp_Object element;
+
+ if (x >= 0 && (geometry & XNegative))
+ element = Fcons (Qleft, Fcons (Qminus, Fcons (make_number (-x), Qnil)));
+ else if (x < 0 && ! (geometry & XNegative))
+ element = Fcons (Qleft, Fcons (Qplus, Fcons (make_number (x), Qnil)));
+ else
+ element = Fcons (Qleft, make_number (x));
+ result = Fcons (element, result);
+ }
+
+ if (geometry & YValue)
+ {
+ Lisp_Object element;
+
+ if (y >= 0 && (geometry & YNegative))
+ element = Fcons (Qtop, Fcons (Qminus, Fcons (make_number (-y), Qnil)));
+ else if (y < 0 && ! (geometry & YNegative))
+ element = Fcons (Qtop, Fcons (Qplus, Fcons (make_number (y), Qnil)));
+ else
+ element = Fcons (Qtop, make_number (y));
+ result = Fcons (element, result);
+ }
+
+ if (geometry & WidthValue)
+ result = Fcons (Fcons (Qwidth, make_number (width)), result);
+ if (geometry & HeightValue)
+ result = Fcons (Fcons (Qheight, make_number (height)), result);
+
+ return result;
+}
+
+/* Calculate the desired size and position of frame F.
+ Return the flags saying which aspects were specified.
+
+ Also set the win_gravity and size_hint_flags of F.
+
+ Adjust height for toolbar if TOOLBAR_P is 1.
+
+ This function does not make the coordinates positive. */
+
+#define DEFAULT_ROWS 40
+#define DEFAULT_COLS 80
+
+int
+x_figure_window_size (f, parms, toolbar_p)
+ struct frame *f;
+ Lisp_Object parms;
+ int toolbar_p;
+{
+ register Lisp_Object tem0, tem1, tem2;
+ long window_prompting = 0;
+ Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
+ /* Default values if we fall through.
+ Actually, if that happens we should get
+ window manager prompting. */
+ SET_FRAME_COLS (f, DEFAULT_COLS);
+ FRAME_LINES (f) = DEFAULT_ROWS;
+ /* Window managers expect that if program-specified
+ positions are not (0,0), they're intentional, not defaults. */
+ f->top_pos = 0;
+ f->left_pos = 0;
+
+ /* Ensure that old new_text_cols and new_text_lines will not override the
+ values set here. */
+ /* ++KFS: This was specific to W32, but seems ok for all platforms */
+ f->new_text_cols = f->new_text_lines = 0;
+
+ tem0 = x_get_arg (dpyinfo, parms, Qheight, 0, 0, RES_TYPE_NUMBER);
+ tem1 = x_get_arg (dpyinfo, parms, Qwidth, 0, 0, RES_TYPE_NUMBER);
+ tem2 = x_get_arg (dpyinfo, parms, Quser_size, 0, 0, RES_TYPE_NUMBER);
+ if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
+ {
+ if (!EQ (tem0, Qunbound))
+ {
+ CHECK_NUMBER (tem0);
+ FRAME_LINES (f) = XINT (tem0);
+ }
+ if (!EQ (tem1, Qunbound))
+ {
+ CHECK_NUMBER (tem1);
+ SET_FRAME_COLS (f, XINT (tem1));
+ }
+ if (!NILP (tem2) && !EQ (tem2, Qunbound))
+ window_prompting |= USSize;
+ else
+ window_prompting |= PSize;
+ }
+
+ f->scroll_bar_actual_width
+ = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
+
+ /* This used to be done _before_ calling x_figure_window_size, but
+ since the height is reset here, this was really a no-op. I
+ assume that moving it here does what Gerd intended (although he
+ no longer can remember what that was... ++KFS, 2003-03-25. */
+
+ /* Add the tool-bar height to the initial frame height so that the
+ user gets a text display area of the size he specified with -g or
+ via .Xdefaults. Later changes of the tool-bar height don't
+ change the frame size. This is done so that users can create
+ tall Emacs frames without having to guess how tall the tool-bar
+ will get. */
+ if (toolbar_p && FRAME_TOOL_BAR_LINES (f))
+ {
+ int margin, relief, bar_height;
+
+ relief = (tool_bar_button_relief >= 0
+ ? tool_bar_button_relief
+ : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
+
+ if (INTEGERP (Vtool_bar_button_margin)
+ && XINT (Vtool_bar_button_margin) > 0)
+ margin = XFASTINT (Vtool_bar_button_margin);
+ else if (CONSP (Vtool_bar_button_margin)
+ && INTEGERP (XCDR (Vtool_bar_button_margin))
+ && XINT (XCDR (Vtool_bar_button_margin)) > 0)
+ margin = XFASTINT (XCDR (Vtool_bar_button_margin));
+ else
+ margin = 0;
+
+ bar_height = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
+ FRAME_LINES (f) += (bar_height + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
+ }
+
+ compute_fringe_widths (f, 0);
+
+ FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, FRAME_COLS (f));
+ FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES (f));
+
+ tem0 = x_get_arg (dpyinfo, parms, Qtop, 0, 0, RES_TYPE_NUMBER);
+ tem1 = x_get_arg (dpyinfo, parms, Qleft, 0, 0, RES_TYPE_NUMBER);
+ tem2 = x_get_arg (dpyinfo, parms, Quser_position, 0, 0, RES_TYPE_NUMBER);
+ if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
+ {
+ if (EQ (tem0, Qminus))
+ {
+ f->top_pos = 0;
+ window_prompting |= YNegative;
+ }
+ else if (CONSP (tem0) && EQ (XCAR (tem0), Qminus)
+ && CONSP (XCDR (tem0))
+ && INTEGERP (XCAR (XCDR (tem0))))
+ {
+ f->top_pos = - XINT (XCAR (XCDR (tem0)));
+ window_prompting |= YNegative;
+ }
+ else if (CONSP (tem0) && EQ (XCAR (tem0), Qplus)
+ && CONSP (XCDR (tem0))
+ && INTEGERP (XCAR (XCDR (tem0))))
+ {
+ f->top_pos = XINT (XCAR (XCDR (tem0)));
+ }
+ else if (EQ (tem0, Qunbound))
+ f->top_pos = 0;
+ else
+ {
+ CHECK_NUMBER (tem0);
+ f->top_pos = XINT (tem0);
+ if (f->top_pos < 0)
+ window_prompting |= YNegative;
+ }
+
+ if (EQ (tem1, Qminus))
+ {
+ f->left_pos = 0;
+ window_prompting |= XNegative;
+ }
+ else if (CONSP (tem1) && EQ (XCAR (tem1), Qminus)
+ && CONSP (XCDR (tem1))
+ && INTEGERP (XCAR (XCDR (tem1))))
+ {
+ f->left_pos = - XINT (XCAR (XCDR (tem1)));
+ window_prompting |= XNegative;
+ }
+ else if (CONSP (tem1) && EQ (XCAR (tem1), Qplus)
+ && CONSP (XCDR (tem1))
+ && INTEGERP (XCAR (XCDR (tem1))))
+ {
+ f->left_pos = XINT (XCAR (XCDR (tem1)));
+ }
+ else if (EQ (tem1, Qunbound))
+ f->left_pos = 0;
+ else
+ {
+ CHECK_NUMBER (tem1);
+ f->left_pos = XINT (tem1);
+ if (f->left_pos < 0)
+ window_prompting |= XNegative;
+ }
+
+ if (!NILP (tem2) && ! EQ (tem2, Qunbound))
+ window_prompting |= USPosition;
+ else
+ window_prompting |= PPosition;
+ }
+
+ if (f->want_fullscreen != FULLSCREEN_NONE)
+ {
+ int left, top;
+ int width, height;
+
+ /* It takes both for some WM:s to place it where we want */
+ window_prompting = USPosition | PPosition;
+ x_fullscreen_adjust (f, &width, &height, &top, &left);
+ FRAME_COLS (f) = width;
+ FRAME_LINES (f) = height;
+ FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width);
+ FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
+ f->left_pos = left;
+ f->top_pos = top;
+ }
+
+ if (window_prompting & XNegative)
+ {
+ if (window_prompting & YNegative)
+ f->win_gravity = SouthEastGravity;
+ else
+ f->win_gravity = NorthEastGravity;
+ }
+ else
+ {
+ if (window_prompting & YNegative)
+ f->win_gravity = SouthWestGravity;
+ else
+ f->win_gravity = NorthWestGravity;
+ }
+
+ f->size_hint_flags = window_prompting;
+
+ return window_prompting;
+}
+
+
+
+#endif /* HAVE_WINDOW_SYSTEM */
+
+
+\f
+/***********************************************************************
+ Initialization
+ ***********************************************************************/
+
+void
+syms_of_frame ()
+{
+ Qframep = intern ("framep");
+ staticpro (&Qframep);
+ Qframe_live_p = intern ("frame-live-p");
+ staticpro (&Qframe_live_p);
+ Qheight = intern ("height");
+ staticpro (&Qheight);
+ Qicon = intern ("icon");
+ staticpro (&Qicon);
+ Qminibuffer = intern ("minibuffer");
+ staticpro (&Qminibuffer);
+ Qmodeline = intern ("modeline");
+ staticpro (&Qmodeline);
+ Qonly = intern ("only");
+ staticpro (&Qonly);
+ Qwidth = intern ("width");
+ staticpro (&Qwidth);
+ Qgeometry = intern ("geometry");
+ staticpro (&Qgeometry);
+ Qicon_left = intern ("icon-left");
+ staticpro (&Qicon_left);
+ Qicon_top = intern ("icon-top");
+ staticpro (&Qicon_top);
+ Qleft = intern ("left");
+ staticpro (&Qleft);
+ Qright = intern ("right");
+ staticpro (&Qright);
+ Quser_position = intern ("user-position");
+ staticpro (&Quser_position);
+ Quser_size = intern ("user-size");
+ staticpro (&Quser_size);
+ Qwindow_id = intern ("window-id");
+ staticpro (&Qwindow_id);
+#ifdef HAVE_X_WINDOWS
+ Qouter_window_id = intern ("outer-window-id");
+ staticpro (&Qouter_window_id);
+#endif
+ Qparent_id = intern ("parent-id");
+ staticpro (&Qparent_id);
+ Qx = intern ("x");
+ staticpro (&Qx);
+ Qw32 = intern ("w32");
+ staticpro (&Qw32);
+ Qpc = intern ("pc");
+ staticpro (&Qpc);
+ Qmac = intern ("mac");
+ staticpro (&Qmac);
+ Qvisible = intern ("visible");
+ staticpro (&Qvisible);
+ Qbuffer_predicate = intern ("buffer-predicate");
+ staticpro (&Qbuffer_predicate);
+ Qbuffer_list = intern ("buffer-list");
+ staticpro (&Qbuffer_list);
+ Qdisplay_type = intern ("display-type");
+ staticpro (&Qdisplay_type);
+ Qbackground_mode = intern ("background-mode");
+ staticpro (&Qbackground_mode);
+ Qtty_color_mode = intern ("tty-color-mode");
+ staticpro (&Qtty_color_mode);
+ Qtty = intern ("tty");
+ staticpro (&Qtty);
+ Qtty_type = intern ("tty-type");
+ staticpro (&Qtty_type);
+
+ Qface_set_after_frame_default = intern ("face-set-after-frame-default");
+ staticpro (&Qface_set_after_frame_default);
+
+ Qfullwidth = intern ("fullwidth");
+ staticpro (&Qfullwidth);
+ Qfullheight = intern ("fullheight");
+ staticpro (&Qfullheight);
+ Qfullboth = intern ("fullboth");
+ staticpro (&Qfullboth);
+ Qx_resource_name = intern ("x-resource-name");
+ staticpro (&Qx_resource_name);
+
+ Qx_frame_parameter = intern ("x-frame-parameter");
+ staticpro (&Qx_frame_parameter);
+
+ {
+ int i;
+
+ for (i = 0; i < sizeof (frame_parms) / sizeof (frame_parms[0]); i++)
+ {
+ Lisp_Object v = intern (frame_parms[i].name);
+ if (frame_parms[i].variable)
+ {
+ *frame_parms[i].variable = v;
+ staticpro (frame_parms[i].variable);
+ }
+ Fput (v, Qx_frame_parameter, make_number (i));
+ }
+ }
+
+#ifdef HAVE_WINDOW_SYSTEM
+ DEFVAR_LISP ("x-resource-name", &Vx_resource_name,
+ doc: /* The name Emacs uses to look up X resources.
+`x-get-resource' uses this as the first component of the instance name
+when requesting resource values.
+Emacs initially sets `x-resource-name' to the name under which Emacs
+was invoked, or to the value specified with the `-name' or `-rn'
+switches, if present.
+
+It may be useful to bind this variable locally around a call
+to `x-get-resource'. See also the variable `x-resource-class'. */);
+ Vx_resource_name = Qnil;
+
+ DEFVAR_LISP ("x-resource-class", &Vx_resource_class,
+ doc: /* The class Emacs uses to look up X resources.
+`x-get-resource' uses this as the first component of the instance class
+when requesting resource values.
+
+Emacs initially sets `x-resource-class' to "Emacs".
+
+Setting this variable permanently is not a reasonable thing to do,
+but binding this variable locally around a call to `x-get-resource'
+is a reasonable practice. See also the variable `x-resource-name'. */);
+ Vx_resource_class = build_string (EMACS_CLASS);
+#endif
+
+ DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
+ doc: /* Alist of default values for frame creation.
+These may be set in your init file, like this:
+ (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1))
+These override values given in window system configuration data,
+ including X Windows' defaults database.
+For values specific to the first Emacs frame, see `initial-frame-alist'.
+For values specific to the separate minibuffer frame, see
+ `minibuffer-frame-alist'.
+The `menu-bar-lines' element of the list controls whether new frames
+ have menu bars; `menu-bar-mode' works by altering this element.
+Setting this variable does not affect existing frames, only new ones. */);
+ Vdefault_frame_alist = Qnil;
+
+ 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(HAVE_CARBON)
+ /* MS-Windows has scroll bars on the right by default. */
+ Vdefault_frame_scroll_bars = Qright;
+#else
+ Vdefault_frame_scroll_bars = Qleft;
+#endif
+#else
+ Vdefault_frame_scroll_bars = Qnil;
+#endif
+
+ Qinhibit_default_face_x_resources
+ = intern ("inhibit-default-face-x-resources");
+ staticpro (&Qinhibit_default_face_x_resources);
+
+ DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified,
+ doc: /* Non-nil if all of emacs is iconified and frame updates are not needed. */);
+ Vemacs_iconified = Qnil;
+
+ DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function,
+ doc: /* If non-nil, function to transform normal value of `mouse-position'.
+`mouse-position' calls this function, passing its usual return value as
+argument, and returns whatever this function returns.
+This abnormal hook exists for the benefit of packages like `xt-mouse.el'
+which need to do mouse handling at the Lisp level. */);
+ Vmouse_position_function = Qnil;
+
+ DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight,
+ doc: /* If non-nil, clickable text is highlighted when mouse is over it.
+If the value is an integer, highlighting is only shown after moving the
+mouse, while keyboard input turns off the highlight even when the mouse
+is over the clickable text. However, the mouse shape still indicates
+when the mouse is over clickable text. */);
+ Vmouse_highlight = Qt;
+
+ DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions,
+ doc: /* Functions to be run before deleting a frame.
+The functions are run with one arg, the frame to be deleted.
+See `delete-frame'. */);
+ Vdelete_frame_functions = Qnil;
+
+ DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame,
+ doc: /* Minibufferless frames use this frame's minibuffer.
+
+Emacs cannot create minibufferless frames unless this is set to an
+appropriate surrogate.
+
+Emacs consults this variable only when creating minibufferless
+frames; once the frame is created, it sticks with its assigned
+minibuffer, no matter what this variable is set to. This means that
+this variable doesn't necessarily say anything meaningful about the
+current set of frames, or where the minibuffer is currently being
+displayed.
+
+This variable is local to the current terminal and cannot be buffer-local. */);
+
+ staticpro (&Vframe_list);
+
+ defsubr (&Sactive_minibuffer_window);
+ defsubr (&Sframep);
+ defsubr (&Sframe_live_p);
+ defsubr (&Smake_terminal_frame);
+ defsubr (&Shandle_switch_frame);
+ defsubr (&Signore_event);
+ defsubr (&Sselect_frame);
+ defsubr (&Sselected_frame);
+ defsubr (&Swindow_frame);
+ defsubr (&Sframe_root_window);
+ defsubr (&Sframe_first_window);
+ defsubr (&Sframe_selected_window);
+ defsubr (&Sset_frame_selected_window);
+ defsubr (&Sframe_list);
+ defsubr (&Snext_frame);
+ defsubr (&Sprevious_frame);
+ defsubr (&Sdelete_frame);
+ defsubr (&Smouse_position);
+ defsubr (&Smouse_pixel_position);
+ defsubr (&Sset_mouse_position);
+ defsubr (&Sset_mouse_pixel_position);
+#if 0
+ defsubr (&Sframe_configuration);
+ defsubr (&Srestore_frame_configuration);
+#endif
+ defsubr (&Smake_frame_visible);
+ defsubr (&Smake_frame_invisible);
+ defsubr (&Siconify_frame);
+ defsubr (&Sframe_visible_p);
+ defsubr (&Svisible_frame_list);
+ defsubr (&Sraise_frame);
+ defsubr (&Slower_frame);
+ defsubr (&Sredirect_frame_focus);
+ defsubr (&Sframe_focus);
+ defsubr (&Sframe_parameters);
+ defsubr (&Sframe_parameter);
+ defsubr (&Smodify_frame_parameters);
+ defsubr (&Sframe_char_height);
+ defsubr (&Sframe_char_width);
+ defsubr (&Sframe_pixel_height);
+ defsubr (&Sframe_pixel_width);
+ defsubr (&Sset_frame_height);
+ defsubr (&Sset_frame_width);
+ defsubr (&Sset_frame_size);
+ defsubr (&Sset_frame_position);
+
+#ifdef HAVE_WINDOW_SYSTEM
+ defsubr (&Sx_get_resource);
+ defsubr (&Sx_parse_geometry);
+#endif
+
+}
+
+/* arch-tag: 7dbf2c69-9aad-45f8-8296-db893d6dd039
+ (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff