Differential D6186 Diff 15554 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);
		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;
		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		}