/* Definitions and headers for communication with X protocol.
- Copyright (C) 1989 Free Software Foundation, Inc.
+ Copyright (C) 1989, 1993 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
filled_box_cursor, hollow_box_cursor, bar_cursor
};
-#define PIXEL_WIDTH(f) ((f)->display.x->pixel_width)
-#define PIXEL_HEIGHT(f) ((f)->display.x->pixel_height)
-
/* Each X frame object points to its own struct x_display object
in the display.x field. The x_display structure contains all
the information that is specific to X windows. */
/* Flag to set when the X window needs to be completely repainted. */
int needs_exposure;
- /* What kind of text cursor is drawn in this window right now? (If
- there is no cursor (phys_cursor_x < 0), then this means nothing. */
- enum text_cursor_kinds text_cursor_kind;
+ /* What kind of text cursor is drawn in this window right now?
+ (If there is no cursor (phys_cursor_x < 0), then this means nothing.) */
+ enum text_cursor_kinds current_cursor;
+
+ /* What kind of text cursor should we draw in the future?
+ This should always be filled_box_cursor or bar_cursor. */
+ enum text_cursor_kinds desired_cursor;
/* These are the current window manager hints. It seems that
XSetWMHints, when presented with an unset bit in the `flags'
to the mask as we go. */
XWMHints wm_hints;
- /* The list of vertical scrollbars currently being displayed in this
- frame. */
- struct scrollbar *vertical_scrollbars;
-
- /* The timestamp used to implement the condemn/redeem/judge functions. */
- int judge_timestamp;
-
/* The size of the extra width currently allotted for vertical
- scrollbars, in pixels. */
- int vertical_scrollbar_extra;
+ scroll bars, in pixels. */
+ int vertical_scroll_bar_extra;
};
/* Return the window associated with the frame F. */
#define FRAME_X_WINDOW(f) ((f)->display.x->window_desc)
+/* These two really ought to be called FRAME_PIXEL_{WIDTH,HEIGHT}. */
+#define PIXEL_WIDTH(f) ((f)->display.x->pixel_width)
+#define PIXEL_HEIGHT(f) ((f)->display.x->pixel_height)
+
+#define FRAME_DESIRED_CURSOR(f) ((f)->display.x->desired_cursor)
+
\f
/* When X windows are used, a glyf may be a 16 bit unsigned datum.
The high order byte is the face number and is used as an index
extern struct face *x_face_table[];
\f
-/* X-specific scrollbar stuff. */
+/* X-specific scroll bar stuff. */
-struct scrollbar {
+/* We represent scroll bars as lisp vectors. This allows us to place
+ references to them in windows without worrying about whether we'll
+ end up with windows referring to dead scroll bars; the garbage
+ collector will free it when its time comes.
- /* The frame we're displayed on. */
- struct frame *frame;
+ We use struct scroll_bar as a template for accessing fields of the
+ vector. */
- /* The next in the chain of scrollbars in this frame. */
- struct scrollbar *next;
+struct scroll_bar {
- /* The window representing this scrollbar. */
- Window window;
+ /* These fields are shared by all vectors. */
+ int size_from_Lisp_Vector_struct;
+ struct Lisp_Vector *next_from_Lisp_Vector_struct;
- /* The position and size of the scrollbar in pixels, relative to the
- frame. */
- int top, left;
- int width, height;
+ /* The window we're a scroll bar for. */
+ Lisp_Object window;
- /* The starting and ending positions of the handle, relative to
- the handle area. If they're equal, that means the handle
- hasn't been drawn yet. */
- int start, end;
+ /* The next and previous in the chain of scroll bars in this frame. */
+ Lisp_Object next, prev;
- /* The timestamp for judgement. If this is less than
- judge_timestamp in the x_display structure, this scrollbar is
- damned. */
- int judge_timestamp;
+ /* The X window representing this scroll bar. Since this is a full
+ 32-bit quantity, we store it split into two 32-bit values. */
+ Lisp_Object x_window_low, x_window_high;
- /* If the scrollbar handle is currently being dragged by the user,
+ /* The position and size of the scroll bar in pixels, relative to the
+ frame. */
+ Lisp_Object top, left, width, height;
+
+ /* The starting and ending positions of the handle, relative to the
+ handle area (i.e. zero is the top position, not
+ SCROLL_BAR_TOP_BORDER). If they're equal, that means the handle
+ hasn't been drawn yet.
+
+ These are not actually the locations where the beginning and end
+ are drawn; in order to keep handles from becoming invisible when
+ editing large files, we establish a minimum height by always
+ drawing handle bottoms VERTICAL_SCROLL_BAR_MIN_HANDLE pixels below
+ where they would be normally; the bottom and top are in a
+ different co-ordinate system. */
+ Lisp_Object start, end;
+
+ /* If the scroll bar handle is currently being dragged by the user,
this is the number of pixels from the top of the handle to the
place where the user grabbed it. If the handle isn't currently
- being dragged, this is -1. */
- int dragging;
+ being dragged, this is Qnil. */
+ Lisp_Object dragging;
};
-/* Return the outside pixel width for a vertical scrollbar on frame F. */
-#define VERTICAL_SCROLLBAR_PIXEL_WIDTH(f) (2*FONT_WIDTH ((f)->display.x->font))
+/* The number of elements a vector holding a struct scroll_bar needs. */
+#define SCROLL_BAR_VEC_SIZE \
+ ((sizeof (struct scroll_bar) - sizeof (int) - sizeof (struct Lisp_Vector *)) \
+ / sizeof (Lisp_Object))
+
+/* Turning a lisp vector value into a pointer to a struct scroll_bar. */
+#define XSCROLL_BAR(vec) ((struct scroll_bar *) XPNTR (vec))
+
+
+/* Building a 32-bit C integer from two 16-bit lisp integers. */
+#define SCROLL_BAR_PACK(low, high) (XINT (high) << 16 | XINT (low))
+
+/* Setting two lisp integers to the low and high words of a 32-bit C int. */
+#define SCROLL_BAR_UNPACK(low, high, int32) \
+ (XSET ((low), Lisp_Int, (int32) & 0xffff), \
+ XSET ((high), Lisp_Int, ((int32) >> 16) & 0xffff))
+
-/* Return the outside pixel height for a vertical scrollbar HEIGHT
+/* Extract the X window id of the scroll bar from a struct scroll_bar. */
+#define SCROLL_BAR_X_WINDOW(ptr) \
+ ((Window) SCROLL_BAR_PACK ((ptr)->x_window_low, (ptr)->x_window_high))
+
+/* Store a window id in a struct scroll_bar. */
+#define SET_SCROLL_BAR_X_WINDOW(ptr, id) \
+ (SCROLL_BAR_UNPACK ((ptr)->x_window_low, (ptr)->x_window_high, (int) id))
+
+
+/* Return the outside pixel width for a vertical scroll bar on frame F. */
+#define VERTICAL_SCROLL_BAR_PIXEL_WIDTH(f) (2*FONT_WIDTH ((f)->display.x->font))
+
+/* Return the outside pixel height for a vertical scroll bar HEIGHT
rows high on frame F. */
-#define VERTICAL_SCROLLBAR_PIXEL_HEIGHT(f, height) \
+#define VERTICAL_SCROLL_BAR_PIXEL_HEIGHT(f, height) \
((height) * FONT_HEIGHT ((f)->display.x->font))
+/* Return the inside width of a vertical scroll bar, given the outside
+ width. */
+#define VERTICAL_SCROLL_BAR_INSIDE_WIDTH(width) \
+ ((width) - VERTICAL_SCROLL_BAR_LEFT_BORDER - VERTICAL_SCROLL_BAR_RIGHT_BORDER)
+
+/* Return the length of the rectangle within which the top of the
+ handle must stay. This isn't equivalent to the inside height,
+ because the scroll bar handle has a minimum height.
+
+ This is the real range of motion for the scroll bar, so when we're
+ scaling buffer positions to scroll bar positions, we use this, not
+ VERTICAL_SCROLL_BAR_INSIDE_HEIGHT. */
+#define VERTICAL_SCROLL_BAR_TOP_RANGE(height) \
+ (VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (height) - VERTICAL_SCROLL_BAR_MIN_HANDLE)
+
+/* Return the inside height of vertical scroll bar, given the outside
+ height. See VERTICAL_SCROLL_BAR_TOP_RANGE too. */
+#define VERTICAL_SCROLL_BAR_INSIDE_HEIGHT(height) \
+ ((height) - VERTICAL_SCROLL_BAR_TOP_BORDER - VERTICAL_SCROLL_BAR_BOTTOM_BORDER)
+
+
+/* Border widths for scroll bars.
-/* Border widths for scrollbars. */
-#define VERTICAL_SCROLLBAR_LEFT_BORDER (1)
-#define VERTICAL_SCROLLBAR_RIGHT_BORDER (2)
-#define VERTICAL_SCROLLBAR_TOP_BORDER (1)
-#define VERTICAL_SCROLLBAR_BOTTOM_BORDER (1)
+ Scroll bar windows don't have any X borders; their border width is
+ set to zero, and we redraw borders ourselves. This makes the code
+ a bit cleaner, since we don't have to convert between outside width
+ (used when relating to the rest of the screen) and inside width
+ (used when sizing and drawing the scroll bar window itself).
+
+ The handle moves up and down/back and forth in a rectange inset
+ from the edges of the scroll bar. These are widths by which we
+ inset the handle boundaries from the scroll bar edges. */
+#define VERTICAL_SCROLL_BAR_LEFT_BORDER (2)
+#define VERTICAL_SCROLL_BAR_RIGHT_BORDER (3)
+#define VERTICAL_SCROLL_BAR_TOP_BORDER (2)
+#define VERTICAL_SCROLL_BAR_BOTTOM_BORDER (2)
+
+/* Minimum lengths for scroll bar handles, in pixels. */
+#define VERTICAL_SCROLL_BAR_MIN_HANDLE (5)
\f
/* Manipulating pixel sizes and character sizes.
Knowledge of which factors affect the overall size of the window should
be hidden in these macros, if that's possible.
-/* Return the pixel width of frame F if it has WIDTH columns. */
+/* Return the upper/left pixel position of the character cell on frame F
+ at ROW/COL. */
+#define CHAR_TO_PIXEL_ROW(f, row) \
+ ((f)->display.x->internal_border_width \
+ + (row) * FONT_HEIGHT ((f)->display.x->font))
+#define CHAR_TO_PIXEL_COL(f, col) \
+ ((f)->display.x->internal_border_width \
+ + (col) * FONT_WIDTH ((f)->display.x->font))
+
+/* Return the pixel width/height of frame F if it has
+ WIDTH columns/HEIGHT rows. */
#define CHAR_TO_PIXEL_WIDTH(f, width) \
- ((width) * FONT_WIDTH ((f)->display.x->font) \
- + 2 * (f)->display.x->internal_border_width \
- + (f)->display.x->vertical_scrollbar_extra)
-
-/* Return the pixel height of frame F if it has HEIGHT rows. */
+ (CHAR_TO_PIXEL_COL (f, width) \
+ + (f)->display.x->vertical_scroll_bar_extra \
+ + (f)->display.x->internal_border_width)
#define CHAR_TO_PIXEL_HEIGHT(f, height) \
- ((height) * FONT_HEIGHT ((f)->display.x->font) \
- + 2 * (f)->display.x->internal_border_width)
+ (CHAR_TO_PIXEL_ROW (f, height) \
+ + (f)->display.x->internal_border_width)
-/* How many columns of text can we fit in WIDTH pixels on frame F? */
-#define PIXEL_TO_CHAR_WIDTH(f, width) \
- (((width) \
- - (f)->display.x->vertical_scrollbar_extra \
- - 2 * (f)->display.x->internal_border_width) \
- / FONT_WIDTH ((f)->display.x->font))
-/* How many rows of text can we fit in HEIGHT pixels on frame F? */
-#define PIXEL_TO_CHAR_HEIGHT(f, height) \
- (((height) \
- - 2 * (f)->display.x->internal_border_width) \
+/* Return the row/column (zero-based) of the character cell containing
+ the pixel on FRAME at ROW/COL. */
+#define PIXEL_TO_CHAR_ROW(frame, row) \
+ (((row) - (f)->display.x->internal_border_width) \
/ FONT_HEIGHT ((f)->display.x->font))
+#define PIXEL_TO_CHAR_COL(frame, col) \
+ (((col) - (f)->display.x->internal_border_width) \
+ / FONT_WIDTH ((f)->display.x->font))
+/* How many columns/rows of text can we fit in WIDTH/HEIGHT pixels on
+ frame F? */
+#define PIXEL_TO_CHAR_WIDTH(f, width) \
+ (PIXEL_TO_CHAR_COL (f, ((width) \
+ - (f)->display.x->internal_border_width \
+ - (f)->display.x->vertical_scroll_bar_extra)))
+#define PIXEL_TO_CHAR_HEIGHT(f, height) \
+ (PIXEL_TO_CHAR_ROW (f, ((height) \
+ - (f)->display.x->internal_border_width)))