Differential D1231 Diff 3620 src/client/remote_access.cpp

Changeset View

Standalone View

View Options

src/client/remote_access.cpp

  • This file was added.
1​/****************************************************************************
2​Copyright 2016 Oleg Chernovskiy <kanedias@xaker.ru>
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 "remote_access.h"
21​#include "event_queue.h"
22​#include "wayland_pointer_p.h"
23​// Wayland
24​#include <wayland-remote-access-client-protocol.h>
25​// Qt
26​#include <QtCore/QDebug>
27​
28​namespace KWayland
29​{
30​namespace Client
31​{
32​
33​class RemoteAccessManager::Private
34​{
35​public:
36​ explicit Private(RemoteAccessManager *ram);
37​ void setup(org_kde_kwin_remote_access_manager *k);
38​
39​ WaylandPointer<org_kde_kwin_remote_access_manager, org_kde_kwin_remote_access_manager_destroy> ram;
40​ EventQueue *queue = nullptr;
41​private:
42​ static const struct org_kde_kwin_remote_access_manager_listener s_listener;
43​ static void bufferReadyCallback(void *data, org_kde_kwin_remote_access_manager *org_kde_kwin_remoteaccess, quint32 buffer_id);
44​
45​ RemoteAccessManager *q;
46​};
47​
48​RemoteAccessManager::Private::Private(RemoteAccessManager *q)
49​ : q(q)
50​{
51​}
52​
53​const org_kde_kwin_remote_access_manager_listener RemoteAccessManager::Private::s_listener = {
54​ bufferReadyCallback
55​};
56​
57​void RemoteAccessManager::Private::bufferReadyCallback(void *data, org_kde_kwin_remote_access_manager *interface, quint32 buffer_id)
58​{
59​ auto ramp = reinterpret_cast<RemoteAccessManager::Private*>(data);
60​ Q_ASSERT(ramp->ram == interface);
61​
62​ // handle it fully internally, get the buffer immediately
63​ auto requested = org_kde_kwin_remote_access_manager_get_buffer(ramp->ram, buffer_id);
64​ auto rbuf = new RemoteBuffer(ramp->q);
65​ rbuf->setup(requested);
66​
67​ emit ramp->q->bufferReady(rbuf);
graesslinUnsubmitted
Done

qCDebug please

graesslin: qCDebug please
68​}
69​
70​void RemoteAccessManager::Private::setup(org_kde_kwin_remote_access_manager *k)
71​{
72​ Q_ASSERT(k);
73​ Q_ASSERT(!ram);
74​ ram.setup(k);
75​ org_kde_kwin_remote_access_manager_add_listener(k, &s_listener, this);
76​}
77​
78​RemoteAccessManager::RemoteAccessManager(QObject *parent)
79​ : QObject(parent)
80​ , d(new Private(this))
81​{
82​}
83​
84​RemoteAccessManager::~RemoteAccessManager()
85​{
86​ release();
87​}
88​
89​void RemoteAccessManager::setup(org_kde_kwin_remote_access_manager *ram)
90​{
91​ d->setup(ram);
92​}
93​
94​void RemoteAccessManager::release()
95​{
96​ d->ram.release();
97​}
98​
99​void RemoteAccessManager::destroy()
100​{
101​ d->ram.destroy();
102​}
103​
104​void RemoteAccessManager::setEventQueue(EventQueue *queue)
105​{
106​ d->queue = queue;
107​}
108​
109​EventQueue *RemoteAccessManager::eventQueue()
110​{
111​ return d->queue;
112​}
113​
114​RemoteAccessManager::operator org_kde_kwin_remote_access_manager*() {
115​ return d->ram;
116​}
117​
118​RemoteAccessManager::operator org_kde_kwin_remote_access_manager*() const {
119​ return d->ram;
120​}
121​
122​bool RemoteAccessManager::isValid() const
123​{
124​ return d->ram.isValid();
125​}
126​
127​class RemoteBuffer::Private
128​{
129​public:
130​ Private(RemoteBuffer *q);
131​ void setup(org_kde_kwin_remote_buffer *buffer);
132​
133​ static struct org_kde_kwin_remote_buffer_listener s_listener;
134​ static void paramsCallback(void *data, org_kde_kwin_remote_buffer *rbuf,
135​ qint32 fd, quint32 width, quint32 height, quint32 stride, quint32 format);
136​
137​ WaylandPointer<org_kde_kwin_remote_buffer, org_kde_kwin_remote_buffer_no_longer_needed> remotebuffer;
138​ RemoteBuffer *q;
139​};
140​
romanggUnsubmitted
Not Done

rm whitespace

romangg: rm whitespace
141​RemoteBuffer::Private::Private(RemoteBuffer *q)
142​ : q(q)
143​{
144​}
145​
146​void RemoteBuffer::Private::paramsCallback(void *data, org_kde_kwin_remote_buffer *rbuf,
147​ qint32 fd, quint32 width, quint32 height, quint32 stride, quint32 format)
148​{
149​ Q_UNUSED(rbuf)
150​ Private *p = reinterpret_cast<Private *>(data);
151​ emit p->q->paramsObtained(fd, width, height, stride, format);
152​}
153​
154​#ifndef DOXYGEN_SHOULD_SKIP_THIS
155​org_kde_kwin_remote_buffer_listener RemoteBuffer::Private::s_listener = {
156​ paramsCallback
157​};
158​#endif
159​
160​void RemoteBuffer::Private::setup(org_kde_kwin_remote_buffer *rbuffer)
161​{
162​ remotebuffer.setup(rbuffer);
163​ org_kde_kwin_remote_buffer_add_listener(rbuffer, &s_listener, this);
164​}
165​
166​RemoteBuffer::RemoteBuffer(QObject *parent)
167​ : QObject(parent)
168​ , d(new Private(this))
169​{
170​}
171​
172​RemoteBuffer::~RemoteBuffer()
173​{
174​ release();
175​ qDebug() << "Buffer released";
176​}
177​
178​void RemoteBuffer::setup(org_kde_kwin_remote_buffer *remotebuffer)
179​{
180​ Q_ASSERT(remotebuffer);
181​ Q_ASSERT(!d->remotebuffer);
182​ d->setup(remotebuffer);
183​}
184​
185​void RemoteBuffer::release()
186​{
187​ d->remotebuffer.release();
188​}
189​
190​void RemoteBuffer::destroy()
191​{
192​ d->remotebuffer.destroy();
193​}
194​
195​RemoteBuffer::operator org_kde_kwin_remote_buffer*() {
196​ return d->remotebuffer;
197​}
198​
199​RemoteBuffer::operator org_kde_kwin_remote_buffer*() const {
200​ return d->remotebuffer;
201​}
202​
203​bool RemoteBuffer::isValid() const
204​{
205​ return d->remotebuffer.isValid();
206​}
207​
208​void RemoteBuffer::noLongerNeeded()
209​{
210​ // notify server about end of processing
211​ // (see wayland pointer deleter in private part)
212​ deleteLater();
213​}
214​
215​}
216​}