/* 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,
#define EVENT_BUFFER_SIZE 64
-#define RES_CLASS "emacs"
-
/* Max and Min sizes in character columns. */
#define MINWIDTH 10
#define MINHEIGHT 10
#define MAXHEIGHT 80
#ifdef HAVE_X11
+
+/* HAVE_X11R4 is defined if we have the features of X11R4. It should
+ be defined when we're using X11R5, since X11R5 has the features of
+ X11R4. If, in the future, we find we need more of these flags
+ (HAVE_X11R5, for example), code should always be written to test
+ the most recent flag first:
+
+ #ifdef HAVE_X11R5
+ ...
+ #elif HAVE_X11R4
+ ...
+ #elif HAVE_X11
+ ...
+ #endif
+
+ If you ever find yourself writing a "#ifdef HAVE_FOO" clause that
+ looks a lot like another one, consider moving the text into a macro
+ whose definition is configuration-dependent, but whose usage is
+ universal - like the stuff in systime.h.
+
+ It turns out that we can auto-detect whether we're being compiled
+ with X11R3 or X11R4 by looking for the flag macros for R4 structure
+ members that R3 doesn't have. */
+#ifdef PBaseSize
+#define HAVE_X11R4
+#endif
+
#define PIX_TYPE unsigned long
#define XDISPLAY x_current_display,
#define XFlushQueue() XFlush(x_current_display)
#define DISPLAY_SCREEN_ARG x_current_display, \
XDefaultScreen (x_current_display)
#define DISPLAY_CELLS DisplayCells (x_current_display, XDefaultScreen (x_current_display))
-#define ROOT_WINDOW RootWindow (x_current_display, XDefaultScreen (x_current_display))
+#define ROOT_WINDOW RootWindow (x_current_display, DefaultScreen (x_current_display))
#define FONT_TYPE XFontStruct
#define Color XColor
#define FONT_HEIGHT(f) ((f)->ascent + (f)->descent)
#define FONT_BASE(f) ((f)->ascent)
-/* GC values used for drawing non-standard (other face) text. */
-extern XGCValues face_gc_values;
-
/* The mask of events that text windows always want to receive. This
does not include mouse movement events. It is used when the window
is created (in x_window) and when we ask/unask for mouse movement
#define BLOCK_INPUT (x_input_blocked++)
/* End critical section. */
-#define UNBLOCK_INPUT (x_input_blocked--, (x_input_blocked < 0 ? abort () : 0))
+#define UNBLOCK_INPUT \
+ (x_input_blocked--, (x_input_blocked < 0 ? (abort (), 0) : 0))
#define TOTALLY_UNBLOCK_INPUT (x_input_blocked = 0)
#define UNBLOCK_INPUT_RESIGNAL UNBLOCK_INPUT
extern Display *x_current_display;
-extern struct screen *x_window_to_screen ();
+extern struct frame *x_window_to_frame ();
-/* The screen (if any) which has the X window that has keyboard focus.
- Zero if none. This is examined by Ffocus_screen in xfns.c */
+/* The frame (if any) which has the X window that has keyboard focus.
+ Zero if none. This is examined by Ffocus_frame in xfns.c */
-struct screen *x_focus_screen;
+struct frame *x_focus_frame;
#ifdef HAVE_X11
/* Variables associated with the X display screen this emacs is using. */
/* How many screens this X display has. */
-extern Lisp_Object x_screen_count;
+extern int x_screen_count;
/* The vendor supporting this X server. */
extern Lisp_Object Vx_vendor;
/* The vendor's release number for this X server. */
-extern Lisp_Object x_release;
+extern int x_release;
/* Height of this X screen in pixels. */
-extern Lisp_Object x_screen_height;
+extern int x_screen_height;
/* Height of this X screen in millimeters. */
-extern Lisp_Object x_screen_height_mm;
+extern int x_screen_height_mm;
/* Width of this X screen in pixels. */
-extern Lisp_Object x_screen_width;
+extern int x_screen_width;
/* Width of this X screen in millimeters. */
-extern Lisp_Object x_screen_width_mm;
+extern int x_screen_width_mm;
/* Does this X screen do backing store? */
extern Lisp_Object Vx_backing_store;
/* Does this X screen do save-unders? */
-extern Lisp_Object x_save_under;
+extern int x_save_under;
/* Number of planes for this screen. */
-extern Lisp_Object x_screen_planes;
+extern int x_screen_planes;
/* X Visual type of this screen. */
extern Lisp_Object Vx_screen_visual;
filled_box_cursor, hollow_box_cursor, bar_cursor
};
-#define PIXEL_WIDTH(s) ((s)->display.x->pixel_width)
-#define PIXEL_HEIGHT(s) ((s)->display.x->pixel_height)
-
-/* Each X screen object points to its own struct x_display object
+/* 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. */
int pixel_height, pixel_width;
#ifdef HAVE_X11
- /* The tiled border used when the mouse is out of the screen. */
+ /* The tiled border used when the mouse is out of the frame. */
Pixmap border_tile;
/* Here are the Graphics Contexts for the default font. */
#endif /* HAVE_X11 */
/* Width of the internal border. This is a line of background color
- just inside the window's border. When the screen is selected,
+ just inside the window's border. When the frame is selected,
a highlighting is displayed inside the internal border. */
int internal_border_width;
- /* The X window used for this screen.
- May be zero while the screen object is being created
+ /* The X window used for this frame.
+ May be zero while the frame object is being created
and the X window has not yet been created. */
Window window_desc;
PIX_TYPE border_pixel;
PIX_TYPE mouse_pixel;
- /* Windows for scrollbars */
- Window v_scrollbar;
- Window v_thumbup;
- Window v_thumbdown;
- Window v_slider;
-
- Window h_scrollbar;
- Window h_thumbleft;
- Window h_thumbright;
- Window h_slider;
-
- /* Scrollbar info */
-
- int v_scrollbar_width;
- int h_scrollbar_height;
-
/* Descriptor for the cursor in use for this window. */
#ifdef HAVE_X11
Cursor text_cursor;
/* The name that was associated with the icon, the last time
it was refreshed. Usually the same as the name of the
- buffer in the currently selected window in the screen */
+ buffer in the currently selected window in the frame */
char *icon_label;
/* 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'
+ member of the hints structure, does not leave the corresponding
+ attribute unchanged; rather, it resets that attribute to its
+ default value. For example, unless you set the `icon_pixmap'
+ field and the `IconPixmapHint' bit, XSetWMHints will forget what
+ your icon pixmap was. This is rather troublesome, since some of
+ the members (for example, `input' and `icon_pixmap') want to stay
+ the same throughout the execution of Emacs. So, we keep this
+ structure around, just leaving values in it and adding new bits
+ to the mask as we go. */
+ XWMHints wm_hints;
+
+ /* The size of the extra width currently allotted for vertical
+ 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
fixed width, and to have the same height and width. */
#ifdef HAVE_X11
-/* Table of GC's used for this screen. */
-GC *gc_table;
-/* How many GCs are in the table. */
-int gcs_in_use;
-
-struct face
-{
- GC face_gc;
- unsigned int foreground;
- unsigned int background;
- Pixmap stipple;
- XFontStruct *font;
-};
+/* Face declared in dispextern.h */
#else /* X10 */
#define MAX_FACES_AND_GLYPHS 256
extern struct face *x_face_table[];
+
+\f
+/* X-specific scroll bar stuff. */
+
+/* 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.
+
+ We use struct scroll_bar as a template for accessing fields of the
+ vector. */
+
+struct scroll_bar {
+
+ /* These fields are shared by all vectors. */
+ int size_from_Lisp_Vector_struct;
+ struct Lisp_Vector *next_from_Lisp_Vector_struct;
+
+ /* The window we're a scroll bar for. */
+ Lisp_Object window;
+
+ /* The next and previous in the chain of scroll bars in this frame. */
+ Lisp_Object next, prev;
+
+ /* 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;
+
+ /* 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 Qnil. */
+ Lisp_Object dragging;
+};
+
+/* 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))
+
+
+/* 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_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.
+
+ 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 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) \
+ (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) \
+ (CHAR_TO_PIXEL_ROW (f, height) \
+ + (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)))