Debian Codegraph @

xcb/libqt5xcbqpa-dev/5.11.1/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 Q_BYTE_ORDER == Q_BIG_ENDIAN
381 return m_setup->image_byte_order != XCB_IMAGE_ORDER_MSB_FIRST;
382 #else
383 return m_setup->image_byte_order != XCB_IMAGE_ORDER_LSB_FIRST;
384 #endif
385 }
386
387 QXcbKeyboard *keyboard() const { return m_keyboard; }
388
389 #ifndef QT_NO_CLIPBOARD
390 QXcbClipboard *clipboard() const { return m_clipboard; }
391 #endif
392 #if QT_CONFIG(draganddrop)
393 QXcbDrag *drag() const { return m_drag; }
394 #endif
395
396 QXcbWMSupport *wmSupport() const { return m_wmSupport.data(); }
397 xcb_window_t rootWindow();
398 xcb_window_t clientLeader();
399
400 bool hasDefaultVisualId() const { return m_defaultVisualId != UINT_MAX; }
401 xcb_visualid_t defaultVisualId() const { return m_defaultVisualId; }
402
403 #if QT_CONFIG(xcb_xlib)
404 void *xlib_display() const;
405 void *createVisualInfoForDefaultVisualId() const;
406 #endif
407 void sync();
408
409 void handleXcbError(xcb_generic_error_t *error);
410 void printXcbError(const char *message, xcb_generic_error_t *error);
411 void handleXcbEvent(xcb_generic_event_t *event);
412 void printXcbEvent(const QLoggingCategory &log, const char *message,
413 xcb_generic_event_t *event) const;
414
415 void addWindowEventListener(xcb_window_t id, QXcbWindowEventListener *eventListener);
416 void removeWindowEventListener(xcb_window_t id);
417 QXcbWindowEventListener *windowEventListenerFromId(xcb_window_t id);
418 QXcbWindow *platformWindowFromId(xcb_window_t id);
419
420 template<typename T>
421 inline xcb_generic_event_t *checkEvent(T &checker);
422
423 typedef bool (*PeekFunc)(QXcbConnection *, xcb_generic_event_t *);
424 void addPeekFunc(PeekFunc f);
425
426 // Peek at all queued events
427 qint32 generatePeekerId();
428 bool removePeekerId(qint32 peekerId);
429 enum PeekOption { PeekDefault = 0, PeekFromCachedIndex = 1 }; // see qx11info_x11.h
430 Q_DECLARE_FLAGS(PeekOptions, PeekOption)
431 typedef bool (*PeekerCallback)(xcb_generic_event_t *event, void *peekerData);
432 bool peekEventQueue(PeekerCallback peeker, void *peekerData = nullptr,
433 PeekOptions option = PeekDefault, qint32 peekerId = -1);
434
435 inline xcb_timestamp_t time() const { return m_time; }
436 inline void setTime(xcb_timestamp_t t) { if (t > m_time) m_time = t; }
437
438 inline xcb_timestamp_t netWmUserTime() const { return m_netWmUserTime; }
439 inline void setNetWmUserTime(xcb_timestamp_t t) { if (t > m_netWmUserTime) m_netWmUserTime = t; }
440
441 bool hasXFixes() const { return has_xfixes; }
442 bool hasXShape() const { return has_shape_extension; }
443 bool hasXRandr() const { return has_randr_extension; }
444 bool hasInputShape() const { return has_input_shape; }
445 bool hasXKB() const { return has_xkb; }
446 bool hasXRender(int major = -1, int minor = -1) const
447 {
448 if (has_render_extension && major != -1 && minor != -1)
449 return m_xrenderVersion >= qMakePair(major, minor);
450
451 return has_render_extension;
452 }
453 bool hasXInput2() const { return m_xi2Enabled; }
454 bool hasShm() const { return has_shm; }
455 bool hasShmFd() const { return has_shm_fd; }
456
457 bool threadedEventHandling() const { return m_reader->isRunning(); }
458
459 xcb_timestamp_t getTimestamp();
460 xcb_window_t getSelectionOwner(xcb_atom_t atom) const;
461 xcb_window_t getQtSelectionOwner();
462
463 void setButtonState(Qt::MouseButton button, bool down);
464 Qt::MouseButtons buttonState() const { return m_buttonState; }
465 Qt::MouseButton button() const { return m_button; }
466 Qt::MouseButton translateMouseButton(xcb_button_t s);
467
468 QXcbWindow *focusWindow() const { return m_focusWindow; }
469 void setFocusWindow(QWindow *);
470 QXcbWindow *mouseGrabber() const { return m_mouseGrabber; }
471 void setMouseGrabber(QXcbWindow *);
472 QXcbWindow *mousePressWindow() const { return m_mousePressWindow; }
473 void setMousePressWindow(QXcbWindow *);
474
475 QByteArray startupId() const { return m_startupId; }
476 void setStartupId(const QByteArray &nextId) { m_startupId = nextId; }
477 void clearStartupId() { m_startupId.clear(); }
478
479 void grabServer();
480 void ungrabServer();
481
482 QXcbNativeInterface *nativeInterface() const { return m_nativeInterface; }
483
484 QXcbSystemTrayTracker *systemTrayTracker() const;
485 static bool xEmbedSystemTrayAvailable();
486 static bool xEmbedSystemTrayVisualHasAlphaChannel();
487
488 #if QT_CONFIG(xinput2)
489 void xi2SelectStateEvents();
490 void xi2SelectDeviceEvents(xcb_window_t window);
491 void xi2SelectDeviceEventsCompatibility(xcb_window_t window);
492 bool xi2SetMouseGrabEnabled(xcb_window_t w, bool grab);
493 bool xi2MouseEventsDisabled() const;
494 bool isAtLeastXI21() const { return m_xi2Enabled && m_xi2Minor >= 1; }
495 bool isAtLeastXI22() const { return m_xi2Enabled && m_xi2Minor >= 2; }
496 Qt::MouseButton xiToQtMouseButton(uint32_t b);
497 #ifdef XCB_USE_XINPUT21
498 void xi2UpdateScrollingDevices();
499 #endif
500 #ifdef XCB_USE_XINPUT22
501 bool startSystemMoveResizeForTouchBegin(xcb_window_t window, const QPoint &point, int corner);
502 bool isTouchScreen(int id);
503 #endif
504 #endif
505 QXcbEventReader *eventReader() const { return m_reader; }
506
507 bool canGrab() const { return m_canGrabServer; }
508
509 QXcbGlIntegration *glIntegration() const { return m_glIntegration; }
510
511 protected:
512 bool event(QEvent *e) override;
513
514 public slots:
515 void flush() { xcb_flush(m_connection); }
516
517 private slots:
518 void processXcbEvents();
519
520 private:
521 void initializeAllAtoms();
522 void sendConnectionEvent(QXcbAtom::Atom atom, uint id = 0);
523 void initializeShm();
524 void initializeXFixes();
525 void initializeXRender();
526 void initializeXRandr();
527 void initializeXinerama();
528 void initializeXShape();
529 void initializeXKB();
530 void handleClientMessageEvent(const xcb_client_message_event_t *event);
531 QXcbScreen* findScreenForCrtc(xcb_window_t rootWindow, xcb_randr_crtc_t crtc) const;
532 QXcbScreen* findScreenForOutput(xcb_window_t rootWindow, xcb_randr_output_t output) const;
533 QXcbVirtualDesktop* virtualDesktopForRootWindow(xcb_window_t rootWindow) const;
534 void updateScreens(const xcb_randr_notify_event_t *event);
535 bool checkOutputIsPrimary(xcb_window_t rootWindow, xcb_randr_output_t output);
536 void updateScreen(QXcbScreen *screen, const xcb_randr_output_change_t &outputChange);
537 QXcbScreen *createScreen(QXcbVirtualDesktop *virtualDesktop,
538 const xcb_randr_output_change_t &outputChange,
539 xcb_randr_get_output_info_reply_t *outputInfo);
540 void destroyScreen(QXcbScreen *screen);
541 void initializeScreens();
542 bool compressEvent(xcb_generic_event_t *event, int currentIndex, QXcbEventArray *eventqueue) const;
543
544 bool m_xi2Enabled = false;
545 #if QT_CONFIG(xinput2)
546 int m_xi2Minor = -1;
547 void initializeXInput2();
548 void xi2SetupDevice(void *info, bool removeExisting = true);
549 void xi2SetupDevices();
550 struct TouchDeviceData {
551 QTouchDevice *qtTouchDevice = nullptr;
552 QHash<int, QWindowSystemInterface::TouchPoint> touchPoints;
553 QHash<int, QPointF> pointPressedPosition; // in screen coordinates where each point was pressed
554 struct ValuatorClassInfo {
555 double min = 0;
556 double max = 0;
557 int number = -1;
558 QXcbAtom::Atom label;
559 };
560 QVector<ValuatorClassInfo> valuatorInfo;
561
562 // Stuff that is relevant only for touchpads
563 QPointF firstPressedPosition; // in screen coordinates where the first point was pressed
564 QPointF firstPressedNormalPosition; // device coordinates (0 to 1, 0 to 1) where the first point was pressed
565 QSizeF size; // device size in mm
566 bool providesTouchOrientation = false;
567 };
568 TouchDeviceData *populateTouchDevices(void *info);
569 TouchDeviceData *touchDeviceForId(int id);
570 void xi2HandleEvent(xcb_ge_event_t *event);
571 void xi2HandleHierarchyEvent(void *event);
572 void xi2HandleDeviceChangedEvent(void *event);
573 int m_xiOpCode, m_xiEventBase, m_xiErrorBase;
574 #ifdef XCB_USE_XINPUT22
575 void xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindow);
576 #endif // XCB_USE_XINPUT22
577 #if QT_CONFIG(tabletevent)
578 struct TabletData {
579 int deviceId = 0;
580 QTabletEvent::PointerType pointerType = QTabletEvent::UnknownPointer;
581 QTabletEvent::TabletDevice tool = QTabletEvent::Stylus;
582 Qt::MouseButtons buttons = 0;
583 qint64 serialId = 0;
584 bool inProximity = false;
585 struct ValuatorClassInfo {
586 double minVal = 0;
587 double maxVal = 0;
588 double curVal = 0;
589 int number = -1;
590 };
591 QHash<int, ValuatorClassInfo> valuatorInfo;
592 };
593 friend class QTypeInfo<TabletData>;
594 friend class QTypeInfo<TabletData::ValuatorClassInfo>;
595 bool xi2HandleTabletEvent(const void *event, TabletData *tabletData);
596 void xi2ReportTabletEvent(const void *event, TabletData *tabletData);
597 QVector<TabletData> m_tabletData;
598 TabletData *tabletDataForDevice(int id);
599 #endif // QT_CONFIG(tabletevent)
600 struct ScrollingDevice {
601 int deviceId = 0;
602 int verticalIndex = 0;
603 int horizontalIndex = 0;
604 double verticalIncrement = 0;
605 double horizontalIncrement = 0;
606 Qt::Orientations orientations = 0;
607 Qt::Orientations legacyOrientations = 0;
608 QPointF lastScrollPosition;
609 };
610 QHash<int, ScrollingDevice> m_scrollingDevices;
611 #ifdef XCB_USE_XINPUT21
612 void xi2HandleScrollEvent(void *event, ScrollingDevice &scrollingDevice);
613 void xi2UpdateScrollingDevice(ScrollingDevice &scrollingDevice);
614 ScrollingDevice *scrollingDeviceForId(int id);
615 #endif
616
617 static bool xi2GetValuatorValueIfSet(const void *event, int valuatorNum, double *value);
618 static void xi2PrepareXIGenericDeviceEvent(xcb_ge_event_t *event);
619 #endif
620
621 xcb_connection_t *m_connection = nullptr;
622 const xcb_setup_t *m_setup = nullptr;
623 const bool m_canGrabServer;
624 const xcb_visualid_t m_defaultVisualId;
625
626 QList<QXcbVirtualDesktop *> m_virtualDesktops;
627 QList<QXcbScreen *> m_screens;
628 int m_primaryScreenNumber = 0;
629
630 xcb_atom_t m_allAtoms[QXcbAtom::NAtoms];
631
632 xcb_timestamp_t m_time = XCB_CURRENT_TIME;
633 xcb_timestamp_t m_netWmUserTime = XCB_CURRENT_TIME;
634
635 QByteArray m_displayName;
636
637 QXcbKeyboard *m_keyboard = nullptr;
638 #ifndef QT_NO_CLIPBOARD
639 QXcbClipboard *m_clipboard = nullptr;
640 #endif
641 #if QT_CONFIG(draganddrop)
642 QXcbDrag *m_drag = nullptr;
643 #endif
644 QScopedPointer<QXcbWMSupport> m_wmSupport;
645 QXcbNativeInterface *m_nativeInterface = nullptr;
646
647 #if QT_CONFIG(xcb_xlib)
648 void *m_xlib_display = nullptr;
649 #endif
650 QXcbEventReader *m_reader = nullptr;
651
652 #if QT_CONFIG(xinput2)
653 QHash<int, TouchDeviceData> m_touchDevices;
654 #ifdef XCB_USE_XINPUT22
655 struct StartSystemMoveResizeInfo {
656 xcb_window_t window = XCB_NONE;
657 uint16_t deviceid;
658 uint32_t pointid;
659 int corner;
660 } m_startSystemMoveResizeInfo;
661 #endif
662 #endif
663 WindowMapper m_mapper;
664
665 QVector<PeekFunc> m_peekFuncs;
666
667 uint32_t xfixes_first_event = 0;
668 uint32_t xrandr_first_event = 0;
669 uint32_t xkb_first_event = 0;
670
671 bool has_xfixes = false;
672 bool has_xinerama_extension = false;
673 bool has_shape_extension = false;
674 bool has_randr_extension = false;
675 bool has_input_shape;
676 bool has_xkb = false;
677 bool has_render_extension = false;
678 bool has_shm = false;
679 bool has_shm_fd = false;
680
681 QPair<int, int> m_xrenderVersion;
682
683 Qt::MouseButtons m_buttonState = 0;
684 Qt::MouseButton m_button = Qt::NoButton;
685
686 QXcbWindow *m_focusWindow = nullptr;
687 QXcbWindow *m_mouseGrabber = nullptr;
688 QXcbWindow *m_mousePressWindow = nullptr;
689
690 xcb_window_t m_clientLeader = 0;
691 QByteArray m_startupId;
692 QXcbSystemTrayTracker *m_systemTrayTracker = nullptr;
693 QXcbGlIntegration *m_glIntegration = nullptr;
694 bool m_xiGrab = false;
695 QVector<int> m_xiMasterPointerIds;
696
697 xcb_window_t m_qtSelectionOwner = 0;
698
699 bool m_mainEventLoopFlushedQueue = false;
700 qint32 m_peekerIdSource = 0;
701 bool m_peekerIndexCacheDirty = false;
702 QHash<qint32, qint32> m_peekerToCachedIndex;
703 friend class QXcbEventReader;
704 };
705 #if QT_CONFIG(xinput2)
706 #if QT_CONFIG(tabletevent)
707 Q_DECLARE_TYPEINFO(QXcbConnection::TabletData::ValuatorClassInfo, Q_PRIMITIVE_TYPE);
708 Q_DECLARE_TYPEINFO(QXcbConnection::TabletData, Q_MOVABLE_TYPE);
709 #endif
710 #endif
711
712 template<typename T>
713 xcb_generic_event_t *QXcbConnection::checkEvent(T &checker)
714 {
715 QXcbEventArray *eventqueue = m_reader->lock();
716
717 for (int i = 0; i < eventqueue->size(); ++i) {
718 xcb_generic_event_t *event = eventqueue->at(i);
719 if (checker.checkEvent(event)) {
720 (*eventqueue)[i] = 0;
721 m_reader->unlock();
722 return event;
723 }
724 }
725 m_reader->unlock();
726 return 0;
727 }
728
729 class QXcbConnectionGrabber
730 {
731 public:
732 QXcbConnectionGrabber(QXcbConnection *connection);
733 ~QXcbConnectionGrabber();
734 void release();
735 private:
736 QXcbConnection *m_connection;
737 };
738
739 #define Q_XCB_REPLY_CONNECTION_ARG(connection, ...) connection
740
741 struct QStdFreeDeleter {
742 void operator()(void *p) const Q_DECL_NOTHROW { return std::free(p); }
743 };
744
745 #define Q_XCB_REPLY(call, ...) \
746 std::unique_ptr<call##_reply_t, QStdFreeDeleter>( \
747 call##_reply(Q_XCB_REPLY_CONNECTION_ARG(__VA_ARGS__), call(__VA_ARGS__), nullptr) \
748 )
749
750 #define Q_XCB_REPLY_UNCHECKED(call, ...) \
751 std::unique_ptr<call##_reply_t, QStdFreeDeleter>( \
752 call##_reply(Q_XCB_REPLY_CONNECTION_ARG(__VA_ARGS__), call##_unchecked(__VA_ARGS__), nullptr) \
753 )
754
755 template <typename T>
756 union q_padded_xcb_event {
757 T event;
758 char padding[32];
759 };
760
761 // The xcb_send_event() requires all events to have 32 bytes. It calls memcpy() on the
762 // passed in event. If the passed in event is less than 32 bytes, memcpy() reaches into
763 // unrelated memory.
764 #define Q_DECLARE_XCB_EVENT(event_var, event_type) \
765 q_padded_xcb_event<event_type> store = {}; \
766 auto &event_var = store.event;
767
768 QT_END_NAMESPACE
769
770 #endif