Lisp_Object Qframep, Qframe_live_p;
Lisp_Object Qicon, Qmodeline;
-Lisp_Object Qonly;
+Lisp_Object Qonly, Qnone;
Lisp_Object Qx, Qw32, Qmac, Qpc, Qns;
Lisp_Object Qvisible;
Lisp_Object Qdisplay_type;
struct window *w = XWINDOW (window);
w->last_modified = 0;
- XSETFASTINT (WVAR (w, top_line), XFASTINT (WVAR (w, top_line)) + n);
- XSETFASTINT (WVAR (w, total_lines), XFASTINT (WVAR (w, total_lines)) - n);
+ WSET (w, top_line, make_number (XFASTINT (w->top_line) + n));
+ WSET (w, total_lines, make_number (XFASTINT (w->total_lines) - n));
/* Handle just the top child in a vertical split. */
- if (!NILP (WVAR (w, vchild)))
- set_menu_bar_lines_1 (WVAR (w, vchild), n);
+ if (!NILP (w->vchild))
+ set_menu_bar_lines_1 (w->vchild, n);
/* Adjust all children in a horizontal split. */
- for (window = WVAR (w, hchild); !NILP (window); window = WVAR (w, next))
+ for (window = w->hchild; !NILP (window); window = w->next)
{
w = XWINDOW (window);
set_menu_bar_lines_1 (window, n);
windows_or_buffers_changed++;
FRAME_WINDOW_SIZES_CHANGED (f) = 1;
FRAME_MENU_BAR_LINES (f) = nlines;
- set_menu_bar_lines_1 (FVAR (f, root_window), nlines - olines);
+ set_menu_bar_lines_1 (f->root_window, nlines - olines);
adjust_glyphs (f);
}
}
/* Initialize Lisp data. Note that allocate_frame initializes all
Lisp data to nil, so do it only for slots which should not be nil. */
- FVAR (f, tool_bar_position) = Qtop;
+ FSET (f, tool_bar_position, Qtop);
/* Initialize non-Lisp data. Note that allocate_frame zeroes out all
non-Lisp data, so do it only for slots which should not be zero.
if (mini_p)
{
mini_window = make_window ();
- WVAR (XWINDOW (root_window), next) = mini_window;
- WVAR (XWINDOW (mini_window), prev) = root_window;
+ WSET (XWINDOW (root_window), next, mini_window);
+ WSET (XWINDOW (mini_window), prev, root_window);
XWINDOW (mini_window)->mini = 1;
- WVAR (XWINDOW (mini_window), frame) = frame;
- FVAR (f, minibuffer_window) = mini_window;
+ WSET (XWINDOW (mini_window), frame, frame);
+ FSET (f, minibuffer_window, mini_window);
}
else
{
mini_window = Qnil;
- WVAR (XWINDOW (root_window), next) = Qnil;
- FVAR (f, minibuffer_window) = Qnil;
+ WSET (XWINDOW (root_window), next, Qnil);
+ FSET (f, minibuffer_window, Qnil);
}
- WVAR (XWINDOW (root_window), frame) = frame;
+ WSET (XWINDOW (root_window), frame, frame);
/* 10 is arbitrary,
just so that there is "something there."
SET_FRAME_COLS (f, 10);
FRAME_LINES (f) = 10;
- XSETFASTINT (WVAR (XWINDOW (root_window), total_cols), 10);
- XSETFASTINT (WVAR (XWINDOW (root_window), total_lines), (mini_p ? 9 : 10));
+ WSET (XWINDOW (root_window), total_cols, make_number (10));
+ WSET (XWINDOW (root_window), total_lines, make_number (mini_p ? 9 : 10));
if (mini_p)
{
- XSETFASTINT (WVAR (XWINDOW (mini_window), total_cols), 10);
- XSETFASTINT (WVAR (XWINDOW (mini_window), top_line), 9);
- XSETFASTINT (WVAR (XWINDOW (mini_window), total_lines), 1);
+ WSET (XWINDOW (mini_window), total_cols, make_number (10));
+ WSET (XWINDOW (mini_window), top_line, make_number (9));
+ WSET (XWINDOW (mini_window), total_lines, make_number (1));
}
/* Choose a buffer for the frame's root window. */
{
Lisp_Object buf;
- WVAR (XWINDOW (root_window), buffer) = Qt;
+ WSET (XWINDOW (root_window), buffer, Qt);
buf = Fcurrent_buffer ();
/* If buf is a 'hidden' buffer (i.e. one whose name starts with
a space), try to find another one. */
etc. Running Lisp functions at this point surely ends in a
SEGV. */
set_window_buffer (root_window, buf, 0, 0);
- FVAR (f, buffer_list) = Fcons (buf, Qnil);
+ FSET (f, buffer_list, Fcons (buf, Qnil));
}
if (mini_p)
{
- WVAR (XWINDOW (mini_window), buffer) = Qt;
+ WSET (XWINDOW (mini_window), buffer, Qt);
set_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
0, 0);
}
- FVAR (f, root_window) = root_window;
- FVAR (f, selected_window) = root_window;
+ FSET (f, root_window, root_window);
+ FSET (f, selected_window, root_window);
/* Make sure this window seems more recently used than
a newly-created, never-selected window. */
- XWINDOW (FVAR (f, selected_window))->use_time = ++window_select_count;
+ XWINDOW (f->selected_window)->use_time = ++window_select_count;
return f;
}
CHECK_LIVE_WINDOW (mini_window);
if (!NILP (mini_window)
- && FRAME_KBOARD (XFRAME (WVAR (XWINDOW (mini_window), frame))) != kb)
+ && FRAME_KBOARD (XFRAME (XWINDOW (mini_window)->frame)) != kb)
error ("Frame and minibuffer must be on the same terminal");
/* Make a frame containing just a root window. */
UNGCPRO;
}
- mini_window = FVAR (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)),
- minibuffer_window);
+ mini_window
+ = XFRAME (KVAR (kb, Vdefault_minibuffer_frame))->minibuffer_window;
}
- FVAR (f, minibuffer_window) = mini_window;
+ FSET (f, minibuffer_window, mini_window);
/* Make the chosen minibuffer window display the proper minibuffer,
unless it is already showing a minibuffer. */
- if (NILP (Fmemq (WVAR (XWINDOW (mini_window), buffer), Vminibuffer_list)))
+ if (NILP (Fmemq (XWINDOW (mini_window)->buffer, Vminibuffer_list)))
Fset_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
Avoid infinite looping on the window chain by marking next pointer
as nil. */
- mini_window = FVAR (f, minibuffer_window) = FVAR (f, root_window);
+ mini_window = FSET (f, minibuffer_window, f->root_window);
XWINDOW (mini_window)->mini = 1;
- WVAR (XWINDOW (mini_window), next) = Qnil;
- WVAR (XWINDOW (mini_window), prev) = Qnil;
- WVAR (XWINDOW (mini_window), frame) = frame;
+ WSET (XWINDOW (mini_window), next, Qnil);
+ WSET (XWINDOW (mini_window), prev, Qnil);
+ WSET (XWINDOW (mini_window), frame, frame);
/* Put the proper buffer in that window. */
Vframe_list = Fcons (frame, Vframe_list);
tty_frame_count = 1;
- FVAR (f, name) = build_pure_c_string ("F1");
+ FSET (f, name, build_pure_c_string ("F1"));
f->visible = 1;
f->async_visible = 1;
XSETFRAME (frame, f);
Vframe_list = Fcons (frame, Vframe_list);
- FVAR (f, name) = make_formatted_string (name, "F%"pMd, ++tty_frame_count);
+ FSET (f, name, make_formatted_string (name, "F%"pMd, ++tty_frame_count));
f->visible = 1; /* FRAME_SET_VISIBLE wd set frame_garbaged. */
f->async_visible = 1; /* Don't let visible be cleared later. */
result = Fassq (parameter, supplied_parms);
if (NILP (result))
- result = Fassq (parameter, FVAR (XFRAME (selected_frame), param_alist));
+ result = Fassq (parameter, XFRAME (selected_frame)->param_alist);
if (NILP (result) && current_value != NULL)
result = build_string (current_value);
if (!NILP (result) && !STRINGP (result))
/* Make the frame face alist be frame-specific, so that each
frame could change its face definitions independently. */
- FVAR (f, face_alist) = Fcopy_alist (FVAR (sf, face_alist));
+ FSET (f, face_alist, Fcopy_alist (sf->face_alist));
/* Simple Fcopy_alist isn't enough, because we need the contents of
the vectors which are the CDRs of associations in face_alist to
be copied as well. */
- for (tem = FVAR (f, face_alist); CONSP (tem); tem = XCDR (tem))
+ for (tem = f->face_alist; CONSP (tem); tem = XCDR (tem))
XSETCDR (XCAR (tem), Fcopy_sequence (XCDR (XCAR (tem))));
return frame;
}
if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
last_nonminibuf_frame = XFRAME (selected_frame);
- Fselect_window (FVAR (XFRAME (frame), selected_window), norecord);
+ Fselect_window (XFRAME (frame)->selected_window, norecord);
/* We want to make sure that the next event generates a frame-switch
event to the appropriate frame. This seems kludgy to me, but
}
/* Don't allow minibuf_window to remain on a deleted frame. */
- if (EQ (FVAR (f, minibuffer_window), minibuf_window))
+ if (EQ (f->minibuffer_window, minibuf_window))
{
- Fset_window_buffer (FVAR (sf, minibuffer_window),
- WVAR (XWINDOW (minibuf_window), buffer), Qnil);
- minibuf_window = FVAR (sf, minibuffer_window);
+ Fset_window_buffer (sf->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer, Qnil);
+ minibuf_window = sf->minibuffer_window;
/* If the dying minibuffer window was selected,
select the new one. */
}
/* Don't let echo_area_window to remain on a deleted frame. */
- if (EQ (FVAR (f, minibuffer_window), echo_area_window))
- echo_area_window = FVAR (sf, minibuffer_window);
+ if (EQ (f->minibuffer_window, echo_area_window))
+ echo_area_window = sf->minibuffer_window;
/* Clear any X selections for this frame. */
#ifdef HAVE_X_WINDOWS
/* Mark all the windows that used to be on FRAME as deleted, and then
remove the reference to them. */
- delete_all_child_windows (FVAR (f, root_window));
- FVAR (f, root_window) = Qnil;
+ delete_all_child_windows (f->root_window);
+ FSET (f, root_window, Qnil);
Vframe_list = Fdelq (frame, Vframe_list);
FRAME_SET_VISIBLE (f, 0);
garbage collection. The frame object itself may not be garbage
collected until much later, because recent_keys and other data
structures can still refer to it. */
- FVAR (f, menu_bar_vector) = Qnil;
+ FSET (f, menu_bar_vector, Qnil);
free_font_driver_list (f);
xfree (f->namebuf);
}
#endif
- make_frame_visible_1 (FVAR (XFRAME (frame), root_window));
+ make_frame_visible_1 (XFRAME (frame)->root_window);
/* Make menu bar update for the Buffers and Frames menus. */
windows_or_buffers_changed++;
{
struct window *w;
- for (;!NILP (window); window = WVAR (w, next))
+ for (;!NILP (window); window = w->next)
{
w = XWINDOW (window);
- if (!NILP (WVAR (w, buffer)))
- BVAR (XBUFFER (WVAR (w, buffer)), display_time) = Fcurrent_time ();
+ if (!NILP (w->buffer))
+ BSET (XBUFFER (w->buffer), display_time, Fcurrent_time ());
- if (!NILP (WVAR (w, vchild)))
- make_frame_visible_1 (WVAR (w, vchild));
- if (!NILP (WVAR (w, hchild)))
- make_frame_visible_1 (WVAR (w, hchild));
+ if (!NILP (w->vchild))
+ make_frame_visible_1 (w->vchild);
+ if (!NILP (w->hchild))
+ make_frame_visible_1 (w->hchild);
}
}
error ("Attempt to make invisible the sole visible or iconified frame");
/* Don't allow minibuf_window to remain on a deleted frame. */
- if (EQ (FVAR (XFRAME (frame), minibuffer_window), minibuf_window))
+ if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
{
struct frame *sf = XFRAME (selected_frame);
- Fset_window_buffer (FVAR (sf, minibuffer_window),
- WVAR (XWINDOW (minibuf_window), buffer), Qnil);
- minibuf_window = FVAR (sf, minibuffer_window);
+ Fset_window_buffer (sf->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer, Qnil);
+ minibuf_window = sf->minibuffer_window;
}
/* I think this should be done with a hook. */
#endif
/* Don't allow minibuf_window to remain on a deleted frame. */
- if (EQ (FVAR (XFRAME (frame), minibuffer_window), minibuf_window))
+ if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
{
struct frame *sf = XFRAME (selected_frame);
- Fset_window_buffer (FVAR (sf, minibuffer_window),
- WVAR (XWINDOW (minibuf_window), buffer), Qnil);
- minibuf_window = FVAR (sf, minibuffer_window);
+ Fset_window_buffer (sf->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer, Qnil);
+ minibuf_window = sf->minibuffer_window;
}
/* I think this should be done with a hook. */
f = XFRAME (frame);
- FVAR (f, focus_frame) = focus_frame;
+ FSET (f, focus_frame, focus_frame);
if (FRAME_TERMINAL (f)->frame_rehighlight_hook)
(*FRAME_TERMINAL (f)->frame_rehighlight_hook) (f);
{
register Lisp_Object tem;
- tem = Fassq (prop, FVAR (frame, param_alist));
+ tem = Fassq (prop, frame->param_alist);
if (EQ (tem, Qnil))
return tem;
return Fcdr (tem);
Lisp_Object
frame_buffer_predicate (Lisp_Object frame)
{
- return FVAR (XFRAME (frame), buffer_predicate);
+ return XFRAME (frame)->buffer_predicate;
}
/* Return the buffer-list of the selected frame. */
static Lisp_Object
frame_buffer_list (Lisp_Object frame)
{
- return FVAR (XFRAME (frame), buffer_list);
+ return XFRAME (frame)->buffer_list;
}
/* Discard BUFFER from the buffer-list and buried-buffer-list of each frame. */
FOR_EACH_FRAME (tail, frame)
{
- FVAR (XFRAME (frame), buffer_list)
- = Fdelq (buffer, FVAR (XFRAME (frame), buffer_list));
- FVAR (XFRAME (frame), buried_buffer_list)
- = Fdelq (buffer, FVAR (XFRAME (frame), buried_buffer_list));
+ FSET (XFRAME (frame), buffer_list,
+ Fdelq (buffer, XFRAME (frame)->buffer_list));
+ FSET (XFRAME (frame), buried_buffer_list,
+ Fdelq (buffer, XFRAME (frame)->buried_buffer_list));
}
}
/* Check for no change needed in this very common case
before we do any consing. */
- if (frame_name_fnn_p (SSDATA (FVAR (f, name)),
- SBYTES (FVAR (f, name))))
+ if (frame_name_fnn_p (SSDATA (f->name), SBYTES (f->name)))
return;
name = make_formatted_string (namebuf, "F%"pMd, ++tty_frame_count);
CHECK_STRING (name);
/* Don't change the name if it's already NAME. */
- if (! NILP (Fstring_equal (name, FVAR (f, name))))
+ if (! NILP (Fstring_equal (name, f->name)))
return;
/* Don't allow the user to set the frame name to F<num>, so it
error ("Frame names of the form F<num> are usurped by Emacs");
}
- FVAR (f, name) = name;
+ FSET (f, name, name);
update_mode_lines = 1;
}
for (; CONSP (val); val = XCDR (val))
if (!NILP (Fbuffer_live_p (XCAR (val))))
list = Fcons (XCAR (val), list);
- FVAR (f, buffer_list) = Fnreverse (list);
+ FSET (f, buffer_list, Fnreverse (list));
return;
}
if (EQ (prop, Qburied_buffer_list))
for (; CONSP (val); val = XCDR (val))
if (!NILP (Fbuffer_live_p (XCAR (val))))
list = Fcons (XCAR (val), list);
- FVAR (f, buried_buffer_list) = Fnreverse (list);
+ FSET (f, buried_buffer_list, Fnreverse (list));
return;
}
FRAME_TTY (f)->previous_frame = NULL;
/* Update the frame parameter alist. */
- old_alist_elt = Fassq (prop, FVAR (f, param_alist));
+ old_alist_elt = Fassq (prop, f->param_alist);
if (EQ (old_alist_elt, Qnil))
- FVAR (f, param_alist) = Fcons (Fcons (prop, val), FVAR (f, param_alist));
+ FSET (f, param_alist, Fcons (Fcons (prop, val), f->param_alist));
else
Fsetcdr (old_alist_elt, val);
in addition to the alist. */
if (EQ (prop, Qbuffer_predicate))
- FVAR (f, buffer_predicate) = val;
+ FSET (f, buffer_predicate, val);
if (! FRAME_WINDOW_P (f))
{
error ("Surrogate minibuffer windows must be minibuffer windows");
if ((FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
- && !EQ (val, FVAR (f, minibuffer_window)))
+ && !EQ (val, f->minibuffer_window))
error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
/* Install the chosen minibuffer window, with proper buffer. */
- FVAR (f, minibuffer_window) = val;
+ FSET (f, minibuffer_window, val);
}
}
if (!FRAME_LIVE_P (f))
return Qnil;
- alist = Fcopy_alist (FVAR (f, param_alist));
+ alist = Fcopy_alist (f->param_alist);
GCPRO1 (alist);
if (!FRAME_WINDOW_P (f))
: FRAME_W32_P (f) ? "w32term"
:"tty"));
}
- store_in_alist (&alist, Qname, FVAR (f, name));
+ 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, Qunsplittable, (FRAME_NO_SPLIT_P (f) ? Qt : Qnil));
store_in_alist (&alist, Qbuffer_list, frame_buffer_list (frame));
store_in_alist (&alist, Qburied_buffer_list,
- FVAR (XFRAME (frame), buried_buffer_list));
+ XFRAME (frame)->buried_buffer_list);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
{
/* Avoid consing in frequent cases. */
if (EQ (parameter, Qname))
- value = FVAR (f, name);
+ 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);
else if (EQ (parameter, Qbackground_color)
|| EQ (parameter, Qforeground_color))
{
- value = Fassq (parameter, FVAR (f, param_alist));
+ value = Fassq (parameter, f->param_alist);
if (CONSP (value))
{
value = XCDR (value);
}
else if (EQ (parameter, Qdisplay_type)
|| EQ (parameter, Qbackground_mode))
- value = Fcdr (Fassq (parameter, FVAR (f, param_alist)));
+ value = Fcdr (Fassq (parameter, f->param_alist));
else
/* FIXME: Avoid this code path at all (as well as code duplication)
by sharing more code with Fframe_parameters. */
if (! TYPE_RANGED_INTEGERP (int, icon_left))
{
icon_left_no_change = 1;
- icon_left = Fcdr (Fassq (Qicon_left, FVAR (f, param_alist)));
+ icon_left = Fcdr (Fassq (Qicon_left, f->param_alist));
if (NILP (icon_left))
XSETINT (icon_left, 0);
}
if (! TYPE_RANGED_INTEGERP (int, icon_top))
{
icon_top_no_change = 1;
- icon_top = Fcdr (Fassq (Qicon_top, FVAR (f, param_alist)));
+ icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
if (NILP (icon_top))
XSETINT (icon_top, 0);
}
store_in_alist (alistptr, Qouter_window_id,
make_formatted_string (buf, "%lu", w));
#endif
- store_in_alist (alistptr, Qicon_name, FVAR (f, icon_name));
+ store_in_alist (alistptr, Qicon_name, f->icon_name);
FRAME_SAMPLE_VISIBILITY (f);
store_in_alist (alistptr, Qvisibility,
(FRAME_VISIBLE_P (f) ? Qt
XSETFASTINT (tem, FRAME_X_OUTPUT (f)->parent_desc);
store_in_alist (alistptr, Qexplicit_name, (f->explicit_name ? Qt : Qnil));
store_in_alist (alistptr, Qparent_id, tem);
- store_in_alist (alistptr, Qtool_bar_position, FVAR (f, tool_bar_position));
+ store_in_alist (alistptr, Qtool_bar_position, f->tool_bar_position);
}
signal_error ("Invalid screen-gamma", new_value);
/* Apply the new gamma value to the frame background. */
- bgcolor = Fassq (Qbackground_color, FVAR (f, param_alist));
+ bgcolor = Fassq (Qbackground_color, f->param_alist);
if (CONSP (bgcolor) && (bgcolor = XCDR (bgcolor), STRINGP (bgcolor)))
{
Lisp_Object parm_index = Fget (Qbackground_color, Qx_frame_parameter);
{
Lisp_Object tem;
- tem = assq_no_quit (Qicon_type, FVAR (f, param_alist));
+ tem = assq_no_quit (Qicon_type, f->param_alist);
if (CONSP (tem))
return XCDR (tem);
else
DEFSYM (Qminibuffer, "minibuffer");
DEFSYM (Qmodeline, "modeline");
DEFSYM (Qonly, "only");
+ DEFSYM (Qnone, "none");
DEFSYM (Qwidth, "width");
DEFSYM (Qgeometry, "geometry");
DEFSYM (Qicon_left, "icon-left");
Vmake_pointer_invisible = Qt;
DEFVAR_LISP ("delete-frame-functions", Vdelete_frame_functions,
- doc: /* Functions to be run before deleting a frame.
+ doc: /* Functions run before deleting a frame.
The functions are run with one arg, the frame to be deleted.
See `delete-frame'.
HCoop / bpt / emacs.git / blobdiff