/* X Communication module for terminals which understand the X protocol.
- Copyright (C) 1989, 1992 Free Software Foundation, Inc.
+ Copyright (C) 1989, 1992, 1993 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "lisp.h"
-/* On 4.3 this loses if it comes after xterm.h. */
+/* On 4.3 these lose if they come after xterm.h. */
+#include <stdio.h>
#include <signal.h>
/* This may include sys/types.h, and that somehow loses
if this is not done before the other system files. */
#include "xterm.h"
+#include <X11/cursorfont.h>
#ifndef USG
/* Load sys/types.h if not already loaded.
#include "systime.h"
#include <fcntl.h>
-#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <setjmp.h>
#include "frame.h"
#include "disptab.h"
#include "buffer.h"
+#include "window.h"
#ifdef HAVE_X11
#define XMapWindow XMapRaised /* Raise them when mapping. */
/* Nonzero means we must reprint all windows
because 1) we received an ExposeWindow event
- or 2) we received too many ExposeRegion events to record. */
+ or 2) we received too many ExposeRegion events to record.
+ This is never needed under X11. */
static int expose_all_windows;
/* Nonzero means we must reprint all icon windows. */
Display *x_current_display;
+/* 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
XT functions. It is zero while not inside an update.
static 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. */
+ Zero if none. This is examined by Ffocus_frame in frame.c. Note
+ that a mere EnterNotify event can set this; if you need to know the
+ last frame specified in a FocusIn or FocusOut event, use
+ x_focus_event_frame. */
struct frame *x_focus_frame;
+/* The last frame mentioned in a FocusIn or FocusOut event. This is
+ separate from x_focus_frame, because whether or not LeaveNotify
+ events cause us to lose focus depends on whether or not we have
+ received a FocusIn event for it. */
+struct frame *x_focus_event_frame;
+
/* The frame which currently has the visual highlight, and should get
keyboard input (other sorts of input have the frame encoded in the
event). It points to the X focus frame's selected window's
extern int errno;
+/* See keyboard.c. */
+extern int extra_keyboard_modifiers;
+
extern Display *XOpenDisplay ();
extern Window XCreateWindow ();
static int XTclear_end_of_line ();
\f
-/* These hooks are called by update_frame at the beginning and end
+/* Starting and ending updates.
+
+ These hooks are called by update_frame at the beginning and end
of a frame update. We record in `updating_frame' the identity
of the frame being updated, so that the XT... functions do not
need to take a frame as argument. Most of the XT... functions
UNBLOCK_INPUT;
}
+#ifndef HAVE_X11
static void x_do_pending_expose ();
+#endif
static
XTupdate_end (f)
BLOCK_INPUT;
#ifndef HAVE_X11
dumpqueue ();
-#endif /* HAVE_X11 */
- adjust_scrollbars (f);
x_do_pending_expose ();
+#endif /* HAVE_X11 */
x_display_cursor (f, 1);
/* XTclear_frame (); */
}
\f
-/* Set the nominal cursor position of the frame:
- where display update commands will take effect.
+/* Set the nominal cursor position of the frame.
+ This is where display update commands will take effect.
This does not affect the place where the cursor-box is displayed. */
static int
}
#endif /* ! 0 */
\f
-/* Output some text at the nominal frame cursor position,
- advancing the cursor over the text.
+/* Output some text at the nominal frame cursor position.
+ Advance the cursor over the text.
Output LEN glyphs at START.
`highlight', set up by XTreassert_line_highlight or XTchange_line_highlight,
}
dumpglyphs (f,
- (curs_x * FONT_WIDTH (f->display.x->font)
- + f->display.x->internal_border_width),
- (curs_y * FONT_HEIGHT (f->display.x->font)
- + f->display.x->internal_border_width),
- start, len, highlight, f->display.x->font);
+ CHAR_TO_PIXEL_COL (f, curs_x),
+ CHAR_TO_PIXEL_ROW (f, curs_y),
+ start, len, highlight, f->display.x->font);
/* If we drew on top of the cursor, note that it is turned off. */
if (curs_y == f->phys_cursor_y
UNBLOCK_INPUT;
}
\f
-/* Erase the current text line from the nominal cursor position (inclusive)
+/* Clear to the end of the line.
+ Erase the current text line from the nominal cursor position (inclusive)
to column FIRST_UNUSED (exclusive). The idea is that everything
from FIRST_UNUSED onward is already erased. */
#ifdef HAVE_X11
XClearArea (x_current_display, FRAME_X_WINDOW (f),
- curs_x * FONT_WIDTH (f->display.x->font)
- + f->display.x->internal_border_width,
- curs_y * FONT_HEIGHT (f->display.x->font)
- + f->display.x->internal_border_width,
+ CHAR_TO_PIXEL_COL (f, curs_x),
+ CHAR_TO_PIXEL_ROW (f, curs_y),
FONT_WIDTH (f->display.x->font) * (first_unused - curs_x),
FONT_HEIGHT (f->display.x->font), False);
#else /* ! defined (HAVE_X11) */
XPixSet (FRAME_X_WINDOW (f),
- curs_x * FONT_WIDTH (f->display.x->font) + f->display.x->internal_border_width,
- curs_y * FONT_HEIGHT (f->display.x->font) + f->display.x->internal_border_width,
+ CHAR_TO_PIXEL_COL (f, curs_x),
+ CHAR_TO_PIXEL_ROW (f, curs_y),
FONT_WIDTH (f->display.x->font) * (first_unused - curs_x),
FONT_HEIGHT (f->display.x->font),
f->display.x->background_pixel);
curs_y = 0;
BLOCK_INPUT;
+
XClear (FRAME_X_WINDOW (f));
+
+ /* We have to clear the scroll bars, too. If we have changed
+ colors or something like that, then they should be notified. */
+ x_scroll_bar_clear (f);
+
#ifndef HAVE_X11
dumpborder (f, 0);
#endif /* HAVE_X11 */
+
XFlushQueue ();
UNBLOCK_INPUT;
}
\f
-/* Paint horzontal bars down the frame for a visible bell.
- Note that this may be way too slow on some machines. */
+/* Invert the middle quarter of the frame for .15 sec. */
+
+/* We use the select system call to do the waiting, so we have to make sure
+ it's avaliable. If it isn't, we just won't do visual bells. */
+#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
+
+/* Subtract the `struct timeval' values X and Y,
+ storing the result in RESULT.
+ Return 1 if the difference is negative, otherwise 0. */
+
+static int
+timeval_subtract (result, x, y)
+ struct timeval *result, x, y;
+{
+ /* Perform the carry for the later subtraction by updating y.
+ This is safer because on some systems
+ the tv_sec member is unsigned. */
+ if (x.tv_usec < y.tv_usec)
+ {
+ int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1;
+ y.tv_usec -= 1000000 * nsec;
+ y.tv_sec += nsec;
+ }
+ if (x.tv_usec - y.tv_usec > 1000000)
+ {
+ int nsec = (y.tv_usec - x.tv_usec) / 1000000;
+ y.tv_usec += 1000000 * nsec;
+ y.tv_sec -= nsec;
+ }
+
+ /* Compute the time remaining to wait. tv_usec is certainly positive. */
+ result->tv_sec = x.tv_sec - y.tv_sec;
+ result->tv_usec = x.tv_usec - y.tv_usec;
+
+ /* Return indication of whether the result should be considered negative. */
+ return x.tv_sec < y.tv_sec;
+}
XTflash (f)
struct frame *f;
{
- register struct frame_glyphs *active_frame = FRAME_CURRENT_GLYPHS (f);
- register int i;
- int x, y;
+ BLOCK_INPUT;
- if (updating_frame != 0)
- abort ();
+ {
+ GC gc;
- BLOCK_INPUT;
-#ifdef HAVE_X11
-#if 0
- for (i = f->height * FONT_HEIGHT (f->display.x->font) - 10;
- i >= 0;
- i -= 100) /* Should be NO LOWER than 75 for speed reasons. */
- XFillRectangle (x_current_display, FRAME_X_WINDOW (f),
- f->display.x->cursor_gc,
- 0, i, f->width * FONT_WIDTH (f->display.x->font)
- + 2 * f->display.x->internal_border_width, 25);
-#endif /* ! 0 */
+ /* Create a GC that will use the GXxor function to flip foreground pixels
+ into background pixels. */
+ {
+ XGCValues values;
- x = (f->width * FONT_WIDTH (f->display.x->font)) / 4;
- y = (f->height * FONT_HEIGHT (f->display.x->font)) / 4;
- XFillRectangle (x_current_display, FRAME_X_WINDOW (f),
- f->display.x->cursor_gc,
- x, y, 2 * x, 2 * y);
- dumpglyphs (f, (x + f->display.x->internal_border_width),
- (y + f->display.x->internal_border_width),
- &active_frame->glyphs[(f->height / 4) + 1][(f->width / 4)],
- 1, 0, f->display.x->font);
+ values.function = GXxor;
+ values.foreground = (f->display.x->foreground_pixel
+ ^ f->display.x->background_pixel);
+
+ gc = XCreateGC (x_current_display, FRAME_X_WINDOW (f),
+ GCFunction | GCForeground, &values);
+ }
-#else /* ! defined (HAVE_X11) */
- for (i = f->height * FONT_HEIGHT (f->display.x->font) - 10;
- i >= 0;
- i -= 50)
- XPixFill (FRAME_X_WINDOW (f), 0, i,
- f->width * FONT_WIDTH (f->display.x->font)
- + 2 * f->display.x->internal_border_width, 10,
- WHITE_PIX_DEFAULT, ClipModeClipped, GXinvert, AllPlanes);
-#endif /* ! defined (HAVE_X11) */
+ {
+ int width = PIXEL_WIDTH (f);
+ int height = PIXEL_HEIGHT (f);
- XFlushQueue ();
- UNBLOCK_INPUT;
-}
+ XFillRectangle (x_current_display, FRAME_X_WINDOW (f), gc,
+ width/4, height/4, width/2, height/2);
+ XFlush (x_current_display);
-/* Flip background and forground colors of the frame. */
+ {
+ struct timeval wakeup, now;
-x_invert_frame (f)
- struct frame *f;
-{
-#ifdef HAVE_X11
- GC temp;
- unsigned long pix_temp;
+ gettimeofday (&wakeup, (struct timezone *) 0);
- x_display_cursor (f, 0);
- XClearWindow (x_current_display, FRAME_X_WINDOW (f));
- temp = f->display.x->normal_gc;
- f->display.x->normal_gc = f->display.x->reverse_gc;
- f->display.x->reverse_gc = temp;
- pix_temp = f->display.x->foreground_pixel;
- f->display.x->foreground_pixel = f->display.x->background_pixel;
- f->display.x->background_pixel = pix_temp;
-
- XSetWindowBackground (x_current_display, FRAME_X_WINDOW (f),
- f->display.x->background_pixel);
- if (f->display.x->background_pixel == f->display.x->cursor_pixel)
- {
- f->display.x->cursor_pixel = f->display.x->foreground_pixel;
- XSetBackground (x_current_display, f->display.x->cursor_gc,
- f->display.x->cursor_pixel);
- XSetForeground (x_current_display, f->display.x->cursor_gc,
- f->display.x->background_pixel);
+ /* Compute time to wait until, propagating carry from usecs. */
+ wakeup.tv_usec += 150000;
+ wakeup.tv_sec += (wakeup.tv_usec / 1000000);
+ wakeup.tv_usec %= 1000000;
+
+ /* Keep waiting until past the time wakeup. */
+ while (1)
+ {
+ struct timeval timeout;
+
+ gettimeofday (&timeout, (struct timezone *)0);
+
+ /* In effect, timeout = wakeup - timeout.
+ Break if result would be negative. */
+ if (timeval_subtract (&timeout, wakeup, timeout))
+ break;
+
+ /* Try to wait that long--but we might wake up sooner. */
+ select (0, 0, 0, 0, &timeout);
+ }
+ }
+
+ XFillRectangle (x_current_display, FRAME_X_WINDOW (f), gc,
+ width/4, height/4, width/2, height/2);
+ XFreeGC (x_current_display, gc);
+ XFlush (x_current_display);
}
- redraw_frame (f);
-#endif /* ! defined (HAVE_X11) */
+ }
+
+ UNBLOCK_INPUT;
}
+#endif
+
+
/* Make audible bell. */
#ifdef HAVE_X11
XTring_bell ()
{
+#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
if (visible_bell)
-#if 0
XTflash (selected_frame);
-#endif /* ! 0 */
- {
- x_invert_frame (selected_frame);
- x_invert_frame (selected_frame);
- }
else
+#endif
{
BLOCK_INPUT;
XRINGBELL;
}
}
\f
-/* Insert and delete character are not supposed to be used
- because we are supposed to turn off the feature of using them. */
+/* Insert and delete character.
+ These are not supposed to be used because we are supposed to turn
+ off the feature of using them. */
static
XTinsert_glyphs (start, len)
flexlines = n;
}
\f
-/* Perform an insert-lines operation, inserting N lines
- at a vertical position curs_y. */
+/* Perform an insert-lines operation.
+ Insert N lines at a vertical position curs_y. */
static void
stufflines (n)
#ifdef HAVE_X11
XCopyArea (x_current_display, FRAME_X_WINDOW (f),
FRAME_X_WINDOW (f), f->display.x->normal_gc,
- intborder, topregion * FONT_HEIGHT (f->display.x->font) + intborder,
+ intborder, CHAR_TO_PIXEL_ROW (f, topregion),
f->width * FONT_WIDTH (f->display.x->font),
length * FONT_HEIGHT (f->display.x->font), intborder,
- newtop * FONT_HEIGHT (f->display.x->font) + intborder);
+ CHAR_TO_PIXEL_ROW (f, newtop));
#else /* ! defined (HAVE_X11) */
XMoveArea (FRAME_X_WINDOW (f),
- intborder, topregion * FONT_HEIGHT (f->display.x->font) + intborder,
- intborder, newtop * FONT_HEIGHT (f->display.x->font) + intborder,
+ intborder, CHAR_TO_PIXEL_ROW (f, topregion),
+ intborder, CHAR_TO_PIXEL_ROW (f, newtop),
f->width * FONT_WIDTH (f->display.x->font),
length * FONT_HEIGHT (f->display.x->font));
/* Now we must process any ExposeRegion events that occur
{
#ifdef HAVE_X11
XClearArea (x_current_display, FRAME_X_WINDOW (f), intborder,
- topregion * FONT_HEIGHT (f->display.x->font) + intborder,
+ CHAR_TO_PIXEL_ROW (f, topregion),
f->width * FONT_WIDTH (f->display.x->font),
n * FONT_HEIGHT (f->display.x->font), False);
#else /* ! defined (HAVE_X11) */
XPixSet (FRAME_X_WINDOW (f),
intborder,
- topregion * FONT_HEIGHT (f->display.x->font) + intborder,
+ CHAR_TO_PIXEL_ROW (f, topregion),
f->width * FONT_WIDTH (f->display.x->font),
n * FONT_HEIGHT (f->display.x->font),
f->display.x->background_pixel);
{
#ifdef HAVE_X11
XClearArea (x_current_display, FRAME_X_WINDOW (f), intborder,
- curs_y * FONT_HEIGHT (f->display.x->font) + intborder,
+ CHAR_TO_PIXEL_ROW (f, curs_y),
f->width * FONT_WIDTH (f->display.x->font),
(flexlines - curs_y) * FONT_HEIGHT (f->display.x->font), False);
#else /* ! defined (HAVE_X11) */
XPixSet (FRAME_X_WINDOW (f),
- intborder, curs_y * FONT_HEIGHT (f->display.x->font) + intborder,
+ intborder, CHAR_TO_PIXEL_ROW (f, curs_y),
f->width * FONT_WIDTH (f->display.x->font),
(flexlines - curs_y) * FONT_HEIGHT (f->display.x->font),
f->display.x->background_pixel);
XCopyArea (x_current_display, FRAME_X_WINDOW (f),
FRAME_X_WINDOW (f), f->display.x->normal_gc,
intborder,
- (curs_y + n) * FONT_HEIGHT (f->display.x->font) + intborder,
+ CHAR_TO_PIXEL_ROW (f, curs_y + n),
f->width * FONT_WIDTH (f->display.x->font),
(flexlines - (curs_y + n)) * FONT_HEIGHT (f->display.x->font),
- intborder, curs_y * FONT_HEIGHT (f->display.x->font) + intborder);
+ intborder, CHAR_TO_PIXEL_ROW (f, curs_y));
XClearArea (x_current_display, FRAME_X_WINDOW (f),
intborder,
- (flexlines - n) * FONT_HEIGHT (f->display.x->font) + intborder,
+ CHAR_TO_PIXEL_ROW (f, flexlines - n),
f->width * FONT_WIDTH (f->display.x->font),
n * FONT_HEIGHT (f->display.x->font), False);
#else /* ! defined (HAVE_X11) */
XMoveArea (FRAME_X_WINDOW (f),
intborder,
- (curs_y + n) * FONT_HEIGHT (f->display.x->font) + intborder,
- intborder, curs_y * FONT_HEIGHT (f->display.x->font) + intborder,
+ CHAR_TO_PIXEL_ROW (f, curs_y + n),
+ intborder, CHAR_TO_PIXEL_ROW (f, curs_y),
f->width * FONT_WIDTH (f->display.x->font),
(flexlines - (curs_y + n)) * FONT_HEIGHT (f->display.x->font));
/* Now we must process any ExposeRegion events that occur
may want to copy this area to another area. */
x_read_exposes ();
XPixSet (FRAME_X_WINDOW (f), intborder,
- (flexlines - n) * FONT_HEIGHT (f->display.x->font) + intborder,
+ CHAR_TO_PIXEL_ROW (f, flexlines - n),
f->width * FONT_WIDTH (f->display.x->font),
n * FONT_HEIGHT (f->display.x->font), f->display.x->background_pixel);
#endif /* ! defined (HAVE_X11) */
UNBLOCK_INPUT;
}
\f
+/* Support routines for exposure events. */
static void clear_cursor ();
/* Output into a rectangle of an X-window (for frame F)
if (FRAME_GARBAGED_P (f))
return;
- top -= f->display.x->internal_border_width;
- left -= f->display.x->internal_border_width;
-
/* Express rectangle as four edges, instead of position-and-size. */
bottom = top + rows;
right = left + cols;
#ifndef HAVE_X11 /* Window manger does this for X11. */
- /* If the rectangle includes any of the internal border area,
- redisplay the border emphasis. */
- if (top < 0 || left < 0
- || bottom > f->height * FONT_HEIGHT (f->display.x->font)
- || right > f->width * FONT_WIDTH (f->display.x->font))
- dumpborder (f, 0);
+ {
+ int intborder = f->display.x->internal_border_width;
+
+ /* If the rectangle includes any of the internal border area,
+ redisplay the border emphasis. */
+ if (top < intborder || left < intborder
+ || bottom > intborder + f->height * FONT_HEIGHT (f->display.x->font)
+ || right > intborder + f->width * FONT_WIDTH (f->display.x->font))
+ dumpborder (f, 0);
+ }
#endif /* HAVE_X11 /* Window manger does this for X11. */ */
/* Convert rectangle edges in pixels to edges in chars.
Round down for left and top, up for right and bottom. */
- top /= FONT_HEIGHT (f->display.x->font);
- left /= FONT_WIDTH (f->display.x->font);
+ top = PIXEL_TO_CHAR_ROW (f, top);
+ left = PIXEL_TO_CHAR_COL (f, left);
bottom += (FONT_HEIGHT (f->display.x->font) - 1);
right += (FONT_WIDTH (f->display.x->font) - 1);
- bottom /= FONT_HEIGHT (f->display.x->font);
- right /= FONT_WIDTH (f->display.x->font);
+ bottom = PIXEL_TO_CHAR_ROW (f, bottom);
+ right = PIXEL_TO_CHAR_COL (f, right);
/* Clip the rectangle to what can be visible. */
if (left < 0)
continue;
dumpglyphs (f,
- (left * FONT_WIDTH (f->display.x->font)
- + f->display.x->internal_border_width),
- (y * FONT_HEIGHT (f->display.x->font)
- + f->display.x->internal_border_width),
- line, min (cols, active_frame->used[y] - left),
- active_frame->highlight[y], f->display.x->font);
+ 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);
}
/* Turn the cursor on if we turned it off. */
}
#endif /* HAVE_X11 */
\f
-/* Process all expose events that are pending.
+/* Process all expose events that are pending, for X10.
Redraws the cursor if necessary on any frame that
is not in the process of being updated with update_frame. */
+#ifndef HAVE_X11
static void
x_do_pending_expose ()
{
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))
continue;
- if (!f->visible)
+ if (!f->async_visible)
continue;
if (!f->display.x->needs_exposure)
continue;
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;
dumpqueue ();
#endif /* ! defined (HAVE_X11) */
}
+#endif
#ifdef HAVE_X11
static void
}
-/* The focus has changed, or we have make a frame's selected window
- point to a window on a different frame (this happens with global
- minibuffer frames). Shift the highlight as appropriate. */
+/* The focus has changed, or we have redirected a frame's focus to
+ another frame (this happens when a frame uses a surrogate
+ minibuffer frame). Shift the highlight as appropriate. */
static void
XTframe_rehighlight ()
{
if (x_focus_frame)
{
- x_highlight_frame = XFRAME (FRAME_FOCUS_FRAME (x_focus_frame));
- if (x_highlight_frame->display.nothing == 0)
- XSET (FRAME_FOCUS_FRAME (x_focus_frame), Lisp_Frame,
- (x_highlight_frame = x_focus_frame));
+ x_highlight_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))
+ {
+ FRAME_FOCUS_FRAME (x_focus_frame) = Qnil;
+ x_highlight_frame = x_focus_frame;
+ }
}
else
x_highlight_frame = 0;
}
}
\f
-enum window_type
-{
- no_window,
- scrollbar_window,
- text_window,
-};
-
-/* Position of the mouse in characters */
-unsigned int x_mouse_x, x_mouse_y;
-
-/* Offset in buffer of character under the pointer, or 0. */
-extern int mouse_buffer_offset;
-
-extern int buffer_posn_from_coords ();
-
-/* Symbols from xfns.c to denote the different parts of a window. */
-extern Lisp_Object Qmodeline_part, Qtext_part;
-
-#if 0
-/* Set *RESULT to an emacs input_event corresponding to MOTION_EVENT.
- F is the frame in which the event occurred.
-
- WINDOW_TYPE says whether the event happened in a scrollbar window
- or a text window, affecting the format of the event created.
-
- PART specifies which part of the scrollbar the event happened in,
- if WINDOW_TYPE == scrollbar_window.
-
- If the mouse is over the same character as the last time we checked,
- don't return an event; set result->kind to no_event. */
-
-static void
-notice_mouse_movement (result, motion_event, f, window_type, part)
- struct input_event *result;
- XMotionEvent motion_event;
- struct frame *f;
- int window_type;
- Lisp_Object part;
-{
- int x, y, root_x, root_y, pix_x, pix_y;
- unsigned int keys_and_buttons;
- Window w, root_window;
-
- /* Unless we decide otherwise below, return a non-event. */
- result->kind = no_event;
-
- if (XQueryPointer (x_current_display,
- FRAME_X_WINDOW (f),
- &root_window, &w,
- &root_x, &root_y, &pix_x, &pix_y,
- &keys_and_buttons)
- == False)
- return;
-
-#if 0
- if (w == None) /* Mouse no longer in window. */
- return Qnil;
-#endif /* ! 0 */
-
- pixel_to_glyph_translation (f, pix_x, pix_y, &x, &y);
- if (x == x_mouse_x && y == x_mouse_y)
- return;
-
- x_mouse_x = x;
- x_mouse_y = y;
-
- /* What sort of window are we in now? */
- if (window_type == text_window) /* Text part */
- {
- int modeline_p;
-
- Vmouse_window = window_from_coordinates (f, x, y, &modeline_p);
-
- if (XTYPE (Vmouse_window) == Lisp_Window)
- mouse_buffer_offset
- = buffer_posn_from_coords (XWINDOW (Vmouse_window), x, y);
- else
- mouse_buffer_offset = 0;
-
- if (EQ (Vmouse_window, Qnil))
- Vmouse_frame_part = Qnil;
- else if (modeline_p)
- Vmouse_frame_part = Qmodeline_part;
- else
- Vmouse_frame_part = Qtext_part;
-
- result->kind = window_sys_event;
- result->code = Qmouse_moved;
-
- return;
- }
- else if (window_type == scrollbar_window) /* Scrollbar */
- {
- Vmouse_window = f->selected_window;
- mouse_buffer_offset = 0;
- Vmouse_frame_part = part;
-
- result->kind = window_sys_event;
- result->code = Qmouse_moved;
-
- return;
- }
-
- return;
-}
-#endif /* ! 0 */
-
-\f
/* Mouse clicks and mouse movement. Rah. */
#ifdef HAVE_X11
register int *x, *y;
XRectangle *bounds;
{
- int ibw = f->display.x->internal_border_width;
- int width, height;
- FONT_TYPE *font = f->display.x->font;
-
- width = FONT_WIDTH (font);
- height = FONT_HEIGHT (font);
-
- /* What line is it on? */
- if (pix_y < ibw)
- *y = 0;
- else if (pix_y > f->display.x->pixel_height - ibw)
- *y = FRAME_HEIGHT (f) - 1;
- else
- *y = (pix_y - ibw) / height;
-
- /* And what column? */
- if (pix_x < ibw)
- *x = 0;
- else if (pix_x > f->display.x->pixel_width - ibw)
- *x = FRAME_WIDTH (f) - 1;
- else
- *x = (pix_x - ibw) / width;
+ pix_x = PIXEL_TO_CHAR_COL (f, pix_x);
+ pix_y = PIXEL_TO_CHAR_ROW (f, pix_y);
if (bounds)
{
- bounds->width = width;
- bounds->height = height;
- bounds->x = ibw + (*x * width);
- bounds->y = ibw + (*y * height);
+ bounds->width = FONT_WIDTH (f->display.x->font);
+ bounds->height = FONT_HEIGHT (f->display.x->font);
+ bounds->x = CHAR_TO_PIXEL_COL (f, pix_x);
+ bounds->y = CHAR_TO_PIXEL_ROW (f, pix_y);
}
+
+ if (pix_x < 0) pix_x = 0;
+ else if (pix_x > f->width) pix_x = f->width;
+
+ if (pix_y < 0) pix_y = 0;
+ else if (pix_y > f->height) pix_y = f->height;
+
+ *x = pix_x;
+ *y = pix_y;
}
/* Any buttons grabbed. */
/* Which modifier keys are on which modifier bits?
With each keystroke, X returns eight bits indicating which modifier
- keys were held down when the key was pressed. The low three bits
- indicate the state of the shift, shift lock, caps lock, and control
- keys; their interpretation is fixed. However, the interpretation
- of the other five modifier bits depends on what keys are attached
+ keys were held down when the key was pressed. The interpretation
+ of the top five modifier bits depends on what keys are attached
to them. If the Meta_L and Meta_R keysyms are on mod5, then mod5
is the meta bit.
x_meta_mod_mask is a mask containing the bits used for the meta key.
It may have more than one bit set, if more than one modifier bit
has meta keys on it. Basically, if EVENT is a KeyPress event,
- the meta key is pressed if (EVENT.state & x_meta_mod_mask) != 0. */
-static int x_meta_mod_mask;
+ the meta key is pressed if (EVENT.state & x_meta_mod_mask) != 0.
+
+ x_shift_lock_mask is LockMask if the XK_Shift_Lock keysym is on the
+ lock modifier bit, or zero otherwise. Non-alphabetic keys should
+ only be affected by the lock modifier bit if XK_Shift_Lock is in
+ use; XK_Caps_Lock should only affect alphabetic keys. With this
+ arrangement, the lock modifier should shift the character if
+ (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 ()
{
- KeyCode min_code, max_code;
+ int min_code, max_code;
KeySym *syms;
int syms_per_code;
XModifierKeymap *mods;
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;
XDisplayKeycodes (x_current_display, &min_code, &max_code);
syms = XGetKeyboardMapping (x_current_display,
&syms_per_code);
mods = XGetModifierMapping (x_current_display);
- /* If CapsLock is on the lock modifier, then only letters should be
- affected; since XLookupString takes care of this for us, the lock
- modifier shouldn't set shift_modifier. However, if ShiftLock is
- on the lock modifier, then lock should mean shift. */
+ /* Scan the modifier table to see which modifier bits the Meta and
+ Alt keysyms are on. */
{
int row, col; /* The row and column in the modifier table. */
for (code_col = 0; code_col < syms_per_code; code_col++)
{
- int sym = syms[(code * syms_per_code) + code_col];
+ int sym = syms[((code - min_code) * syms_per_code) + code_col];
- if (sym == XK_Meta_L || sym == XK_Meta_R)
+ switch (sym)
{
+ case XK_Meta_L:
+ case XK_Meta_R:
x_meta_mod_mask |= (1 << row);
break;
+
+ case XK_Alt_L:
+ case XK_Alt_R:
+ 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:
+ /* Ignore this if it's not on the lock modifier. */
+ if ((1 << row) == LockMask)
+ x_shift_lock_mask = LockMask;
+ break;
}
}
}
}
}
+ /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
+ if (! x_meta_mod_mask)
+ {
+ x_meta_mod_mask = x_alt_mod_mask;
+ x_alt_mod_mask = 0;
+ }
+
XFree ((char *) syms);
- XFreeModifierMap (mods);
+ XFreeModifiermap (mods);
}
/* Convert a set of X modifier bits to the proper form for a
struct input_event modifiers value. */
-static Lisp_Object
+static unsigned int
x_convert_modifiers (state)
unsigned int state;
{
- return ( ((state & (ShiftMask | LockMask)) ? shift_modifier : 0)
- | ((state & ControlMask) ? ctrl_modifier : 0)
- | ((state & x_meta_mod_mask) ? meta_modifier : 0));
+ 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_alt_mod_mask) ? alt_modifier : 0)
+ | ((state & x_super_mod_mask) ? super_modifier : 0)
+ | ((state & x_hyper_mod_mask) ? hyper_modifier : 0));
}
-extern struct frame *x_window_to_scrollbar ();
-extern Lisp_Object Vmouse_event;
-
/* Prepare a mouse-event in *RESULT for placement in the input queue.
If the event is a button press, then note that we have grabbed
- the mouse.
-
- If PART and PREFIX are 0, then the event occurred in the text part;
- otherwise it happened in a scrollbar. */
+ the mouse. */
static Lisp_Object
-construct_mouse_click (result, event, f, part, prefix)
+construct_mouse_click (result, event, f)
struct input_event *result;
XButtonEvent *event;
struct frame *f;
- int prefix;
- Lisp_Object part;
{
- /* Initialize those fields text and scrollbar clicks hold in common.
- Make the event type no_event; we'll change that when we decide
+ /* Make the event type no_event; we'll change that when we decide
otherwise. */
- result->kind = no_event;
- XSET (result->code, Lisp_Int, event->button);
+ result->kind = mouse_click;
+ XSET (result->code, Lisp_Int, event->button - Button1);
result->timestamp = event->time;
result->modifiers = (x_convert_modifiers (event->state)
- | (event->type == ButtonRelease ? up_modifier : 0));
+ | (event->type == ButtonRelease
+ ? up_modifier
+ : down_modifier));
/* Notice if the mouse is still grabbed. */
if (event->type == ButtonPress)
Vmouse_depressed = Qnil;
}
- if (part) /* Scrollbar event */
- {
- int pos, len;
-
- pos = event->y - (f->display.x->v_scrollbar_width - 2);
- XSET (x_mouse_x, Lisp_Int, pos);
- len = ((FONT_HEIGHT (f->display.x->font) * f->height)
- + f->display.x->internal_border_width
- - (2 * (f->display.x->v_scrollbar_width - 2)));
- XSET (x_mouse_y, Lisp_Int, len);
-
- result->kind = scrollbar_click;
- result->part = part;
- XSET (result->x, Lisp_Int, (f->display.x->top_pos - event->y));
- XSET (result->y, Lisp_Int, f->display.x->pixel_height);
- result->frame = f;
- }
- else /* Text Window Event */
- {
- int row, column;
+ {
+ int row, column;
- pixel_to_glyph_coords (f, event->x, event->y, &column, &row, NULL);
- result->kind = mouse_click;
- result->x = column;
- result->y = row;
- result->frame = f;
- }
+ pixel_to_glyph_coords (f, event->x, event->y, &column, &row, NULL);
+ XFASTINT (result->x) = column;
+ XFASTINT (result->y) = row;
+ XSET (result->frame_or_window, Lisp_Frame, f);
+ }
}
static FRAME_PTR last_mouse_frame;
static XRectangle last_mouse_glyph;
+/* The scroll bar in which the last X motion event occurred.
+
+ 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 scroll bar, we set this
+ to Qnil, to tell XTmouse_position to return an ordinary motion event. */
+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
doesn't seem to be any way to wrest the timestamp from the server
the mainstream emacs code by setting mouse_moved. If not, ask for
another motion event, so we can check again the next time it moves. */
static void
-note_mouse_position (frame, event)
+note_mouse_movement (frame, event)
FRAME_PTR frame;
XMotionEvent *event;
|| event->x >= last_mouse_glyph.x + last_mouse_glyph.width
|| event->y < last_mouse_glyph.y
|| event->y >= last_mouse_glyph.y + last_mouse_glyph.height)
- mouse_moved = 1;
+ {
+ mouse_moved = 1;
+ last_mouse_scroll_bar = Qnil;
+ }
else
{
/* It's on the same glyph. Call XQueryPointer so we'll get an
}
}
+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 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 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
+ the mouse is over.
+
+ Set *time to the server timestamp for the time at which the mouse
+ was at this position.
+
This clears the mouse_moved flag, so we can wait for the next mouse
- position. This also calls XQueryPointer, which will cause the
- server to give us another MotionNotify when the mouse moves again.
- */
+ movement. This also calls XQueryPointer, which will cause the
+ server to give us another MotionNotify when the mouse moves
+ again. */
+
+static void
+XTmouse_position (f, bar_window, part, x, y, time)
+ FRAME_PTR *f;
+ Lisp_Object *bar_window;
+ enum scroll_bar_part *part;
+ Lisp_Object *x, *y;
+ unsigned long *time;
+{
+ BLOCK_INPUT;
+
+ if (! NILP (last_mouse_scroll_bar))
+ x_scroll_bar_report_motion (f, bar_window, part, x, y, time);
+ else
+ {
+ Window root;
+ int root_x, root_y;
+
+ Window dummy_window;
+ int dummy;
+
+ mouse_moved = 0;
+ last_mouse_scroll_bar = Qnil;
+
+ /* Figure out which root window we're on. */
+ XQueryPointer (x_current_display,
+ DefaultRootWindow (x_current_display),
+
+ /* The root window which contains the pointer. */
+ &root,
+
+ /* Trash which we can't trust if the pointer is on
+ a different screen. */
+ &dummy_window,
+
+ /* The position on that root window. */
+ &root_x, &root_y,
+
+ /* More trash we can't trust. */
+ &dummy, &dummy,
+
+ /* Modifier keys and pointer buttons, about which
+ we don't care. */
+ (unsigned int *) &dummy);
+
+ /* Now we have a position on the root; find the innermost window
+ containing the pointer. */
+ {
+ Window win, child;
+ int win_x, win_y;
+ int parent_x, parent_y;
+
+ win = root;
+ for (;;)
+ {
+ XTranslateCoordinates (x_current_display,
+
+ /* From-window, to-window. */
+ root, win,
+
+ /* From-position, to-position. */
+ root_x, root_y, &win_x, &win_y,
+
+ /* Child of win. */
+ &child);
+
+ if (child == None)
+ break;
+
+ win = child;
+ parent_x = win_x;
+ parent_y = win_y;
+ }
+
+ /* Now we know that:
+ win is the innermost window containing the pointer
+ (XTC says it has no child containing the pointer),
+ win_x and win_y are the pointer's position in it
+ (XTC did this the last time through), and
+ parent_x and parent_y are the pointer's position in win's parent.
+ (They are what win_x and win_y were when win was child.
+ If win is the root window, it has no parent, and
+ parent_{x,y} are invalid, but that's okay, because we'll
+ never use them in that case.) */
+
+ /* Is win one of our frames? */
+ *f = x_window_to_frame (win);
+
+ /* If not, is it one of our scroll bars? */
+ if (! *f)
+ {
+ struct scroll_bar *bar = x_window_to_scroll_bar (win);
+
+ if (bar)
+ {
+ *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+ win_x = parent_x;
+ win_y = parent_y;
+ }
+ }
+
+ if (*f)
+ {
+ pixel_to_glyph_coords (*f, win_x, win_y, &win_x, &win_y,
+ &last_mouse_glyph);
+
+ *bar_window = Qnil;
+ *part = 0;
+ XSET (*x, Lisp_Int, win_x);
+ XSET (*y, Lisp_Int, win_y);
+ *time = last_mouse_movement_time;
+ }
+ }
+ }
+
+ UNBLOCK_INPUT;
+}
+
+#else /* ! defined (HAVE_X11) */
+#define XEvent XKeyPressedEvent
+#endif /* ! defined (HAVE_X11) */
+\f
+/* Scroll bar support. */
+
+/* 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;
+ 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 (XGCTYPE (frame) != Lisp_Frame)
+ abort ();
+
+ /* Scan this frame's scroll bar list for a scroll bar with the
+ right window ID. */
+ 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 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 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 scroll_bar *bar =
+ XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
+
+ BLOCK_INPUT;
+
+ {
+ XSetWindowAttributes a;
+ unsigned long mask;
+
+ a.background_pixel = frame->display.x->background_pixel;
+ a.event_mask = (ButtonPressMask | ButtonReleaseMask
+ | ButtonMotionMask | PointerMotionHintMask
+ | ExposureMask);
+ a.cursor = x_vertical_scroll_bar_cursor;
+
+ mask = (CWBackPixel | CWEventMask | CWCursor);
+
+ SET_SCROLL_BAR_X_WINDOW
+ (bar,
+ XCreateWindow (x_current_display, FRAME_X_WINDOW (frame),
+
+ /* Position and size of scroll bar. */
+ left, top, width, height,
+
+ /* Border width, depth, class, and visual. */
+ 0, CopyFromParent, CopyFromParent, CopyFromParent,
+
+ /* Attributes. */
+ mask, &a));
+ }
+
+ XSET (bar->window, Lisp_Window, window);
+ XSET (bar->top, Lisp_Int, top);
+ XSET (bar->left, Lisp_Int, left);
+ XSET (bar->width, Lisp_Int, width);
+ XSET (bar->height, Lisp_Int, height);
+ XSET (bar->start, Lisp_Int, 0);
+ XSET (bar->end, Lisp_Int, 0);
+ bar->dragging = Qnil;
+
+ /* Add bar to its frame's list of scroll bars. */
+ bar->next = FRAME_SCROLL_BARS (frame);
+ bar->prev = Qnil;
+ XSET (FRAME_SCROLL_BARS (frame), Lisp_Vector, bar);
+ if (! NILP (bar->next))
+ XSET (XSCROLL_BAR (bar->next)->prev, Lisp_Vector, bar);
+
+ XMapWindow (x_current_display, SCROLL_BAR_X_WINDOW (bar));
+
+ UNBLOCK_INPUT;
+
+ return bar;
+}
+
+/* Draw BAR's handle in the proper position.
+ If the handle is already drawn from START to END, don't bother
+ redrawing it, unless REBUILD is non-zero; in that case, always
+ redraw it. (REBUILD is handy for drawing the handle after expose
+ 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 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_scroll_bar_set_handle (bar, start, end, rebuild)
+ struct scroll_bar *bar;
+ int start, end;
+ int rebuild;
+{
+ int dragging = ! NILP (bar->dragging);
+ 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. */
+ if (! rebuild
+ && start == XINT (bar->start)
+ && end == XINT (bar->end))
+ return;
+
+ BLOCK_INPUT;
+
+ {
+ 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. */
+ {
+ int length = end - start;
+
+ if (start < 0)
+ start = 0;
+ else if (start > top_range)
+ start = top_range;
+ end = start + length;
+
+ if (end < start)
+ end = start;
+ else if (end > top_range && ! dragging)
+ end = top_range;
+ }
+
+ /* Store the adjusted setting in the scroll bar. */
+ XSET (bar->start, Lisp_Int, start);
+ XSET (bar->end, Lisp_Int, end);
+
+ /* Clip the end position, just for display. */
+ if (end > top_range)
+ end = top_range;
+
+ /* 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_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." */
+ if (0 < start)
+ XClearArea (x_current_display, w,
+
+ /* x, y, width, height, and exposures. */
+ VERTICAL_SCROLL_BAR_LEFT_BORDER,
+ VERTICAL_SCROLL_BAR_TOP_BORDER,
+ inside_width, start,
+ False);
+
+ /* Draw the handle itself. */
+ XFillRectangle (x_current_display, w, gc,
+
+ /* x, y, width, height */
+ VERTICAL_SCROLL_BAR_LEFT_BORDER,
+ VERTICAL_SCROLL_BAR_TOP_BORDER + start,
+ inside_width, end - start);
+
+
+ /* Draw the empty space below the handle. Note that we can't
+ clear zero-height areas; that means "clear to end of window." */
+ if (end < inside_height)
+ XClearArea (x_current_display, w,
+
+ /* x, y, width, height, and exposures. */
+ VERTICAL_SCROLL_BAR_LEFT_BORDER,
+ VERTICAL_SCROLL_BAR_TOP_BORDER + end,
+ inside_width, inside_height - end,
+ False);
+
+ }
+
+ UNBLOCK_INPUT;
+}
+
+/* Move a scroll bar around on the screen, to accomodate changing
+ window configurations. */
+static void
+x_scroll_bar_move (bar, top, left, width, height)
+ struct scroll_bar *bar;
+ int top, left, width, height;
+{
+ BLOCK_INPUT;
+
+ {
+ XWindowChanges wc;
+ unsigned int mask = 0;
+
+ wc.x = left;
+ wc.y = top;
+ wc.width = width;
+ wc.height = height;
+
+ if (left != XINT (bar->left)) mask |= CWX;
+ if (top != XINT (bar->top)) mask |= CWY;
+ if (width != XINT (bar->width)) mask |= CWWidth;
+ if (height != XINT (bar->height)) mask |= CWHeight;
+
+ if (mask)
+ XConfigureWindow (x_current_display, SCROLL_BAR_X_WINDOW (bar),
+ mask, &wc);
+ }
+
+ XSET (bar->left, Lisp_Int, left);
+ XSET (bar->top, Lisp_Int, top);
+ XSET (bar->width, Lisp_Int, width);
+ XSET (bar->height, Lisp_Int, height);
+
+ UNBLOCK_INPUT;
+}
+
+/* Destroy the X window for BAR, and set its Emacs window's scroll bar
+ to nil. */
+static void
+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, SCROLL_BAR_X_WINDOW (bar));
+
+ /* 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 scroll bar,
+ create one. */
+static void
+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_SCROLL_BAR_COLUMN (window);
+ int height = WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window);
+
+ /* 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_SCROLL_BAR_PIXEL_WIDTH (f);
+ int pixel_height = VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f, height);
+
+ struct scroll_bar *bar;
+
+ /* 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 = XSCROLL_BAR (window->vertical_scroll_bar);
+ x_scroll_bar_move (bar, pixel_top, pixel_left, pixel_width, pixel_height);
+ }
+
+ /* Set the scroll bar's current state, unless we're currently being
+ dragged. */
+ if (NILP (bar->dragging))
+ {
+ int top_range =
+ VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height);
+
+ if (whole == 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_scroll_bar_set_handle (bar, start, end, 0);
+ }
+ }
+
+ 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 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* 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 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_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_SCROLL_BARS (frame)))
+ abort ();
+
+ /* Move them all to the "condemned" list. */
+ FRAME_CONDEMNED_SCROLL_BARS (frame) = FRAME_SCROLL_BARS (frame);
+ FRAME_SCROLL_BARS (frame) = Qnil;
+}
+
+/* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
+ Note that WINDOW isn't necessarily condemned at all. */
+static void
+XTredeem_scroll_bar (window)
+ struct window *window;
+{
+ struct scroll_bar *bar;
+
+ /* We can't redeem this window's scroll bar if it doesn't have one. */
+ if (NILP (window->vertical_scroll_bar))
+ abort ();
+
+ bar = XSCROLL_BAR (window->vertical_scroll_bar);
+
+ /* Unlink it from the condemned list. */
+ {
+ FRAME_PTR f = XFRAME (WINDOW_FRAME (window));
+
+ if (NILP (bar->prev))
+ {
+ /* If the prev pointer is nil, it must be the first in one of
+ the lists. */
+ 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),
+ 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
+ XSCROLL_BAR (bar->prev)->next = bar->next;
+
+ if (! NILP (bar->next))
+ XSCROLL_BAR (bar->next)->prev = bar->prev;
+
+ bar->next = FRAME_SCROLL_BARS (f);
+ bar->prev = Qnil;
+ XSET (FRAME_SCROLL_BARS (f), Lisp_Vector, bar);
+ if (! NILP (bar->next))
+ XSET (XSCROLL_BAR (bar->next)->prev, Lisp_Vector, bar);
+ }
+}
+
+/* Remove all scroll bars on FRAME that haven't been saved since the
+ last call to `*condemn_scroll_bars_hook'. */
+static void
+XTjudge_scroll_bars (f)
+ FRAME_PTR f;
+{
+ Lisp_Object bar, next;
+
+ 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 scroll bars. */
+ FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil;
+
+ for (; ! NILP (bar); bar = next)
+ {
+ struct scroll_bar *b = XSCROLL_BAR (bar);
+
+ x_scroll_bar_remove (b);
+
+ next = b->next;
+ b->next = b->prev = Qnil;
+ }
+
+ /* 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 scroll bar.
+
+ This may be called from a signal handler, so we have to ignore GC
+ mark bits. */
+static void
+x_scroll_bar_expose (bar, event)
+ struct scroll_bar *bar;
+ XEvent *event;
+{
+ Window w = SCROLL_BAR_X_WINDOW (bar);
+ GC gc = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))->display.x->normal_gc;
+
+ BLOCK_INPUT;
+
+ x_scroll_bar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);
+
+ /* Draw a one-pixel border just inside the edges of the scroll bar. */
+ XDrawRectangle (x_current_display, w, gc,
+
+ /* x, y, width, height */
+ 0, 0, XINT (bar->width) - 1, XINT (bar->height) - 1);
+
+ /* Draw another line to make the extra-thick border on the right. */
+ XFillRectangle (x_current_display, w, gc,
+
+ /* x, y, width, height */
+ XINT (bar->width) - 2, 1, 1, XINT (bar->height) - 2);
+
+ UNBLOCK_INPUT;
+}
+
+/* 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_scroll_bar_handle_click (bar, event, emacs_event)
+ struct scroll_bar *bar;
+ XEvent *event;
+ struct input_event *emacs_event;
+{
+ if (XGCTYPE (bar->window) != Lisp_Window)
+ abort ();
+
+ 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)
+ | (event->type == ButtonRelease
+ ? up_modifier
+ : down_modifier));
+ emacs_event->frame_or_window = bar->window;
+ emacs_event->timestamp = event->xbutton.time;
+ {
+ int internal_height =
+ VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar->height));
+ int top_range =
+ 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 = 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 = 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 == 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. */
+ if (event->type == ButtonRelease
+ && ! NILP (bar->dragging))
+ {
+ int new_start = y - XINT (bar->dragging);
+ int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
+
+ 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 == scroll_bar_handle)
+ emacs_event->x = bar->start;
+ else
+ XSET (emacs_event->x, Lisp_Int, y);
+
+ XSET (emacs_event->y, Lisp_Int, top_range);
+ }
+}
+
+/* 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_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_scroll_bar, Lisp_Vector, bar);
+
+ /* If we're dragging the bar, display it. */
+ if (! GC_NILP (bar->dragging))
+ {
+ /* Where should the handle be now? */
+ int new_start = event->xmotion.y - XINT (bar->dragging);
+
+ if (new_start != XINT (bar->start))
+ {
+ int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
+
+ x_scroll_bar_set_handle (bar, new_start, new_end, 0);
+ }
+ }
+
+ /* Call XQueryPointer so we'll get an event the next time the mouse
+ moves and we can see *still* on the same position. */
+ {
+ int dummy;
+
+ XQueryPointer (event->xmotion.display, event->xmotion.window,
+ (Window *) &dummy, (Window *) &dummy,
+ &dummy, &dummy, &dummy, &dummy,
+ (unsigned int *) &dummy);
+ }
+}
+/* Return information to the user about the current position of the mouse
+ on the scroll bar. */
static void
-XTmouse_position (f, x, y, time)
+x_scroll_bar_report_motion (f, bar_window, part, x, y, time)
FRAME_PTR *f;
+ Lisp_Object *bar_window;
+ enum scroll_bar_part *part;
Lisp_Object *x, *y;
unsigned long *time;
{
- int ix, iy, dummy;
- Display *d = x_current_display;
- Window guess, root, child;
+ struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
+ int win_x, win_y;
BLOCK_INPUT;
- /* I would like to have an X function that just told me the
- innermost window containing the mouse.
-
- /* There doesn't seem to be any way to just get the innermost window
- containing the pointer, no matter what X frame it's on; you have
- to guess a window, and then X will tell you which one of that
- window's children it's in. If the pointer isn't in any of that
- window's children, it gives you a root window that contains it.
-
- So we start with the selected frame's window and chase down
- branches under the guidance of XQueryPointer until we hit a leaf
- (all of the Emacs windows we care about are leaf windows). If at
- any time XQueryPointer returns false, that means that the current
- window does not contain the pointer any more (perhaps it moved),
- so we start with the root window XQueryPointer has given us and
- start again. */
-
- guess = FRAME_X_WINDOW (selected_frame);
- for (;;)
- if (XQueryPointer (d, guess, &root, &child,
- &dummy, &dummy, &ix, &iy, (unsigned int *) &dummy))
+ /* Get the mouse's position relative to the scroll bar window, and
+ report that. */
+ {
+ Window dummy_window;
+ int dummy_coord;
+ unsigned int dummy_mask;
+
+ if (! XQueryPointer (x_current_display,
+ SCROLL_BAR_X_WINDOW (bar),
+
+ /* Root, child, root x and root y. */
+ &dummy_window, &dummy_window,
+ &dummy_coord, &dummy_coord,
+
+ /* Position relative to scroll bar. */
+ &win_x, &win_y,
+
+ /* Mouse buttons and modifier keys. */
+ &dummy_mask))
{
- if (child == None)
- /* Guess is a leaf window, and it contains the pointer. */
- break;
- else
- guess = child;
+ *f = 0;
+ goto done;
}
+ }
+
+ {
+ 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_SCROLL_BAR_TOP_BORDER;
+
+ if (! NILP (bar->dragging))
+ win_y -= XINT (bar->dragging);
+
+ if (win_y < 0)
+ win_y = 0;
+ if (win_y > top_range)
+ win_y = top_range;
+
+ *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
+ *bar_window = bar->window;
+
+ if (! NILP (bar->dragging))
+ *part = scroll_bar_handle;
+ else if (win_y < XINT (bar->start))
+ *part = scroll_bar_above_handle;
+ else if (win_y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
+ *part = scroll_bar_handle;
else
- /* When XQueryPointer returns False, the pointer isn't in guess
- anymore, but root is the root window of the frame we should
- try instead. */
- guess = root;
-
- *f = last_mouse_frame = x_window_to_frame (guess);
- if (! *f)
- *x = *y = Qnil;
- else
- {
- pixel_to_glyph_coords (*f, ix, iy, &ix, &iy, &last_mouse_glyph);
- XSET (*x, Lisp_Int, ix);
- XSET (*y, Lisp_Int, iy);
- }
+ *part = scroll_bar_below_handle;
- mouse_moved = 0;
+ XSET (*x, Lisp_Int, win_y);
+ XSET (*y, Lisp_Int, top_range);
+ *time = last_mouse_movement_time;
+ }
- /* I don't know how to find the time for the last movement; it seems
- like XQueryPointer ought to return it, but it doesn't. So, we'll
- return the time of the last MotionNotify event we received. Note
- that the use of motion hints means that this isn't guaranteed to
- be accurate at all. */
- *time = last_mouse_movement_time;
+ mouse_moved = 0;
+ last_mouse_scroll_bar = Qnil;
+ done:
UNBLOCK_INPUT;
}
-#else /* ! defined (HAVE_X11) */
-#define XEvent XKeyPressedEvent
-#endif /* ! defined (HAVE_X11) */
+
+/* The screen has been cleared so we may have changed foreground or
+ 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_scroll_bar_clear (f)
+ FRAME_PTR f;
+{
+ Lisp_Object bar;
+
+ for (bar = FRAME_SCROLL_BARS (f);
+ XTYPE (bar) == Lisp_Vector;
+ bar = XSCROLL_BAR (bar)->next)
+ XClearArea (x_current_display, SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)),
+ 0, 0, 0, 0, True);
+}
+
+
\f
+/* The main X event-reading loop - XTread_socket. */
/* Timestamp of enter window event. This is only used by XTread_socket,
but we have to put it out here, since static variables within functions
sometimes don't work. */
static Time enter_timestamp;
+/* This holds the state XLookupString needs to implement dead keys
+ and other tricks known as "compose processing". _X Window System_
+ says that a portable program can't use this, but Stephen Gildea assures
+ me that letting the compiler initialize it to zeros will work okay.
+
+ This must be defined outside of XTread_socket, for the same reasons
+ given for enter_timestamp, above. */
+static XComposeStatus compose_status;
+
/* Communication with window managers. */
Atom Xatom_wm_protocols;
WAITP is nonzero if we should block until input arrives.
EXPECTED is nonzero if the caller knows input is available. */
-Lisp_Object
+int
XTread_socket (sd, bufp, numchars, waitp, expected)
register int sd;
register struct input_event *bufp;
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)
{
f = x_window_to_frame (event.xexpose.window);
if (f)
{
- if (f->visible == 0)
+ if (f->async_visible == 0)
{
- f->visible = 1;
- f->iconified = 0;
+ f->async_visible = 1;
+ f->async_iconified = 0;
SET_FRAME_GARBAGED (f);
}
else
- dumprectangle (x_window_to_frame (event.xexpose.window),
- event.xexpose.x, event.xexpose.y,
- event.xexpose.width, event.xexpose.height);
+ {
+ dumprectangle (x_window_to_frame (event.xexpose.window),
+ event.xexpose.x, event.xexpose.y,
+ event.xexpose.width, event.xexpose.height);
+ }
+ }
+ else
+ {
+ struct scroll_bar *bar
+ = x_window_to_scroll_bar (event.xexpose.window);
+
+ if (bar)
+ x_scroll_bar_expose (bar, &event);
}
break;
case GraphicsExpose: /* This occurs when an XCopyArea's
source area was obscured or not
available.*/
- dumprectangle (x_window_to_frame (event.xgraphicsexpose.drawable),
- event.xgraphicsexpose.x, event.xgraphicsexpose.y,
- event.xgraphicsexpose.width,
- event.xgraphicsexpose.height);
+ f = x_window_to_frame (event.xgraphicsexpose.drawable);
+ if (f)
+ {
+ dumprectangle (f,
+ event.xgraphicsexpose.x, event.xgraphicsexpose.y,
+ event.xgraphicsexpose.width,
+ event.xgraphicsexpose.height);
+ }
break;
case NoExpose: /* This occurs when an XCopyArea's
if (event.window == f->display.x->icon_desc)
{
refreshicon (f);
- f->iconified = 1;
+ f->async_iconified = 1;
}
if (event.window == FRAME_X_WINDOW (f))
{
/* Say must check all windows' needs_exposure flags. */
expose_all_windows = 1;
f->display.x->needs_exposure = 1;
- f->visible = 1;
+ f->async_visible = 1;
}
break;
#ifdef HAVE_X11
case UnmapNotify:
- {
- XWMHints *hints;
-
- f = x_window_to_frame (event.xunmap.window);
- if (f) /* F may no longer exist if
+ f = x_window_to_frame (event.xunmap.window);
+ if (f) /* F may no longer exist if
the frame was deleted. */
- {
- /* While a frame is unmapped, display generation is
- disabled; you don't want to spend time updating a
- display that won't ever be seen. */
- f->visible = 0;
- x_mouse_x = x_mouse_y = -1;
- }
- }
+ {
+ /* While a frame is unmapped, display generation is
+ disabled; you don't want to spend time updating a
+ display that won't ever be seen. */
+ f->async_visible = 0;
+ }
break;
case MapNotify:
f = x_window_to_frame (event.xmap.window);
if (f)
{
- f->visible = 1;
- f->iconified = 0;
+ f->async_visible = 1;
+ f->async_iconified = 0;
/* wait_reading_process_input will notice this and update
the frame's display structures. */
case UnmapWindow:
f = x_window_to_frame (event.window);
if (event.window == f->display.x->icon_desc)
- f->iconified = 0;
+ f->async_iconified = 0;
if (event.window == FRAME_X_WINDOW (f))
- f->visible = 0;
+ f->async_visible = 0;
break;
#endif /* ! defined (HAVE_X11) */
#ifdef HAVE_X11
case KeyPress:
f = x_window_to_frame (event.xkey.window);
+
if (f != 0)
{
KeySym keysym;
- XComposeStatus status;
char copy_buffer[80];
- int modifiers = event.xkey.state;
+ int modifiers;
+
+ event.xkey.state |= extra_keyboard_modifiers;
+ modifiers = event.xkey.state;
/* Some keyboards generate different characters
depending on the state of the meta key, in an attempt
just clear the meta-key flag to get the 'pure' character. */
event.xkey.state &= ~Mod1Mask;
- /* This will have to go some day... */
- nbytes = XLookupString (&event.xkey,
- copy_buffer,
- 80,
- &keysym,
- &status);
+ /* This will have to go some day... */
+ nbytes =
+ XLookupString (&event.xkey, copy_buffer, 80, &keysym,
+ &compose_status);
/* Strip off the vendor-specific keysym bit, and take a shot
at recognizing the codes. HP servers have extra keysyms
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 */
{
bufp->kind = non_ascii_keystroke;
- XSET (bufp->code, Lisp_Int, (unsigned) keysym - 0xff50);
- bufp->frame = f;
+ XSET (bufp->code, Lisp_Int, (unsigned) keysym - 0xff00);
+ XSET (bufp->frame_or_window, Lisp_Frame, f);
bufp->modifiers = x_convert_modifiers (modifiers);
bufp->timestamp = event.xkey.time;
bufp++;
if (nbytes == 1)
{
- if (modifiers & Mod1Mask)
- *copy_buffer |= METABIT;
bufp->kind = ascii_keystroke;
XSET (bufp->code, Lisp_Int, *copy_buffer);
- bufp->frame = f;
+ XSET (bufp->frame_or_window, Lisp_Frame, f);
+ bufp->modifiers = x_convert_modifiers (modifiers);
bufp->timestamp = event.xkey.time;
bufp++;
}
{
bufp->kind = ascii_keystroke;
XSET (bufp->code, Lisp_Int, copy_buffer[i]);
- bufp->frame = f;
+ XSET (bufp->frame_or_window, Lisp_Frame, f);
+ bufp->modifiers = x_convert_modifiers (modifiers);
bufp->timestamp = event.xkey.time;
bufp++;
}
bufp->kind = ascii_keystroke;
XSET (bufp->code, Lisp_Int, where_mapping[i]);
XSET (bufp->time, Lisp_Int, event.xkey.time);
- bufp->frame = f;
+ XSET (bufp->frame_or_window, Lisp_Frame, f);
bufp++;
}
count += nbytes;
#endif /* ! defined (HAVE_X11) */
#ifdef HAVE_X11
+
+ /* Here's a possible interpretation of the whole
+ FocusIn-EnterNotify FocusOut-LeaveNotify mess. If you get a
+ FocusIn event, you have to get a FocusOut event before you
+ relinquish the focus. If you haven't received a FocusIn event,
+ then a mere LeaveNotify is enough to free you. */
+
case EnterNotify:
f = x_window_to_frame (event.xcrossing.window);
- if (event.xcrossing.detail == NotifyInferior) /* Left Scrollbar */
- ;
- else if (event.xcrossing.focus) /* Entered Window */
+ if (event.xcrossing.focus) /* Entered Window */
{
- /* If we decide we want to generate an event to be seen
- by the rest of Emacs, we put it here. */
- struct input_event emacs_event;
- emacs_event.kind = no_event;
-
/* Avoid nasty pop/raise loops. */
if (f && (!(f->auto_raise)
|| !(f->auto_lower)
x_new_focus_frame (f);
enter_timestamp = event.xcrossing.time;
}
-#if 0
- else if ((f = x_window_to_scrollbar (event.xcrossing.window,
- &part, &prefix)))
- /* Fake a motion event */
- notice_mouse_movement (&emacs_event,
- event.xmotion, f, scrollbar_window,
- part);
-#endif /* ! 0 */
-
-#if 0
- if (! EQ (Vx_send_mouse_movement_events, Qnil)
- && numchars >= 1
- && emacs_event.kind != no_event)
- {
- bcopy (&emacs_event, bufp, sizeof (struct input_event));
- bufp++;
- count++;
- numchars--;
- }
-#endif /* ! 0 */
}
else if (f == x_focus_frame)
x_new_focus_frame (0);
-#if 0
- else if (f = x_window_to_frame (event.xcrossing.window))
- x_mouse_frame = f;
-#endif /* ! 0 */
break;
case FocusIn:
f = x_window_to_frame (event.xfocus.window);
+ if (event.xfocus.detail != NotifyPointer)
+ x_focus_event_frame = f;
if (f)
x_new_focus_frame (f);
break;
+
case LeaveNotify:
- if (event.xcrossing.detail != NotifyInferior
- && event.xcrossing.subwindow == None
- && event.xcrossing.mode == NotifyNormal)
- {
- f = x_window_to_frame (event.xcrossing.window);
+ f = x_window_to_frame (event.xcrossing.window);
- if (event.xcrossing.focus)
+ if (event.xcrossing.focus)
+ {
+ if (! x_focus_event_frame)
+ x_new_focus_frame (0);
+ else
x_new_focus_frame (f);
- else if (f == x_focus_frame)
+ }
+ else
+ {
+ if (f == x_focus_event_frame)
+ x_focus_event_frame = 0;
+ if (f == x_focus_frame)
x_new_focus_frame (0);
}
break;
case FocusOut:
f = x_window_to_frame (event.xfocus.window);
+ if (event.xfocus.detail != NotifyPointer
+ && f == x_focus_event_frame)
+ x_focus_event_frame = 0;
if (f && f == x_focus_frame)
x_new_focus_frame (0);
break;
{
f = x_window_to_frame (event.xmotion.window);
if (f)
- note_mouse_position (f, &event.xmotion);
-#if 0
- else if ((f = x_window_to_scrollbar (event.xmotion.window,
- &part, &prefix)))
+ note_mouse_movement (f, &event.xmotion);
+ else
{
- What should go here?
+ struct scroll_bar *bar =
+ x_window_to_scroll_bar (event.xmotion.window);
+
+ if (bar)
+ x_scroll_bar_note_movement (bar, &event);
}
-#endif /* ! 0 */
}
break;
case ConfigureNotify:
- {
- int rows, columns;
- f = x_window_to_frame (event.xconfigure.window);
- if (!f)
- break;
-
- columns = ((event.xconfigure.width -
- (2 * f->display.x->internal_border_width)
- - f->display.x->v_scrollbar_width)
- / FONT_WIDTH (f->display.x->font));
- rows = ((event.xconfigure.height -
- (2 * f->display.x->internal_border_width)
- - f->display.x->h_scrollbar_height)
- / FONT_HEIGHT (f->display.x->font));
-
- /* Even if the number of character rows and columns has
- not changed, the font size may have changed, so we need
- to check the pixel dimensions as well. */
- if (columns != f->width
- || rows != f->height
- || event.xconfigure.width != f->display.x->pixel_width
- || event.xconfigure.height != f->display.x->pixel_height)
- {
- change_frame_size (f, rows, columns, 0, 1);
- x_resize_scrollbars (f);
- SET_FRAME_GARBAGED (f);
- }
+ f = x_window_to_frame (event.xconfigure.window);
+ if (f)
+ {
+ int rows = PIXEL_TO_CHAR_HEIGHT (f, event.xconfigure.height);
+ int columns = PIXEL_TO_CHAR_WIDTH (f, event.xconfigure.width);
+
+ /* Even if the number of character rows and columns has
+ not changed, the font size may have changed, so we need
+ to check the pixel dimensions as well. */
+ if (columns != f->width
+ || rows != f->height
+ || event.xconfigure.width != f->display.x->pixel_width
+ || event.xconfigure.height != f->display.x->pixel_height)
+ {
+ change_frame_size (f, rows, columns, 0, 1);
+ SET_FRAME_GARBAGED (f);
+ }
- f->display.x->pixel_width = event.xconfigure.width;
- f->display.x->pixel_height = event.xconfigure.height;
- f->display.x->left_pos = event.xconfigure.x;
- f->display.x->top_pos = event.xconfigure.y;
- break;
- }
+ f->display.x->pixel_width = event.xconfigure.width;
+ f->display.x->pixel_height = event.xconfigure.height;
+ f->display.x->left_pos = event.xconfigure.x;
+ f->display.x->top_pos = event.xconfigure.y;
+ }
+ break;
case ButtonPress:
case ButtonRelease:
f = x_window_to_frame (event.xbutton.window);
if (f)
- if (!x_focus_frame || (f == x_focus_frame))
- construct_mouse_click (&emacs_event,
- &event, f, 0, 0);
- else
- continue;
+ {
+ if (!x_focus_frame || (f == x_focus_frame))
+ construct_mouse_click (&emacs_event,
+ &event, f);
+ }
else
- if ((f = x_window_to_scrollbar (event.xbutton.window,
- &part, &prefix)))
- {
- if (!x_focus_frame || (selected_frame == x_focus_frame))
- construct_mouse_click (&emacs_event,
- &event, f, part, prefix);
- else
- continue;
- }
+ {
+ struct scroll_bar *bar =
+ x_window_to_scroll_bar (event.xbutton.window);
+
+ if (bar)
+ x_scroll_bar_handle_click (bar, &event, &emacs_event);
+ }
if (numchars >= 1 && emacs_event.kind != no_event)
{
{
bufp->kind = ascii_keystroke;
bufp->code = (char) 'X' & 037; /* C-x */
- bufp->frame = f;
+ XSET (bufp->frame_or_window, Lisp_Frame, f);
XSET (bufp->time, Lisp_Int, event.xkey.time);
bufp++;
bufp->kind = ascii_keystroke;
bufp->code = (char) 0; /* C-@ */
- bufp->frame = f;
+ XSET (bufp->frame_or_window, Lisp_Frame, f);
XSET (bufp->time, Lisp_Int, event.xkey.time);
bufp++;
#endif /* ! defined (HAVE_X11) */
case MappingNotify:
- if (event.xmapping.request == MappingKeyboard)
- /* Someone has changed the keyboard mapping - flush the
- local cache. */
- XRefreshKeyboardMapping (&event.xmapping);
+ /* Someone has changed the keyboard mapping - update the
+ local cache. */
+ switch (event.xmapping.request)
+ {
+ case MappingModifier:
+ x_find_modifier_meanings ();
+ /* This is meant to fall through. */
+ case MappingKeyboard:
+ XRefreshKeyboardMapping (&event.xmapping);
+ }
break;
default:
#endif /* ! defined (HAVE_SELECT) */
#endif /* ! 0 */
+#ifndef HAVE_X11
if (updating_frame == 0)
x_do_pending_expose ();
+#endif
UNBLOCK_INPUT;
return count;
#endif /* HAVE_X11 */
\f
+/* Drawing the cursor. */
+
+
/* Draw a hollow box cursor. Don't change the inside of the box. */
static void
x_draw_box (f)
struct frame *f;
{
- int left = f->cursor_x * FONT_WIDTH (f->display.x->font)
- + f->display.x->internal_border_width;
- int top = f->cursor_y * FONT_HEIGHT (f->display.x->font)
- + f->display.x->internal_border_width;
+ int left = CHAR_TO_PIXEL_COL (f, f->cursor_x);
+ int top = CHAR_TO_PIXEL_ROW (f, f->cursor_y);
int width = FONT_WIDTH (f->display.x->font);
int height = FONT_HEIGHT (f->display.x->font);
#ifdef HAVE_X11
- /* Perhaps we should subtract 1 from width and height... */
XDrawRectangle (x_current_display, FRAME_X_WINDOW (f),
f->display.x->cursor_gc,
left, top, width - 1, height - 1);
{
int mask;
- if (! f->visible
+ if (! FRAME_VISIBLE_P (f)
|| f->phys_cursor_x < 0)
return;
#ifdef HAVE_X11
x_display_cursor (f, 0);
-#if 0
- XClearArea (x_current_display, FRAME_X_WINDOW (f),
- f->phys_cursor_x * FONT_WIDTH (f->display.x->font)
- + f->display.x->internal_border_width,
- f->phys_cursor_y * FONT_HEIGHT (f->display.x->font)
- + f->display.x->internal_border_width,
- FONT_WIDTH (f->display.x->font) + 1, FONT_HEIGHT (f->display.x->font) + 1, False);
-#endif /* ! 0 */
#else /* ! defined (HAVE_X11) */
XPixSet (FRAME_X_WINDOW (f),
- f->phys_cursor_x * FONT_WIDTH (f->display.x->font) + f->display.x->internal_border_width,
- f->phys_cursor_y * FONT_HEIGHT (f->display.x->font) + f->display.x->internal_border_width,
+ CHAR_TO_PIXEL_COL (f, f->phys_cursor_x),
+ CHAR_TO_PIXEL_ROW (f, f->phys_cursor_y),
FONT_WIDTH (f->display.x->font), FONT_HEIGHT (f->display.x->font),
f->display.x->background_pixel);
#endif /* ! defined (HAVE_X11) */
f->phys_cursor_x = -1;
}
+/* Redraw the glyph at ROW, COLUMN on frame F, in the style
+ HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
+ glyph drawn. */
+
+static void
+x_draw_single_glyph (f, row, column, glyph, highlight)
+ struct frame *f;
+ int row, column;
+ GLYPH glyph;
+ int highlight;
+{
+ dumpglyphs (f,
+ CHAR_TO_PIXEL_COL (f, column),
+ CHAR_TO_PIXEL_ROW (f, row),
+ &glyph, 1, highlight, f->display.x->font);
+}
+
static void
x_display_bar_cursor (f, on)
struct frame *f;
int on;
{
- register int phys_x = f->phys_cursor_x;
- register int phys_y = f->phys_cursor_y;
- register int x1;
- register int y1;
- register int y2;
+ struct frame_glyphs *current_glyphs = FRAME_CURRENT_GLYPHS (f);
+
+ if (! FRAME_VISIBLE_P (f))
+ return;
- if (! f->visible || (! on && f->phys_cursor_x < 0))
+ if (! on && f->phys_cursor_x < 0)
return;
-#ifdef HAVE_X11
- if (phys_x >= 0 &&
- (!on || phys_x != f->cursor_x || phys_y != f->cursor_y))
+ /* If we're not updating, then we want to use the current frame's
+ cursor position, not our local idea of where the cursor ought to be. */
+ if (f != updating_frame)
{
- x1 = phys_x * FONT_WIDTH (f->display.x->font)
- + f->display.x->internal_border_width;
- y1 = phys_y * FONT_HEIGHT (f->display.x->font)
- + f->display.x->internal_border_width - 1;
- y2 = y1 + FONT_HEIGHT (f->display.x->font) + 1;
-
- XDrawLine (x_current_display, FRAME_X_WINDOW (f),
- f->display.x->reverse_gc, x1, y1, x1, y2);
+ curs_x = FRAME_CURSOR_X (f);
+ curs_y = FRAME_CURSOR_Y (f);
+ }
- f->phys_cursor_x = phys_x = -1;
+ /* If there is anything wrong with the current cursor state, remove it. */
+ if (f->phys_cursor_x >= 0
+ && (!on
+ || f->phys_cursor_x != curs_x
+ || f->phys_cursor_y != curs_y
+ || f->display.x->current_cursor != bar_cursor))
+ {
+ /* Erase the cursor by redrawing the character underneath it. */
+ x_draw_single_glyph (f, f->phys_cursor_y, f->phys_cursor_x,
+ f->phys_cursor_glyph,
+ current_glyphs->highlight[f->phys_cursor_y]);
+ f->phys_cursor_x = -1;
}
- if (on && f == x_highlight_frame)
+ /* If we now need a cursor in the new place or in the new form, do it so. */
+ if (on
+ && (f->phys_cursor_x < 0
+ || (f->display.x->current_cursor != bar_cursor)))
{
- x1 = f->cursor_x * FONT_WIDTH (f->display.x->font)
- + f->display.x->internal_border_width;
- y1 = f->cursor_y * FONT_HEIGHT (f->display.x->font)
- + f->display.x->internal_border_width - 1;
- y2 = y1 + FONT_HEIGHT (f->display.x->font) + 1;
+ f->phys_cursor_glyph
+ = ((current_glyphs->enable[curs_y]
+ && curs_x < current_glyphs->used[curs_y])
+ ? current_glyphs->glyphs[curs_y][curs_x]
+ : SPACEGLYPH);
+ XFillRectangle (x_current_display, FRAME_X_WINDOW (f),
+ f->display.x->cursor_gc,
+ CHAR_TO_PIXEL_COL (f, curs_x),
+ CHAR_TO_PIXEL_ROW (f, curs_y),
+ 1, FONT_HEIGHT (f->display.x->font));
- XDrawLine (x_current_display, FRAME_X_WINDOW (f),
- f->display.x->cursor_gc, x1, y1, x1, y2);
+ f->phys_cursor_x = curs_x;
+ f->phys_cursor_y = curs_y;
- f->phys_cursor_x = f->cursor_x;
- f->phys_cursor_y = f->cursor_y;
+ f->display.x->current_cursor = bar_cursor;
}
-#else /* ! defined (HAVE_X11) */
- Give it up, dude.
-#endif /* ! defined (HAVE_X11) */
-}
-
-/* Redraw the glyph at ROW, COLUMN on frame F, in the style
- HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
- glyph drawn. */
-
-static void
-x_draw_single_glyph (f, row, column, glyph, highlight)
- struct frame *f;
- int row, column;
- GLYPH glyph;
- int highlight;
-{
- dumpglyphs (f,
- (column * FONT_WIDTH (f->display.x->font)
- + f->display.x->internal_border_width),
- (row * FONT_HEIGHT (f->display.x->font)
- + f->display.x->internal_border_width),
- &glyph, 1, highlight, f->display.x->font);
+ if (updating_frame != f)
+ XFlushQueue ();
}
+
/* Turn the displayed cursor of frame F on or off according to ON.
If ON is nonzero, where to put the cursor is specified
by F->cursor_x and F->cursor_y. */
{
struct frame_glyphs *current_glyphs = FRAME_CURRENT_GLYPHS (f);
+ if (! FRAME_VISIBLE_P (f))
+ return;
+
+ /* If cursor is off and we want it off, return quickly. */
+ if (!on && f->phys_cursor_x < 0)
+ return;
+
/* If we're not updating, then we want to use the current frame's
cursor position, not our local idea of where the cursor ought to be. */
if (f != updating_frame)
curs_y = FRAME_CURSOR_Y (f);
}
- if (! f->visible)
- return;
-
- /* If cursor is off and we want it off, return quickly. */
- if (!on && f->phys_cursor_x < 0)
- return;
-
/* If cursor is currently being shown and we don't want it to be
or it is in the wrong place,
or we want a hollow box and it's not so, (pout!)
&& (!on
|| f->phys_cursor_x != curs_x
|| f->phys_cursor_y != curs_y
- || (f->display.x->text_cursor_kind != hollow_box_cursor
+ || (f->display.x->current_cursor != hollow_box_cursor
&& (f != x_highlight_frame))))
{
/* Erase the cursor by redrawing the character underneath it. */
write it in the right place. */
if (on
&& (f->phys_cursor_x < 0
- || (f->display.x->text_cursor_kind != filled_box_cursor
+ || (f->display.x->current_cursor != filled_box_cursor
&& f == x_highlight_frame)))
{
f->phys_cursor_glyph
if (f != x_highlight_frame)
{
x_draw_box (f);
- f->display.x->text_cursor_kind = hollow_box_cursor;
+ f->display.x->current_cursor = hollow_box_cursor;
}
else
{
x_draw_single_glyph (f, curs_y, curs_x,
f->phys_cursor_glyph, 2);
- f->display.x->text_cursor_kind = filled_box_cursor;
+ f->display.x->current_cursor = filled_box_cursor;
}
f->phys_cursor_x = curs_x;
XFlushQueue ();
}
-extern Lisp_Object Vbar_cursor;
-
x_display_cursor (f, on)
struct frame *f;
int on;
{
- if (EQ (Vbar_cursor, Qnil))
+ if (FRAME_DESIRED_CURSOR (f) == filled_box_cursor)
x_display_box_cursor (f, on);
- else
+ else if (FRAME_DESIRED_CURSOR (f) == bar_cursor)
x_display_bar_cursor (f, on);
+ else
+ /* Those are the only two we have implemented! */
+ abort ();
}
\f
/* Icons. */
#endif /* ! defined (HAVE_X11) */
}
-/* Make the x-window of frame F use the kitchen-sink icon
- that's a window generated by Emacs. */
+/* Make the x-window of frame F use the gnu icon bitmap. */
int
x_bitmap_icon (f)
if (FRAME_X_WINDOW (f) == 0)
return 1;
- if (icon_font_info == 0)
- icon_font_info
- = XGetFont (XGetDefault (XDISPLAY
- (char *) XSTRING (invocation_name)->data,
- "BodyFont"));
-
#ifdef HAVE_X11
if (icon_name)
f->display.x->icon_label = icon_name;
f->display.x->icon_bitmap_flag = 0;
x_wm_set_icon_pixmap (f, 0);
#else /* ! defined (HAVE_X11) */
+ if (icon_font_info == 0)
+ icon_font_info
+ = XGetFont (XGetDefault (XDISPLAY
+ (char *) XSTRING (invocation_name)->data,
+ "BodyFont"));
+
if (f->display.x->icon_desc)
{
XClearIconWindow (XDISPLAY FRAME_X_WINDOW (f));
\f
/* Handling X errors. */
-/* A handler for SIGPIPE, when it occurs on the X server's connection.
- This basically does an orderly shutdown of Emacs. */
+/* Shut down Emacs in an orderly fashion, because of a SIGPIPE on the
+ X server's connection, or an error reported via the X protocol. */
static SIGTYPE
x_connection_closed ()
{
if (_Xdebug)
abort ();
- else
- Fkill_emacs (make_number (70));
+
+ shut_down_emacs (0);
+
+ 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;
fprintf (stderr, "X protocol error: %s on protocol request %d\n",
buf, error->request_code);
+ /* 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 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 ();
}
#endif /* ! 0 */
\f
+/* Changing the font of the frame. */
+
/* Set the font of the x-window specified by frame F
to the font named NEWNAME. This is safe to use
even before F has an actual x-window. */
}
#endif /* ! defined (HAVE_X11) */
\f
+/* X Window sizes and positions. */
+
x_calc_absolute_position (f)
struct frame *f;
{
#ifdef HAVE_X11
if (f->display.x->left_pos < 0)
f->display.x->left_pos
- = XINT (x_screen_width) - PIXEL_WIDTH (f) + f->display.x->left_pos;
+ = x_screen_width - PIXEL_WIDTH (f) + f->display.x->left_pos;
if (f->display.x->top_pos < 0)
f->display.x->top_pos
- = XINT (x_screen_height) - PIXEL_HEIGHT (f) + f->display.x->top_pos;
+ = x_screen_height - PIXEL_HEIGHT (f) + f->display.x->top_pos;
#else /* ! defined (HAVE_X11) */
WINDOWINFO_TYPE parentinfo;
{
int pixelwidth, pixelheight;
int mask;
- int ibw = f->display.x->internal_border_width;
BLOCK_INPUT;
check_frame_size (f, &rows, &cols);
- pixelwidth = (cols * FONT_WIDTH (f->display.x->font) + 2 * ibw
- + f->display.x->v_scrollbar_width);
- pixelheight = (rows * FONT_HEIGHT (f->display.x->font) + 2 * ibw
- + f->display.x->h_scrollbar_height);
+ 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);
#ifdef HAVE_X11
x_wm_set_size_hint (f, 0);
/* Now, strictly speaking, we can't be sure that this is accurate,
but the window manager will get around to dealing with the size
change request eventually, and we'll hear how it went when the
- ConfigureNotify event gets here. */
- FRAME_WIDTH (f) = cols;
- FRAME_WIDTH (f) = rows;
+ ConfigureNotify event gets here.
+
+ We could just not bother storing any of this information here,
+ and let the ConfigureNotify event set everything up, but that
+ 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. */
+ change_frame_size (f, rows, cols, 0, 0);
PIXEL_WIDTH (f) = pixelwidth;
PIXEL_HEIGHT (f) = pixelheight;
+ /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
+ receive in the ConfigureNotify event; if we get what we asked
+ for, then the event won't cause the screen to become garbaged, so
+ we have to make sure to do it here. */
+ SET_FRAME_GARBAGED (f);
+
XFlushQueue ();
UNBLOCK_INPUT;
}
x_set_resize_hint (f)
struct frame *f;
{
-
- XSetResizeHint (FRAME_X_WINDOW (f), 2 * f->display.x->internal_border_width,
+ XSetResizeHint (FRAME_X_WINDOW (f),
2 * f->display.x->internal_border_width,
- FONT_WIDTH (f->display.x->font), FONT_HEIGHT (f->display.x->font));
+ 2 * f->display.x->internal_border_width,
+ FONT_WIDTH (f->display.x->font),
+ FONT_HEIGHT (f->display.x->font));
}
#endif /* HAVE_X11 */
\f
+/* Mouse warping, focus shifting, raising and lowering. */
x_set_mouse_position (f, x, y)
struct frame *f;
x_raise_frame (f);
- if (x < 0)
- pix_x = (FRAME_WIDTH (f)
- * FONT_WIDTH (f->display.x->font)
- + 2 * f->display.x->internal_border_width
- + f->display.x->v_scrollbar_width) / 2;
- else
- pix_x = x * FONT_WIDTH (f->display.x->font) + 2; /* add 2 pixels to each
- dimension to move the
- mouse into the char
- cell */
-
- if (y < 0)
- pix_y = (FRAME_HEIGHT (f)
- * FONT_HEIGHT (f->display.x->font)
- + 2 * f->display.x->internal_border_width
- + f->display.x->h_scrollbar_height) / 2;
- else
- pix_y = y * FONT_HEIGHT (f->display.x->font) + 2;
+ pix_x = CHAR_TO_PIXEL_COL (f, x) + FONT_WIDTH (f->display.x->font) / 2;
+ pix_y = CHAR_TO_PIXEL_ROW (f, y) + FONT_HEIGHT (f->display.x->font) / 2;
+
+ if (pix_x < 0) pix_x = 0;
+ if (pix_x > PIXEL_WIDTH (f)) pix_x = PIXEL_WIDTH (f);
+
+ if (pix_y < 0) pix_y = 0;
+ if (pix_y > PIXEL_HEIGHT (f)) pix_y = PIXEL_HEIGHT (f);
BLOCK_INPUT;
- x_mouse_x = x;
- x_mouse_y = y;
XWarpMousePointer (FRAME_X_WINDOW (f), pix_x, pix_y);
UNBLOCK_INPUT;
x_raise_frame (f)
struct frame *f;
{
- if (f->visible)
+ if (f->async_visible)
{
BLOCK_INPUT;
XRaiseWindow (XDISPLAY FRAME_X_WINDOW (f));
x_lower_frame (f)
struct frame *f;
{
- if (f->visible)
+ if (f->async_visible)
{
BLOCK_INPUT;
XLowerWindow (XDISPLAY FRAME_X_WINDOW (f));
}
}
+static void
+XTframe_raise_lower (f, raise)
+ FRAME_PTR f;
+ int raise;
+{
+ if (raise)
+ x_raise_frame (f);
+ else
+ x_lower_frame (f);
+}
+
+
/* Change from withdrawn state to mapped state. */
x_make_frame_visible (f)
x_wm_set_window_state (f, NormalState);
XMapWindow (XDISPLAY FRAME_X_WINDOW (f));
- if (f->display.x->v_scrollbar != 0 || f->display.x->h_scrollbar != 0)
+ 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));
XUnmapWindow (f->display.x->icon_desc);
/* Handled by the MapNotify event for X11 */
- f->visible = 1;
- f->iconified = 0;
+ f->async_visible = 1;
+ f->async_iconified = 0;
/* NOTE: this may cause problems for the first frame. */
XTcursor_to (0, 0);
{
int mask;
- if (! f->visible)
+ if (! f->async_visible)
return;
BLOCK_INPUT;
#else /* ! defined (HAVE_X11) */
XUnmapWindow (FRAME_X_WINDOW (f));
- f->visible = 0; /* Handled by the UnMap event for X11 */
+ f->async_visible = 0; /* Handled by the UnMap event for X11 */
if (f->display.x->icon_desc != 0)
XUnmapWindow (f->display.x->icon_desc);
{
int mask;
- if (f->iconified)
+ if (f->async_iconified)
return;
BLOCK_INPUT;
IconicState. */
x_wm_set_window_state (f, IconicState);
- f->iconified = 1;
+ f->async_iconified = 1;
#else /* ! defined (HAVE_X11) */
XUnmapWindow (XDISPLAY FRAME_X_WINDOW (f));
- f->visible = 0; /* Handled in the UnMap event for X11. */
+ f->async_visible = 0; /* Handled in the UnMap event for X11. */
if (f->display.x->icon_desc != 0)
{
XMapWindow (XDISPLAY f->display.x->icon_desc);
UNBLOCK_INPUT;
}
-/* Destroy the X window of frame F.
- DISPL is the former f->display (since f->display
- has already been nulled out). */
+/* Destroy the X window of frame F. */
-x_destroy_window (f, displ)
+x_destroy_window (f)
struct frame *f;
- union display displ;
{
- int mask;
-
BLOCK_INPUT;
- if (displ.x->icon_desc != 0)
- XDestroyWindow (XDISPLAY displ.x->icon_desc);
- XDestroyWindow (XDISPLAY displ.x->window_desc);
+
+ if (f->display.x->icon_desc != 0)
+ XDestroyWindow (XDISPLAY f->display.x->icon_desc);
+ XDestroyWindow (XDISPLAY f->display.x->window_desc);
XFlushQueue ();
- UNBLOCK_INPUT;
- free (displ.x);
+ free (f->display.x);
+ f->display.x = 0;
if (f == x_focus_frame)
x_focus_frame = 0;
if (f == x_highlight_frame)
x_highlight_frame = 0;
+
+ UNBLOCK_INPUT;
}
\f
+/* Manage event queues for X10. */
+
#ifndef HAVE_X11
/* Manage event queues.
}
#endif /* HAVE_X11 */
\f
+/* Setting window manager hints. */
+
#ifdef HAVE_X11
x_wm_set_size_hint (f, prompting)
size_hints.width = PIXEL_WIDTH (f);
size_hints.width_inc = FONT_WIDTH (f->display.x->font);
size_hints.height_inc = FONT_HEIGHT (f->display.x->font);
- size_hints.max_width =
- (x_screen_width - ((2 * f->display.x->internal_border_width)
- + f->display.x->v_scrollbar_width));
- size_hints.max_height =
- (x_screen_height - ((2 * f->display.x->internal_border_width)
- + f->display.x->h_scrollbar_height));
+ size_hints.max_width = x_screen_width - CHAR_TO_PIXEL_WIDTH (f, 0);
+ size_hints.max_height = x_screen_height - CHAR_TO_PIXEL_HEIGHT (f, 0);
+
{
int base_width, base_height;
- base_width = ((2 * f->display.x->internal_border_width)
- + f->display.x->v_scrollbar_width);
- base_height = ((2 * f->display.x->internal_border_width)
- + f->display.x->h_scrollbar_height);
+ base_width = CHAR_TO_PIXEL_WIDTH (f, 0);
+ base_height = CHAR_TO_PIXEL_HEIGHT (f, 0);
{
int min_rows = 0, min_cols = 0;
{
Window window = FRAME_X_WINDOW (f);
- f->display.x->wm_hints.flags |= IconPixmapHint;
- f->display.x->wm_hints.icon_pixmap = icon_pixmap ? icon_pixmap : None;
+ if (icon_pixmap)
+ {
+ f->display.x->wm_hints.icon_pixmap = icon_pixmap;
+ f->display.x->wm_hints.flags |= IconPixmapHint;
+ }
+ else
+ f->display.x->wm_hints.flags &= ~IconPixmapHint;
XSetWMHints (x_current_display, window, &f->display.x->wm_hints);
}
}
\f
+/* Initialization. */
+
void
x_term_init (display_name)
char *display_name;
/* Figure out which modifier bits mean what. */
x_find_modifier_meanings ();
-
+
+ /* Get the scroll bar cursor. */
+ x_vertical_scroll_bar_cursor =
+ XCreateFontCursor (x_current_display, XC_sb_v_double_arrow);
+
/* 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 ();
read_socket_hook = XTread_socket;
cursor_to_hook = XTcursor_to;
reassert_line_highlight_hook = XTreassert_line_highlight;
- frame_rehighlight_hook = XTframe_rehighlight;
mouse_position_hook = XTmouse_position;
+ frame_rehighlight_hook = XTframe_rehighlight;
+ frame_raise_lower_hook = XTframe_raise_lower;
+ 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
{
staticpro (&invocation_name);
invocation_name = Qnil;
+
+ staticpro (&last_mouse_scroll_bar);
}
#endif /* ! defined (HAVE_X11) */
#endif /* ! defined (HAVE_X_WINDOWS) */
HCoop / bpt / emacs.git / blobdiff