Differential D12235 Diff 34190 src/server/xdgoutput_interface.cpp

Changeset View

Standalone View

View Options

src/server/xdgoutput_interface.cpp

  • This file was added.
1​/****************************************************************************
2​Copyright 2018 David Edmundson <kde@davidedmundson.co.uk>
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 "xdgoutput_interface.h"
21​#include "display.h"
22​#include "global_p.h"
23​#include "resource_p.h"
24​#include "output_interface.h"
25​
26​#include <wayland-xdg-output-server-protocol.h>
27​
28​namespace KWayland
29​{
30​namespace Server
31​{
32​
33​class XdgOutputManagerInterface::Private : public Global::Private
34​{
35​public:
36​ Private(XdgOutputManagerInterface *q, Display *d);
37​ QHash<OutputInterface*, XdgOutputInterface*> outputs;
38​
39​private:
40​ void bind(wl_client *client, uint32_t version, uint32_t id) override;
41​
42​ static void unbind(wl_resource *resource);
43​ static Private *cast(wl_resource *r) {
44​ return reinterpret_cast<Private*>(wl_resource_get_user_data(r));
45​ }
46​
47​ static void destroyCallback(wl_client *client, wl_resource *resource);
48​ static void getXdgOutputCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource * output);
49​
50​ XdgOutputManagerInterface *q;
51​ static const struct zxdg_output_manager_v1_interface s_interface;
52​ static const quint32 s_version;
53​};
54​
55​const quint32 XdgOutputManagerInterface::Private::s_version = 1;
56​
57​#ifndef DOXYGEN_SHOULD_SKIP_THIS
58​const struct zxdg_output_manager_v1_interface XdgOutputManagerInterface::Private::s_interface = {
59​ destroyCallback,
60​ getXdgOutputCallback
61​};
62​#endif
63​
64​class XdgOutputV1Interface: public Resource
65​{
66​public:
67​ XdgOutputV1Interface(XdgOutputManagerInterface *parent, wl_resource *parentResource);
68​ ~XdgOutputV1Interface();
69​ void setLogicalSize(const QSize &size);
70​ void setLogicalPosition(const QPoint &pos);
71​ void done();
72​private:
73​ class Private;
74​};
75​
76​class XdgOutputInterface::Private
77​{
78​public:
79​ void resourceConnected(XdgOutputV1Interface *resource);
80​ void resourceDisconnected(XdgOutputV1Interface *resource);
81​ QPoint pos;
82​ QSize size;
83​ bool doneOnce = false;
84​ QList<XdgOutputV1Interface*> resources;
romanggUnsubmitted
Not Done

This variable is only relevant until the compositor has sent for the first time the done event via XdgOutputInterface::done(). Afterwards it is always true. Is it meant this way? If yes, could we use another name making this fact more explicit, like: doneOnce?

On the other side what if a compositor never sends the done event via XdgOutputInterface::done() because the xdg output never changes its logical size or position after the compositor publishes the xdg output to clients and it expects clients to receive the current values on connecting to the resource?

romangg: This variable is only relevant until the compositor has sent for the first time the done event…
romanggUnsubmitted
Not Done

The inline comment is in the wrong line. It is referring to the done member variable.

romangg: The inline comment is in the wrong line. It is referring to the `done` member variable.
davidedmundsonAuthorUnsubmitted
Not Done

If yes, could we use another name making this fact more explicit, like: doneOnce?

It is. I can make that change

On the other side what if a compositor never sends the done event via

It should be set on creation. If it's not the compositor is doing things wrong. I can update the docs to make it clear

davidedmundson: > If yes, could we use another name making this fact more explicit, like: doneOnce? It is. I…
85​};
86​
87​
88​XdgOutputManagerInterface::XdgOutputManagerInterface(Display *display, QObject *parent)
89​ : Global(new XdgOutputManagerInterface::Private(this, display))
90​{
91​}
92​
93​XdgOutputManagerInterface::~XdgOutputManagerInterface()
94​{}
95​
96​XdgOutputInterface* XdgOutputManagerInterface::createXdgOutput(OutputInterface *output, QObject *parent)
97​{
98​ Q_D();
99​ if (!d->outputs.contains(output)) {
100​ auto xdgOutput = new XdgOutputInterface(parent);
101​ d->outputs[output] = xdgOutput;
102​ //as XdgOutput lifespan is managed by user, delete our mapping when either
103​ //it or the relevant Output gets deleted
104​ connect(output, &QObject::destroyed, this, [this, output]() {
105​ Q_D();
106​ d->outputs.remove(output);
107​ });
108​ connect(xdgOutput, &QObject::destroyed, this, [this, output]() {
romanggUnsubmitted
Done

You do not want to connect the destroyed signal of this (i.e. the one of the XdgOuputManagerInterface) here but the one of the new XdgOutputInterface, right?

romangg: You do not want to connect the destroyed signal of `this` (i.e. the one of the…
109​ Q_D();
110​ d->outputs.remove(output);
111​ });
112​
113​ }
114​ return d->outputs[output];
115​}
116​
117​XdgOutputManagerInterface::Private* XdgOutputManagerInterface::d_func() const
118​{
119​ return reinterpret_cast<Private*>(d.data());
120​}
121​
122​void XdgOutputManagerInterface::Private::destroyCallback(wl_client *client, wl_resource *resource)
123​{
124​ Q_UNUSED(client)
125​ wl_resource_destroy(resource);
126​}
127​
128​void XdgOutputManagerInterface::Private::getXdgOutputCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource * outputResource)
129​{
130​ auto d = cast(resource);
131​ auto output = OutputInterface::get(outputResource);
132​ if (!output) { // output client is requesting XdgOutput for an Output that doesn't exist
romanggUnsubmitted
Done

Comment: client is requesting XdgOutput for output, that doesn't exist

romangg: Comment: `client is requesting XdgOutput for output, that doesn't exist`
133​ return;
134​ }
135​ if (!d->outputs.contains(output)) {
136​ return; //server hasn't created an XdgOutput for this output yet, give the client nothing
137​ }
138​ auto iface = new XdgOutputV1Interface(d->q, resource);
139​ iface->create(d->display->getConnection(client), wl_resource_get_version(resource), id);
140​ if (!iface->resource()) {
141​ wl_resource_post_no_memory(resource);
142​ delete iface;
143​ return;
144​ }
145​
146​ auto xdgOutput = d->outputs[output];
147​ xdgOutput->d->resourceConnected(iface);
148​ connect(iface, &XdgOutputV1Interface::unbound, xdgOutput, [xdgOutput, iface]() {
149​ xdgOutput->d->resourceDisconnected(iface);
150​ });
151​}
152​
153​XdgOutputManagerInterface::Private::Private(XdgOutputManagerInterface *q, Display *d)
154​ : Global::Private(d, &zxdg_output_manager_v1_interface, s_version)
155​ , q(q)
156​{
157​}
158​
159​void XdgOutputManagerInterface::Private::bind(wl_client *client, uint32_t version, uint32_t id)
160​{
161​ auto c = display->getConnection(client);
162​ wl_resource *resource = c->createResource(&zxdg_output_manager_v1_interface, qMin(version, s_version), id);
163​ if (!resource) {
164​ wl_client_post_no_memory(client);
165​ return;
166​ }
167​ wl_resource_set_implementation(resource, &s_interface, this, unbind);
168​}
169​
170​void XdgOutputManagerInterface::Private::unbind(wl_resource *resource)
171​{
172​ Q_UNUSED(resource)
173​}
174​
175​XdgOutputInterface::XdgOutputInterface(QObject *parent):
176​ QObject(parent),
177​ d(new XdgOutputInterface::Private)
178​{
179​}
180​
181​XdgOutputInterface::~XdgOutputInterface()
182​{}
183​
184​void XdgOutputInterface::setLogicalSize(const QSize &size)
185​{
186​ if (size == d->size) {
187​ return;
188​ }
189​ d->size = size;
190​ for(auto resource: d->resources) {
191​ resource->setLogicalSize(size);
192​ }
193​}
194​
195​QSize XdgOutputInterface::logicalSize() const
196​{
197​ return d->size;
198​}
199​
200​void XdgOutputInterface::setLogicalPosition(const QPoint &pos)
201​{
202​ if (pos == d->pos) {
203​ return;
204​ }
205​ d->pos = pos;
206​ for(auto resource: d->resources) {
207​ resource->setLogicalPosition(pos);
208​ }
209​}
210​
211​QPoint XdgOutputInterface::logicalPosition() const
212​{
213​ return d->pos;
214​}
215​
216​void XdgOutputInterface::done()
217​{
218​ d->doneOnce = true;
219​ for(auto resource: d->resources) {
220​ resource->done();
221​ }
222​}
223​
224​void XdgOutputInterface::Private::resourceConnected(XdgOutputV1Interface *resource)
225​{
226​ resource->setLogicalPosition(pos);
227​ resource->setLogicalSize(size);
228​ if (doneOnce) {
229​ resource->done();
230​ }
231​ resources << resource;
232​}
233​
234​void XdgOutputInterface::Private::resourceDisconnected(XdgOutputV1Interface *resource)
235​{
236​ resources.removeOne(resource);
237​}
238​
239​
240​class XdgOutputV1Interface::Private : public Resource::Private
241​{
242​public:
243​ Private(XdgOutputV1Interface *q, XdgOutputManagerInterface *c, wl_resource *parentResource);
244​ ~Private();
245​
246​private:
247​
248​ XdgOutputV1Interface *q_func() {
249​ return reinterpret_cast<XdgOutputV1Interface *>(q);
250​ }
251​
252​ static const struct zxdg_output_v1_interface s_interface;
253​};
254​
255​XdgOutputV1Interface::XdgOutputV1Interface(XdgOutputManagerInterface *parent, wl_resource *parentResource)
256​ :Resource(new XdgOutputV1Interface::Private(this, parent, parentResource))
257​{}
258​
259​XdgOutputV1Interface::~XdgOutputV1Interface()
260​{}
261​
262​void XdgOutputV1Interface::setLogicalSize(const QSize &size)
263​{
264​ if (!d->resource) {
265​ return;
266​ }
267​ zxdg_output_v1_send_logical_size(d->resource, size.width(), size.height());
268​}
269​
270​void XdgOutputV1Interface::setLogicalPosition(const QPoint &pos)
271​{
272​ if (!d->resource) {
273​ return;
274​ }
275​ zxdg_output_v1_send_logical_position(d->resource, pos.x(), pos.y());
276​}
277​
278​void XdgOutputV1Interface::done()
279​{
280​ if (!d->resource) {
281​ return;
282​ }
283​ zxdg_output_v1_send_done(d->resource);
284​}
285​
286​#ifndef DOXYGEN_SHOULD_SKIP_THIS
287​const struct zxdg_output_v1_interface XdgOutputV1Interface::Private::s_interface = {
288​ resourceDestroyedCallback
289​};
290​#endif
291​
292​XdgOutputV1Interface::Private::Private(XdgOutputV1Interface *q, XdgOutputManagerInterface *c, wl_resource *parentResource)
293​ : Resource::Private(q, c, parentResource, &zxdg_output_v1_interface, &s_interface)
294​{
295​}
296​
297​XdgOutputV1Interface::Private::~Private()
298​{
299​ if (resource) {
300​ wl_resource_destroy(resource);
301​ resource = nullptr;
302​ }
303​}
304​
305​}
306​}
307​