src/xterm.h

   1 /* Definitions and headers for communication with X protocol.
   2    Copyright (C) 1989, 1993, 1994 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #ifdef HAVE_X11
  21 #include <X11/Xlib.h>
  22 #include <X11/cursorfont.h>
  23 #include <X11/Xutil.h>
  24 #include <X11/keysym.h>
  25 #include <X11/Xatom.h>
  26 #include <X11/Xresource.h>
  27 #else
  28 #include <X/Xlib.h>
  29 #endif /* HAVE_X11 */
  30
  31 #ifdef USE_X_TOOLKIT
  32 #include <X11/StringDefs.h>
  33 #include <X11/IntrinsicP.h>     /* CoreP.h needs this */
  34 #include <X11/CoreP.h>          /* foul, but we need this to use our own
  35                                    window inside a widget instead of one
  36                                    that Xt creates... */
  37 #include <X11/StringDefs.h>
  38 #endif
  39
  40 /* Define a queue for X-events.  One such queue is used for mouse clicks.
  41    Another is used for expose events.  */
  42
  43 #define EVENT_BUFFER_SIZE 64
  44
  45 /* Max and Min sizes in character columns. */
  46 #define MINWIDTH 10
  47 #define MINHEIGHT 10
  48 #define MAXWIDTH 300
  49 #define MAXHEIGHT 80
  50
  51 #ifdef HAVE_X11
  52
  53 /* HAVE_X11R4 is defined if we have the features of X11R4.  It should
  54    be defined when we're using X11R5, since X11R5 has the features of
  55    X11R4.  If, in the future, we find we need more of these flags
  56    (HAVE_X11R5, for example), code should always be written to test
  57    the most recent flag first:
  58
  59       #ifdef HAVE_X11R5
  60         ...
  61       #elif HAVE_X11R4
  62         ...
  63       #elif HAVE_X11
  64         ...
  65       #endif
  66
  67    If you ever find yourself writing a "#ifdef HAVE_FOO" clause that
  68    looks a lot like another one, consider moving the text into a macro
  69    whose definition is configuration-dependent, but whose usage is
  70    universal - like the stuff in systime.h.
  71
  72    It turns out that we can auto-detect whether we're being compiled
  73    with X11R3 or X11R4 by looking for the flag macros for R4 structure
  74    members that R3 doesn't have.  */
  75 #ifdef PBaseSize
  76 /* AIX 3.1's X is somewhere between X11R3 and X11R4.  It has
  77    PBaseSize, but not XWithdrawWindow, XSetWMName, XSetWMNormalHints,
  78    XSetWMIconName.
  79    AIX 3.2 is at least X11R4.  */
  80 #if (!defined AIX) || (defined AIX3_2)
  81 #define HAVE_X11R4
  82 #endif
  83 #endif
  84
  85 #ifdef XlibSpecificationRelease
  86 #if XlibSpecificationRelease >= 5
  87 #define HAVE_X11R5
  88 /* In case someone has X11R5 on AIX 3.1,
  89    make sure HAVE_X11R4 is defined as well as HAVE_X11R5.  */
  90 #define HAVE_X11R4
  91 #endif
  92 #endif
  93
  94 #define PIX_TYPE unsigned long
  95 #define XDISPLAY x_current_display,
  96 #define XFlushQueue() XFlush(x_current_display)
  97 #define BLACK_PIX_DEFAULT BlackPixel (x_current_display, \
  98                                       XDefaultScreen (x_current_display))
  99 #define WHITE_PIX_DEFAULT WhitePixel (x_current_display, \
 100                                       XDefaultScreen (x_current_display))
 101 #define DISPLAY_SCREEN_ARG x_current_display, \
 102                                       XDefaultScreen (x_current_display)
 103 #define DISPLAY_CELLS DisplayCells (x_current_display, XDefaultScreen (x_current_display))
 104 #define ROOT_WINDOW RootWindow (x_current_display, DefaultScreen (x_current_display))
 105 #define FONT_TYPE XFontStruct
 106 #define Color XColor
 107
 108 #define XExposeRegionEvent XExposeEvent
 109 #define Bitmap Pixmap                   /* In X11, Bitmaps are a kind of
 110                                            Pixmap.  */
 111 #define WINDOWINFO_TYPE XWindowAttributes
 112 #define XGetWindowInfo(w, i) XGetWindowAttributes (x_current_display, \
 113                                                    (w), (i))
 114 #define XGetFont(f) XLoadQueryFont (x_current_display, (f))
 115 #define XLoseFont(f) XFreeFont (x_current_display, (f))
 116 #define XStuffPending() XPending (x_current_display)
 117 #define XClear(w) XClearWindow (x_current_display, (w))
 118 #define XWarpMousePointer(w,x,y) XWarpPointer (x_current_display, None, w, \
 119                                                0,0,0,0, x, y)
 120 #define XHandleError XSetErrorHandler
 121 #define XHandleIOError XSetIOErrorHandler
 122
 123 #define XChangeWindowSize(w,x,y) XResizeWindow(x_current_display,w,x,y)
 124
 125 #define FONT_WIDTH(f)   ((f)->max_bounds.width)
 126 #define FONT_HEIGHT(f)  ((f)->ascent + (f)->descent)
 127 #define FONT_BASE(f)    ((f)->ascent)
 128
 129 /* The mask of events that text windows always want to receive.  This
 130    does not include mouse movement events.  It is used when the window
 131    is created (in x_window) and when we ask/unask for mouse movement
 132    events (in XTmouse_tracking_enable).
 133
 134    We do include ButtonReleases in this set because elisp isn't always
 135    fast enough to catch them when it wants them, and they're rare
 136    enough that they don't use much processor time.  */
 137
 138 #define STANDARD_EVENT_SET      \
 139   (KeyPressMask                 \
 140    | ExposureMask               \
 141    | ButtonPressMask            \
 142    | ButtonReleaseMask          \
 143    | PointerMotionMask          \
 144    | PointerMotionHintMask      \
 145    | StructureNotifyMask        \
 146    | FocusChangeMask            \
 147    | LeaveWindowMask            \
 148    | EnterWindowMask            \
 149    | VisibilityChangeMask)
 150
 151 #else   /* X10 */
 152
 153 #define ConnectionNumber(dpy) dpyno()
 154 #define PIX_TYPE int
 155 #define XDISPLAY
 156 #define XFlushQueue() XFlush()
 157 #define BLACK_PIX_DEFAULT BlackPixel
 158 #define WHITE_PIX_DEFAULT WhitePixel
 159 #define DISPLAY_SCREEN_ARG
 160 #define DISPLAY_CELLS DisplayCells ()
 161 #define ROOT_WINDOW RootWindow
 162 #define XFree free
 163 #define FONT_TYPE FontInfo
 164
 165 #define WINDOWINFO_TYPE WindowInfo
 166 #define XGetWindowInfo(w, i) XQueryWindow ((w), (i))
 167 #define XGetFont(f) XOpenFont ((f))
 168 #define XLoseFont(f) XCloseFont ((f))
 169 #define XStuffPending() XPending ()
 170 #define XWarpMousePointer(w,x,y) XWarpMouse (w,x,y)
 171 #define XHandleError XErrorHandler
 172 #define XHandleIOError XIOErrorHandler
 173
 174 #define FONT_WIDTH(f)   ((f)->width)
 175 #define FONT_HEIGHT(f)  ((f)->height)
 176 #define FONT_BASE(f)    ((f)->base)
 177
 178 #define XChangeWindowSize(w,x,y) XChangeWindow(w,x,y)
 179
 180 #endif /* X10 */
 181
 182 struct event_queue
 183   {
 184     int rindex;                 /* Index at which to fetch next. */
 185     int windex;                 /* Index at which to store next.  */
 186     XEvent xrep[EVENT_BUFFER_SIZE];
 187   };
 188
 189 /* Queue for mouse clicks.  */
 190 extern struct event_queue x_mouse_queue;
 191
 192 /* This is the X connection that we are using.  */
 193
 194 extern Display *x_current_display;
 195
 196 /* This checks to make sure we have a display.  */
 197 extern void check_x ();
 198
 199 extern struct frame *x_window_to_frame ();
 200
 201 #ifdef USE_X_TOOLKIT
 202 extern struct frame *x_any_window_to_frame ();
 203 extern struct frame *x_top_window_to_frame ();
 204 #endif
 205
 206 /* The frame (if any) which has the X window that has keyboard focus.
 207    Zero if none.  This is examined by Ffocus_frame in xfns.c */
 208
 209 extern struct frame *x_focus_frame;
 210
 211 #ifdef HAVE_X11
 212 /* Variables associated with the X display screen this emacs is using.  */
 213
 214 /* How many screens this X display has.  */
 215 extern int x_screen_count;
 216
 217 /* The vendor supporting this X server.  */
 218 extern Lisp_Object Vx_vendor;
 219
 220 /* The vendor's release number for this X server.  */
 221 extern int x_release;
 222
 223 /* Height of this X screen in pixels.  */
 224 extern int x_screen_height;
 225
 226 /* Height of this X screen in millimeters.  */
 227 extern int x_screen_height_mm;
 228
 229 /* Width of this X screen in pixels.  */
 230 extern int x_screen_width;
 231
 232 /* Width of this X screen in millimeters.  */
 233 extern int x_screen_width_mm;
 234
 235 /* Does this X screen do backing store?  */
 236 extern Lisp_Object Vx_backing_store;
 237
 238 /* Does this X screen do save-unders?  */
 239 extern int x_save_under;
 240
 241 /* Number of planes for this screen.  */
 242 extern int x_screen_planes;
 243
 244 /* X Visual type of this screen.  */
 245 extern Lisp_Object Vx_screen_visual;
 246
 247 /* Mask of which mouse buttons are currently held down.  */
 248 extern unsigned int x_mouse_grabbed;
 249
 250 #endif /* HAVE_X11 */
 251
 252 enum text_cursor_kinds {
 253   filled_box_cursor, hollow_box_cursor, bar_cursor
 254 };
 255 \f
 256 /* For each X display, we have a structure that records
 257    information about it.  */
 258
 259 struct x_screen
 260 {
 261   /* Chain of all x_display structures.  */
 262   struct x_display *next;
 263   /* This says how to access this display in Xlib.  */
 264   Display *x_display_value;
 265   /* This records previous values returned by x-list-fonts.  */
 266   Lisp_Object font_list_cache;
 267   /* The name of this display.  */
 268   Lisp_Object name;
 269   /* Number of frames that are on this display.  */
 270   int reference_count;
 271 };
 272 \f
 273 /* Each X frame object points to its own struct x_display object
 274    in the display.x field.  The x_display structure contains all
 275    the information that is specific to X windows.  */
 276
 277 struct x_display
 278 {
 279   /* Position of the X window (x and y offsets in root window).  */
 280   int left_pos;
 281   int top_pos;
 282
 283   /* Border width of the X window as known by the X window system.  */
 284   int border_width;
 285
 286   /* Size of the X window in pixels.  */
 287   int pixel_height, pixel_width;
 288
 289   /* Height of a line, in pixels.  */
 290   int line_height;
 291
 292 #ifdef HAVE_X11
 293   /* The tiled border used when the mouse is out of the frame.  */
 294   Pixmap border_tile;
 295
 296   /* Here are the Graphics Contexts for the default font.  */
 297   GC normal_gc;                         /* Normal video */
 298   GC reverse_gc;                        /* Reverse video */
 299   GC cursor_gc;                         /* cursor drawing */
 300 #endif /* HAVE_X11 */
 301
 302   /* Width of the internal border.  This is a line of background color
 303      just inside the window's border.  When the frame is selected,
 304      a highlighting is displayed inside the internal border.  */
 305   int internal_border_width;
 306
 307   /* The X window used for this frame.
 308      May be zero while the frame object is being created
 309      and the X window has not yet been created.  */
 310   Window window_desc;
 311
 312   /* The X window used for the bitmap icon;
 313      or 0 if we don't have a bitmap icon.  */
 314   Window icon_desc;
 315
 316   /* The X window that is the parent of this X window.
 317      Usually but not always RootWindow.  */
 318   Window parent_desc;
 319
 320 #ifdef USE_X_TOOLKIT
 321   /* The widget of this screen.  This is the window of a "shell" widget.  */
 322   Widget widget;
 323   /* The XmPanedWindows...  */
 324   Widget column_widget;
 325   /* The widget of the edit portion of this screen; the window in
 326      "window_desc" is inside of this.  */
 327   Widget edit_widget;
 328
 329   Widget menubar_widget;
 330 #endif
 331
 332   /* If >=0, a bitmap index.  The indicated bitmap is used for the
 333      icon. */
 334   int icon_bitmap;
 335
 336   FONT_TYPE *font;
 337
 338   /* Pixel values used for various purposes.
 339      border_pixel may be -1 meaning use a gray tile.  */
 340   PIX_TYPE background_pixel;
 341   PIX_TYPE foreground_pixel;
 342   PIX_TYPE cursor_pixel;
 343   PIX_TYPE border_pixel;
 344   PIX_TYPE mouse_pixel;
 345   PIX_TYPE cursor_foreground_pixel;
 346
 347   /* Descriptor for the cursor in use for this window.  */
 348 #ifdef HAVE_X11
 349   Cursor text_cursor;
 350   Cursor nontext_cursor;
 351   Cursor modeline_cursor;
 352   Cursor cross_cursor;
 353 #else
 354   Cursor cursor;
 355 #endif
 356
 357   /* The name that was associated with the icon, the last time
 358      it was refreshed.  Usually the same as the name of the
 359      buffer in the currently selected window in the frame */
 360   char *icon_label;
 361
 362   /* Flag to set when the X window needs to be completely repainted.  */
 363   int needs_exposure;
 364
 365   /* What kind of text cursor is drawn in this window right now?
 366      (If there is no cursor (phys_cursor_x < 0), then this means nothing.)  */
 367   enum text_cursor_kinds current_cursor;
 368
 369   /* What kind of text cursor should we draw in the future?
 370      This should always be filled_box_cursor or bar_cursor.  */
 371   enum text_cursor_kinds desired_cursor;
 372
 373   /* These are the current window manager hints.  It seems that
 374      XSetWMHints, when presented with an unset bit in the `flags'
 375      member of the hints structure, does not leave the corresponding
 376      attribute unchanged; rather, it resets that attribute to its
 377      default value.  For example, unless you set the `icon_pixmap'
 378      field and the `IconPixmapHint' bit, XSetWMHints will forget what
 379      your icon pixmap was.  This is rather troublesome, since some of
 380      the members (for example, `input' and `icon_pixmap') want to stay
 381      the same throughout the execution of Emacs.  So, we keep this
 382      structure around, just leaving values in it and adding new bits
 383      to the mask as we go.  */
 384   XWMHints wm_hints;
 385
 386   /* The size of the extra width currently allotted for vertical
 387      scroll bars, in pixels.  */
 388   int vertical_scroll_bar_extra;
 389
 390   /* Table of parameter faces for this frame.  Any X resources (pixel
 391      values, fonts) referred to here have been allocated explicitly
 392      for this face, and should be freed if we change the face.  */
 393   struct face **param_faces;
 394   int n_param_faces;
 395
 396   /* Table of computed faces for this frame.  These are the faces
 397      whose indexes go into the upper bits of a glyph, computed by
 398      combining the parameter faces specified by overlays, text
 399      properties, and what have you.  The X resources mentioned here
 400      are all shared with parameter faces.  */
 401   struct face **computed_faces;
 402   int n_computed_faces;         /* How many are valid */
 403   int size_computed_faces;      /* How many are allocated */
 404
 405   /* This is the gravity value for the specified window position.  */
 406   int win_gravity;
 407
 408   /* The geometry flags for this window.  */
 409   int size_hint_flags;
 410
 411   /* This is the Emacs structure for the X display this frame is on.  */
 412   struct x_screen *x_screen;
 413 };
 414
 415 /* Get at the computed faces of an X window frame.  */
 416 #define FRAME_PARAM_FACES(f) ((f)->display.x->param_faces)
 417 #define FRAME_N_PARAM_FACES(f) ((f)->display.x->n_param_faces)
 418 #define FRAME_DEFAULT_PARAM_FACE(f) (FRAME_PARAM_FACES (f)[0])
 419 #define FRAME_MODE_LINE_PARAM_FACE(f) (FRAME_PARAM_FACES (f)[1])
 420
 421 #define FRAME_COMPUTED_FACES(f) ((f)->display.x->computed_faces)
 422 #define FRAME_N_COMPUTED_FACES(f) ((f)->display.x->n_computed_faces)
 423 #define FRAME_SIZE_COMPUTED_FACES(f) ((f)->display.x->size_computed_faces)
 424 #define FRAME_DEFAULT_FACE(f) ((f)->display.x->computed_faces[0])
 425 #define FRAME_MODE_LINE_FACE(f) ((f)->display.x->computed_faces[1])
 426
 427 /* Return the window associated with the frame F.  */
 428 #define FRAME_X_WINDOW(f) ((f)->display.x->window_desc)
 429
 430 #define FRAME_FOREGROUND_PIXEL(f) ((f)->display.x->foreground_pixel)
 431 #define FRAME_BACKGROUND_PIXEL(f) ((f)->display.x->background_pixel)
 432 #define FRAME_FONT(f) ((f)->display.x->font)
 433
 434 #define FRAME_X_SCREEN(f) ((f)->display.x->x_screen)
 435
 436 /* This is the `Display *' which frame F is on.  */
 437 #define FRAME_X_DISPLAY(f) ((f)->display.x->x_screen->x_display_value)
 438
 439 /* These two really ought to be called FRAME_PIXEL_{WIDTH,HEIGHT}.  */
 440 #define PIXEL_WIDTH(f) ((f)->display.x->pixel_width)
 441 #define PIXEL_HEIGHT(f) ((f)->display.x->pixel_height)
 442
 443 #define FRAME_DESIRED_CURSOR(f) ((f)->display.x->desired_cursor)
 444
 445 \f
 446 /* When X windows are used, a glyph may be a 16 bit unsigned datum.
 447    The high order byte is the face number and is used as an index
 448    in the face table.  A face is a font plus:
 449     1) the unhighlighted foreground color,
 450     2) the unhighlighted background color.
 451    For highlighting, the two colors are exchanged.
 452    Face number 0 is unused.  The low order byte of a glyph gives
 453    the character within the font.  All fonts are assumed to be
 454    fixed width, and to have the same height and width.  */
 455
 456 #ifdef HAVE_X11
 457
 458 /* Face declared in dispextern.h */
 459
 460 #else   /* X10 */
 461
 462 struct face
 463 {
 464   FONT_TYPE *font;      /* Font info for specified font.  */
 465   int  fg;              /* Unhighlighted foreground.  */
 466   int  bg;              /* Unhighlighted background.  */
 467 };
 468 #endif  /* X10 */
 469
 470 #define MAX_FACES_AND_GLYPHS 256
 471 extern struct face *x_face_table[];
 472
 473 \f
 474 /* X-specific scroll bar stuff.  */
 475
 476 /* We represent scroll bars as lisp vectors.  This allows us to place
 477    references to them in windows without worrying about whether we'll
 478    end up with windows referring to dead scroll bars; the garbage
 479    collector will free it when its time comes.
 480
 481    We use struct scroll_bar as a template for accessing fields of the
 482    vector.  */
 483
 484 struct scroll_bar {
 485
 486   /* These fields are shared by all vectors.  */
 487   EMACS_INT size_from_Lisp_Vector_struct;
 488   struct Lisp_Vector *next_from_Lisp_Vector_struct;
 489
 490   /* The window we're a scroll bar for.  */
 491   Lisp_Object window;
 492
 493   /* The next and previous in the chain of scroll bars in this frame.  */
 494   Lisp_Object next, prev;
 495
 496   /* The X window representing this scroll bar.  Since this is a full
 497      32-bit quantity, we store it split into two 32-bit values.  */
 498   Lisp_Object x_window_low, x_window_high;
 499
 500   /* The position and size of the scroll bar in pixels, relative to the
 501      frame.  */
 502   Lisp_Object top, left, width, height;
 503
 504   /* The starting and ending positions of the handle, relative to the
 505      handle area (i.e. zero is the top position, not
 506      SCROLL_BAR_TOP_BORDER).  If they're equal, that means the handle
 507      hasn't been drawn yet.
 508
 509      These are not actually the locations where the beginning and end
 510      are drawn; in order to keep handles from becoming invisible when
 511      editing large files, we establish a minimum height by always
 512      drawing handle bottoms VERTICAL_SCROLL_BAR_MIN_HANDLE pixels below
 513      where they would be normally; the bottom and top are in a
 514      different co-ordinate system.  */
 515   Lisp_Object start, end;
 516
 517   /* If the scroll bar handle is currently being dragged by the user,
 518      this is the number of pixels from the top of the handle to the
 519      place where the user grabbed it.  If the handle isn't currently
 520      being dragged, this is Qnil.  */
 521   Lisp_Object dragging;
 522 };
 523
 524 /* The number of elements a vector holding a struct scroll_bar needs.  */
 525 #define SCROLL_BAR_VEC_SIZE \
 526   ((sizeof (struct scroll_bar) - sizeof (EMACS_INT) - sizeof (struct Lisp_Vector *)) \
 527    / sizeof (Lisp_Object))
 528
 529 /* Turning a lisp vector value into a pointer to a struct scroll_bar.  */
 530 #define XSCROLL_BAR(vec) ((struct scroll_bar *) XPNTR (vec))
 531
 532
 533 /* Building a 32-bit C integer from two 16-bit lisp integers.  */
 534 #define SCROLL_BAR_PACK(low, high) (XINT (high) << 16 | XINT (low))
 535
 536 /* Setting two lisp integers to the low and high words of a 32-bit C int.  */
 537 #define SCROLL_BAR_UNPACK(low, high, int32) \
 538   (XSETINT ((low),   (int32)        & 0xffff), \
 539    XSETINT ((high), ((int32) >> 16) & 0xffff))
 540
 541
 542 /* Extract the X window id of the scroll bar from a struct scroll_bar.  */
 543 #define SCROLL_BAR_X_WINDOW(ptr) \
 544   ((Window) SCROLL_BAR_PACK ((ptr)->x_window_low, (ptr)->x_window_high))
 545
 546 /* Store a window id in a struct scroll_bar.  */
 547 #define SET_SCROLL_BAR_X_WINDOW(ptr, id) \
 548   (SCROLL_BAR_UNPACK ((ptr)->x_window_low, (ptr)->x_window_high, (int) id))
 549
 550
 551 /* Return the outside pixel height for a vertical scroll bar HEIGHT
 552    rows high on frame F.  */
 553 #define VERTICAL_SCROLL_BAR_PIXEL_HEIGHT(f, height) \
 554   ((height) * (f)->display.x->line_height)
 555
 556 /* Return the inside width of a vertical scroll bar, given the outside
 557    width.  */
 558 #define VERTICAL_SCROLL_BAR_INSIDE_WIDTH(width) \
 559   ((width) - VERTICAL_SCROLL_BAR_LEFT_BORDER - VERTICAL_SCROLL_BAR_RIGHT_BORDER)
 560
 561 /* Return the length of the rectangle within which the top of the
 562    handle must stay.  This isn't equivalent to the inside height,
 563    because the scroll bar handle has a minimum height.
 564
 565    This is the real range of motion for the scroll bar, so when we're
 566    scaling buffer positions to scroll bar positions, we use this, not
 567    VERTICAL_SCROLL_BAR_INSIDE_HEIGHT.  */
 568 #define VERTICAL_SCROLL_BAR_TOP_RANGE(height) \
 569   (VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (height) - VERTICAL_SCROLL_BAR_MIN_HANDLE)
 570
 571 /* Return the inside height of vertical scroll bar, given the outside
 572    height.  See VERTICAL_SCROLL_BAR_TOP_RANGE too.  */
 573 #define VERTICAL_SCROLL_BAR_INSIDE_HEIGHT(height) \
 574   ((height) - VERTICAL_SCROLL_BAR_TOP_BORDER - VERTICAL_SCROLL_BAR_BOTTOM_BORDER)
 575
 576
 577 /* Border widths for scroll bars.
 578
 579    Scroll bar windows don't have any X borders; their border width is
 580    set to zero, and we redraw borders ourselves.  This makes the code
 581    a bit cleaner, since we don't have to convert between outside width
 582    (used when relating to the rest of the screen) and inside width
 583    (used when sizing and drawing the scroll bar window itself).
 584
 585    The handle moves up and down/back and forth in a rectangle inset
 586    from the edges of the scroll bar.  These are widths by which we
 587    inset the handle boundaries from the scroll bar edges.  */
 588 #define VERTICAL_SCROLL_BAR_LEFT_BORDER (2)
 589 #define VERTICAL_SCROLL_BAR_RIGHT_BORDER (2)
 590 #define VERTICAL_SCROLL_BAR_TOP_BORDER (2)
 591 #define VERTICAL_SCROLL_BAR_BOTTOM_BORDER (2)
 592
 593 /* Minimum lengths for scroll bar handles, in pixels.  */
 594 #define VERTICAL_SCROLL_BAR_MIN_HANDLE (5)
 595
 596 \f
 597 /* Manipulating pixel sizes and character sizes.
 598    Knowledge of which factors affect the overall size of the window should
 599    be hidden in these macros, if that's possible.
 600
 601    Return the upper/left pixel position of the character cell on frame F
 602    at ROW/COL.  */
 603 #define CHAR_TO_PIXEL_ROW(f, row) \
 604   ((f)->display.x->internal_border_width \
 605    + (row) * (f)->display.x->line_height)
 606 #define CHAR_TO_PIXEL_COL(f, col) \
 607   ((f)->display.x->internal_border_width \
 608    + (col) * FONT_WIDTH ((f)->display.x->font))
 609
 610 /* Return the pixel width/height of frame F if it has
 611    WIDTH columns/HEIGHT rows.  */
 612 #define CHAR_TO_PIXEL_WIDTH(f, width) \
 613   (CHAR_TO_PIXEL_COL (f, width) \
 614    + (f)->display.x->vertical_scroll_bar_extra \
 615    + (f)->display.x->internal_border_width)
 616 #define CHAR_TO_PIXEL_HEIGHT(f, height) \
 617   (CHAR_TO_PIXEL_ROW (f, height) \
 618    + (f)->display.x->internal_border_width)
 619
 620
 621 /* Return the row/column (zero-based) of the character cell containing
 622    the pixel on FRAME at ROW/COL.  */
 623 #define PIXEL_TO_CHAR_ROW(f, row) \
 624   (((row) - (f)->display.x->internal_border_width) \
 625    / (f)->display.x->line_height)
 626 #define PIXEL_TO_CHAR_COL(f, col) \
 627   (((col) - (f)->display.x->internal_border_width) \
 628    / FONT_WIDTH ((f)->display.x->font))
 629
 630 /* How many columns/rows of text can we fit in WIDTH/HEIGHT pixels on
 631    frame F?  */
 632 #define PIXEL_TO_CHAR_WIDTH(f, width) \
 633   (PIXEL_TO_CHAR_COL (f, ((width) \
 634                           - (f)->display.x->internal_border_width \
 635                           - (f)->display.x->vertical_scroll_bar_extra)))
 636 #define PIXEL_TO_CHAR_HEIGHT(f, height) \
 637   (PIXEL_TO_CHAR_ROW (f, ((height) \
 638                           - (f)->display.x->internal_border_width)))
 639 \f
 640 /* If a struct input_event has a kind which is selection_request_event
 641    or selection_clear_event, then its contents are really described
 642    by this structure.  */
 643
 644 /* For an event of kind selection_request_event,
 645    this structure really describes the contents.  */
 646 struct selection_input_event
 647 {
 648   int kind;
 649   Display *display;
 650   Window requestor;
 651   Atom selection, target, property;
 652   Time time;
 653 };
 654
 655 #define SELECTION_EVENT_DISPLAY(eventp) \
 656   (((struct selection_input_event *) (eventp))->display)
 657 #define SELECTION_EVENT_REQUESTOR(eventp)       \
 658   (((struct selection_input_event *) (eventp))->requestor)
 659 #define SELECTION_EVENT_SELECTION(eventp)       \
 660   (((struct selection_input_event *) (eventp))->selection)
 661 #define SELECTION_EVENT_TARGET(eventp)  \
 662   (((struct selection_input_event *) (eventp))->target)
 663 #define SELECTION_EVENT_PROPERTY(eventp)        \
 664   (((struct selection_input_event *) (eventp))->property)
 665 #define SELECTION_EVENT_TIME(eventp)    \
 666   (((struct selection_input_event *) (eventp))->time)
 667
 668 \f
 669 /* Interface to the face code functions.  */
 670
 671 /* Create the first two computed faces for a frame -- the ones that
 672    have GC's.  */
 673 extern void init_frame_faces (/* FRAME_PTR */);
 674
 675 /* Free the resources for the faces associated with a frame.  */
 676 extern void free_frame_faces (/* FRAME_PTR */);
 677
 678 /* Given a computed face, find or make an equivalent display face
 679    in face_vector, and return a pointer to it.  */
 680 extern struct face *intern_face (/* FRAME_PTR, struct face * */);
 681
 682 /* Given a frame and a face name, return the face's ID number, or
 683    zero if it isn't a recognized face name.  */
 684 extern int face_name_id_number (/* FRAME_PTR, Lisp_Object */);
 685
 686 /* Return non-zero if FONT1 and FONT2 have the same size bounding box.
 687    We assume that they're both character-cell fonts.  */
 688 extern int same_size_fonts (/* XFontStruct *, XFontStruct * */);
 689
 690 /* Recompute the GC's for the default and modeline faces.
 691    We call this after changing frame parameters on which those GC's
 692    depend.  */
 693 extern void recompute_basic_faces (/* FRAME_PTR */);
 694
 695 /* Return the face ID associated with a buffer position POS.  Store
 696    into *ENDPTR the next position at which a different face is
 697    needed.  This does not take account of glyphs that specify their
 698    own face codes.  F is the frame in use for display, and W is a
 699    window displaying the current buffer.
 700
 701    REGION_BEG, REGION_END delimit the region, so it can be highlighted.  */
 702 extern int compute_char_face (/* FRAME_PTR frame,
 703                                  struct window *w,
 704                                  int pos,
 705                                  int region_beg, int region_end,
 706                                  int *endptr */);
 707 /* Return the face ID to use to display a special glyph which selects
 708    FACE_CODE as the face ID, assuming that ordinarily the face would
 709    be BASIC_FACE.  F is the frame.  */
 710 extern int compute_glyph_face (/* FRAME_PTR, int */);