2014-08-26 14:07:39 +00:00
|
|
|
/********************************************************************
|
2014-09-17 13:57:56 +00:00
|
|
|
Copyright 2014 Martin Gräßlin <mgraesslin@kde.org>
|
2014-08-26 14:07:39 +00:00
|
|
|
|
2014-09-17 13:57:56 +00:00
|
|
|
This library is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU Lesser General Public
|
|
|
|
License as published by the Free Software Foundation; either
|
|
|
|
version 2.1 of the License, or (at your option) version 3, or any
|
|
|
|
later version accepted by the membership of KDE e.V. (or its
|
|
|
|
successor approved by the membership of KDE e.V.), which shall
|
|
|
|
act as a proxy defined in Section 6 of version 3 of the license.
|
2014-08-26 14:07:39 +00:00
|
|
|
|
2014-09-17 13:57:56 +00:00
|
|
|
This library is distributed in the hope that it will be useful,
|
2014-08-26 14:07:39 +00:00
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2014-09-17 13:57:56 +00:00
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
Lesser General Public License for more details.
|
2014-08-26 14:07:39 +00:00
|
|
|
|
2014-09-17 13:57:56 +00:00
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
|
|
License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
2014-08-26 14:07:39 +00:00
|
|
|
*********************************************************************/
|
2014-09-17 14:20:56 +00:00
|
|
|
#ifndef WAYLAND_SERVER_DISPLAY_H
|
|
|
|
#define WAYLAND_SERVER_DISPLAY_H
|
2014-08-26 14:07:39 +00:00
|
|
|
|
|
|
|
#include <QList>
|
|
|
|
#include <QObject>
|
|
|
|
|
2014-10-14 11:43:24 +00:00
|
|
|
#include <KWayland/Server/kwaylandserver_export.h>
|
2014-09-17 13:10:43 +00:00
|
|
|
|
2014-11-17 15:01:18 +00:00
|
|
|
#include "clientconnection.h"
|
|
|
|
|
|
|
|
struct wl_client;
|
2014-08-26 14:07:39 +00:00
|
|
|
struct wl_display;
|
|
|
|
struct wl_event_loop;
|
|
|
|
|
2014-09-17 14:10:38 +00:00
|
|
|
namespace KWayland
|
2014-08-26 14:07:39 +00:00
|
|
|
{
|
2015-09-09 16:16:02 +00:00
|
|
|
/**
|
|
|
|
* @short KWayland Server.
|
|
|
|
*
|
|
|
|
* This namespace groups all classes related to the Server module.
|
|
|
|
*
|
|
|
|
* The main entry point into the KWayland::Server API is the Display class.
|
|
|
|
* It allows to create a Wayland server and create various global objects on it.
|
|
|
|
*
|
|
|
|
* KWayland::Server is an API to easily create a head-less Wayland server with a
|
|
|
|
* Qt style API.
|
|
|
|
*
|
|
|
|
* @see Display
|
|
|
|
**/
|
2014-09-17 14:10:38 +00:00
|
|
|
namespace Server
|
2014-08-26 14:07:39 +00:00
|
|
|
{
|
|
|
|
|
2014-08-28 07:52:35 +00:00
|
|
|
class CompositorInterface;
|
2014-11-04 14:10:22 +00:00
|
|
|
class DataDeviceManagerInterface;
|
2015-08-31 14:08:58 +00:00
|
|
|
class DpmsManagerInterface;
|
2015-07-02 09:35:16 +00:00
|
|
|
class IdleInterface;
|
2017-10-20 16:28:25 +00:00
|
|
|
enum class IdleInhibitManagerInterfaceVersion;
|
Add Remote Access interface to KWayland
Summary:
This commit adds an interface bridge from KWin to KRfb. The purpose of
this protocol is to pass a GBM fd of currently displayed buffer from
KWin. The buffer is expected to be fully drawn once it is passed.
Related to D1230
Test Plan:
********* Start testing of RemoteAccessTest *********
Config: Using QtTest library 5.6.0, Qt 5.6.0 (x86_64-little_endian-lp64 shared (dynamic) release build; by GCC 6.1.1 20160501)
PASS : RemoteAccessTest::initTestCase()
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Connected to Wayland server at: "kwayland-test-remote-access-0"
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Wayland Interface: wl_shm / 1 / 1
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Wayland Interface: org_kde_kwin_remote_access_manager / 2 / 1
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-server: Server buffer sent: fd 15
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Got buffer, server fd: 15
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-server: Remote buffer returned, client 4 , id 0 , fd 15
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-server: Buffer released, fd 15
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Buffer released
PASS : RemoteAccessTest::testSendReleaseSingle()
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Connected to Wayland server at: "kwayland-test-remote-access-0"
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Wayland Interface: wl_shm / 1 / 1
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Wayland Interface: org_kde_kwin_remote_access_manager / 2 / 1
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-server: Server buffer sent: fd 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Got buffer, server fd: 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Got buffer, server fd: 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-server: Remote buffer returned, client 4 , id 0 , fd 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-server: Remote buffer returned, client 5 , id 0 , fd 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-server: Buffer released, fd 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Buffer released
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Buffer released
PASS : RemoteAccessTest::testSendReleaseMultiple()
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-client: Connected to Wayland server at: "kwayland-test-remote-access-0"
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-client: Wayland Interface: wl_shm / 1 / 1
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-client: Wayland Interface: org_kde_kwin_remote_access_manager / 2 / 1
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-server: Server buffer sent: fd 15
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-server: Buffer released, fd 15
PASS : RemoteAccessTest::testSendClientGone()
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Connected to Wayland server at: "kwayland-test-remote-access-0"
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Wayland Interface: wl_shm / 1 / 1
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Wayland Interface: org_kde_kwin_remote_access_manager / 2 / 1
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-server: Server buffer sent: fd 15
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Got buffer, server fd: 15
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Buffer released
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-server: Buffer released, fd 15
PASS : RemoteAccessTest::testSendReceiveClientGone()
PASS : RemoteAccessTest::cleanupTestCase()
Totals: 6 passed, 0 failed, 0 skipped, 0 blacklisted
********* Finished testing of RemoteAccessTest *********
Reviewers: graesslin, davidedmundson, romangg
Reviewed By: davidedmundson, romangg
Subscribers: jtamate, jgrulich, romangg, ngraham, alexeymin, #frameworks, davidedmundson, plasma-devel
Tags: #plasma_on_wayland, #frameworks
Maniphest Tasks: T5653, T7785
Differential Revision: https://phabricator.kde.org/D1231
2018-03-25 17:14:42 +00:00
|
|
|
class RemoteAccessManagerInterface;
|
2017-10-20 16:28:25 +00:00
|
|
|
class IdleInhibitManagerInterface;
|
2015-07-02 19:21:57 +00:00
|
|
|
class FakeInputInterface;
|
2014-08-26 14:07:39 +00:00
|
|
|
class OutputInterface;
|
server side of new outputmanagement protocol
This implements the server part of the screen management protocol. The
protocol is implemented as a wayland protocol.
It provides the following mechanisms:
- a list of outputs, close to wl_output, with additional properties for
enabled, uuid, edid, etc.. These OutputDevices correspond to a
connected output that can be enabled by the compositor, but is not
necessarily currently used for rendering.
- a global OutputManagement, which allows creating config objects, one
per client. The client can make changes to the outputs through
setScale(outputdevice*, scale) for example.
- an OutputConfiguration resource, that can be handed to a client and
used for configuration. Changes are double buffered here. Only after
OutputConfiguration.apply() has been called, the changes are relayed
over the global OutputManagement.
The compositor is responsible to handle changes.
For a more detailed description, see the API docs in especially
outputconfiguration.h.
REVIEW:125942
2015-11-04 14:36:52 +00:00
|
|
|
class OutputDeviceInterface;
|
|
|
|
class OutputConfigurationInterface;
|
|
|
|
class OutputManagementInterface;
|
2015-06-09 00:48:56 +00:00
|
|
|
class PlasmaShellInterface;
|
2015-06-12 01:05:14 +00:00
|
|
|
class PlasmaWindowManagementInterface;
|
2015-06-09 22:56:31 +00:00
|
|
|
class QtSurfaceExtensionInterface;
|
2014-09-02 07:34:31 +00:00
|
|
|
class SeatInterface;
|
2015-07-15 09:07:50 +00:00
|
|
|
class ShadowManagerInterface;
|
2015-08-26 12:42:58 +00:00
|
|
|
class BlurManagerInterface;
|
2015-09-02 16:13:25 +00:00
|
|
|
class ContrastManagerInterface;
|
2015-12-10 08:39:24 +00:00
|
|
|
class ServerSideDecorationManagerInterface;
|
2015-09-09 11:04:11 +00:00
|
|
|
class SlideManagerInterface;
|
2014-08-29 09:42:57 +00:00
|
|
|
class ShellInterface;
|
2014-10-14 12:04:35 +00:00
|
|
|
class SubCompositorInterface;
|
2016-05-02 12:28:26 +00:00
|
|
|
enum class TextInputInterfaceVersion;
|
|
|
|
class TextInputManagerInterface;
|
2016-04-21 10:56:02 +00:00
|
|
|
class XdgShellV5Interface;
|
|
|
|
enum class XdgShellInterfaceVersion;
|
|
|
|
class XdgShellInterface;
|
2016-10-07 07:07:34 +00:00
|
|
|
enum class RelativePointerInterfaceVersion;
|
|
|
|
class RelativePointerManagerInterface;
|
2016-10-26 08:27:14 +00:00
|
|
|
enum class PointerGesturesInterfaceVersion;
|
|
|
|
class PointerGesturesInterface;
|
2016-11-08 13:17:15 +00:00
|
|
|
enum class PointerConstraintsInterfaceVersion;
|
|
|
|
class PointerConstraintsInterface;
|
Wayland foreign protocol
Summary:
Implement the "foreign" wayland protocol.
A client can export a surface with an unique string as handle,
then another client can refer to that surface and set an own surface as
child of that surface.
Potential use cases are out-of-process dialogs, such as file dialogs,
meant to be used by sandboxed processes that may not have the access
it needs to implement such dialogs.
The handle needs to be shared between the processes with other means,
such as dbus or command line paramenters.
The public api of the server side only tracks parent/child relationships as this is the only data kwin would need it for, the rest of the api is not exported so should be safer from eventual protocol changes
Test Plan:
the autotest works, but has a lot of random crashes when deleting surfaces,
unfortunately backtraces don't tell much and the crashes never occur when running into valgrind
behavior may still be wrong, depending on how the protocol is supposed
to work if more clients try to set the same exported surface as parent
Reviewers: #plasma, #kwin, davidedmundson, graesslin
Reviewed By: #plasma, #kwin, graesslin
Subscribers: davidedmundson, graesslin, plasma-devel, #frameworks
Tags: #frameworks, #plasma_on_wayland
Differential Revision: https://phabricator.kde.org/D7369
2017-10-13 09:29:17 +00:00
|
|
|
class XdgForeignInterface;
|
2017-12-18 21:50:31 +00:00
|
|
|
class AppMenuManagerInterface;
|
2018-01-03 10:24:57 +00:00
|
|
|
class ServerSideDecorationPaletteManagerInterface;
|
2018-05-15 09:45:17 +00:00
|
|
|
class XdgOutputManagerInterface;
|
2014-08-26 14:07:39 +00:00
|
|
|
|
2015-09-09 11:49:58 +00:00
|
|
|
/**
|
|
|
|
* @brief Class holding the Wayland server display loop.
|
|
|
|
*
|
|
|
|
* @todo Improve documentation
|
|
|
|
**/
|
2014-09-17 13:10:43 +00:00
|
|
|
class KWAYLANDSERVER_EXPORT Display : public QObject
|
2014-08-26 14:07:39 +00:00
|
|
|
{
|
|
|
|
Q_OBJECT
|
|
|
|
Q_PROPERTY(QString socketName READ socketName WRITE setSocketName NOTIFY socketNameChanged)
|
|
|
|
Q_PROPERTY(bool running READ isRunning NOTIFY runningChanged)
|
|
|
|
public:
|
|
|
|
explicit Display(QObject *parent = nullptr);
|
|
|
|
virtual ~Display();
|
|
|
|
|
|
|
|
void setSocketName(const QString &name);
|
|
|
|
QString socketName() const;
|
|
|
|
|
2014-08-29 09:42:57 +00:00
|
|
|
quint32 serial();
|
|
|
|
quint32 nextSerial();
|
|
|
|
|
2014-11-27 15:42:16 +00:00
|
|
|
/**
|
|
|
|
* How to setup the server connection.
|
|
|
|
* @li ConnectToSocket: the server will open the socket identified by the socket name
|
|
|
|
* @li ConnectClientsOnly: only connections through createClient are possible
|
|
|
|
**/
|
|
|
|
enum class StartMode {
|
|
|
|
ConnectToSocket,
|
|
|
|
ConnectClientsOnly
|
|
|
|
};
|
|
|
|
void start(StartMode mode = StartMode::ConnectToSocket);
|
2014-08-26 14:07:39 +00:00
|
|
|
void terminate();
|
2014-11-07 10:41:37 +00:00
|
|
|
/**
|
|
|
|
* Starts the event loop for the server socket.
|
|
|
|
* This method should only be used if start() is used before creating the
|
|
|
|
* QCoreApplication. In that case start() cannot fully setup the event processing
|
|
|
|
* and the loop needs to be started after the QCoreApplication got created.
|
|
|
|
* @see start
|
|
|
|
* @see dispatchEvents
|
|
|
|
**/
|
|
|
|
void startLoop();
|
|
|
|
/**
|
|
|
|
* Dispatches pending events in a blocking way. May only be used if the Display is
|
|
|
|
* created and started before the QCoreApplication is created. Once the QCoreApplication
|
2015-05-18 08:27:44 +00:00
|
|
|
* is created and the event loop is started this method delegates to the normal dispatch
|
|
|
|
* handling.
|
2014-11-07 10:41:37 +00:00
|
|
|
* @see startLoop
|
|
|
|
**/
|
|
|
|
void dispatchEvents(int msecTimeout = -1);
|
2014-08-26 14:07:39 +00:00
|
|
|
|
2014-11-27 15:16:54 +00:00
|
|
|
/**
|
|
|
|
* Create a client for the given file descriptor.
|
|
|
|
*
|
|
|
|
* The client is created as if it connected through the normal server
|
|
|
|
* socket. This method can be used to create a connection bypassing the
|
|
|
|
* normal socket connection. It's recommended to use together with
|
|
|
|
* socketpair and pass the other side of the socket to the client.
|
|
|
|
*
|
|
|
|
* @param fd The file descriptor for the socket to the client
|
|
|
|
* @returns The new ClientConnection or @c null on failure.
|
|
|
|
**/
|
|
|
|
ClientConnection *createClient(int fd);
|
|
|
|
|
2014-09-18 13:40:22 +00:00
|
|
|
operator wl_display*();
|
|
|
|
operator wl_display*() const;
|
|
|
|
bool isRunning() const;
|
2014-08-26 14:07:39 +00:00
|
|
|
|
|
|
|
OutputInterface *createOutput(QObject *parent = nullptr);
|
|
|
|
void removeOutput(OutputInterface *output);
|
2014-09-18 13:40:22 +00:00
|
|
|
QList<OutputInterface*> outputs() const;
|
2014-08-26 14:07:39 +00:00
|
|
|
|
server side of new outputmanagement protocol
This implements the server part of the screen management protocol. The
protocol is implemented as a wayland protocol.
It provides the following mechanisms:
- a list of outputs, close to wl_output, with additional properties for
enabled, uuid, edid, etc.. These OutputDevices correspond to a
connected output that can be enabled by the compositor, but is not
necessarily currently used for rendering.
- a global OutputManagement, which allows creating config objects, one
per client. The client can make changes to the outputs through
setScale(outputdevice*, scale) for example.
- an OutputConfiguration resource, that can be handed to a client and
used for configuration. Changes are double buffered here. Only after
OutputConfiguration.apply() has been called, the changes are relayed
over the global OutputManagement.
The compositor is responsible to handle changes.
For a more detailed description, see the API docs in especially
outputconfiguration.h.
REVIEW:125942
2015-11-04 14:36:52 +00:00
|
|
|
OutputDeviceInterface *createOutputDevice(QObject *parent = nullptr);
|
|
|
|
void removeOutputDevice(OutputDeviceInterface *output);
|
|
|
|
QList<OutputDeviceInterface*> outputDevices() const;
|
|
|
|
|
2014-08-28 07:52:35 +00:00
|
|
|
CompositorInterface *createCompositor(QObject *parent = nullptr);
|
2014-08-28 12:22:53 +00:00
|
|
|
void createShm();
|
2014-08-29 09:42:57 +00:00
|
|
|
ShellInterface *createShell(QObject *parent = nullptr);
|
2014-09-02 07:34:31 +00:00
|
|
|
SeatInterface *createSeat(QObject *parent = nullptr);
|
2015-12-15 14:47:19 +00:00
|
|
|
/**
|
|
|
|
* @returns All SeatInterface currently managed on the Display.
|
|
|
|
* @since 5.6
|
|
|
|
**/
|
|
|
|
QVector<SeatInterface*> seats() const;
|
2014-10-14 12:04:35 +00:00
|
|
|
SubCompositorInterface *createSubCompositor(QObject *parent = nullptr);
|
2014-11-04 14:10:22 +00:00
|
|
|
DataDeviceManagerInterface *createDataDeviceManager(QObject *parent = nullptr);
|
server side of new outputmanagement protocol
This implements the server part of the screen management protocol. The
protocol is implemented as a wayland protocol.
It provides the following mechanisms:
- a list of outputs, close to wl_output, with additional properties for
enabled, uuid, edid, etc.. These OutputDevices correspond to a
connected output that can be enabled by the compositor, but is not
necessarily currently used for rendering.
- a global OutputManagement, which allows creating config objects, one
per client. The client can make changes to the outputs through
setScale(outputdevice*, scale) for example.
- an OutputConfiguration resource, that can be handed to a client and
used for configuration. Changes are double buffered here. Only after
OutputConfiguration.apply() has been called, the changes are relayed
over the global OutputManagement.
The compositor is responsible to handle changes.
For a more detailed description, see the API docs in especially
outputconfiguration.h.
REVIEW:125942
2015-11-04 14:36:52 +00:00
|
|
|
OutputManagementInterface *createOutputManagement(QObject *parent = nullptr);
|
2015-06-09 00:48:56 +00:00
|
|
|
PlasmaShellInterface *createPlasmaShell(QObject *parent = nullptr);
|
2015-06-12 01:05:14 +00:00
|
|
|
PlasmaWindowManagementInterface *createPlasmaWindowManagement(QObject *parent = nullptr);
|
2015-06-09 22:56:31 +00:00
|
|
|
QtSurfaceExtensionInterface *createQtSurfaceExtension(QObject *parent = nullptr);
|
2015-07-02 09:35:16 +00:00
|
|
|
IdleInterface *createIdle(QObject *parent = nullptr);
|
Add Remote Access interface to KWayland
Summary:
This commit adds an interface bridge from KWin to KRfb. The purpose of
this protocol is to pass a GBM fd of currently displayed buffer from
KWin. The buffer is expected to be fully drawn once it is passed.
Related to D1230
Test Plan:
********* Start testing of RemoteAccessTest *********
Config: Using QtTest library 5.6.0, Qt 5.6.0 (x86_64-little_endian-lp64 shared (dynamic) release build; by GCC 6.1.1 20160501)
PASS : RemoteAccessTest::initTestCase()
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Connected to Wayland server at: "kwayland-test-remote-access-0"
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Wayland Interface: wl_shm / 1 / 1
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Wayland Interface: org_kde_kwin_remote_access_manager / 2 / 1
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-server: Server buffer sent: fd 15
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Got buffer, server fd: 15
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-server: Remote buffer returned, client 4 , id 0 , fd 15
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-server: Buffer released, fd 15
QDEBUG : RemoteAccessTest::testSendReleaseSingle() kwayland-client: Buffer released
PASS : RemoteAccessTest::testSendReleaseSingle()
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Connected to Wayland server at: "kwayland-test-remote-access-0"
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Wayland Interface: wl_shm / 1 / 1
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Wayland Interface: org_kde_kwin_remote_access_manager / 2 / 1
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-server: Server buffer sent: fd 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Got buffer, server fd: 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Got buffer, server fd: 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-server: Remote buffer returned, client 4 , id 0 , fd 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-server: Remote buffer returned, client 5 , id 0 , fd 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-server: Buffer released, fd 15
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Buffer released
QDEBUG : RemoteAccessTest::testSendReleaseMultiple() kwayland-client: Buffer released
PASS : RemoteAccessTest::testSendReleaseMultiple()
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-client: Connected to Wayland server at: "kwayland-test-remote-access-0"
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-client: Wayland Interface: wl_shm / 1 / 1
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-client: Wayland Interface: org_kde_kwin_remote_access_manager / 2 / 1
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-server: Server buffer sent: fd 15
QDEBUG : RemoteAccessTest::testSendClientGone() kwayland-server: Buffer released, fd 15
PASS : RemoteAccessTest::testSendClientGone()
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Connected to Wayland server at: "kwayland-test-remote-access-0"
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Wayland Interface: wl_shm / 1 / 1
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Wayland Interface: org_kde_kwin_remote_access_manager / 2 / 1
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-server: Server buffer sent: fd 15
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Got buffer, server fd: 15
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-client: Buffer released
QDEBUG : RemoteAccessTest::testSendReceiveClientGone() kwayland-server: Buffer released, fd 15
PASS : RemoteAccessTest::testSendReceiveClientGone()
PASS : RemoteAccessTest::cleanupTestCase()
Totals: 6 passed, 0 failed, 0 skipped, 0 blacklisted
********* Finished testing of RemoteAccessTest *********
Reviewers: graesslin, davidedmundson, romangg
Reviewed By: davidedmundson, romangg
Subscribers: jtamate, jgrulich, romangg, ngraham, alexeymin, #frameworks, davidedmundson, plasma-devel
Tags: #plasma_on_wayland, #frameworks
Maniphest Tasks: T5653, T7785
Differential Revision: https://phabricator.kde.org/D1231
2018-03-25 17:14:42 +00:00
|
|
|
RemoteAccessManagerInterface *createRemoteAccessManager(QObject *parent = nullptr);
|
2015-07-02 19:21:57 +00:00
|
|
|
FakeInputInterface *createFakeInput(QObject *parent = nullptr);
|
2015-07-15 09:07:50 +00:00
|
|
|
ShadowManagerInterface *createShadowManager(QObject *parent = nullptr);
|
2015-08-26 12:42:58 +00:00
|
|
|
BlurManagerInterface *createBlurManager(QObject *parent = nullptr);
|
2015-09-02 16:13:25 +00:00
|
|
|
ContrastManagerInterface *createContrastManager(QObject *parent = nullptr);
|
2015-09-09 11:04:11 +00:00
|
|
|
SlideManagerInterface *createSlideManager(QObject *parent = nullptr);
|
2015-08-31 14:08:58 +00:00
|
|
|
DpmsManagerInterface *createDpmsManager(QObject *parent = nullptr);
|
2015-12-10 08:39:24 +00:00
|
|
|
/**
|
|
|
|
* @since 5.6
|
|
|
|
**/
|
|
|
|
ServerSideDecorationManagerInterface *createServerSideDecorationManager(QObject *parent = nullptr);
|
2016-05-02 12:28:26 +00:00
|
|
|
/**
|
|
|
|
* Create the text input manager in interface @p version.
|
|
|
|
* @returns The created manager object
|
|
|
|
* @since 5.23
|
|
|
|
**/
|
|
|
|
TextInputManagerInterface *createTextInputManager(const TextInputInterfaceVersion &version, QObject *parent = nullptr);
|
2014-08-28 07:52:35 +00:00
|
|
|
|
2016-04-21 10:56:02 +00:00
|
|
|
/**
|
|
|
|
* Creates the XdgShell in interface @p version.
|
|
|
|
*
|
|
|
|
* @since 5.25
|
|
|
|
**/
|
|
|
|
XdgShellInterface *createXdgShell(const XdgShellInterfaceVersion &version, QObject *parent = nullptr);
|
|
|
|
|
2016-10-07 07:07:34 +00:00
|
|
|
/**
|
|
|
|
* Creates the RelativePointerManagerInterface in interface @p version
|
|
|
|
*
|
|
|
|
* @returns The created manager object
|
|
|
|
* @since 5.28
|
|
|
|
**/
|
|
|
|
RelativePointerManagerInterface *createRelativePointerManager(const RelativePointerInterfaceVersion &version, QObject *parent = nullptr);
|
|
|
|
|
2016-10-26 08:27:14 +00:00
|
|
|
/**
|
|
|
|
* Creates the PointerGesturesInterface in interface @p version
|
|
|
|
*
|
|
|
|
* @returns The created manager object
|
|
|
|
* @since 5.29
|
|
|
|
**/
|
|
|
|
PointerGesturesInterface *createPointerGestures(const PointerGesturesInterfaceVersion &version, QObject *parent = nullptr);
|
|
|
|
|
2016-11-08 13:17:15 +00:00
|
|
|
/**
|
|
|
|
* Creates the PointerConstraintsInterface in interface @p version
|
|
|
|
*
|
|
|
|
* @returns The created manager object
|
|
|
|
* @since 5.29
|
|
|
|
**/
|
|
|
|
PointerConstraintsInterface *createPointerConstraints(const PointerConstraintsInterfaceVersion &version, QObject *parent = nullptr);
|
|
|
|
|
Wayland foreign protocol
Summary:
Implement the "foreign" wayland protocol.
A client can export a surface with an unique string as handle,
then another client can refer to that surface and set an own surface as
child of that surface.
Potential use cases are out-of-process dialogs, such as file dialogs,
meant to be used by sandboxed processes that may not have the access
it needs to implement such dialogs.
The handle needs to be shared between the processes with other means,
such as dbus or command line paramenters.
The public api of the server side only tracks parent/child relationships as this is the only data kwin would need it for, the rest of the api is not exported so should be safer from eventual protocol changes
Test Plan:
the autotest works, but has a lot of random crashes when deleting surfaces,
unfortunately backtraces don't tell much and the crashes never occur when running into valgrind
behavior may still be wrong, depending on how the protocol is supposed
to work if more clients try to set the same exported surface as parent
Reviewers: #plasma, #kwin, davidedmundson, graesslin
Reviewed By: #plasma, #kwin, graesslin
Subscribers: davidedmundson, graesslin, plasma-devel, #frameworks
Tags: #frameworks, #plasma_on_wayland
Differential Revision: https://phabricator.kde.org/D7369
2017-10-13 09:29:17 +00:00
|
|
|
/**
|
|
|
|
* Creates the XdgForeignInterface in interface @p version
|
|
|
|
*
|
|
|
|
* @returns The created manager object
|
|
|
|
* @since 5.40
|
|
|
|
**/
|
|
|
|
XdgForeignInterface *createXdgForeignInterface(QObject *parent = nullptr);
|
2017-10-20 16:28:25 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates the IdleInhibitManagerInterface in interface @p version.
|
|
|
|
*
|
|
|
|
* @returns The created manager object
|
|
|
|
* @since 5.41
|
|
|
|
**/
|
|
|
|
IdleInhibitManagerInterface *createIdleInhibitManager(const IdleInhibitManagerInterfaceVersion &version, QObject *parent = nullptr);
|
|
|
|
|
2017-12-18 21:50:31 +00:00
|
|
|
/**
|
|
|
|
* Creates the AppMenuManagerInterface in interface @p version.
|
|
|
|
*
|
|
|
|
* @returns The created manager object
|
2017-12-26 19:46:38 +00:00
|
|
|
* @since 5.42
|
2017-12-18 21:50:31 +00:00
|
|
|
**/
|
|
|
|
AppMenuManagerInterface *createAppMenuManagerInterface(QObject *parent = nullptr);
|
|
|
|
|
2018-01-03 10:24:57 +00:00
|
|
|
/**
|
|
|
|
* Creates the ServerSideDecorationPaletteManagerInterface in interface @p version.
|
|
|
|
*
|
|
|
|
* @returns The created manager object
|
|
|
|
* @since 5.42
|
|
|
|
**/
|
|
|
|
ServerSideDecorationPaletteManagerInterface *createServerSideDecorationPaletteManager(QObject *parent = nullptr);
|
|
|
|
|
2018-05-15 09:45:17 +00:00
|
|
|
/**
|
|
|
|
* Creates the XdgOutputManagerInterface
|
|
|
|
*
|
|
|
|
* @return the created manager
|
2018-05-17 21:15:55 +00:00
|
|
|
* @since 5.47
|
2018-05-15 09:45:17 +00:00
|
|
|
*/
|
|
|
|
XdgOutputManagerInterface *createXdgOutputManager(QObject *parent = nullptr);
|
|
|
|
|
2017-12-18 21:50:31 +00:00
|
|
|
|
2014-11-17 15:01:18 +00:00
|
|
|
/**
|
|
|
|
* Gets the ClientConnection for the given @p client.
|
|
|
|
* If there is no ClientConnection yet for the given @p client, it will be created.
|
|
|
|
* @param client The native client for which the ClientConnection is retrieved
|
|
|
|
* @return The ClientConnection for the given native client
|
|
|
|
**/
|
|
|
|
ClientConnection *getConnection(wl_client *client);
|
2014-11-17 17:13:28 +00:00
|
|
|
QVector<ClientConnection*> connections() const;
|
2014-11-17 15:01:18 +00:00
|
|
|
|
2015-03-03 08:43:30 +00:00
|
|
|
/**
|
|
|
|
* Set the EGL @p display for this Wayland display.
|
|
|
|
* The EGLDisplay can only be set once and must be alive as long as the Wayland display
|
|
|
|
* is alive. The user should have set up the binding between the EGLDisplay and the
|
|
|
|
* Wayland display prior to calling this method.
|
|
|
|
*
|
|
|
|
* @see eglDisplay
|
|
|
|
* @since 5.3
|
|
|
|
**/
|
|
|
|
void setEglDisplay(void *display);
|
|
|
|
/**
|
|
|
|
* @returns the EGLDisplay used for this Wayland display or EGL_NO_DISPLAY if not set.
|
|
|
|
* @see setEglDisplay
|
|
|
|
* @since 5.3
|
|
|
|
**/
|
|
|
|
void *eglDisplay() const;
|
|
|
|
|
2014-08-26 14:07:39 +00:00
|
|
|
Q_SIGNALS:
|
|
|
|
void socketNameChanged(const QString&);
|
|
|
|
void runningChanged(bool);
|
|
|
|
void aboutToTerminate();
|
2014-11-17 15:01:18 +00:00
|
|
|
void clientConnected(KWayland::Server::ClientConnection*);
|
|
|
|
void clientDisconnected(KWayland::Server::ClientConnection*);
|
2014-08-26 14:07:39 +00:00
|
|
|
|
|
|
|
private:
|
2014-09-18 13:40:22 +00:00
|
|
|
class Private;
|
|
|
|
QScopedPointer<Private> d;
|
2014-08-26 14:07:39 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|