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 /* Mechanism for interlocking between main program level
 175    and input interrupt level.  */
 176
 177 /* Nonzero during a critical section.  At such a time, an input interrupt
 178    does nothing but set `x_pending_input'.  */
 179 extern int x_input_blocked;
 180
 181 /* Nonzero means an input interrupt has arrived
 182    during the current critical section.  */
 183 extern int x_pending_input;
 184
 185 /* Begin critical section. */
 186 #define BLOCK_INPUT (x_input_blocked++)
 187
 188 /* End critical section. */
 189 #ifdef SIGIO
 190 /* If doing interrupt input, and an interrupt came in when input was blocked,
 191    reinvoke the interrupt handler now to deal with it.  */
 192 #define UNBLOCK_INPUT \
 193   ((x_input_blocked--, (x_input_blocked < 0 ? (abort (), 0) : 0)),      \
 194    (x_input_blocked == 0 && x_pending_input != 0 ? (kill (0, SIGIO), 0) : 0))
 195 #else
 196 #define UNBLOCK_INPUT \
 197   (x_input_blocked--, (x_input_blocked < 0 ? (abort (), 0) : 0))
 198 #endif
 199
 200 #define TOTALLY_UNBLOCK_INPUT (x_input_blocked = 0)
 201 #define UNBLOCK_INPUT_RESIGNAL UNBLOCK_INPUT
 202
 203 /* This is the X connection that we are using.  */
 204
 205 extern Display *x_current_display;
 206
 207 extern struct frame *x_window_to_frame ();
 208
 209 /* The frame (if any) which has the X window that has keyboard focus.
 210    Zero if none.  This is examined by Ffocus_frame in xfns.c */
 211
 212 struct frame *x_focus_frame;
 213
 214 #ifdef HAVE_X11
 215 /* Variables associated with the X display screen this emacs is using. */
 216
 217 /* How many screens this X display has. */
 218 extern int x_screen_count;
 219
 220 /* The vendor supporting this X server. */
 221 extern Lisp_Object Vx_vendor;
 222
 223 /* The vendor's release number for this X server. */
 224 extern int x_release;
 225
 226 /* Height of this X screen in pixels. */
 227 extern int x_screen_height;
 228
 229 /* Height of this X screen in millimeters. */
 230 extern int x_screen_height_mm;
 231
 232 /* Width of this X screen in pixels. */
 233 extern int x_screen_width;
 234
 235 /* Width of this X screen in millimeters. */
 236 extern int x_screen_width_mm;
 237
 238 /* Does this X screen do backing store? */
 239 extern Lisp_Object Vx_backing_store;
 240
 241 /* Does this X screen do save-unders? */
 242 extern int x_save_under;
 243
 244 /* Number of planes for this screen. */
 245 extern int x_screen_planes;
 246
 247 /* X Visual type of this screen. */
 248 extern Lisp_Object Vx_screen_visual;
 249
 250 #endif /* HAVE_X11 */
 251 \f
 252 enum text_cursor_kinds {
 253   filled_box_cursor, hollow_box_cursor, bar_cursor
 254 };
 255
 256 /* Each X frame object points to its own struct x_display object
 257    in the display.x field.  The x_display structure contains all
 258    the information that is specific to X windows.  */
 259
 260 struct x_display
 261 {
 262   /* Position of the X window (x and y offsets in root window).  */
 263   int left_pos;
 264   int top_pos;
 265
 266   /* Border width of the X window as known by the X window system.  */
 267   int border_width;
 268
 269   /* Size of the X window in pixels. */
 270   int pixel_height, pixel_width;
 271
 272 #ifdef HAVE_X11
 273   /* The tiled border used when the mouse is out of the frame. */
 274   Pixmap border_tile;
 275
 276   /* Here are the Graphics Contexts for the default font. */
 277   GC normal_gc;                         /* Normal video */
 278   GC reverse_gc;                        /* Reverse video */
 279   GC cursor_gc;                         /* cursor drawing */
 280 #endif /* HAVE_X11 */
 281
 282   /* Width of the internal border.  This is a line of background color
 283      just inside the window's border.  When the frame is selected,
 284      a highlighting is displayed inside the internal border.  */
 285   int internal_border_width;
 286
 287   /* The X window used for this frame.
 288      May be zero while the frame object is being created
 289      and the X window has not yet been created.  */
 290   Window window_desc;
 291
 292   /* The X window used for the bitmap icon;
 293      or 0 if we don't have a bitmap icon.  */
 294   Window icon_desc;
 295
 296   /* The X window that is the parent of this X window.
 297      Usually but not always RootWindow.  */
 298   Window parent_desc;
 299
 300   /* 1 for bitmap icon, 0 for text icon.  */
 301   int icon_bitmap_flag;
 302
 303   FONT_TYPE *font;
 304
 305   /* Pixel values used for various purposes.
 306      border_pixel may be -1 meaning use a gray tile.  */
 307   PIX_TYPE background_pixel;
 308   PIX_TYPE foreground_pixel;
 309   PIX_TYPE cursor_pixel;
 310   PIX_TYPE border_pixel;
 311   PIX_TYPE mouse_pixel;
 312
 313   /* Descriptor for the cursor in use for this window.  */
 314 #ifdef HAVE_X11
 315   Cursor text_cursor;
 316   Cursor nontext_cursor;
 317   Cursor modeline_cursor;
 318 #else
 319   Cursor cursor;
 320 #endif
 321
 322   /* The name that was associated with the icon, the last time
 323      it was refreshed.  Usually the same as the name of the
 324      buffer in the currently selected window in the frame */
 325   char *icon_label;
 326
 327   /* Flag to set when the X window needs to be completely repainted. */
 328   int needs_exposure;
 329
 330   /* What kind of text cursor is drawn in this window right now?
 331      (If there is no cursor (phys_cursor_x < 0), then this means nothing.)  */
 332   enum text_cursor_kinds current_cursor;
 333
 334   /* What kind of text cursor should we draw in the future?
 335      This should always be filled_box_cursor or bar_cursor.  */
 336   enum text_cursor_kinds desired_cursor;
 337
 338   /* These are the current window manager hints.  It seems that
 339      XSetWMHints, when presented with an unset bit in the `flags'
 340      member of the hints structure, does not leave the corresponding
 341      attribute unchanged; rather, it resets that attribute to its
 342      default value.  For example, unless you set the `icon_pixmap'
 343      field and the `IconPixmapHint' bit, XSetWMHints will forget what
 344      your icon pixmap was.  This is rather troublesome, since some of
 345      the members (for example, `input' and `icon_pixmap') want to stay
 346      the same throughout the execution of Emacs.  So, we keep this
 347      structure around, just leaving values in it and adding new bits
 348      to the mask as we go.  */
 349   XWMHints wm_hints;
 350
 351   /* The size of the extra width currently allotted for vertical
 352      scroll bars, in pixels.  */
 353   int vertical_scroll_bar_extra;
 354 };
 355
 356 /* Return the window associated with the frame F.  */
 357 #define FRAME_X_WINDOW(f) ((f)->display.x->window_desc)
 358
 359 /* These two really ought to be called FRAME_PIXEL_{WIDTH,HEIGHT}.  */
 360 #define PIXEL_WIDTH(f) ((f)->display.x->pixel_width)
 361 #define PIXEL_HEIGHT(f) ((f)->display.x->pixel_height)
 362
 363 #define FRAME_DESIRED_CURSOR(f) ((f)->display.x->desired_cursor)
 364
 365 \f
 366 /* When X windows are used, a glyf may be a 16 bit unsigned datum.
 367    The high order byte is the face number and is used as an index
 368    in the face table.  A face is a font plus:
 369     1) the unhighlighted foreground color,
 370     2) the unhighlighted background color.
 371    For highlighting, the two colors are exchanged.
 372    Face number 0 is unused.  The low order byte of a glyf gives
 373    the character within the font.  All fonts are assumed to be
 374    fixed width, and to have the same height and width. */
 375
 376 #ifdef HAVE_X11
 377
 378 /* Face declared in dispextern.h */
 379
 380 #else   /* X10 */
 381
 382 struct face
 383 {
 384   FONT_TYPE *font;      /* Font info for specified font. */
 385   int  fg;              /* Unhighlighted foreground. */
 386   int  bg;              /* Unhighlighted background. */
 387 };
 388 #endif  /* X10 */
 389
 390 #define MAX_FACES_AND_GLYPHS 256
 391 extern struct face *x_face_table[];
 392
 393 \f
 394 /* X-specific scroll bar stuff.  */
 395
 396 /* We represent scroll bars as lisp vectors.  This allows us to place
 397    references to them in windows without worrying about whether we'll
 398    end up with windows referring to dead scroll bars; the garbage
 399    collector will free it when its time comes.
 400
 401    We use struct scroll_bar as a template for accessing fields of the
 402    vector.  */
 403
 404 struct scroll_bar {
 405
 406   /* These fields are shared by all vectors.  */
 407   int size_from_Lisp_Vector_struct;
 408   struct Lisp_Vector *next_from_Lisp_Vector_struct;
 409
 410   /* The window we're a scroll bar for.  */
 411   Lisp_Object window;
 412
 413   /* The next and previous in the chain of scroll bars in this frame.  */
 414   Lisp_Object next, prev;
 415
 416   /* The X window representing this scroll bar.  Since this is a full
 417      32-bit quantity, we store it split into two 32-bit values.  */
 418   Lisp_Object x_window_low, x_window_high;
 419
 420   /* The position and size of the scroll bar in pixels, relative to the
 421      frame.  */
 422   Lisp_Object top, left, width, height;
 423
 424   /* The starting and ending positions of the handle, relative to the
 425      handle area (i.e. zero is the top position, not
 426      SCROLL_BAR_TOP_BORDER).  If they're equal, that means the handle
 427      hasn't been drawn yet.
 428
 429      These are not actually the locations where the beginning and end
 430      are drawn; in order to keep handles from becoming invisible when
 431      editing large files, we establish a minimum height by always
 432      drawing handle bottoms VERTICAL_SCROLL_BAR_MIN_HANDLE pixels below
 433      where they would be normally; the bottom and top are in a
 434      different co-ordinate system.  */
 435   Lisp_Object start, end;
 436
 437   /* If the scroll bar handle is currently being dragged by the user,
 438      this is the number of pixels from the top of the handle to the
 439      place where the user grabbed it.  If the handle isn't currently
 440      being dragged, this is Qnil.  */
 441   Lisp_Object dragging;
 442 };
 443
 444 /* The number of elements a vector holding a struct scroll_bar needs.  */
 445 #define SCROLL_BAR_VEC_SIZE \
 446   ((sizeof (struct scroll_bar) - sizeof (int) - sizeof (struct Lisp_Vector *)) \
 447    / sizeof (Lisp_Object))
 448
 449 /* Turning a lisp vector value into a pointer to a struct scroll_bar.  */
 450 #define XSCROLL_BAR(vec) ((struct scroll_bar *) XPNTR (vec))
 451
 452
 453 /* Building a 32-bit C integer from two 16-bit lisp integers.  */
 454 #define SCROLL_BAR_PACK(low, high) (XINT (high) << 16 | XINT (low))
 455
 456 /* Setting two lisp integers to the low and high words of a 32-bit C int.  */
 457 #define SCROLL_BAR_UNPACK(low, high, int32) \
 458   (XSET ((low),  Lisp_Int,  (int32)        & 0xffff), \
 459    XSET ((high), Lisp_Int, ((int32) >> 16) & 0xffff))
 460
 461
 462 /* Extract the X window id of the scroll bar from a struct scroll_bar.  */
 463 #define SCROLL_BAR_X_WINDOW(ptr) \
 464   ((Window) SCROLL_BAR_PACK ((ptr)->x_window_low, (ptr)->x_window_high))
 465
 466 /* Store a window id in a struct scroll_bar.  */
 467 #define SET_SCROLL_BAR_X_WINDOW(ptr, id) \
 468   (SCROLL_BAR_UNPACK ((ptr)->x_window_low, (ptr)->x_window_high, (int) id))
 469
 470
 471 /* Return the outside pixel width for a vertical scroll bar on frame F.  */
 472 #define VERTICAL_SCROLL_BAR_PIXEL_WIDTH(f) (2*FONT_WIDTH ((f)->display.x->font))
 473
 474 /* Return the outside pixel height for a vertical scroll bar HEIGHT
 475    rows high on frame F.  */
 476 #define VERTICAL_SCROLL_BAR_PIXEL_HEIGHT(f, height) \
 477   ((height) * FONT_HEIGHT ((f)->display.x->font))
 478
 479 /* Return the inside width of a vertical scroll bar, given the outside
 480    width.  */
 481 #define VERTICAL_SCROLL_BAR_INSIDE_WIDTH(width) \
 482   ((width) - VERTICAL_SCROLL_BAR_LEFT_BORDER - VERTICAL_SCROLL_BAR_RIGHT_BORDER)
 483
 484 /* Return the length of the rectangle within which the top of the
 485    handle must stay.  This isn't equivalent to the inside height,
 486    because the scroll bar handle has a minimum height.
 487
 488    This is the real range of motion for the scroll bar, so when we're
 489    scaling buffer positions to scroll bar positions, we use this, not
 490    VERTICAL_SCROLL_BAR_INSIDE_HEIGHT.  */
 491 #define VERTICAL_SCROLL_BAR_TOP_RANGE(height) \
 492   (VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (height) - VERTICAL_SCROLL_BAR_MIN_HANDLE)
 493
 494 /* Return the inside height of vertical scroll bar, given the outside
 495    height.  See VERTICAL_SCROLL_BAR_TOP_RANGE too.  */
 496 #define VERTICAL_SCROLL_BAR_INSIDE_HEIGHT(height) \
 497   ((height) - VERTICAL_SCROLL_BAR_TOP_BORDER - VERTICAL_SCROLL_BAR_BOTTOM_BORDER)
 498
 499
 500 /* Border widths for scroll bars.
 501
 502    Scroll bar windows don't have any X borders; their border width is
 503    set to zero, and we redraw borders ourselves.  This makes the code
 504    a bit cleaner, since we don't have to convert between outside width
 505    (used when relating to the rest of the screen) and inside width
 506    (used when sizing and drawing the scroll bar window itself).
 507
 508    The handle moves up and down/back and forth in a rectange inset
 509    from the edges of the scroll bar.  These are widths by which we
 510    inset the handle boundaries from the scroll bar edges.  */
 511 #define VERTICAL_SCROLL_BAR_LEFT_BORDER (2)
 512 #define VERTICAL_SCROLL_BAR_RIGHT_BORDER (3)
 513 #define VERTICAL_SCROLL_BAR_TOP_BORDER (2)
 514 #define VERTICAL_SCROLL_BAR_BOTTOM_BORDER (2)
 515
 516 /* Minimum lengths for scroll bar handles, in pixels.  */
 517 #define VERTICAL_SCROLL_BAR_MIN_HANDLE (5)
 518
 519 \f
 520 /* Manipulating pixel sizes and character sizes.
 521    Knowledge of which factors affect the overall size of the window should
 522    be hidden in these macros, if that's possible.
 523
 524 /* Return the upper/left pixel position of the character cell on frame F
 525    at ROW/COL.  */
 526 #define CHAR_TO_PIXEL_ROW(f, row) \
 527   ((f)->display.x->internal_border_width \
 528    + (row) * FONT_HEIGHT ((f)->display.x->font))
 529 #define CHAR_TO_PIXEL_COL(f, col) \
 530   ((f)->display.x->internal_border_width \
 531    + (col) * FONT_WIDTH ((f)->display.x->font))
 532
 533 /* Return the pixel width/height of frame F if it has
 534    WIDTH columns/HEIGHT rows.  */
 535 #define CHAR_TO_PIXEL_WIDTH(f, width) \
 536   (CHAR_TO_PIXEL_COL (f, width) \
 537    + (f)->display.x->vertical_scroll_bar_extra \
 538    + (f)->display.x->internal_border_width)
 539 #define CHAR_TO_PIXEL_HEIGHT(f, height) \
 540   (CHAR_TO_PIXEL_ROW (f, height) \
 541    + (f)->display.x->internal_border_width)
 542
 543
 544 /* Return the row/column (zero-based) of the character cell containing
 545    the pixel on FRAME at ROW/COL.  */
 546 #define PIXEL_TO_CHAR_ROW(frame, row) \
 547   (((row) - (f)->display.x->internal_border_width) \
 548    / FONT_HEIGHT ((f)->display.x->font))
 549 #define PIXEL_TO_CHAR_COL(frame, col) \
 550   (((col) - (f)->display.x->internal_border_width) \
 551    / FONT_WIDTH ((f)->display.x->font))
 552
 553 /* How many columns/rows of text can we fit in WIDTH/HEIGHT pixels on
 554    frame F?  */
 555 #define PIXEL_TO_CHAR_WIDTH(f, width) \
 556   (PIXEL_TO_CHAR_COL (f, ((width) \
 557                           - (f)->display.x->internal_border_width \
 558                           - (f)->display.x->vertical_scroll_bar_extra)))
 559 #define PIXEL_TO_CHAR_HEIGHT(f, height) \
 560   (PIXEL_TO_CHAR_ROW (f, ((height) \
 561                           - (f)->display.x->internal_border_width)))
 562 \f
 563 /* If a struct input_event has a kind which is selection_request_event
 564    or selection_clear_event, then its contents are really described
 565    by this structure.  */
 566
 567 /* For an event of kind selection_request_event,
 568    this structure really describes the contents.  */
 569 struct selection_input_event
 570 {
 571   int kind;
 572   Display *display;
 573   Window requestor;
 574   Atom selection, target, property;
 575   Time time;
 576 };
 577
 578 #define SELECTION_EVENT_DISPLAY(eventp) \
 579   (((struct selection_input_event *) (eventp))->display)
 580 #define SELECTION_EVENT_REQUESTOR(eventp)       \
 581   (((struct selection_input_event *) (eventp))->requestor)
 582 #define SELECTION_EVENT_SELECTION(eventp)       \
 583   (((struct selection_input_event *) (eventp))->selection)
 584 #define SELECTION_EVENT_TARGET(eventp)  \
 585   (((struct selection_input_event *) (eventp))->target)
 586 #define SELECTION_EVENT_PROPERTY(eventp)        \
 587   (((struct selection_input_event *) (eventp))->property)
 588 #define SELECTION_EVENT_TIME(eventp)    \
 589   (((struct selection_input_event *) (eventp))->time)