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