| 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 |