Differential D1231 Diff 15553 src/client/remote_access.cpp

Changeset View

Standalone View

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		#include "logging_p.h"
24		// Wayland
25		#include <wayland-remote-access-client-protocol.h>
26
27		namespace KWayland
28		{
29		namespace Client
30		{
31
32		class RemoteAccessManager::Private
33		{
34		public:
35		explicit Private(RemoteAccessManager *ram);
36		void setup(org_kde_kwin_remote_access_manager *k);
37
38		WaylandPointer<org_kde_kwin_remote_access_manager, org_kde_kwin_remote_access_manager_release> ram;
39		EventQueue *queue = nullptr;
40		private:
41		static const struct org_kde_kwin_remote_access_manager_listener s_listener;
42		static void bufferReadyCallback(void data, org_kde_kwin_remote_access_manager org_kde_kwin_remoteaccess, quint32 buffer_id);
43
44		RemoteAccessManager *q;
45		};
46
47		RemoteAccessManager::Private::Private(RemoteAccessManager *q)
48		: q(q)
49		{
50		}
51
52		const org_kde_kwin_remote_access_manager_listener RemoteAccessManager::Private::s_listener = {
53		bufferReadyCallback
54		};
55
56		void RemoteAccessManager::Private::bufferReadyCallback(void data, org_kde_kwin_remote_access_manager interface, quint32 buffer_id)
57		{
58		auto ramp = reinterpret_cast<RemoteAccessManager::Private*>(data);
59		Q_ASSERT(ramp->ram == interface);
60
61		// handle it fully internally, get the buffer immediately
62		auto requested = org_kde_kwin_remote_access_manager_get_buffer(ramp->ram, buffer_id);
63		auto rbuf = new RemoteBuffer(ramp->q);
64		rbuf->setup(requested);
65		qCDebug(KWAYLAND_CLIENT) << "Got buffer, server fd:" << buffer_id;
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_release> remotebuffer;
138		RemoteBuffer *q;
139
140		qint32 fd = 0;
	romanggUnsubmitted Not Done rm whitespace romangg: rm whitespace
141		quint32 width = 0;
142		quint32 height = 0;
143		quint32 stride = 0;
144		quint32 format = 0;
145		};
146
147		RemoteBuffer::Private::Private(RemoteBuffer *q)
148		: q(q)
149		{
150		}
151
152		void RemoteBuffer::Private::paramsCallback(void data, org_kde_kwin_remote_buffer rbuf,
153		qint32 fd, quint32 width, quint32 height, quint32 stride, quint32 format)
154		{
155		Q_UNUSED(rbuf)
156		Private p = reinterpret_cast<Private >(data);
157		p->fd = fd;
158		p->width = width;
159		p->height = height;
160		p->stride = stride;
161		p->format = format;
162		emit p->q->parametersObtained();
163		}
164
165		#ifndef DOXYGEN_SHOULD_SKIP_THIS
166		org_kde_kwin_remote_buffer_listener RemoteBuffer::Private::s_listener = {
167		paramsCallback
168		};
169		#endif
170
171		void RemoteBuffer::Private::setup(org_kde_kwin_remote_buffer *rbuffer)
172		{
173		remotebuffer.setup(rbuffer);
174		org_kde_kwin_remote_buffer_add_listener(rbuffer, &s_listener, this);
175		}
176
177		RemoteBuffer::RemoteBuffer(QObject *parent)
178		: QObject(parent)
179		, d(new Private(this))
180		{
181		}
182
183		RemoteBuffer::~RemoteBuffer()
184		{
185		release();
186		qCDebug(KWAYLAND_CLIENT) << "Buffer released";
187		}
188
189		void RemoteBuffer::setup(org_kde_kwin_remote_buffer *remotebuffer)
190		{
191		Q_ASSERT(remotebuffer);
192		Q_ASSERT(!d->remotebuffer);
193		d->setup(remotebuffer);
194		}
195
196		void RemoteBuffer::release()
197		{
198		d->remotebuffer.release();
199		}
200
201		void RemoteBuffer::destroy()
202		{
203		d->remotebuffer.destroy();
204		}
205
206		RemoteBuffer::operator org_kde_kwin_remote_buffer*() {
207		return d->remotebuffer;
208		}
209
210		RemoteBuffer::operator org_kde_kwin_remote_buffer*() const {
211		return d->remotebuffer;
212		}
213
214		bool RemoteBuffer::isValid() const
215		{
216		return d->remotebuffer.isValid();
217		}
218
219		qint32 RemoteBuffer::fd()
220		{
221		return d->fd;
222		}
223
224		quint32 RemoteBuffer::width()
225		{
226		return d->width;
227		}
228
229		quint32 RemoteBuffer::height()
230		{
231		return d->height;
232		}
233
234		quint32 RemoteBuffer::stride()
235		{
236		return d->stride;
237		}
238
239		quint32 RemoteBuffer::format()
240		{
241		return d->format;
242		}
243
244
245		}
246		}