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