eventstr.h revision 35c4bbdf 
1/*
2 * Copyright © 2009 Red Hat, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 *
23 */
24
25#ifndef EVENTSTR_H
26#define EVENTSTR_H
27
28#include <events.h>
29/**
30 * @file events.h
31 * This file describes the event structures used internally by the X
32 * server during event generation and event processing.
33 *
34 * When are internal events used?
35 * Events from input devices are stored as internal events in the EQ and
36 * processed as internal events until late in the processing cycle. Only then
37 * do they switch to their respective wire events.
38 */
39
40/**
41 * Event types. Used exclusively internal to the server, not visible on the
42 * protocol.
43 *
44 * Note: Keep KeyPress to Motion aligned with the core events.
45 *       Keep ET_Raw* in the same order as KeyPress - Motion
46 */
47enum EventType {
48    ET_KeyPress = 2,
49    ET_KeyRelease,
50    ET_ButtonPress,
51    ET_ButtonRelease,
52    ET_Motion,
53    ET_TouchBegin,
54    ET_TouchUpdate,
55    ET_TouchEnd,
56    ET_TouchOwnership,
57    ET_Enter,
58    ET_Leave,
59    ET_FocusIn,
60    ET_FocusOut,
61    ET_ProximityIn,
62    ET_ProximityOut,
63    ET_DeviceChanged,
64    ET_Hierarchy,
65    ET_DGAEvent,
66    ET_RawKeyPress,
67    ET_RawKeyRelease,
68    ET_RawButtonPress,
69    ET_RawButtonRelease,
70    ET_RawMotion,
71    ET_RawTouchBegin,
72    ET_RawTouchUpdate,
73    ET_RawTouchEnd,
74    ET_XQuartz,
75    ET_BarrierHit,
76    ET_BarrierLeave,
77    ET_Internal = 0xFF          /* First byte */
78};
79
80/**
81 * Used for ALL input device events internal in the server until
82 * copied into the matching protocol event.
83 *
84 * Note: We only use the device id because the DeviceIntPtr may become invalid while
85 * the event is in the EQ.
86 */
87struct _DeviceEvent {
88    unsigned char header; /**< Always ET_Internal */
89    enum EventType type;  /**< One of EventType */
90    int length;           /**< Length in bytes */
91    Time time;            /**< Time in ms */
92    int deviceid;         /**< Device to post this event for */
93    int sourceid;         /**< The physical source device */
94    union {
95        uint32_t button;  /**< Button number (also used in pointer emulating
96                               touch events) */
97        uint32_t key;     /**< Key code */
98    } detail;
99    uint32_t touchid;     /**< Touch ID (client_id) */
100    int16_t root_x;       /**< Pos relative to root window in integral data */
101    float root_x_frac;    /**< Pos relative to root window in frac part */
102    int16_t root_y;       /**< Pos relative to root window in integral part */
103    float root_y_frac;    /**< Pos relative to root window in frac part */
104    uint8_t buttons[(MAX_BUTTONS + 7) / 8];  /**< Button mask */
105    struct {
106        uint8_t mask[(MAX_VALUATORS + 7) / 8];/**< Valuator mask */
107        uint8_t mode[(MAX_VALUATORS + 7) / 8];/**< Valuator mode (Abs or Rel)*/
108        double data[MAX_VALUATORS];           /**< Valuator data */
109    } valuators;
110    struct {
111        uint32_t base;    /**< XKB base modifiers */
112        uint32_t latched; /**< XKB latched modifiers */
113        uint32_t locked;  /**< XKB locked modifiers */
114        uint32_t effective;/**< XKB effective modifiers */
115    } mods;
116    struct {
117        uint8_t base;    /**< XKB base group */
118        uint8_t latched; /**< XKB latched group */
119        uint8_t locked;  /**< XKB locked group */
120        uint8_t effective;/**< XKB effective group */
121    } group;
122    Window root;      /**< Root window of the event */
123    int corestate;    /**< Core key/button state BEFORE the event */
124    int key_repeat;   /**< Internally-generated key repeat event */
125    uint32_t flags;   /**< Flags to be copied into the generated event */
126    uint32_t resource; /**< Touch event resource, only for TOUCH_REPLAYING */
127};
128
129/**
130 * Generated internally whenever a touch ownership chain changes - an owner
131 * has accepted or rejected a touch, or a grab/event selection in the delivery
132 * chain has been removed.
133 */
134struct _TouchOwnershipEvent {
135    unsigned char header; /**< Always ET_Internal */
136    enum EventType type;  /**< ET_TouchOwnership */
137    int length;           /**< Length in bytes */
138    Time time;            /**< Time in ms */
139    int deviceid;         /**< Device to post this event for */
140    int sourceid;         /**< The physical source device */
141    uint32_t touchid;     /**< Touch ID (client_id) */
142    uint8_t reason;       /**< ::XIAcceptTouch, ::XIRejectTouch */
143    uint32_t resource;    /**< Provoking grab or event selection */
144    uint32_t flags;       /**< Flags to be copied into the generated event */
145};
146
147/* Flags used in DeviceChangedEvent to signal if the slave has changed */
148#define DEVCHANGE_SLAVE_SWITCH 0x2
149/* Flags used in DeviceChangedEvent to signal whether the event was a
150 * pointer event or a keyboard event */
151#define DEVCHANGE_POINTER_EVENT 0x4
152#define DEVCHANGE_KEYBOARD_EVENT 0x8
153/* device capabilities changed */
154#define DEVCHANGE_DEVICE_CHANGE 0x10
155
156/**
157 * Sent whenever a device's capabilities have changed.
158 */
159struct _DeviceChangedEvent {
160    unsigned char header; /**< Always ET_Internal */
161    enum EventType type;  /**< ET_DeviceChanged */
162    int length;           /**< Length in bytes */
163    Time time;            /**< Time in ms */
164    int deviceid;         /**< Device whose capabilities have changed */
165    int flags;            /**< Mask of ::HAS_NEW_SLAVE,
166                               ::POINTER_EVENT, ::KEYBOARD_EVENT */
167    int masterid;         /**< MD when event was generated */
168    int sourceid;         /**< The device that caused the change */
169
170    struct {
171        int num_buttons;        /**< Number of buttons */
172        Atom names[MAX_BUTTONS];/**< Button names */
173    } buttons;
174
175    int num_valuators;          /**< Number of axes */
176    struct {
177        uint32_t min;           /**< Minimum value */
178        uint32_t max;           /**< Maximum value */
179        double value;           /**< Current value */
180        /* FIXME: frac parts of min/max */
181        uint32_t resolution;    /**< Resolution counts/m */
182        uint8_t mode;           /**< Relative or Absolute */
183        Atom name;              /**< Axis name */
184        ScrollInfo scroll;      /**< Smooth scrolling info */
185    } valuators[MAX_VALUATORS];
186
187    struct {
188        int min_keycode;
189        int max_keycode;
190    } keys;
191};
192
193#if XFreeXDGA
194/**
195 * DGAEvent, used by DGA to intercept and emulate input events.
196 */
197struct _DGAEvent {
198    unsigned char header; /**<  Always ET_Internal */
199    enum EventType type;  /**<  ET_DGAEvent */
200    int length;           /**<  Length in bytes */
201    Time time;            /**<  Time in ms */
202    int subtype;          /**<  KeyPress, KeyRelease, ButtonPress,
203                                ButtonRelease, MotionNotify */
204    int detail;           /**<  Button number or key code */
205    int dx;               /**<  Relative x coordinate */
206    int dy;               /**<  Relative y coordinate */
207    int screen;           /**<  Screen number this event applies to */
208    uint16_t state;       /**<  Core modifier/button state */
209};
210#endif
211
212/**
213 * Raw event, contains the data as posted by the device.
214 */
215struct _RawDeviceEvent {
216    unsigned char header; /**<  Always ET_Internal */
217    enum EventType type;  /**<  ET_Raw */
218    int length;           /**<  Length in bytes */
219    Time time;            /**<  Time in ms */
220    int deviceid;         /**< Device to post this event for */
221    int sourceid;         /**< The physical source device */
222    union {
223        uint32_t button;  /**< Button number */
224        uint32_t key;     /**< Key code */
225    } detail;
226    struct {
227        uint8_t mask[(MAX_VALUATORS + 7) / 8];/**< Valuator mask */
228        double data[MAX_VALUATORS];           /**< Valuator data */
229        double data_raw[MAX_VALUATORS];       /**< Valuator data as posted */
230    } valuators;
231    uint32_t flags;       /**< Flags to be copied into the generated event */
232};
233
234struct _BarrierEvent {
235    unsigned char header; /**<  Always ET_Internal */
236    enum EventType type;  /**<  ET_BarrierHit, ET_BarrierLeave */
237    int length;           /**<  Length in bytes */
238    Time time;            /**<  Time in ms */
239    int deviceid;         /**< Device to post this event for */
240    int sourceid;         /**< The physical source device */
241    int barrierid;
242    Window window;
243    Window root;
244    double dx;
245    double dy;
246    double root_x;
247    double root_y;
248    int16_t dt;
249    int32_t event_id;
250    uint32_t flags;
251};
252
253#ifdef XQUARTZ
254#define XQUARTZ_EVENT_MAXARGS 5
255struct _XQuartzEvent {
256    unsigned char header; /**< Always ET_Internal */
257    enum EventType type;  /**< Always ET_XQuartz */
258    int length;           /**< Length in bytes */
259    Time time;            /**< Time in ms. */
260    int subtype;          /**< Subtype defined by XQuartz DDX */
261    uint32_t data[XQUARTZ_EVENT_MAXARGS]; /**< Up to 5 32bit values passed to handler */
262};
263#endif
264
265/**
266 * Event type used inside the X server for input event
267 * processing.
268 */
269union _InternalEvent {
270    struct {
271        unsigned char header;     /**< Always ET_Internal */
272        enum EventType type;      /**< One of ET_* */
273        int length;               /**< Length in bytes */
274        Time time;                /**< Time in ms. */
275    } any;
276    DeviceEvent device_event;
277    DeviceChangedEvent changed_event;
278    TouchOwnershipEvent touch_ownership_event;
279    BarrierEvent barrier_event;
280#if XFreeXDGA
281    DGAEvent dga_event;
282#endif
283    RawDeviceEvent raw_event;
284#ifdef XQUARTZ
285    XQuartzEvent xquartz_event;
286#endif
287};
288
289#endif
290