| 1 | /************************************************************ |
| 2 | |
| 3 | Copyright 1987, 1998 The Open Group |
| 4 | |
| 5 | Permission to use, copy, modify, distribute, and sell this software and its |
| 6 | documentation for any purpose is hereby granted without fee, provided that |
| 7 | the above copyright notice appear in all copies and that both that |
| 8 | copyright notice and this permission notice appear in supporting |
| 9 | documentation. |
| 10 | |
| 11 | The above copyright notice and this permission notice shall be included in |
| 12 | all copies or substantial portions of the Software. |
| 13 | |
| 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 17 | OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN |
| 18 | AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| 19 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 20 | |
| 21 | Except as contained in this notice, the name of The Open Group shall not be |
| 22 | used in advertising or otherwise to promote the sale, use or other dealings |
| 23 | in this Software without prior written authorization from The Open Group. |
| 24 | |
| 25 | Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. |
| 26 | |
| 27 | All Rights Reserved |
| 28 | |
| 29 | Permission to use, copy, modify, and distribute this software and its |
| 30 | documentation for any purpose and without fee is hereby granted, |
| 31 | provided that the above copyright notice appear in all copies and that |
| 32 | both that copyright notice and this permission notice appear in |
| 33 | supporting documentation, and that the name of Digital not be |
| 34 | used in advertising or publicity pertaining to distribution of the |
| 35 | software without specific, written prior permission. |
| 36 | |
| 37 | DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING |
| 38 | ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL |
| 39 | DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR |
| 40 | ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, |
| 41 | WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, |
| 42 | ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
| 43 | SOFTWARE. |
| 44 | |
| 45 | ********************************************************/ |
| 46 | |
| 47 | #ifndef INPUTSTRUCT_H |
| 48 | #define INPUTSTRUCT_H |
| 49 | |
| 50 | #include <X11/extensions/XI2proto.h> |
| 51 | |
| 52 | #include <pixman.h> |
| 53 | #include "input.h" |
| 54 | #include "window.h" |
| 55 | #include "dixstruct.h" |
| 56 | #include "cursorstr.h" |
| 57 | #include "geext.h" |
| 58 | #include "privates.h" |
| 59 | |
| 60 | #define BitIsOn(ptr, bit) (!!(((const BYTE *) (ptr))[(bit)>>3] & (1 << ((bit) & 7)))) |
| 61 | #define SetBit(ptr, bit) (((BYTE *) (ptr))[(bit)>>3] |= (1 << ((bit) & 7))) |
| 62 | #define ClearBit(ptr, bit) (((BYTE *)(ptr))[(bit)>>3] &= ~(1 << ((bit) & 7))) |
| 63 | extern _X_EXPORT int CountBits(const uint8_t * mask, int len); |
| 64 | |
| 65 | #define SameClient(obj,client) \ |
| 66 | (CLIENT_BITS((obj)->resource) == (client)->clientAsMask) |
| 67 | |
| 68 | #define EMASKSIZE (MAXDEVICES + 2) |
| 69 | |
| 70 | /* This is the last XI2 event supported by the server. If you add |
| 71 | * events to the protocol, the server will not support these events until |
| 72 | * this number here is bumped. |
| 73 | */ |
| 74 | #define XI2LASTEVENT XI_BarrierLeave |
| 75 | #define XI2MASKSIZE ((XI2LASTEVENT >> 3) + 1) /* no of bytes for masks */ |
| 76 | |
| 77 | /** |
| 78 | * Scroll types for ::SetScrollValuator and the scroll type in the |
| 79 | * ::ScrollInfoPtr. |
| 80 | */ |
| 81 | enum ScrollType { |
| 82 | SCROLL_TYPE_NONE = 0, /**< Not a scrolling valuator */ |
| 83 | SCROLL_TYPE_VERTICAL = 8, |
| 84 | SCROLL_TYPE_HORIZONTAL = 9, |
| 85 | }; |
| 86 | |
| 87 | /** |
| 88 | * This struct stores the core event mask for each client except the client |
| 89 | * that created the window. |
| 90 | * |
| 91 | * Each window that has events selected from other clients has at least one of |
| 92 | * these masks. If multiple clients selected for events on the same window, |
| 93 | * these masks are in a linked list. |
| 94 | * |
| 95 | * The event mask for the client that created the window is stored in |
| 96 | * win->eventMask instead. |
| 97 | * |
| 98 | * The resource id is simply a fake client ID to associate this mask with a |
| 99 | * client. |
| 100 | * |
| 101 | * Kludge: OtherClients and InputClients must be compatible, see code. |
| 102 | */ |
| 103 | typedef struct _OtherClients { |
| 104 | OtherClientsPtr next; /**< Pointer to the next mask */ |
| 105 | XID resource; /**< id for putting into resource manager */ |
| 106 | Mask mask; /**< Core event mask */ |
| 107 | } OtherClients; |
| 108 | |
| 109 | /** |
| 110 | * This struct stores the XI event mask for each client. |
| 111 | * |
| 112 | * Each window that has events selected has at least one of these masks. If |
| 113 | * multiple client selected for events on the same window, these masks are in |
| 114 | * a linked list. |
| 115 | */ |
| 116 | typedef struct _InputClients { |
| 117 | InputClientsPtr next; /**< Pointer to the next mask */ |
| 118 | XID resource; /**< id for putting into resource manager */ |
| 119 | Mask mask[EMASKSIZE]; /**< Actual XI event mask, deviceid is index */ |
| 120 | /** XI2 event masks. One per device, each bit is a mask of (1 << type) */ |
| 121 | struct _XI2Mask *xi2mask; |
| 122 | } InputClients; |
| 123 | |
| 124 | /** |
| 125 | * Combined XI event masks from all devices. |
| 126 | * |
| 127 | * This is the XI equivalent of the deliverableEvents, eventMask and |
| 128 | * dontPropagate mask of the WindowRec (or WindowOptRec). |
| 129 | * |
| 130 | * A window that has an XI client selecting for events has exactly one |
| 131 | * OtherInputMasks struct and exactly one InputClients struct hanging off |
| 132 | * inputClients. Each further client appends to the inputClients list. |
| 133 | * Each Mask field is per-device, with the device id as the index. |
| 134 | * Exception: for non-device events (Presence events), the MAXDEVICES |
| 135 | * deviceid is used. |
| 136 | */ |
| 137 | typedef struct _OtherInputMasks { |
| 138 | /** |
| 139 | * Bitwise OR of all masks by all clients and the window's parent's masks. |
| 140 | */ |
| 141 | Mask deliverableEvents[EMASKSIZE]; |
| 142 | /** |
| 143 | * Bitwise OR of all masks by all clients on this window. |
| 144 | */ |
| 145 | Mask inputEvents[EMASKSIZE]; |
| 146 | /** The do-not-propagate masks for each device. */ |
| 147 | Mask dontPropagateMask[EMASKSIZE]; |
| 148 | /** The clients that selected for events */ |
| 149 | InputClientsPtr inputClients; |
| 150 | /* XI2 event masks. One per device, each bit is a mask of (1 << type) */ |
| 151 | struct _XI2Mask *xi2mask; |
| 152 | } OtherInputMasks; |
| 153 | |
| 154 | /* |
| 155 | * The following structure gets used for both active and passive grabs. For |
| 156 | * active grabs some of the fields (e.g. modifiers) are not used. However, |
| 157 | * that is not much waste since there aren't many active grabs (one per |
| 158 | * keyboard/pointer device) going at once in the server. |
| 159 | */ |
| 160 | |
| 161 | #define MasksPerDetailMask 8 /* 256 keycodes and 256 possible |
| 162 | modifier combinations, but only |
| 163 | 3 buttons. */ |
| 164 | |
| 165 | typedef struct _DetailRec { /* Grab details may be bit masks */ |
| 166 | unsigned int exact; |
| 167 | Mask *pMask; |
| 168 | } DetailRec; |
| 169 | |
| 170 | union _GrabMask { |
| 171 | Mask core; |
| 172 | Mask xi; |
| 173 | struct _XI2Mask *xi2mask; |
| 174 | }; |
| 175 | |
| 176 | /** |
| 177 | * Central struct for device grabs. |
| 178 | * The same struct is used for both core grabs and device grabs, with |
| 179 | * different fields being set. |
| 180 | * If the grab is a core grab (GrabPointer/GrabKeyboard), then the eventMask |
| 181 | * is a combination of standard event masks (i.e. PointerMotionMask | |
| 182 | * ButtonPressMask). |
| 183 | * If the grab is a device grab (GrabDevice), then the eventMask is a |
| 184 | * combination of event masks for a given XI event type (see SetEventInfo). |
| 185 | * |
| 186 | * If the grab is a result of a ButtonPress, then eventMask is the core mask |
| 187 | * and deviceMask is set to the XI event mask for the grab. |
| 188 | */ |
| 189 | typedef struct _GrabRec { |
| 190 | GrabPtr next; /* for chain of passive grabs */ |
| 191 | XID resource; |
| 192 | DeviceIntPtr device; |
| 193 | WindowPtr window; |
| 194 | unsigned ownerEvents:1; |
| 195 | unsigned keyboardMode:1; |
| 196 | unsigned pointerMode:1; |
| 197 | enum InputLevel grabtype; |
| 198 | CARD8 type; /* event type for passive grabs, 0 for active grabs */ |
| 199 | DetailRec modifiersDetail; |
| 200 | DeviceIntPtr modifierDevice; |
| 201 | DetailRec detail; /* key or button */ |
| 202 | WindowPtr confineTo; /* always NULL for keyboards */ |
| 203 | CursorPtr cursor; /* always NULL for keyboards */ |
| 204 | Mask eventMask; |
| 205 | Mask deviceMask; |
| 206 | /* XI2 event masks. One per device, each bit is a mask of (1 << type) */ |
| 207 | struct _XI2Mask *xi2mask; |
| 208 | } GrabRec; |
| 209 | |
| 210 | /** |
| 211 | * Sprite information for a device. |
| 212 | */ |
| 213 | typedef struct _SpriteRec { |
| 214 | CursorPtr current; |
| 215 | BoxRec hotLimits; /* logical constraints of hot spot */ |
| 216 | Bool confined; /* confined to screen */ |
| 217 | RegionPtr hotShape; /* additional logical shape constraint */ |
| 218 | BoxRec physLimits; /* physical constraints of hot spot */ |
| 219 | WindowPtr win; /* window of logical position */ |
| 220 | HotSpot hot; /* logical pointer position */ |
| 221 | HotSpot hotPhys; /* physical pointer position */ |
| 222 | #ifdef PANORAMIX |
| 223 | ScreenPtr screen; /* all others are in Screen 0 coordinates */ |
| 224 | RegionRec Reg1; /* Region 1 for confining motion */ |
| 225 | RegionRec Reg2; /* Region 2 for confining virtual motion */ |
| 226 | WindowPtr windows[MAXSCREENS]; |
| 227 | WindowPtr confineWin; /* confine window */ |
| 228 | #endif |
| 229 | /* The window trace information is used at dix/events.c to avoid having |
| 230 | * to compute all the windows between the root and the current pointer |
| 231 | * window each time a button or key goes down. The grabs on each of those |
| 232 | * windows must be checked. |
| 233 | * spriteTraces should only be used at dix/events.c! */ |
| 234 | WindowPtr *spriteTrace; |
| 235 | int spriteTraceSize; |
| 236 | int spriteTraceGood; |
| 237 | |
| 238 | /* Due to delays between event generation and event processing, it is |
| 239 | * possible that the pointer has crossed screen boundaries between the |
| 240 | * time in which it begins generating events and the time when |
| 241 | * those events are processed. |
| 242 | * |
| 243 | * pEnqueueScreen: screen the pointer was on when the event was generated |
| 244 | * pDequeueScreen: screen the pointer was on when the event is processed |
| 245 | */ |
| 246 | ScreenPtr pEnqueueScreen; |
| 247 | ScreenPtr pDequeueScreen; |
| 248 | |
| 249 | } SpriteRec; |
| 250 | |
| 251 | typedef struct _KeyClassRec { |
| 252 | int sourceid; |
| 253 | CARD8 down[DOWN_LENGTH]; |
| 254 | CARD8 postdown[DOWN_LENGTH]; |
| 255 | int modifierKeyCount[8]; |
| 256 | struct _XkbSrvInfo *xkbInfo; |
| 257 | } KeyClassRec, *KeyClassPtr; |
| 258 | |
| 259 | typedef struct _ScrollInfo { |
| 260 | enum ScrollType type; |
| 261 | double increment; |
| 262 | int flags; |
| 263 | } ScrollInfo, *ScrollInfoPtr; |
| 264 | |
| 265 | typedef struct _AxisInfo { |
| 266 | int resolution; |
| 267 | int min_resolution; |
| 268 | int max_resolution; |
| 269 | int min_value; |
| 270 | int max_value; |
| 271 | Atom label; |
| 272 | CARD8 mode; |
| 273 | ScrollInfo scroll; |
| 274 | } AxisInfo, *AxisInfoPtr; |
| 275 | |
| 276 | typedef struct _ValuatorAccelerationRec { |
| 277 | int number; |
| 278 | PointerAccelSchemeProc AccelSchemeProc; |
| 279 | void *accelData; /* at disposal of AccelScheme */ |
| 280 | PointerAccelSchemeInitProc AccelInitProc; |
| 281 | DeviceCallbackProc AccelCleanupProc; |
| 282 | } ValuatorAccelerationRec, *ValuatorAccelerationPtr; |
| 283 | |
| 284 | typedef struct _ValuatorClassRec { |
| 285 | int sourceid; |
| 286 | int numMotionEvents; |
| 287 | int first_motion; |
| 288 | int last_motion; |
| 289 | void *motion; /* motion history buffer. Different layout |
| 290 | for MDs and SDs! */ |
| 291 | WindowPtr motionHintWindow; |
| 292 | |
| 293 | AxisInfoPtr axes; |
| 294 | unsigned short numAxes; |
| 295 | double *axisVal; /* always absolute, but device-coord system */ |
| 296 | ValuatorAccelerationRec accelScheme; |
| 297 | int h_scroll_axis; /* horiz smooth-scrolling axis */ |
| 298 | int v_scroll_axis; /* vert smooth-scrolling axis */ |
| 299 | } ValuatorClassRec; |
| 300 | |
| 301 | typedef struct _TouchListener { |
| 302 | XID listener; /* grabs/event selection IDs receiving |
| 303 | * events for this touch */ |
| 304 | int resource_type; /* listener's resource type */ |
| 305 | enum TouchListenerType type; |
| 306 | enum TouchListenerState state; |
| 307 | enum InputLevel level; /* matters only for emulating touches */ |
| 308 | WindowPtr window; |
| 309 | GrabPtr grab; |
| 310 | } TouchListener; |
| 311 | |
| 312 | typedef struct _TouchPointInfo { |
| 313 | uint32_t client_id; /* touch ID as seen in client events */ |
| 314 | int sourceid; /* Source device's ID for this touchpoint */ |
| 315 | Bool active; /* whether or not the touch is active */ |
| 316 | Bool pending_finish; /* true if the touch is physically inactive |
| 317 | * but still owned by a grab */ |
| 318 | SpriteRec sprite; /* window trace for delivery */ |
| 319 | ValuatorMask *valuators; /* last recorded axis values */ |
| 320 | TouchListener *listeners; /* set of listeners */ |
| 321 | int num_listeners; |
| 322 | int num_grabs; /* number of open grabs on this touch |
| 323 | * which have not accepted or rejected */ |
| 324 | Bool emulate_pointer; |
| 325 | DeviceEvent *history; /* History of events on this touchpoint */ |
| 326 | size_t history_elements; /* Number of current elements in history */ |
| 327 | size_t history_size; /* Size of history in elements */ |
| 328 | } TouchPointInfoRec; |
| 329 | |
| 330 | typedef struct _DDXTouchPointInfo { |
| 331 | uint32_t client_id; /* touch ID as seen in client events */ |
| 332 | Bool active; /* whether or not the touch is active */ |
| 333 | uint32_t ddx_id; /* touch ID given by the DDX */ |
| 334 | Bool emulate_pointer; |
| 335 | |
| 336 | ValuatorMask *valuators; /* last axis values as posted, pre-transform */ |
| 337 | } DDXTouchPointInfoRec; |
| 338 | |
| 339 | typedef struct _TouchClassRec { |
| 340 | int sourceid; |
| 341 | TouchPointInfoPtr touches; |
| 342 | unsigned short num_touches; /* number of allocated touches */ |
| 343 | unsigned short max_touches; /* maximum number of touches, may be 0 */ |
| 344 | CARD8 mode; /* ::XIDirectTouch, XIDependentTouch */ |
| 345 | /* for pointer-emulation */ |
| 346 | CARD8 buttonsDown; /* number of buttons down */ |
| 347 | unsigned short state; /* logical button state */ |
| 348 | Mask motionMask; |
| 349 | } TouchClassRec; |
| 350 | |
| 351 | typedef struct _ButtonClassRec { |
| 352 | int sourceid; |
| 353 | CARD8 numButtons; |
| 354 | CARD8 buttonsDown; /* number of buttons currently down |
| 355 | This counts logical buttons, not |
| 356 | physical ones, i.e if some buttons |
| 357 | are mapped to 0, they're not counted |
| 358 | here */ |
| 359 | unsigned short state; |
| 360 | Mask motionMask; |
| 361 | CARD8 down[DOWN_LENGTH]; |
| 362 | CARD8 postdown[DOWN_LENGTH]; |
| 363 | CARD8 map[MAP_LENGTH]; |
| 364 | union _XkbAction *xkb_acts; |
| 365 | Atom labels[MAX_BUTTONS]; |
| 366 | } ButtonClassRec, *ButtonClassPtr; |
| 367 | |
| 368 | typedef struct _FocusClassRec { |
| 369 | int sourceid; |
| 370 | WindowPtr win; /* May be set to a int constant (e.g. PointerRootWin)! */ |
| 371 | int revert; |
| 372 | TimeStamp time; |
| 373 | WindowPtr *trace; |
| 374 | int traceSize; |
| 375 | int traceGood; |
| 376 | } FocusClassRec, *FocusClassPtr; |
| 377 | |
| 378 | typedef struct _ProximityClassRec { |
| 379 | int sourceid; |
| 380 | char in_proximity; |
| 381 | } ProximityClassRec, *ProximityClassPtr; |
| 382 | |
| 383 | typedef struct _KbdFeedbackClassRec *KbdFeedbackPtr; |
| 384 | typedef struct _PtrFeedbackClassRec *PtrFeedbackPtr; |
| 385 | typedef struct _IntegerFeedbackClassRec *IntegerFeedbackPtr; |
| 386 | typedef struct _StringFeedbackClassRec *StringFeedbackPtr; |
| 387 | typedef struct _BellFeedbackClassRec *BellFeedbackPtr; |
| 388 | typedef struct _LedFeedbackClassRec *LedFeedbackPtr; |
| 389 | |
| 390 | typedef struct _KbdFeedbackClassRec { |
| 391 | BellProcPtr BellProc; |
| 392 | KbdCtrlProcPtr CtrlProc; |
| 393 | KeybdCtrl ctrl; |
| 394 | KbdFeedbackPtr next; |
| 395 | struct _XkbSrvLedInfo *xkb_sli; |
| 396 | } KbdFeedbackClassRec; |
| 397 | |
| 398 | typedef struct _PtrFeedbackClassRec { |
| 399 | PtrCtrlProcPtr CtrlProc; |
| 400 | PtrCtrl ctrl; |
| 401 | PtrFeedbackPtr next; |
| 402 | } PtrFeedbackClassRec; |
| 403 | |
| 404 | typedef struct _IntegerFeedbackClassRec { |
| 405 | IntegerCtrlProcPtr CtrlProc; |
| 406 | IntegerCtrl ctrl; |
| 407 | IntegerFeedbackPtr next; |
| 408 | } IntegerFeedbackClassRec; |
| 409 | |
| 410 | typedef struct _StringFeedbackClassRec { |
| 411 | StringCtrlProcPtr CtrlProc; |
| 412 | StringCtrl ctrl; |
| 413 | StringFeedbackPtr next; |
| 414 | } StringFeedbackClassRec; |
| 415 | |
| 416 | typedef struct _BellFeedbackClassRec { |
| 417 | BellProcPtr BellProc; |
| 418 | BellCtrlProcPtr CtrlProc; |
| 419 | BellCtrl ctrl; |
| 420 | BellFeedbackPtr next; |
| 421 | } BellFeedbackClassRec; |
| 422 | |
| 423 | typedef struct _LedFeedbackClassRec { |
| 424 | LedCtrlProcPtr CtrlProc; |
| 425 | LedCtrl ctrl; |
| 426 | LedFeedbackPtr next; |
| 427 | struct _XkbSrvLedInfo *xkb_sli; |
| 428 | } LedFeedbackClassRec; |
| 429 | |
| 430 | typedef struct _ClassesRec { |
| 431 | KeyClassPtr key; |
| 432 | ValuatorClassPtr valuator; |
| 433 | TouchClassPtr touch; |
| 434 | ButtonClassPtr button; |
| 435 | FocusClassPtr focus; |
| 436 | ProximityClassPtr proximity; |
| 437 | KbdFeedbackPtr kbdfeed; |
| 438 | PtrFeedbackPtr ptrfeed; |
| 439 | IntegerFeedbackPtr intfeed; |
| 440 | StringFeedbackPtr stringfeed; |
| 441 | BellFeedbackPtr bell; |
| 442 | LedFeedbackPtr leds; |
| 443 | } ClassesRec; |
| 444 | |
| 445 | /* Device properties */ |
| 446 | typedef struct _XIPropertyValue { |
| 447 | Atom type; /* ignored by server */ |
| 448 | short format; /* format of data for swapping - 8,16,32 */ |
| 449 | long size; /* size of data in (format/8) bytes */ |
| 450 | pointer data; /* private to client */ |
| 451 | } XIPropertyValueRec; |
| 452 | |
| 453 | typedef struct _XIProperty { |
| 454 | struct _XIProperty *next; |
| 455 | Atom propertyName; |
| 456 | BOOL deletable; /* clients can delete this prop? */ |
| 457 | XIPropertyValueRec value; |
| 458 | } XIPropertyRec; |
| 459 | |
| 460 | typedef XIPropertyRec *XIPropertyPtr; |
| 461 | typedef XIPropertyValueRec *XIPropertyValuePtr; |
| 462 | |
| 463 | typedef struct _XIPropertyHandler { |
| 464 | struct _XIPropertyHandler *next; |
| 465 | long id; |
| 466 | int (*SetProperty) (DeviceIntPtr dev, |
| 467 | Atom property, XIPropertyValuePtr prop, BOOL checkonly); |
| 468 | int (*GetProperty) (DeviceIntPtr dev, Atom property); |
| 469 | int (*DeleteProperty) (DeviceIntPtr dev, Atom property); |
| 470 | } XIPropertyHandler, *XIPropertyHandlerPtr; |
| 471 | |
| 472 | /* states for devices */ |
| 473 | |
| 474 | #define NOT_GRABBED 0 |
| 475 | #define THAWED 1 |
| 476 | #define THAWED_BOTH 2 /* not a real state */ |
| 477 | #define FREEZE_NEXT_EVENT 3 |
| 478 | #define FREEZE_BOTH_NEXT_EVENT 4 |
| 479 | #define FROZEN 5 /* any state >= has device frozen */ |
| 480 | #define FROZEN_NO_EVENT 5 |
| 481 | #define FROZEN_WITH_EVENT 6 |
| 482 | #define THAW_OTHERS 7 |
| 483 | |
| 484 | typedef struct _GrabInfoRec { |
| 485 | TimeStamp grabTime; |
| 486 | Bool fromPassiveGrab; /* true if from passive grab */ |
| 487 | Bool implicitGrab; /* implicit from ButtonPress */ |
| 488 | GrabPtr unused; /* Kept for ABI stability, remove soon */ |
| 489 | GrabPtr grab; |
| 490 | CARD8 activatingKey; |
| 491 | void (*ActivateGrab) (DeviceIntPtr /*device */ , |
| 492 | GrabPtr /*grab */ , |
| 493 | TimeStamp /*time */ , |
| 494 | Bool /*autoGrab */ ); |
| 495 | void (*DeactivateGrab) (DeviceIntPtr /*device */ ); |
| 496 | struct { |
| 497 | Bool frozen; |
| 498 | int state; |
| 499 | GrabPtr other; /* if other grab has this frozen */ |
| 500 | DeviceEvent *event; /* saved to be replayed */ |
| 501 | } sync; |
| 502 | } GrabInfoRec, *GrabInfoPtr; |
| 503 | |
| 504 | typedef struct _SpriteInfoRec { |
| 505 | /* sprite must always point to a valid sprite. For devices sharing the |
| 506 | * sprite, let sprite point to a paired spriteOwner's sprite. */ |
| 507 | SpritePtr sprite; /* sprite information */ |
| 508 | Bool spriteOwner; /* True if device owns the sprite */ |
| 509 | DeviceIntPtr paired; /* The paired device. Keyboard if |
| 510 | spriteOwner is TRUE, otherwise the |
| 511 | pointer that owns the sprite. */ |
| 512 | |
| 513 | /* keep states for animated cursor */ |
| 514 | struct { |
| 515 | CursorPtr pCursor; |
| 516 | ScreenPtr pScreen; |
| 517 | int elt; |
| 518 | CARD32 time; |
| 519 | } anim; |
| 520 | } SpriteInfoRec, *SpriteInfoPtr; |
| 521 | |
| 522 | /* device types */ |
| 523 | #define MASTER_POINTER 1 |
| 524 | #define MASTER_KEYBOARD 2 |
| 525 | #define SLAVE 3 |
| 526 | /* special types for GetMaster */ |
| 527 | #define MASTER_ATTACHED 4 /* Master for this device */ |
| 528 | #define KEYBOARD_OR_FLOAT 5 /* Keyboard master for this device or this device if floating */ |
| 529 | #define POINTER_OR_FLOAT 6 /* Pointer master for this device or this device if floating */ |
| 530 | |
| 531 | typedef struct _DeviceIntRec { |
| 532 | DeviceRec public; |
| 533 | DeviceIntPtr next; |
| 534 | Bool startup; /* true if needs to be turned on at |
| 535 | server initialization time */ |
| 536 | DeviceProc deviceProc; /* proc(DevicePtr, DEVICE_xx). It is |
| 537 | used to initialize, turn on, or |
| 538 | turn off the device */ |
| 539 | Bool inited; /* TRUE if INIT returns Success */ |
| 540 | Bool enabled; /* TRUE if ON returns Success */ |
| 541 | Bool coreEvents; /* TRUE if device also sends core */ |
| 542 | GrabInfoRec deviceGrab; /* grab on the device */ |
| 543 | int type; /* MASTER_POINTER, MASTER_KEYBOARD, SLAVE */ |
| 544 | Atom xinput_type; |
| 545 | char *name; |
| 546 | int id; |
| 547 | KeyClassPtr key; |
| 548 | ValuatorClassPtr valuator; |
| 549 | TouchClassPtr touch; |
| 550 | ButtonClassPtr button; |
| 551 | FocusClassPtr focus; |
| 552 | ProximityClassPtr proximity; |
| 553 | KbdFeedbackPtr kbdfeed; |
| 554 | PtrFeedbackPtr ptrfeed; |
| 555 | IntegerFeedbackPtr intfeed; |
| 556 | StringFeedbackPtr stringfeed; |
| 557 | BellFeedbackPtr bell; |
| 558 | LedFeedbackPtr leds; |
| 559 | struct _XkbInterest *xkb_interest; |
| 560 | char *config_info; /* used by the hotplug layer */ |
| 561 | ClassesPtr unused_classes; /* for master devices */ |
| 562 | int saved_master_id; /* for slaves while grabbed */ |
| 563 | PrivateRec *devPrivates; |
| 564 | DeviceUnwrapProc unwrapProc; |
| 565 | SpriteInfoPtr spriteInfo; |
| 566 | DeviceIntPtr master; /* master device */ |
| 567 | DeviceIntPtr lastSlave; /* last slave device used */ |
| 568 | |
| 569 | /* last valuator values recorded, not posted to client; |
| 570 | * for slave devices, valuators is in device coordinates, mapped to the |
| 571 | * desktop |
| 572 | * for master devices, valuators is in desktop coordinates. |
| 573 | * see dix/getevents.c |
| 574 | * remainder supports acceleration |
| 575 | */ |
| 576 | struct { |
| 577 | double valuators[MAX_VALUATORS]; |
| 578 | int numValuators; |
| 579 | DeviceIntPtr slave; |
| 580 | ValuatorMask *scroll; |
| 581 | int num_touches; /* size of the touches array */ |
| 582 | DDXTouchPointInfoPtr touches; |
| 583 | } last; |
| 584 | |
| 585 | /* Input device property handling. */ |
| 586 | struct { |
| 587 | XIPropertyPtr properties; |
| 588 | XIPropertyHandlerPtr handlers; /* NULL-terminated */ |
| 589 | } properties; |
| 590 | |
| 591 | /* coordinate transformation matrix for relative movement. Matrix with |
| 592 | * the translation component dropped */ |
| 593 | struct pixman_f_transform relative_transform; |
| 594 | /* scale matrix for absolute devices, this is the combined matrix of |
| 595 | [1/scale] . [transform] . [scale]. See DeviceSetTransform */ |
| 596 | struct pixman_f_transform scale_and_transform; |
| 597 | |
| 598 | /* XTest related master device id */ |
| 599 | int xtest_master_id; |
| 600 | |
| 601 | struct _SyncCounter *idle_counter; |
| 602 | } DeviceIntRec; |
| 603 | |
| 604 | typedef struct { |
| 605 | int numDevices; /* total number of devices */ |
| 606 | DeviceIntPtr devices; /* all devices turned on */ |
| 607 | DeviceIntPtr off_devices; /* all devices turned off */ |
| 608 | DeviceIntPtr keyboard; /* the main one for the server */ |
| 609 | DeviceIntPtr pointer; |
| 610 | DeviceIntPtr all_devices; |
| 611 | DeviceIntPtr all_master_devices; |
| 612 | } InputInfo; |
| 613 | |
| 614 | extern _X_EXPORT InputInfo inputInfo; |
| 615 | |
| 616 | /* for keeping the events for devices grabbed synchronously */ |
| 617 | typedef struct _QdEvent *QdEventPtr; |
| 618 | typedef struct _QdEvent { |
| 619 | struct xorg_list next; |
| 620 | DeviceIntPtr device; |
| 621 | ScreenPtr pScreen; /* what screen the pointer was on */ |
| 622 | unsigned long months; /* milliseconds is in the event */ |
| 623 | InternalEvent *event; |
| 624 | } QdEventRec; |
| 625 | |
| 626 | /** |
| 627 | * syncEvents is the global structure for queued events. |
| 628 | * |
| 629 | * Devices can be frozen through GrabModeSync pointer grabs. If this is the |
| 630 | * case, events from these devices are added to "pending" instead of being |
| 631 | * processed normally. When the device is unfrozen, events in "pending" are |
| 632 | * replayed and processed as if they would come from the device directly. |
| 633 | */ |
| 634 | typedef struct _EventSyncInfo { |
| 635 | struct xorg_list pending; |
| 636 | |
| 637 | /** The device to replay events for. Only set in AllowEvents(), in which |
| 638 | * case it is set to the device specified in the request. */ |
| 639 | DeviceIntPtr replayDev; /* kludgy rock to put flag for */ |
| 640 | |
| 641 | /** |
| 642 | * The window the events are supposed to be replayed on. |
| 643 | * This window may be set to the grab's window (but only when |
| 644 | * Replay{Pointer|Keyboard} is given in the XAllowEvents() |
| 645 | * request. */ |
| 646 | WindowPtr replayWin; /* ComputeFreezes */ |
| 647 | /** |
| 648 | * Flag to indicate whether we're in the process of |
| 649 | * replaying events. Only set in ComputeFreezes(). */ |
| 650 | Bool playingEvents; |
| 651 | TimeStamp time; |
| 652 | } EventSyncInfoRec, *EventSyncInfoPtr; |
| 653 | |
| 654 | extern EventSyncInfoRec syncEvents; |
| 655 | |
| 656 | /** |
| 657 | * Given a sprite, returns the window at the bottom of the trace (i.e. the |
| 658 | * furthest window from the root). |
| 659 | */ |
| 660 | static inline WindowPtr |
| 661 | DeepestSpriteWin(SpritePtr sprite) |
| 662 | { |
| 663 | assert(sprite->spriteTraceGood > 0); |
| 664 | return sprite->spriteTrace[sprite->spriteTraceGood - 1]; |
| 665 | } |
| 666 | |
| 667 | struct _XI2Mask { |
| 668 | unsigned char **masks; /* event mask in masks[deviceid][event type byte] */ |
| 669 | size_t nmasks; /* number of masks */ |
| 670 | size_t mask_size; /* size of each mask in bytes */ |
| 671 | }; |
| 672 | |
| 673 | #endif /* INPUTSTRUCT_H */ |