*/
+#define NEW_SELECTIONS
+
#include "config.h"
#ifdef HAVE_X_WINDOWS
#include "lisp.h"
+#include "blockinput.h"
/* On 4.3 these lose if they come after xterm.h. */
#include <stdio.h>
#include <sys/ioctl.h>
#include <strings.h>
#else /* ! defined (BSD) */
+#ifndef VMS
#include <sys/termio.h>
#include <string.h>
+#endif
#endif /* ! defined (BSD) */
/* Allow m- file to inhibit use of FIONREAD. */
struct event_queue x_mouse_queue;
#endif /* HAVE_X11 */
-/* Nonzero after BLOCK_INPUT; prevents input events from being
- processed until later. */
-
-int x_input_blocked;
-
#if defined (SIGIO) && defined (FIONREAD)
int BLOCK_INPUT_mask;
#endif /* ! defined (SIGIO) && defined (FIONREAD) */
-/* Nonzero if input events came in while x_input_blocked was nonzero.
- UNBLOCK_INPUT checks for this. */
-
-int x_pending_input;
-
/* The id of a bitmap used for icon windows.
One such map is shared by all Emacs icon windows.
This is zero if we have not yet had a need to create the bitmap. */
extern Lisp_Object Vcommand_line_args;
char *hostname, *x_id_name;
-Lisp_Object invocation_name;
/* This is the X connection that we are using. */
Display *x_current_display;
-/* The cursor to use for vertical scrollbars on x_current_display. */
-static Cursor x_vertical_scrollbar_cursor;
+/* The cursor to use for vertical scroll bars on x_current_display. */
+static Cursor x_vertical_scroll_bar_cursor;
-/* Frame being updated by update_frame. */
-/* This is set by XTupdate_begin and looked at by all the
+/* Frame being updated by update_frame. This is declared in term.c.
+ This is set by update_begin and looked at by all the
XT functions. It is zero while not inside an update.
In that case, the XT functions assume that `selected_frame'
is the frame to apply to. */
-
-static struct frame *updating_frame;
+extern struct frame *updating_frame;
/* The frame (if any) which has the X window that has keyboard focus.
Zero if none. This is examined by Ffocus_frame in frame.c. Note
extern int errno;
+/* A mask of extra modifier bits to put into every keyboard char. */
+extern int extra_keyboard_modifiers;
+
extern Display *XOpenDisplay ();
extern Window XCreateWindow ();
if (f == 0)
abort ();
- updating_frame = f;
flexlines = f->height;
highlight = 0;
x_display_cursor (f, 1);
- updating_frame = 0;
XFlushQueue ();
UNBLOCK_INPUT;
}
WINDOW is the x-window to output to. LEFT and TOP are starting coords.
HL is 1 if this text is highlighted, 2 if the cursor is on it.
- FONT is the default font to use (for glyphs whose font-code is 0). */
+ FONT is the default font to use (for glyphs whose font-code is 0).
-static void
-dumpglyphs (f, left, top, gp, n, hl, font)
- struct frame *f;
- int left, top;
- register GLYPH *gp; /* Points to first GLYPH. */
- register int n; /* Number of glyphs to display. */
- int hl;
- FONT_TYPE *font;
-{
- register int len;
- Window window = FRAME_X_WINDOW (f);
- GC drawing_gc = (hl == 2 ? f->display.x->cursor_gc
- : (hl ? f->display.x->reverse_gc
- : f->display.x->normal_gc));
+ Since the display generation code is responsible for calling
+ compute_char_face and compute_glyph_face on everything it puts in
+ the display structure, we can assume that the face code on each
+ glyph is a valid index into FRAME_FACES (f), and the one to which
+ we can actually apply intern_face. */
- if (sizeof (GLYPH) == sizeof (XChar2b))
- XDrawImageString16 (x_current_display, window, drawing_gc,
- left, top + FONT_BASE (font), (XChar2b *) gp, n);
- else if (sizeof (GLYPH) == sizeof (unsigned char))
- XDrawImageString (x_current_display, window, drawing_gc,
- left, top + FONT_BASE (font), (char *) gp, n);
- else
- /* What size of glyph ARE you using? And does X have a function to
- draw them? */
- abort ();
-}
+#if 1
+/* This is the multi-face code. */
-#if 0
static void
-dumpglyphs (f, left, top, gp, n, hl, font)
+dumpglyphs (f, left, top, gp, n, hl)
struct frame *f;
int left, top;
register GLYPH *gp; /* Points to first GLYPH. */
register int n; /* Number of glyphs to display. */
int hl;
- FONT_TYPE *font;
{
- char buf[f->width]; /* Holds characters to be displayed. */
+ /* Holds characters to be displayed. */
+ char *buf = (char *) alloca (f->width * sizeof (*buf));
register char *cp; /* Steps through buf[]. */
register int tlen = GLYPH_TABLE_LENGTH;
register Lisp_Object *tbase = GLYPH_TABLE_BASE;
Window window = FRAME_X_WINDOW (f);
- int cursor_pixel = f->display.x->cursor_pixel;
- int fg_pixel = f->display.x->foreground_pixel;
- int bg_pixel = f->display.x->background_pixel;
- int intborder = f->display.x->internal_border_width;
- while (n)
+ extern struct face *intern_face (/* FRAME_PTR, struct face * */);
+
+ while (n > 0)
{
/* Get the face-code of the next GLYPH. */
int cf, len;
int g = *gp;
- while (GLYPH_ALIAS_P (tbase, tlen, g))
- g = GLYPH_ALIAS (tbase, g);
-
- cf = g >> 8;
+ GLYPH_FOLLOW_ALIASES (tbase, tlen, g);
+ cf = GLYPH_FACE (g);
/* Find the run of consecutive glyphs with the same face-code.
Extract their character codes into BUF. */
while (n > 0)
{
g = *gp;
- while (GLYPH_ALIAS_P (tbase, tlen, g))
- g = GLYPH_ALIAS (tbase, g);
- if ((g >> 8) != cf)
+ GLYPH_FOLLOW_ALIASES (tbase, tlen, g);
+ if (GLYPH_FACE (g) != cf)
break;
- *cp++ = 0377 & g;
+ *cp++ = GLYPH_CHAR (g);
--n;
++gp;
}
/* Now output this run of chars, with the font and pixel values
determined by the face code CF. */
- if (cf == 0)
- {
-#ifdef HAVE_X11
- GC GC_cursor = f->display.x->cursor_gc;
- GC GC_reverse = f->display.x->reverse_gc;
- GC GC_normal = f->display.x->normal_gc;
-
- XDrawImageString (x_current_display, window,
- (hl == 2
- ? GC_cursor
- : (hl ? GC_reverse : GC_normal)),
- left, top + FONT_BASE (font), buf, len);
-#else /* ! defined (HAVE_X11) */
- XText (window, left, top,
- buf,
- len,
- font->id,
- (hl == 2
- ? (cursor_pixel == fg_pixel ? bg_pixel : fg_pixel)
- : hl ? bg_pixel : fg_pixel),
- (hl == 2 ? cursor_pixel
- : hl ? fg_pixel : bg_pixel));
-#endif /* ! defined (HAVE_X11) */
- }
- else
+ {
+ struct face *face = FRAME_DEFAULT_FACE (f);
+ FONT_TYPE *font = FACE_FONT (face);
+ GC gc = FACE_GC (face);
+ int defaulted = 1;
+ int gc_temporary = 0;
+
+ /* First look at the face of the text itself. */
+ if (cf != 0)
+ {
+ /* The face codes on the glyphs must be valid indices into the
+ frame's face table. */
+ if (cf < 0 || cf >= FRAME_N_FACES (f))
+ abort ();
+
+ if (cf == 1)
+ face = FRAME_MODE_LINE_FACE (f);
+ else
+ face = intern_face (f, FRAME_FACES (f) [cf]);
+ font = FACE_FONT (face);
+ gc = FACE_GC (face);
+ defaulted = 0;
+ }
+
+ /* Then comes the distinction between modeline and normal text. */
+ else if (hl == 0)
+ ;
+ else if (hl == 1)
+ {
+ face = FRAME_MODE_LINE_FACE (f);
+ font = FACE_FONT (face);
+ gc = FACE_GC (face);
+ defaulted = 0;
+ }
+
+#define FACE_DEFAULT (~0)
+
+ /* Now override that if the cursor's on this character. */
+ if (hl == 2 && (defaulted
+ || !(face->font && (int) face->font != FACE_DEFAULT)))
+ {
+ gc = f->display.x->cursor_gc;
+ }
+ /* Cursor on non-default face: must merge. */
+ else if (hl == 2)
+ {
+ XGCValues xgcv;
+ unsigned long mask;
+
+ xgcv.background = f->display.x->cursor_pixel;
+ xgcv.foreground = f->display.x->cursor_foreground_pixel;
+ xgcv.font = face->font->fid;
+ xgcv.graphics_exposures = 0;
+ mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
+ gc = XCreateGC (x_current_display, FRAME_X_WINDOW (f),
+ mask, &xgcv);
+#if 0
+ if (face->stipple && face->stipple != FACE_DEFAULT)
+ XSetStipple (x_current_display, gc, face->stipple);
+#endif
+ gc_temporary = 1;
+ }
+
+ XDrawImageString (x_current_display, window, gc,
+ left, top + FONT_BASE (font), buf, len);
+
+ if (gc_temporary)
+ XFreeGC (x_current_display, gc);
+
+ /* We should probably check for XA_UNDERLINE_POSITION and
+ XA_UNDERLINE_THICKNESS properties on the font, but let's
+ just get the thing working, and come back to that. */
{
-#ifdef HAVE_X11
- if (FACE_IS_FONT (cf))
- XDrawImageString (x_current_display, FRAME_X_WINDOW (f),
- FACE_GC (cf),
- left, top + FONT_BASE (FACE_FONT (cf)),
- buf, len);
- else if (FACE_IS_IMAGE (cf))
- XCopyPlane (x_current_display, FACE_IMAGE (cf),
- FRAME_X_WINDOW (f),
- f->display.x->normal_gc,
- 0, 0,
- FACE_IMAGE_WIDTH (cf),
- FACE_IMAGE_HEIGHT (cf), left, top);
- else
- abort ();
-#else /* ! defined (HAVE_X11) */
- register struct face *fp = x_face_table[cf];
-
- XText (window, left, top,
- buf,
- len,
- fp->font->id,
- (hl == 2
- ? (cursor_pixel == fp->fg ? fp->bg : fp->fg)
- : hl ? fp->bg : fp->fg),
- (hl == 2 ? cursor_pixel
- : hl ? fp->fg : fp->bg));
-#endif /* ! defined (HAVE_X11) */
+ int underline_position = 1;
+
+ if (font->descent <= underline_position)
+ underline_position = font->descent - 1;
+
+ if (face->underline)
+ XFillRectangle (x_current_display, FRAME_X_WINDOW (f),
+ FACE_GC (face),
+ left, (top
+ + FONT_BASE (font)
+ + underline_position),
+ len * FONT_WIDTH (font), 1);
}
- left += len * FONT_WIDTH (font);
+
+ left += len * FONT_WIDTH (font);
+ }
}
}
-#endif /* ! 0 */
+#endif /* 1 */
+
+#if 0
+/* This is the old single-face code. */
+
+static void
+dumpglyphs (f, left, top, gp, n, hl, font)
+ struct frame *f;
+ int left, top;
+ register GLYPH *gp; /* Points to first GLYPH. */
+ register int n; /* Number of glyphs to display. */
+ int hl;
+ FONT_TYPE *font;
+{
+ register int len;
+ Window window = FRAME_X_WINDOW (f);
+ GC drawing_gc = (hl == 2 ? f->display.x->cursor_gc
+ : (hl ? f->display.x->reverse_gc
+ : f->display.x->normal_gc));
+
+ if (sizeof (GLYPH) == sizeof (XChar2b))
+ XDrawImageString16 (x_current_display, window, drawing_gc,
+ left, top + FONT_BASE (font), (XChar2b *) gp, n);
+ else if (sizeof (GLYPH) == sizeof (unsigned char))
+ XDrawImageString (x_current_display, window, drawing_gc,
+ left, top + FONT_BASE (font), (char *) gp, n);
+ else
+ /* What size of glyph ARE you using? And does X have a function to
+ draw them? */
+ abort ();
+}
+#endif
\f
/* Output some text at the nominal frame cursor position.
Advance the cursor over the text.
dumpglyphs (f,
CHAR_TO_PIXEL_COL (f, curs_x),
CHAR_TO_PIXEL_ROW (f, curs_y),
- start, len, highlight, f->display.x->font);
+ start, len, highlight);
/* If we drew on top of the cursor, note that it is turned off. */
if (curs_y == f->phys_cursor_y
XClear (FRAME_X_WINDOW (f));
- /* We have to clear the scrollbars, too. If we have changed
+ /* We have to clear the scroll bars, too. If we have changed
colors or something like that, then they should be notified. */
- x_scrollbar_clear (f);
+ x_scroll_bar_clear (f);
#ifndef HAVE_X11
dumpborder (f, 0);
CHAR_TO_PIXEL_COL (f, left),
CHAR_TO_PIXEL_ROW (f, y),
line, min (cols, active_frame->used[y] - left),
- active_frame->highlight[y], f->display.x->font);
+ active_frame->highlight[y]);
}
/* Turn the cursor on if we turned it off. */
int intborder;
frame = XCONS (tail)->car;
- if (XTYPE (frame) != Lisp_Frame)
+ if (XGCTYPE (frame) != Lisp_Frame)
continue;
f = XFRAME (frame);
if (! FRAME_X_P (f))
clear_cursor (f);
XGetWindowInfo (FRAME_X_WINDOW (f), &windowinfo);
temp_width = ((windowinfo.width - 2 * intborder
- - f->display.x->v_scrollbar_width)
+ - f->display.x->v_scroll_bar_width)
/ FONT_WIDTH (f->display.x->font));
temp_height = ((windowinfo.height- 2 * intborder
- - f->display.x->h_scrollbar_height)
+ - f->display.x->h_scroll_bar_height)
/ FONT_HEIGHT (f->display.x->font));
if (temp_width != f->width || temp_height != f->height)
{
change_frame_size (f, max (1, temp_height),
max (1, temp_width), 0, 1);
- x_resize_scrollbars (f);
+ x_resize_scroll_bars (f);
}
f->display.x->left_pos = windowinfo.x;
f->display.x->top_pos = windowinfo.y;
if (x_focus_frame)
{
x_highlight_frame =
- ((XTYPE (FRAME_FOCUS_FRAME (x_focus_frame)) == Lisp_Frame)
+ ((XGCTYPE (FRAME_FOCUS_FRAME (x_focus_frame)) == Lisp_Frame)
? XFRAME (FRAME_FOCUS_FRAME (x_focus_frame))
: x_focus_frame);
if (! FRAME_LIVE_P (x_highlight_frame))
(EVENT.state & x_shift_lock_mask) != 0. */
static int x_meta_mod_mask, x_shift_lock_mask;
+/* These are like x_meta_mod_mask, but for different modifiers. */
+static int x_alt_mod_mask, x_super_mod_mask, x_hyper_mod_mask;
+
/* Initialize mode_switch_bit and modifier_meaning. */
static void
x_find_modifier_meanings ()
KeySym *syms;
int syms_per_code;
XModifierKeymap *mods;
- int alt_mod_mask = 0;
x_meta_mod_mask = 0;
x_shift_lock_mask = 0;
+ x_alt_mod_mask = 0;
+ x_super_mod_mask = 0;
+ x_hyper_mod_mask = 0;
+#ifdef HAVE_X11R4
XDisplayKeycodes (x_current_display, &min_code, &max_code);
+#else
+ min_code = x_current_display->min_keycode;
+ max_code = x_current_display->max_keycode;
+#endif
+
syms = XGetKeyboardMapping (x_current_display,
min_code, max_code - min_code + 1,
&syms_per_code);
case XK_Alt_L:
case XK_Alt_R:
- alt_mod_mask |= (1 << row);
+ x_alt_mod_mask |= (1 << row);
+ break;
+
+ case XK_Hyper_L:
+ case XK_Hyper_R:
+ x_hyper_mod_mask |= (1 << row);
+ break;
+
+ case XK_Super_L:
+ case XK_Super_R:
+ x_super_mod_mask |= (1 << row);
break;
case XK_Shift_Lock:
/* If we couldn't find any meta keys, accept any alt keys as meta keys. */
if (! x_meta_mod_mask)
- x_meta_mod_mask = alt_mod_mask;
+ {
+ x_meta_mod_mask = x_alt_mod_mask;
+ x_alt_mod_mask = 0;
+ }
+ /* If some keys are both alt and meta,
+ make them just meta, not alt. */
+ if (x_alt_mod_mask & x_meta_mod_mask)
+ {
+ x_alt_mod_mask &= ~x_meta_mod_mask;
+ }
+
XFree ((char *) syms);
XFreeModifiermap (mods);
}
-/* Convert a set of X modifier bits to the proper form for a
- struct input_event modifiers value. */
-
+/* Convert between the modifier bits X uses and the modifier bits
+ Emacs uses. */
static unsigned int
-x_convert_modifiers (state)
+x_x_to_emacs_modifiers (state)
unsigned int state;
{
return ( ((state & (ShiftMask | x_shift_lock_mask)) ? shift_modifier : 0)
| ((state & ControlMask) ? ctrl_modifier : 0)
- | ((state & x_meta_mod_mask) ? meta_modifier : 0));
+ | ((state & x_meta_mod_mask) ? meta_modifier : 0)
+ | ((state & x_alt_mod_mask) ? alt_modifier : 0)
+ | ((state & x_super_mod_mask) ? super_modifier : 0)
+ | ((state & x_hyper_mod_mask) ? hyper_modifier : 0));
+}
+
+static unsigned int
+x_emacs_to_x_modifiers (state)
+ unsigned int state;
+{
+ return ( ((state & alt_modifier) ? x_alt_mod_mask : 0)
+ | ((state & super_modifier) ? x_super_mod_mask : 0)
+ | ((state & hyper_modifier) ? x_hyper_mod_mask : 0)
+ | ((state & shift_modifier) ? ShiftMask : 0)
+ | ((state & ctrl_modifier) ? ControlMask : 0)
+ | ((state & meta_modifier) ? x_meta_mod_mask : 0));
}
/* Prepare a mouse-event in *RESULT for placement in the input queue.
result->kind = mouse_click;
XSET (result->code, Lisp_Int, event->button - Button1);
result->timestamp = event->time;
- result->modifiers = (x_convert_modifiers (event->state)
+ result->modifiers = (x_x_to_emacs_modifiers (event->state)
| (event->type == ButtonRelease
? up_modifier
: down_modifier));
static FRAME_PTR last_mouse_frame;
static XRectangle last_mouse_glyph;
-/* The scrollbar in which the last X motion event occurred.
+/* The scroll bar in which the last X motion event occurred.
- If the last X motion event occured in a scrollbar, we set this
- so XTmouse_position can know whether to report a scrollbar motion or
+ If the last X motion event occured in a scroll bar, we set this
+ so XTmouse_position can know whether to report a scroll bar motion or
an ordinary motion.
- If the last X motion event didn't occur in a scrollbar, we set this
+ If the last X motion event didn't occur in a scroll bar, we set this
to Qnil, to tell XTmouse_position to return an ordinary motion event. */
-static Lisp_Object last_mouse_scrollbar;
+static Lisp_Object last_mouse_scroll_bar;
/* This is a hack. We would really prefer that XTmouse_position would
return the time associated with the position it returns, but there
|| event->y >= last_mouse_glyph.y + last_mouse_glyph.height)
{
mouse_moved = 1;
- last_mouse_scrollbar = Qnil;
+ last_mouse_scroll_bar = Qnil;
}
else
{
}
}
-static struct scrollbar *x_window_to_scrollbar ();
-static void x_scrollbar_report_motion ();
+static struct scroll_bar *x_window_to_scroll_bar ();
+static void x_scroll_bar_report_motion ();
/* Return the current position of the mouse.
- If the mouse movement started in a scrollbar, set *f, *bar_window,
- and *part to the frame, window, and scrollbar part that the mouse
+ If the mouse movement started in a scroll bar, set *f, *bar_window,
+ and *part to the frame, window, and scroll bar part that the mouse
is over. Set *x and *y to the portion and whole of the mouse's
- position on the scrollbar.
+ position on the scroll bar.
If the mouse movement started elsewhere, set *f to the frame the
mouse is on, *bar_window to nil, and *x and *y to the character cell
XTmouse_position (f, bar_window, part, x, y, time)
FRAME_PTR *f;
Lisp_Object *bar_window;
- enum scrollbar_part *part;
+ enum scroll_bar_part *part;
Lisp_Object *x, *y;
unsigned long *time;
{
BLOCK_INPUT;
- if (! NILP (last_mouse_scrollbar))
- x_scrollbar_report_motion (f, bar_window, part, x, y, time);
+ if (! NILP (last_mouse_scroll_bar))
+ x_scroll_bar_report_motion (f, bar_window, part, x, y, time);
else
{
Window root;
int dummy;
mouse_moved = 0;
- last_mouse_scrollbar = Qnil;
+ last_mouse_scroll_bar = Qnil;
/* Figure out which root window we're on. */
XQueryPointer (x_current_display,
/* Is win one of our frames? */
*f = x_window_to_frame (win);
- /* If not, is it one of our scrollbars? */
+ /* If not, is it one of our scroll bars? */
if (! *f)
{
- struct scrollbar *bar = x_window_to_scrollbar (win);
+ struct scroll_bar *bar = x_window_to_scroll_bar (win);
if (bar)
{
#define XEvent XKeyPressedEvent
#endif /* ! defined (HAVE_X11) */
\f
-/* Scrollbar support. */
+/* Scroll bar support. */
-/* Given an X window ID, find the struct scrollbar which manages it. */
-static struct scrollbar *
-x_window_to_scrollbar (window_id)
+/* Given an X window ID, find the struct scroll_bar which manages it.
+ This can be called in GC, so we have to make sure to strip off mark
+ bits. */
+static struct scroll_bar *
+x_window_to_scroll_bar (window_id)
Window window_id;
{
Lisp_Object tail, frame;
- for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = Vframe_list;
+ XGCTYPE (tail) == Lisp_Cons;
+ tail = XCONS (tail)->cdr)
{
Lisp_Object frame = XCONS (tail)->car;
Lisp_Object bar, condemned;
/* All elements of Vframe_list should be frames. */
- if (XTYPE (frame) != Lisp_Frame)
+ if (XGCTYPE (frame) != Lisp_Frame)
abort ();
- /* Scan this frame's scrollbar list for a scrollbar with the
+ /* Scan this frame's scroll bar list for a scroll bar with the
right window ID. */
- condemned = FRAME_CONDEMNED_SCROLLBARS (XFRAME (frame));
- for (bar = FRAME_SCROLLBARS (XFRAME (frame));
+ condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
+ for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
/* This trick allows us to search both the ordinary and
- condemned scrollbar lists with one loop. */
- ! NILP (bar) || (bar = condemned, condemned = Qnil, ! NILP (bar));
- bar = XSCROLLBAR(bar)->next)
- if (SCROLLBAR_X_WINDOW (XSCROLLBAR (bar)) == window_id)
- return XSCROLLBAR (bar);
+ condemned scroll bar lists with one loop. */
+ ! GC_NILP (bar) || (bar = condemned,
+ condemned = Qnil,
+ ! GC_NILP (bar));
+ bar = XSCROLL_BAR(bar)->next)
+ if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)) == window_id)
+ return XSCROLL_BAR (bar);
}
return 0;
}
-/* Open a new X window to serve as a scrollbar, and return the
- scrollbar vector for it. */
-static struct scrollbar *
-x_scrollbar_create (window, top, left, width, height)
+/* Open a new X window to serve as a scroll bar, and return the
+ scroll bar vector for it. */
+static struct scroll_bar *
+x_scroll_bar_create (window, top, left, width, height)
struct window *window;
int top, left, width, height;
{
FRAME_PTR frame = XFRAME (WINDOW_FRAME (window));
- struct scrollbar *bar =
- XSCROLLBAR (Fmake_vector (make_number (SCROLLBAR_VEC_SIZE), Qnil));
+ struct scroll_bar *bar =
+ XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
BLOCK_INPUT;
a.event_mask = (ButtonPressMask | ButtonReleaseMask
| ButtonMotionMask | PointerMotionHintMask
| ExposureMask);
- a.cursor = x_vertical_scrollbar_cursor;
+ a.cursor = x_vertical_scroll_bar_cursor;
mask = (CWBackPixel | CWEventMask | CWCursor);
- SET_SCROLLBAR_X_WINDOW
+ SET_SCROLL_BAR_X_WINDOW
(bar,
XCreateWindow (x_current_display, FRAME_X_WINDOW (frame),
- /* Position and size of scrollbar. */
+ /* Position and size of scroll bar. */
left, top, width, height,
/* Border width, depth, class, and visual. */
bar->dragging = Qnil;
/* Add bar to its frame's list of scroll bars. */
- bar->next = FRAME_SCROLLBARS (frame);
+ bar->next = FRAME_SCROLL_BARS (frame);
bar->prev = Qnil;
- XSET (FRAME_SCROLLBARS (frame), Lisp_Vector, bar);
+ XSET (FRAME_SCROLL_BARS (frame), Lisp_Vector, bar);
if (! NILP (bar->next))
- XSET (XSCROLLBAR (bar->next)->prev, Lisp_Vector, bar);
+ XSET (XSCROLL_BAR (bar->next)->prev, Lisp_Vector, bar);
- XMapWindow (x_current_display, SCROLLBAR_X_WINDOW (bar));
+ XMapWindow (x_current_display, SCROLL_BAR_X_WINDOW (bar));
UNBLOCK_INPUT;
events.)
Normally, we want to constrain the start and end of the handle to
- fit inside its rectangle, but if the user is dragging the scrollbar
+ fit inside its rectangle, but if the user is dragging the scroll bar
handle, we want to let them drag it down all the way, so that the
bar's top is as far down as it goes; otherwise, there's no way to
move to the very end of the buffer. */
static void
-x_scrollbar_set_handle (bar, start, end, rebuild)
- struct scrollbar *bar;
+x_scroll_bar_set_handle (bar, start, end, rebuild)
+ struct scroll_bar *bar;
int start, end;
int rebuild;
{
int dragging = ! NILP (bar->dragging);
- Window w = SCROLLBAR_X_WINDOW (bar);
+ Window w = SCROLL_BAR_X_WINDOW (bar);
GC gc = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))->display.x->normal_gc;
/* If the display is already accurate, do nothing. */
BLOCK_INPUT;
{
- int inside_width = VERTICAL_SCROLLBAR_INSIDE_WIDTH (XINT (bar->width));
- int inside_height = VERTICAL_SCROLLBAR_INSIDE_HEIGHT (XINT (bar->height));
- int top_range = VERTICAL_SCROLLBAR_TOP_RANGE (XINT (bar->height));
+ int inside_width = VERTICAL_SCROLL_BAR_INSIDE_WIDTH (XINT (bar->width));
+ int inside_height = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar->height));
+ int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar->height));
/* Make sure the values are reasonable, and try to preserve
the distance between start and end. */
end = top_range;
}
- /* Store the adjusted setting in the scrollbar. */
+ /* Store the adjusted setting in the scroll bar. */
XSET (bar->start, Lisp_Int, start);
XSET (bar->end, Lisp_Int, end);
if (end > top_range)
end = top_range;
- /* Draw bottom positions VERTICAL_SCROLLBAR_MIN_HANDLE pixels
+ /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
below top positions, to make sure the handle is always at least
that many pixels tall. */
- end += VERTICAL_SCROLLBAR_MIN_HANDLE;
+ end += VERTICAL_SCROLL_BAR_MIN_HANDLE;
/* Draw the empty space above the handle. Note that we can't clear
zero-height areas; that means "clear to end of window." */
XClearArea (x_current_display, w,
/* x, y, width, height, and exposures. */
- VERTICAL_SCROLLBAR_LEFT_BORDER,
- VERTICAL_SCROLLBAR_TOP_BORDER,
+ VERTICAL_SCROLL_BAR_LEFT_BORDER,
+ VERTICAL_SCROLL_BAR_TOP_BORDER,
inside_width, start,
False);
XFillRectangle (x_current_display, w, gc,
/* x, y, width, height */
- VERTICAL_SCROLLBAR_LEFT_BORDER,
- VERTICAL_SCROLLBAR_TOP_BORDER + start,
+ VERTICAL_SCROLL_BAR_LEFT_BORDER,
+ VERTICAL_SCROLL_BAR_TOP_BORDER + start,
inside_width, end - start);
XClearArea (x_current_display, w,
/* x, y, width, height, and exposures. */
- VERTICAL_SCROLLBAR_LEFT_BORDER,
- VERTICAL_SCROLLBAR_TOP_BORDER + end,
+ VERTICAL_SCROLL_BAR_LEFT_BORDER,
+ VERTICAL_SCROLL_BAR_TOP_BORDER + end,
inside_width, inside_height - end,
False);
UNBLOCK_INPUT;
}
-/* Move a scrollbar around on the screen, to accomodate changing
+/* Move a scroll bar around on the screen, to accomodate changing
window configurations. */
static void
-x_scrollbar_move (bar, top, left, width, height)
- struct scrollbar *bar;
+x_scroll_bar_move (bar, top, left, width, height)
+ struct scroll_bar *bar;
int top, left, width, height;
{
BLOCK_INPUT;
if (height != XINT (bar->height)) mask |= CWHeight;
if (mask)
- XConfigureWindow (x_current_display, SCROLLBAR_X_WINDOW (bar),
+ XConfigureWindow (x_current_display, SCROLL_BAR_X_WINDOW (bar),
mask, &wc);
}
UNBLOCK_INPUT;
}
-/* Destroy the X window for BAR, and set its Emacs window's scrollbar
+/* Destroy the X window for BAR, and set its Emacs window's scroll bar
to nil. */
static void
-x_scrollbar_remove (bar)
- struct scrollbar *bar;
+x_scroll_bar_remove (bar)
+ struct scroll_bar *bar;
{
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
BLOCK_INPUT;
/* Destroy the window. */
- XDestroyWindow (x_current_display, SCROLLBAR_X_WINDOW (bar));
+ XDestroyWindow (x_current_display, SCROLL_BAR_X_WINDOW (bar));
- /* Disassociate this scrollbar from its window. */
- XWINDOW (bar->window)->vertical_scrollbar = Qnil;
+ /* Disassociate this scroll bar from its window. */
+ XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
UNBLOCK_INPUT;
}
/* Set the handle of the vertical scroll bar for WINDOW to indicate
that we are displaying PORTION characters out of a total of WHOLE
- characters, starting at POSITION. If WINDOW has no scrollbar,
+ characters, starting at POSITION. If WINDOW has no scroll bar,
create one. */
static void
-XTset_vertical_scrollbar (window, portion, whole, position)
+XTset_vertical_scroll_bar (window, portion, whole, position)
struct window *window;
int portion, whole, position;
{
FRAME_PTR f = XFRAME (WINDOW_FRAME (window));
int top = XINT (window->top);
- int left = WINDOW_VERTICAL_SCROLLBAR_COLUMN (window);
- int height = WINDOW_VERTICAL_SCROLLBAR_HEIGHT (window);
+ int left = WINDOW_VERTICAL_SCROLL_BAR_COLUMN (window);
+ int height = WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window);
- /* Where should this scrollbar be, pixelwise? */
+ /* Where should this scroll bar be, pixelwise? */
int pixel_top = CHAR_TO_PIXEL_ROW (f, top);
int pixel_left = CHAR_TO_PIXEL_COL (f, left);
- int pixel_width = VERTICAL_SCROLLBAR_PIXEL_WIDTH (f);
- int pixel_height = VERTICAL_SCROLLBAR_PIXEL_HEIGHT (f, height);
+ int pixel_width = VERTICAL_SCROLL_BAR_PIXEL_WIDTH (f);
+ int pixel_height = VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f, height);
- struct scrollbar *bar;
+ struct scroll_bar *bar;
- /* Does the scrollbar exist yet? */
- if (NILP (window->vertical_scrollbar))
- bar = x_scrollbar_create (window,
+ /* Does the scroll bar exist yet? */
+ if (NILP (window->vertical_scroll_bar))
+ bar = x_scroll_bar_create (window,
pixel_top, pixel_left,
pixel_width, pixel_height);
else
{
/* It may just need to be moved and resized. */
- bar = XSCROLLBAR (window->vertical_scrollbar);
- x_scrollbar_move (bar, pixel_top, pixel_left, pixel_width, pixel_height);
+ bar = XSCROLL_BAR (window->vertical_scroll_bar);
+ x_scroll_bar_move (bar, pixel_top, pixel_left, pixel_width, pixel_height);
}
- /* Set the scrollbar's current state, unless we're currently being
+ /* Set the scroll bar's current state, unless we're currently being
dragged. */
if (NILP (bar->dragging))
{
int top_range =
- VERTICAL_SCROLLBAR_TOP_RANGE (pixel_height);
+ VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height);
if (whole == 0)
- x_scrollbar_set_handle (bar, 0, top_range, 0);
+ x_scroll_bar_set_handle (bar, 0, top_range, 0);
else
{
int start = (position * top_range) / whole;
int end = ((position + portion) * top_range) / whole;
- x_scrollbar_set_handle (bar, start, end, 0);
+ x_scroll_bar_set_handle (bar, start, end, 0);
}
}
- XSET (window->vertical_scrollbar, Lisp_Vector, bar);
+ XSET (window->vertical_scroll_bar, Lisp_Vector, bar);
}
/* The following three hooks are used when we're doing a thorough
- redisplay of the frame. We don't explicitly know which scrollbars
+ redisplay of the frame. We don't explicitly know which scroll bars
are going to be deleted, because keeping track of when windows go
away is a real pain - "Can you say set-window-configuration, boys
and girls?" Instead, we just assert at the beginning of redisplay
- that *all* scrollbars are to be removed, and then save a scrollbar
+ that *all* scroll bars are to be removed, and then save a scroll bar
from the fiery pit when we actually redisplay its window. */
-/* Arrange for all scrollbars on FRAME to be removed at the next call
- to `*judge_scrollbars_hook'. A scrollbar may be spared if
- `*redeem_scrollbar_hook' is applied to its window before the judgement. */
+/* Arrange for all scroll bars on FRAME to be removed at the next call
+ to `*judge_scroll_bars_hook'. A scroll bar may be spared if
+ `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
static void
-XTcondemn_scrollbars (frame)
+XTcondemn_scroll_bars (frame)
FRAME_PTR frame;
{
/* The condemned list should be empty at this point; if it's not,
then the rest of Emacs isn't using the condemn/redeem/judge
protocol correctly. */
- if (! NILP (FRAME_CONDEMNED_SCROLLBARS (frame)))
+ if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
abort ();
/* Move them all to the "condemned" list. */
- FRAME_CONDEMNED_SCROLLBARS (frame) = FRAME_SCROLLBARS (frame);
- FRAME_SCROLLBARS (frame) = Qnil;
+ FRAME_CONDEMNED_SCROLL_BARS (frame) = FRAME_SCROLL_BARS (frame);
+ FRAME_SCROLL_BARS (frame) = Qnil;
}
-/* Unmark WINDOW's scrollbar for deletion in this judgement cycle.
+/* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
Note that WINDOW isn't necessarily condemned at all. */
static void
-XTredeem_scrollbar (window)
+XTredeem_scroll_bar (window)
struct window *window;
{
- struct scrollbar *bar;
+ struct scroll_bar *bar;
- /* We can't redeem this window's scrollbar if it doesn't have one. */
- if (NILP (window->vertical_scrollbar))
+ /* We can't redeem this window's scroll bar if it doesn't have one. */
+ if (NILP (window->vertical_scroll_bar))
abort ();
- bar = XSCROLLBAR (window->vertical_scrollbar);
+ bar = XSCROLL_BAR (window->vertical_scroll_bar);
/* Unlink it from the condemned list. */
{
{
/* If the prev pointer is nil, it must be the first in one of
the lists. */
- if (EQ (FRAME_SCROLLBARS (f), window->vertical_scrollbar))
+ if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
/* It's not condemned. Everything's fine. */
return;
- else if (EQ (FRAME_CONDEMNED_SCROLLBARS (f),
- window->vertical_scrollbar))
- FRAME_CONDEMNED_SCROLLBARS (f) = bar->next;
+ else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
+ window->vertical_scroll_bar))
+ FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
else
/* If its prev pointer is nil, it must be at the front of
one or the other! */
abort ();
}
else
- XSCROLLBAR (bar->prev)->next = bar->next;
+ XSCROLL_BAR (bar->prev)->next = bar->next;
if (! NILP (bar->next))
- XSCROLLBAR (bar->next)->prev = bar->prev;
+ XSCROLL_BAR (bar->next)->prev = bar->prev;
- bar->next = FRAME_SCROLLBARS (f);
+ bar->next = FRAME_SCROLL_BARS (f);
bar->prev = Qnil;
- XSET (FRAME_SCROLLBARS (f), Lisp_Vector, bar);
+ XSET (FRAME_SCROLL_BARS (f), Lisp_Vector, bar);
if (! NILP (bar->next))
- XSET (XSCROLLBAR (bar->next)->prev, Lisp_Vector, bar);
+ XSET (XSCROLL_BAR (bar->next)->prev, Lisp_Vector, bar);
}
}
-/* Remove all scrollbars on FRAME that haven't been saved since the
- last call to `*condemn_scrollbars_hook'. */
+/* Remove all scroll bars on FRAME that haven't been saved since the
+ last call to `*condemn_scroll_bars_hook'. */
static void
-XTjudge_scrollbars (f)
+XTjudge_scroll_bars (f)
FRAME_PTR f;
{
Lisp_Object bar, next;
- bar = FRAME_CONDEMNED_SCROLLBARS (f);
+ bar = FRAME_CONDEMNED_SCROLL_BARS (f);
/* Clear out the condemned list now so we won't try to process any
- more events on the hapless scrollbars. */
- FRAME_CONDEMNED_SCROLLBARS (f) = Qnil;
+ more events on the hapless scroll bars. */
+ FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil;
for (; ! NILP (bar); bar = next)
{
- struct scrollbar *b = XSCROLLBAR (bar);
+ struct scroll_bar *b = XSCROLL_BAR (bar);
- x_scrollbar_remove (b);
+ x_scroll_bar_remove (b);
next = b->next;
b->next = b->prev = Qnil;
}
- /* Now there should be no references to the condemned scrollbars,
+ /* Now there should be no references to the condemned scroll bars,
and they should get garbage-collected. */
}
-/* Handle an Expose or GraphicsExpose event on a scrollbar. */
+/* Handle an Expose or GraphicsExpose event on a scroll bar.
+
+ This may be called from a signal handler, so we have to ignore GC
+ mark bits. */
static void
-x_scrollbar_expose (bar, event)
- struct scrollbar *bar;
+x_scroll_bar_expose (bar, event)
+ struct scroll_bar *bar;
XEvent *event;
{
- Window w = SCROLLBAR_X_WINDOW (bar);
+ Window w = SCROLL_BAR_X_WINDOW (bar);
GC gc = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))->display.x->normal_gc;
BLOCK_INPUT;
- x_scrollbar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);
+ x_scroll_bar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);
- /* Draw a one-pixel border just inside the edges of the scrollbar. */
+ /* Draw a one-pixel border just inside the edges of the scroll bar. */
XDrawRectangle (x_current_display, w, gc,
/* x, y, width, height */
UNBLOCK_INPUT;
}
-/* Handle a mouse click on the scrollbar BAR. If *EMACS_EVENT's kind
- is set to something other than no_event, it is enqueued. */
+/* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
+ is set to something other than no_event, it is enqueued.
+
+ This may be called from a signal handler, so we have to ignore GC
+ mark bits. */
static void
-x_scrollbar_handle_click (bar, event, emacs_event)
- struct scrollbar *bar;
+x_scroll_bar_handle_click (bar, event, emacs_event)
+ struct scroll_bar *bar;
XEvent *event;
struct input_event *emacs_event;
{
- if (XTYPE (bar->window) != Lisp_Window)
+ if (XGCTYPE (bar->window) != Lisp_Window)
abort ();
- emacs_event->kind = scrollbar_click;
+ emacs_event->kind = scroll_bar_click;
XSET (emacs_event->code, Lisp_Int, event->xbutton.button - Button1);
emacs_event->modifiers =
- (x_convert_modifiers (event->xbutton.state)
+ (x_x_to_emacs_modifiers (event->xbutton.state)
| (event->type == ButtonRelease
? up_modifier
: down_modifier));
emacs_event->timestamp = event->xbutton.time;
{
int internal_height =
- VERTICAL_SCROLLBAR_INSIDE_HEIGHT (XINT (bar->height));
+ VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar->height));
int top_range =
- VERTICAL_SCROLLBAR_TOP_RANGE (XINT (bar->height));
- int y = event->xbutton.y - VERTICAL_SCROLLBAR_TOP_BORDER;
+ VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar->height));
+ int y = event->xbutton.y - VERTICAL_SCROLL_BAR_TOP_BORDER;
if (y < 0) y = 0;
if (y > top_range) y = top_range;
if (y < XINT (bar->start))
- emacs_event->part = scrollbar_above_handle;
- else if (y < XINT (bar->end) + VERTICAL_SCROLLBAR_MIN_HANDLE)
- emacs_event->part = scrollbar_handle;
+ emacs_event->part = scroll_bar_above_handle;
+ else if (y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
+ emacs_event->part = scroll_bar_handle;
else
- emacs_event->part = scrollbar_below_handle;
+ emacs_event->part = scroll_bar_below_handle;
/* If the user has just clicked on the handle, record where they're
holding it. */
if (event->type == ButtonPress
- && emacs_event->part == scrollbar_handle)
+ && emacs_event->part == scroll_bar_handle)
XSET (bar->dragging, Lisp_Int, y - XINT (bar->start));
/* If the user has released the handle, set it to its final position. */
int new_start = y - XINT (bar->dragging);
int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
- x_scrollbar_set_handle (bar, new_start, new_end, 0);
+ x_scroll_bar_set_handle (bar, new_start, new_end, 0);
bar->dragging = Qnil;
}
/* Clicks on the handle are always reported as occuring at the top of
the handle. */
- if (emacs_event->part == scrollbar_handle)
+ if (emacs_event->part == scroll_bar_handle)
emacs_event->x = bar->start;
else
XSET (emacs_event->x, Lisp_Int, y);
}
}
-/* Handle some mouse motion while someone is dragging the scrollbar. */
+/* Handle some mouse motion while someone is dragging the scroll bar.
+
+ This may be called from a signal handler, so we have to ignore GC
+ mark bits. */
static void
-x_scrollbar_note_movement (bar, event)
- struct scrollbar *bar;
+x_scroll_bar_note_movement (bar, event)
+ struct scroll_bar *bar;
XEvent *event;
{
last_mouse_movement_time = event->xmotion.time;
mouse_moved = 1;
- XSET (last_mouse_scrollbar, Lisp_Vector, bar);
+ XSET (last_mouse_scroll_bar, Lisp_Vector, bar);
/* If we're dragging the bar, display it. */
- if (! NILP (bar->dragging))
+ if (! GC_NILP (bar->dragging))
{
/* Where should the handle be now? */
int new_start = event->xmotion.y - XINT (bar->dragging);
{
int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
- x_scrollbar_set_handle (bar, new_start, new_end, 0);
+ x_scroll_bar_set_handle (bar, new_start, new_end, 0);
}
}
}
/* Return information to the user about the current position of the mouse
- on the scrollbar. */
+ on the scroll bar. */
static void
-x_scrollbar_report_motion (f, bar_window, part, x, y, time)
+x_scroll_bar_report_motion (f, bar_window, part, x, y, time)
FRAME_PTR *f;
Lisp_Object *bar_window;
- enum scrollbar_part *part;
+ enum scroll_bar_part *part;
Lisp_Object *x, *y;
unsigned long *time;
{
- struct scrollbar *bar = XSCROLLBAR (last_mouse_scrollbar);
+ struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
int win_x, win_y;
BLOCK_INPUT;
- /* Get the mouse's position relative to the scrollbar window, and
+ /* Get the mouse's position relative to the scroll bar window, and
report that. */
{
Window dummy_window;
unsigned int dummy_mask;
if (! XQueryPointer (x_current_display,
- SCROLLBAR_X_WINDOW (bar),
+ SCROLL_BAR_X_WINDOW (bar),
/* Root, child, root x and root y. */
&dummy_window, &dummy_window,
&dummy_coord, &dummy_coord,
- /* Position relative to scrollbar. */
+ /* Position relative to scroll bar. */
&win_x, &win_y,
/* Mouse buttons and modifier keys. */
}
{
- int inside_height = VERTICAL_SCROLLBAR_INSIDE_HEIGHT (XINT (bar->height));
- int top_range = VERTICAL_SCROLLBAR_TOP_RANGE (XINT (bar->height));
+ int inside_height = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar->height));
+ int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar->height));
- win_y -= VERTICAL_SCROLLBAR_TOP_BORDER;
+ win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
if (! NILP (bar->dragging))
win_y -= XINT (bar->dragging);
*bar_window = bar->window;
if (! NILP (bar->dragging))
- *part = scrollbar_handle;
+ *part = scroll_bar_handle;
else if (win_y < XINT (bar->start))
- *part = scrollbar_above_handle;
- else if (win_y < XINT (bar->end) + VERTICAL_SCROLLBAR_MIN_HANDLE)
- *part = scrollbar_handle;
+ *part = scroll_bar_above_handle;
+ else if (win_y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
+ *part = scroll_bar_handle;
else
- *part = scrollbar_below_handle;
+ *part = scroll_bar_below_handle;
XSET (*x, Lisp_Int, win_y);
XSET (*y, Lisp_Int, top_range);
}
mouse_moved = 0;
- last_mouse_scrollbar = Qnil;
+ last_mouse_scroll_bar = Qnil;
done:
UNBLOCK_INPUT;
/* The screen has been cleared so we may have changed foreground or
- background colors, and the scrollbars may need to be redrawn.
- Clear out the scrollbars, and ask for expose events, so we can
+ background colors, and the scroll bars may need to be redrawn.
+ Clear out the scroll bars, and ask for expose events, so we can
redraw them. */
-x_scrollbar_clear (f)
+x_scroll_bar_clear (f)
FRAME_PTR f;
{
Lisp_Object bar;
- for (bar = FRAME_SCROLLBARS (f);
+ for (bar = FRAME_SCROLL_BARS (f);
XTYPE (bar) == Lisp_Vector;
- bar = XSCROLLBAR (bar)->next)
- XClearArea (x_current_display, SCROLLBAR_X_WINDOW (XSCROLLBAR (bar)),
+ bar = XSCROLL_BAR (bar)->next)
+ XClearArea (x_current_display, SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)),
0, 0, 0, 0, True);
}
Atom Xatom_wm_configure_denied; /* When our config request is denied */
Atom Xatom_wm_window_moved; /* When the WM moves us. */
+/* Window manager communication. */
+Atom Xatom_wm_change_state;
+
+/* Record the last 100 characters stored
+ to help debug the loss-of-chars-during-GC problem. */
+int temp_index;
+short temp_buffer[100];
+
/* Read events coming from the X server.
This routine is called by the SIGIO handler.
We return as soon as there are no more events to be read.
int prefix;
Lisp_Object part;
- if (x_input_blocked)
+ if (interrupt_input_blocked)
{
- x_pending_input = 1;
+ interrupt_input_pending = 1;
return -1;
}
- x_pending_input = 0;
+ interrupt_input_pending = 0;
BLOCK_INPUT;
if (numchars <= 0)
f = x_window_to_frame (event.xclient.window);
if (f)
x_focus_on_frame (f);
- /* Not certain about handling scrollbars here */
+ /* Not certain about handling scroll bars here */
}
else if (event.xclient.data.l[0] == Xatom_wm_save_yourself)
{
}
break;
+#ifdef NEW_SELECTIONS
+ case SelectionNotify:
+ x_handle_selection_notify (&event);
+ break;
+#endif
+
case SelectionClear: /* Someone has grabbed ownership. */
+#ifdef NEW_SELECTIONS
+ {
+ XSelectionClearEvent *eventp = (XSelectionClearEvent *) &event;
+
+ if (numchars == 0)
+ abort ();
+
+ bufp->kind = selection_clear_event;
+ SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
+ SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
+ SELECTION_EVENT_TIME (bufp) = eventp->time;
+ bufp++;
+
+ count += 1;
+ numchars -= 1;
+ }
+#else
x_disown_selection (event.xselectionclear.window,
event.xselectionclear.selection,
event.xselectionclear.time);
+#endif
break;
case SelectionRequest: /* Someone wants our selection. */
+#ifdef NEW_SELECTIONS
+ {
+ XSelectionRequestEvent *eventp = (XSelectionRequestEvent *) &event;
+
+ if (numchars == 0)
+ abort ();
+
+ bufp->kind = selection_request_event;
+ SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
+ SELECTION_EVENT_REQUESTOR (bufp) = eventp->requestor;
+ SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
+ SELECTION_EVENT_TARGET (bufp) = eventp->target;
+ SELECTION_EVENT_PROPERTY (bufp) = eventp->property;
+ SELECTION_EVENT_TIME (bufp) = eventp->time;
+ bufp++;
+
+ count += 1;
+ numchars -= 1;
+ }
+#else
x_answer_selection_request (event);
+#endif
break;
case PropertyNotify:
-
+#ifdef NEW_SELECTIONS
+ x_handle_property_notify (&event);
+#else
/* If we're being told about a root window property, then it's
a cut buffer change. */
if (event.xproperty.window == ROOT_WINDOW)
about re-selecting. */
x_send_incremental (event);
}
+#endif
break;
case Expose:
}
else
{
- struct scrollbar *bar
- = x_window_to_scrollbar (event.xexpose.window);
+ struct scroll_bar *bar
+ = x_window_to_scroll_bar (event.xexpose.window);
if (bar)
- x_scrollbar_expose (bar, &event);
+ x_scroll_bar_expose (bar, &event);
}
break;
{
KeySym keysym;
char copy_buffer[80];
- int modifiers = event.xkey.state;
+ int modifiers;
- /* Some keyboards generate different characters
- depending on the state of the meta key, in an attempt
- to support non-English typists. It would be nice to
- keep this functionality somehow, but for now, we will
- just clear the meta-key flag to get the 'pure' character. */
- event.xkey.state &= ~Mod1Mask;
+ event.xkey.state
+ |= x_emacs_to_x_modifiers (extra_keyboard_modifiers);
+ modifiers = event.xkey.state;
/* This will have to go some day... */
+
+ /* make_lispy_event turns chars into control chars.
+ Don't do it here because XLookupString is too eager. */
+ event.xkey.state &= ~ControlMask;
nbytes =
XLookupString (&event.xkey, copy_buffer, 80, &keysym,
&compose_status);
if (numchars > 1)
{
- if (IsCursorKey (keysym) /* 0xff50 <= x < 0xff60 */
+ if ((keysym >= XK_BackSpace && keysym <= XK_Escape)
+ || keysym == XK_Delete
+ || IsCursorKey (keysym) /* 0xff50 <= x < 0xff60 */
|| IsMiscFunctionKey (keysym) /* 0xff60 <= x < 0xff80 */
|| IsKeypadKey (keysym) /* 0xff80 <= x < 0xffbe */
|| IsFunctionKey (keysym)) /* 0xffbe <= x < 0xffe1 */
{
+ if (temp_index == sizeof temp_buffer / sizeof (short))
+ temp_index = 0;
+ temp_buffer[temp_index++] = keysym;
bufp->kind = non_ascii_keystroke;
- XSET (bufp->code, Lisp_Int, (unsigned) keysym - 0xff50);
+ XSET (bufp->code, Lisp_Int, (unsigned) keysym - 0xff00);
XSET (bufp->frame_or_window, Lisp_Frame, f);
- bufp->modifiers = x_convert_modifiers (modifiers);
+ bufp->modifiers = x_x_to_emacs_modifiers (modifiers);
bufp->timestamp = event.xkey.time;
bufp++;
count++;
{
register int i;
- if (nbytes == 1)
+ for (i = 0; i < nbytes; i++)
{
- if (modifiers & x_meta_mod_mask)
- *copy_buffer |= METABIT;
+ if (temp_index == sizeof temp_buffer / sizeof (short))
+ temp_index = 0;
+ temp_buffer[temp_index++] = copy_buffer[i];
bufp->kind = ascii_keystroke;
- XSET (bufp->code, Lisp_Int, *copy_buffer);
+ XSET (bufp->code, Lisp_Int, copy_buffer[i]);
XSET (bufp->frame_or_window, Lisp_Frame, f);
+ bufp->modifiers = x_x_to_emacs_modifiers (modifiers);
bufp->timestamp = event.xkey.time;
bufp++;
}
- else
- for (i = nbytes - 1; i > 1; i--)
- {
- bufp->kind = ascii_keystroke;
- XSET (bufp->code, Lisp_Int, copy_buffer[i]);
- XSET (bufp->frame_or_window, Lisp_Frame, f);
- bufp->timestamp = event.xkey.time;
- bufp++;
- }
count += nbytes;
numchars -= nbytes;
}
+ else
+ abort ();
}
+ else
+ abort ();
}
break;
#else /* ! defined (HAVE_X11) */
note_mouse_movement (f, &event.xmotion);
else
{
- struct scrollbar *bar =
- x_window_to_scrollbar (event.xmotion.window);
+ struct scroll_bar *bar =
+ x_window_to_scroll_bar (event.xmotion.window);
if (bar)
- x_scrollbar_note_movement (bar, &event);
+ x_scroll_bar_note_movement (bar, &event);
}
}
break;
{
if (!x_focus_frame || (f == x_focus_frame))
construct_mouse_click (&emacs_event,
- &event, f, Qnil, 0);
+ &event, f);
}
else
{
- struct scrollbar *bar =
- x_window_to_scrollbar (event.xbutton.window);
+ struct scroll_bar *bar =
+ x_window_to_scroll_bar (event.xbutton.window);
if (bar)
- x_scrollbar_handle_click (bar, &event, &emacs_event);
+ x_scroll_bar_handle_click (bar, &event, &emacs_event);
}
if (numchars >= 1 && emacs_event.kind != no_event)
dumpglyphs (f,
CHAR_TO_PIXEL_COL (f, column),
CHAR_TO_PIXEL_ROW (f, row),
- &glyph, 1, highlight, f->display.x->font);
+ &glyph, 1, highlight);
}
static void
{
struct frame_glyphs *current_glyphs = FRAME_CURRENT_GLYPHS (f);
- if (! FRAME_VISIBLE_P (f))
+ /* This is pointless on invisible frames, and dangerous on garbaged
+ frames; in the latter case, the frame may be in the midst of
+ changing its size, and curs_x and curs_y may be off the frame. */
+ if (! FRAME_VISIBLE_P (f) || FRAME_GARBAGED_P (f))
return;
if (! on && f->phys_cursor_x < 0)
{
struct frame_glyphs *current_glyphs = FRAME_CURRENT_GLYPHS (f);
- if (! FRAME_VISIBLE_P (f))
+ /* This is pointless on invisible frames, and dangerous on garbaged
+ frames; in the latter case, the frame may be in the midst of
+ changing its size, and curs_x and curs_y may be off the frame. */
+ if (! FRAME_VISIBLE_P (f) || FRAME_GARBAGED_P (f))
return;
/* If cursor is off and we want it off, return quickly. */
if (! f->display.x->icon_label)
f->display.x->icon_label = " *emacs* ";
+#if 0
XSetIconName (x_current_display, FRAME_X_WINDOW (f),
(char *) f->display.x->icon_label);
+#endif
f->display.x->icon_bitmap_flag = 0;
x_wm_set_icon_pixmap (f, 0);
if (icon_font_info == 0)
icon_font_info
= XGetFont (XGetDefault (XDISPLAY
- (char *) XSTRING (invocation_name)->data,
+ (char *) XSTRING (Vinvocation_name)->data,
"BodyFont"));
if (f->display.x->icon_desc)
exit (70);
}
-/* An X error handler which prints an error message and then kills Emacs.
- This is what's normally installed as Xlib's handler for protocol and
- I/O errors. */
+/* An X error handler which prints an error message and then kills
+ Emacs. This is what's normally installed as Xlib's handler for
+ protocol errors. */
static int
x_error_quitter (display, error)
Display *display;
x_connection_closed ();
}
+/* A handler for X IO errors which prints an error message and then
+ kills Emacs. This is what is always installed as Xlib's handler
+ for I/O errors. */
+static int
+x_io_error_quitter (display)
+ Display *display;
+{
+ fprintf (stderr, "Connection to X server %s lost.\n",
+ XDisplayName (DisplayString (display)));
+
+ /* While we're testing Emacs 19, we'll just dump core whenever we
+ get an X error, so we can figure out why it happened. */
+ abort ();
+
+ x_connection_closed ();
+}
+
/* A buffer for storing X error messages. */
static char (*x_caught_error_message)[200];
char buf[256];
sprintf (buf, format, *x_caught_error_message);
- free (x_caught_error_message);
+ xfree (x_caught_error_message);
x_uncatch_errors ();
error (buf);
void
x_uncatch_errors ()
{
- free (x_caught_error_message);
+ xfree (x_caught_error_message);
XHandleError (x_error_quitter);
}
f->display.x->font->fid);
XSetFont (x_current_display, f->display.x->cursor_gc,
f->display.x->font->fid);
+ init_frame_faces (f);
x_set_window_size (f, f->width, f->height);
}
BLOCK_INPUT;
check_frame_size (f, &rows, &cols);
- f->display.x->vertical_scrollbar_extra =
- (FRAME_HAS_VERTICAL_SCROLLBARS (f)
- ? VERTICAL_SCROLLBAR_PIXEL_WIDTH (f)
+ f->display.x->vertical_scroll_bar_extra =
+ (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
+ ? VERTICAL_SCROLL_BAR_PIXEL_WIDTH (f)
: 0);
pixelwidth = CHAR_TO_PIXEL_WIDTH (f, cols);
pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows);
might be kind of confusing to the lisp code, since size changes
wouldn't be reported in the frame parameters until some random
point in the future when the ConfigureNotify event arrives. */
- FRAME_WIDTH (f) = cols;
- FRAME_HEIGHT (f) = rows;
+ change_frame_size (f, rows, cols, 0, 0);
PIXEL_WIDTH (f) = pixelwidth;
PIXEL_HEIGHT (f) = pixelheight;
x_wm_set_window_state (f, NormalState);
XMapWindow (XDISPLAY FRAME_X_WINDOW (f));
- if (FRAME_HAS_VERTICAL_SCROLLBARS (f))
+ if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
XMapSubwindows (x_current_display, FRAME_X_WINDOW (f));
#else /* ! defined (HAVE_X11) */
XMapWindow (XDISPLAY FRAME_X_WINDOW (f));
UNBLOCK_INPUT;
}
-/* Window manager communication. Created in Fx_open_connection. */
-extern Atom Xatom_wm_change_state;
-
/* Change window state from mapped to iconified. */
x_iconify_frame (f)
if (f->display.x->icon_desc != 0)
XDestroyWindow (XDISPLAY f->display.x->icon_desc);
XDestroyWindow (XDISPLAY f->display.x->window_desc);
+ free_frame_faces (f);
XFlushQueue ();
- free (f->display.x);
+ xfree (f->display.x);
f->display.x = 0;
if (f == x_focus_frame)
x_focus_frame = 0;
XSetAfterFunction (x_current_display, x_trace_wire);
#endif /* ! 0 */
- invocation_name = Ffile_name_nondirectory (Fcar (Vcommand_line_args));
-
/* Try to get the host name; if the buffer is too short, try
again. Apparently, the only indication gethostname gives of
whether the buffer was large enough is the presence or absence
hostname_size <<= 1;
hostname = (char *) xrealloc (hostname, hostname_size);
}
- x_id_name = (char *) xmalloc (XSTRING (invocation_name)->size
+ x_id_name = (char *) xmalloc (XSTRING (Vinvocation_name)->size
+ strlen (hostname)
+ 2);
- sprintf (x_id_name, "%s@%s", XSTRING (invocation_name)->data, hostname);
+ sprintf (x_id_name, "%s@%s", XSTRING (Vinvocation_name)->data, hostname);
}
/* Figure out which modifier bits mean what. */
x_find_modifier_meanings ();
- /* Get the scrollbar cursor. */
- x_vertical_scrollbar_cursor =
- XCreateFontCursor (x_current_display, XC_sb_v_double_arrow);
+ /* Get the scroll bar cursor. */
+ x_vertical_scroll_bar_cursor
+ = XCreateFontCursor (x_current_display, XC_sb_v_double_arrow);
+#if 0
/* Watch for PropertyNotify events on the root window; we use them
to figure out when to invalidate our cache of the cut buffers. */
x_watch_cut_buffer_cache ();
+#endif
- dup2 (ConnectionNumber (x_current_display), 0);
+ if (ConnectionNumber (x_current_display) != 0)
+ {
+ dup2 (ConnectionNumber (x_current_display), 0);
#ifndef SYSV_STREAMS
- /* Streams somehow keeps track of which descriptor number
- is being used to talk to X. So it is not safe to substitute
- descriptor 0. But it is safe to make descriptor 0 a copy of it. */
- close (ConnectionNumber (x_current_display));
- ConnectionNumber (x_current_display) = 0; /* Looks a little strange?
+ /* Streams somehow keeps track of which descriptor number
+ is being used to talk to X. So it is not safe to substitute
+ descriptor 0. But it is safe to make descriptor 0 a copy of it. */
+ close (ConnectionNumber (x_current_display));
+ ConnectionNumber (x_current_display) = 0; /* Looks a little strange?
* check the def of the macro;
* it is a genuine lvalue */
#endif /* SYSV_STREAMS */
+ }
#endif /* ! defined (HAVE_X11) */
mouse_position_hook = XTmouse_position;
frame_rehighlight_hook = XTframe_rehighlight;
frame_raise_lower_hook = XTframe_raise_lower;
- set_vertical_scrollbar_hook = XTset_vertical_scrollbar;
- condemn_scrollbars_hook = XTcondemn_scrollbars;
- redeem_scrollbar_hook = XTredeem_scrollbar;
- judge_scrollbars_hook = XTjudge_scrollbars;
+ set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
+ condemn_scroll_bars_hook = XTcondemn_scroll_bars;
+ redeem_scroll_bar_hook = XTredeem_scroll_bar;
+ judge_scroll_bars_hook = XTjudge_scroll_bars;
scroll_region_ok = 1; /* we'll scroll partial frames */
char_ins_del_ok = 0; /* just as fast to write the line */
/* Note that there is no real way portable across R3/R4 to get the
original error handler. */
XHandleError (x_error_quitter);
- XHandleIOError (x_error_quitter);
+ XHandleIOError (x_io_error_quitter);
/* Disable Window Change signals; they are handled by X events. */
#ifdef SIGWINCH
void
syms_of_xterm ()
{
- staticpro (&invocation_name);
- invocation_name = Qnil;
-
- staticpro (&last_mouse_scrollbar);
+ staticpro (&last_mouse_scroll_bar);
}
#endif /* ! defined (HAVE_X11) */
#endif /* ! defined (HAVE_X_WINDOWS) */