Differential D1231 Diff 4337 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_release> 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​ qDebug() << "Client: Got buffer, server fd:" << buffer_id;
67​
graesslinUnsubmitted
Done

qCDebug please

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

rm whitespace

romangg: rm whitespace
141​ qint32 fd = 0;
142​ quint32 width = 0;
143​ quint32 height = 0;
144​ quint32 stride = 0;
145​ quint32 format = 0;
146​};
147​
148​RemoteBuffer::Private::Private(RemoteBuffer *q)
149​ : q(q)
150​{
151​}
152​
153​void RemoteBuffer::Private::paramsCallback(void *data, org_kde_kwin_remote_buffer *rbuf,
154​ qint32 fd, quint32 width, quint32 height, quint32 stride, quint32 format)
155​{
156​ Q_UNUSED(rbuf)
157​ Private *p = reinterpret_cast<Private *>(data);
158​ p->fd = fd;
159​ p->width = width;
160​ p->height = height;
161​ p->stride = stride;
162​ p->format = format;
163​ emit p->q->paramsObtained();
164​}
165​
166​#ifndef DOXYGEN_SHOULD_SKIP_THIS
167​org_kde_kwin_remote_buffer_listener RemoteBuffer::Private::s_listener = {
168​ paramsCallback
169​};
170​#endif
171​
172​void RemoteBuffer::Private::setup(org_kde_kwin_remote_buffer *rbuffer)
173​{
174​ remotebuffer.setup(rbuffer);
175​ org_kde_kwin_remote_buffer_add_listener(rbuffer, &s_listener, this);
176​}
177​
178​RemoteBuffer::RemoteBuffer(QObject *parent)
179​ : QObject(parent)
180​ , d(new Private(this))
181​{
182​}
183​
184​RemoteBuffer::~RemoteBuffer()
185​{
186​ release();
187​ qDebug() << "Client: buffer released";
188​}
189​
190​void RemoteBuffer::setup(org_kde_kwin_remote_buffer *remotebuffer)
191​{
192​ Q_ASSERT(remotebuffer);
193​ Q_ASSERT(!d->remotebuffer);
194​ d->setup(remotebuffer);
195​}
196​
197​void RemoteBuffer::release()
198​{
199​ d->remotebuffer.release();
200​}
201​
202​void RemoteBuffer::destroy()
203​{
204​ d->remotebuffer.destroy();
205​}
206​
207​RemoteBuffer::operator org_kde_kwin_remote_buffer*() {
208​ return d->remotebuffer;
209​}
210​
211​RemoteBuffer::operator org_kde_kwin_remote_buffer*() const {
212​ return d->remotebuffer;
213​}
214​
215​bool RemoteBuffer::isValid() const
216​{
217​ return d->remotebuffer.isValid();
218​}
219​
220​qint32 RemoteBuffer::fd()
221​{
222​ return d->fd;
223​}
224​
225​quint32 RemoteBuffer::width()
226​{
227​ return d->width;
228​}
229​
230​quint32 RemoteBuffer::height()
231​{
232​ return d->height;
233​}
234​
235​quint32 RemoteBuffer::stride()
236​{
237​ return d->stride;
238​}
239​
240​quint32 RemoteBuffer::format()
241​{
242​ return d->format;
243​}
244​
245​
246​}
247​}
248​No newline at end of file