Differential D13510 Diff 37872 src/server/xdgshell_stable_interface.cpp

Changeset View

Standalone View

View Options

src/server/xdgshell_stable_interface.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_stable_interface_p.h"
21​#include "xdgshell_interface_p.h"
22​#include "generic_shell_surface_p.h"
23​#include "display.h"
24​#include "global_p.h"
25​#include "global.h"
26​#include "resource_p.h"
27​#include "output_interface.h"
28​#include "seat_interface.h"
29​#include "surface_interface.h"
30​
31​#include <wayland-xdg-shell-server-protocol.h>
32​
33​namespace KWayland
34​{
35​namespace Server
36​{
37​
38​class XdgShellStableInterface::Private : public XdgShellInterface::Private
39​{
40​public:
41​ Private(XdgShellStableInterface *q, Display *d);
42​
43​ QVector<XdgSurfaceStableInterface*> surfaces;
44​ QVector<XdgPositionerStableInterface*> positioners;
45​
46​private:
47​
48​ void createSurface(wl_client *client, uint32_t version, uint32_t id, SurfaceInterface *surface, wl_resource *parentResource);
49​ void createPositioner(wl_client *client, uint32_t version, uint32_t id, wl_resource *parentResource);
50​
51​ void bind(wl_client *client, uint32_t version, uint32_t id) override;
52​
53​ quint32 ping(XdgShellSurfaceInterface * surface) override;
54​
55​ static void unbind(wl_resource *resource);
56​ static Private *cast(wl_resource *r) {
57​ return static_cast<Private*>(wl_resource_get_user_data(r));
58​ }
59​
60​ static void destroyCallback(wl_client *client, wl_resource *resource);
61​ static void createPositionerCallback(wl_client *client, wl_resource *resource, uint32_t id);
62​ static void getXdgSurfaceCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource * surface);
63​ static void pongCallback(wl_client *client, wl_resource *resource, uint32_t serial);
64​
65​ XdgShellStableInterface *q;
66​ static const struct xdg_wm_base_interface s_interface;
67​ static const quint32 s_version;
68​ QHash<wl_client *, wl_resource*> resources;
69​};
70​
71​class XdgPopupStableInterface::Private : public XdgShellPopupInterface::Private
72​{
73​public:
74​ Private(XdgPopupStableInterface *q, XdgShellStableInterface *c, SurfaceInterface *surface, wl_resource *parentResource);
75​ ~Private() override;
76​
zzagUnsubmitted
Done

I would also add override, e.g.

~Private() override;
zzag: I would also add override, e.g. ```lang=cpp ~Private() override; ```
77​ void ackConfigure(quint32 serial) {
78​ if (!configureSerials.contains(serial)) {
79​ return;
80​ }
romanggUnsubmitted
Done

not according to specs

romangg: not according to specs
81​ while (!configureSerials.isEmpty()) {
82​ quint32 i = configureSerials.takeFirst();
83​ emit q_func()->configureAcknowledged(i);
84​ if (i == serial) {
85​ break;
86​ }
87​ }
88​ }
89​
90​ void popupDone() override;
91​ quint32 configure(const QRect &rect) override;
92​
93​ XdgPopupStableInterface *q_func() {
94​ return static_cast<XdgPopupStableInterface *>(q);
95​ }
96​private:
97​ static void grabCallback(wl_client *client, wl_resource *resource, wl_resource *seat, uint32_t serial);
98​
99​ static const struct xdg_popup_interface s_interface;
100​};
101​
102​class XdgSurfaceStableInterface::Private : public KWayland::Server::Resource::Private
103​{
104​public:
105​ Private(XdgSurfaceStableInterface* q, XdgShellStableInterface* c, SurfaceInterface* surface, wl_resource* parentResource);
106​
107​ ~Private() override;
108​
109​ XdgSurfaceStableInterface *q_func() {
110​ return static_cast<XdgSurfaceStableInterface *>(q);
111​ }
112​
113​ void createTopLevel(wl_client *client, uint32_t version, uint32_t id, wl_resource *parentResource);
114​ void createPopup(wl_client *client, uint32_t version, uint32_t id, wl_resource *parentResource, wl_resource *parentWindow, wl_resource *positioner);
115​ XdgShellStableInterface *m_shell;
116​ SurfaceInterface *m_surface;
117​
118​ //effectively a union, only one of these should be populated.
119​ //a surface cannot have two roles
120​ QPointer<XdgTopLevelStableInterface> m_topLevel;
121​ QPointer<XdgPopupStableInterface> m_popup;
122​
123​private:
124​ static void destroyCallback(wl_client *client, wl_resource *resource);
125​ static void getTopLevelCallback(wl_client *client, wl_resource *resource, uint32_t id);
126​ static void getPopupCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource *parent, wl_resource *positioner);
127​ static void ackConfigureCallback(wl_client *client, wl_resource *resource, uint32_t serial);
128​ static void setWindowGeometryCallback(wl_client *client, wl_resource *resource, int32_t x, int32_t y, int32_t width, int32_t height);
129​ static const struct xdg_surface_interface s_interface;
130​};
131​
132​class XdgTopLevelStableInterface::Private : public XdgShellSurfaceInterface::Private
133​{
134​public:
135​ Private(XdgTopLevelStableInterface* q, XdgShellStableInterface* c, SurfaceInterface* surface, wl_resource* parentResource);
136​ ~Private() override;
137​
138​ void close() override;
139​
140​ void ackConfigure(quint32 serial) {
141​ if (!configureSerials.contains(serial)) {
142​ return;
143​ }
144​ while (!configureSerials.isEmpty()) {
145​ quint32 i = configureSerials.takeFirst();
146​ emit q_func()->configureAcknowledged(i);
147​ if (i == serial) {
148​ break;
149​ }
150​ }
151​ }
152​
153​ quint32 configure(States states, const QSize &size) override {
154​ if (!resource) {
155​ return 0;
156​ }
157​ const quint32 serial = global->display()->nextSerial();
158​ wl_array configureStates;
159​ wl_array_init(&configureStates);
160​ if (states.testFlag(State::Maximized)) {
161​ uint32_t *s = static_cast<uint32_t*>(wl_array_add(&configureStates, sizeof(uint32_t)));
romanggUnsubmitted
Not Done

Could you pls name this better: for example wlStates

romangg: Could you pls name this better: for example wlStates
162​ *s = XDG_TOPLEVEL_STATE_MAXIMIZED;
163​ }
164​ if (states.testFlag(State::Fullscreen)) {
165​ uint32_t *s = static_cast<uint32_t*>(wl_array_add(&configureStates, sizeof(uint32_t)));
166​ *s = XDG_TOPLEVEL_STATE_FULLSCREEN;
167​ }
168​ if (states.testFlag(State::Resizing)) {
169​ uint32_t *s = static_cast<uint32_t*>(wl_array_add(&configureStates, sizeof(uint32_t)));
170​ *s = XDG_TOPLEVEL_STATE_RESIZING;
171​ }
172​ if (states.testFlag(State::Activated)) {
173​ uint32_t *s = static_cast<uint32_t*>(wl_array_add(&configureStates, sizeof(uint32_t)));
174​ *s = XDG_TOPLEVEL_STATE_ACTIVATED;
175​ }
176​ configureSerials << serial;
177​ xdg_toplevel_send_configure(resource, size.width(), size.height(), &configureStates);
178​
179​ xdg_surface_send_configure(parentResource, serial);
180​
181​ client->flush();
182​ wl_array_release(&configureStates);
183​ return serial;
184​ };
185​
186​ XdgTopLevelStableInterface *q_func() {
187​ return static_cast<XdgTopLevelStableInterface*>(q);
188​ }
189​
190​private:
191​ static void destroyCallback(wl_client *client, wl_resource *resource);
192​ static void setParentCallback(struct wl_client *client, struct wl_resource *resource, wl_resource *parent);
193​ static void showWindowMenuCallback(wl_client *client, wl_resource *resource, wl_resource *seat, uint32_t serial, int32_t x, int32_t y);
194​ static void setMaxSizeCallback(wl_client *client, wl_resource *resource, int32_t width, int32_t height);
195​ static void setMinSizeCallback(wl_client *client, wl_resource *resource, int32_t width, int32_t height);
196​ static void setMaximizedCallback(wl_client *client, wl_resource *resource);
197​ static void unsetMaximizedCallback(wl_client *client, wl_resource *resource);
198​ static void setFullscreenCallback(wl_client *client, wl_resource *resource, wl_resource *output);
199​ static void unsetFullscreenCallback(wl_client *client, wl_resource *resource);
200​ static void setMinimizedCallback(wl_client *client, wl_resource *resource);
201​
202​ static const struct xdg_toplevel_interface s_interface;
203​};
204​
205​
206​const quint32 XdgShellStableInterface::Private::s_version = 1;
207​
208​#ifndef DOXYGEN_SHOULD_SKIP_THIS
209​const struct xdg_wm_base_interface XdgShellStableInterface::Private::s_interface = {
210​ destroyCallback,
211​ createPositionerCallback,
212​ getXdgSurfaceCallback,
213​ pongCallback
214​};
215​#endif
216​
217​void XdgShellStableInterface::Private::destroyCallback(wl_client *client, wl_resource *resource)
218​{
219​ Q_UNUSED(client)
220​ auto s = cast(resource);
221​ if (!s->surfaces.isEmpty()) {
222​ wl_resource_post_error(resource, XDG_WM_BASE_ERROR_DEFUNCT_SURFACES, "WMBase destroyed before surfaces");
223​ }
romanggUnsubmitted
Not Done

Do it?

romangg: Do it?
224​
225​ wl_resource_destroy(resource);
226​}
227​
228​void XdgShellStableInterface::Private::createPositionerCallback(wl_client *client, wl_resource *resource, uint32_t id)
229​{
230​ auto s = cast(resource);
231​ s->createPositioner(client, wl_resource_get_version(resource), id, resource);
232​}
233​
234​void XdgShellStableInterface::Private::getXdgSurfaceCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource * surface)
235​{
236​ auto s = cast(resource);
237​ s->createSurface(client, wl_resource_get_version(resource), id, SurfaceInterface::get(surface), resource);
238​}
239​
240​void XdgShellStableInterface::Private::createSurface(wl_client *client, uint32_t version, uint32_t id, SurfaceInterface *surface, wl_resource *parentResource)
241​{
242​ auto it = std::find_if(surfaces.constBegin(), surfaces.constEnd(),
243​ [surface](XdgSurfaceStableInterface *s) {
244​ return surface == s->surface();
zzagUnsubmitted
Done

Which one should return?

zzag: Which one should return?
davidedmundsonAuthorUnsubmitted
Not Done

oops, thanks

davidedmundson: oops, thanks
245​ }
246​ );
247​ if (it != surfaces.constEnd()) {
romanggUnsubmitted
Not Done

Wrong id XDG_WM_BASE_ERROR_ROLE.

romangg: Wrong id `XDG_WM_BASE_ERROR_ROLE`.
davidedmundsonAuthorUnsubmitted
Not Done

What role do you think it should be?

I'm using the error for when a wl_surface has another role in the case that you call get_xdg_surface twice on the same wl_surface, which seems close enough.

davidedmundson: What role do you think it should be? I'm using the error for when a wl_surface has another…
romanggUnsubmitted
Not Done

XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED

romangg: `XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED`
248​ wl_resource_post_error(surface->resource(), XDG_WM_BASE_ERROR_ROLE, "XDG Surface already created");
249​ return;
250​ }
251​ XdgSurfaceStableInterface *shellSurface = new XdgSurfaceStableInterface(q, surface, parentResource);
252​ surfaces << shellSurface;
253​ QObject::connect(shellSurface, &XdgSurfaceStableInterface::destroyed, q,
254​ [this, shellSurface] {
255​ surfaces.removeAll(shellSurface);
256​ }
257​ );
258​
259​ shellSurface->d->create(display->getConnection(client), version, id);
260​}
261​
262​void XdgShellStableInterface::Private::createPositioner(wl_client *client, uint32_t version, uint32_t id, wl_resource *parentResource)
263​{
264​ Q_UNUSED(client)
265​
266​ XdgPositionerStableInterface *positioner = new XdgPositionerStableInterface(q, parentResource);
267​ positioners << positioner;
268​ QObject::connect(positioner, &Resource::destroyed, q,
269​ [this, positioner] {
270​ positioners.removeAll(positioner);
271​ }
272​ );
273​ positioner->d->create(display->getConnection(client), version, id);
274​}
275​
276​void XdgShellStableInterface::Private::pongCallback(wl_client *client, wl_resource *resource, uint32_t serial)
277​{
278​ Q_UNUSED(client)
279​ auto s = cast(resource);
280​ auto timerIt = s->pingTimers.find(serial);
281​ if (timerIt != s->pingTimers.end() && timerIt.value()->isActive()) {
282​ delete timerIt.value();
283​ s->pingTimers.erase(timerIt);
284​ emit s->q->pongReceived(serial);
285​ }
286​}
287​
288​XdgShellStableInterface::Private::Private(XdgShellStableInterface *q, Display *d)
289​ : XdgShellInterface::Private(XdgShellInterfaceVersion::Stable, q, d, &xdg_wm_base_interface, 1)
290​ , q(q)
291​{
292​}
293​
294​void XdgShellStableInterface::Private::bind(wl_client *client, uint32_t version, uint32_t id)
295​{
296​ auto c = display->getConnection(client);
297​ auto resource = c->createResource(&xdg_wm_base_interface, qMin(version, s_version), id);
298​ if (!resource) {
299​ wl_client_post_no_memory(client);
300​ return;
301​ }
302​ resources[client] = resource;
303​ wl_resource_set_implementation(resource, &s_interface, this, unbind);
304​}
305​
306​void XdgShellStableInterface::Private::unbind(wl_resource *resource)
307​{
308​ auto s = cast(resource);
309​ auto client = wl_resource_get_client(resource);
310​ s->resources.remove(client);
311​}
312​
313​XdgTopLevelStableInterface *XdgShellStableInterface::getSurface(wl_resource *resource)
314​{
315​ if (!resource) {
316​ return nullptr;
317​ }
318​ Q_D();
319​
320​ for (auto it = d->surfaces.constBegin(); it != d->surfaces.constEnd() ; it++) {
321​ auto topLevel = (*it)->topLevel();
322​ if (topLevel && topLevel->resource() == resource) {
323​ return topLevel;
324​ }
325​ }
326​ return nullptr;
327​}
328​
329​XdgSurfaceStableInterface *XdgShellStableInterface::realGetSurface(wl_resource *resource)
330​{
331​ if (!resource) {
332​ return nullptr;
333​ }
334​ Q_D();
335​
336​ for (auto it = d->surfaces.constBegin(); it != d->surfaces.constEnd() ; it++) {
337​ if ((*it)->resource() == resource) {
338​ return (*it);
339​ }
340​ }
341​ return nullptr;
342​}
343​
344​XdgPositionerStableInterface *XdgShellStableInterface::getPositioner(wl_resource *resource)
345​{
346​ if (!resource) {
347​ return nullptr;
348​ }
349​ Q_D();
350​ for (auto it = d->positioners.constBegin(); it != d->positioners.constEnd() ; it++) {
351​ if ((*it)->resource() == resource) {
352​ return *it;
353​ }
354​ }
355​ return nullptr;
356​}
357​
358​quint32 XdgShellStableInterface::Private::ping(XdgShellSurfaceInterface *surface)
359​{
360​ auto client = surface->client()->client();
361​ //from here we can get the resource bound to our global.
362​
363​ auto clientXdgShellResource = resources.value(client);
364​ if (!clientXdgShellResource) {
365​ return 0;
366​ }
367​
368​ const quint32 pingSerial = display->nextSerial();
369​ xdg_wm_base_send_ping(clientXdgShellResource, pingSerial);
370​
371​ setupTimer(pingSerial);
372​ return pingSerial;
373​}
374​
375​XdgShellStableInterface::Private *XdgShellStableInterface::d_func() const
376​{
377​ return static_cast<Private*>(d.data());
378​}
379​
380​namespace {
381​template <>
382​Qt::Edges edgesToQtEdges(xdg_toplevel_resize_edge edges)
383​{
384​ Qt::Edges qtEdges;
385​ switch (edges) {
386​ case XDG_TOPLEVEL_RESIZE_EDGE_TOP:
387​ qtEdges = Qt::TopEdge;
388​ break;
389​ case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM:
390​ qtEdges = Qt::BottomEdge;
391​ break;
392​ case XDG_TOPLEVEL_RESIZE_EDGE_LEFT:
393​ qtEdges = Qt::LeftEdge;
394​ break;
395​ case XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT:
396​ qtEdges = Qt::TopEdge | Qt::LeftEdge;
397​ break;
398​ case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT:
399​ qtEdges = Qt::BottomEdge | Qt::LeftEdge;
400​ break;
401​ case XDG_TOPLEVEL_RESIZE_EDGE_RIGHT:
402​ qtEdges = Qt::RightEdge;
403​ break;
404​ case XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT:
405​ qtEdges = Qt::TopEdge | Qt::RightEdge;
406​ break;
407​ case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT:
408​ qtEdges = Qt::BottomEdge | Qt::RightEdge;
409​ break;
410​ case XDG_TOPLEVEL_RESIZE_EDGE_NONE:
411​ break;
412​ default:
413​ Q_UNREACHABLE();
414​ break;
415​ }
416​ return qtEdges;
417​}
418​}
419​
420​#ifndef DOXYGEN_SHOULD_SKIP_THIS
421​const struct xdg_surface_interface XdgSurfaceStableInterface::Private::s_interface = {
422​ destroyCallback,
423​ getTopLevelCallback,
424​ getPopupCallback,
425​ setWindowGeometryCallback,
426​ ackConfigureCallback
427​};
428​#endif
429​
430​void XdgSurfaceStableInterface::Private::destroyCallback(wl_client *client, wl_resource *resource)
431​{
432​ Q_UNUSED(client)
433​ wl_resource_destroy(resource);
434​}
435​
436​void XdgSurfaceStableInterface::Private::getTopLevelCallback(wl_client *client, wl_resource *resource, uint32_t id)
437​{
438​ auto s = cast<XdgSurfaceStableInterface::Private>(resource);
439​ s->createTopLevel(client, wl_resource_get_version(resource), id, resource);
440​}
441​
442​void XdgSurfaceStableInterface::Private::createTopLevel(wl_client *client, uint32_t version, uint32_t id, wl_resource *parentResource)
443​{
444​ if (m_topLevel) {
445​ wl_resource_post_error(parentResource, XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED, "Toplevel already created on this surface");
446​ return;
447​ }
448​ if (m_popup) {
449​ wl_resource_post_error(parentResource, XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED, "Popup already created on this surface");
450​ return;
451​ }
452​ m_topLevel = new XdgTopLevelStableInterface (m_shell, m_surface, parentResource);
453​ m_topLevel->d->create(m_shell->display()->getConnection(client), version, id);
454​
455​ emit m_shell->surfaceCreated(m_topLevel);
456​}
457​
458​
459​void XdgSurfaceStableInterface::Private::getPopupCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource *parent, wl_resource *positioner)
460​{
461​ auto s = cast<XdgSurfaceStableInterface::Private>(resource);
462​ s->createPopup(client, wl_resource_get_version(resource), id, resource, parent, positioner);
463​}
464​
465​void XdgSurfaceStableInterface::Private::createPopup(wl_client *client, uint32_t version, uint32_t id, wl_resource *parentResource, wl_resource *parentSurface, wl_resource *positioner)
466​{
467​
468​ if (m_topLevel) {
469​ wl_resource_post_error(parentResource, XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED, "Toplevel already created on this surface");
470​ return;
471​ }
472​ if (m_popup) {
473​ wl_resource_post_error(parentResource, XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED, "Popup already created on this surface");
474​ return;
475​ }
476​
477​ auto xdgPositioner = m_shell->getPositioner(positioner);
478​ if (!xdgPositioner) {
479​ wl_resource_post_error(parentResource, XDG_WM_BASE_ERROR_INVALID_POSITIONER, "Invalid positioner");
480​ return;
481​ }
482​ m_popup = new XdgPopupStableInterface(m_shell, m_surface, parentResource);
483​ auto pd = m_popup->d_func();
484​
485​ pd->create(m_shell->display()->getConnection(client), version, id);
486​
487​ auto parentXdgSurface = m_shell->realGetSurface(parentSurface);
488​ if (!parentXdgSurface) {
489​ wl_resource_post_error(parentResource, XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT, "Invalid popup parent");
490​ return;
491​ }
492​ pd->parent = parentXdgSurface->surface();
493​ pd->initialSize = xdgPositioner->initialSize();
494​ pd->anchorRect = xdgPositioner->anchorRect();
zzagUnsubmitted
Done

Can be simplified, e.g.

if (!parentXdgSurface) {
    wl_resource_post_error(parentResource, XDG_WM_BASE_ERROR_INVALID_POPUP_PARENT, "Invalid popup parent");
    return;
}

pd->parent = parentXdgSurface->surface();
pd->....
zzag: Can be simplified, e.g. ```lang=cpp if (!parentXdgSurface) { wl_resource_post_error…
495​ pd->anchorEdge = xdgPositioner->anchorEdge();
496​ pd->gravity = xdgPositioner->gravity();
497​ pd->constraintAdjustments = xdgPositioner->constraintAdjustments();
498​ pd->anchorOffset = xdgPositioner->anchorOffset();
499​
500​ emit m_shell->xdgPopupCreated(m_popup.data());
501​}
502​
503​
504​void XdgSurfaceStableInterface::Private::ackConfigureCallback(wl_client *client, wl_resource *resource, uint32_t serial)
505​{
506​ auto s = cast<Private>(resource);
507​ Q_ASSERT(client == *s->client);
508​
509​ if (s->m_topLevel) {
510​ s->m_topLevel->d_func()->ackConfigure(serial);
511​ } else if (s->m_popup) {
512​ s->m_popup->d_func()->ackConfigure(serial);
513​ }
514​}
515​
516​void XdgSurfaceStableInterface::Private::setWindowGeometryCallback(wl_client *client, wl_resource *resource, int32_t x, int32_t y, int32_t width, int32_t height)
517​{
518​ // TODO: implement - not done for v5 either
519​ Q_UNUSED(client)
520​ Q_UNUSED(resource)
521​ Q_UNUSED(x)
522​ Q_UNUSED(y)
523​ Q_UNUSED(width)
524​ Q_UNUSED(height)
525​}
526​
527​XdgSurfaceStableInterface::Private::Private(XdgSurfaceStableInterface *q, XdgShellStableInterface *c, SurfaceInterface *surface, wl_resource *parentResource)
528​ : KWayland::Server::Resource::Private(q, c, parentResource, &xdg_surface_interface, &s_interface),
529​ m_shell(c),
530​ m_surface(surface)
531​{
532​}
533​
534​XdgSurfaceStableInterface::Private::~Private() = default;
535​
536​
537​class XdgPositionerStableInterface::Private : public KWayland::Server::Resource::Private
538​{
539​public:
540​ Private(XdgPositionerStableInterface *q, XdgShellStableInterface *c, wl_resource* parentResource);
541​
542​ QSize initialSize;
543​ QRect anchorRect;
544​ Qt::Edges anchorEdge;
545​ Qt::Edges gravity;
546​ PositionerConstraints constraintAdjustments;
547​ QPoint anchorOffset;
548​
549​private:
550​ static void setSizeCallback(wl_client *client, wl_resource *resource, int32_t width, int32_t height);
551​ static void setAnchorRectCallback(wl_client *client, wl_resource *resource, int32_t x, int32_t y, int32_t width, int32_t height);
552​ static void setAnchorCallback(wl_client *client, wl_resource *resource, uint32_t anchor);
553​ static void setGravityCallback(wl_client *client, wl_resource *resource, uint32_t gravity);
554​ static void setConstraintAdjustmentCallback(wl_client *client, wl_resource *resource, uint32_t constraint_adjustment);
555​ static void setOffsetCallback(wl_client *client, wl_resource *resource, int32_t x, int32_t y);
556​
557​ static const struct xdg_positioner_interface s_interface;
558​};
559​
560​XdgPositionerStableInterface::Private::Private(XdgPositionerStableInterface *q, XdgShellStableInterface *c, wl_resource *parentResource)
561​ : KWayland::Server::Resource::Private(q, c, parentResource, &xdg_positioner_interface, &s_interface)
562​{
563​}
564​
565​#ifndef DOXYGEN_SHOULD_SKIP_THIS
566​const struct xdg_positioner_interface XdgPositionerStableInterface::Private::s_interface = {
567​ resourceDestroyedCallback,
568​ setSizeCallback,
569​ setAnchorRectCallback,
570​ setAnchorCallback,
571​ setGravityCallback,
572​ setConstraintAdjustmentCallback,
573​ setOffsetCallback
574​};
575​#endif
576​
577​
578​void XdgPositionerStableInterface::Private::setSizeCallback(wl_client *client, wl_resource *resource, int32_t width, int32_t height) {
579​ Q_UNUSED(client)
580​ auto s = cast<Private>(resource);
581​ s->initialSize = QSize(width, height);
582​}
583​
584​void XdgPositionerStableInterface::Private::setAnchorRectCallback(wl_client *client, wl_resource *resource, int32_t x, int32_t y, int32_t width, int32_t height)
585​{
586​ Q_UNUSED(client)
587​ auto s = cast<Private>(resource);
588​ s->anchorRect = QRect(x, y, width, height);
589​}
590​
591​void XdgPositionerStableInterface::Private::setAnchorCallback(wl_client *client, wl_resource *resource, uint32_t anchor) {
592​ Q_UNUSED(client)
593​
594​ auto s = cast<Private>(resource);
595​
596​ Qt::Edges qtEdges;
597​ switch (anchor) {
598​ case XDG_POSITIONER_ANCHOR_TOP:
599​ qtEdges = Qt::TopEdge;
600​ break;
601​ case XDG_POSITIONER_ANCHOR_BOTTOM:
602​ qtEdges = Qt::BottomEdge;
603​ break;
604​ case XDG_POSITIONER_ANCHOR_LEFT:
605​ qtEdges = Qt::LeftEdge;
606​ break;
607​ case XDG_POSITIONER_ANCHOR_TOP_LEFT:
608​ qtEdges = Qt::TopEdge | Qt::LeftEdge;
609​ break;
610​ case XDG_POSITIONER_ANCHOR_BOTTOM_LEFT:
611​ qtEdges = Qt::BottomEdge | Qt::LeftEdge;
612​ break;
613​ case XDG_POSITIONER_ANCHOR_RIGHT:
614​ qtEdges = Qt::RightEdge;
615​ break;
616​ case XDG_POSITIONER_ANCHOR_TOP_RIGHT:
617​ qtEdges = Qt::TopEdge | Qt::RightEdge;
618​ break;
619​ case XDG_POSITIONER_ANCHOR_BOTTOM_RIGHT:
620​ qtEdges = Qt::BottomEdge | Qt::RightEdge;
621​ break;
622​ case XDG_POSITIONER_ANCHOR_NONE:
623​ break;
624​ default:
625​ Q_UNREACHABLE();
626​ break;
627​ }
628​
629​ s->anchorEdge = qtEdges;
630​}
631​
632​void XdgPositionerStableInterface::Private::setGravityCallback(wl_client *client, wl_resource *resource, uint32_t gravity) {
633​ Q_UNUSED(client)
634​ auto s = cast<Private>(resource);
635​
636​ Qt::Edges qtEdges;
637​ switch (gravity) {
638​ case XDG_POSITIONER_GRAVITY_TOP:
639​ qtEdges = Qt::TopEdge;
640​ break;
641​ case XDG_POSITIONER_GRAVITY_BOTTOM:
642​ qtEdges = Qt::BottomEdge;
643​ break;
644​ case XDG_POSITIONER_GRAVITY_LEFT:
645​ qtEdges = Qt::LeftEdge;
646​ break;
647​ case XDG_POSITIONER_GRAVITY_TOP_LEFT:
648​ qtEdges = Qt::TopEdge | Qt::LeftEdge;
649​ break;
650​ case XDG_POSITIONER_GRAVITY_BOTTOM_LEFT:
651​ qtEdges = Qt::BottomEdge | Qt::LeftEdge;
652​ break;
653​ case XDG_POSITIONER_GRAVITY_RIGHT:
654​ qtEdges = Qt::RightEdge;
655​ break;
656​ case XDG_POSITIONER_GRAVITY_TOP_RIGHT:
657​ qtEdges = Qt::TopEdge | Qt::RightEdge;
658​ break;
659​ case XDG_POSITIONER_GRAVITY_BOTTOM_RIGHT:
660​ qtEdges = Qt::BottomEdge | Qt::RightEdge;
661​ break;
662​ case XDG_POSITIONER_GRAVITY_NONE:
663​ break;
664​ default:
665​ Q_UNREACHABLE();
666​ break;
667​ }
668​
669​ s->gravity = qtEdges;
670​}
671​
672​void XdgPositionerStableInterface::Private::setConstraintAdjustmentCallback(wl_client *client, wl_resource *resource, uint32_t constraint_adjustment) {
673​ Q_UNUSED(client)
674​ auto s = cast<Private>(resource);
675​ PositionerConstraints constraints;
676​ if (constraint_adjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_X) {
677​ constraints |= PositionerConstraint::SlideX;
678​ }
679​ if (constraint_adjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_SLIDE_Y) {
680​ constraints |= PositionerConstraint::SlideY;
681​ }
682​ if (constraint_adjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_X) {
683​ constraints |= PositionerConstraint::FlipX;
684​ }
685​ if (constraint_adjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_FLIP_Y) {
686​ constraints |= PositionerConstraint::FlipY;
687​ }
688​ if (constraint_adjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_X) {
689​ constraints |= PositionerConstraint::ResizeX;
690​ }
691​ if (constraint_adjustment & XDG_POSITIONER_CONSTRAINT_ADJUSTMENT_RESIZE_Y) {
692​ constraints |= PositionerConstraint::ResizeY;
693​ }
694​ s->constraintAdjustments = constraints;
695​}
696​
697​void XdgPositionerStableInterface::Private::setOffsetCallback(wl_client *client, wl_resource *resource, int32_t x, int32_t y)
698​{
699​ Q_UNUSED(client)
700​ auto s = cast<Private>(resource);
701​ s->anchorOffset = QPoint(x,y);
702​}
703​
704​void XdgTopLevelStableInterface::Private::close()
705​{
706​ xdg_toplevel_send_close(resource);
707​ client->flush();
708​}
709​
710​void XdgTopLevelStableInterface::Private::setMaxSizeCallback(wl_client *client, wl_resource *resource, int32_t width, int32_t height)
711​{
712​ auto s = cast<Private>(resource);
713​ Q_ASSERT(client == *s->client);
714​ s->q_func()->maxSizeChanged(QSize(width, height));
715​}
716​
717​void XdgTopLevelStableInterface::Private::setMinSizeCallback(wl_client *client, wl_resource *resource, int32_t width, int32_t height)
718​{
719​ auto s = cast<Private>(resource);
720​ Q_ASSERT(client == *s->client);
721​ s->q_func()->minSizeChanged(QSize(width, height));
722​}
723​
724​const struct xdg_toplevel_interface XdgTopLevelStableInterface::Private::s_interface = {
725​ destroyCallback,
726​ setParentCallback,
727​ setTitleCallback,
728​ setAppIdCallback,
729​ showWindowMenuCallback,
730​ moveCallback,
731​ resizeCallback<xdg_toplevel_resize_edge>,
732​ setMaxSizeCallback,
733​ setMinSizeCallback,
734​ setMaximizedCallback,
735​ unsetMaximizedCallback,
736​ setFullscreenCallback,
737​ unsetFullscreenCallback,
738​ setMinimizedCallback
739​};
740​
741​void XdgTopLevelStableInterface::Private::destroyCallback(wl_client *client, wl_resource *resource)
742​{
743​ Q_UNUSED(client)
744​ wl_resource_destroy(resource);
745​}
746​
747​void XdgTopLevelStableInterface::Private::setParentCallback(wl_client *client, wl_resource *resource, wl_resource *parent)
748​{
749​ auto s = cast<Private>(resource);
750​ Q_ASSERT(client == *s->client);
751​ if (!parent) {
752​ //setting null is valid API. Clear
753​ s->parent = nullptr;
754​ emit s->q_func()->transientForChanged();
755​ } else {
756​ auto parentSurface = static_cast<XdgShellStableInterface*>(s->q->global())->getSurface(parent);
757​ if (s->parent.data() != parentSurface) {
758​ s->parent = QPointer<XdgTopLevelStableInterface>(parentSurface);
759​ emit s->q_func()->transientForChanged();
760​ }
761​ }
762​}
763​
764​void XdgTopLevelStableInterface::Private::showWindowMenuCallback(wl_client *client, wl_resource *resource, wl_resource *seat, uint32_t serial, int32_t x, int32_t y)
765​{
766​ auto s = cast<Private>(resource);
767​ Q_ASSERT(client == *s->client);
768​ emit s->q_func()->windowMenuRequested(SeatInterface::get(seat), serial, QPoint(x, y));
769​}
770​
771​XdgTopLevelStableInterface::Private::Private(XdgTopLevelStableInterface *q, XdgShellStableInterface *c, SurfaceInterface *surface, wl_resource *parentResource)
772​ : XdgShellSurfaceInterface::Private(XdgShellInterfaceVersion::Stable, q, c, surface, parentResource, &xdg_toplevel_interface, &s_interface)
773​{
774​}
775​
776​void XdgTopLevelStableInterface::Private::setMaximizedCallback(wl_client *client, wl_resource *resource)
777​{
778​ auto s = cast<Private>(resource);
779​ Q_ASSERT(client == *s->client);
780​ s->q_func()->maximizedChanged(true);
781​}
782​
783​void XdgTopLevelStableInterface::Private::unsetMaximizedCallback(wl_client *client, wl_resource *resource)
784​{
785​ auto s = cast<Private>(resource);
786​ Q_ASSERT(client == *s->client);
787​ s->q_func()->maximizedChanged(false);
788​}
789​
790​void XdgTopLevelStableInterface::Private::setFullscreenCallback(wl_client *client, wl_resource *resource, wl_resource *output)
791​{
792​ auto s = cast<Private>(resource);
793​ Q_ASSERT(client == *s->client);
794​ OutputInterface *o = nullptr;
795​ if (output) {
796​ o = OutputInterface::get(output);
797​ }
798​ s->q_func()->fullscreenChanged(true, o);
799​}
800​
801​void XdgTopLevelStableInterface::Private::unsetFullscreenCallback(wl_client *client, wl_resource *resource)
802​{
803​ auto s = cast<Private>(resource);
804​ Q_ASSERT(client == *s->client);
805​ s->q_func()->fullscreenChanged(false, nullptr);
806​}
807​
808​void XdgTopLevelStableInterface::Private::setMinimizedCallback(wl_client *client, wl_resource *resource)
809​{
810​ auto s = cast<Private>(resource);
811​ Q_ASSERT(client == *s->client);
812​ s->q_func()->minimizeRequested();
813​}
814​
815​XdgTopLevelStableInterface::Private::~Private() = default;
816​
817​#ifndef DOXYGEN_SHOULD_SKIP_THIS
818​const struct xdg_popup_interface XdgPopupStableInterface::Private::s_interface = {
819​ resourceDestroyedCallback,
820​ grabCallback
821​};
822​#endif
823​
824​XdgPopupStableInterface::Private::Private(XdgPopupStableInterface *q, XdgShellStableInterface *c, SurfaceInterface *surface, wl_resource *parentResource)
825​ : XdgShellPopupInterface::Private(XdgShellInterfaceVersion::Stable, q, c, surface, parentResource, &xdg_popup_interface, &s_interface)
826​{
827​}
828​
829​void XdgPopupStableInterface::Private::grabCallback(wl_client *client, wl_resource *resource, wl_resource *seat, uint32_t serial)
830​{
831​ Q_UNUSED(client)
832​ auto s = cast<Private>(resource);
833​ auto seatInterface = SeatInterface::get(seat);
834​ s->q_func()->grabRequested(seatInterface, serial);
835​}
836​
837​XdgPopupStableInterface::Private::~Private() = default;
838​
839​quint32 XdgPopupStableInterface::Private::configure(const QRect &rect)
840​{
841​ if (!resource) {
842​ return 0;
843​ }
844​ const quint32 serial = global->display()->nextSerial();
845​ configureSerials << serial;
846​ xdg_popup_send_configure(resource, rect.x(), rect.y(), rect.width(), rect.height());
847​ xdg_surface_send_configure(parentResource, serial);
848​ client->flush();
849​
850​ return serial;
851​}
852​
853​void XdgPopupStableInterface::Private::popupDone()
854​{
855​ if (!resource) {
856​ return;
857​ }
858​ // TODO: dismiss all child popups
859​ xdg_popup_send_popup_done(resource);
860​ client->flush();
861​}
862​
863​XdgShellStableInterface::XdgShellStableInterface(Display *display, QObject *parent)
864​ : XdgShellInterface(new Private(this, display), parent)
865​{
866​}
867​
868​Display* XdgShellStableInterface::display() const
869​{
870​ return d->display;
871​}
872​
873​XdgShellStableInterface::~XdgShellStableInterface() = default;
874​
875​XdgSurfaceStableInterface::XdgSurfaceStableInterface(XdgShellStableInterface *parent, SurfaceInterface *surface, wl_resource *parentResource)
876​ : KWayland::Server::Resource(new Private(this, parent, surface, parentResource))
877​{
878​}
879​
880​XdgSurfaceStableInterface::~XdgSurfaceStableInterface() = default;
881​
882​SurfaceInterface* XdgSurfaceStableInterface::surface() const
883​{
884​ Q_D();
885​ return d->m_surface;
886​}
887​
888​XdgPositionerStableInterface::XdgPositionerStableInterface(XdgShellStableInterface *parent, wl_resource *parentResource)
889​ : KWayland::Server::Resource(new Private(this, parent, parentResource))
890​{
891​}
892​
893​QSize XdgPositionerStableInterface::initialSize() const
894​{
895​ Q_D();
896​ return d->initialSize;
897​}
898​
899​QRect XdgPositionerStableInterface::anchorRect() const
900​{
901​ Q_D();
902​ return d->anchorRect;
903​}
904​
905​Qt::Edges XdgPositionerStableInterface::anchorEdge() const
906​{
907​ Q_D();
908​ return d->anchorEdge;
909​}
910​
911​Qt::Edges XdgPositionerStableInterface::gravity() const
912​{
913​ Q_D();
914​ return d->gravity;
915​}
916​
917​PositionerConstraints XdgPositionerStableInterface::constraintAdjustments() const
918​{
919​ Q_D();
920​ return d->constraintAdjustments;
921​}
922​
923​QPoint XdgPositionerStableInterface::anchorOffset() const
924​{
925​ Q_D();
926​ return d->anchorOffset;
927​}
928​
929​
930​XdgPositionerStableInterface::Private *XdgPositionerStableInterface::d_func() const
931​{
932​ return static_cast<Private*>(d.data());
933​}
934​
935​
936​XdgTopLevelStableInterface* XdgSurfaceStableInterface::topLevel() const
937​{
938​ Q_D();
939​ return d->m_topLevel.data();
940​}
941​
942​XdgPopupStableInterface* XdgSurfaceStableInterface::popup() const
943​{
944​ Q_D();
945​ return d->m_popup.data();
946​}
947​
948​XdgSurfaceStableInterface::Private *XdgSurfaceStableInterface::d_func() const
949​{
950​ return static_cast<Private*>(d.data());
951​}
952​
953​
954​XdgTopLevelStableInterface::XdgTopLevelStableInterface(XdgShellStableInterface *parent, SurfaceInterface *surface, wl_resource *parentResource)
955​ : KWayland::Server::XdgShellSurfaceInterface(new Private(this, parent, surface, parentResource))
956​{
957​}
958​
959​XdgTopLevelStableInterface::~XdgTopLevelStableInterface() = default;
960​
961​XdgTopLevelStableInterface::Private *XdgTopLevelStableInterface::d_func() const
962​{
963​ return static_cast<Private*>(d.data());
964​}
965​
966​XdgPopupStableInterface::XdgPopupStableInterface(XdgShellStableInterface *parent, SurfaceInterface *surface, wl_resource *parentResource)
967​ : XdgShellPopupInterface(new Private(this, parent, surface, parentResource))
968​{
969​}
970​
971​XdgPopupStableInterface::~XdgPopupStableInterface() = default;
972​
973​XdgPopupStableInterface::Private *XdgPopupStableInterface::d_func() const
974​{
975​ return static_cast<Private*>(d.data());
976​}
977​
978​}
979​}
980​