[deb_xorg-server.git] / include / eventstr.h

/*
 * Copyright © 2009 Red Hat, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 */

#ifndef EVENTSTR_H
#define EVENTSTR_H

#include <events.h>
/**
 * @file events.h
 * This file describes the event structures used internally by the X
 * server during event generation and event processing.
 *
 * When are internal events used?
 * Events from input devices are stored as internal events in the EQ and
 * processed as internal events until late in the processing cycle. Only then
 * do they switch to their respective wire events.
 */

/**
 * Event types. Used exclusively internal to the server, not visible on the
 * protocol.
 *
 * Note: Keep KeyPress to Motion aligned with the core events.
 *       Keep ET_Raw* in the same order as KeyPress - Motion
 */
enum EventType {
    ET_KeyPress = 2,
    ET_KeyRelease,
    ET_ButtonPress,
    ET_ButtonRelease,
    ET_Motion,
    ET_TouchBegin,
    ET_TouchUpdate,
    ET_TouchEnd,
    ET_TouchOwnership,
    ET_Enter,
    ET_Leave,
    ET_FocusIn,
    ET_FocusOut,
    ET_ProximityIn,
    ET_ProximityOut,
    ET_DeviceChanged,
    ET_Hierarchy,
    ET_DGAEvent,
    ET_RawKeyPress,
    ET_RawKeyRelease,
    ET_RawButtonPress,
    ET_RawButtonRelease,
    ET_RawMotion,
    ET_RawTouchBegin,
    ET_RawTouchUpdate,
    ET_RawTouchEnd,
    ET_XQuartz,
    ET_BarrierHit,
    ET_BarrierLeave,
    ET_Internal = 0xFF          /* First byte */
};

/**
 * Used for ALL input device events internal in the server until
 * copied into the matching protocol event.
 *
 * Note: We only use the device id because the DeviceIntPtr may become invalid while
 * the event is in the EQ.
 */
struct _DeviceEvent {
    unsigned char header; /**< Always ET_Internal */
    enum EventType type;  /**< One of EventType */
    int length;           /**< Length in bytes */
    Time time;            /**< Time in ms */
    int deviceid;         /**< Device to post this event for */
    int sourceid;         /**< The physical source device */
    union {
        uint32_t button;  /**< Button number (also used in pointer emulating
                               touch events) */
        uint32_t key;     /**< Key code */
    } detail;
    uint32_t touchid;     /**< Touch ID (client_id) */
    int16_t root_x;       /**< Pos relative to root window in integral data */
    float root_x_frac;    /**< Pos relative to root window in frac part */
    int16_t root_y;       /**< Pos relative to root window in integral part */
    float root_y_frac;    /**< Pos relative to root window in frac part */
    uint8_t buttons[(MAX_BUTTONS + 7) / 8];  /**< Button mask */
    struct {
        uint8_t mask[(MAX_VALUATORS + 7) / 8];/**< Valuator mask */
        uint8_t mode[(MAX_VALUATORS + 7) / 8];/**< Valuator mode (Abs or Rel)*/
        double data[MAX_VALUATORS];           /**< Valuator data */
    } valuators;
    struct {
        uint32_t base;    /**< XKB base modifiers */
        uint32_t latched; /**< XKB latched modifiers */
        uint32_t locked;  /**< XKB locked modifiers */
        uint32_t effective;/**< XKB effective modifiers */
    } mods;
    struct {
        uint8_t base;    /**< XKB base group */
        uint8_t latched; /**< XKB latched group */
        uint8_t locked;  /**< XKB locked group */
        uint8_t effective;/**< XKB effective group */
    } group;
    Window root;      /**< Root window of the event */
    int corestate;    /**< Core key/button state BEFORE the event */
    int key_repeat;   /**< Internally-generated key repeat event */
    uint32_t flags;   /**< Flags to be copied into the generated event */
    uint32_t resource; /**< Touch event resource, only for TOUCH_REPLAYING */
};

/**
 * Generated internally whenever a touch ownership chain changes - an owner
 * has accepted or rejected a touch, or a grab/event selection in the delivery
 * chain has been removed.
 */
struct _TouchOwnershipEvent {
    unsigned char header; /**< Always ET_Internal */
    enum EventType type;  /**< ET_TouchOwnership */
    int length;           /**< Length in bytes */
    Time time;            /**< Time in ms */
    int deviceid;         /**< Device to post this event for */
    int sourceid;         /**< The physical source device */
    uint32_t touchid;     /**< Touch ID (client_id) */
    uint8_t reason;       /**< ::XIAcceptTouch, ::XIRejectTouch */
    uint32_t resource;    /**< Provoking grab or event selection */
    uint32_t flags;       /**< Flags to be copied into the generated event */
};

/* Flags used in DeviceChangedEvent to signal if the slave has changed */
#define DEVCHANGE_SLAVE_SWITCH 0x2
/* Flags used in DeviceChangedEvent to signal whether the event was a
 * pointer event or a keyboard event */
#define DEVCHANGE_POINTER_EVENT 0x4
#define DEVCHANGE_KEYBOARD_EVENT 0x8
/* device capabilities changed */
#define DEVCHANGE_DEVICE_CHANGE 0x10

/**
 * Sent whenever a device's capabilities have changed.
 */
struct _DeviceChangedEvent {
    unsigned char header; /**< Always ET_Internal */
    enum EventType type;  /**< ET_DeviceChanged */
    int length;           /**< Length in bytes */
    Time time;            /**< Time in ms */
    int deviceid;         /**< Device whose capabilities have changed */
    int flags;            /**< Mask of ::HAS_NEW_SLAVE,
                               ::POINTER_EVENT, ::KEYBOARD_EVENT */
    int masterid;         /**< MD when event was generated */
    int sourceid;         /**< The device that caused the change */

    struct {
        int num_buttons;        /**< Number of buttons */
        Atom names[MAX_BUTTONS];/**< Button names */
    } buttons;

    int num_valuators;          /**< Number of axes */
    struct {
        uint32_t min;           /**< Minimum value */
        uint32_t max;           /**< Maximum value */
        double value;           /**< Current value */;
        /* FIXME: frac parts of min/max */
        uint32_t resolution;    /**< Resolution counts/m */
        uint8_t mode;           /**< Relative or Absolute */
        Atom name;              /**< Axis name */
        ScrollInfo scroll;      /**< Smooth scrolling info */
    } valuators[MAX_VALUATORS];

    struct {
        int min_keycode;
        int max_keycode;
    } keys;
};

#if XFreeXDGA
/**
 * DGAEvent, used by DGA to intercept and emulate input events.
 */
struct _DGAEvent {
    unsigned char header; /**<  Always ET_Internal */
    enum EventType type;  /**<  ET_DGAEvent */
    int length;           /**<  Length in bytes */
    Time time;            /**<  Time in ms */
    int subtype;          /**<  KeyPress, KeyRelease, ButtonPress,
                                ButtonRelease, MotionNotify */
    int detail;           /**<  Button number or key code */
    int dx;               /**<  Relative x coordinate */
    int dy;               /**<  Relative y coordinate */
    int screen;           /**<  Screen number this event applies to */
    uint16_t state;       /**<  Core modifier/button state */
};
#endif

/**
 * Raw event, contains the data as posted by the device.
 */
struct _RawDeviceEvent {
    unsigned char header; /**<  Always ET_Internal */
    enum EventType type;  /**<  ET_Raw */
    int length;           /**<  Length in bytes */
    Time time;            /**<  Time in ms */
    int deviceid;         /**< Device to post this event for */
    int sourceid;         /**< The physical source device */
    union {
        uint32_t button;  /**< Button number */
        uint32_t key;     /**< Key code */
    } detail;
    struct {
        uint8_t mask[(MAX_VALUATORS + 7) / 8];/**< Valuator mask */
        double data[MAX_VALUATORS];           /**< Valuator data */
        double data_raw[MAX_VALUATORS];       /**< Valuator data as posted */
    } valuators;
    uint32_t flags;       /**< Flags to be copied into the generated event */
};

struct _BarrierEvent {
    unsigned char header; /**<  Always ET_Internal */
    enum EventType type;  /**<  ET_BarrierHit, ET_BarrierLeave */
    int length;           /**<  Length in bytes */
    Time time;            /**<  Time in ms */
    int deviceid;         /**< Device to post this event for */
    int sourceid;         /**< The physical source device */
    int barrierid;
    Window window;
    Window root;
    double dx;
    double dy;
    double root_x;
    double root_y;
    int16_t dt;
    int32_t event_id;
    uint32_t flags;
};

#ifdef XQUARTZ
#define XQUARTZ_EVENT_MAXARGS 5
struct _XQuartzEvent {
    unsigned char header; /**< Always ET_Internal */
    enum EventType type;  /**< Always ET_XQuartz */
    int length;           /**< Length in bytes */
    Time time;            /**< Time in ms. */
    int subtype;          /**< Subtype defined by XQuartz DDX */
    uint32_t data[XQUARTZ_EVENT_MAXARGS]; /**< Up to 5 32bit values passed to handler */
};
#endif

/**
 * Event type used inside the X server for input event
 * processing.
 */
union _InternalEvent {
    struct {
        unsigned char header;     /**< Always ET_Internal */
        enum EventType type;      /**< One of ET_* */
        int length;               /**< Length in bytes */
        Time time;                /**< Time in ms. */
    } any;
    DeviceEvent device_event;
    DeviceChangedEvent changed_event;
    TouchOwnershipEvent touch_ownership_event;
    BarrierEvent barrier_event;
#if XFreeXDGA
    DGAEvent dga_event;
#endif
    RawDeviceEvent raw_event;
#ifdef XQUARTZ
    XQuartzEvent xquartz_event;
#endif
};

#endif
Commit	Line	Data
a09e091a JB	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	*/
	47	enum 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	*/
87	struct _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	*/
134	struct _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	*/
159	struct _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	*/
197	struct _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	*/
215	struct _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
234	struct _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
255	struct _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	*/
269	union _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