Commit 6e08fb2f authored by Roman Gilg's avatar Roman Gilg

[xwl] Generic X selections translation mechanism with Clipboard support

Summary:
In this patch an infrastructure is created to represent generic X selections
in a Wayland session and use them for data transfers between Xwayland windows
and Wayland native clients.

The central manager is the DataBridge class, in which Selection objects can be
created. This is hard-coded and such a Selection object persists until the end
of the session, so no arbitrary selections can be created on the fly. For now
the X Clipboard selection is supported, whose corresponding mechanism in the
Wayland protocol is just called Selection.

A Selection object listens for selection owner changes on the X side and for
similar events into the Wayland server interfaces. If a data provider is
available a selection source object is created by the Selection object. In case
data is requested on the other side, a data transfer is initialized by creating
a Transfer object. A Selection keeps track of all transfers and makes sure that
they are destroyed when they are finished or in case they idle because of
misbehaving clients.

The Clipboard class translates the X Clipboard via a proxy window. Selection
changes on the Wayland side are listened to through a new signal on the active
KWayland seat interface.

The previously used X clipboard syncer helper is disabled. The clipboard sync
autotest is changed to the new mechanism.

BUG: 394765
BUG: 395313

Test Plan: Manually and clipboard sync autotest.

Reviewers: #kwin

Subscribers: zzag, graesslin, kwin

Tags: #kwin

Differential Revision: https://phabricator.kde.org/D15061
parent 608a89a8
......@@ -651,13 +651,32 @@ install(TARGETS kwin ${INSTALL_TARGETS_DEFAULT_ARGS} LIBRARY NAMELIN
install(TARGETS kdeinit_kwin_x11 ${INSTALL_TARGETS_DEFAULT_ARGS} )
install(TARGETS kwin_x11 ${INSTALL_TARGETS_DEFAULT_ARGS} )
set(kwin_XWAYLAND_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/xwl/xwayland.cpp
${CMAKE_CURRENT_SOURCE_DIR}/xwl/databridge.cpp
${CMAKE_CURRENT_SOURCE_DIR}/xwl/selection.cpp
${CMAKE_CURRENT_SOURCE_DIR}/xwl/selection_source.cpp
${CMAKE_CURRENT_SOURCE_DIR}/xwl/transfer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/xwl/clipboard.cpp
)
include(ECMQtDeclareLoggingCategory)
ecm_qt_declare_logging_category(kwin_XWAYLAND_SRCS
HEADER
xwayland_logging.h
IDENTIFIER
KWIN_XWL
CATEGORY_NAME
kwin_xwl
DEFAULT_SEVERITY
Critical
)
set(kwin_WAYLAND_SRCS
tabletmodemanager.cpp
main_wayland.cpp
xwl/xwayland.cpp
)
add_executable(kwin_wayland ${kwin_WAYLAND_SRCS})
add_executable(kwin_wayland ${kwin_WAYLAND_SRCS} ${kwin_XWAYLAND_SRCS})
target_link_libraries(kwin_wayland kwin KF5::Crash)
if (HAVE_LIBCAP)
target_link_libraries(kwin_wayland ${Libcap_LIBRARIES})
......
......@@ -58,9 +58,17 @@ Atoms::Atoms()
, gtk_frame_extents(QByteArrayLiteral("_GTK_FRAME_EXTENTS"))
, kwin_dbus_service(QByteArrayLiteral("_ORG_KDE_KWIN_DBUS_SERVICE"))
, utf8_string(QByteArrayLiteral("UTF8_STRING"))
, text(QByteArrayLiteral("TEXT"))
, uri_list(QByteArrayLiteral("text/uri-list"))
, wl_surface_id(QByteArrayLiteral("WL_SURFACE_ID"))
, kde_net_wm_appmenu_service_name(QByteArrayLiteral("_KDE_NET_WM_APPMENU_SERVICE_NAME"))
, kde_net_wm_appmenu_object_path(QByteArrayLiteral("_KDE_NET_WM_APPMENU_OBJECT_PATH"))
, clipboard(QByteArrayLiteral("CLIPBOARD"))
, timestamp(QByteArrayLiteral("TIMESTAMP"))
, targets(QByteArrayLiteral("TARGETS"))
, delete_atom(QByteArrayLiteral("DELETE"))
, incr(QByteArrayLiteral("INCR"))
, wl_selection(QByteArrayLiteral("WL_SELECTION"))
, m_dtSmWindowInfo(QByteArrayLiteral("_DT_SM_WINDOW_INFO"))
, m_motifSupport(QByteArrayLiteral("_MOTIF_WM_INFO"))
, m_helpersRetrieved(false)
......
......@@ -67,9 +67,17 @@ public:
Xcb::Atom gtk_frame_extents;
Xcb::Atom kwin_dbus_service;
Xcb::Atom utf8_string;
Xcb::Atom text;
Xcb::Atom uri_list;
Xcb::Atom wl_surface_id;
Xcb::Atom kde_net_wm_appmenu_service_name;
Xcb::Atom kde_net_wm_appmenu_object_path;
Xcb::Atom clipboard;
Xcb::Atom timestamp;
Xcb::Atom targets;
Xcb::Atom delete_atom;
Xcb::Atom incr;
Xcb::Atom wl_selection;
/**
* @internal
......
add_subdirectory(helper)
add_library(KWinIntegrationTestFramework STATIC ../../xwl/xwayland.cpp kwin_wayland_test.cpp test_helpers.cpp)
add_library(KWinIntegrationTestFramework STATIC kwin_wayland_test.cpp test_helpers.cpp ${kwin_XWAYLAND_SRCS})
target_link_libraries(KWinIntegrationTestFramework kwin Qt5::Test)
function(integrationTest)
......
......@@ -83,6 +83,10 @@ WaylandTestApplication::~WaylandTestApplication()
if (effects) {
static_cast<EffectsHandlerImpl*>(effects)->unloadAllEffects();
}
if (m_xwayland) {
// needs to be done before workspace gets destroyed
m_xwayland->prepareDestroy();
}
destroyWorkspace();
waylandServer()->dispatch();
if (QStyle *s = style()) {
......
......@@ -23,6 +23,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "screens.h"
#include "wayland_server.h"
#include "workspace.h"
#include "../../xwl/databridge.h"
#include <KWayland/Server/datadevice_interface.h>
......@@ -67,11 +68,15 @@ void XClipboardSyncTest::initTestCase()
QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
waylandServer()->initWorkspace();
// wait till the xclipboard sync data device is created
if (clipboardSyncDevicedCreated.empty()) {
QVERIFY(clipboardSyncDevicedCreated.wait());
// // wait till the xclipboard sync data device is created
// if (clipboardSyncDevicedCreated.empty()) {
// QVERIFY(clipboardSyncDevicedCreated.wait());
// }
// wait till the DataBridge sync data device is created
while (Xwl::DataBridge::self()->dataDeviceIface() == nullptr) {
QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
}
QVERIFY(!waylandServer()->xclipboardSyncDataDevice().isNull());
QVERIFY(Xwl::DataBridge::self()->dataDeviceIface() != nullptr);
}
void XClipboardSyncTest::cleanup()
......@@ -93,8 +98,8 @@ void XClipboardSyncTest::testSync_data()
QTest::addColumn<QString>("copyPlatform");
QTest::addColumn<QString>("pastePlatform");
QTest::newRow("x11-wayland") << QStringLiteral("xcb") << QStringLiteral("wayland");
QTest::newRow("wayland-x11") << QStringLiteral("wayland") << QStringLiteral("xcb");
QTest::newRow("x11->wayland") << QStringLiteral("xcb") << QStringLiteral("wayland");
QTest::newRow("wayland->x11") << QStringLiteral("wayland") << QStringLiteral("xcb");
}
void XClipboardSyncTest::testSync()
......@@ -109,10 +114,12 @@ void XClipboardSyncTest::testSync()
QVERIFY(clientAddedSpy.isValid());
QSignalSpy shellClientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
QVERIFY(shellClientAddedSpy.isValid());
QSignalSpy clipboardChangedSpy(waylandServer()->xclipboardSyncDataDevice().data(), &KWayland::Server::DataDeviceInterface::selectionChanged);
QSignalSpy clipboardChangedSpy(Xwl::DataBridge::self()->dataDeviceIface(), &KWayland::Server::DataDeviceInterface::selectionChanged);
QVERIFY(clipboardChangedSpy.isValid());
QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
// start the copy process
QFETCH(QString, copyPlatform);
environment.insert(QStringLiteral("QT_QPA_PLATFORM"), copyPlatform);
environment.insert(QStringLiteral("WAYLAND_DISPLAY"), s_socketName);
......@@ -169,6 +176,7 @@ void XClipboardSyncTest::testSync()
QCOMPARE(clientAddedSpy.count(), 1);
QCOMPARE(shellClientAddedSpy.count(), 1);
QVERIFY(pasteClient);
if (workspace()->activeClient() != pasteClient) {
QSignalSpy clientActivatedSpy(workspace(), &Workspace::clientActivated);
QVERIFY(clientActivatedSpy.isValid());
......@@ -180,6 +188,8 @@ void XClipboardSyncTest::testSync()
QCOMPARE(finishedSpy.first().first().toInt(), 0);
delete m_pasteProcess;
m_pasteProcess = nullptr;
delete m_copyProcess;
m_copyProcess = nullptr;
}
WAYLANDTEST_MAIN(XClipboardSyncTest)
......
......@@ -128,6 +128,10 @@ ApplicationWayland::~ApplicationWayland()
if (effects) {
static_cast<EffectsHandlerImpl*>(effects)->unloadAllEffects();
}
if (m_xwayland) {
// needs to be done before workspace gets destroyed
m_xwayland->prepareDestroy();
}
destroyWorkspace();
waylandServer()->dispatch();
......
......@@ -30,6 +30,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <KWayland/Client/connection_thread.h>
#include <KWayland/Client/event_queue.h>
#include <KWayland/Client/registry.h>
#include <KWayland/Client/seat.h>
#include <KWayland/Client/datadevicemanager.h>
#include <KWayland/Client/shm_pool.h>
#include <KWayland/Client/surface.h>
// Server
......@@ -90,7 +92,7 @@ WaylandServer::WaylandServer(QObject *parent)
qRegisterMetaType<KWayland::Server::OutputInterface::DpmsMode>();
connect(kwinApp(), &Application::screensCreated, this, &WaylandServer::initOutputs);
connect(kwinApp(), &Application::x11ConnectionChanged, this, &WaylandServer::setupX11ClipboardSync);
// connect(kwinApp(), &Application::x11ConnectionChanged, this, &WaylandServer::setupX11ClipboardSync);
}
WaylandServer::~WaylandServer()
......@@ -112,6 +114,8 @@ void WaylandServer::destroyInternalConnection()
}
delete m_internalConnection.registry;
delete m_internalConnection.seat;
delete m_internalConnection.ddm;
delete m_internalConnection.shm;
dispatch();
m_internalConnection.client->deleteLater();
......@@ -254,9 +258,9 @@ bool WaylandServer::init(const QByteArray &socketName, InitalizationFlags flags)
m_seat->create();
m_display->createPointerGestures(PointerGesturesInterfaceVersion::UnstableV1, m_display)->create();
m_display->createPointerConstraints(PointerConstraintsInterfaceVersion::UnstableV1, m_display)->create();
auto ddm = m_display->createDataDeviceManager(m_display);
ddm->create();
connect(ddm, &DataDeviceManagerInterface::dataDeviceCreated, this,
m_dataDeviceManager = m_display->createDataDeviceManager(m_display);
m_dataDeviceManager->create();
connect(m_dataDeviceManager, &DataDeviceManagerInterface::dataDeviceCreated, this,
[this] (DataDeviceInterface *ddi) {
if (ddi->client() == m_xclipbaordSync.client && m_xclipbaordSync.client != nullptr) {
m_xclipbaordSync.ddi = QPointer<DataDeviceInterface>(ddi);
......@@ -639,8 +643,17 @@ void WaylandServer::createInternalConnection()
}
);
connect(registry, &Registry::interfacesAnnounced, this,
[this] {
[this, registry] {
m_internalConnection.interfacesAnnounced = true;
const auto seatInterface = registry->interface(Registry::Interface::Seat);
if (seatInterface.name != 0) {
m_internalConnection.seat = registry->createSeat(seatInterface.name, seatInterface.version, this);
}
const auto ddmInterface = registry->interface(Registry::Interface::DataDeviceManager);
if (ddmInterface.name != 0) {
m_internalConnection.ddm = registry->createDataDeviceManager(ddmInterface.name, ddmInterface.version, this);
}
}
);
registry->setup();
......
......@@ -35,6 +35,8 @@ namespace Client
{
class ConnectionThread;
class Registry;
class Seat;
class DataDeviceManager;
class ShmPool;
class Surface;
}
......@@ -48,6 +50,7 @@ class DataDeviceInterface;
class IdleInterface;
class ShellInterface;
class SeatInterface;
class DataDeviceManagerInterface;
class ServerSideDecorationManagerInterface;
class ServerSideDecorationPaletteManagerInterface;
class SurfaceInterface;
......@@ -99,6 +102,9 @@ public:
KWayland::Server::SeatInterface *seat() {
return m_seat;
}
KWayland::Server::DataDeviceManagerInterface *dataDeviceManager() {
return m_dataDeviceManager;
}
KWayland::Server::ShellInterface *shell() {
return m_shell;
}
......@@ -178,6 +184,12 @@ public:
QPointer<KWayland::Server::DataDeviceInterface> xclipboardSyncDataDevice() const {
return m_xclipbaordSync.ddi;
}
KWayland::Client::Seat *internalSeat() {
return m_internalConnection.seat;
}
KWayland::Client::DataDeviceManager *internalDataDeviceManager() {
return m_internalConnection.ddm;
}
KWayland::Client::ShmPool *internalShmPool() {
return m_internalConnection.shm;
}
......@@ -233,6 +245,7 @@ private:
KWayland::Server::Display *m_display = nullptr;
KWayland::Server::CompositorInterface *m_compositor = nullptr;
KWayland::Server::SeatInterface *m_seat = nullptr;
KWayland::Server::DataDeviceManagerInterface *m_dataDeviceManager = nullptr;
KWayland::Server::ShellInterface *m_shell = nullptr;
KWayland::Server::XdgShellInterface *m_xdgShell5 = nullptr;
KWayland::Server::XdgShellInterface *m_xdgShell6 = nullptr;
......@@ -258,6 +271,8 @@ private:
KWayland::Client::ConnectionThread *client = nullptr;
QThread *clientThread = nullptr;
KWayland::Client::Registry *registry = nullptr;
KWayland::Client::Seat *seat = nullptr;
KWayland::Client::DataDeviceManager *ddm = nullptr;
KWayland::Client::ShmPool *shm = nullptr;
bool interfacesAnnounced = false;
......
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright 2019 Roman Gilg <subdiff@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "clipboard.h"
#include "xwayland.h"
#include "databridge.h"
#include "selection_source.h"
#include "transfer.h"
#include "wayland_server.h"
#include "workspace.h"
#include "abstract_client.h"
#include <KWayland/Client/connection_thread.h>
#include <KWayland/Client/datadevice.h>
#include <KWayland/Client/datasource.h>
#include <KWayland/Server/seat_interface.h>
#include <KWayland/Server/datadevice_interface.h>
#include <KWayland/Server/datasource_interface.h>
#include <xcb/xcb_event.h>
#include <xcb/xfixes.h>
#include <xwayland_logging.h>
namespace KWin {
namespace Xwl {
Clipboard::Clipboard(xcb_atom_t atom, QObject *parent)
: Selection(atom, parent)
{
auto *xcbConn = kwinApp()->x11Connection();
const uint32_t clipboardValues[] = { XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
XCB_EVENT_MASK_PROPERTY_CHANGE };
xcb_create_window(xcbConn,
XCB_COPY_FROM_PARENT,
window(),
kwinApp()->x11RootWindow(),
0, 0,
10, 10,
0,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
Xwayland::self()->xcbScreen()->root_visual,
XCB_CW_EVENT_MASK,
clipboardValues);
registerXfixes();
xcb_flush(xcbConn);
connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::selectionChanged,
this, &Clipboard::wlSelectionChanged);
}
void Clipboard::wlSelectionChanged(KWayland::Server::DataDeviceInterface *ddi)
{
if (ddi && ddi != DataBridge::self()->dataDeviceIface()) {
// Wayland native client provides new selection
if (!m_checkConnection) {
m_checkConnection = connect(workspace(), &Workspace::clientActivated,
this, [this](AbstractClient *ac) {
Q_UNUSED(ac);
checkWlSource();
});
}
// remove previous source so checkWlSource() can create a new one
setWlSource(nullptr);
}
checkWlSource();
}
void Clipboard::checkWlSource()
{
auto ddi = waylandServer()->seat()->selection();
auto removeSource = [this] {
if (wlSource()) {
setWlSource(nullptr);
ownSelection(false);
}
};
// Wayland source gets created when:
// - the Wl selection exists,
// - its source is not Xwayland,
// - a client is active,
// - this client is an Xwayland one.
//
// Otherwise the Wayland source gets destroyed to shield
// against snooping X clients.
if (!ddi || DataBridge::self()->dataDeviceIface() == ddi) {
// Xwayland source or no source
disconnect(m_checkConnection);
m_checkConnection = QMetaObject::Connection();
removeSource();
return;
}
if (!workspace()->activeClient() || !workspace()->activeClient()->inherits("KWin::Client")) {
// no active client or active client is Wayland native
removeSource();
return;
}
// Xwayland client is active and we need a Wayland source
if (wlSource()) {
// source already exists, nothing more to do
return;
}
auto *wls = new WlSource(this, ddi);
setWlSource(wls);
auto *dsi = ddi->selection();
if (dsi) {
wls->setDataSourceIface(dsi);
}
connect(ddi, &KWayland::Server::DataDeviceInterface::selectionChanged,
wls, &WlSource::setDataSourceIface);
ownSelection(true);
}
void Clipboard::doHandleXfixesNotify(xcb_xfixes_selection_notify_event_t *event)
{
createX11Source(event);
auto *xSrc = x11Source();
if (xSrc) {
xSrc->getTargets();
}
}
void Clipboard::x11OffersChanged(const QVector<QString> &added, const QVector<QString> &removed)
{
auto *xSrc = x11Source();
if (!xSrc) {
return;
}
const auto offers = xSrc->offers();
const bool hasOffers = offers.size() > 0;
if (hasOffers) {
if (!xSrc->dataSource() || !removed.isEmpty()) {
// create new Wl DataSource if there is none or when types
// were removed (Wl Data Sources can only add types)
auto *ddm = waylandServer()->internalDataDeviceManager();
auto *ds = ddm->createDataSource(xSrc);
// also offers directly the currently available types
xSrc->setDataSource(ds);
DataBridge::self()->dataDevice()->setSelection(0, ds);
waylandServer()->seat()->setSelection(DataBridge::self()->dataDeviceIface());
} else if (auto *ds = xSrc->dataSource()) {
for (const auto &mime : added) {
ds->offer(mime);
}
}
} else {
waylandServer()->seat()->setSelection(nullptr);
}
waylandServer()->internalClientConection()->flush();
waylandServer()->dispatch();
}
}
}
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright 2019 Roman Gilg <subdiff@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#ifndef KWIN_XWL_CLIPBOARD
#define KWIN_XWL_CLIPBOARD
#include "selection.h"
namespace KWayland
{
namespace Server
{
class DataDeviceInterface;
}
}
namespace KWin
{
namespace Xwl
{
/**
* Represents the X clipboard, which is on Wayland side just called
* @e selection.
*/
class Clipboard : public Selection
{
Q_OBJECT
public:
Clipboard(xcb_atom_t atom, QObject *parent);
private:
void doHandleXfixesNotify(xcb_xfixes_selection_notify_event_t *event) override;
void x11OffersChanged(const QVector<QString> &added, const QVector<QString> &removed) override;
/**
* React to Wl selection change.
*/
void wlSelectionChanged(KWayland::Server::DataDeviceInterface *ddi);
/**
* Check the current state of the selection and if a source needs
* to be created or destroyed.
*/
void checkWlSource();
QMetaObject::Connection m_checkConnection;
};
}
}
#endif
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright 2018 Roman Gilg <subdiff@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "databridge.h"
#include "xwayland.h"
#include "selection.h"
#include "clipboard.h"
#include "atoms.h"
#include "wayland_server.h"
#include "workspace.h"
#include "abstract_client.h"
// KWayland
#include <KWayland/Client/seat.h>
#include <KWayland/Client/datadevicemanager.h>
#include <KWayland/Server/seat_interface.h>
#include <KWayland/Server/datadevicemanager_interface.h>
#include <KWayland/Server/datadevice_interface.h>
namespace KWin {
namespace Xwl {
static DataBridge *s_self = nullptr;
DataBridge* DataBridge::self()
{
return s_self;
}
DataBridge::DataBridge(QObject *parent)
: QObject(parent)
{
s_self = this;
auto *ddm = waylandServer()->internalDataDeviceManager();
auto *seat = waylandServer()->internalSeat();
m_dd = ddm->getDataDevice(seat, this);
waylandServer()->dispatch();
const auto *ddmi = waylandServer()->dataDeviceManager();
auto *dc = new QMetaObject::Connection();
*dc = connect(ddmi, &KWayland::Server::DataDeviceManagerInterface::dataDeviceCreated, this,
[this, dc](KWayland::Server::DataDeviceInterface *ddi) {
if (m_ddi || ddi->client() != waylandServer()->internalConnection()) {
return;
}
QObject::disconnect(*dc);
delete dc;
m_ddi = ddi;
init();
}
);
}
DataBridge::~DataBridge()
{
s_self = nullptr;
}
void DataBridge::init()
{
m_clipboard = new Clipboard(atoms->clipboard, this);
waylandServer()->dispatch();
}
bool DataBridge::filterEvent(xcb_generic_event_t *event)
{
if (m_clipboard->filterEvent(event)) {
return true;
}
if (event->response_type - Xwayland::self()->xfixes()->first_event == XCB_XFIXES_SELECTION_NOTIFY) {
return handleXfixesNotify((xcb_xfixes_selection_notify_event_t *)event);
}
return false;
}
bool DataBridge::handleXfixesNotify(xcb_xfixes_selection_notify_event_t *event)
{
auto getSelection = [this](xcb_atom_t atom) -> Selection* {
if (atom == atoms->clipboard) {
return m_clipboard;
}
return nullptr;
};
auto *sel = getSelection(event->selection);
return sel && sel->handleXfixesNotify(event);
}
}
}
/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright 2018 Roman Gilg <subdiff@gmail.com>