1// Copyright (C) 2016 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qxcbwindow.h"
5
6#include <QtDebug>
7#include <QMetaEnum>
8#include <QScreen>
9#include <QtCore/QFileInfo>
10#include <QtGui/QIcon>
11#include <QtGui/QRegion>
12#include <QtGui/private/qhighdpiscaling_p.h>
13
14#include "qxcbintegration.h"
15#include "qxcbconnection.h"
16#include "qxcbscreen.h"
17#if QT_CONFIG(draganddrop)
18#include "qxcbdrag.h"
19#endif
20#include "qxcbkeyboard.h"
21#include "qxcbimage.h"
22#include "qxcbwmsupport.h"
23#include "qxcbimage.h"
24#include "qxcbnativeinterface.h"
25#include "qxcbsystemtraytracker.h"
26
27#include <qpa/qplatformintegration.h>
28#include <qpa/qplatformcursor.h>
29
30#include <algorithm>
31
32#include <xcb/xcb_icccm.h>
33#include <xcb/xfixes.h>
34#include <xcb/shape.h>
35#include <xcb/xinput.h>
36
37#include <private/qguiapplication_p.h>
38#include <private/qwindow_p.h>
39
40#include <qpa/qplatformbackingstore.h>
41#include <qpa/qwindowsysteminterface.h>
42
43#include <stdio.h>
44
45#if QT_CONFIG(xcb_xlib)
46#define register /* C++17 deprecated register */
47#include <X11/Xlib.h>
48#include <X11/Xutil.h>
49#undef register
50#endif
51
52#define XCOORD_MAX 32767
53enum {
54 defaultWindowWidth = 160,
55 defaultWindowHeight = 160
56};
57
58QT_BEGIN_NAMESPACE
59
60using namespace Qt::StringLiterals;
61
62Q_LOGGING_CATEGORY(lcQpaWindow, "qt.qpa.window");
63Q_LOGGING_CATEGORY(lcQpaXcbWindow, "qt.qpa.xcb.window");
64
65Q_DECLARE_TYPEINFO(xcb_rectangle_t, Q_PRIMITIVE_TYPE);
66
67#undef FocusIn
68
69enum QX11EmbedFocusInDetail {
70 XEMBED_FOCUS_CURRENT = 0,
71 XEMBED_FOCUS_FIRST = 1,
72 XEMBED_FOCUS_LAST = 2
73};
74
75enum QX11EmbedInfoFlags {
76 XEMBED_MAPPED = (1 << 0),
77};
78
79enum QX11EmbedMessageType {
80 XEMBED_EMBEDDED_NOTIFY = 0,
81 XEMBED_WINDOW_ACTIVATE = 1,
82 XEMBED_WINDOW_DEACTIVATE = 2,
83 XEMBED_REQUEST_FOCUS = 3,
84 XEMBED_FOCUS_IN = 4,
85 XEMBED_FOCUS_OUT = 5,
86 XEMBED_FOCUS_NEXT = 6,
87 XEMBED_FOCUS_PREV = 7,
88 XEMBED_MODALITY_ON = 10,
89 XEMBED_MODALITY_OFF = 11,
90 XEMBED_REGISTER_ACCELERATOR = 12,
91 XEMBED_UNREGISTER_ACCELERATOR = 13,
92 XEMBED_ACTIVATE_ACCELERATOR = 14
93};
94
95const quint32 XEMBED_VERSION = 0;
96
97QXcbScreen *QXcbWindow::parentScreen()
98{
99 return QPlatformWindow::parent() ? static_cast<QXcbWindow*>(QPlatformWindow::parent())->parentScreen() : xcbScreen();
100}
101
102QXcbScreen *QXcbWindow::initialScreen() const
103{
104 // Resolve initial screen via QWindowPrivate::screenForGeometry(),
105 // which works in platform independent coordinates, as opposed to
106 // QPlatformWindow::screenForGeometry() that uses native coordinates.
107 QWindowPrivate *windowPrivate = qt_window_private(window: window());
108 QScreen *screen = windowPrivate->screenForGeometry(rect: window()->geometry());
109 return static_cast<QXcbScreen*>(screen->handle());
110}
111
112// Returns \c true if we should set WM_TRANSIENT_FOR on \a w
113static inline bool isTransient(const QWindow *w)
114{
115 return w->type() == Qt::Dialog
116 || w->type() == Qt::Sheet
117 || w->type() == Qt::Tool
118 || w->type() == Qt::SplashScreen
119 || w->type() == Qt::ToolTip
120 || w->type() == Qt::Drawer
121 || w->type() == Qt::Popup;
122}
123
124void QXcbWindow::setImageFormatForVisual(const xcb_visualtype_t *visual)
125{
126 if (qt_xcb_imageFormatForVisual(connection: connection(), depth: m_depth, visual, imageFormat: &m_imageFormat, needsRgbSwap: &m_imageRgbSwap))
127 return;
128
129 switch (m_depth) {
130 case 32:
131 case 24:
132 qWarning(msg: "Using RGB32 fallback, if this works your X11 server is reporting a bad screen format.");
133 m_imageFormat = QImage::Format_RGB32;
134 break;
135 case 16:
136 qWarning(msg: "Using RGB16 fallback, if this works your X11 server is reporting a bad screen format.");
137 m_imageFormat = QImage::Format_RGB16;
138 break;
139 default:
140 break;
141 }
142}
143
144#if QT_CONFIG(xcb_xlib)
145static inline XTextProperty* qstringToXTP(Display *dpy, const QString& s)
146{
147 #include <X11/Xatom.h>
148
149 static XTextProperty tp = { .value: nullptr, .encoding: 0, .format: 0, .nitems: 0 };
150 static bool free_prop = true; // we can't free tp.value in case it references
151 // the data of the static QByteArray below.
152 if (tp.value) {
153 if (free_prop)
154 XFree(tp.value);
155 tp.value = nullptr;
156 free_prop = true;
157 }
158
159 int errCode = 0;
160 QByteArray mapped = s.toLocal8Bit(); // should always be utf-8
161 char* tl[2];
162 tl[0] = mapped.data();
163 tl[1] = nullptr;
164 errCode = XmbTextListToTextProperty(display: dpy, list: tl, count: 1, style: XStdICCTextStyle, text_prop_return: &tp);
165 if (errCode < 0)
166 qCDebug(lcQpaXcb, "XmbTextListToTextProperty result code %d", errCode);
167
168 if (errCode < 0) {
169 static QByteArray qcs;
170 qcs = s.toLatin1();
171 tp.value = (uchar*)qcs.data();
172 tp.encoding = XA_STRING;
173 tp.format = 8;
174 tp.nitems = qcs.size();
175 free_prop = false;
176 }
177 return &tp;
178}
179#endif // QT_CONFIG(xcb_xlib)
180
181// TODO move this into a utility function in QWindow or QGuiApplication
182static QWindow *childWindowAt(QWindow *win, const QPoint &p)
183{
184 for (QObject *obj : win->children()) {
185 if (obj->isWindowType()) {
186 QWindow *childWin = static_cast<QWindow *>(obj);
187 if (childWin->isVisible()) {
188 if (QWindow *recurse = childWindowAt(win: childWin, p))
189 return recurse;
190 }
191 }
192 }
193 if (!win->isTopLevel()
194 && !(win->flags() & Qt::WindowTransparentForInput)
195 && win->geometry().contains(p: win->parent()->mapFromGlobal(pos: p))) {
196 return win;
197 }
198 return nullptr;
199}
200
201static const char *wm_window_type_property_id = "_q_xcb_wm_window_type";
202static const char *wm_window_role_property_id = "_q_xcb_wm_window_role";
203
204QXcbWindow::QXcbWindow(QWindow *window)
205 : QPlatformWindow(window)
206{
207 setConnection(xcbScreen()->connection());
208}
209
210enum : quint32 {
211 baseEventMask
212 = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY
213 | XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_FOCUS_CHANGE,
214
215 defaultEventMask = baseEventMask
216 | XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE
217 | XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE
218 | XCB_EVENT_MASK_BUTTON_MOTION | XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW
219 | XCB_EVENT_MASK_POINTER_MOTION,
220
221 transparentForInputEventMask = baseEventMask
222 | XCB_EVENT_MASK_VISIBILITY_CHANGE
223 | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT
224 | XCB_EVENT_MASK_COLOR_MAP_CHANGE | XCB_EVENT_MASK_OWNER_GRAB_BUTTON
225};
226
227void QXcbWindow::create()
228{
229 xcb_window_t old_m_window = m_window;
230 destroy();
231
232 m_windowState = Qt::WindowNoState;
233 m_trayIconWindow = isTrayIconWindow(window: window());
234
235 Qt::WindowType type = window()->type();
236
237 QXcbScreen *currentScreen = xcbScreen();
238 QXcbScreen *platformScreen = QPlatformWindow::parent() ? parentScreen() : initialScreen();
239 QRect rect = QPlatformWindow::parent()
240 ? QHighDpi::toNativeLocalPosition(value: window()->geometry(), context: platformScreen)
241 : QHighDpi::toNativePixels(value: window()->geometry(), context: platformScreen);
242
243 if (type == Qt::Desktop) {
244 m_window = platformScreen->root();
245 m_depth = platformScreen->screen()->root_depth;
246 m_visualId = platformScreen->screen()->root_visual;
247 const xcb_visualtype_t *visual = nullptr;
248 if (connection()->hasDefaultVisualId()) {
249 visual = platformScreen->visualForId(visualid: connection()->defaultVisualId());
250 if (visual)
251 m_visualId = connection()->defaultVisualId();
252 if (!visual)
253 qWarning(msg: "Could not use default visual id. Falling back to root_visual for screen.");
254 }
255 if (!visual)
256 visual = platformScreen->visualForId(visualid: m_visualId);
257 setImageFormatForVisual(visual);
258 connection()->addWindowEventListener(id: m_window, eventListener: this);
259 return;
260 }
261
262 const QSize minimumSize = windowMinimumSize();
263 if (rect.width() > 0 || rect.height() > 0) {
264 rect.setWidth(qBound(min: 1, val: rect.width(), XCOORD_MAX));
265 rect.setHeight(qBound(min: 1, val: rect.height(), XCOORD_MAX));
266 } else if (minimumSize.width() > 0 || minimumSize.height() > 0) {
267 rect.setSize(minimumSize);
268 } else {
269 rect.setWidth(QHighDpi::toNativePixels(value: int(defaultWindowWidth), context: platformScreen->QPlatformScreen::screen()));
270 rect.setHeight(QHighDpi::toNativePixels(value: int(defaultWindowHeight), context: platformScreen->QPlatformScreen::screen()));
271 }
272
273 QPlatformWindow::setGeometry(rect);
274
275 if (platformScreen != currentScreen)
276 QWindowSystemInterface::handleWindowScreenChanged(window: window(), newScreen: platformScreen->QPlatformScreen::screen());
277
278 xcb_window_t xcb_parent_id = platformScreen->root();
279 if (QPlatformWindow::parent()) {
280 xcb_parent_id = static_cast<QXcbWindow *>(QPlatformWindow::parent())->xcb_window();
281 m_embedded = QPlatformWindow::parent()->isForeignWindow();
282
283 QSurfaceFormat parentFormat = QPlatformWindow::parent()->window()->requestedFormat();
284 if (window()->surfaceType() != QSurface::OpenGLSurface && parentFormat.hasAlpha()) {
285 window()->setFormat(parentFormat);
286 }
287 }
288
289 resolveFormat(format: platformScreen->surfaceFormatFor(format: window()->requestedFormat()));
290
291 const xcb_visualtype_t *visual = nullptr;
292
293 if (m_trayIconWindow && connection()->systemTrayTracker()) {
294 visual = platformScreen->visualForId(visualid: connection()->systemTrayTracker()->visualId());
295 } else if (connection()->hasDefaultVisualId()) {
296 visual = platformScreen->visualForId(visualid: connection()->defaultVisualId());
297 if (!visual)
298 qWarning() << "Failed to use requested visual id.";
299 }
300
301 if (QPlatformWindow::parent()) {
302 // When using a Vulkan QWindow via QWidget::createWindowContainer() we
303 // must make sure the visuals are compatible. Now, the parent will be
304 // of RasterGLSurface which typically chooses a GLX/EGL compatible
305 // visual which may not be what the Vulkan window would choose.
306 // Therefore, take the parent's visual.
307 if (window()->surfaceType() == QSurface::VulkanSurface
308 && QPlatformWindow::parent()->window()->surfaceType() != QSurface::VulkanSurface)
309 {
310 visual = platformScreen->visualForId(visualid: static_cast<QXcbWindow *>(QPlatformWindow::parent())->visualId());
311 }
312 }
313
314 if (!visual)
315 visual = createVisual();
316
317 if (!visual) {
318 qWarning() << "Falling back to using screens root_visual.";
319 visual = platformScreen->visualForId(visualid: platformScreen->screen()->root_visual);
320 }
321
322 Q_ASSERT(visual);
323
324 m_visualId = visual->visual_id;
325 m_depth = platformScreen->depthOfVisual(visualid: m_visualId);
326 setImageFormatForVisual(visual);
327
328 quint32 mask = XCB_CW_BACK_PIXMAP
329 | XCB_CW_BORDER_PIXEL
330 | XCB_CW_BIT_GRAVITY
331 | XCB_CW_OVERRIDE_REDIRECT
332 | XCB_CW_SAVE_UNDER
333 | XCB_CW_EVENT_MASK
334 | XCB_CW_COLORMAP;
335
336 quint32 values[] = {
337 XCB_BACK_PIXMAP_NONE,
338 platformScreen->screen()->black_pixel,
339 XCB_GRAVITY_NORTH_WEST,
340 type == Qt::Popup || type == Qt::ToolTip || (window()->flags() & Qt::BypassWindowManagerHint),
341 type == Qt::Popup || type == Qt::Tool || type == Qt::SplashScreen || type == Qt::ToolTip || type == Qt::Drawer,
342 defaultEventMask,
343 platformScreen->colormapForVisual(visualid: m_visualId)
344 };
345
346 m_window = xcb_generate_id(c: xcb_connection());
347 xcb_create_window(c: xcb_connection(),
348 depth: m_depth,
349 wid: m_window, // window id
350 parent: xcb_parent_id, // parent window id
351 x: rect.x(),
352 y: rect.y(),
353 width: rect.width(),
354 height: rect.height(),
355 border_width: 0, // border width
356 class: XCB_WINDOW_CLASS_INPUT_OUTPUT, // window class
357 visual: m_visualId, // visual
358 value_mask: mask,
359 value_list: values);
360
361 connection()->addWindowEventListener(id: m_window, eventListener: this);
362
363 propagateSizeHints();
364
365 xcb_atom_t properties[5];
366 int propertyCount = 0;
367 properties[propertyCount++] = atom(atom: QXcbAtom::AtomWM_DELETE_WINDOW);
368 properties[propertyCount++] = atom(atom: QXcbAtom::AtomWM_TAKE_FOCUS);
369 properties[propertyCount++] = atom(atom: QXcbAtom::Atom_NET_WM_PING);
370
371 if (connection()->hasXSync())
372 properties[propertyCount++] = atom(atom: QXcbAtom::Atom_NET_WM_SYNC_REQUEST);
373
374 if (window()->flags() & Qt::WindowContextHelpButtonHint)
375 properties[propertyCount++] = atom(atom: QXcbAtom::Atom_NET_WM_CONTEXT_HELP);
376
377 xcb_change_property(c: xcb_connection(),
378 mode: XCB_PROP_MODE_REPLACE,
379 window: m_window,
380 property: atom(atom: QXcbAtom::AtomWM_PROTOCOLS),
381 type: XCB_ATOM_ATOM,
382 format: 32,
383 data_len: propertyCount,
384 data: properties);
385 m_syncValue.hi = 0;
386 m_syncValue.lo = 0;
387
388 const QByteArray wmClass = QXcbIntegration::instance()->wmClass();
389 if (!wmClass.isEmpty()) {
390 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE,
391 window: m_window, property: atom(atom: QXcbAtom::AtomWM_CLASS),
392 type: XCB_ATOM_STRING, format: 8, data_len: wmClass.size(), data: wmClass.constData());
393 }
394
395 QString desktopFileName = QGuiApplication::desktopFileName();
396 if (QGuiApplication::desktopFileName().isEmpty()) {
397 QFileInfo fi = QFileInfo(QCoreApplication::instance()->applicationFilePath());
398 QStringList domainName =
399 QCoreApplication::instance()->organizationDomain().split(sep: QLatin1Char('.'),
400 behavior: Qt::SkipEmptyParts);
401
402 if (domainName.isEmpty()) {
403 desktopFileName = fi.baseName();
404 } else {
405 for (int i = 0; i < domainName.size(); ++i)
406 desktopFileName.prepend(c: QLatin1Char('.')).prepend(s: domainName.at(i));
407 desktopFileName.append(s: fi.baseName());
408 }
409 }
410 if (!desktopFileName.isEmpty()) {
411 const QByteArray dfName = desktopFileName.toUtf8();
412 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE,
413 window: m_window, property: atom(atom: QXcbAtom::Atom_KDE_NET_WM_DESKTOP_FILE),
414 type: atom(atom: QXcbAtom::AtomUTF8_STRING), format: 8, data_len: dfName.size(), data: dfName.constData());
415 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE,
416 window: m_window, property: atom(atom: QXcbAtom::Atom_GTK_APPLICATION_ID),
417 type: atom(atom: QXcbAtom::AtomUTF8_STRING), format: 8, data_len: dfName.size(), data: dfName.constData());
418 }
419
420 if (connection()->hasXSync()) {
421 m_syncCounter = xcb_generate_id(c: xcb_connection());
422 xcb_sync_create_counter(c: xcb_connection(), id: m_syncCounter, initial_value: m_syncValue);
423
424 xcb_change_property(c: xcb_connection(),
425 mode: XCB_PROP_MODE_REPLACE,
426 window: m_window,
427 property: atom(atom: QXcbAtom::Atom_NET_WM_SYNC_REQUEST_COUNTER),
428 type: XCB_ATOM_CARDINAL,
429 format: 32,
430 data_len: 1,
431 data: &m_syncCounter);
432 }
433
434 // set the PID to let the WM kill the application if unresponsive
435 quint32 pid = getpid();
436 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: m_window,
437 property: atom(atom: QXcbAtom::Atom_NET_WM_PID), type: XCB_ATOM_CARDINAL, format: 32,
438 data_len: 1, data: &pid);
439
440 const QByteArray clientMachine = QSysInfo::machineHostName().toLocal8Bit();
441 if (!clientMachine.isEmpty()) {
442 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: m_window,
443 property: atom(atom: QXcbAtom::AtomWM_CLIENT_MACHINE), type: XCB_ATOM_STRING, format: 8,
444 data_len: clientMachine.size(), data: clientMachine.constData());
445 }
446
447 // Create WM_HINTS property on the window, so we can xcb_icccm_get_wm_hints*()
448 // from various setter functions for adjusting the hints.
449 xcb_icccm_wm_hints_t hints;
450 memset(s: &hints, c: 0, n: sizeof(hints));
451 hints.flags = XCB_ICCCM_WM_HINT_WINDOW_GROUP;
452 hints.window_group = connection()->clientLeader();
453 xcb_icccm_set_wm_hints(c: xcb_connection(), window: m_window, hints: &hints);
454
455 xcb_window_t leader = connection()->clientLeader();
456 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: m_window,
457 property: atom(atom: QXcbAtom::AtomWM_CLIENT_LEADER), type: XCB_ATOM_WINDOW, format: 32,
458 data_len: 1, data: &leader);
459
460 /* Add XEMBED info; this operation doesn't initiate the embedding. */
461 quint32 data[] = { XEMBED_VERSION, XEMBED_MAPPED };
462 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: m_window,
463 property: atom(atom: QXcbAtom::Atom_XEMBED_INFO),
464 type: atom(atom: QXcbAtom::Atom_XEMBED_INFO),
465 format: 32, data_len: 2, data: (void *)data);
466
467 if (connection()->hasXInput2())
468 connection()->xi2SelectDeviceEvents(window: m_window);
469
470 setWindowState(window()->windowStates());
471 setWindowFlags(window()->flags());
472 setWindowTitle(window()->title());
473
474 // force sync to read outstanding requests - see QTBUG-29106
475 connection()->sync();
476
477#if QT_CONFIG(draganddrop)
478 connection()->drag()->dndEnable(win: this, on: true);
479#endif
480
481 const qreal opacity = qt_window_private(window: window())->opacity;
482 if (!qFuzzyCompare(p1: opacity, p2: qreal(1.0)))
483 setOpacity(opacity);
484
485 setMask(QHighDpi::toNativeLocalRegion(pointRegion: window()->mask(), window: window()));
486
487 if (window()->isTopLevel())
488 setWindowIcon(window()->icon());
489
490 if (window()->dynamicPropertyNames().contains(t: wm_window_role_property_id)) {
491 QByteArray wmWindowRole = window()->property(name: wm_window_role_property_id).toByteArray();
492 setWindowRole(QString::fromLatin1(ba: wmWindowRole));
493 }
494
495 if (m_trayIconWindow)
496 m_embedded = requestSystemTrayWindowDock();
497
498 if (m_window != old_m_window) {
499 if (!m_wmTransientForChildren.isEmpty()) {
500 QList<QPointer<QXcbWindow>> transientChildren = m_wmTransientForChildren;
501 m_wmTransientForChildren.clear();
502 for (auto transientChild : transientChildren) {
503 if (transientChild)
504 transientChild->updateWmTransientFor();
505 }
506 }
507 }
508}
509
510QXcbWindow::~QXcbWindow()
511{
512 destroy();
513}
514
515QXcbForeignWindow::QXcbForeignWindow(QWindow *window, WId nativeHandle)
516 : QXcbWindow(window)
517{
518 m_window = nativeHandle;
519
520 // Reflect the foreign window's geometry as our own
521 if (auto geometry = Q_XCB_REPLY(xcb_get_geometry, xcb_connection(), m_window)) {
522 QRect nativeGeometry(geometry->x, geometry->y, geometry->width, geometry->height);
523 QPlatformWindow::setGeometry(nativeGeometry);
524 }
525
526 // And reparent, if we have a parent already
527 if (QPlatformWindow::parent())
528 setParent(QPlatformWindow::parent());
529}
530
531QXcbForeignWindow::~QXcbForeignWindow()
532{
533 if (QPlatformWindow::parent())
534 setParent(nullptr);
535
536 // Clear window so that destroy() does not affect it
537 m_window = 0;
538
539 if (connection()->mouseGrabber() == this)
540 connection()->setMouseGrabber(nullptr);
541 if (connection()->mousePressWindow() == this)
542 connection()->setMousePressWindow(nullptr);
543}
544
545void QXcbWindow::destroy()
546{
547 if (connection()->focusWindow() == this)
548 doFocusOut();
549 if (connection()->mouseGrabber() == this)
550 connection()->setMouseGrabber(nullptr);
551 if (connection()->mousePressWindow() == this)
552 connection()->setMousePressWindow(nullptr);
553
554 if (m_syncCounter && connection()->hasXSync())
555 xcb_sync_destroy_counter(c: xcb_connection(), counter: m_syncCounter);
556 if (m_window) {
557 if (m_netWmUserTimeWindow) {
558 xcb_delete_property(c: xcb_connection(), window: m_window, property: atom(atom: QXcbAtom::Atom_NET_WM_USER_TIME_WINDOW));
559 // Some window managers, like metacity, do XSelectInput on the _NET_WM_USER_TIME_WINDOW window,
560 // without trapping BadWindow (which crashes when the user time window is destroyed).
561 connection()->sync();
562 xcb_destroy_window(c: xcb_connection(), window: m_netWmUserTimeWindow);
563 m_netWmUserTimeWindow = XCB_NONE;
564 }
565 connection()->removeWindowEventListener(id: m_window);
566 xcb_destroy_window(c: xcb_connection(), window: m_window);
567 m_window = 0;
568 }
569
570 m_mapped = false;
571 m_recreationReasons = RecreationNotNeeded;
572
573 if (m_pendingSyncRequest)
574 m_pendingSyncRequest->invalidate();
575}
576
577void QXcbWindow::setGeometry(const QRect &rect)
578{
579 QPlatformWindow::setGeometry(rect);
580
581 propagateSizeHints();
582
583 QXcbScreen *currentScreen = xcbScreen();
584 QXcbScreen *newScreen = QPlatformWindow::parent() ? parentScreen() : static_cast<QXcbScreen*>(screenForGeometry(newGeometry: rect));
585
586 if (!newScreen)
587 newScreen = xcbScreen();
588
589 if (newScreen != currentScreen)
590 QWindowSystemInterface::handleWindowScreenChanged(window: window(), newScreen: newScreen->QPlatformScreen::screen());
591
592 if (qt_window_private(window: window())->positionAutomatic) {
593 const quint32 mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
594 const qint32 values[] = {
595 qBound<qint32>(min: 1, val: rect.width(), XCOORD_MAX),
596 qBound<qint32>(min: 1, val: rect.height(), XCOORD_MAX),
597 };
598 xcb_configure_window(c: xcb_connection(), window: m_window, value_mask: mask, value_list: reinterpret_cast<const quint32*>(values));
599 } else {
600 const quint32 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
601 const qint32 values[] = {
602 qBound<qint32>(min: -XCOORD_MAX, val: rect.x(), XCOORD_MAX),
603 qBound<qint32>(min: -XCOORD_MAX, val: rect.y(), XCOORD_MAX),
604 qBound<qint32>(min: 1, val: rect.width(), XCOORD_MAX),
605 qBound<qint32>(min: 1, val: rect.height(), XCOORD_MAX),
606 };
607 xcb_configure_window(c: xcb_connection(), window: m_window, value_mask: mask, value_list: reinterpret_cast<const quint32*>(values));
608 if (window()->parent() && !window()->transientParent()) {
609 // Wait for server reply for parented windows to ensure that a few window
610 // moves will come as a one event. This is important when native widget is
611 // moved a few times in X and Y directions causing native scroll. Widget
612 // must get single event to not trigger unwanted widget position changes
613 // and then expose events causing backingstore flushes with incorrect
614 // offset causing image crruption.
615 connection()->sync();
616 }
617 }
618
619 xcb_flush(c: xcb_connection());
620}
621
622QMargins QXcbWindow::frameMargins() const
623{
624 if (m_dirtyFrameMargins) {
625 if (connection()->wmSupport()->isSupportedByWM(atom: atom(atom: QXcbAtom::Atom_NET_FRAME_EXTENTS))) {
626 auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(), false, m_window,
627 atom(QXcbAtom::Atom_NET_FRAME_EXTENTS), XCB_ATOM_CARDINAL, 0, 4);
628 if (reply && reply->type == XCB_ATOM_CARDINAL && reply->format == 32 && reply->value_len == 4) {
629 quint32 *data = (quint32 *)xcb_get_property_value(R: reply.get());
630 // _NET_FRAME_EXTENTS format is left, right, top, bottom
631 m_frameMargins = QMargins(data[0], data[2], data[1], data[3]);
632 m_dirtyFrameMargins = false;
633 return m_frameMargins;
634 }
635 }
636
637 // _NET_FRAME_EXTENTS property is not available, so
638 // walk up the window tree to get the frame parent
639 xcb_window_t window = m_window;
640 xcb_window_t parent = m_window;
641
642 bool foundRoot = false;
643
644 const QList<xcb_window_t> &virtualRoots =
645 connection()->wmSupport()->virtualRoots();
646
647 while (!foundRoot) {
648 auto reply = Q_XCB_REPLY_UNCHECKED(xcb_query_tree, xcb_connection(), parent);
649 if (reply) {
650 if (reply->root == reply->parent || virtualRoots.indexOf(t: reply->parent) != -1 || reply->parent == XCB_WINDOW_NONE) {
651 foundRoot = true;
652 } else {
653 window = parent;
654 parent = reply->parent;
655 }
656 } else {
657 m_dirtyFrameMargins = false;
658 m_frameMargins = QMargins();
659 return m_frameMargins;
660 }
661 }
662
663 QPoint offset;
664
665 auto reply = Q_XCB_REPLY(xcb_translate_coordinates, xcb_connection(), window, parent, 0, 0);
666 if (reply) {
667 offset = QPoint(reply->dst_x, reply->dst_y);
668 }
669
670 auto geom = Q_XCB_REPLY(xcb_get_geometry, xcb_connection(), parent);
671 if (geom) {
672 // --
673 // add the border_width for the window managers frame... some window managers
674 // do not use a border_width of zero for their frames, and if we the left and
675 // top strut, we ensure that pos() is absolutely correct. frameGeometry()
676 // will still be incorrect though... perhaps i should have foffset as well, to
677 // indicate the frame offset (equal to the border_width on X).
678 // - Brad
679 // -- copied from qwidget_x11.cpp
680
681 int left = offset.x() + geom->border_width;
682 int top = offset.y() + geom->border_width;
683 int right = geom->width + geom->border_width - geometry().width() - offset.x();
684 int bottom = geom->height + geom->border_width - geometry().height() - offset.y();
685
686 m_frameMargins = QMargins(left, top, right, bottom);
687 }
688
689 m_dirtyFrameMargins = false;
690 }
691
692 return m_frameMargins;
693}
694
695void QXcbWindow::setVisible(bool visible)
696{
697 if (visible)
698 show();
699 else
700 hide();
701}
702
703void QXcbWindow::updateWmTransientFor()
704{
705 xcb_window_t transientXcbParent = XCB_NONE;
706 if (isTransient(w: window())) {
707 QWindow *tp = window()->transientParent();
708 if (tp && tp->handle()) {
709 QXcbWindow *handle = static_cast<QXcbWindow *>(tp->handle());
710 transientXcbParent = tp->handle()->winId();
711 if (transientXcbParent) {
712 handle->registerWmTransientForChild(this);
713 qCDebug(lcQpaXcbWindow) << Q_FUNC_INFO << static_cast<QPlatformWindow *>(handle)
714 << " registerWmTransientForChild " << static_cast<QPlatformWindow *>(this);
715 }
716 }
717 // Default to client leader if there is no transient parent, else modal dialogs can
718 // be hidden by their parents.
719 if (!transientXcbParent)
720 transientXcbParent = connection()->clientLeader();
721 if (transientXcbParent) { // ICCCM 4.1.2.6
722 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: m_window,
723 property: XCB_ATOM_WM_TRANSIENT_FOR, type: XCB_ATOM_WINDOW, format: 32,
724 data_len: 1, data: &transientXcbParent);
725 qCDebug(lcQpaXcbWindow, "0x%x added XCB_ATOM_WM_TRANSIENT_FOR 0x%x", m_window, transientXcbParent);
726 }
727 }
728 if (!transientXcbParent)
729 xcb_delete_property(c: xcb_connection(), window: m_window, property: XCB_ATOM_WM_TRANSIENT_FOR);
730}
731
732void QXcbWindow::registerWmTransientForChild(QXcbWindow *child)
733{
734 if (!child)
735 return;
736
737 if (!m_wmTransientForChildren.contains(t: child))
738 m_wmTransientForChildren.append(t: child);
739}
740
741void QXcbWindow::show()
742{
743 if (window()->isTopLevel()) {
744 if (m_recreationReasons != RecreationNotNeeded) {
745 qCDebug(lcQpaWindow) << "QXcbWindow: need to recreate window" << window() << m_recreationReasons;
746 create();
747 m_recreationReasons = RecreationNotNeeded;
748 }
749
750 // update WM_NORMAL_HINTS
751 propagateSizeHints();
752
753 // update WM_TRANSIENT_FOR
754 updateWmTransientFor();
755
756 // update _NET_WM_STATE
757 setNetWmStateOnUnmappedWindow();
758 }
759
760 // QWidget-attribute Qt::WA_ShowWithoutActivating.
761 const auto showWithoutActivating = window()->property(name: "_q_showWithoutActivating");
762 if (showWithoutActivating.isValid() && showWithoutActivating.toBool())
763 updateNetWmUserTime(timestamp: 0);
764 else if (connection()->time() != XCB_TIME_CURRENT_TIME)
765 updateNetWmUserTime(timestamp: connection()->time());
766
767 if (m_trayIconWindow)
768 return; // defer showing until XEMBED_EMBEDDED_NOTIFY
769
770 xcb_map_window(c: xcb_connection(), window: m_window);
771
772 if (QGuiApplication::modalWindow() == window())
773 requestActivateWindow();
774
775 xcbScreen()->windowShown(window: this);
776
777 connection()->sync();
778}
779
780void QXcbWindow::hide()
781{
782 xcb_unmap_window(c: xcb_connection(), window: m_window);
783
784 // send synthetic UnmapNotify event according to icccm 4.1.4
785 q_padded_xcb_event<xcb_unmap_notify_event_t> event = {};
786 event.response_type = XCB_UNMAP_NOTIFY;
787 event.event = xcbScreen()->root();
788 event.window = m_window;
789 event.from_configure = false;
790 xcb_send_event(c: xcb_connection(), propagate: false, destination: xcbScreen()->root(),
791 event_mask: XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, event: (const char *)&event);
792
793 xcb_flush(c: xcb_connection());
794
795 if (connection()->mouseGrabber() == this)
796 connection()->setMouseGrabber(nullptr);
797 if (QPlatformWindow *w = connection()->mousePressWindow()) {
798 // Unset mousePressWindow when it (or one of its parents) is unmapped
799 while (w) {
800 if (w == this) {
801 connection()->setMousePressWindow(nullptr);
802 break;
803 }
804 w = w->parent();
805 }
806 }
807
808 m_mapped = false;
809
810 // Hiding a modal window doesn't send an enter event to its transient parent when the
811 // mouse is already over the parent window, so the enter event must be emulated.
812 if (window()->isModal()) {
813 // Get the cursor position at modal window screen
814 const QPoint nativePos = xcbScreen()->cursor()->pos();
815 const QPoint cursorPos = QHighDpi::fromNativePixels(value: nativePos, context: xcbScreen()->screenForPosition(point: nativePos)->screen());
816
817 // Find the top level window at cursor position.
818 // Don't use QGuiApplication::topLevelAt(): search only the virtual siblings of this window's screen
819 QWindow *enterWindow = nullptr;
820 const auto screens = xcbScreen()->virtualSiblings();
821 for (QPlatformScreen *screen : screens) {
822 if (screen->geometry().contains(p: cursorPos)) {
823 const QPoint devicePosition = QHighDpi::toNativePixels(value: cursorPos, context: screen->screen());
824 enterWindow = screen->topLevelAt(point: devicePosition);
825 break;
826 }
827 }
828
829 if (enterWindow && enterWindow != window()) {
830 // Find the child window at cursor position, otherwise use the top level window
831 if (QWindow *childWindow = childWindowAt(win: enterWindow, p: cursorPos))
832 enterWindow = childWindow;
833 const QPoint localPos = enterWindow->mapFromGlobal(pos: cursorPos);
834 QWindowSystemInterface::handleEnterEvent(window: enterWindow,
835 local: localPos * QHighDpiScaling::factor(context: enterWindow),
836 global: nativePos);
837 }
838 }
839}
840
841bool QXcbWindow::relayFocusToModalWindow() const
842{
843 QWindow *w = static_cast<QWindowPrivate *>(QObjectPrivate::get(o: window()))->eventReceiver();
844 // get top-level window
845 while (w && w->parent())
846 w = w->parent();
847
848 QWindow *modalWindow = nullptr;
849 const bool blocked = QGuiApplicationPrivate::instance()->isWindowBlocked(window: w, blockingWindow: &modalWindow);
850 if (blocked && modalWindow != w) {
851 modalWindow->requestActivate();
852 connection()->flush();
853 return true;
854 }
855
856 return false;
857}
858
859void QXcbWindow::doFocusIn()
860{
861 if (relayFocusToModalWindow())
862 return;
863 QWindow *w = static_cast<QWindowPrivate *>(QObjectPrivate::get(o: window()))->eventReceiver();
864 connection()->setFocusWindow(w);
865 QWindowSystemInterface::handleFocusWindowChanged(window: w, r: Qt::ActiveWindowFocusReason);
866}
867
868void QXcbWindow::doFocusOut()
869{
870 connection()->setFocusWindow(nullptr);
871 relayFocusToModalWindow();
872 // Do not set the active window to nullptr if there is a FocusIn coming.
873 connection()->focusInTimer().start();
874}
875
876struct QtMotifWmHints {
877 quint32 flags, functions, decorations;
878 qint32 input_mode; // unused
879 quint32 status; // unused
880};
881
882enum {
883 MWM_HINTS_FUNCTIONS = (1L << 0),
884
885 MWM_FUNC_ALL = (1L << 0),
886 MWM_FUNC_RESIZE = (1L << 1),
887 MWM_FUNC_MOVE = (1L << 2),
888 MWM_FUNC_MINIMIZE = (1L << 3),
889 MWM_FUNC_MAXIMIZE = (1L << 4),
890 MWM_FUNC_CLOSE = (1L << 5),
891
892 MWM_HINTS_DECORATIONS = (1L << 1),
893
894 MWM_DECOR_ALL = (1L << 0),
895 MWM_DECOR_BORDER = (1L << 1),
896 MWM_DECOR_RESIZEH = (1L << 2),
897 MWM_DECOR_TITLE = (1L << 3),
898 MWM_DECOR_MENU = (1L << 4),
899 MWM_DECOR_MINIMIZE = (1L << 5),
900 MWM_DECOR_MAXIMIZE = (1L << 6),
901};
902
903QXcbWindow::NetWmStates QXcbWindow::netWmStates()
904{
905 NetWmStates result;
906
907 auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, xcb_connection(),
908 0, m_window, atom(QXcbAtom::Atom_NET_WM_STATE),
909 XCB_ATOM_ATOM, 0, 1024);
910
911 if (reply && reply->format == 32 && reply->type == XCB_ATOM_ATOM) {
912 const xcb_atom_t *states = static_cast<const xcb_atom_t *>(xcb_get_property_value(R: reply.get()));
913 const xcb_atom_t *statesEnd = states + reply->length;
914 if (statesEnd != std::find(first: states, last: statesEnd, val: atom(atom: QXcbAtom::Atom_NET_WM_STATE_ABOVE)))
915 result |= NetWmStateAbove;
916 if (statesEnd != std::find(first: states, last: statesEnd, val: atom(atom: QXcbAtom::Atom_NET_WM_STATE_BELOW)))
917 result |= NetWmStateBelow;
918 if (statesEnd != std::find(first: states, last: statesEnd, val: atom(atom: QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN)))
919 result |= NetWmStateFullScreen;
920 if (statesEnd != std::find(first: states, last: statesEnd, val: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ)))
921 result |= NetWmStateMaximizedHorz;
922 if (statesEnd != std::find(first: states, last: statesEnd, val: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT)))
923 result |= NetWmStateMaximizedVert;
924 if (statesEnd != std::find(first: states, last: statesEnd, val: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MODAL)))
925 result |= NetWmStateModal;
926 if (statesEnd != std::find(first: states, last: statesEnd, val: atom(atom: QXcbAtom::Atom_NET_WM_STATE_STAYS_ON_TOP)))
927 result |= NetWmStateStaysOnTop;
928 if (statesEnd != std::find(first: states, last: statesEnd, val: atom(atom: QXcbAtom::Atom_NET_WM_STATE_DEMANDS_ATTENTION)))
929 result |= NetWmStateDemandsAttention;
930 if (statesEnd != std::find(first: states, last: statesEnd, val: atom(atom: QXcbAtom::Atom_NET_WM_STATE_HIDDEN)))
931 result |= NetWmStateHidden;
932 } else {
933 qCDebug(lcQpaXcb, "getting net wm state (%x), empty\n", m_window);
934 }
935
936 return result;
937}
938
939void QXcbWindow::setWindowFlags(Qt::WindowFlags flags)
940{
941 Qt::WindowType type = static_cast<Qt::WindowType>(int(flags & Qt::WindowType_Mask));
942
943 if (type == Qt::ToolTip)
944 flags |= Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint | Qt::X11BypassWindowManagerHint;
945 if (type == Qt::Popup)
946 flags |= Qt::X11BypassWindowManagerHint;
947
948 Qt::WindowFlags oldflags = window()->flags();
949 if ((oldflags & Qt::WindowStaysOnTopHint) != (flags & Qt::WindowStaysOnTopHint))
950 m_recreationReasons |= WindowStaysOnTopHintChanged;
951 if ((oldflags & Qt::WindowStaysOnBottomHint) != (flags & Qt::WindowStaysOnBottomHint))
952 m_recreationReasons |= WindowStaysOnBottomHintChanged;
953
954 const quint32 mask = XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK;
955 const quint32 values[] = {
956 // XCB_CW_OVERRIDE_REDIRECT
957 (flags & Qt::BypassWindowManagerHint) ? 1u : 0,
958 // XCB_CW_EVENT_MASK
959 (flags & Qt::WindowTransparentForInput) ? transparentForInputEventMask : defaultEventMask
960 };
961
962 xcb_change_window_attributes(c: xcb_connection(), window: xcb_window(), value_mask: mask, value_list: values);
963
964 WindowTypes wmWindowTypes;
965 if (window()->dynamicPropertyNames().contains(t: wm_window_type_property_id)) {
966 wmWindowTypes = static_cast<WindowTypes>(
967 qvariant_cast<int>(v: window()->property(name: wm_window_type_property_id)));
968 }
969
970 setWmWindowType(types: wmWindowTypes, flags);
971 setNetWmState(flags);
972 setMotifWmHints(flags);
973
974 setTransparentForMouseEvents(flags & Qt::WindowTransparentForInput);
975 updateDoesNotAcceptFocus(doesNotAcceptFocus: flags & Qt::WindowDoesNotAcceptFocus);
976}
977
978void QXcbWindow::setMotifWmHints(Qt::WindowFlags flags)
979{
980 Qt::WindowType type = static_cast<Qt::WindowType>(int(flags & Qt::WindowType_Mask));
981
982 QtMotifWmHints mwmhints;
983 memset(s: &mwmhints, c: 0, n: sizeof(mwmhints));
984
985 if (type != Qt::SplashScreen) {
986 mwmhints.flags |= MWM_HINTS_DECORATIONS;
987
988 bool customize = flags & Qt::CustomizeWindowHint;
989 if (type == Qt::Window && !customize) {
990 const Qt::WindowFlags defaultFlags = Qt::WindowSystemMenuHint | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint;
991 if (!(flags & defaultFlags))
992 flags |= defaultFlags;
993 }
994 if (!(flags & Qt::FramelessWindowHint) && !(customize && !(flags & Qt::WindowTitleHint))) {
995 mwmhints.decorations |= MWM_DECOR_BORDER;
996 mwmhints.decorations |= MWM_DECOR_RESIZEH;
997 mwmhints.decorations |= MWM_DECOR_TITLE;
998
999 if (flags & Qt::WindowSystemMenuHint)
1000 mwmhints.decorations |= MWM_DECOR_MENU;
1001
1002 if (flags & Qt::WindowMinimizeButtonHint) {
1003 mwmhints.decorations |= MWM_DECOR_MINIMIZE;
1004 mwmhints.functions |= MWM_FUNC_MINIMIZE;
1005 }
1006
1007 if (flags & Qt::WindowMaximizeButtonHint) {
1008 mwmhints.decorations |= MWM_DECOR_MAXIMIZE;
1009 mwmhints.functions |= MWM_FUNC_MAXIMIZE;
1010 }
1011
1012 if (flags & Qt::WindowCloseButtonHint)
1013 mwmhints.functions |= MWM_FUNC_CLOSE;
1014 }
1015 } else {
1016 // if type == Qt::SplashScreen
1017 mwmhints.decorations = MWM_DECOR_ALL;
1018 }
1019
1020 if (mwmhints.functions != 0) {
1021 mwmhints.flags |= MWM_HINTS_FUNCTIONS;
1022 mwmhints.functions |= MWM_FUNC_MOVE | MWM_FUNC_RESIZE;
1023 } else {
1024 mwmhints.functions = MWM_FUNC_ALL;
1025 }
1026
1027 if (!(flags & Qt::FramelessWindowHint)
1028 && flags & Qt::CustomizeWindowHint
1029 && flags & Qt::WindowTitleHint
1030 && !(flags &
1031 (Qt::WindowMinimizeButtonHint
1032 | Qt::WindowMaximizeButtonHint
1033 | Qt::WindowCloseButtonHint)))
1034 {
1035 // a special case - only the titlebar without any button
1036 mwmhints.flags = MWM_HINTS_FUNCTIONS;
1037 mwmhints.functions = MWM_FUNC_MOVE | MWM_FUNC_RESIZE;
1038 mwmhints.decorations = 0;
1039 }
1040
1041 if (mwmhints.flags) {
1042 xcb_change_property(c: xcb_connection(),
1043 mode: XCB_PROP_MODE_REPLACE,
1044 window: m_window,
1045 property: atom(atom: QXcbAtom::Atom_MOTIF_WM_HINTS),
1046 type: atom(atom: QXcbAtom::Atom_MOTIF_WM_HINTS),
1047 format: 32,
1048 data_len: 5,
1049 data: &mwmhints);
1050 } else {
1051 xcb_delete_property(c: xcb_connection(), window: m_window, property: atom(atom: QXcbAtom::Atom_MOTIF_WM_HINTS));
1052 }
1053}
1054
1055void QXcbWindow::setNetWmState(bool set, xcb_atom_t one, xcb_atom_t two)
1056{
1057 xcb_client_message_event_t event;
1058
1059 event.response_type = XCB_CLIENT_MESSAGE;
1060 event.format = 32;
1061 event.sequence = 0;
1062 event.window = m_window;
1063 event.type = atom(atom: QXcbAtom::Atom_NET_WM_STATE);
1064 event.data.data32[0] = set ? 1 : 0;
1065 event.data.data32[1] = one;
1066 event.data.data32[2] = two;
1067 event.data.data32[3] = 0;
1068 event.data.data32[4] = 0;
1069
1070 xcb_send_event(c: xcb_connection(), propagate: 0, destination: xcbScreen()->root(),
1071 event_mask: XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
1072 event: (const char *)&event);
1073}
1074
1075void QXcbWindow::setNetWmState(Qt::WindowStates state)
1076{
1077 if ((m_windowState ^ state) & Qt::WindowMaximized) {
1078 setNetWmState(set: state & Qt::WindowMaximized,
1079 one: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ),
1080 two: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT));
1081 }
1082
1083 if ((m_windowState ^ state) & Qt::WindowFullScreen)
1084 setNetWmState(set: state & Qt::WindowFullScreen, one: atom(atom: QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN));
1085}
1086
1087void QXcbWindow::setNetWmState(Qt::WindowFlags flags)
1088{
1089 setNetWmState(set: flags & Qt::WindowStaysOnTopHint,
1090 one: atom(atom: QXcbAtom::Atom_NET_WM_STATE_ABOVE),
1091 two: atom(atom: QXcbAtom::Atom_NET_WM_STATE_STAYS_ON_TOP));
1092 setNetWmState(set: flags & Qt::WindowStaysOnBottomHint, one: atom(atom: QXcbAtom::Atom_NET_WM_STATE_BELOW));
1093}
1094
1095void QXcbWindow::setNetWmStateOnUnmappedWindow()
1096{
1097 if (Q_UNLIKELY(m_mapped))
1098 qCDebug(lcQpaXcb()) << "internal info: " << Q_FUNC_INFO << "called on mapped window";
1099
1100 NetWmStates states;
1101 const Qt::WindowFlags flags = window()->flags();
1102 if (flags & Qt::WindowStaysOnTopHint) {
1103 states |= NetWmStateAbove;
1104 states |= NetWmStateStaysOnTop;
1105 } else if (flags & Qt::WindowStaysOnBottomHint) {
1106 states |= NetWmStateBelow;
1107 }
1108
1109 if (window()->windowStates() & Qt::WindowMinimized)
1110 states |= NetWmStateHidden;
1111
1112 if (window()->windowStates() & Qt::WindowFullScreen)
1113 states |= NetWmStateFullScreen;
1114
1115 if (window()->windowStates() & Qt::WindowMaximized) {
1116 states |= NetWmStateMaximizedHorz;
1117 states |= NetWmStateMaximizedVert;
1118 }
1119
1120 if (window()->modality() != Qt::NonModal)
1121 states |= NetWmStateModal;
1122
1123 // According to EWMH:
1124 // "The Window Manager should remove _NET_WM_STATE whenever a window is withdrawn".
1125 // Which means that we don't have to read this property before changing it on a withdrawn
1126 // window. But there are situations where users want to adjust this property as well
1127 // (e4cea305ed2ba3c9f580bf9d16c59a1048af0e8a), so instead of overwriting the property
1128 // we first read it and then merge our hints with the existing values, allowing a user
1129 // to set custom hints.
1130
1131 QList<xcb_atom_t> atoms;
1132 auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, xcb_connection(),
1133 0, m_window, atom(QXcbAtom::Atom_NET_WM_STATE),
1134 XCB_ATOM_ATOM, 0, 1024);
1135 if (reply && reply->format == 32 && reply->type == XCB_ATOM_ATOM && reply->value_len > 0) {
1136 const xcb_atom_t *data = static_cast<const xcb_atom_t *>(xcb_get_property_value(R: reply.get()));
1137 atoms.resize(size: reply->value_len);
1138 memcpy(dest: (void *)&atoms.first(), src: (void *)data, n: reply->value_len * sizeof(xcb_atom_t));
1139 }
1140
1141 if (states & NetWmStateAbove && !atoms.contains(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_ABOVE)))
1142 atoms.push_back(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_ABOVE));
1143 if (states & NetWmStateBelow && !atoms.contains(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_BELOW)))
1144 atoms.push_back(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_BELOW));
1145 if (states & NetWmStateHidden && !atoms.contains(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_HIDDEN)))
1146 atoms.push_back(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_HIDDEN));
1147 if (states & NetWmStateFullScreen && !atoms.contains(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN)))
1148 atoms.push_back(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN));
1149 if (states & NetWmStateMaximizedHorz && !atoms.contains(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ)))
1150 atoms.push_back(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ));
1151 if (states & NetWmStateMaximizedVert && !atoms.contains(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT)))
1152 atoms.push_back(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT));
1153 if (states & NetWmStateModal && !atoms.contains(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MODAL)))
1154 atoms.push_back(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MODAL));
1155 if (states & NetWmStateStaysOnTop && !atoms.contains(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_STAYS_ON_TOP)))
1156 atoms.push_back(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_STAYS_ON_TOP));
1157 if (states & NetWmStateDemandsAttention && !atoms.contains(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_DEMANDS_ATTENTION)))
1158 atoms.push_back(t: atom(atom: QXcbAtom::Atom_NET_WM_STATE_DEMANDS_ATTENTION));
1159
1160 if (atoms.isEmpty()) {
1161 xcb_delete_property(c: xcb_connection(), window: m_window, property: atom(atom: QXcbAtom::Atom_NET_WM_STATE));
1162 } else {
1163 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: m_window,
1164 property: atom(atom: QXcbAtom::Atom_NET_WM_STATE), type: XCB_ATOM_ATOM, format: 32,
1165 data_len: atoms.size(), data: atoms.constData());
1166 }
1167 xcb_flush(c: xcb_connection());
1168}
1169
1170void QXcbWindow::setWindowState(Qt::WindowStates state)
1171{
1172 if (state == m_windowState)
1173 return;
1174
1175 Qt::WindowStates unsetState = m_windowState & ~state;
1176 Qt::WindowStates newState = state & ~m_windowState;
1177
1178 // unset old state
1179 if (unsetState & Qt::WindowMinimized)
1180 xcb_map_window(c: xcb_connection(), window: m_window);
1181 if (unsetState & Qt::WindowMaximized)
1182 setNetWmState(set: false,
1183 one: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_HORZ),
1184 two: atom(atom: QXcbAtom::Atom_NET_WM_STATE_MAXIMIZED_VERT));
1185 if (unsetState & Qt::WindowFullScreen)
1186 setNetWmState(set: false, one: atom(atom: QXcbAtom::Atom_NET_WM_STATE_FULLSCREEN));
1187
1188 // set new state
1189 if (newState & Qt::WindowMinimized) {
1190 {
1191 xcb_client_message_event_t event;
1192
1193 event.response_type = XCB_CLIENT_MESSAGE;
1194 event.format = 32;
1195 event.sequence = 0;
1196 event.window = m_window;
1197 event.type = atom(atom: QXcbAtom::AtomWM_CHANGE_STATE);
1198 event.data.data32[0] = XCB_ICCCM_WM_STATE_ICONIC;
1199 event.data.data32[1] = 0;
1200 event.data.data32[2] = 0;
1201 event.data.data32[3] = 0;
1202 event.data.data32[4] = 0;
1203
1204 xcb_send_event(c: xcb_connection(), propagate: 0, destination: xcbScreen()->root(),
1205 event_mask: XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
1206 event: (const char *)&event);
1207 }
1208 m_minimized = true;
1209 }
1210
1211 // set Maximized && FullScreen state if need
1212 setNetWmState(state);
1213
1214 xcb_get_property_cookie_t cookie = xcb_icccm_get_wm_hints_unchecked(c: xcb_connection(), window: m_window);
1215 xcb_icccm_wm_hints_t hints;
1216 if (xcb_icccm_get_wm_hints_reply(c: xcb_connection(), cookie, hints: &hints, e: nullptr)) {
1217 if (state & Qt::WindowMinimized)
1218 xcb_icccm_wm_hints_set_iconic(hints: &hints);
1219 else
1220 xcb_icccm_wm_hints_set_normal(hints: &hints);
1221 xcb_icccm_set_wm_hints(c: xcb_connection(), window: m_window, hints: &hints);
1222 }
1223
1224 connection()->sync();
1225 m_windowState = state;
1226}
1227
1228void QXcbWindow::updateNetWmUserTime(xcb_timestamp_t timestamp)
1229{
1230 xcb_window_t wid = m_window;
1231 // If timestamp == 0, then it means that the window should not be
1232 // initially activated. Don't update global user time for this
1233 // special case.
1234 if (timestamp != 0)
1235 connection()->setNetWmUserTime(timestamp);
1236
1237 const bool isSupportedByWM = connection()->wmSupport()->isSupportedByWM(atom: atom(atom: QXcbAtom::Atom_NET_WM_USER_TIME_WINDOW));
1238 if (m_netWmUserTimeWindow || isSupportedByWM) {
1239 if (!m_netWmUserTimeWindow) {
1240 m_netWmUserTimeWindow = xcb_generate_id(c: xcb_connection());
1241 xcb_create_window(c: xcb_connection(),
1242 XCB_COPY_FROM_PARENT, // depth -- same as root
1243 wid: m_netWmUserTimeWindow, // window id
1244 parent: m_window, // parent window id
1245 x: -1, y: -1, width: 1, height: 1,
1246 border_width: 0, // border width
1247 class: XCB_WINDOW_CLASS_INPUT_OUTPUT, // window class
1248 visual: m_visualId, // visual
1249 value_mask: 0, // value mask
1250 value_list: nullptr); // value list
1251 wid = m_netWmUserTimeWindow;
1252 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: m_window, property: atom(atom: QXcbAtom::Atom_NET_WM_USER_TIME_WINDOW),
1253 type: XCB_ATOM_WINDOW, format: 32, data_len: 1, data: &m_netWmUserTimeWindow);
1254 xcb_delete_property(c: xcb_connection(), window: m_window, property: atom(atom: QXcbAtom::Atom_NET_WM_USER_TIME));
1255
1256 QXcbWindow::setWindowTitle(conn: connection(), window: m_netWmUserTimeWindow,
1257 QStringLiteral("Qt NET_WM User Time Window"));
1258
1259 } else if (!isSupportedByWM) {
1260 // WM no longer supports it, then we should remove the
1261 // _NET_WM_USER_TIME_WINDOW atom.
1262 xcb_delete_property(c: xcb_connection(), window: m_window, property: atom(atom: QXcbAtom::Atom_NET_WM_USER_TIME_WINDOW));
1263 xcb_destroy_window(c: xcb_connection(), window: m_netWmUserTimeWindow);
1264 m_netWmUserTimeWindow = XCB_NONE;
1265 } else {
1266 wid = m_netWmUserTimeWindow;
1267 }
1268 }
1269 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: wid, property: atom(atom: QXcbAtom::Atom_NET_WM_USER_TIME),
1270 type: XCB_ATOM_CARDINAL, format: 32, data_len: 1, data: &timestamp);
1271}
1272
1273void QXcbWindow::setTransparentForMouseEvents(bool transparent)
1274{
1275 if (!connection()->hasXFixes() || transparent == m_transparent)
1276 return;
1277
1278 xcb_rectangle_t rectangle;
1279
1280 xcb_rectangle_t *rect = nullptr;
1281 int nrect = 0;
1282
1283 if (!transparent) {
1284 rectangle.x = 0;
1285 rectangle.y = 0;
1286 rectangle.width = geometry().width();
1287 rectangle.height = geometry().height();
1288 rect = &rectangle;
1289 nrect = 1;
1290 }
1291
1292 xcb_xfixes_region_t region = xcb_generate_id(c: xcb_connection());
1293 xcb_xfixes_create_region(c: xcb_connection(), region, rectangles_len: nrect, rectangles: rect);
1294 xcb_xfixes_set_window_shape_region_checked(c: xcb_connection(), dest: m_window, dest_kind: XCB_SHAPE_SK_INPUT, x_offset: 0, y_offset: 0, region);
1295 xcb_xfixes_destroy_region(c: xcb_connection(), region);
1296
1297 m_transparent = transparent;
1298}
1299
1300void QXcbWindow::updateDoesNotAcceptFocus(bool doesNotAcceptFocus)
1301{
1302 xcb_get_property_cookie_t cookie = xcb_icccm_get_wm_hints_unchecked(c: xcb_connection(), window: m_window);
1303
1304 xcb_icccm_wm_hints_t hints;
1305 if (!xcb_icccm_get_wm_hints_reply(c: xcb_connection(), cookie, hints: &hints, e: nullptr))
1306 return;
1307
1308 xcb_icccm_wm_hints_set_input(hints: &hints, input: !doesNotAcceptFocus);
1309 xcb_icccm_set_wm_hints(c: xcb_connection(), window: m_window, hints: &hints);
1310}
1311
1312WId QXcbWindow::winId() const
1313{
1314 return m_window;
1315}
1316
1317void QXcbWindow::setParent(const QPlatformWindow *parent)
1318{
1319 QPoint topLeft = geometry().topLeft();
1320
1321 xcb_window_t xcb_parent_id;
1322 if (parent) {
1323 const QXcbWindow *qXcbParent = static_cast<const QXcbWindow *>(parent);
1324 xcb_parent_id = qXcbParent->xcb_window();
1325 m_embedded = qXcbParent->isForeignWindow();
1326 } else {
1327 xcb_parent_id = xcbScreen()->root();
1328 m_embedded = false;
1329 }
1330 xcb_reparent_window(c: xcb_connection(), window: xcb_window(), parent: xcb_parent_id, x: topLeft.x(), y: topLeft.y());
1331 connection()->sync();
1332}
1333
1334void QXcbWindow::setWindowTitle(const QString &title)
1335{
1336 setWindowTitle(conn: connection(), window: m_window, title);
1337}
1338
1339void QXcbWindow::setWindowIconText(const QString &title)
1340{
1341 const QByteArray ba = title.toUtf8();
1342 xcb_change_property(c: xcb_connection(),
1343 mode: XCB_PROP_MODE_REPLACE,
1344 window: m_window,
1345 property: atom(atom: QXcbAtom::Atom_NET_WM_ICON_NAME),
1346 type: atom(atom: QXcbAtom::AtomUTF8_STRING),
1347 format: 8,
1348 data_len: ba.size(),
1349 data: ba.constData());
1350}
1351
1352void QXcbWindow::setWindowIcon(const QIcon &icon)
1353{
1354 QList<quint32> icon_data;
1355 const uint32_t sizeLimit = xcb_get_maximum_request_length(c: xcb_connection());
1356 if (!icon.isNull()) {
1357 QList<QSize> availableSizes = icon.availableSizes();
1358 if (availableSizes.isEmpty()) {
1359 // try to use default sizes since the icon can be a scalable image like svg.
1360 availableSizes.push_back(t: QSize(16,16));
1361 availableSizes.push_back(t: QSize(32,32));
1362 availableSizes.push_back(t: QSize(64,64));
1363 availableSizes.push_back(t: QSize(128,128));
1364 }
1365 for (int i = 0; i < availableSizes.size(); ++i) {
1366 QSize size = availableSizes.at(i);
1367 QPixmap pixmap = icon.pixmap(size);
1368 if (!pixmap.isNull()) {
1369 QImage image = pixmap.toImage().convertToFormat(f: QImage::Format_ARGB32);
1370 int pos = icon_data.size();
1371 int newSize = pos + 2 + image.width()*image.height();
1372 // In the absence of the BIG-REQUESTS extension, or with too big DPR,
1373 // the size of icon data is too big for the xcb request very easily.
1374 if (quint64(newSize) > quint64(sizeLimit))
1375 break;
1376 icon_data.resize(size: newSize);
1377 icon_data[pos++] = image.width();
1378 icon_data[pos++] = image.height();
1379 memcpy(dest: icon_data.data() + pos, src: image.bits(), n: image.width()*image.height()*4);
1380 }
1381 }
1382 }
1383
1384 if (!icon_data.isEmpty()) {
1385 // Ignore icon exceeding maximum xcb request length
1386 if (quint64(icon_data.size()) > quint64(sizeLimit)) {
1387 qWarning() << "Ignoring window icon" << icon_data.size()
1388 << "exceeds maximum xcb request length"
1389 << sizeLimit;
1390 return;
1391 }
1392 xcb_change_property(c: xcb_connection(),
1393 mode: XCB_PROP_MODE_REPLACE,
1394 window: m_window,
1395 property: atom(atom: QXcbAtom::Atom_NET_WM_ICON),
1396 type: atom(atom: QXcbAtom::AtomCARDINAL),
1397 format: 32,
1398 data_len: icon_data.size(),
1399 data: (unsigned char *) icon_data.data());
1400 } else {
1401 xcb_delete_property(c: xcb_connection(),
1402 window: m_window,
1403 property: atom(atom: QXcbAtom::Atom_NET_WM_ICON));
1404 }
1405}
1406
1407void QXcbWindow::raise()
1408{
1409 const quint32 mask = XCB_CONFIG_WINDOW_STACK_MODE;
1410 const quint32 values[] = { XCB_STACK_MODE_ABOVE };
1411 xcb_configure_window(c: xcb_connection(), window: m_window, value_mask: mask, value_list: values);
1412}
1413
1414void QXcbWindow::lower()
1415{
1416 const quint32 mask = XCB_CONFIG_WINDOW_STACK_MODE;
1417 const quint32 values[] = { XCB_STACK_MODE_BELOW };
1418 xcb_configure_window(c: xcb_connection(), window: m_window, value_mask: mask, value_list: values);
1419}
1420
1421void QXcbWindow::propagateSizeHints()
1422{
1423 // update WM_NORMAL_HINTS
1424 xcb_size_hints_t hints;
1425 memset(s: &hints, c: 0, n: sizeof(hints));
1426
1427 const QRect rect = geometry();
1428 QWindowPrivate *win = qt_window_private(window: window());
1429
1430 if (!win->positionAutomatic)
1431 xcb_icccm_size_hints_set_position(hints: &hints, user_specified: true, x: rect.x(), y: rect.y());
1432 if (rect.width() < QWINDOWSIZE_MAX || rect.height() < QWINDOWSIZE_MAX)
1433 xcb_icccm_size_hints_set_size(hints: &hints, user_specified: true, width: rect.width(), height: rect.height());
1434
1435 /* Gravity describes how to interpret x and y values the next time
1436 window needs to be positioned on a screen.
1437 XCB_GRAVITY_STATIC : the left top corner of the client window
1438 XCB_GRAVITY_NORTH_WEST : the left top corner of the frame window */
1439 auto gravity = win->positionPolicy == QWindowPrivate::WindowFrameInclusive
1440 ? XCB_GRAVITY_NORTH_WEST : XCB_GRAVITY_STATIC;
1441
1442 xcb_icccm_size_hints_set_win_gravity(hints: &hints, win_gravity: gravity);
1443
1444 QSize minimumSize = windowMinimumSize();
1445 QSize maximumSize = windowMaximumSize();
1446 QSize baseSize = windowBaseSize();
1447 QSize sizeIncrement = windowSizeIncrement();
1448
1449 if (minimumSize.width() > 0 || minimumSize.height() > 0)
1450 xcb_icccm_size_hints_set_min_size(hints: &hints,
1451 min_width: qMin(XCOORD_MAX,b: minimumSize.width()),
1452 min_height: qMin(XCOORD_MAX,b: minimumSize.height()));
1453
1454 if (maximumSize.width() < QWINDOWSIZE_MAX || maximumSize.height() < QWINDOWSIZE_MAX)
1455 xcb_icccm_size_hints_set_max_size(hints: &hints,
1456 max_width: qMin(XCOORD_MAX, b: maximumSize.width()),
1457 max_height: qMin(XCOORD_MAX, b: maximumSize.height()));
1458
1459 if (sizeIncrement.width() > 0 || sizeIncrement.height() > 0) {
1460 if (!baseSize.isNull() && baseSize.isValid())
1461 xcb_icccm_size_hints_set_base_size(hints: &hints, base_width: baseSize.width(), base_height: baseSize.height());
1462 xcb_icccm_size_hints_set_resize_inc(hints: &hints, width_inc: sizeIncrement.width(), height_inc: sizeIncrement.height());
1463 }
1464
1465 xcb_icccm_set_wm_normal_hints(c: xcb_connection(), window: m_window, hints: &hints);
1466
1467 m_sizeHintsScaleFactor = QHighDpiScaling::factor(context: screen());
1468}
1469
1470void QXcbWindow::requestActivateWindow()
1471{
1472 /* Never activate embedded windows; doing that would prevent the container
1473 * to re-gain the keyboard focus later. */
1474 if (m_embedded) {
1475 QPlatformWindow::requestActivateWindow();
1476 return;
1477 }
1478
1479 {
1480 QMutexLocker locker(&m_mappedMutex);
1481 if (!m_mapped) {
1482 m_deferredActivation = true;
1483 return;
1484 }
1485 m_deferredActivation = false;
1486 }
1487
1488 updateNetWmUserTime(timestamp: connection()->time());
1489 QWindow *focusWindow = QGuiApplication::focusWindow();
1490 xcb_window_t current = XCB_NONE;
1491 if (focusWindow) {
1492 if (QPlatformWindow *pw = focusWindow->handle())
1493 current = pw->winId();
1494 }
1495
1496 if (window()->isTopLevel()
1497 && !(window()->flags() & Qt::X11BypassWindowManagerHint)
1498 && (!focusWindow || !window()->isAncestorOf(child: focusWindow))
1499 && connection()->wmSupport()->isSupportedByWM(atom: atom(atom: QXcbAtom::Atom_NET_ACTIVE_WINDOW))) {
1500 xcb_client_message_event_t event;
1501
1502 event.response_type = XCB_CLIENT_MESSAGE;
1503 event.format = 32;
1504 event.sequence = 0;
1505 event.window = m_window;
1506 event.type = atom(atom: QXcbAtom::Atom_NET_ACTIVE_WINDOW);
1507 event.data.data32[0] = 1;
1508 event.data.data32[1] = connection()->time();
1509 event.data.data32[2] = current;
1510 event.data.data32[3] = 0;
1511 event.data.data32[4] = 0;
1512
1513 xcb_send_event(c: xcb_connection(), propagate: 0, destination: xcbScreen()->root(),
1514 event_mask: XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
1515 event: (const char *)&event);
1516 } else {
1517 xcb_set_input_focus(c: xcb_connection(), revert_to: XCB_INPUT_FOCUS_PARENT, focus: m_window, time: connection()->time());
1518 }
1519
1520 connection()->sync();
1521}
1522
1523QSurfaceFormat QXcbWindow::format() const
1524{
1525 return m_format;
1526}
1527
1528QXcbWindow::WindowTypes QXcbWindow::wmWindowTypes() const
1529{
1530 WindowTypes result;
1531
1532 auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, xcb_connection(),
1533 0, m_window, atom(QXcbAtom::Atom_NET_WM_WINDOW_TYPE),
1534 XCB_ATOM_ATOM, 0, 1024);
1535 if (reply && reply->format == 32 && reply->type == XCB_ATOM_ATOM) {
1536 const xcb_atom_t *types = static_cast<const xcb_atom_t *>(xcb_get_property_value(R: reply.get()));
1537 const xcb_atom_t *types_end = types + reply->length;
1538 for (; types != types_end; types++) {
1539 QXcbAtom::Atom type = connection()->qatom(atom: *types);
1540 switch (type) {
1541 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NORMAL:
1542 result |= WindowType::Normal;
1543 break;
1544 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DESKTOP:
1545 result |= WindowType::Desktop;
1546 break;
1547 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DOCK:
1548 result |= WindowType::Dock;
1549 break;
1550 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLBAR:
1551 result |= WindowType::Toolbar;
1552 break;
1553 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_MENU:
1554 result |= WindowType::Menu;
1555 break;
1556 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_UTILITY:
1557 result |= WindowType::Utility;
1558 break;
1559 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_SPLASH:
1560 result |= WindowType::Splash;
1561 break;
1562 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DIALOG:
1563 result |= WindowType::Dialog;
1564 break;
1565 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DROPDOWN_MENU:
1566 result |= WindowType::DropDownMenu;
1567 break;
1568 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_POPUP_MENU:
1569 result |= WindowType::PopupMenu;
1570 break;
1571 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLTIP:
1572 result |= WindowType::Tooltip;
1573 break;
1574 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NOTIFICATION:
1575 result |= WindowType::Notification;
1576 break;
1577 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_COMBO:
1578 result |= WindowType::Combo;
1579 break;
1580 case QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DND:
1581 result |= WindowType::Dnd;
1582 break;
1583 case QXcbAtom::Atom_KDE_NET_WM_WINDOW_TYPE_OVERRIDE:
1584 result |= WindowType::KdeOverride;
1585 break;
1586 default:
1587 break;
1588 }
1589 }
1590 }
1591 return result;
1592}
1593
1594void QXcbWindow::setWmWindowType(WindowTypes types, Qt::WindowFlags flags)
1595{
1596 QList<xcb_atom_t> atoms;
1597
1598 // manual selection 1 (these are never set by Qt and take precedence)
1599 if (types & WindowType::Normal)
1600 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NORMAL));
1601 if (types & WindowType::Desktop)
1602 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DESKTOP));
1603 if (types & WindowType::Dock)
1604 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DOCK));
1605 if (types & WindowType::Notification)
1606 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NOTIFICATION));
1607
1608 // manual selection 2 (Qt uses these during auto selection);
1609 if (types & WindowType::Utility)
1610 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_UTILITY));
1611 if (types & WindowType::Splash)
1612 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_SPLASH));
1613 if (types & WindowType::Dialog)
1614 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DIALOG));
1615 if (types & WindowType::Tooltip)
1616 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLTIP));
1617 if (types & WindowType::KdeOverride)
1618 atoms.append(t: atom(atom: QXcbAtom::Atom_KDE_NET_WM_WINDOW_TYPE_OVERRIDE));
1619
1620 // manual selection 3 (these can be set by Qt, but don't have a
1621 // corresponding Qt::WindowType). note that order of the *MENU
1622 // atoms is important
1623 if (types & WindowType::Menu)
1624 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_MENU));
1625 if (types & WindowType::DropDownMenu)
1626 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DROPDOWN_MENU));
1627 if (types & WindowType::PopupMenu)
1628 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_POPUP_MENU));
1629 if (types & WindowType::Toolbar)
1630 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLBAR));
1631 if (types & WindowType::Combo)
1632 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_COMBO));
1633 if (types & WindowType::Dnd)
1634 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DND));
1635
1636 // automatic selection
1637 Qt::WindowType type = static_cast<Qt::WindowType>(int(flags & Qt::WindowType_Mask));
1638 switch (type) {
1639 case Qt::Dialog:
1640 case Qt::Sheet:
1641 if (!(types & WindowType::Dialog))
1642 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_DIALOG));
1643 break;
1644 case Qt::Tool:
1645 case Qt::Drawer:
1646 if (!(types & WindowType::Utility))
1647 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_UTILITY));
1648 break;
1649 case Qt::ToolTip:
1650 if (!(types & WindowType::Tooltip))
1651 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_TOOLTIP));
1652 break;
1653 case Qt::SplashScreen:
1654 if (!(types & WindowType::Splash))
1655 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_SPLASH));
1656 break;
1657 default:
1658 break;
1659 }
1660
1661 if ((flags & Qt::FramelessWindowHint) && !(types & WindowType::KdeOverride)) {
1662 // override netwm type - quick and easy for KDE noborder
1663 atoms.append(t: atom(atom: QXcbAtom::Atom_KDE_NET_WM_WINDOW_TYPE_OVERRIDE));
1664 }
1665
1666 if (atoms.size() == 1 && atoms.first() == atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NORMAL))
1667 atoms.clear();
1668 else
1669 atoms.append(t: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE_NORMAL));
1670
1671 if (atoms.isEmpty()) {
1672 xcb_delete_property(c: xcb_connection(), window: m_window, property: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE));
1673 } else {
1674 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: m_window,
1675 property: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_TYPE), type: XCB_ATOM_ATOM, format: 32,
1676 data_len: atoms.size(), data: atoms.constData());
1677 }
1678 xcb_flush(c: xcb_connection());
1679}
1680
1681void QXcbWindow::setWindowRole(const QString &role)
1682{
1683 QByteArray roleData = role.toLatin1();
1684 xcb_change_property(c: xcb_connection(), mode: XCB_PROP_MODE_REPLACE, window: m_window,
1685 property: atom(atom: QXcbAtom::AtomWM_WINDOW_ROLE), type: XCB_ATOM_STRING, format: 8,
1686 data_len: roleData.size(), data: roleData.constData());
1687}
1688
1689void QXcbWindow::setParentRelativeBackPixmap()
1690{
1691 const quint32 mask = XCB_CW_BACK_PIXMAP;
1692 const quint32 values[] = { XCB_BACK_PIXMAP_PARENT_RELATIVE };
1693 xcb_change_window_attributes(c: xcb_connection(), window: m_window, value_mask: mask, value_list: values);
1694}
1695
1696bool QXcbWindow::requestSystemTrayWindowDock()
1697{
1698 if (!connection()->systemTrayTracker())
1699 return false;
1700 connection()->systemTrayTracker()->requestSystemTrayWindowDock(window: m_window);
1701 return true;
1702}
1703
1704bool QXcbWindow::handleNativeEvent(xcb_generic_event_t *event)
1705{
1706 auto eventType = connection()->nativeInterface()->nativeEventType();
1707 qintptr result = 0; // Used only by MS Windows
1708 return QWindowSystemInterface::handleNativeEvent(window: window(), eventType, message: event, result: &result);
1709}
1710
1711void QXcbWindow::handleExposeEvent(const xcb_expose_event_t *event)
1712{
1713 QRect rect(event->x, event->y, event->width, event->height);
1714 m_exposeRegion |= rect;
1715
1716 bool pending = true;
1717
1718 connection()->eventQueue()->peek(option: QXcbEventQueue::PeekConsumeMatchAndContinue,
1719 peeker: [this, &pending](xcb_generic_event_t *event, int type) {
1720 if (type != XCB_EXPOSE)
1721 return false;
1722 auto expose = reinterpret_cast<xcb_expose_event_t *>(event);
1723 if (expose->window != m_window)
1724 return false;
1725 if (expose->count == 0)
1726 pending = false;
1727 m_exposeRegion |= QRect(expose->x, expose->y, expose->width, expose->height);
1728 free(ptr: expose);
1729 return true;
1730 });
1731
1732 // if count is non-zero there are more expose events pending
1733 if (event->count == 0 || !pending) {
1734 QWindowSystemInterface::handleExposeEvent(window: window(), region: m_exposeRegion);
1735 m_exposeRegion = QRegion();
1736 }
1737}
1738
1739void QXcbWindow::handleClientMessageEvent(const xcb_client_message_event_t *event)
1740{
1741 if (event->format != 32)
1742 return;
1743
1744 if (event->type == atom(atom: QXcbAtom::AtomWM_PROTOCOLS)) {
1745 xcb_atom_t protocolAtom = event->data.data32[0];
1746 if (protocolAtom == atom(atom: QXcbAtom::AtomWM_DELETE_WINDOW)) {
1747 QWindowSystemInterface::handleCloseEvent(window: window());
1748 } else if (protocolAtom == atom(atom: QXcbAtom::AtomWM_TAKE_FOCUS)) {
1749 connection()->setTime(event->data.data32[1]);
1750 relayFocusToModalWindow();
1751 return;
1752 } else if (protocolAtom == atom(atom: QXcbAtom::Atom_NET_WM_PING)) {
1753 if (event->window == xcbScreen()->root())
1754 return;
1755
1756 xcb_client_message_event_t reply = *event;
1757
1758 reply.response_type = XCB_CLIENT_MESSAGE;
1759 reply.window = xcbScreen()->root();
1760
1761 xcb_send_event(c: xcb_connection(), propagate: 0, destination: xcbScreen()->root(),
1762 event_mask: XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
1763 event: (const char *)&reply);
1764 xcb_flush(c: xcb_connection());
1765 } else if (protocolAtom == atom(atom: QXcbAtom::Atom_NET_WM_SYNC_REQUEST)) {
1766 connection()->setTime(event->data.data32[1]);
1767 m_syncValue.lo = event->data.data32[2];
1768 m_syncValue.hi = event->data.data32[3];
1769 if (connection()->hasXSync())
1770 m_syncState = SyncReceived;
1771#ifndef QT_NO_WHATSTHIS
1772 } else if (protocolAtom == atom(atom: QXcbAtom::Atom_NET_WM_CONTEXT_HELP)) {
1773 QWindowSystemInterface::handleEnterWhatsThisEvent();
1774#endif
1775 } else {
1776 qCWarning(lcQpaXcb, "Unhandled WM_PROTOCOLS (%s)",
1777 connection()->atomName(protocolAtom).constData());
1778 }
1779#if QT_CONFIG(draganddrop)
1780 } else if (event->type == atom(atom: QXcbAtom::AtomXdndEnter)) {
1781 connection()->drag()->handleEnter(window: this, event);
1782 } else if (event->type == atom(atom: QXcbAtom::AtomXdndPosition)) {
1783 connection()->drag()->handlePosition(w: this, event);
1784 } else if (event->type == atom(atom: QXcbAtom::AtomXdndLeave)) {
1785 connection()->drag()->handleLeave(w: this, event);
1786 } else if (event->type == atom(atom: QXcbAtom::AtomXdndDrop)) {
1787 connection()->drag()->handleDrop(this, event);
1788#endif
1789 } else if (event->type == atom(atom: QXcbAtom::Atom_XEMBED)) {
1790 handleXEmbedMessage(event);
1791 } else if (event->type == atom(atom: QXcbAtom::Atom_NET_ACTIVE_WINDOW)) {
1792 doFocusIn();
1793 } else if (event->type == atom(atom: QXcbAtom::AtomMANAGER)
1794 || event->type == atom(atom: QXcbAtom::Atom_NET_WM_STATE)
1795 || event->type == atom(atom: QXcbAtom::AtomWM_CHANGE_STATE)) {
1796 // Ignore _NET_WM_STATE, MANAGER which are relate to tray icons
1797 // and other messages.
1798 } else if (event->type == atom(atom: QXcbAtom::Atom_COMPIZ_DECOR_PENDING)
1799 || event->type == atom(atom: QXcbAtom::Atom_COMPIZ_DECOR_REQUEST)
1800 || event->type == atom(atom: QXcbAtom::Atom_COMPIZ_DECOR_DELETE_PIXMAP)
1801 || event->type == atom(atom: QXcbAtom::Atom_COMPIZ_TOOLKIT_ACTION)
1802 || event->type == atom(atom: QXcbAtom::Atom_GTK_LOAD_ICONTHEMES)) {
1803 //silence the _COMPIZ and _GTK messages for now
1804 } else {
1805 qCWarning(lcQpaXcb) << "Unhandled client message: " << connection()->atomName(atom: event->type);
1806 }
1807}
1808
1809void QXcbWindow::handleConfigureNotifyEvent(const xcb_configure_notify_event_t *event)
1810{
1811 bool fromSendEvent = (event->response_type & 0x80);
1812 QPoint pos(event->x, event->y);
1813 if (!QPlatformWindow::parent() && !fromSendEvent) {
1814 // Do not trust the position, query it instead.
1815 auto reply = Q_XCB_REPLY(xcb_translate_coordinates, xcb_connection(),
1816 xcb_window(), xcbScreen()->root(), 0, 0);
1817 if (reply) {
1818 pos.setX(reply->dst_x);
1819 pos.setY(reply->dst_y);
1820 }
1821 }
1822
1823 const QRect actualGeometry = QRect(pos, QSize(event->width, event->height));
1824 QPlatformScreen *newScreen = QPlatformWindow::parent() ? QPlatformWindow::parent()->screen() : screenForGeometry(newGeometry: actualGeometry);
1825 if (!newScreen)
1826 return;
1827
1828 QWindowSystemInterface::handleGeometryChange(window: window(), newRect: actualGeometry);
1829
1830 // QPlatformScreen::screen() is updated asynchronously, so we can't compare it
1831 // with the newScreen. Just send the WindowScreenChanged event and QGuiApplication
1832 // will make the comparison later.
1833 QWindowSystemInterface::handleWindowScreenChanged(window: window(), newScreen: newScreen->screen());
1834
1835 if (!qFuzzyCompare(p1: QHighDpiScaling::factor(context: newScreen), p2: m_sizeHintsScaleFactor))
1836 propagateSizeHints();
1837
1838 // Send the synthetic expose event on resize only when the window is shrunk,
1839 // because the "XCB_GRAVITY_NORTH_WEST" flag doesn't send it automatically.
1840 if (!m_oldWindowSize.isEmpty()
1841 && (actualGeometry.width() < m_oldWindowSize.width()
1842 || actualGeometry.height() < m_oldWindowSize.height())) {
1843 QWindowSystemInterface::handleExposeEvent(window: window(), region: QRegion(0, 0, actualGeometry.width(), actualGeometry.height()));
1844 }
1845 m_oldWindowSize = actualGeometry.size();
1846
1847 if (connection()->hasXSync() && m_syncState == SyncReceived)
1848 m_syncState = SyncAndConfigureReceived;
1849
1850 m_dirtyFrameMargins = true;
1851}
1852
1853bool QXcbWindow::isExposed() const
1854{
1855 return m_mapped;
1856}
1857
1858bool QXcbWindow::isEmbedded() const
1859{
1860 return m_embedded;
1861}
1862
1863QPoint QXcbWindow::mapToGlobal(const QPoint &pos) const
1864{
1865 if (!m_embedded)
1866 return QPlatformWindow::mapToGlobal(pos);
1867
1868 QPoint ret;
1869 auto reply = Q_XCB_REPLY(xcb_translate_coordinates, xcb_connection(),
1870 xcb_window(), xcbScreen()->root(),
1871 pos.x(), pos.y());
1872 if (reply) {
1873 ret.setX(reply->dst_x);
1874 ret.setY(reply->dst_y);
1875 }
1876
1877 return ret;
1878}
1879
1880QPoint QXcbWindow::mapFromGlobal(const QPoint &pos) const
1881{
1882 if (!m_embedded)
1883 return QPlatformWindow::mapFromGlobal(pos);
1884
1885 QPoint ret;
1886 auto reply = Q_XCB_REPLY(xcb_translate_coordinates, xcb_connection(),
1887 xcbScreen()->root(), xcb_window(),
1888 pos.x(), pos.y());
1889 if (reply) {
1890 ret.setX(reply->dst_x);
1891 ret.setY(reply->dst_y);
1892 }
1893
1894 return ret;
1895}
1896
1897void QXcbWindow::handleMapNotifyEvent(const xcb_map_notify_event_t *event)
1898{
1899 if (event->window == m_window) {
1900 m_mappedMutex.lock();
1901 m_mapped = true;
1902 const bool deferredActivation = m_deferredActivation;
1903 m_mappedMutex.unlock();
1904 if (deferredActivation)
1905 requestActivateWindow();
1906
1907 QWindowSystemInterface::handleExposeEvent(window: window(), region: QRect(QPoint(), geometry().size()));
1908 }
1909}
1910
1911void QXcbWindow::handleUnmapNotifyEvent(const xcb_unmap_notify_event_t *event)
1912{
1913 if (event->window == m_window) {
1914 m_mappedMutex.lock();
1915 m_mapped = false;
1916 m_mappedMutex.unlock();
1917 QWindowSystemInterface::handleExposeEvent(window: window(), region: QRegion());
1918 }
1919}
1920
1921void QXcbWindow::handleButtonPressEvent(int event_x, int event_y, int root_x, int root_y,
1922 int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp,
1923 QEvent::Type type, Qt::MouseEventSource source)
1924{
1925 const bool isWheel = detail >= 4 && detail <= 7;
1926 if (!isWheel && window() != QGuiApplication::focusWindow()) {
1927 QWindow *w = static_cast<QWindowPrivate *>(QObjectPrivate::get(o: window()))->eventReceiver();
1928 if (!(w->flags() & (Qt::WindowDoesNotAcceptFocus | Qt::BypassWindowManagerHint))
1929 && w->type() != Qt::ToolTip
1930 && w->type() != Qt::Popup) {
1931 w->requestActivate();
1932 }
1933 }
1934
1935 updateNetWmUserTime(timestamp);
1936
1937 if (m_embedded && !m_trayIconWindow) {
1938 if (window() != QGuiApplication::focusWindow()) {
1939 const QXcbWindow *container = static_cast<const QXcbWindow *>(QPlatformWindow::parent());
1940 Q_ASSERT(container != nullptr);
1941
1942 sendXEmbedMessage(window: container->xcb_window(), message: XEMBED_REQUEST_FOCUS);
1943 }
1944 }
1945 QPoint local(event_x, event_y);
1946 QPoint global(root_x, root_y);
1947
1948 if (isWheel) {
1949 if (!connection()->isAtLeastXI21()) {
1950 QPoint angleDelta;
1951 if (detail == 4)
1952 angleDelta.setY(120);
1953 else if (detail == 5)
1954 angleDelta.setY(-120);
1955 else if (detail == 6)
1956 angleDelta.setX(120);
1957 else if (detail == 7)
1958 angleDelta.setX(-120);
1959 if (modifiers & Qt::AltModifier)
1960 angleDelta = angleDelta.transposed();
1961 QWindowSystemInterface::handleWheelEvent(window: window(), timestamp, local, global, pixelDelta: QPoint(), angleDelta, mods: modifiers);
1962 }
1963 return;
1964 }
1965
1966 connection()->setMousePressWindow(this);
1967
1968 handleMouseEvent(time: timestamp, local, global, modifiers, type, source);
1969}
1970
1971void QXcbWindow::handleButtonReleaseEvent(int event_x, int event_y, int root_x, int root_y,
1972 int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp,
1973 QEvent::Type type, Qt::MouseEventSource source)
1974{
1975 QPoint local(event_x, event_y);
1976 QPoint global(root_x, root_y);
1977
1978 if (detail >= 4 && detail <= 7) {
1979 // mouse wheel, handled in handleButtonPressEvent()
1980 return;
1981 }
1982
1983 if (connection()->buttonState() == Qt::NoButton) {
1984 connection()->setMousePressWindow(nullptr);
1985 m_ignorePressedWindowOnMouseLeave = false;
1986 }
1987
1988 handleMouseEvent(time: timestamp, local, global, modifiers, type, source);
1989}
1990
1991static inline bool doCheckUnGrabAncestor(QXcbConnection *conn)
1992{
1993 /* Checking for XCB_NOTIFY_MODE_GRAB and XCB_NOTIFY_DETAIL_ANCESTOR prevents unwanted
1994 * enter/leave events on AwesomeWM on mouse button press. It also ignores duplicated
1995 * enter/leave events on Alt+Tab switching on some WMs with XInput2 events.
1996 * Without XInput2 events the (Un)grabAncestor cannot be checked when mouse button is
1997 * not pressed, otherwise (e.g. on Alt+Tab) it can igonre important enter/leave events.
1998 */
1999 if (conn) {
2000 const bool mouseButtonsPressed = (conn->buttonState() != Qt::NoButton);
2001 return mouseButtonsPressed || conn->hasXInput2();
2002 }
2003 return true;
2004}
2005
2006static bool ignoreLeaveEvent(quint8 mode, quint8 detail, QXcbConnection *conn)
2007{
2008 return ((doCheckUnGrabAncestor(conn)
2009 && mode == XCB_NOTIFY_MODE_GRAB && detail == XCB_NOTIFY_DETAIL_ANCESTOR)
2010 || (mode == XCB_NOTIFY_MODE_UNGRAB && detail == XCB_NOTIFY_DETAIL_INFERIOR)
2011 || detail == XCB_NOTIFY_DETAIL_VIRTUAL
2012 || detail == XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL);
2013}
2014
2015static bool ignoreEnterEvent(quint8 mode, quint8 detail, QXcbConnection *conn = nullptr)
2016{
2017 return ((doCheckUnGrabAncestor(conn)
2018 && mode == XCB_NOTIFY_MODE_UNGRAB && detail == XCB_NOTIFY_DETAIL_ANCESTOR)
2019 || (mode != XCB_NOTIFY_MODE_NORMAL && mode != XCB_NOTIFY_MODE_UNGRAB)
2020 || detail == XCB_NOTIFY_DETAIL_VIRTUAL
2021 || detail == XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL);
2022}
2023
2024void QXcbWindow::handleEnterNotifyEvent(int event_x, int event_y, int root_x, int root_y,
2025 quint8 mode, quint8 detail, xcb_timestamp_t timestamp)
2026{
2027 connection()->setTime(timestamp);
2028
2029 if (ignoreEnterEvent(mode, detail, conn: connection())
2030 || (connection()->mousePressWindow() && !m_ignorePressedWindowOnMouseLeave)) {
2031 return;
2032 }
2033
2034 // Updates scroll valuators, as user might have done some scrolling outside our X client.
2035 connection()->xi2UpdateScrollingDevices();
2036
2037 if (mode == XCB_NOTIFY_MODE_UNGRAB && connection()->queryMouseButtons() != Qt::NoButton)
2038 m_ignorePressedWindowOnMouseLeave = true;
2039
2040 const QPoint global = QPoint(root_x, root_y);
2041 const QPoint local(event_x, event_y);
2042 QWindowSystemInterface::handleEnterEvent(window: window(), local, global);
2043}
2044
2045void QXcbWindow::handleLeaveNotifyEvent(int root_x, int root_y,
2046 quint8 mode, quint8 detail, xcb_timestamp_t timestamp)
2047{
2048 connection()->setTime(timestamp);
2049
2050 QXcbWindow *mousePressWindow = connection()->mousePressWindow();
2051 if (ignoreLeaveEvent(mode, detail, conn: connection())
2052 || (mousePressWindow && !m_ignorePressedWindowOnMouseLeave)) {
2053 return;
2054 }
2055
2056 // check if enter event is buffered
2057 auto event = connection()->eventQueue()->peek(peeker: [](xcb_generic_event_t *event, int type) {
2058 if (type != XCB_ENTER_NOTIFY)
2059 return false;
2060 auto enter = reinterpret_cast<xcb_enter_notify_event_t *>(event);
2061 return !ignoreEnterEvent(mode: enter->mode, detail: enter->detail);
2062 });
2063 auto enter = reinterpret_cast<xcb_enter_notify_event_t *>(event);
2064 QXcbWindow *enterWindow = enter ? connection()->platformWindowFromId(id: enter->event) : nullptr;
2065
2066 if (enterWindow) {
2067 QPoint local(enter->event_x, enter->event_y);
2068 QPoint global = QPoint(root_x, root_y);
2069 QWindowSystemInterface::handleEnterLeaveEvent(enter: enterWindow->window(), leave: window(), local, global);
2070 } else {
2071 QWindowSystemInterface::handleLeaveEvent(window: window());
2072 if (m_ignorePressedWindowOnMouseLeave)
2073 connection()->setMousePressWindow(nullptr);
2074 }
2075
2076 free(ptr: enter);
2077}
2078
2079void QXcbWindow::handleMotionNotifyEvent(int event_x, int event_y, int root_x, int root_y,
2080 Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp,
2081 QEvent::Type type, Qt::MouseEventSource source)
2082{
2083 QPoint local(event_x, event_y);
2084 QPoint global(root_x, root_y);
2085
2086 // "mousePressWindow" can be NULL i.e. if a window will be grabbed or unmapped, so set it again here.
2087 // Unset "mousePressWindow" when mouse button isn't pressed - in some cases the release event won't arrive.
2088 const bool isMouseButtonPressed = (connection()->buttonState() != Qt::NoButton);
2089 const bool hasMousePressWindow = (connection()->mousePressWindow() != nullptr);
2090 if (isMouseButtonPressed && !hasMousePressWindow)
2091 connection()->setMousePressWindow(this);
2092 else if (hasMousePressWindow && !isMouseButtonPressed)
2093 connection()->setMousePressWindow(nullptr);
2094
2095 handleMouseEvent(time: timestamp, local, global, modifiers, type, source);
2096}
2097
2098void QXcbWindow::handleButtonPressEvent(const xcb_button_press_event_t *event)
2099{
2100 Qt::KeyboardModifiers modifiers = connection()->keyboard()->translateModifiers(s: event->state);
2101 handleButtonPressEvent(event_x: event->event_x, event_y: event->event_y, root_x: event->root_x, root_y: event->root_y, detail: event->detail,
2102 modifiers, timestamp: event->time, type: QEvent::MouseButtonPress);
2103}
2104
2105void QXcbWindow::handleButtonReleaseEvent(const xcb_button_release_event_t *event)
2106{
2107 Qt::KeyboardModifiers modifiers = connection()->keyboard()->translateModifiers(s: event->state);
2108 handleButtonReleaseEvent(event_x: event->event_x, event_y: event->event_y, root_x: event->root_x, root_y: event->root_y, detail: event->detail,
2109 modifiers, timestamp: event->time, type: QEvent::MouseButtonRelease);
2110}
2111
2112void QXcbWindow::handleMotionNotifyEvent(const xcb_motion_notify_event_t *event)
2113{
2114 Qt::KeyboardModifiers modifiers = connection()->keyboard()->translateModifiers(s: event->state);
2115 handleMotionNotifyEvent(event_x: event->event_x, event_y: event->event_y, root_x: event->root_x, root_y: event->root_y, modifiers,
2116 timestamp: event->time, type: QEvent::MouseMove);
2117}
2118
2119static inline int fixed1616ToInt(xcb_input_fp1616_t val)
2120{
2121 return int(qreal(val) / 0x10000);
2122}
2123
2124#define qt_xcb_mask_is_set(ptr, event) (((unsigned char*)(ptr))[(event)>>3] & (1 << ((event) & 7)))
2125
2126void QXcbWindow::handleXIMouseEvent(xcb_ge_event_t *event, Qt::MouseEventSource source)
2127{
2128 QXcbConnection *conn = connection();
2129 auto *ev = reinterpret_cast<xcb_input_button_press_event_t *>(event);
2130
2131 if (ev->buttons_len > 0) {
2132 unsigned char *buttonMask = (unsigned char *) &ev[1];
2133 // There is a bug in the evdev driver which leads to receiving mouse events without
2134 // XIPointerEmulated being set: https://bugs.freedesktop.org/show_bug.cgi?id=98188
2135 // Filter them out by other attributes: when their source device is a touch screen
2136 // and the LMB is pressed.
2137 if (qt_xcb_mask_is_set(buttonMask, 1) && conn->isTouchScreen(id: ev->sourceid)) {
2138 if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
2139 qCDebug(lcQpaXInput, "XI2 mouse event from touch device %d was ignored", ev->sourceid);
2140 return;
2141 }
2142 for (int i = 1; i <= 15; ++i)
2143 conn->setButtonState(button: conn->translateMouseButton(s: i), qt_xcb_mask_is_set(buttonMask, i));
2144 }
2145
2146 const Qt::KeyboardModifiers modifiers = conn->keyboard()->translateModifiers(s: ev->mods.effective);
2147 const int event_x = fixed1616ToInt(val: ev->event_x);
2148 const int event_y = fixed1616ToInt(val: ev->event_y);
2149 const int root_x = fixed1616ToInt(val: ev->root_x);
2150 const int root_y = fixed1616ToInt(val: ev->root_y);
2151
2152 conn->keyboard()->updateXKBStateFromXI(modInfo: &ev->mods, groupInfo: &ev->group);
2153
2154 const Qt::MouseButton button = conn->xiToQtMouseButton(b: ev->detail);
2155
2156 const char *sourceName = nullptr;
2157 if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled())) {
2158 const QMetaObject *metaObject = qt_getEnumMetaObject(source);
2159 const QMetaEnum me = metaObject->enumerator(index: metaObject->indexOfEnumerator(name: qt_getEnumName(source)));
2160 sourceName = me.valueToKey(value: source);
2161 }
2162
2163 switch (ev->event_type) {
2164 case XCB_INPUT_BUTTON_PRESS:
2165 if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
2166 qCDebug(lcQpaXInputEvents, "XI2 mouse press, button %d, time %d, source %s", button, ev->time, sourceName);
2167 conn->setButtonState(button, down: true);
2168 handleButtonPressEvent(event_x, event_y, root_x, root_y, detail: ev->detail, modifiers, timestamp: ev->time, type: QEvent::MouseButtonPress, source);
2169 break;
2170 case XCB_INPUT_BUTTON_RELEASE:
2171 if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
2172 qCDebug(lcQpaXInputEvents, "XI2 mouse release, button %d, time %d, source %s", button, ev->time, sourceName);
2173 conn->setButtonState(button, down: false);
2174 handleButtonReleaseEvent(event_x, event_y, root_x, root_y, detail: ev->detail, modifiers, timestamp: ev->time, type: QEvent::MouseButtonRelease, source);
2175 break;
2176 case XCB_INPUT_MOTION:
2177 if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
2178 qCDebug(lcQpaXInputEvents, "XI2 mouse motion %d,%d, time %d, source %s", event_x, event_y, ev->time, sourceName);
2179 handleMotionNotifyEvent(event_x, event_y, root_x, root_y, modifiers, timestamp: ev->time, type: QEvent::MouseMove, source);
2180 break;
2181 default:
2182 qWarning() << "Unrecognized XI2 mouse event" << ev->event_type;
2183 break;
2184 }
2185}
2186
2187void QXcbWindow::handleXIEnterLeave(xcb_ge_event_t *event)
2188{
2189 auto *ev = reinterpret_cast<xcb_input_enter_event_t *>(event);
2190
2191 // Compare the window with current mouse grabber to prevent deliver events to any other windows.
2192 // If leave event occurs and the window is under mouse - allow to deliver the leave event.
2193 QXcbWindow *mouseGrabber = connection()->mouseGrabber();
2194 if (mouseGrabber && mouseGrabber != this
2195 && (ev->event_type != XCB_INPUT_LEAVE || QGuiApplicationPrivate::currentMouseWindow != window())) {
2196 return;
2197 }
2198
2199 const int root_x = fixed1616ToInt(val: ev->root_x);
2200 const int root_y = fixed1616ToInt(val: ev->root_y);
2201
2202 switch (ev->event_type) {
2203 case XCB_INPUT_ENTER: {
2204 const int event_x = fixed1616ToInt(val: ev->event_x);
2205 const int event_y = fixed1616ToInt(val: ev->event_y);
2206 qCDebug(lcQpaXInputEvents, "XI2 mouse enter %d,%d, mode %d, detail %d, time %d",
2207 event_x, event_y, ev->mode, ev->detail, ev->time);
2208 handleEnterNotifyEvent(event_x, event_y, root_x, root_y, mode: ev->mode, detail: ev->detail, timestamp: ev->time);
2209 break;
2210 }
2211 case XCB_INPUT_LEAVE:
2212 qCDebug(lcQpaXInputEvents, "XI2 mouse leave, mode %d, detail %d, time %d",
2213 ev->mode, ev->detail, ev->time);
2214 connection()->keyboard()->updateXKBStateFromXI(modInfo: &ev->mods, groupInfo: &ev->group);
2215 handleLeaveNotifyEvent(root_x, root_y, mode: ev->mode, detail: ev->detail, timestamp: ev->time);
2216 break;
2217 }
2218}
2219
2220QXcbWindow *QXcbWindow::toWindow() { return this; }
2221
2222void QXcbWindow::handleMouseEvent(xcb_timestamp_t time, const QPoint &local, const QPoint &global,
2223 Qt::KeyboardModifiers modifiers, QEvent::Type type, Qt::MouseEventSource source)
2224{
2225 m_lastPointerPosition = local;
2226 m_lastPointerGlobalPosition = global;
2227 connection()->setTime(time);
2228 Qt::MouseButton button = type == QEvent::MouseMove ? Qt::NoButton : connection()->button();
2229 QWindowSystemInterface::handleMouseEvent(window: window(), timestamp: time, local, global,
2230 state: connection()->buttonState(), button,
2231 type, mods: modifiers, source);
2232}
2233
2234void QXcbWindow::handleEnterNotifyEvent(const xcb_enter_notify_event_t *event)
2235{
2236 handleEnterNotifyEvent(event_x: event->event_x, event_y: event->event_y, root_x: event->root_x, root_y: event->root_y, mode: event->mode, detail: event->detail, timestamp: event->time);
2237}
2238
2239void QXcbWindow::handleLeaveNotifyEvent(const xcb_leave_notify_event_t *event)
2240{
2241 handleLeaveNotifyEvent(root_x: event->root_x, root_y: event->root_y, mode: event->mode, detail: event->detail, timestamp: event->time);
2242}
2243
2244void QXcbWindow::handlePropertyNotifyEvent(const xcb_property_notify_event_t *event)
2245{
2246 connection()->setTime(event->time);
2247
2248 const bool propertyDeleted = event->state == XCB_PROPERTY_DELETE;
2249
2250 if (event->atom == atom(atom: QXcbAtom::Atom_NET_WM_STATE) || event->atom == atom(atom: QXcbAtom::AtomWM_STATE)) {
2251 if (propertyDeleted)
2252 return;
2253
2254 Qt::WindowStates newState = Qt::WindowNoState;
2255
2256 if (event->atom == atom(atom: QXcbAtom::AtomWM_STATE)) { // WM_STATE: Quick check for 'Minimize'.
2257 auto reply = Q_XCB_REPLY(xcb_get_property, xcb_connection(),
2258 0, m_window, atom(QXcbAtom::AtomWM_STATE),
2259 XCB_ATOM_ANY, 0, 1024);
2260 if (reply && reply->format == 32 && reply->type == atom(atom: QXcbAtom::AtomWM_STATE)) {
2261 const quint32 *data = (const quint32 *)xcb_get_property_value(R: reply.get());
2262 if (reply->length != 0)
2263 m_minimized = (data[0] == XCB_ICCCM_WM_STATE_ICONIC
2264 || (data[0] == XCB_ICCCM_WM_STATE_WITHDRAWN && m_minimized));
2265 }
2266 }
2267
2268 const NetWmStates states = netWmStates();
2269 // _NET_WM_STATE_HIDDEN should be set by the Window Manager to indicate that a window would
2270 // not be visible on the screen if its desktop/viewport were active and its coordinates were
2271 // within the screen bounds. The canonical example is that minimized windows should be in
2272 // the _NET_WM_STATE_HIDDEN state.
2273 if (m_minimized && (!connection()->wmSupport()->isSupportedByWM(atom: NetWmStateHidden)
2274 || states.testFlag(flag: NetWmStateHidden)))
2275 newState = Qt::WindowMinimized;
2276
2277 if (states & NetWmStateFullScreen)
2278 newState |= Qt::WindowFullScreen;
2279 if ((states & NetWmStateMaximizedHorz) && (states & NetWmStateMaximizedVert))
2280 newState |= Qt::WindowMaximized;
2281 // Send Window state, compress events in case other flags (modality, etc) are changed.
2282 if (m_lastWindowStateEvent != newState) {
2283 QWindowSystemInterface::handleWindowStateChanged(window: window(), newState);
2284 m_lastWindowStateEvent = newState;
2285 m_windowState = newState;
2286 if ((m_windowState & Qt::WindowMinimized) && connection()->mouseGrabber() == this)
2287 connection()->setMouseGrabber(nullptr);
2288 }
2289 return;
2290 } else if (event->atom == atom(atom: QXcbAtom::Atom_NET_FRAME_EXTENTS)) {
2291 m_dirtyFrameMargins = true;
2292 }
2293}
2294
2295void QXcbWindow::handleFocusInEvent(const xcb_focus_in_event_t *event)
2296{
2297 // Ignore focus events that are being sent only because the pointer is over
2298 // our window, even if the input focus is in a different window.
2299 if (event->detail == XCB_NOTIFY_DETAIL_POINTER)
2300 return;
2301
2302 connection()->focusInTimer().stop();
2303 doFocusIn();
2304}
2305
2306
2307void QXcbWindow::handleFocusOutEvent(const xcb_focus_out_event_t *event)
2308{
2309 // Ignore focus events that are being sent only because the pointer is over
2310 // our window, even if the input focus is in a different window.
2311 if (event->detail == XCB_NOTIFY_DETAIL_POINTER)
2312 return;
2313 doFocusOut();
2314}
2315
2316void QXcbWindow::updateSyncRequestCounter()
2317{
2318 if (m_syncState != SyncAndConfigureReceived) {
2319 // window manager does not expect a sync event yet.
2320 return;
2321 }
2322 if (connection()->hasXSync() && (m_syncValue.lo != 0 || m_syncValue.hi != 0)) {
2323 xcb_sync_set_counter(c: xcb_connection(), counter: m_syncCounter, value: m_syncValue);
2324 xcb_flush(c: xcb_connection());
2325
2326 m_syncValue.lo = 0;
2327 m_syncValue.hi = 0;
2328 m_syncState = NoSyncNeeded;
2329 }
2330}
2331
2332const xcb_visualtype_t *QXcbWindow::createVisual()
2333{
2334 return xcbScreen() ? xcbScreen()->visualForFormat(format: m_format)
2335 : nullptr;
2336}
2337
2338bool QXcbWindow::setKeyboardGrabEnabled(bool grab)
2339{
2340 if (grab && !connection()->canGrab())
2341 return false;
2342
2343 if (!grab) {
2344 xcb_ungrab_keyboard(c: xcb_connection(), time: XCB_TIME_CURRENT_TIME);
2345 return true;
2346 }
2347
2348 auto reply = Q_XCB_REPLY(xcb_grab_keyboard, xcb_connection(), false,
2349 m_window, XCB_TIME_CURRENT_TIME,
2350 XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
2351 return reply && reply->status == XCB_GRAB_STATUS_SUCCESS;
2352}
2353
2354bool QXcbWindow::setMouseGrabEnabled(bool grab)
2355{
2356 if (!grab && connection()->mouseGrabber() == this)
2357 connection()->setMouseGrabber(nullptr);
2358
2359 if (grab && !connection()->canGrab())
2360 return false;
2361
2362 if (connection()->hasXInput2()) {
2363 bool result = connection()->xi2SetMouseGrabEnabled(w: m_window, grab);
2364 if (grab && result)
2365 connection()->setMouseGrabber(this);
2366 return result;
2367 }
2368
2369 if (!grab) {
2370 xcb_ungrab_pointer(c: xcb_connection(), time: XCB_TIME_CURRENT_TIME);
2371 return true;
2372 }
2373
2374 auto reply = Q_XCB_REPLY(xcb_grab_pointer, xcb_connection(),
2375 false, m_window,
2376 (XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE
2377 | XCB_EVENT_MASK_BUTTON_MOTION | XCB_EVENT_MASK_ENTER_WINDOW
2378 | XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_POINTER_MOTION),
2379 XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
2380 XCB_WINDOW_NONE, XCB_CURSOR_NONE,
2381 XCB_TIME_CURRENT_TIME);
2382 bool result = reply && reply->status == XCB_GRAB_STATUS_SUCCESS;
2383 if (result)
2384 connection()->setMouseGrabber(this);
2385 return result;
2386}
2387
2388bool QXcbWindow::windowEvent(QEvent *event)
2389{
2390 switch (event->type()) {
2391 case QEvent::FocusIn:
2392 if (m_embedded && !m_trayIconWindow && !event->spontaneous()) {
2393 QFocusEvent *focusEvent = static_cast<QFocusEvent *>(event);
2394 switch (focusEvent->reason()) {
2395 case Qt::TabFocusReason:
2396 case Qt::BacktabFocusReason:
2397 {
2398 const QXcbWindow *container =
2399 static_cast<const QXcbWindow *>(QPlatformWindow::parent());
2400 sendXEmbedMessage(window: container->xcb_window(),
2401 message: focusEvent->reason() == Qt::TabFocusReason ?
2402 XEMBED_FOCUS_NEXT : XEMBED_FOCUS_PREV);
2403 event->accept();
2404 }
2405 break;
2406 default:
2407 break;
2408 }
2409 }
2410 break;
2411 default:
2412 break;
2413 }
2414 return QPlatformWindow::windowEvent(event);
2415}
2416
2417bool QXcbWindow::startSystemResize(Qt::Edges edges)
2418{
2419 return startSystemMoveResize(pos: m_lastPointerPosition, edges);
2420}
2421
2422bool QXcbWindow::startSystemMove()
2423{
2424 return startSystemMoveResize(pos: m_lastPointerPosition, edges: 16);
2425}
2426
2427bool QXcbWindow::startSystemMoveResize(const QPoint &pos, int edges)
2428{
2429 const xcb_atom_t moveResize = connection()->atom(qatom: QXcbAtom::Atom_NET_WM_MOVERESIZE);
2430 if (!connection()->wmSupport()->isSupportedByWM(atom: moveResize))
2431 return false;
2432
2433 // ### FIXME QTBUG-53389
2434 bool startedByTouch = connection()->startSystemMoveResizeForTouch(window: m_window, edges);
2435 if (startedByTouch) {
2436 const QString wmname = connection()->windowManagerName();
2437 if (wmname != "kwin"_L1 && wmname != "openbox"_L1) {
2438 qCDebug(lcQpaXInputDevices) << "only KDE and OpenBox support startSystemMove/Resize which is triggered from touch events: XDG_CURRENT_DESKTOP="
2439 << qgetenv(varName: "XDG_CURRENT_DESKTOP");
2440 connection()->abortSystemMoveResize(window: m_window);
2441 return false;
2442 }
2443 // KWin, Openbox, AwesomeWM and Gnome have been tested to work with _NET_WM_MOVERESIZE.
2444 } else { // Started by mouse press.
2445 doStartSystemMoveResize(globalPos: mapToGlobal(pos), edges);
2446 }
2447
2448 return true;
2449}
2450
2451static uint qtEdgesToXcbMoveResizeDirection(Qt::Edges edges)
2452{
2453 if (edges == (Qt::TopEdge | Qt::LeftEdge))
2454 return 0;
2455 if (edges == Qt::TopEdge)
2456 return 1;
2457 if (edges == (Qt::TopEdge | Qt::RightEdge))
2458 return 2;
2459 if (edges == Qt::RightEdge)
2460 return 3;
2461 if (edges == (Qt::RightEdge | Qt::BottomEdge))
2462 return 4;
2463 if (edges == Qt::BottomEdge)
2464 return 5;
2465 if (edges == (Qt::BottomEdge | Qt::LeftEdge))
2466 return 6;
2467 if (edges == Qt::LeftEdge)
2468 return 7;
2469
2470 qWarning() << "Cannot convert " << edges << "to _NET_WM_MOVERESIZE direction.";
2471 return 0;
2472}
2473
2474void QXcbWindow::doStartSystemMoveResize(const QPoint &globalPos, int edges)
2475{
2476 qCDebug(lcQpaXInputDevices) << "triggered system move or resize via sending _NET_WM_MOVERESIZE client message";
2477 const xcb_atom_t moveResize = connection()->atom(qatom: QXcbAtom::Atom_NET_WM_MOVERESIZE);
2478 xcb_client_message_event_t xev;
2479 xev.response_type = XCB_CLIENT_MESSAGE;
2480 xev.type = moveResize;
2481 xev.sequence = 0;
2482 xev.window = xcb_window();
2483 xev.format = 32;
2484 xev.data.data32[0] = globalPos.x();
2485 xev.data.data32[1] = globalPos.y();
2486 if (edges == 16)
2487 xev.data.data32[2] = 8; // move
2488 else
2489 xev.data.data32[2] = qtEdgesToXcbMoveResizeDirection(edges: Qt::Edges(edges));
2490 xev.data.data32[3] = XCB_BUTTON_INDEX_1;
2491 xev.data.data32[4] = 0;
2492 xcb_ungrab_pointer(c: connection()->xcb_connection(), XCB_CURRENT_TIME);
2493 xcb_send_event(c: connection()->xcb_connection(), propagate: false, destination: xcbScreen()->root(),
2494 event_mask: XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY,
2495 event: (const char *)&xev);
2496
2497 connection()->setDuringSystemMoveResize(true);
2498}
2499
2500// Sends an XEmbed message.
2501void QXcbWindow::sendXEmbedMessage(xcb_window_t window, quint32 message,
2502 quint32 detail, quint32 data1, quint32 data2)
2503{
2504 xcb_client_message_event_t event;
2505
2506 event.response_type = XCB_CLIENT_MESSAGE;
2507 event.format = 32;
2508 event.sequence = 0;
2509 event.window = window;
2510 event.type = atom(atom: QXcbAtom::Atom_XEMBED);
2511 event.data.data32[0] = connection()->time();
2512 event.data.data32[1] = message;
2513 event.data.data32[2] = detail;
2514 event.data.data32[3] = data1;
2515 event.data.data32[4] = data2;
2516 xcb_send_event(c: xcb_connection(), propagate: false, destination: window, event_mask: XCB_EVENT_MASK_NO_EVENT, event: (const char *)&event);
2517}
2518
2519static bool focusWindowChangeQueued(const QWindow *window)
2520{
2521 /* Check from window system event queue if the next queued activation
2522 * targets a window other than @window.
2523 */
2524 QWindowSystemInterfacePrivate::FocusWindowEvent *systemEvent =
2525 static_cast<QWindowSystemInterfacePrivate::FocusWindowEvent *>
2526 (QWindowSystemInterfacePrivate::peekWindowSystemEvent(t: QWindowSystemInterfacePrivate::FocusWindow));
2527 return systemEvent && systemEvent->focused != window;
2528}
2529
2530void QXcbWindow::handleXEmbedMessage(const xcb_client_message_event_t *event)
2531{
2532 connection()->setTime(event->data.data32[0]);
2533 switch (event->data.data32[1]) {
2534 case XEMBED_WINDOW_ACTIVATE:
2535 case XEMBED_WINDOW_DEACTIVATE:
2536 break;
2537 case XEMBED_EMBEDDED_NOTIFY:
2538 xcb_map_window(c: xcb_connection(), window: m_window);
2539 xcbScreen()->windowShown(window: this);
2540 break;
2541 case XEMBED_FOCUS_IN:
2542 connection()->focusInTimer().stop();
2543 Qt::FocusReason reason;
2544 switch (event->data.data32[2]) {
2545 case XEMBED_FOCUS_FIRST:
2546 reason = Qt::TabFocusReason;
2547 break;
2548 case XEMBED_FOCUS_LAST:
2549 reason = Qt::BacktabFocusReason;
2550 break;
2551 case XEMBED_FOCUS_CURRENT:
2552 default:
2553 reason = Qt::OtherFocusReason;
2554 break;
2555 }
2556 connection()->setFocusWindow(window());
2557 QWindowSystemInterface::handleFocusWindowChanged(window: window(), r: reason);
2558 break;
2559 case XEMBED_FOCUS_OUT:
2560 if (window() == QGuiApplication::focusWindow()
2561 && !focusWindowChangeQueued(window: window())) {
2562 connection()->setFocusWindow(nullptr);
2563 QWindowSystemInterface::handleFocusWindowChanged(window: nullptr);
2564 }
2565 break;
2566 }
2567}
2568
2569static inline xcb_rectangle_t qRectToXCBRectangle(const QRect &r)
2570{
2571 xcb_rectangle_t result;
2572 result.x = qMax(SHRT_MIN, b: r.x());
2573 result.y = qMax(SHRT_MIN, b: r.y());
2574 result.width = qMin(a: (int)USHRT_MAX, b: r.width());
2575 result.height = qMin(a: (int)USHRT_MAX, b: r.height());
2576 return result;
2577}
2578
2579void QXcbWindow::setOpacity(qreal level)
2580{
2581 if (!m_window)
2582 return;
2583
2584 quint32 value = qRound64(d: qBound(min: qreal(0), val: level, max: qreal(1)) * 0xffffffff);
2585
2586 xcb_change_property(c: xcb_connection(),
2587 mode: XCB_PROP_MODE_REPLACE,
2588 window: m_window,
2589 property: atom(atom: QXcbAtom::Atom_NET_WM_WINDOW_OPACITY),
2590 type: XCB_ATOM_CARDINAL,
2591 format: 32,
2592 data_len: 1,
2593 data: (uchar *)&value);
2594}
2595
2596QList<xcb_rectangle_t> qRegionToXcbRectangleList(const QRegion &region)
2597{
2598 QList<xcb_rectangle_t> rects;
2599 rects.reserve(asize: region.rectCount());
2600 for (const QRect &r : region)
2601 rects.push_back(t: qRectToXCBRectangle(r));
2602 return rects;
2603}
2604
2605void QXcbWindow::setMask(const QRegion &region)
2606{
2607 if (!connection()->hasXShape())
2608 return;
2609 if (region.isEmpty()) {
2610 xcb_shape_mask(c: connection()->xcb_connection(), operation: XCB_SHAPE_SO_SET,
2611 destination_kind: XCB_SHAPE_SK_BOUNDING, destination_window: xcb_window(), x_offset: 0, y_offset: 0, XCB_NONE);
2612 } else {
2613 const auto rects = qRegionToXcbRectangleList(region);
2614 xcb_shape_rectangles(c: connection()->xcb_connection(), operation: XCB_SHAPE_SO_SET,
2615 destination_kind: XCB_SHAPE_SK_BOUNDING, ordering: XCB_CLIP_ORDERING_UNSORTED,
2616 destination_window: xcb_window(), x_offset: 0, y_offset: 0, rectangles_len: rects.size(), rectangles: &rects[0]);
2617 }
2618}
2619
2620void QXcbWindow::setAlertState(bool enabled)
2621{
2622 if (m_alertState == enabled)
2623 return;
2624
2625 m_alertState = enabled;
2626
2627 setNetWmState(set: enabled, one: atom(atom: QXcbAtom::Atom_NET_WM_STATE_DEMANDS_ATTENTION));
2628}
2629
2630uint QXcbWindow::visualId() const
2631{
2632 return m_visualId;
2633}
2634
2635bool QXcbWindow::needsSync() const
2636{
2637 return m_syncState == SyncAndConfigureReceived;
2638}
2639
2640void QXcbWindow::postSyncWindowRequest()
2641{
2642 if (!m_pendingSyncRequest) {
2643 QXcbSyncWindowRequest *e = new QXcbSyncWindowRequest(this);
2644 m_pendingSyncRequest = e;
2645 QCoreApplication::postEvent(receiver: xcbScreen()->connection(), event: e);
2646 }
2647}
2648
2649QXcbScreen *QXcbWindow::xcbScreen() const
2650{
2651 return static_cast<QXcbScreen *>(screen());
2652}
2653
2654void QXcbWindow::setWindowTitle(const QXcbConnection *conn, xcb_window_t window, const QString &title)
2655{
2656 QString fullTitle = formatWindowTitle(title, separator: QString::fromUtf8(utf8: " \xe2\x80\x94 ")); // unicode character U+2014, EM DASH
2657 const QByteArray ba = std::move(fullTitle).toUtf8();
2658 xcb_change_property(c: conn->xcb_connection(),
2659 mode: XCB_PROP_MODE_REPLACE,
2660 window,
2661 property: conn->atom(qatom: QXcbAtom::Atom_NET_WM_NAME),
2662 type: conn->atom(qatom: QXcbAtom::AtomUTF8_STRING),
2663 format: 8,
2664 data_len: ba.size(),
2665 data: ba.constData());
2666
2667#if QT_CONFIG(xcb_xlib)
2668 Display *dpy = static_cast<Display *>(conn->xlib_display());
2669 XTextProperty *text = qstringToXTP(dpy, s: title);
2670 if (text)
2671 XSetWMName(dpy, window, text);
2672#endif
2673 xcb_flush(c: conn->xcb_connection());
2674}
2675
2676QString QXcbWindow::windowTitle(const QXcbConnection *conn, xcb_window_t window)
2677{
2678 const xcb_atom_t utf8Atom = conn->atom(qatom: QXcbAtom::AtomUTF8_STRING);
2679 auto reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, conn->xcb_connection(),
2680 false, window, conn->atom(QXcbAtom::Atom_NET_WM_NAME),
2681 utf8Atom, 0, 1024);
2682 if (reply && reply->format == 8 && reply->type == utf8Atom) {
2683 const char *name = reinterpret_cast<const char *>(xcb_get_property_value(R: reply.get()));
2684 return QString::fromUtf8(utf8: name, size: xcb_get_property_value_length(R: reply.get()));
2685 }
2686
2687 reply = Q_XCB_REPLY_UNCHECKED(xcb_get_property, conn->xcb_connection(),
2688 false, window, conn->atom(QXcbAtom::AtomWM_NAME),
2689 XCB_ATOM_STRING, 0, 1024);
2690 if (reply && reply->format == 8 && reply->type == XCB_ATOM_STRING) {
2691 const char *name = reinterpret_cast<const char *>(xcb_get_property_value(R: reply.get()));
2692 return QString::fromLatin1(str: name, size: xcb_get_property_value_length(R: reply.get()));
2693 }
2694
2695 return QString();
2696}
2697
2698QT_END_NAMESPACE
2699
2700

Provided by KDAB

Privacy Policy
Start learning QML with our Intro Training
Find out more

source code of qtbase/src/plugins/platforms/xcb/qxcbwindow.cpp