1 /************************************************************
3 Copyright 1987, 1998 The Open Group
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
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
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.
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.
25 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
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.
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
45 ********************************************************/
50 #include <X11/extensions/XI2proto.h>
55 #include "dixstruct.h"
56 #include "cursorstr.h"
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
);
65 #define SameClient(obj,client) \
66 (CLIENT_BITS((obj)->resource) == (client)->clientAsMask)
68 #define EMASKSIZE (MAXDEVICES + 2)
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.
74 #define XI2LASTEVENT XI_BarrierLeave
75 #define XI2MASKSIZE ((XI2LASTEVENT >> 3) + 1) /* no of bytes for masks */
78 * Scroll types for ::SetScrollValuator and the scroll type in the
82 SCROLL_TYPE_NONE
= 0, /**< Not a scrolling valuator */
83 SCROLL_TYPE_VERTICAL
= 8,
84 SCROLL_TYPE_HORIZONTAL
= 9,
88 * This struct stores the core event mask for each client except the client
89 * that created the window.
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.
95 * The event mask for the client that created the window is stored in
96 * win->eventMask instead.
98 * The resource id is simply a fake client ID to associate this mask with a
101 * Kludge: OtherClients and InputClients must be compatible, see code.
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 */
110 * This struct stores the XI event mask for each client.
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
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
;
125 * Combined XI event masks from all devices.
127 * This is the XI equivalent of the deliverableEvents, eventMask and
128 * dontPropagate mask of the WindowRec (or WindowOptRec).
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
137 typedef struct _OtherInputMasks
{
139 * Bitwise OR of all masks by all clients and the window's parent's masks.
141 Mask deliverableEvents
[EMASKSIZE
];
143 * Bitwise OR of all masks by all clients on this window.
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
;
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.
161 #define MasksPerDetailMask 8 /* 256 keycodes and 256 possible
162 modifier combinations, but only
165 typedef struct _DetailRec
{ /* Grab details may be bit masks */
173 struct _XI2Mask
*xi2mask
;
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 |
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).
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.
189 typedef struct _GrabRec
{
190 GrabPtr next
; /* for chain of passive grabs */
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 */
206 /* XI2 event masks. One per device, each bit is a mask of (1 << type) */
207 struct _XI2Mask
*xi2mask
;
211 * Sprite information for a device.
213 typedef struct _SpriteRec
{
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 */
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 */
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
;
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.
243 * pEnqueueScreen: screen the pointer was on when the event was generated
244 * pDequeueScreen: screen the pointer was on when the event is processed
246 ScreenPtr pEnqueueScreen
;
247 ScreenPtr pDequeueScreen
;
251 typedef struct _KeyClassRec
{
253 CARD8 down
[DOWN_LENGTH
];
254 CARD8 postdown
[DOWN_LENGTH
];
255 int modifierKeyCount
[8];
256 struct _XkbSrvInfo
*xkbInfo
;
257 } KeyClassRec
, *KeyClassPtr
;
259 typedef struct _ScrollInfo
{
260 enum ScrollType type
;
263 } ScrollInfo
, *ScrollInfoPtr
;
265 typedef struct _AxisInfo
{
274 } AxisInfo
, *AxisInfoPtr
;
276 typedef struct _ValuatorAccelerationRec
{
278 PointerAccelSchemeProc AccelSchemeProc
;
279 void *accelData
; /* at disposal of AccelScheme */
280 PointerAccelSchemeInitProc AccelInitProc
;
281 DeviceCallbackProc AccelCleanupProc
;
282 } ValuatorAccelerationRec
, *ValuatorAccelerationPtr
;
284 typedef struct _ValuatorClassRec
{
289 void *motion
; /* motion history buffer. Different layout
291 WindowPtr motionHintWindow
;
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 */
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 */
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 */
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 */
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
;
336 ValuatorMask
*valuators
; /* last axis values as posted, pre-transform */
337 } DDXTouchPointInfoRec
;
339 typedef struct _TouchClassRec
{
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 */
351 typedef struct _ButtonClassRec
{
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
359 unsigned short state
;
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
;
368 typedef struct _FocusClassRec
{
370 WindowPtr win
; /* May be set to a int constant (e.g. PointerRootWin)! */
376 } FocusClassRec
, *FocusClassPtr
;
378 typedef struct _ProximityClassRec
{
381 } ProximityClassRec
, *ProximityClassPtr
;
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
;
390 typedef struct _KbdFeedbackClassRec
{
391 BellProcPtr BellProc
;
392 KbdCtrlProcPtr CtrlProc
;
395 struct _XkbSrvLedInfo
*xkb_sli
;
396 } KbdFeedbackClassRec
;
398 typedef struct _PtrFeedbackClassRec
{
399 PtrCtrlProcPtr CtrlProc
;
402 } PtrFeedbackClassRec
;
404 typedef struct _IntegerFeedbackClassRec
{
405 IntegerCtrlProcPtr CtrlProc
;
407 IntegerFeedbackPtr next
;
408 } IntegerFeedbackClassRec
;
410 typedef struct _StringFeedbackClassRec
{
411 StringCtrlProcPtr CtrlProc
;
413 StringFeedbackPtr next
;
414 } StringFeedbackClassRec
;
416 typedef struct _BellFeedbackClassRec
{
417 BellProcPtr BellProc
;
418 BellCtrlProcPtr CtrlProc
;
420 BellFeedbackPtr next
;
421 } BellFeedbackClassRec
;
423 typedef struct _LedFeedbackClassRec
{
424 LedCtrlProcPtr CtrlProc
;
427 struct _XkbSrvLedInfo
*xkb_sli
;
428 } LedFeedbackClassRec
;
430 typedef struct _ClassesRec
{
432 ValuatorClassPtr valuator
;
434 ButtonClassPtr button
;
436 ProximityClassPtr proximity
;
437 KbdFeedbackPtr kbdfeed
;
438 PtrFeedbackPtr ptrfeed
;
439 IntegerFeedbackPtr intfeed
;
440 StringFeedbackPtr stringfeed
;
441 BellFeedbackPtr bell
;
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
;
453 typedef struct _XIProperty
{
454 struct _XIProperty
*next
;
456 BOOL deletable
; /* clients can delete this prop? */
457 XIPropertyValueRec value
;
460 typedef XIPropertyRec
*XIPropertyPtr
;
461 typedef XIPropertyValueRec
*XIPropertyValuePtr
;
463 typedef struct _XIPropertyHandler
{
464 struct _XIPropertyHandler
*next
;
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
;
472 /* states for devices */
474 #define NOT_GRABBED 0
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
484 typedef struct _GrabInfoRec
{
486 Bool fromPassiveGrab
; /* true if from passive grab */
487 Bool implicitGrab
; /* implicit from ButtonPress */
488 GrabPtr unused
; /* Kept for ABI stability, remove soon */
491 void (*ActivateGrab
) (DeviceIntPtr
/*device */ ,
493 TimeStamp
/*time */ ,
494 Bool
/*autoGrab */ );
495 void (*DeactivateGrab
) (DeviceIntPtr
/*device */ );
499 GrabPtr other
; /* if other grab has this frozen */
500 DeviceEvent
*event
; /* saved to be replayed */
502 } GrabInfoRec
, *GrabInfoPtr
;
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. */
513 /* keep states for animated cursor */
520 } SpriteInfoRec
, *SpriteInfoPtr
;
523 #define MASTER_POINTER 1
524 #define MASTER_KEYBOARD 2
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 */
531 typedef struct _DeviceIntRec
{
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 */
548 ValuatorClassPtr valuator
;
550 ButtonClassPtr button
;
552 ProximityClassPtr proximity
;
553 KbdFeedbackPtr kbdfeed
;
554 PtrFeedbackPtr ptrfeed
;
555 IntegerFeedbackPtr intfeed
;
556 StringFeedbackPtr stringfeed
;
557 BellFeedbackPtr bell
;
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 */
569 /* last valuator values recorded, not posted to client;
570 * for slave devices, valuators is in device coordinates, mapped to the
572 * for master devices, valuators is in desktop coordinates.
573 * see dix/getevents.c
574 * remainder supports acceleration
577 double valuators
[MAX_VALUATORS
];
580 ValuatorMask
*scroll
;
581 int num_touches
; /* size of the touches array */
582 DDXTouchPointInfoPtr touches
;
585 /* Input device property handling. */
587 XIPropertyPtr properties
;
588 XIPropertyHandlerPtr handlers
; /* NULL-terminated */
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
;
598 /* XTest related master device id */
601 struct _SyncCounter
*idle_counter
;
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
;
614 extern _X_EXPORT InputInfo inputInfo
;
616 /* for keeping the events for devices grabbed synchronously */
617 typedef struct _QdEvent
*QdEventPtr
;
618 typedef struct _QdEvent
{
619 struct xorg_list next
;
621 ScreenPtr pScreen
; /* what screen the pointer was on */
622 unsigned long months
; /* milliseconds is in the event */
623 InternalEvent
*event
;
627 * syncEvents is the global structure for queued events.
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.
634 typedef struct _EventSyncInfo
{
635 struct xorg_list pending
;
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 */
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()
646 WindowPtr replayWin
; /* ComputeFreezes */
648 * Flag to indicate whether we're in the process of
649 * replaying events. Only set in ComputeFreezes(). */
652 } EventSyncInfoRec
, *EventSyncInfoPtr
;
654 extern EventSyncInfoRec syncEvents
;
657 * Given a sprite, returns the window at the bottom of the trace (i.e. the
658 * furthest window from the root).
660 static inline WindowPtr
661 DeepestSpriteWin(SpritePtr sprite
)
663 assert(sprite
->spriteTraceGood
> 0);
664 return sprite
->spriteTrace
[sprite
->spriteTraceGood
- 1];
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 */
673 #endif /* INPUTSTRUCT_H */