Differential D6047 Diff 17813 src/client/xdgshell_v6.cpp

Changeset View

Standalone View

View Options

src/client/xdgshell_v6.cpp

  • This file was added.
1​/****************************************************************************
2​Copyright 2017 David Edmundson <davidedmundson@kde.org>
3​
4​This library is free software; you can redistribute it and/or
5​modify it under the terms of the GNU Lesser General Public
6​License as published by the Free Software Foundation; either
7​version 2.1 of the License, or (at your option) version 3, or any
8​later version accepted by the membership of KDE e.V. (or its
9​successor approved by the membership of KDE e.V.), which shall
10​act as a proxy defined in Section 6 of version 3 of the license.
11​
12​This library is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​Lesser General Public License for more details.
16​
17​You should have received a copy of the GNU Lesser General Public
18​License along with this library. If not, see <http://www.gnu.org/licenses/>.
19​****************************************************************************/
20​#include "xdgshell_p.h"
21​#include "event_queue.h"
22​#include "output.h"
23​#include "seat.h"
24​#include "surface.h"
25​#include "wayland_pointer_p.h"
26​#include <wayland-xdg-shell-v6-client-protocol.h>
27​
28​#include <QDebug>
graesslinUnsubmitted
Not Done

I don't see any debug messages in this file

graesslin: I don't see any debug messages in this file
29​
30​namespace KWayland
31​{
32​namespace Client
33​{
34​
35​class XdgShellUnstableV6::Private : public XdgShell::Private
36​{
37​public:
38​ void setupV6(zxdg_shell_v6 *shell) override;
39​ void release() override;
40​ void destroy() override;
41​ bool isValid() const override;
42​ XdgShellSurface *getXdgSurface(Surface *surface, QObject *parent) override;
43​
44​ XdgShellPopup *getXdgPopup(Surface *surface, XdgShellSurface *parentSurface, const XdgPositioner &positioner, QObject *parent) override;
45​ XdgShellPopup *getXdgPopup(Surface *surface, XdgShellPopup *parentSurface, const XdgPositioner &positioner, QObject *parent) override;
46​
47​ operator zxdg_shell_v6*() override {
48​ return xdgshellv6;
49​ }
50​ operator zxdg_shell_v6*() const override {
51​ return xdgshellv6;
52​ }
53​
54​private:
55​ XdgShellPopup *internalGetXdgPopup(Surface *surface, zxdg_surface_v6 *parentSurface, const XdgPositioner &positioner, QObject *parent);
56​ static void pingCallback(void *data, struct zxdg_shell_v6 *shell, uint32_t serial);
57​
58​ WaylandPointer<zxdg_shell_v6, zxdg_shell_v6_destroy> xdgshellv6;
59​ static const struct zxdg_shell_v6_listener s_shellListener;
60​};
61​
62​const struct zxdg_shell_v6_listener XdgShellUnstableV6::Private::s_shellListener = {
63​ pingCallback,
64​};
65​
66​void XdgShellUnstableV6::Private::pingCallback(void *data, struct zxdg_shell_v6 *shell, uint32_t serial)
67​{
68​ Q_UNUSED(data)
69​ zxdg_shell_v6_pong(shell, serial);
70​}
71​
72​void XdgShellUnstableV6::Private::setupV6(zxdg_shell_v6 *shell)
73​{
74​ Q_ASSERT(shell);
75​ Q_ASSERT(!xdgshellv6);
76​ xdgshellv6.setup(shell);
77​ zxdg_shell_v6_add_listener(shell, &s_shellListener, this);
78​}
79​
80​void XdgShellUnstableV6::Private::release()
81​{
82​ xdgshellv6.release();
83​}
84​
85​void XdgShellUnstableV6::Private::destroy()
86​{
87​ xdgshellv6.destroy();
88​}
89​
90​bool XdgShellUnstableV6::Private::isValid() const
91​{
92​ return xdgshellv6.isValid();
93​}
94​
95​XdgShellSurface *XdgShellUnstableV6::Private::getXdgSurface(Surface *surface, QObject *parent)
96​{
97​ Q_ASSERT(isValid());
98​ auto ss = zxdg_shell_v6_get_xdg_surface(xdgshellv6, *surface);
99​
100​ if (!ss) {
101​ return nullptr;
102​ }
103​
104​ auto s = new XdgTopLevelUnstableV6(parent);
105​ auto toplevel = zxdg_surface_v6_get_toplevel(ss);
106​ if (queue) {
107​ queue->addProxy(ss);
108​ queue->addProxy(toplevel);
109​ }
110​ s->setup(ss, toplevel);
111​ return s;
112​}
113​
114​XdgShellPopup *XdgShellUnstableV6::Private::getXdgPopup(Surface *surface, XdgShellSurface *parentSurface, const XdgPositioner &positioner, QObject *parent)
115​{
116​ return internalGetXdgPopup(surface, *parentSurface, positioner, parent);
117​}
118​
119​XdgShellPopup *XdgShellUnstableV6::Private::getXdgPopup(Surface *surface, XdgShellPopup *parentSurface, const XdgPositioner &positioner, QObject *parent)
120​{
121​ return internalGetXdgPopup(surface, *parentSurface, positioner, parent);
122​}
123​
124​XdgShellPopup *XdgShellUnstableV6::Private::internalGetXdgPopup(Surface *surface, zxdg_surface_v6 *parentSurface, const XdgPositioner &positioner, QObject *parent)
125​{
126​ Q_ASSERT(isValid());
127​ auto ss = zxdg_shell_v6_get_xdg_surface(xdgshellv6, *surface);
128​ if (!ss) {
129​ return nullptr;
130​ }
131​
132​ auto p = zxdg_shell_v6_create_positioner(xdgshellv6);
133​
134​ auto anchorRect = positioner.anchorRect();
135​ zxdg_positioner_v6_set_anchor_rect(p, anchorRect.x(), anchorRect.y(), anchorRect.width(), anchorRect.height());
136​
137​ QSize initialSize = positioner.initialSize();
138​ zxdg_positioner_v6_set_size(p, initialSize.width(), initialSize.height());
139​
140​ QPoint anchorOffset = positioner.anchorOffset();
141​ if (!anchorOffset.isNull()) {
142​ zxdg_positioner_v6_set_offset(p, anchorOffset.x(), anchorOffset.y());
143​ }
144​
145​ uint32_t anchor = 0;
146​ if (positioner.anchorEdge().testFlag(Qt::LeftEdge)) {
147​ anchor |= ZXDG_POSITIONER_V6_ANCHOR_LEFT;
148​ }
149​ if (positioner.anchorEdge().testFlag(Qt::TopEdge)) {
150​ anchor |= ZXDG_POSITIONER_V6_ANCHOR_TOP;
151​ }
152​ if (positioner.anchorEdge().testFlag(Qt::RightEdge)) {
153​ anchor |= ZXDG_POSITIONER_V6_ANCHOR_RIGHT;
154​ }
155​ if (positioner.anchorEdge().testFlag(Qt::BottomEdge)) {
156​ anchor |= ZXDG_POSITIONER_V6_ANCHOR_BOTTOM;
157​ }
158​ if (anchor != 0) {
159​ zxdg_positioner_v6_set_anchor(p, anchor);
160​ }
161​
162​ uint32_t gravity = 0;
163​ if (positioner.anchorEdge().testFlag(Qt::LeftEdge)) {
164​ gravity |= ZXDG_POSITIONER_V6_GRAVITY_LEFT;
165​ }
166​ if (positioner.anchorEdge().testFlag(Qt::TopEdge)) {
167​ gravity |= ZXDG_POSITIONER_V6_GRAVITY_TOP;
168​ }
169​ if (positioner.anchorEdge().testFlag(Qt::RightEdge)) {
170​ gravity |= ZXDG_POSITIONER_V6_GRAVITY_RIGHT;
171​ }
172​ if (positioner.anchorEdge().testFlag(Qt::BottomEdge)) {
173​ gravity |= ZXDG_POSITIONER_V6_GRAVITY_BOTTOM;
174​ }
175​ zxdg_positioner_v6_set_anchor(p, anchor);
176​ if (gravity != 0) {
177​ zxdg_positioner_v6_set_gravity(p, gravity);
178​ }
179​
180​ uint32_t constraint = 0;
181​ if (positioner.constraints().testFlag(XdgPositioner::Constraint::SlideX)) {
182​ constraint |= ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_SLIDE_X;
183​ }
184​ if (positioner.constraints().testFlag(XdgPositioner::Constraint::SlideY)) {
185​ constraint |= ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_SLIDE_Y;
186​ }
187​ if (positioner.constraints().testFlag(XdgPositioner::Constraint::FlipX)) {
188​ constraint |= ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_FLIP_X;
189​ }
190​ if (positioner.constraints().testFlag(XdgPositioner::Constraint::FlipY)) {
191​ constraint |= ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_FLIP_Y;
192​ }
193​ if (positioner.constraints().testFlag(XdgPositioner::Constraint::ResizeX)) {
194​ constraint |= ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_RESIZE_Y;
195​ }
196​ if (positioner.constraints().testFlag(XdgPositioner::Constraint::ResizeY)) {
197​ constraint |= ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_RESIZE_Y;
198​ }
199​ if (constraint != 0) {
200​ zxdg_positioner_v6_set_constraint_adjustment(p, constraint);
201​ }
202​
203​ XdgShellPopup *s = new XdgShellPopupUnstableV6(parent);
204​ auto popup = zxdg_surface_v6_get_popup(ss, parentSurface, p);
205​ if (queue) {
206​ //deliberately not adding the positioner because the positioner has no events sent to it
207​ queue->addProxy(ss);
208​ queue->addProxy(popup);
209​ }
210​ s->setup(ss, popup);
211​
212​ zxdg_positioner_v6_destroy(p);
213​
214​ return s;
215​}
216​
217​XdgShellUnstableV6::XdgShellUnstableV6(QObject *parent)
218​ : XdgShell(new Private, parent)
219​{
220​}
221​
222​XdgShellUnstableV6::~XdgShellUnstableV6() = default;
223​
224​
225​//A top level wraps both xdg_surface_v6 and xdg_top_level into the public API XdgShelllSurface
226​class XdgTopLevelUnstableV6::Private : public XdgShellSurface::Private
227​{
228​public:
229​ Private(XdgShellSurface *q);
230​ WaylandPointer<zxdg_toplevel_v6, zxdg_toplevel_v6_destroy> xdgtoplevelv6;
231​ WaylandPointer<zxdg_surface_v6, zxdg_surface_v6_destroy> xdgsurfacev6;
232​
233​ void setupV6(zxdg_surface_v6 *surface, zxdg_toplevel_v6 *toplevel) override;
234​ void release() override;
235​ void destroy() override;
236​ bool isValid() const override;
237​
238​ operator zxdg_surface_v6*() override {
239​ return xdgsurfacev6;
240​ }
241​ operator zxdg_surface_v6*() const override {
242​ return xdgsurfacev6;
243​ }
244​ operator zxdg_toplevel_v6*() override {
245​ return xdgtoplevelv6;
246​ }
247​ operator zxdg_toplevel_v6*() const override {
248​ return xdgtoplevelv6;
249​ }
250​
251​ void setTransientFor(XdgShellSurface *parent) override;
252​ void setTitle(const QString &title) override;
253​ void setAppId(const QByteArray &appId) override;
254​ void showWindowMenu(Seat *seat, quint32 serial, qint32 x, qint32 y) override;
255​ void move(Seat *seat, quint32 serial) override;
256​ void resize(Seat *seat, quint32 serial, Qt::Edges edges) override;
257​ void ackConfigure(quint32 serial) override;
258​ void setMaximized() override;
259​ void unsetMaximized() override;
260​ void setFullscreen(Output *output) override;
261​ void unsetFullscreen() override;
262​ void setMinimized() override;
263​ void setMaxSize(const QSize &size) override;
264​ void setMinSize(const QSize &size) override;
265​
266​private:
267​ QSize pendingSize;
268​ States pendingState;
269​
270​ static void configureCallback(void *data, struct zxdg_toplevel_v6 *xdg_toplevel, int32_t width, int32_t height, struct wl_array *state);
271​ static void closeCallback(void *data, zxdg_toplevel_v6 *xdg_toplevel);
272​ static void surfaceConfigureCallback(void *data, zxdg_surface_v6 *xdg_surface, uint32_t serial);
273​
274​ static const struct zxdg_toplevel_v6_listener s_toplevelListener;
275​ static const struct zxdg_surface_v6_listener s_surfaceListener;
276​};
277​
278​const struct zxdg_toplevel_v6_listener XdgTopLevelUnstableV6::Private::s_toplevelListener = {
279​ configureCallback,
280​ closeCallback
281​};
282​
283​const struct zxdg_surface_v6_listener XdgTopLevelUnstableV6::Private::s_surfaceListener = {
284​ surfaceConfigureCallback
285​};
286​
287​void XdgTopLevelUnstableV6::Private::surfaceConfigureCallback(void *data, struct zxdg_surface_v6 *surface, uint32_t serial)
288​{
289​ Q_UNUSED(surface)
290​ auto s = reinterpret_cast<Private*>(data);
291​ s->q->configureRequested(s->pendingSize, s->pendingState, serial);
292​ if (!s->pendingSize.isNull()) {
293​ s->q->setSize(s->pendingSize);
294​ s->pendingSize = QSize();
295​ }
296​ s->pendingState = 0;
297​}
298​
299​void XdgTopLevelUnstableV6::Private::configureCallback(void *data, struct zxdg_toplevel_v6 *xdg_toplevel, int32_t width, int32_t height, struct wl_array *state)
300​{
301​ Q_UNUSED(xdg_toplevel)
302​ auto s = reinterpret_cast<Private*>(data);
303​ States states;
304​
305​ uint32_t *statePtr = reinterpret_cast<uint32_t *>(state->data);
306​ for (size_t i = 0; i < state->size / sizeof(uint32_t); i++) {
307​ switch (statePtr[i]) {
308​ case ZXDG_TOPLEVEL_V6_STATE_MAXIMIZED:
309​ states = states | XdgShellSurface::State::Maximized;
310​ break;
311​ case ZXDG_TOPLEVEL_V6_STATE_FULLSCREEN:
312​ states = states | XdgShellSurface::State::Fullscreen;
313​ break;
314​ case ZXDG_TOPLEVEL_V6_STATE_RESIZING:
315​ states = states | XdgShellSurface::State::Resizing;
316​ break;
317​ case ZXDG_TOPLEVEL_V6_STATE_ACTIVATED:
318​ states = states | XdgShellSurface::State::Activated;
319​ break;
320​ }
321​ }
322​ s->pendingSize = QSize(width, height);
323​ s->pendingState = states;
324​}
325​
326​void XdgTopLevelUnstableV6::Private::closeCallback(void *data, zxdg_toplevel_v6 *xdg_toplevel)
327​{
328​ auto s = reinterpret_cast<XdgTopLevelUnstableV6::Private*>(data);
329​ Q_ASSERT(s->xdgtoplevelv6 == xdg_toplevel);
330​ emit s->q->closeRequested();
331​}
332​
333​XdgTopLevelUnstableV6::Private::Private(XdgShellSurface *q)
334​ : XdgShellSurface::Private(q)
335​{
336​}
337​
338​void XdgTopLevelUnstableV6::Private::setupV6(zxdg_surface_v6 *surface, zxdg_toplevel_v6 *topLevel)
339​{
340​ Q_ASSERT(surface);
341​ Q_ASSERT(!xdgtoplevelv6);
342​ xdgsurfacev6.setup(surface);
343​ xdgtoplevelv6.setup(topLevel);
344​ zxdg_surface_v6_add_listener(xdgsurfacev6, &s_surfaceListener, this);
345​ zxdg_toplevel_v6_add_listener(xdgtoplevelv6, &s_toplevelListener, this);
346​}
347​
348​void XdgTopLevelUnstableV6::Private::release()
349​{
350​ xdgtoplevelv6.release();
351​ xdgsurfacev6.release();
352​}
353​
354​void XdgTopLevelUnstableV6::Private::destroy()
355​{
356​ xdgtoplevelv6.destroy();
357​ xdgsurfacev6.destroy();
358​}
359​
360​bool XdgTopLevelUnstableV6::Private::isValid() const
361​{
362​ return xdgtoplevelv6.isValid() && xdgsurfacev6.isValid();
363​}
364​
365​void XdgTopLevelUnstableV6::Private::setTransientFor(XdgShellSurface *parent)
366​{
367​ zxdg_toplevel_v6 *parentSurface = nullptr;
368​ if (parent) {
369​ parentSurface = *parent;
370​ }
371​ zxdg_toplevel_v6_set_parent(xdgtoplevelv6, parentSurface);
372​}
373​
374​void XdgTopLevelUnstableV6::Private::setTitle(const QString & title)
375​{
376​ zxdg_toplevel_v6_set_title(xdgtoplevelv6, title.toUtf8().constData());
377​}
378​
379​void XdgTopLevelUnstableV6::Private::setAppId(const QByteArray & appId)
380​{
381​ zxdg_toplevel_v6_set_app_id(xdgtoplevelv6, appId.constData());
382​}
383​
384​void XdgTopLevelUnstableV6::Private::showWindowMenu(Seat *seat, quint32 serial, qint32 x, qint32 y)
385​{
386​ zxdg_toplevel_v6_show_window_menu(xdgtoplevelv6, *seat, serial, x, y);
387​}
388​
389​void XdgTopLevelUnstableV6::Private::move(Seat *seat, quint32 serial)
390​{
391​ zxdg_toplevel_v6_move(xdgtoplevelv6, *seat, serial);
392​}
393​
394​void XdgTopLevelUnstableV6::Private::resize(Seat *seat, quint32 serial, Qt::Edges edges)
395​{
396​ uint wlEdge = ZXDG_TOPLEVEL_V6_RESIZE_EDGE_NONE;
397​ if (edges.testFlag(Qt::TopEdge)) {
398​ if (edges.testFlag(Qt::LeftEdge) && ((edges & ~Qt::LeftEdge) == Qt::TopEdge)) {
399​ wlEdge = ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_LEFT;
400​ } else if (edges.testFlag(Qt::RightEdge) && ((edges & ~Qt::RightEdge) == Qt::TopEdge)) {
401​ wlEdge = ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_RIGHT;
402​ } else if ((edges & ~Qt::TopEdge) == Qt::Edges()) {
403​ wlEdge = ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP;
404​ }
405​ } else if (edges.testFlag(Qt::BottomEdge)) {
406​ if (edges.testFlag(Qt::LeftEdge) && ((edges & ~Qt::LeftEdge) == Qt::BottomEdge)) {
407​ wlEdge = ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_LEFT;
408​ } else if (edges.testFlag(Qt::RightEdge) && ((edges & ~Qt::RightEdge) == Qt::BottomEdge)) {
409​ wlEdge = ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_RIGHT;
410​ } else if ((edges & ~Qt::BottomEdge) == Qt::Edges()) {
411​ wlEdge = ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM;
412​ }
413​ } else if (edges.testFlag(Qt::RightEdge) && ((edges & ~Qt::RightEdge) == Qt::Edges())) {
414​ wlEdge = ZXDG_TOPLEVEL_V6_RESIZE_EDGE_RIGHT;
415​ } else if (edges.testFlag(Qt::LeftEdge) && ((edges & ~Qt::LeftEdge) == Qt::Edges())) {
416​ wlEdge = ZXDG_TOPLEVEL_V6_RESIZE_EDGE_LEFT;
417​ }
418​ zxdg_toplevel_v6_resize(xdgtoplevelv6, *seat, serial, wlEdge);
419​}
420​
421​void XdgTopLevelUnstableV6::Private::ackConfigure(quint32 serial)
422​{
423​ zxdg_surface_v6_ack_configure(xdgsurfacev6, serial);
424​}
425​
426​void XdgTopLevelUnstableV6::Private::setMaximized()
427​{
428​ zxdg_toplevel_v6_set_maximized(xdgtoplevelv6);
429​}
430​
431​void XdgTopLevelUnstableV6::Private::unsetMaximized()
432​{
433​ zxdg_toplevel_v6_unset_maximized(xdgtoplevelv6);
434​}
435​
436​void XdgTopLevelUnstableV6::Private::setFullscreen(Output *output)
437​{
438​ wl_output *o = nullptr;
439​ if (output) {
440​ o = *output;
441​ }
442​ zxdg_toplevel_v6_set_fullscreen(xdgtoplevelv6, o);
443​}
444​
445​void XdgTopLevelUnstableV6::Private::unsetFullscreen()
446​{
447​ zxdg_toplevel_v6_unset_fullscreen(xdgtoplevelv6);
448​}
449​
450​void XdgTopLevelUnstableV6::Private::setMinimized()
451​{
452​ zxdg_toplevel_v6_set_minimized(xdgtoplevelv6);
453​}
454​
455​void XdgTopLevelUnstableV6::Private::setMaxSize(const QSize &size)
456​{
457​ zxdg_toplevel_v6_set_max_size(xdgtoplevelv6, size.width(), size.height());
458​}
459​
460​void XdgTopLevelUnstableV6::Private::setMinSize(const QSize &size)
461​{
462​ zxdg_toplevel_v6_set_min_size(xdgtoplevelv6, size.width(), size.height());
463​}
464​
465​XdgTopLevelUnstableV6::XdgTopLevelUnstableV6(QObject *parent)
466​ : XdgShellSurface(new Private(this), parent)
467​{
468​}
469​
470​XdgTopLevelUnstableV6::~XdgTopLevelUnstableV6() = default;
471​
472​class XdgShellPopupUnstableV6::Private : public XdgShellPopup::Private
473​{
474​public:
475​ Private(XdgShellPopup *q);
476​
477​ void setupV6(zxdg_surface_v6 *s, zxdg_popup_v6 *p) override;
478​ void release() override;
479​ void destroy() override;
480​ bool isValid() const override;
481​ void requestGrab(Seat *seat, quint32 serial) override;
482​ operator zxdg_surface_v6*() override {
483​ return xdgsurfacev6;
484​ }
485​ operator zxdg_surface_v6*() const override {
486​ return xdgsurfacev6;
487​ }
488​ operator zxdg_popup_v6*() override {
489​ return xdgpopupv6;
490​ }
491​ operator zxdg_popup_v6*() const override {
492​ return xdgpopupv6;
493​ }
494​ WaylandPointer<zxdg_surface_v6, zxdg_surface_v6_destroy> xdgsurfacev6;
495​ WaylandPointer<zxdg_popup_v6, zxdg_popup_v6_destroy> xdgpopupv6;
496​
497​ QRect pendingRect;
498​
499​private:
500​ static void configureCallback(void *data, zxdg_popup_v6 *xdg_popup, int32_t x, int32_t y, int32_t width, int32_t height);
501​ static void popupDoneCallback(void *data, zxdg_popup_v6 *xdg_popup);
502​ static void surfaceConfigureCallback(void *data, zxdg_surface_v6 *xdg_surface, uint32_t serial);
503​
504​ static const struct zxdg_popup_v6_listener s_popupListener;
505​ static const struct zxdg_surface_v6_listener s_surfaceListener;
506​};
507​
508​const struct zxdg_popup_v6_listener XdgShellPopupUnstableV6::Private::s_popupListener = {
509​ configureCallback,
510​ popupDoneCallback
511​};
512​
513​const struct zxdg_surface_v6_listener XdgShellPopupUnstableV6::Private::s_surfaceListener = {
514​ surfaceConfigureCallback,
515​};
516​
517​void XdgShellPopupUnstableV6::Private::configureCallback(void *data, zxdg_popup_v6 *xdg_popup, int32_t x, int32_t y, int32_t width, int32_t height)
518​{
519​ Q_UNUSED(xdg_popup);
520​ auto s = reinterpret_cast<Private*>(data);
521​ s->pendingRect = QRect(x, y, width, height);
522​}
523​
524​void XdgShellPopupUnstableV6::Private::surfaceConfigureCallback(void *data, struct zxdg_surface_v6 *surface, uint32_t serial)
525​{
526​ Q_UNUSED(surface);
527​ auto s = reinterpret_cast<Private*>(data);
528​ s->q->configureRequested(s->pendingRect, serial);
529​ s->pendingRect = QRect();
530​}
531​
532​void XdgShellPopupUnstableV6::Private::popupDoneCallback(void *data, zxdg_popup_v6 *xdg_popup)
533​{
534​ auto s = reinterpret_cast<XdgShellPopupUnstableV6::Private*>(data);
535​ Q_ASSERT(s->xdgpopupv6 == xdg_popup);
536​ emit s->q->popupDone();
537​}
538​
539​XdgShellPopupUnstableV6::Private::Private(XdgShellPopup *q)
540​ : XdgShellPopup::Private(q)
541​{
542​}
543​
544​void XdgShellPopupUnstableV6::Private::setupV6(zxdg_surface_v6 *s, zxdg_popup_v6 *p)
545​{
546​ Q_ASSERT(p);
547​ Q_ASSERT(!xdgsurfacev6);
548​ Q_ASSERT(!xdgpopupv6);
549​
550​ xdgsurfacev6.setup(s);
551​ xdgpopupv6.setup(p);
552​ zxdg_surface_v6_add_listener(xdgsurfacev6, &s_surfaceListener, this);
553​ zxdg_popup_v6_add_listener(xdgpopupv6, &s_popupListener, this);
554​}
555​
556​void XdgShellPopupUnstableV6::Private::release()
557​{
558​ xdgpopupv6.release();
559​}
560​
561​void XdgShellPopupUnstableV6::Private::destroy()
562​{
563​ xdgpopupv6.destroy();
564​}
565​
566​bool XdgShellPopupUnstableV6::Private::isValid() const
567​{
568​ return xdgpopupv6.isValid();
569​}
570​
571​void XdgShellPopupUnstableV6::Private::requestGrab(Seat *seat, quint32 serial)
572​{
573​ zxdg_popup_v6_grab(xdgpopupv6, *seat, serial);
574​}
575​
576​
577​XdgShellPopupUnstableV6::XdgShellPopupUnstableV6(QObject *parent)
578​ : XdgShellPopup(new Private(this), parent)
579​{
580​}
581​
582​XdgShellPopupUnstableV6::~XdgShellPopupUnstableV6() = default;
583​
584​}
585​}