Debian Codegraph @

xcb/libqt5xcbqpa-dev/5.11.3/qxcbconnection.h

raw
1 // Copyright (C) 2016 The Qt Company Ltd.
2 //
3 // SPDX-License-Identifier: LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
4
5 #ifndef QXCBCONNECTION_H
6 #define QXCBCONNECTION_H
7
8 #include <xcb/xcb.h>
9 #include <xcb/randr.h>
10
11 #include <QtGui/private/qtguiglobal_p.h>
12 #include "qxcbexport.h"
13 #include <QHash>
14 #include <QList>
15 #include <QMutex>
16 #include <QObject>
17 #include <QThread>
18 #include <QVector>
19 #include <QVarLengthArray>
20 #include <qpa/qwindowsysteminterface.h>
21 #include <QtCore/QLoggingCategory>
22 #include <QtCore/private/qglobal_p.h>
23
24 #include <cstdlib>
25 #include <memory>
26
27 // This is needed to make Qt compile together with XKB. xkb.h is using a variable
28 // which is called 'explicit', this is a reserved keyword in c++
29 #if QT_CONFIG(xkb)
30 #define explicit dont_use_cxx_explicit
31 #include <xcb/xkb.h>
32 #undef explicit
33 #endif
34
35 #if QT_CONFIG(tabletevent)
36 #include <QTabletEvent>
37 #endif
38
39 #if QT_CONFIG(xinput2)
40 #include <X11/extensions/XI2.h>
41 #ifdef XIScrollClass
42 #define XCB_USE_XINPUT21 // XI 2.1 adds smooth scrolling support
43 #ifdef XI_TouchBeginMask
44 #define XCB_USE_XINPUT22 // XI 2.2 adds multi-point touch support
45 #endif
46 #endif
47 #endif // QT_CONFIG(xinput2)
48
49 struct xcb_randr_get_output_info_reply_t;
50
51 QT_BEGIN_NAMESPACE
52
53 Q_DECLARE_LOGGING_CATEGORY(lcQpaXInput)
54 Q_DECLARE_LOGGING_CATEGORY(lcQpaXInputDevices)
55 Q_DECLARE_LOGGING_CATEGORY(lcQpaXInputEvents)
56 Q_DECLARE_LOGGING_CATEGORY(lcQpaScreen)
57 Q_DECLARE_LOGGING_CATEGORY(lcQpaEvents)
58 Q_DECLARE_LOGGING_CATEGORY(lcQpaXcb)
59 Q_DECLARE_LOGGING_CATEGORY(lcQpaPeeker)
60 Q_DECLARE_LOGGING_CATEGORY(lcQpaKeyboard)
61
62 class QXcbVirtualDesktop;
63 class QXcbScreen;
64 class QXcbWindow;
65 class QXcbDrag;
66 class QXcbKeyboard;
67 class QXcbClipboard;
68 class QXcbWMSupport;
69 class QXcbNativeInterface;
70 class QXcbSystemTrayTracker;
71 class QXcbGlIntegration;
72
73 namespace QXcbAtom {
74 enum Atom {
75 // window-manager <-> client protocols
76 WM_PROTOCOLS,
77 WM_DELETE_WINDOW,
78 WM_TAKE_FOCUS,
79 _NET_WM_PING,
80 _NET_WM_CONTEXT_HELP,
81 _NET_WM_SYNC_REQUEST,
82 _NET_WM_SYNC_REQUEST_COUNTER,
83 MANAGER, // System tray notification
84 _NET_SYSTEM_TRAY_OPCODE, // System tray operation
85
86 // ICCCM window state
87 WM_STATE,
88 WM_CHANGE_STATE,
89 WM_CLASS,
90 WM_NAME,
91
92 // Session management
93 WM_CLIENT_LEADER,
94 WM_WINDOW_ROLE,
95 SM_CLIENT_ID,
96
97 // Clipboard
98 CLIPBOARD,
99 INCR,
100 TARGETS,
101 MULTIPLE,
102 TIMESTAMP,
103 SAVE_TARGETS,
104 CLIP_TEMPORARY,
105 _QT_SELECTION,
106 _QT_CLIPBOARD_SENTINEL,
107 _QT_SELECTION_SENTINEL,
108 CLIPBOARD_MANAGER,
109
110 RESOURCE_MANAGER,
111
112 _XSETROOT_ID,
113
114 _QT_SCROLL_DONE,
115 _QT_INPUT_ENCODING,
116
117 // Qt/XCB specific
118 _QT_CLOSE_CONNECTION,
119
120 _MOTIF_WM_HINTS,
121
122 DTWM_IS_RUNNING,
123 ENLIGHTENMENT_DESKTOP,
124 _DT_SAVE_MODE,
125 _SGI_DESKS_MANAGER,
126
127 // EWMH (aka NETWM)
128 _NET_SUPPORTED,
129 _NET_VIRTUAL_ROOTS,
130 _NET_WORKAREA,
131
132 _NET_MOVERESIZE_WINDOW,
133 _NET_WM_MOVERESIZE,
134
135 _NET_WM_NAME,
136 _NET_WM_ICON_NAME,
137 _NET_WM_ICON,
138
139 _NET_WM_PID,
140
141 _NET_WM_WINDOW_OPACITY,
142
143 _NET_WM_STATE,
144 _NET_WM_STATE_ABOVE,
145 _NET_WM_STATE_BELOW,
146 _NET_WM_STATE_FULLSCREEN,
147 _NET_WM_STATE_MAXIMIZED_HORZ,
148 _NET_WM_STATE_MAXIMIZED_VERT,
149 _NET_WM_STATE_MODAL,
150 _NET_WM_STATE_STAYS_ON_TOP,
151 _NET_WM_STATE_DEMANDS_ATTENTION,
152
153 _NET_WM_USER_TIME,
154 _NET_WM_USER_TIME_WINDOW,
155 _NET_WM_FULL_PLACEMENT,
156
157 _NET_WM_WINDOW_TYPE,
158 _NET_WM_WINDOW_TYPE_DESKTOP,
159 _NET_WM_WINDOW_TYPE_DOCK,
160 _NET_WM_WINDOW_TYPE_TOOLBAR,
161 _NET_WM_WINDOW_TYPE_MENU,
162 _NET_WM_WINDOW_TYPE_UTILITY,
163 _NET_WM_WINDOW_TYPE_SPLASH,
164 _NET_WM_WINDOW_TYPE_DIALOG,
165 _NET_WM_WINDOW_TYPE_DROPDOWN_MENU,
166 _NET_WM_WINDOW_TYPE_POPUP_MENU,
167 _NET_WM_WINDOW_TYPE_TOOLTIP,
168 _NET_WM_WINDOW_TYPE_NOTIFICATION,
169 _NET_WM_WINDOW_TYPE_COMBO,
170 _NET_WM_WINDOW_TYPE_DND,
171 _NET_WM_WINDOW_TYPE_NORMAL,
172 _KDE_NET_WM_WINDOW_TYPE_OVERRIDE,
173
174 _KDE_NET_WM_FRAME_STRUT,
175 _NET_FRAME_EXTENTS,
176
177 _NET_STARTUP_INFO,
178 _NET_STARTUP_INFO_BEGIN,
179
180 _NET_SUPPORTING_WM_CHECK,
181
182 _NET_WM_CM_S0,
183
184 _NET_SYSTEM_TRAY_VISUAL,
185
186 _NET_ACTIVE_WINDOW,
187
188 // Property formats
189 TEXT,
190 UTF8_STRING,
191 CARDINAL,
192
193 // Xdnd
194 XdndEnter,
195 XdndPosition,
196 XdndStatus,
197 XdndLeave,
198 XdndDrop,
199 XdndFinished,
200 XdndTypelist,
201 XdndActionList,
202
203 XdndSelection,
204
205 XdndAware,
206 XdndProxy,
207
208 XdndActionCopy,
209 XdndActionLink,
210 XdndActionMove,
211 XdndActionPrivate,
212
213 // Motif DND
214 _MOTIF_DRAG_AND_DROP_MESSAGE,
215 _MOTIF_DRAG_INITIATOR_INFO,
216 _MOTIF_DRAG_RECEIVER_INFO,
217 _MOTIF_DRAG_WINDOW,
218 _MOTIF_DRAG_TARGETS,
219
220 XmTRANSFER_SUCCESS,
221 XmTRANSFER_FAILURE,
222
223 // Xkb
224 _XKB_RULES_NAMES,
225
226 // XEMBED
227 _XEMBED,
228 _XEMBED_INFO,
229
230 // XInput2
231 ButtonLeft,
232 ButtonMiddle,
233 ButtonRight,
234 ButtonWheelUp,
235 ButtonWheelDown,
236 ButtonHorizWheelLeft,
237 ButtonHorizWheelRight,
238 AbsMTPositionX,
239 AbsMTPositionY,
240 AbsMTTouchMajor,
241 AbsMTTouchMinor,
242 AbsMTOrientation,
243 AbsMTPressure,
244 AbsMTTrackingID,
245 MaxContacts,
246 RelX,
247 RelY,
248 // XInput2 tablet
249 AbsX,
250 AbsY,
251 AbsPressure,
252 AbsTiltX,
253 AbsTiltY,
254 AbsWheel,
255 AbsDistance,
256 WacomSerialIDs,
257 INTEGER,
258 RelHorizWheel,
259 RelVertWheel,
260 RelHorizScroll,
261 RelVertScroll,
262
263 _XSETTINGS_SETTINGS,
264
265 _COMPIZ_DECOR_PENDING,
266 _COMPIZ_DECOR_REQUEST,
267 _COMPIZ_DECOR_DELETE_PIXMAP,
268 _COMPIZ_TOOLKIT_ACTION,
269 _GTK_LOAD_ICONTHEMES,
270
271 NPredefinedAtoms,
272
273 _QT_SETTINGS_TIMESTAMP = NPredefinedAtoms,
274 NAtoms
275 };
276 }
277
278 typedef QVarLengthArray<xcb_generic_event_t *, 64> QXcbEventArray;
279
280 class QXcbConnection;
281 class QXcbEventReader : public QThread
282 {
283 Q_OBJECT
284 public:
285 QXcbEventReader(QXcbConnection *connection);
286
287 void run() override;
288
289 QXcbEventArray *lock();
290 void unlock();
291
292 void start();
293
294 void registerEventDispatcher(QAbstractEventDispatcher *dispatcher);
295
296 signals:
297 void eventPending();
298
299 private slots:
300 void registerForEvents();
301
302 private:
303 void addEvent(xcb_generic_event_t *event);
304
305 QMutex m_mutex;
306 QXcbEventArray m_events;
307 QXcbConnection *m_connection;
308 };
309
310 class QXcbWindowEventListener
311 {
312 public:
313 virtual ~QXcbWindowEventListener() {}
314 virtual bool handleGenericEvent(xcb_generic_event_t *, long *) { return false; }
315
316 virtual void handleExposeEvent(const xcb_expose_event_t *) {}
317 virtual void handleClientMessageEvent(const xcb_client_message_event_t *) {}
318 virtual void handleConfigureNotifyEvent(const xcb_configure_notify_event_t *) {}
319 virtual void handleMapNotifyEvent(const xcb_map_notify_event_t *) {}
320 virtual void handleUnmapNotifyEvent(const xcb_unmap_notify_event_t *) {}
321 virtual void handleDestroyNotifyEvent(const xcb_destroy_notify_event_t *) {}
322 virtual void handleButtonPressEvent(const xcb_button_press_event_t *) {}
323 virtual void handleButtonReleaseEvent(const xcb_button_release_event_t *) {}
324 virtual void handleMotionNotifyEvent(const xcb_motion_notify_event_t *) {}
325 virtual void handleEnterNotifyEvent(const xcb_enter_notify_event_t *) {}
326 virtual void handleLeaveNotifyEvent(const xcb_leave_notify_event_t *) {}
327 virtual void handleFocusInEvent(const xcb_focus_in_event_t *) {}
328 virtual void handleFocusOutEvent(const xcb_focus_out_event_t *) {}
329 virtual void handlePropertyNotifyEvent(const xcb_property_notify_event_t *) {}
330 #if QT_CONFIG(xinput2)
331 virtual void handleXIMouseEvent(xcb_ge_event_t *, Qt::MouseEventSource = Qt::MouseEventNotSynthesized) {}
332 virtual void handleXIEnterLeave(xcb_ge_event_t *) {}
333 #endif
334 virtual QXcbWindow *toWindow() { return 0; }
335 };
336
337 typedef QHash<xcb_window_t, QXcbWindowEventListener *> WindowMapper;
338
339 class QXcbSyncWindowRequest : public QEvent
340 {
341 public:
342 QXcbSyncWindowRequest(QXcbWindow *w) : QEvent(QEvent::Type(QEvent::User + 1)), m_window(w) { }
343
344 QXcbWindow *window() const { return m_window; }
345 void invalidate();
346
347 private:
348 QXcbWindow *m_window;
349 };
350
351 class QAbstractEventDispatcher;
352 class Q_XCB_EXPORT QXcbConnection : public QObject
353 {
354 Q_OBJECT
355 public:
356 QXcbConnection(QXcbNativeInterface *nativeInterface, bool canGrabServer, xcb_visualid_t defaultVisualId, const char *displayName = 0);
357 ~QXcbConnection();
358
359 QXcbConnection *connection() const { return const_cast<QXcbConnection *>(this); }
360 bool isConnected() const;
361
362 const QList<QXcbVirtualDesktop *> &virtualDesktops() const { return m_virtualDesktops; }
363 const QList<QXcbScreen *> &screens() const { return m_screens; }
364 int primaryScreenNumber() const { return m_primaryScreenNumber; }
365 QXcbVirtualDesktop *primaryVirtualDesktop() const { return m_virtualDesktops.value(m_primaryScreenNumber); }
366 QXcbScreen *primaryScreen() const;
367
368 inline xcb_atom_t atom(QXcbAtom::Atom atom) const { return m_allAtoms[atom]; }
369 QXcbAtom::Atom qatom(xcb_atom_t atom) const;
370 xcb_atom_t internAtom(const char *name);
371 QByteArray atomName(xcb_atom_t atom);
372
373 const char *displayName() const { return m_displayName.constData(); }
374 xcb_connection_t *xcb_connection() const { return m_connection; }
375 const xcb_setup_t *setup() const { return m_setup; }
376 const xcb_format_t *formatForDepth(uint8_t depth) const;
377
378 bool imageNeedsEndianSwap() const
379 {
380 if (!hasShm())
381 return false; // The non-Shm path does its own swapping
382 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
383 return m_setup->image_byte_order != XCB_IMAGE_ORDER_MSB_FIRST;
384 #else
385 return m_setup->image_byte_order != XCB_IMAGE_ORDER_LSB_FIRST;
386 #endif
387 }
388
389 QXcbKeyboard *keyboard() const { return m_keyboard; }
390
391 #ifndef QT_NO_CLIPBOARD
392 QXcbClipboard *clipboard() const { return m_clipboard; }
393 #endif
394 #if QT_CONFIG(draganddrop)
395 QXcbDrag *drag() const { return m_drag; }
396 #endif
397
398 QXcbWMSupport *wmSupport() const { return m_wmSupport.data(); }
399 xcb_window_t rootWindow();
400 xcb_window_t clientLeader();
401
402 bool hasDefaultVisualId() const { return m_defaultVisualId != UINT_MAX; }
403 xcb_visualid_t defaultVisualId() const { return m_defaultVisualId; }
404
405 #if QT_CONFIG(xcb_xlib)
406 void *xlib_display() const;
407 void *createVisualInfoForDefaultVisualId() const;
408 #endif
409 void sync();
410
411 void handleXcbError(xcb_generic_error_t *error);
412 void printXcbError(const char *message, xcb_generic_error_t *error);
413 void handleXcbEvent(xcb_generic_event_t *event);
414 void printXcbEvent(const QLoggingCategory &log, const char *message,
415 xcb_generic_event_t *event) const;
416
417 void addWindowEventListener(xcb_window_t id, QXcbWindowEventListener *eventListener);
418 void removeWindowEventListener(xcb_window_t id);
419 QXcbWindowEventListener *windowEventListenerFromId(xcb_window_t id);
420 QXcbWindow *platformWindowFromId(xcb_window_t id);
421
422 template<typename T>
423 inline xcb_generic_event_t *checkEvent(T &checker);
424
425 typedef bool (*PeekFunc)(QXcbConnection *, xcb_generic_event_t *);
426 void addPeekFunc(PeekFunc f);
427
428 // Peek at all queued events
429 qint32 generatePeekerId();
430 bool removePeekerId(qint32 peekerId);
431 enum PeekOption { PeekDefault = 0, PeekFromCachedIndex = 1 }; // see qx11info_x11.h
432 Q_DECLARE_FLAGS(PeekOptions, PeekOption)
433 typedef bool (*PeekerCallback)(xcb_generic_event_t *event, void *peekerData);
434 bool peekEventQueue(PeekerCallback peeker, void *peekerData = nullptr,
435 PeekOptions option = PeekDefault, qint32 peekerId = -1);
436
437 inline xcb_timestamp_t time() const { return m_time; }
438 inline void setTime(xcb_timestamp_t t) { if (t > m_time) m_time = t; }
439
440 inline xcb_timestamp_t netWmUserTime() const { return m_netWmUserTime; }
441 inline void setNetWmUserTime(xcb_timestamp_t t) { if (t > m_netWmUserTime) m_netWmUserTime = t; }
442
443 bool hasXFixes() const { return has_xfixes; }
444 bool hasXShape() const { return has_shape_extension; }
445 bool hasXRandr() const { return has_randr_extension; }
446 bool hasInputShape() const { return has_input_shape; }
447 bool hasXKB() const { return has_xkb; }
448 bool hasXRender(int major = -1, int minor = -1) const
449 {
450 if (has_render_extension && major != -1 && minor != -1)
451 return m_xrenderVersion >= qMakePair(major, minor);
452
453 return has_render_extension;
454 }
455 bool hasXInput2() const { return m_xi2Enabled; }
456 bool hasShm() const { return has_shm; }
457 bool hasShmFd() const { return has_shm_fd; }
458
459 bool threadedEventHandling() const { return m_reader->isRunning(); }
460
461 xcb_timestamp_t getTimestamp();
462 xcb_window_t getSelectionOwner(xcb_atom_t atom) const;
463 xcb_window_t getQtSelectionOwner();
464
465 void setButtonState(Qt::MouseButton button, bool down);
466 Qt::MouseButtons buttonState() const { return m_buttonState; }
467 Qt::MouseButton button() const { return m_button; }
468 Qt::MouseButton translateMouseButton(xcb_button_t s);
469
470 QXcbWindow *focusWindow() const { return m_focusWindow; }
471 void setFocusWindow(QWindow *);
472 QXcbWindow *mouseGrabber() const { return m_mouseGrabber; }
473 void setMouseGrabber(QXcbWindow *);
474 QXcbWindow *mousePressWindow() const { return m_mousePressWindow; }
475 void setMousePressWindow(QXcbWindow *);
476
477 QByteArray startupId() const { return m_startupId; }
478 void setStartupId(const QByteArray &nextId) { m_startupId = nextId; }
479 void clearStartupId() { m_startupId.clear(); }
480
481 void grabServer();
482 void ungrabServer();
483
484 bool isUnity() const { return m_xdgCurrentDesktop == "unity"; }
485 bool isGnome() const { return m_xdgCurrentDesktop == "gnome"; }
486
487 QXcbNativeInterface *nativeInterface() const { return m_nativeInterface; }
488
489 QXcbSystemTrayTracker *systemTrayTracker() const;
490 static bool xEmbedSystemTrayAvailable();
491 static bool xEmbedSystemTrayVisualHasAlphaChannel();
492
493 #if QT_CONFIG(xinput2)
494 void xi2SelectStateEvents();
495 void xi2SelectDeviceEvents(xcb_window_t window);
496 void xi2SelectDeviceEventsCompatibility(xcb_window_t window);
497 bool xi2SetMouseGrabEnabled(xcb_window_t w, bool grab);
498 bool xi2MouseEventsDisabled() const;
499 bool isAtLeastXI21() const { return m_xi2Enabled && m_xi2Minor >= 1; }
500 bool isAtLeastXI22() const { return m_xi2Enabled && m_xi2Minor >= 2; }
501 Qt::MouseButton xiToQtMouseButton(uint32_t b);
502 #ifdef XCB_USE_XINPUT21
503 void xi2UpdateScrollingDevices();
504 #endif
505 #ifdef XCB_USE_XINPUT22
506 bool startSystemMoveResizeForTouchBegin(xcb_window_t window, const QPoint &point, int corner);
507 void abortSystemMoveResizeForTouch();
508 bool isTouchScreen(int id);
509 #endif
510 #endif
511 QXcbEventReader *eventReader() const { return m_reader; }
512
513 bool canGrab() const { return m_canGrabServer; }
514
515 QXcbGlIntegration *glIntegration() const { return m_glIntegration; }
516
517 protected:
518 bool event(QEvent *e) override;
519
520 public slots:
521 void flush() { xcb_flush(m_connection); }
522
523 private slots:
524 void processXcbEvents();
525
526 private:
527 void initializeAllAtoms();
528 void sendConnectionEvent(QXcbAtom::Atom atom, uint id = 0);
529 void initializeShm();
530 void initializeXFixes();
531 void initializeXRender();
532 void initializeXRandr();
533 void initializeXinerama();
534 void initializeXShape();
535 void initializeXKB();
536 void handleClientMessageEvent(const xcb_client_message_event_t *event);
537 QXcbScreen* findScreenForCrtc(xcb_window_t rootWindow, xcb_randr_crtc_t crtc) const;
538 QXcbScreen* findScreenForOutput(xcb_window_t rootWindow, xcb_randr_output_t output) const;
539 QXcbVirtualDesktop* virtualDesktopForRootWindow(xcb_window_t rootWindow) const;
540 void updateScreens(const xcb_randr_notify_event_t *event);
541 bool checkOutputIsPrimary(xcb_window_t rootWindow, xcb_randr_output_t output);
542 void updateScreen(QXcbScreen *screen, const xcb_randr_output_change_t &outputChange);
543 QXcbScreen *createScreen(QXcbVirtualDesktop *virtualDesktop,
544 const xcb_randr_output_change_t &outputChange,
545 xcb_randr_get_output_info_reply_t *outputInfo);
546 void destroyScreen(QXcbScreen *screen);
547 void initializeScreens();
548 bool compressEvent(xcb_generic_event_t *event, int currentIndex, QXcbEventArray *eventqueue) const;
549
550 bool m_xi2Enabled = false;
551 #if QT_CONFIG(xinput2)
552 int m_xi2Minor = -1;
553 void initializeXInput2();
554 void xi2SetupDevice(void *info, bool removeExisting = true);
555 void xi2SetupDevices();
556 struct TouchDeviceData {
557 QTouchDevice *qtTouchDevice = nullptr;
558 QHash<int, QWindowSystemInterface::TouchPoint> touchPoints;
559 QHash<int, QPointF> pointPressedPosition; // in screen coordinates where each point was pressed
560 struct ValuatorClassInfo {
561 double min = 0;
562 double max = 0;
563 int number = -1;
564 QXcbAtom::Atom label;
565 };
566 QVector<ValuatorClassInfo> valuatorInfo;
567
568 // Stuff that is relevant only for touchpads
569 QPointF firstPressedPosition; // in screen coordinates where the first point was pressed
570 QPointF firstPressedNormalPosition; // device coordinates (0 to 1, 0 to 1) where the first point was pressed
571 QSizeF size; // device size in mm
572 bool providesTouchOrientation = false;
573 };
574 TouchDeviceData *populateTouchDevices(void *info);
575 TouchDeviceData *touchDeviceForId(int id);
576 void xi2HandleEvent(xcb_ge_event_t *event);
577 void xi2HandleHierarchyEvent(void *event);
578 void xi2HandleDeviceChangedEvent(void *event);
579 int m_xiOpCode, m_xiEventBase, m_xiErrorBase;
580 #ifdef XCB_USE_XINPUT22
581 void xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindow);
582 #endif // XCB_USE_XINPUT22
583 #if QT_CONFIG(tabletevent)
584 struct TabletData {
585 int deviceId = 0;
586 QTabletEvent::PointerType pointerType = QTabletEvent::UnknownPointer;
587 QTabletEvent::TabletDevice tool = QTabletEvent::Stylus;
588 Qt::MouseButtons buttons = 0;
589 qint64 serialId = 0;
590 bool inProximity = false;
591 struct ValuatorClassInfo {
592 double minVal = 0;
593 double maxVal = 0;
594 double curVal = 0;
595 int number = -1;
596 };
597 QHash<int, ValuatorClassInfo> valuatorInfo;
598 };
599 friend class QTypeInfo<TabletData>;
600 friend class QTypeInfo<TabletData::ValuatorClassInfo>;
601 bool xi2HandleTabletEvent(const void *event, TabletData *tabletData);
602 void xi2ReportTabletEvent(const void *event, TabletData *tabletData);
603 QVector<TabletData> m_tabletData;
604 TabletData *tabletDataForDevice(int id);
605 #endif // QT_CONFIG(tabletevent)
606 struct ScrollingDevice {
607 int deviceId = 0;
608 int verticalIndex = 0;
609 int horizontalIndex = 0;
610 double verticalIncrement = 0;
611 double horizontalIncrement = 0;
612 Qt::Orientations orientations = 0;
613 Qt::Orientations legacyOrientations = 0;
614 QPointF lastScrollPosition;
615 };
616 QHash<int, ScrollingDevice> m_scrollingDevices;
617 #ifdef XCB_USE_XINPUT21
618 void xi2HandleScrollEvent(void *event, ScrollingDevice &scrollingDevice);
619 void xi2UpdateScrollingDevice(ScrollingDevice &scrollingDevice);
620 ScrollingDevice *scrollingDeviceForId(int id);
621 #endif
622
623 static bool xi2GetValuatorValueIfSet(const void *event, int valuatorNum, double *value);
624 static void xi2PrepareXIGenericDeviceEvent(xcb_ge_event_t *event);
625 #endif
626
627 xcb_connection_t *m_connection = nullptr;
628 const xcb_setup_t *m_setup = nullptr;
629 const bool m_canGrabServer;
630 const xcb_visualid_t m_defaultVisualId;
631
632 QList<QXcbVirtualDesktop *> m_virtualDesktops;
633 QList<QXcbScreen *> m_screens;
634 int m_primaryScreenNumber = 0;
635
636 xcb_atom_t m_allAtoms[QXcbAtom::NAtoms];
637
638 xcb_timestamp_t m_time = XCB_CURRENT_TIME;
639 xcb_timestamp_t m_netWmUserTime = XCB_CURRENT_TIME;
640
641 QByteArray m_displayName;
642
643 QXcbKeyboard *m_keyboard = nullptr;
644 #ifndef QT_NO_CLIPBOARD
645 QXcbClipboard *m_clipboard = nullptr;
646 #endif
647 #if QT_CONFIG(draganddrop)
648 QXcbDrag *m_drag = nullptr;
649 #endif
650 QScopedPointer<QXcbWMSupport> m_wmSupport;
651 QXcbNativeInterface *m_nativeInterface = nullptr;
652
653 #if QT_CONFIG(xcb_xlib)
654 void *m_xlib_display = nullptr;
655 #endif
656 QXcbEventReader *m_reader = nullptr;
657
658 #if QT_CONFIG(xinput2)
659 QHash<int, TouchDeviceData> m_touchDevices;
660 #ifdef XCB_USE_XINPUT22
661 struct StartSystemMoveResizeInfo {
662 xcb_window_t window = XCB_NONE;
663 uint16_t deviceid;
664 uint32_t pointid;
665 int corner;
666 } m_startSystemMoveResizeInfo;
667 #endif
668 #endif
669 WindowMapper m_mapper;
670
671 QVector<PeekFunc> m_peekFuncs;
672
673 uint32_t xfixes_first_event = 0;
674 uint32_t xrandr_first_event = 0;
675 uint32_t xkb_first_event = 0;
676
677 bool has_xfixes = false;
678 bool has_xinerama_extension = false;
679 bool has_shape_extension = false;
680 bool has_randr_extension = false;
681 bool has_input_shape;
682 bool has_xkb = false;
683 bool has_render_extension = false;
684 bool has_shm = false;
685 bool has_shm_fd = false;
686
687 QPair<int, int> m_xrenderVersion;
688
689 Qt::MouseButtons m_buttonState = 0;
690 Qt::MouseButton m_button = Qt::NoButton;
691
692 QXcbWindow *m_focusWindow = nullptr;
693 QXcbWindow *m_mouseGrabber = nullptr;
694 QXcbWindow *m_mousePressWindow = nullptr;
695
696 xcb_window_t m_clientLeader = 0;
697 QByteArray m_startupId;
698 QXcbSystemTrayTracker *m_systemTrayTracker = nullptr;
699 QXcbGlIntegration *m_glIntegration = nullptr;
700 bool m_xiGrab = false;
701 QVector<int> m_xiMasterPointerIds;
702
703 xcb_window_t m_qtSelectionOwner = 0;
704
705 bool m_mainEventLoopFlushedQueue = false;
706 qint32 m_peekerIdSource = 0;
707 bool m_peekerIndexCacheDirty = false;
708 QHash<qint32, qint32> m_peekerToCachedIndex;
709 friend class QXcbEventReader;
710
711 QByteArray m_xdgCurrentDesktop;
712 };
713 #if QT_CONFIG(xinput2)
714 #if QT_CONFIG(tabletevent)
715 Q_DECLARE_TYPEINFO(QXcbConnection::TabletData::ValuatorClassInfo, Q_PRIMITIVE_TYPE);
716 Q_DECLARE_TYPEINFO(QXcbConnection::TabletData, Q_MOVABLE_TYPE);
717 #endif
718 #endif
719
720 template<typename T>
721 xcb_generic_event_t *QXcbConnection::checkEvent(T &checker)
722 {
723 QXcbEventArray *eventqueue = m_reader->lock();
724
725 for (int i = 0; i < eventqueue->size(); ++i) {
726 xcb_generic_event_t *event = eventqueue->at(i);
727 if (checker.checkEvent(event)) {
728 (*eventqueue)[i] = 0;
729 m_reader->unlock();
730 return event;
731 }
732 }
733 m_reader->unlock();
734 return 0;
735 }
736
737 class QXcbConnectionGrabber
738 {
739 public:
740 QXcbConnectionGrabber(QXcbConnection *connection);
741 ~QXcbConnectionGrabber();
742 void release();
743 private:
744 QXcbConnection *m_connection;
745 };
746
747 #define Q_XCB_REPLY_CONNECTION_ARG(connection, ...) connection
748
749 struct QStdFreeDeleter {
750 void operator()(void *p) const Q_DECL_NOTHROW { return std::free(p); }
751 };
752
753 #define Q_XCB_REPLY(call, ...) \
754 std::unique_ptr<call##_reply_t, QStdFreeDeleter>( \
755 call##_reply(Q_XCB_REPLY_CONNECTION_ARG(__VA_ARGS__), call(__VA_ARGS__), nullptr) \
756 )
757
758 #define Q_XCB_REPLY_UNCHECKED(call, ...) \
759 std::unique_ptr<call##_reply_t, QStdFreeDeleter>( \
760 call##_reply(Q_XCB_REPLY_CONNECTION_ARG(__VA_ARGS__), call##_unchecked(__VA_ARGS__), nullptr) \
761 )
762
763 template <typename T>
764 union q_padded_xcb_event {
765 T event;
766 char padding[32];
767 };
768
769 // The xcb_send_event() requires all events to have 32 bytes. It calls memcpy() on the
770 // passed in event. If the passed in event is less than 32 bytes, memcpy() reaches into
771 // unrelated memory.
772 #define Q_DECLARE_XCB_EVENT(event_var, event_type) \
773 q_padded_xcb_event<event_type> store = {}; \
774 auto &event_var = store.event;
775
776 QT_END_NAMESPACE
777
778 #endif