src/xterm.h

   1 /* Definitions and headers for communication with X protocol.
   2    Copyright (C) 1989, 1993 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 #endif
 204
 205 /* The frame (if any) which has the X window that has keyboard focus.
 206    Zero if none.  This is examined by Ffocus_frame in xfns.c */
 207
 208 extern struct frame *x_focus_frame;
 209
 210 #ifdef HAVE_X11
 211 /* Variables associated with the X display screen this emacs is using. */
 212
 213 /* How many screens this X display has. */
 214 extern int x_screen_count;
 215
 216 /* The vendor supporting this X server. */
 217 extern Lisp_Object Vx_vendor;
 218
 219 /* The vendor's release number for this X server. */
 220 extern int x_release;
 221
 222 /* Height of this X screen in pixels. */
 223 extern int x_screen_height;
 224
 225 /* Height of this X screen in millimeters. */
 226 extern int x_screen_height_mm;
 227
 228 /* Width of this X screen in pixels. */
 229 extern int x_screen_width;
 230
 231 /* Width of this X screen in millimeters. */
 232 extern int x_screen_width_mm;
 233
 234 /* Does this X screen do backing store? */
 235 extern Lisp_Object Vx_backing_store;
 236
 237 /* Does this X screen do save-unders? */
 238 extern int x_save_under;
 239
 240 /* Number of planes for this screen. */
 241 extern int x_screen_planes;
 242
 243 /* X Visual type of this screen. */
 244 extern Lisp_Object Vx_screen_visual;
 245
 246 #endif /* HAVE_X11 */
 247 \f
 248 enum text_cursor_kinds {
 249   filled_box_cursor, hollow_box_cursor, bar_cursor
 250 };
 251
 252 /* Each X frame object points to its own struct x_display object
 253    in the display.x field.  The x_display structure contains all
 254    the information that is specific to X windows.  */
 255
 256 struct x_display
 257 {
 258   /* Position of the X window (x and y offsets in root window).  */
 259   int left_pos;
 260   int top_pos;
 261
 262   /* Border width of the X window as known by the X window system.  */
 263   int border_width;
 264
 265   /* Size of the X window in pixels. */
 266   int pixel_height, pixel_width;
 267
 268   /* Height of a line, in pixels.  */
 269   int line_height;
 270
 271 #ifdef HAVE_X11
 272   /* The tiled border used when the mouse is out of the frame. */
 273   Pixmap border_tile;
 274
 275   /* Here are the Graphics Contexts for the default font. */
 276   GC normal_gc;                         /* Normal video */
 277   GC reverse_gc;                        /* Reverse video */
 278   GC cursor_gc;                         /* cursor drawing */
 279 #endif /* HAVE_X11 */
 280
 281   /* Width of the internal border.  This is a line of background color
 282      just inside the window's border.  When the frame is selected,
 283      a highlighting is displayed inside the internal border.  */
 284   int internal_border_width;
 285
 286   /* The X window used for this frame.
 287      May be zero while the frame object is being created
 288      and the X window has not yet been created.  */
 289   Window window_desc;
 290
 291   /* The X window used for the bitmap icon;
 292      or 0 if we don't have a bitmap icon.  */
 293   Window icon_desc;
 294
 295   /* The X window that is the parent of this X window.
 296      Usually but not always RootWindow.  */
 297   Window parent_desc;
 298
 299 #ifdef USE_X_TOOLKIT
 300   /* The widget of this screen.  This is the window of a "shell" widget.  */
 301   Widget widget;
 302   /* The XmPanedWindows...  */
 303   Widget column_widget;
 304   /* The widget of the edit portion of this screen; the window in
 305      "window_desc" is inside of this.  */
 306   Widget edit_widget;
 307
 308   Widget menubar_widget;
 309 #endif
 310
 311   /* 1 for bitmap icon, 0 for text icon.  */
 312   int icon_bitmap_flag;
 313
 314   FONT_TYPE *font;
 315
 316   /* Pixel values used for various purposes.
 317      border_pixel may be -1 meaning use a gray tile.  */
 318   PIX_TYPE background_pixel;
 319   PIX_TYPE foreground_pixel;
 320   PIX_TYPE cursor_pixel;
 321   PIX_TYPE border_pixel;
 322   PIX_TYPE mouse_pixel;
 323   PIX_TYPE cursor_foreground_pixel;
 324
 325   /* Descriptor for the cursor in use for this window.  */
 326 #ifdef HAVE_X11
 327   Cursor text_cursor;
 328   Cursor nontext_cursor;
 329   Cursor modeline_cursor;
 330   Cursor cross_cursor;
 331 #else
 332   Cursor cursor;
 333 #endif
 334
 335   /* The name that was associated with the icon, the last time
 336      it was refreshed.  Usually the same as the name of the
 337      buffer in the currently selected window in the frame */
 338   char *icon_label;
 339
 340   /* Flag to set when the X window needs to be completely repainted. */
 341   int needs_exposure;
 342
 343   /* What kind of text cursor is drawn in this window right now?
 344      (If there is no cursor (phys_cursor_x < 0), then this means nothing.)  */
 345   enum text_cursor_kinds current_cursor;
 346
 347   /* What kind of text cursor should we draw in the future?
 348      This should always be filled_box_cursor or bar_cursor.  */
 349   enum text_cursor_kinds desired_cursor;
 350
 351   /* These are the current window manager hints.  It seems that
 352      XSetWMHints, when presented with an unset bit in the `flags'
 353      member of the hints structure, does not leave the corresponding
 354      attribute unchanged; rather, it resets that attribute to its
 355      default value.  For example, unless you set the `icon_pixmap'
 356      field and the `IconPixmapHint' bit, XSetWMHints will forget what
 357      your icon pixmap was.  This is rather troublesome, since some of
 358      the members (for example, `input' and `icon_pixmap') want to stay
 359      the same throughout the execution of Emacs.  So, we keep this
 360      structure around, just leaving values in it and adding new bits
 361      to the mask as we go.  */
 362   XWMHints wm_hints;
 363
 364   /* The size of the extra width currently allotted for vertical
 365      scroll bars, in pixels.  */
 366   int vertical_scroll_bar_extra;
 367
 368   /* Table of parameter faces for this frame.  Any X resources (pixel
 369      values, fonts) referred to here have been allocated explicitly
 370      for this face, and should be freed if we change the face.  */
 371   struct face **param_faces;
 372   int n_param_faces;
 373
 374   /* Table of computed faces for this frame.  These are the faces
 375      whose indexes go into the upper bits of a glyph, computed by
 376      combining the parameter faces specified by overlays, text
 377      properties, and what have you.  The X resources mentioned here
 378      are all shared with parameter faces.  */
 379   struct face **computed_faces;
 380   int n_computed_faces;         /* How many are valid */
 381   int size_computed_faces;      /* How many are allocated */
 382 };
 383
 384 /* Get at the computed faces of an X window frame.  */
 385 #define FRAME_PARAM_FACES(f) ((f)->display.x->param_faces)
 386 #define FRAME_N_PARAM_FACES(f) ((f)->display.x->n_param_faces)
 387 #define FRAME_DEFAULT_PARAM_FACE(f) (FRAME_PARAM_FACES (f)[0])
 388 #define FRAME_MODE_LINE_PARAM_FACE(f) (FRAME_PARAM_FACES (f)[1])
 389
 390 #define FRAME_COMPUTED_FACES(f) ((f)->display.x->computed_faces)
 391 #define FRAME_N_COMPUTED_FACES(f) ((f)->display.x->n_computed_faces)
 392 #define FRAME_SIZE_COMPUTED_FACES(f) ((f)->display.x->size_computed_faces)
 393 #define FRAME_DEFAULT_FACE(f) ((f)->display.x->computed_faces[0])
 394 #define FRAME_MODE_LINE_FACE(f) ((f)->display.x->computed_faces[1])
 395
 396 /* Return the window associated with the frame F.  */
 397 #define FRAME_X_WINDOW(f) ((f)->display.x->window_desc)
 398
 399 /* These two really ought to be called FRAME_PIXEL_{WIDTH,HEIGHT}.  */
 400 #define PIXEL_WIDTH(f) ((f)->display.x->pixel_width)
 401 #define PIXEL_HEIGHT(f) ((f)->display.x->pixel_height)
 402
 403 #define FRAME_DESIRED_CURSOR(f) ((f)->display.x->desired_cursor)
 404
 405 \f
 406 /* When X windows are used, a glyph may be a 16 bit unsigned datum.
 407    The high order byte is the face number and is used as an index
 408    in the face table.  A face is a font plus:
 409     1) the unhighlighted foreground color,
 410     2) the unhighlighted background color.
 411    For highlighting, the two colors are exchanged.
 412    Face number 0 is unused.  The low order byte of a glyph gives
 413    the character within the font.  All fonts are assumed to be
 414    fixed width, and to have the same height and width. */
 415
 416 #ifdef HAVE_X11
 417
 418 /* Face declared in dispextern.h */
 419
 420 #else   /* X10 */
 421
 422 struct face
 423 {
 424   FONT_TYPE *font;      /* Font info for specified font. */
 425   int  fg;              /* Unhighlighted foreground. */
 426   int  bg;              /* Unhighlighted background. */
 427 };
 428 #endif  /* X10 */
 429
 430 #define MAX_FACES_AND_GLYPHS 256
 431 extern struct face *x_face_table[];
 432
 433 \f
 434 /* X-specific scroll bar stuff.  */
 435
 436 /* We represent scroll bars as lisp vectors.  This allows us to place
 437    references to them in windows without worrying about whether we'll
 438    end up with windows referring to dead scroll bars; the garbage
 439    collector will free it when its time comes.
 440
 441    We use struct scroll_bar as a template for accessing fields of the
 442    vector.  */
 443
 444 struct scroll_bar {
 445
 446   /* These fields are shared by all vectors.  */
 447   int size_from_Lisp_Vector_struct;
 448   struct Lisp_Vector *next_from_Lisp_Vector_struct;
 449
 450   /* The window we're a scroll bar for.  */
 451   Lisp_Object window;
 452
 453   /* The next and previous in the chain of scroll bars in this frame.  */
 454   Lisp_Object next, prev;
 455
 456   /* The X window representing this scroll bar.  Since this is a full
 457      32-bit quantity, we store it split into two 32-bit values.  */
 458   Lisp_Object x_window_low, x_window_high;
 459
 460   /* The position and size of the scroll bar in pixels, relative to the
 461      frame.  */
 462   Lisp_Object top, left, width, height;
 463
 464   /* The starting and ending positions of the handle, relative to the
 465      handle area (i.e. zero is the top position, not
 466      SCROLL_BAR_TOP_BORDER).  If they're equal, that means the handle
 467      hasn't been drawn yet.
 468
 469      These are not actually the locations where the beginning and end
 470      are drawn; in order to keep handles from becoming invisible when
 471      editing large files, we establish a minimum height by always
 472      drawing handle bottoms VERTICAL_SCROLL_BAR_MIN_HANDLE pixels below
 473      where they would be normally; the bottom and top are in a
 474      different co-ordinate system.  */
 475   Lisp_Object start, end;
 476
 477   /* If the scroll bar handle is currently being dragged by the user,
 478      this is the number of pixels from the top of the handle to the
 479      place where the user grabbed it.  If the handle isn't currently
 480      being dragged, this is Qnil.  */
 481   Lisp_Object dragging;
 482 };
 483
 484 /* The number of elements a vector holding a struct scroll_bar needs.  */
 485 #define SCROLL_BAR_VEC_SIZE \
 486   ((sizeof (struct scroll_bar) - sizeof (int) - sizeof (struct Lisp_Vector *)) \
 487    / sizeof (Lisp_Object))
 488
 489 /* Turning a lisp vector value into a pointer to a struct scroll_bar.  */
 490 #define XSCROLL_BAR(vec) ((struct scroll_bar *) XPNTR (vec))
 491
 492
 493 /* Building a 32-bit C integer from two 16-bit lisp integers.  */
 494 #define SCROLL_BAR_PACK(low, high) (XINT (high) << 16 | XINT (low))
 495
 496 /* Setting two lisp integers to the low and high words of a 32-bit C int.  */
 497 #define SCROLL_BAR_UNPACK(low, high, int32) \
 498   (XSET ((low),  Lisp_Int,  (int32)        & 0xffff), \
 499    XSET ((high), Lisp_Int, ((int32) >> 16) & 0xffff))
 500
 501
 502 /* Extract the X window id of the scroll bar from a struct scroll_bar.  */
 503 #define SCROLL_BAR_X_WINDOW(ptr) \
 504   ((Window) SCROLL_BAR_PACK ((ptr)->x_window_low, (ptr)->x_window_high))
 505
 506 /* Store a window id in a struct scroll_bar.  */
 507 #define SET_SCROLL_BAR_X_WINDOW(ptr, id) \
 508   (SCROLL_BAR_UNPACK ((ptr)->x_window_low, (ptr)->x_window_high, (int) id))
 509
 510
 511 /* Return the outside pixel width for a vertical scroll bar on frame F.  */
 512 #define VERTICAL_SCROLL_BAR_PIXEL_WIDTH(f) (2*FONT_WIDTH ((f)->display.x->font))
 513
 514 /* Return the outside pixel height for a vertical scroll bar HEIGHT
 515    rows high on frame F.  */
 516 #define VERTICAL_SCROLL_BAR_PIXEL_HEIGHT(f, height) \
 517   ((height) * (f)->display.x->line_height)
 518
 519 /* Return the inside width of a vertical scroll bar, given the outside
 520    width.  */
 521 #define VERTICAL_SCROLL_BAR_INSIDE_WIDTH(width) \
 522   ((width) - VERTICAL_SCROLL_BAR_LEFT_BORDER - VERTICAL_SCROLL_BAR_RIGHT_BORDER)
 523
 524 /* Return the length of the rectangle within which the top of the
 525    handle must stay.  This isn't equivalent to the inside height,
 526    because the scroll bar handle has a minimum height.
 527
 528    This is the real range of motion for the scroll bar, so when we're
 529    scaling buffer positions to scroll bar positions, we use this, not
 530    VERTICAL_SCROLL_BAR_INSIDE_HEIGHT.  */
 531 #define VERTICAL_SCROLL_BAR_TOP_RANGE(height) \
 532   (VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (height) - VERTICAL_SCROLL_BAR_MIN_HANDLE)
 533
 534 /* Return the inside height of vertical scroll bar, given the outside
 535    height.  See VERTICAL_SCROLL_BAR_TOP_RANGE too.  */
 536 #define VERTICAL_SCROLL_BAR_INSIDE_HEIGHT(height) \
 537   ((height) - VERTICAL_SCROLL_BAR_TOP_BORDER - VERTICAL_SCROLL_BAR_BOTTOM_BORDER)
 538
 539
 540 /* Border widths for scroll bars.
 541
 542    Scroll bar windows don't have any X borders; their border width is
 543    set to zero, and we redraw borders ourselves.  This makes the code
 544    a bit cleaner, since we don't have to convert between outside width
 545    (used when relating to the rest of the screen) and inside width
 546    (used when sizing and drawing the scroll bar window itself).
 547
 548    The handle moves up and down/back and forth in a rectangle inset
 549    from the edges of the scroll bar.  These are widths by which we
 550    inset the handle boundaries from the scroll bar edges.  */
 551 #define VERTICAL_SCROLL_BAR_LEFT_BORDER (2)
 552 #define VERTICAL_SCROLL_BAR_RIGHT_BORDER (2)
 553 #define VERTICAL_SCROLL_BAR_TOP_BORDER (2)
 554 #define VERTICAL_SCROLL_BAR_BOTTOM_BORDER (2)
 555
 556 /* Minimum lengths for scroll bar handles, in pixels.  */
 557 #define VERTICAL_SCROLL_BAR_MIN_HANDLE (5)
 558
 559 \f
 560 /* Manipulating pixel sizes and character sizes.
 561    Knowledge of which factors affect the overall size of the window should
 562    be hidden in these macros, if that's possible.
 563
 564 /* Return the upper/left pixel position of the character cell on frame F
 565    at ROW/COL.  */
 566 #define CHAR_TO_PIXEL_ROW(f, row) \
 567   ((f)->display.x->internal_border_width \
 568    + (row) * (f)->display.x->line_height)
 569 #define CHAR_TO_PIXEL_COL(f, col) \
 570   ((f)->display.x->internal_border_width \
 571    + (col) * FONT_WIDTH ((f)->display.x->font))
 572
 573 /* Return the pixel width/height of frame F if it has
 574    WIDTH columns/HEIGHT rows.  */
 575 #define CHAR_TO_PIXEL_WIDTH(f, width) \
 576   (CHAR_TO_PIXEL_COL (f, width) \
 577    + (f)->display.x->vertical_scroll_bar_extra \
 578    + (f)->display.x->internal_border_width)
 579 #define CHAR_TO_PIXEL_HEIGHT(f, height) \
 580   (CHAR_TO_PIXEL_ROW (f, height) \
 581    + (f)->display.x->internal_border_width)
 582
 583
 584 /* Return the row/column (zero-based) of the character cell containing
 585    the pixel on FRAME at ROW/COL.  */
 586 #define PIXEL_TO_CHAR_ROW(f, row) \
 587   (((row) - (f)->display.x->internal_border_width) \
 588    / (f)->display.x->line_height)
 589 #define PIXEL_TO_CHAR_COL(f, col) \
 590   (((col) - (f)->display.x->internal_border_width) \
 591    / FONT_WIDTH ((f)->display.x->font))
 592
 593 /* How many columns/rows of text can we fit in WIDTH/HEIGHT pixels on
 594    frame F?  */
 595 #define PIXEL_TO_CHAR_WIDTH(f, width) \
 596   (PIXEL_TO_CHAR_COL (f, ((width) \
 597                           - (f)->display.x->internal_border_width \
 598                           - (f)->display.x->vertical_scroll_bar_extra)))
 599 #define PIXEL_TO_CHAR_HEIGHT(f, height) \
 600   (PIXEL_TO_CHAR_ROW (f, ((height) \
 601                           - (f)->display.x->internal_border_width)))
 602 \f
 603 /* If a struct input_event has a kind which is selection_request_event
 604    or selection_clear_event, then its contents are really described
 605    by this structure.  */
 606
 607 /* For an event of kind selection_request_event,
 608    this structure really describes the contents.  */
 609 struct selection_input_event
 610 {
 611   int kind;
 612   Display *display;
 613   Window requestor;
 614   Atom selection, target, property;
 615   Time time;
 616 };
 617
 618 #define SELECTION_EVENT_DISPLAY(eventp) \
 619   (((struct selection_input_event *) (eventp))->display)
 620 #define SELECTION_EVENT_REQUESTOR(eventp)       \
 621   (((struct selection_input_event *) (eventp))->requestor)
 622 #define SELECTION_EVENT_SELECTION(eventp)       \
 623   (((struct selection_input_event *) (eventp))->selection)
 624 #define SELECTION_EVENT_TARGET(eventp)  \
 625   (((struct selection_input_event *) (eventp))->target)
 626 #define SELECTION_EVENT_PROPERTY(eventp)        \
 627   (((struct selection_input_event *) (eventp))->property)
 628 #define SELECTION_EVENT_TIME(eventp)    \
 629   (((struct selection_input_event *) (eventp))->time)
 630
 631 \f
 632 /* Interface to the face code functions.  */
 633
 634 /* Create the first two computed faces for a frame -- the ones that
 635    have GC's.  */
 636 extern void init_frame_faces (/* FRAME_PTR */);
 637
 638 /* Free the resources for the faces associated with a frame.  */
 639 extern void free_frame_faces (/* FRAME_PTR */);
 640
 641 /* Given a computed face, find or make an equivalent display face
 642    in face_vector, and return a pointer to it.  */
 643 extern struct face *intern_face (/* FRAME_PTR, struct face * */);
 644
 645 /* Given a frame and a face name, return the face's ID number, or
 646    zero if it isn't a recognized face name.  */
 647 extern int face_name_id_number (/* FRAME_PTR, Lisp_Object */);
 648
 649 /* Return non-zero if FONT1 and FONT2 have the same size bounding box.
 650    We assume that they're both character-cell fonts.  */
 651 extern int same_size_fonts (/* XFontStruct *, XFontStruct * */);
 652
 653 /* Recompute the GC's for the default and modeline faces.
 654    We call this after changing frame parameters on which those GC's
 655    depend.  */
 656 extern void recompute_basic_faces (/* FRAME_PTR */);
 657
 658 /* Return the face ID associated with a buffer position POS.  Store
 659    into *ENDPTR the next position at which a different face is
 660    needed.  This does not take account of glyphs that specify their
 661    own face codes.  F is the frame in use for display, and W is a
 662    window displaying the current buffer.
 663
 664    REGION_BEG, REGION_END delimit the region, so it can be highlighted.  */
 665 extern int compute_char_face (/* FRAME_PTR frame,
 666                                  struct window *w,
 667                                  int pos,
 668                                  int region_beg, int region_end,
 669                                  int *endptr */);
 670 /* Return the face ID to use to display a special glyph which selects
 671    FACE_CODE as the face ID, assuming that ordinarily the face would
 672    be BASIC_FACE.  F is the frame.  */
 673 extern int compute_glyph_face (/* FRAME_PTR, int */);