#include "systime.h"
#include <fcntl.h>
-#include <ctype.h>
#include <errno.h>
#include <setjmp.h>
#include <sys/stat.h>
static void
x_update_window_end (struct window *w, int cursor_on_p, int mouse_face_overwritten_p)
{
- Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (WVAR (w, frame)));
+ Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
if (!w->pseudo_window_p)
{
overhead is very small. */
if (windows_or_buffers_changed
&& desired_row->full_width_p
- && (f = XFRAME (WVAR (w, frame)),
+ && (f = XFRAME (w->frame),
width = FRAME_INTERNAL_BORDER_WIDTH (f),
width != 0)
&& (height = desired_row->visible_height,
static void
x_scroll_run (struct window *w, struct run *run)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (w->frame);
int x, y, width, height, from_y, to_y, bottom_y;
/* Get frame-relative bounding box of the text display area of W,
: dpyinfo->x_focus_frame);
if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
{
- FSET (dpyinfo->x_focus_frame, focus_frame, Qnil);
+ fset_focus_frame (dpyinfo->x_focus_frame, Qnil);
dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
}
}
scroll_bar_end_scroll, 0, 0);
w = XWINDOW (window_being_scrolled);
- if (!NILP (XSCROLL_BAR (WVAR (w, vertical_scroll_bar))->dragging))
+ if (!NILP (XSCROLL_BAR (w->vertical_scroll_bar)->dragging))
{
- XSCROLL_BAR (WVAR (w, vertical_scroll_bar))->dragging = Qnil;
+ XSCROLL_BAR (w->vertical_scroll_bar)->dragging = Qnil;
/* The thumb size is incorrect while dragging: fix it. */
set_vertical_scroll_bar (w);
}
XEvent event;
XClientMessageEvent *ev = (XClientMessageEvent *) &event;
struct window *w = XWINDOW (window);
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (w->frame);
ptrdiff_t i;
BLOCK_INPUT;
ievent->timestamp = CurrentTime;
#else
ievent->timestamp =
- XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (WVAR (w, frame))));
+ XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w->frame)));
#endif
ievent->part = ev->data.l[1];
ievent->code = ev->data.l[2];
static struct scroll_bar *
x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (w->frame);
struct scroll_bar *bar
= ALLOCATE_PSEUDOVECTOR (struct scroll_bar, x_window, PVEC_OTHER);
Lisp_Object barobj;
bar->next = FRAME_SCROLL_BARS (f);
bar->prev = Qnil;
XSETVECTOR (barobj, bar);
- FSET (f, scroll_bars, barobj);
+ fset_scroll_bars (f, barobj);
if (!NILP (bar->next))
XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
#endif
/* Dissociate this scroll bar from its window. */
- WVAR (XWINDOW (bar->window), vertical_scroll_bar) = Qnil;
+ wset_vertical_scroll_bar (XWINDOW (bar->window), Qnil);
UNBLOCK_INPUT;
}
static void
XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int position)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (w->frame);
+ Lisp_Object barobj;
struct scroll_bar *bar;
int top, height, left, sb_left, width, sb_width;
int window_y, window_height;
#endif
/* Does the scroll bar exist yet? */
- if (NILP (WVAR (w, vertical_scroll_bar)))
+ if (NILP (w->vertical_scroll_bar))
{
if (width > 0 && height > 0)
{
/* It may just need to be moved and resized. */
unsigned int mask = 0;
- bar = XSCROLL_BAR (WVAR (w, vertical_scroll_bar));
+ bar = XSCROLL_BAR (w->vertical_scroll_bar);
BLOCK_INPUT;
}
#endif /* not USE_TOOLKIT_SCROLL_BARS */
- XSETVECTOR (WVAR (w, vertical_scroll_bar), bar);
+ XSETVECTOR (barobj, bar);
+ wset_vertical_scroll_bar (w, barobj);
}
{
Lisp_Object bar;
bar = FRAME_SCROLL_BARS (frame);
- FSET (frame, scroll_bars, XSCROLL_BAR (bar)->next);
+ fset_scroll_bars (frame, XSCROLL_BAR (bar)->next);
XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
XSCROLL_BAR (bar)->prev = Qnil;
if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
- FSET (frame, condemned_scroll_bars, bar);
+ fset_condemned_scroll_bars (frame, bar);
}
}
Lisp_Object barobj;
/* We can't redeem this window's scroll bar if it doesn't have one. */
- if (NILP (WVAR (window, vertical_scroll_bar)))
+ if (NILP (window->vertical_scroll_bar))
abort ();
- bar = XSCROLL_BAR (WVAR (window, vertical_scroll_bar));
+ bar = XSCROLL_BAR (window->vertical_scroll_bar);
/* Unlink it from the condemned list. */
f = XFRAME (WINDOW_FRAME (window));
{
/* If the prev pointer is nil, it must be the first in one of
the lists. */
- if (EQ (FRAME_SCROLL_BARS (f), WVAR (window, vertical_scroll_bar)))
+ if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
/* It's not condemned. Everything's fine. */
return;
else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
- WVAR (window, vertical_scroll_bar)))
- FSET (f, condemned_scroll_bars, bar->next);
+ window->vertical_scroll_bar))
+ fset_condemned_scroll_bars (f, bar->next);
else
/* If its prev pointer is nil, it must be at the front of
one or the other! */
bar->next = FRAME_SCROLL_BARS (f);
bar->prev = Qnil;
XSETVECTOR (barobj, bar);
- FSET (f, scroll_bars, barobj);
+ fset_scroll_bars (f, barobj);
if (! NILP (bar->next))
XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
}
/* Clear out the condemned list now so we won't try to process any
more events on the hapless scroll bars. */
- FSET (f, condemned_scroll_bars, Qnil);
+ fset_condemned_scroll_bars (f, Qnil);
for (; ! NILP (bar); bar = next)
{
static void
x_scroll_bar_note_movement (struct scroll_bar *bar, XEvent *event)
{
- FRAME_PTR f = XFRAME (WVAR (XWINDOW (bar->window), frame));
+ FRAME_PTR f = XFRAME (XWINDOW (bar->window)->frame);
last_mouse_movement_time = event->xmotion.time;
mouse highlighting. */
if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
&& (f == 0
- || !EQ (FGET (f, tool_bar_window), hlinfo->mouse_face_window)))
+ || !EQ (f->tool_bar_window, hlinfo->mouse_face_window)))
{
clear_mouse_face (hlinfo);
hlinfo->mouse_face_hidden = 1;
create event iff we don't leave the
selected frame. */
&& (focus_follows_mouse
- || (EQ (WVAR (XWINDOW (window), frame),
- WVAR (XWINDOW (selected_window), frame)))))
+ || (EQ (XWINDOW (window)->frame,
+ XWINDOW (selected_window)->frame))))
{
inev.ie.kind = SELECT_WINDOW_EVENT;
inev.ie.frame_or_window = window;
if (f)
{
/* Is this in the tool-bar? */
- if (WINDOWP (FGET (f, tool_bar_window))
- && WINDOW_TOTAL_LINES (XWINDOW (FGET (f, tool_bar_window))))
+ if (WINDOWP (f->tool_bar_window)
+ && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)))
{
Lisp_Object window;
int x = event.xbutton.x;
int y = event.xbutton.y;
window = window_from_coordinates (f, x, y, 0, 1);
- tool_bar_p = EQ (window, FGET (f, tool_bar_window));
+ tool_bar_p = EQ (window, f->tool_bar_window);
if (tool_bar_p && event.xbutton.button < 4)
{
static void
x_draw_bar_cursor (struct window *w, struct glyph_row *row, int width, enum text_cursor_kinds kind)
{
- struct frame *f = XFRAME (WVAR (w, frame));
+ struct frame *f = XFRAME (w->frame);
struct glyph *cursor_glyph;
/* If cursor is out of bounds, don't draw garbage. This can happen
}
#ifdef HAVE_X_I18N
- if (w == XWINDOW (FGET (f, selected_window)))
+ if (w == XWINDOW (f->selected_window))
if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMPreeditPosition))
xic_set_preeditarea (w, x, y);
#endif
{
/* Set this to t so that delete_frame won't get confused
trying to find a replacement. */
- KVAR (FRAME_KBOARD (XFRAME (frame)), Vdefault_minibuffer_frame) = Qt;
+ kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame)), Qt);
delete_frame (frame, Qnoelisp);
}
xic_set_statusarea (f);
if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
{
- struct window *w = XWINDOW (FGET (f, selected_window));
+ struct window *w = XWINDOW (f->selected_window);
xic_set_preeditarea (w, w->cursor.x, w->cursor.y);
}
}
#endif /* not USE_GTK */
/* If cursor was outside the new size, mark it as off. */
- mark_window_cursors_off (XWINDOW (FGET (f, root_window)));
+ mark_window_cursors_off (XWINDOW (f->root_window));
/* Clear out any recollection of where the mouse highlighting was,
since it might be in a place that's outside the new frame size.
{
terminal->kboard = xmalloc (sizeof *terminal->kboard);
init_kboard (terminal->kboard);
- KVAR (terminal->kboard, Vwindow_system) = Qx;
+ kset_window_system (terminal->kboard, Qx);
/* Add the keyboard to the list before running Lisp code (via
Qvendor_specific_keysyms below), since these are not traced
terminal->kboard->next_kboard = all_kboards;
all_kboards = terminal->kboard;
- if (!EQ (SVAR (XSYMBOL (Qvendor_specific_keysyms), function), Qunbound))
+ if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound))
{
char *vendor = ServerVendor (dpy);
/* Temporarily hide the partially initialized terminal. */
terminal_list = terminal->next_terminal;
UNBLOCK_INPUT;
- KVAR (terminal->kboard, Vsystem_key_alist)
- = call1 (Qvendor_specific_keysyms,
- vendor ? build_string (vendor) : empty_unibyte_string);
+ kset_system_key_alist
+ (terminal->kboard,
+ call1 (Qvendor_specific_keysyms,
+ vendor ? build_string (vendor) : empty_unibyte_string));
BLOCK_INPUT;
terminal->next_terminal = terminal_list;
terminal_list = terminal;
HCoop / bpt / emacs.git / blobdiff