2015-02-09 15:28:37 +03:00
|
|
|
/********************************************************************
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
|
|
|
|
|
|
|
Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
|
|
|
|
|
|
|
|
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 "wayland_server.h"
|
2015-06-16 07:50:22 +03:00
|
|
|
#include "client.h"
|
2016-04-07 10:24:17 +03:00
|
|
|
#include "platform.h"
|
2015-03-04 11:21:10 +03:00
|
|
|
#include "composite.h"
|
2015-02-20 16:54:21 +03:00
|
|
|
#include "screens.h"
|
2015-03-04 11:21:10 +03:00
|
|
|
#include "shell_client.h"
|
2015-02-09 18:08:53 +03:00
|
|
|
#include "workspace.h"
|
2015-02-09 15:28:37 +03:00
|
|
|
|
2015-04-02 15:37:23 +03:00
|
|
|
// Client
|
|
|
|
#include <KWayland/Client/connection_thread.h>
|
2015-08-17 10:42:12 +03:00
|
|
|
#include <KWayland/Client/event_queue.h>
|
2015-04-02 15:37:23 +03:00
|
|
|
#include <KWayland/Client/registry.h>
|
2015-11-10 13:35:00 +03:00
|
|
|
#include <KWayland/Client/shm_pool.h>
|
2015-05-18 12:23:45 +03:00
|
|
|
#include <KWayland/Client/surface.h>
|
2015-04-02 15:37:23 +03:00
|
|
|
// Server
|
2015-02-09 15:28:37 +03:00
|
|
|
#include <KWayland/Server/compositor_interface.h>
|
2015-04-30 10:22:31 +03:00
|
|
|
#include <KWayland/Server/datadevicemanager_interface.h>
|
2015-02-09 15:28:37 +03:00
|
|
|
#include <KWayland/Server/display.h>
|
2015-09-01 12:30:30 +03:00
|
|
|
#include <KWayland/Server/dpms_interface.h>
|
2015-07-02 14:21:30 +03:00
|
|
|
#include <KWayland/Server/idle_interface.h>
|
2015-02-09 15:28:37 +03:00
|
|
|
#include <KWayland/Server/output_interface.h>
|
2015-06-09 20:10:56 +03:00
|
|
|
#include <KWayland/Server/plasmashell_interface.h>
|
2015-06-13 02:48:11 +03:00
|
|
|
#include <KWayland/Server/plasmawindowmanagement_interface.h>
|
2016-11-25 09:17:43 +03:00
|
|
|
#include <KWayland/Server/pointerconstraints_interface.h>
|
2016-10-27 10:10:08 +03:00
|
|
|
#include <KWayland/Server/pointergestures_interface.h>
|
2015-06-10 01:59:53 +03:00
|
|
|
#include <KWayland/Server/qtsurfaceextension_interface.h>
|
2015-02-25 11:35:42 +03:00
|
|
|
#include <KWayland/Server/seat_interface.h>
|
2015-12-17 13:14:54 +03:00
|
|
|
#include <KWayland/Server/server_decoration_interface.h>
|
2015-07-15 12:24:19 +03:00
|
|
|
#include <KWayland/Server/shadow_interface.h>
|
2016-03-21 18:44:07 +03:00
|
|
|
#include <KWayland/Server/subcompositor_interface.h>
|
2015-08-31 16:47:01 +03:00
|
|
|
#include <KWayland/Server/blur_interface.h>
|
2015-02-09 15:28:37 +03:00
|
|
|
#include <KWayland/Server/shell_interface.h>
|
2016-03-10 21:57:07 +03:00
|
|
|
#include <KWayland/Server/outputmanagement_interface.h>
|
|
|
|
#include <KWayland/Server/outputconfiguration_interface.h>
|
2016-04-22 15:13:37 +03:00
|
|
|
#include <KWayland/Server/xdgshell_interface.h>
|
2015-02-09 15:28:37 +03:00
|
|
|
|
2015-05-18 12:23:45 +03:00
|
|
|
// Qt
|
2015-08-17 10:42:12 +03:00
|
|
|
#include <QThread>
|
2015-05-18 12:23:45 +03:00
|
|
|
#include <QWindow>
|
|
|
|
|
2015-02-25 16:15:32 +03:00
|
|
|
// system
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/socket.h>
|
2016-06-20 12:21:16 +03:00
|
|
|
#include <unistd.h>
|
2015-02-25 16:15:32 +03:00
|
|
|
|
2015-11-05 16:09:23 +03:00
|
|
|
//screenlocker
|
|
|
|
#include <KScreenLocker/KsldApp>
|
|
|
|
|
2015-02-09 15:28:37 +03:00
|
|
|
using namespace KWayland::Server;
|
|
|
|
|
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
|
|
|
|
KWIN_SINGLETON_FACTORY(WaylandServer)
|
|
|
|
|
|
|
|
WaylandServer::WaylandServer(QObject *parent)
|
|
|
|
: QObject(parent)
|
|
|
|
{
|
2015-09-01 12:30:30 +03:00
|
|
|
qRegisterMetaType<KWayland::Server::OutputInterface::DpmsMode>();
|
2016-04-25 10:45:04 +03:00
|
|
|
|
|
|
|
connect(kwinApp(), &Application::screensCreated, this, &WaylandServer::initOutputs);
|
2016-06-20 12:21:16 +03:00
|
|
|
connect(kwinApp(), &Application::x11ConnectionChanged, this, &WaylandServer::setupX11ClipboardSync);
|
2015-02-09 15:28:37 +03:00
|
|
|
}
|
|
|
|
|
2015-11-10 16:38:45 +03:00
|
|
|
WaylandServer::~WaylandServer()
|
|
|
|
{
|
|
|
|
destroyInputMethodConnection();
|
|
|
|
}
|
2015-11-10 10:52:40 +03:00
|
|
|
|
|
|
|
void WaylandServer::destroyInternalConnection()
|
2015-08-17 10:42:12 +03:00
|
|
|
{
|
2016-02-02 14:00:12 +03:00
|
|
|
emit terminatingInternalClientConnection();
|
2015-08-17 10:42:12 +03:00
|
|
|
if (m_internalConnection.client) {
|
2015-11-10 13:35:00 +03:00
|
|
|
delete m_internalConnection.registry;
|
|
|
|
delete m_internalConnection.shm;
|
2015-10-22 11:07:02 +03:00
|
|
|
dispatch();
|
2015-08-17 10:42:12 +03:00
|
|
|
m_internalConnection.client->deleteLater();
|
|
|
|
m_internalConnection.clientThread->quit();
|
|
|
|
m_internalConnection.clientThread->wait();
|
2015-11-10 13:43:30 +03:00
|
|
|
delete m_internalConnection.clientThread;
|
2015-11-10 10:52:40 +03:00
|
|
|
m_internalConnection.client = nullptr;
|
2015-11-10 16:27:43 +03:00
|
|
|
m_internalConnection.server->destroy();
|
2016-06-14 17:42:52 +03:00
|
|
|
m_internalConnection.server = nullptr;
|
2015-08-17 10:42:12 +03:00
|
|
|
}
|
|
|
|
}
|
2015-02-09 15:28:37 +03:00
|
|
|
|
2015-11-18 12:29:10 +03:00
|
|
|
void WaylandServer::terminateClientConnections()
|
|
|
|
{
|
|
|
|
destroyInternalConnection();
|
|
|
|
destroyInputMethodConnection();
|
2016-04-26 13:47:02 +03:00
|
|
|
if (m_display) {
|
|
|
|
const auto connections = m_display->connections();
|
|
|
|
for (auto it = connections.begin(); it != connections.end(); ++it) {
|
|
|
|
(*it)->destroy();
|
|
|
|
}
|
2015-11-18 12:29:10 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-22 15:13:37 +03:00
|
|
|
template <class T>
|
|
|
|
void WaylandServer::createSurface(T *surface)
|
|
|
|
{
|
|
|
|
if (!Workspace::self()) {
|
|
|
|
// it's possible that a Surface gets created before Workspace is created
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (surface->client() == m_xwayland.client) {
|
|
|
|
// skip Xwayland clients, those are created using standard X11 way
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (surface->client() == m_screenLockerClientConnection) {
|
|
|
|
ScreenLocker::KSldApp::self()->lockScreenShown();
|
|
|
|
}
|
|
|
|
auto client = new ShellClient(surface);
|
2017-02-07 21:18:18 +03:00
|
|
|
auto it = std::find_if(m_plasmaShellSurfaces.begin(), m_plasmaShellSurfaces.end(),
|
|
|
|
[client] (PlasmaShellSurfaceInterface *surface) {
|
|
|
|
return client->surface() == surface->surface();
|
|
|
|
}
|
|
|
|
);
|
|
|
|
if (it != m_plasmaShellSurfaces.end()) {
|
|
|
|
client->installPlasmaShellSurface(*it);
|
|
|
|
m_plasmaShellSurfaces.erase(it);
|
|
|
|
}
|
2016-04-22 15:13:37 +03:00
|
|
|
if (client->isInternal()) {
|
|
|
|
m_internalClients << client;
|
|
|
|
} else {
|
|
|
|
m_clients << client;
|
|
|
|
}
|
|
|
|
if (client->readyForPainting()) {
|
|
|
|
emit shellClientAdded(client);
|
|
|
|
} else {
|
|
|
|
connect(client, &ShellClient::windowShown, this, &WaylandServer::shellClientShown);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-04 10:09:03 +03:00
|
|
|
bool WaylandServer::init(const QByteArray &socketName, InitalizationFlags flags)
|
2015-02-09 15:28:37 +03:00
|
|
|
{
|
2015-11-05 16:09:23 +03:00
|
|
|
m_initFlags = flags;
|
2015-02-09 15:28:37 +03:00
|
|
|
m_display = new KWayland::Server::Display(this);
|
|
|
|
if (!socketName.isNull() && !socketName.isEmpty()) {
|
|
|
|
m_display->setSocketName(QString::fromUtf8(socketName));
|
|
|
|
}
|
|
|
|
m_display->start();
|
2016-07-04 10:09:03 +03:00
|
|
|
if (!m_display->isRunning()) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-02-09 15:28:37 +03:00
|
|
|
m_compositor = m_display->createCompositor(m_display);
|
|
|
|
m_compositor->create();
|
2015-02-09 18:08:53 +03:00
|
|
|
connect(m_compositor, &CompositorInterface::surfaceCreated, this,
|
|
|
|
[this] (SurfaceInterface *surface) {
|
|
|
|
// check whether we have a Toplevel with the Surface's id
|
|
|
|
Workspace *ws = Workspace::self();
|
|
|
|
if (!ws) {
|
|
|
|
// it's possible that a Surface gets created before Workspace is created
|
|
|
|
return;
|
|
|
|
}
|
2015-04-30 10:23:27 +03:00
|
|
|
if (surface->client() != xWaylandConnection()) {
|
|
|
|
// setting surface is only relevat for Xwayland clients
|
|
|
|
return;
|
|
|
|
}
|
2015-02-09 18:08:53 +03:00
|
|
|
auto check = [surface] (const Toplevel *t) {
|
|
|
|
return t->surfaceId() == surface->id();
|
|
|
|
};
|
|
|
|
if (Toplevel *t = ws->findToplevel(check)) {
|
|
|
|
t->setSurface(surface);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
2015-02-09 15:28:37 +03:00
|
|
|
m_shell = m_display->createShell(m_display);
|
|
|
|
m_shell->create();
|
2016-04-22 15:13:37 +03:00
|
|
|
connect(m_shell, &ShellInterface::surfaceCreated, this, &WaylandServer::createSurface<ShellSurfaceInterface>);
|
|
|
|
m_xdgShell = m_display->createXdgShell(XdgShellInterfaceVersion::UnstableV5, m_display);
|
|
|
|
m_xdgShell->create();
|
|
|
|
connect(m_xdgShell, &XdgShellInterface::surfaceCreated, this, &WaylandServer::createSurface<XdgShellSurfaceInterface>);
|
|
|
|
// TODO: verify seat and serial
|
|
|
|
connect(m_xdgShell, &XdgShellInterface::popupCreated, this, &WaylandServer::createSurface<XdgShellPopupInterface>);
|
2015-02-09 15:28:37 +03:00
|
|
|
m_display->createShm();
|
2015-02-25 11:35:42 +03:00
|
|
|
m_seat = m_display->createSeat(m_display);
|
|
|
|
m_seat->create();
|
2016-10-27 10:10:08 +03:00
|
|
|
m_display->createPointerGestures(PointerGesturesInterfaceVersion::UnstableV1, m_display)->create();
|
2016-11-25 09:17:43 +03:00
|
|
|
m_display->createPointerConstraints(PointerConstraintsInterfaceVersion::UnstableV1, m_display)->create();
|
2016-06-20 12:21:16 +03:00
|
|
|
auto ddm = m_display->createDataDeviceManager(m_display);
|
|
|
|
ddm->create();
|
|
|
|
connect(ddm, &DataDeviceManagerInterface::dataDeviceCreated, this,
|
|
|
|
[this] (DataDeviceInterface *ddi) {
|
|
|
|
if (ddi->client() == m_xclipbaordSync.client && m_xclipbaordSync.client != nullptr) {
|
|
|
|
m_xclipbaordSync.ddi = QPointer<DataDeviceInterface>(ddi);
|
|
|
|
connect(m_xclipbaordSync.ddi.data(), &DataDeviceInterface::selectionChanged, this,
|
|
|
|
[this] {
|
|
|
|
// testing whether the active client inherits Client
|
|
|
|
// it would be better to test for the keyboard focus, but we might get a clipboard update
|
|
|
|
// when the Client is already active, but no Surface is created yet.
|
|
|
|
if (workspace()->activeClient() && workspace()->activeClient()->inherits("KWin::Client")) {
|
|
|
|
m_seat->setSelection(m_xclipbaordSync.ddi.data());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
2015-07-02 14:21:30 +03:00
|
|
|
m_display->createIdle(m_display)->create();
|
2015-06-09 20:10:56 +03:00
|
|
|
m_plasmaShell = m_display->createPlasmaShell(m_display);
|
|
|
|
m_plasmaShell->create();
|
|
|
|
connect(m_plasmaShell, &PlasmaShellInterface::surfaceCreated,
|
|
|
|
[this] (PlasmaShellSurfaceInterface *surface) {
|
|
|
|
if (ShellClient *client = findClient(surface->surface())) {
|
|
|
|
client->installPlasmaShellSurface(surface);
|
2017-02-07 21:18:18 +03:00
|
|
|
} else {
|
|
|
|
m_plasmaShellSurfaces << surface;
|
|
|
|
connect(surface, &QObject::destroyed, this,
|
|
|
|
[this, surface] {
|
|
|
|
m_plasmaShellSurfaces.removeOne(surface);
|
|
|
|
}
|
|
|
|
);
|
2015-06-09 20:10:56 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
2015-06-10 01:59:53 +03:00
|
|
|
m_qtExtendedSurface = m_display->createQtSurfaceExtension(m_display);
|
|
|
|
m_qtExtendedSurface->create();
|
|
|
|
connect(m_qtExtendedSurface, &QtSurfaceExtensionInterface::surfaceCreated,
|
|
|
|
[this] (QtExtendedSurfaceInterface *surface) {
|
|
|
|
if (ShellClient *client = findClient(surface->surface())) {
|
|
|
|
client->installQtExtendedSurface(surface);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
2015-06-13 02:48:11 +03:00
|
|
|
m_windowManagement = m_display->createPlasmaWindowManagement(m_display);
|
|
|
|
m_windowManagement->create();
|
|
|
|
m_windowManagement->setShowingDesktopState(PlasmaWindowManagementInterface::ShowingDesktopState::Disabled);
|
|
|
|
connect(m_windowManagement, &PlasmaWindowManagementInterface::requestChangeShowingDesktop, this,
|
|
|
|
[] (PlasmaWindowManagementInterface::ShowingDesktopState state) {
|
|
|
|
if (!workspace()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
bool set = false;
|
|
|
|
switch (state) {
|
|
|
|
case PlasmaWindowManagementInterface::ShowingDesktopState::Disabled:
|
|
|
|
set = false;
|
|
|
|
break;
|
|
|
|
case PlasmaWindowManagementInterface::ShowingDesktopState::Enabled:
|
|
|
|
set = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
Q_UNREACHABLE();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (set == workspace()->showingDesktop()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
workspace()->setShowingDesktop(set);
|
|
|
|
}
|
|
|
|
);
|
2015-07-15 12:24:19 +03:00
|
|
|
auto shadowManager = m_display->createShadowManager(m_display);
|
|
|
|
shadowManager->create();
|
2015-09-01 12:30:30 +03:00
|
|
|
|
|
|
|
m_display->createDpmsManager(m_display)->create();
|
2015-12-17 13:14:54 +03:00
|
|
|
|
|
|
|
m_decorationManager = m_display->createServerSideDecorationManager(m_display);
|
|
|
|
connect(m_decorationManager, &ServerSideDecorationManagerInterface::decorationCreated, this,
|
|
|
|
[this] (ServerSideDecorationInterface *deco) {
|
|
|
|
if (ShellClient *c = findClient(deco->surface())) {
|
|
|
|
c->installServerSideDecoration(deco);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
|
|
|
m_decorationManager->create();
|
2016-03-10 21:57:07 +03:00
|
|
|
|
|
|
|
m_outputManagement = m_display->createOutputManagement(m_display);
|
|
|
|
connect(m_outputManagement, &OutputManagementInterface::configurationChangeRequested,
|
|
|
|
this, [this](KWayland::Server::OutputConfigurationInterface *config) {
|
2016-04-06 18:30:00 +03:00
|
|
|
kwinApp()->platform()->configurationChangeRequested(config);
|
2016-03-10 21:57:07 +03:00
|
|
|
});
|
2016-04-27 22:03:47 +03:00
|
|
|
m_outputManagement->create();
|
2016-03-21 18:44:07 +03:00
|
|
|
|
|
|
|
m_display->createSubCompositor(m_display)->create();
|
2016-07-04 10:09:03 +03:00
|
|
|
|
|
|
|
return true;
|
2015-06-13 02:48:11 +03:00
|
|
|
}
|
|
|
|
|
2016-06-07 12:43:56 +03:00
|
|
|
void WaylandServer::shellClientShown(Toplevel *t)
|
|
|
|
{
|
|
|
|
ShellClient *c = dynamic_cast<ShellClient*>(t);
|
|
|
|
if (!c) {
|
|
|
|
qCWarning(KWIN_CORE) << "Failed to cast a Toplevel which is supposed to be a ShellClient to ShellClient";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
disconnect(c, &ShellClient::windowShown, this, &WaylandServer::shellClientShown);
|
|
|
|
emit shellClientAdded(c);
|
|
|
|
}
|
|
|
|
|
2015-06-13 02:48:11 +03:00
|
|
|
void WaylandServer::initWorkspace()
|
|
|
|
{
|
|
|
|
if (m_windowManagement) {
|
|
|
|
connect(workspace(), &Workspace::showingDesktopChanged, this,
|
|
|
|
[this] (bool set) {
|
|
|
|
using namespace KWayland::Server;
|
|
|
|
m_windowManagement->setShowingDesktopState(set ?
|
|
|
|
PlasmaWindowManagementInterface::ShowingDesktopState::Enabled :
|
|
|
|
PlasmaWindowManagementInterface::ShowingDesktopState::Disabled
|
|
|
|
);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
2015-11-06 14:21:34 +03:00
|
|
|
|
2016-04-25 09:51:33 +03:00
|
|
|
if (hasScreenLockerIntegration()) {
|
|
|
|
ScreenLocker::KSldApp::self();
|
|
|
|
ScreenLocker::KSldApp::self()->setWaylandDisplay(m_display);
|
|
|
|
ScreenLocker::KSldApp::self()->setGreeterEnvironment(kwinApp()->processStartupEnvironment());
|
|
|
|
ScreenLocker::KSldApp::self()->initialize();
|
|
|
|
|
|
|
|
connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::greeterClientConnectionChanged, this,
|
|
|
|
[this] () {
|
|
|
|
m_screenLockerClientConnection = ScreenLocker::KSldApp::self()->greeterClientConnection();
|
|
|
|
}
|
|
|
|
);
|
2015-11-06 17:08:13 +03:00
|
|
|
|
2016-04-25 09:51:33 +03:00
|
|
|
connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::unlocked, this,
|
|
|
|
[this] () {
|
|
|
|
m_screenLockerClientConnection = nullptr;
|
|
|
|
}
|
|
|
|
);
|
2015-11-06 17:08:13 +03:00
|
|
|
|
2016-04-25 09:51:33 +03:00
|
|
|
if (m_initFlags.testFlag(InitalizationFlag::LockScreen)) {
|
|
|
|
ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate);
|
|
|
|
}
|
2015-11-05 16:09:23 +03:00
|
|
|
}
|
2016-08-16 10:26:17 +03:00
|
|
|
emit initialized();
|
2015-02-20 16:54:21 +03:00
|
|
|
}
|
2015-02-09 15:28:37 +03:00
|
|
|
|
2015-02-20 16:54:21 +03:00
|
|
|
void WaylandServer::initOutputs()
|
|
|
|
{
|
2016-04-06 18:30:00 +03:00
|
|
|
if (kwinApp()->platform()->handlesOutputs()) {
|
2015-04-24 13:00:19 +03:00
|
|
|
return;
|
|
|
|
}
|
2016-07-20 12:42:52 +03:00
|
|
|
syncOutputsToWayland();
|
|
|
|
connect(screens(), &Screens::changed, this,
|
|
|
|
[this] {
|
|
|
|
// when screens change we need to sync this to Wayland.
|
|
|
|
// Unfortunately we don't have much information and cannot properly match a KWin screen
|
|
|
|
// to a Wayland screen.
|
|
|
|
// Thus we just recreate all outputs and delete the old ones
|
|
|
|
const auto outputs = m_display->outputs();
|
|
|
|
syncOutputsToWayland();
|
|
|
|
qDeleteAll(outputs);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandServer::syncOutputsToWayland()
|
|
|
|
{
|
2015-02-20 16:54:21 +03:00
|
|
|
Screens *s = screens();
|
|
|
|
Q_ASSERT(s);
|
|
|
|
for (int i = 0; i < s->count(); ++i) {
|
|
|
|
OutputInterface *output = m_display->createOutput(m_display);
|
2016-10-26 02:36:02 +03:00
|
|
|
output->setScale(s->scale(i));
|
2015-11-25 15:01:36 +03:00
|
|
|
const QRect &geo = s->geometry(i);
|
|
|
|
output->setGlobalPosition(geo.topLeft());
|
|
|
|
output->setPhysicalSize(geo.size() / 3.8);
|
|
|
|
output->addMode(geo.size());
|
2015-02-20 16:54:21 +03:00
|
|
|
output->create();
|
|
|
|
}
|
2015-02-09 15:28:37 +03:00
|
|
|
}
|
|
|
|
|
2016-12-03 16:54:32 +03:00
|
|
|
WaylandServer::SocketPairConnection WaylandServer::createConnection()
|
2015-02-25 16:15:32 +03:00
|
|
|
{
|
2016-12-03 16:54:32 +03:00
|
|
|
SocketPairConnection ret;
|
2015-02-25 16:15:32 +03:00
|
|
|
int sx[2];
|
|
|
|
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sx) < 0) {
|
|
|
|
qCWarning(KWIN_CORE) << "Could not create socket";
|
2016-12-03 16:54:32 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ret.connection = m_display->createClient(sx[0]);
|
|
|
|
ret.fd = sx[1];
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int WaylandServer::createXWaylandConnection()
|
|
|
|
{
|
|
|
|
const auto socket = createConnection();
|
|
|
|
if (!socket.connection) {
|
2015-02-25 16:15:32 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2016-12-03 16:54:32 +03:00
|
|
|
m_xwayland.client = socket.connection;
|
2015-11-10 16:21:48 +03:00
|
|
|
m_xwayland.destroyConnection = connect(m_xwayland.client, &KWayland::Server::ClientConnection::disconnected, this,
|
2015-04-21 10:21:49 +03:00
|
|
|
[] {
|
|
|
|
qFatal("Xwayland Connection died");
|
|
|
|
}
|
|
|
|
);
|
2016-12-03 16:54:32 +03:00
|
|
|
return socket.fd;
|
2015-02-25 16:15:32 +03:00
|
|
|
}
|
|
|
|
|
2015-11-10 16:21:48 +03:00
|
|
|
void WaylandServer::destroyXWaylandConnection()
|
|
|
|
{
|
|
|
|
if (!m_xwayland.client) {
|
|
|
|
return;
|
|
|
|
}
|
2016-06-20 12:21:16 +03:00
|
|
|
// first terminate the clipboard sync
|
|
|
|
if (m_xclipbaordSync.process) {
|
|
|
|
m_xclipbaordSync.process->terminate();
|
|
|
|
}
|
2015-11-10 16:21:48 +03:00
|
|
|
disconnect(m_xwayland.destroyConnection);
|
|
|
|
m_xwayland.client->destroy();
|
|
|
|
m_xwayland.client = nullptr;
|
|
|
|
}
|
|
|
|
|
2015-06-13 05:06:12 +03:00
|
|
|
int WaylandServer::createInputMethodConnection()
|
|
|
|
{
|
2016-12-03 16:54:32 +03:00
|
|
|
const auto socket = createConnection();
|
|
|
|
if (!socket.connection) {
|
2015-06-13 05:06:12 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2016-12-03 16:54:32 +03:00
|
|
|
m_inputMethodServerConnection = socket.connection;
|
|
|
|
return socket.fd;
|
2015-06-13 05:06:12 +03:00
|
|
|
}
|
|
|
|
|
2015-11-10 16:38:45 +03:00
|
|
|
void WaylandServer::destroyInputMethodConnection()
|
|
|
|
{
|
|
|
|
if (!m_inputMethodServerConnection) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_inputMethodServerConnection->destroy();
|
|
|
|
m_inputMethodServerConnection = nullptr;
|
|
|
|
}
|
|
|
|
|
2016-06-20 12:21:16 +03:00
|
|
|
int WaylandServer::createXclipboardSyncConnection()
|
|
|
|
{
|
2016-12-03 16:54:32 +03:00
|
|
|
const auto socket = createConnection();
|
|
|
|
if (!socket.connection) {
|
2016-06-20 12:21:16 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2016-12-03 16:54:32 +03:00
|
|
|
m_xclipbaordSync.client = socket.connection;
|
|
|
|
return socket.fd;
|
2016-06-20 12:21:16 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandServer::setupX11ClipboardSync()
|
|
|
|
{
|
|
|
|
if (m_xclipbaordSync.process) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int socket = dup(createXclipboardSyncConnection());
|
|
|
|
if (socket == -1) {
|
|
|
|
delete m_xclipbaordSync.client;
|
|
|
|
m_xclipbaordSync.client = nullptr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (socket >= 0) {
|
|
|
|
QProcessEnvironment environment = kwinApp()->processStartupEnvironment();
|
|
|
|
environment.insert(QStringLiteral("WAYLAND_SOCKET"), QByteArray::number(socket));
|
|
|
|
environment.insert(QStringLiteral("DISPLAY"), QString::fromUtf8(qgetenv("DISPLAY")));
|
|
|
|
environment.remove("WAYLAND_DISPLAY");
|
|
|
|
m_xclipbaordSync.process = new Process(this);
|
|
|
|
m_xclipbaordSync.process->setProcessChannelMode(QProcess::ForwardedErrorChannel);
|
|
|
|
auto finishedSignal = static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished);
|
|
|
|
connect(m_xclipbaordSync.process, finishedSignal, this,
|
|
|
|
[this] {
|
|
|
|
m_xclipbaordSync.process->deleteLater();
|
|
|
|
m_xclipbaordSync.process = nullptr;
|
|
|
|
m_xclipbaordSync.ddi.clear();
|
|
|
|
m_xclipbaordSync.client->destroy();
|
|
|
|
m_xclipbaordSync.client = nullptr;
|
|
|
|
// TODO: restart
|
|
|
|
}
|
|
|
|
);
|
|
|
|
m_xclipbaordSync.process->setProcessEnvironment(environment);
|
|
|
|
m_xclipbaordSync.process->start(QStringLiteral(KWIN_XCLIPBOARD_SYNC_BIN));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-02 15:37:23 +03:00
|
|
|
void WaylandServer::createInternalConnection()
|
|
|
|
{
|
2016-12-03 16:54:32 +03:00
|
|
|
const auto socket = createConnection();
|
|
|
|
if (!socket.connection) {
|
2015-04-02 15:37:23 +03:00
|
|
|
return;
|
|
|
|
}
|
2016-12-03 16:54:32 +03:00
|
|
|
m_internalConnection.server = socket.connection;
|
2015-04-02 15:37:23 +03:00
|
|
|
using namespace KWayland::Client;
|
2015-08-17 10:42:12 +03:00
|
|
|
m_internalConnection.client = new ConnectionThread();
|
2016-12-03 16:54:32 +03:00
|
|
|
m_internalConnection.client->setSocketFd(socket.fd);
|
2015-08-17 10:42:12 +03:00
|
|
|
m_internalConnection.clientThread = new QThread;
|
|
|
|
m_internalConnection.client->moveToThread(m_internalConnection.clientThread);
|
|
|
|
m_internalConnection.clientThread->start();
|
|
|
|
|
2015-04-02 15:37:23 +03:00
|
|
|
connect(m_internalConnection.client, &ConnectionThread::connected, this,
|
|
|
|
[this] {
|
2015-08-17 10:42:12 +03:00
|
|
|
Registry *registry = new Registry(this);
|
|
|
|
EventQueue *eventQueue = new EventQueue(this);
|
|
|
|
eventQueue->setup(m_internalConnection.client);
|
|
|
|
registry->setEventQueue(eventQueue);
|
2015-04-02 15:37:23 +03:00
|
|
|
registry->create(m_internalConnection.client);
|
2015-08-14 10:28:46 +03:00
|
|
|
m_internalConnection.registry = registry;
|
2015-04-02 15:37:23 +03:00
|
|
|
connect(registry, &Registry::shmAnnounced, this,
|
2015-08-14 10:28:46 +03:00
|
|
|
[this] (quint32 name, quint32 version) {
|
2015-08-17 10:42:12 +03:00
|
|
|
m_internalConnection.shm = m_internalConnection.registry->createShmPool(name, version, this);
|
2015-04-02 15:37:23 +03:00
|
|
|
}
|
|
|
|
);
|
|
|
|
registry->setup();
|
|
|
|
}
|
|
|
|
);
|
|
|
|
m_internalConnection.client->initConnection();
|
|
|
|
}
|
|
|
|
|
2015-03-04 11:21:10 +03:00
|
|
|
void WaylandServer::removeClient(ShellClient *c)
|
|
|
|
{
|
|
|
|
m_clients.removeAll(c);
|
2015-05-21 11:35:03 +03:00
|
|
|
m_internalClients.removeAll(c);
|
2015-03-04 11:21:10 +03:00
|
|
|
emit shellClientRemoved(c);
|
|
|
|
}
|
|
|
|
|
2015-05-18 12:33:00 +03:00
|
|
|
void WaylandServer::dispatch()
|
|
|
|
{
|
|
|
|
if (!m_display) {
|
|
|
|
return;
|
|
|
|
}
|
2015-08-18 09:15:00 +03:00
|
|
|
if (m_internalConnection.server) {
|
|
|
|
m_internalConnection.server->flush();
|
2015-05-18 12:33:00 +03:00
|
|
|
}
|
|
|
|
m_display->dispatchEvents(0);
|
|
|
|
}
|
|
|
|
|
2015-05-21 11:35:03 +03:00
|
|
|
static ShellClient *findClientInList(const QList<ShellClient*> &clients, quint32 id)
|
2015-05-18 15:51:40 +03:00
|
|
|
{
|
2015-05-21 11:35:03 +03:00
|
|
|
auto it = std::find_if(clients.begin(), clients.end(),
|
2015-05-18 15:51:40 +03:00
|
|
|
[id] (ShellClient *c) {
|
|
|
|
return c->windowId() == id;
|
|
|
|
}
|
|
|
|
);
|
2015-05-21 11:35:03 +03:00
|
|
|
if (it == clients.end()) {
|
2015-05-18 15:51:40 +03:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return *it;
|
|
|
|
}
|
|
|
|
|
2015-06-09 20:10:56 +03:00
|
|
|
static ShellClient *findClientInList(const QList<ShellClient*> &clients, KWayland::Server::SurfaceInterface *surface)
|
|
|
|
{
|
|
|
|
auto it = std::find_if(clients.begin(), clients.end(),
|
|
|
|
[surface] (ShellClient *c) {
|
|
|
|
return c->surface() == surface;
|
|
|
|
}
|
|
|
|
);
|
|
|
|
if (it == clients.end()) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return *it;
|
|
|
|
}
|
|
|
|
|
2015-05-21 11:35:03 +03:00
|
|
|
ShellClient *WaylandServer::findClient(quint32 id) const
|
|
|
|
{
|
|
|
|
if (id == 0) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
if (ShellClient *c = findClientInList(m_clients, id)) {
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
if (ShellClient *c = findClientInList(m_internalClients, id)) {
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2015-06-09 20:10:56 +03:00
|
|
|
ShellClient *WaylandServer::findClient(SurfaceInterface *surface) const
|
|
|
|
{
|
|
|
|
if (!surface) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
if (ShellClient *c = findClientInList(m_clients, surface)) {
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
if (ShellClient *c = findClientInList(m_internalClients, surface)) {
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-08-22 17:55:48 +03:00
|
|
|
AbstractClient *WaylandServer::findAbstractClient(SurfaceInterface *surface) const
|
|
|
|
{
|
|
|
|
return findClient(surface);
|
|
|
|
}
|
|
|
|
|
2015-08-17 15:56:15 +03:00
|
|
|
ShellClient *WaylandServer::findClient(QWindow *w) const
|
|
|
|
{
|
|
|
|
if (!w) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
auto it = std::find_if(m_internalClients.constBegin(), m_internalClients.constEnd(),
|
|
|
|
[w] (const ShellClient *c) {
|
|
|
|
return c->internalWindow() == w;
|
|
|
|
}
|
|
|
|
);
|
|
|
|
if (it != m_internalClients.constEnd()) {
|
|
|
|
return *it;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2015-05-21 10:59:45 +03:00
|
|
|
quint32 WaylandServer::createWindowId(SurfaceInterface *surface)
|
|
|
|
{
|
|
|
|
auto it = m_clientIds.constFind(surface->client());
|
|
|
|
quint16 clientId = 0;
|
|
|
|
if (it != m_clientIds.constEnd()) {
|
|
|
|
clientId = it.value();
|
|
|
|
} else {
|
|
|
|
clientId = createClientId(surface->client());
|
|
|
|
}
|
|
|
|
Q_ASSERT(clientId != 0);
|
|
|
|
quint32 id = clientId;
|
|
|
|
// TODO: this does not prevent that two surfaces of same client get same id
|
|
|
|
id = (id << 16) | (surface->id() & 0xFFFF);
|
|
|
|
if (findClient(id)) {
|
|
|
|
qCWarning(KWIN_CORE) << "Invalid client windowId generated:" << id;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
quint16 WaylandServer::createClientId(ClientConnection *c)
|
|
|
|
{
|
|
|
|
auto ids = m_clientIds.values().toSet();
|
|
|
|
quint16 id = 1;
|
|
|
|
if (!ids.isEmpty()) {
|
|
|
|
for (quint16 i = ids.count() + 1; i >= 1 ; i--) {
|
|
|
|
if (!ids.contains(i)) {
|
|
|
|
id = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Q_ASSERT(!ids.contains(id));
|
|
|
|
m_clientIds.insert(c, id);
|
|
|
|
connect(c, &ClientConnection::disconnected, this,
|
|
|
|
[this] (ClientConnection *c) {
|
|
|
|
m_clientIds.remove(c);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2015-11-16 13:19:38 +03:00
|
|
|
bool WaylandServer::isScreenLocked() const
|
|
|
|
{
|
2016-04-25 09:51:33 +03:00
|
|
|
if (!hasScreenLockerIntegration()) {
|
|
|
|
return false;
|
|
|
|
}
|
2016-02-02 12:19:46 +03:00
|
|
|
return ScreenLocker::KSldApp::self()->lockState() == ScreenLocker::KSldApp::Locked ||
|
|
|
|
ScreenLocker::KSldApp::self()->lockState() == ScreenLocker::KSldApp::AcquiringLock;
|
2015-11-16 13:19:38 +03:00
|
|
|
}
|
|
|
|
|
2016-04-25 09:51:33 +03:00
|
|
|
bool WaylandServer::hasScreenLockerIntegration() const
|
|
|
|
{
|
|
|
|
return !m_initFlags.testFlag(InitalizationFlag::NoLockScreenIntegration);
|
|
|
|
}
|
|
|
|
|
2015-02-09 15:28:37 +03:00
|
|
|
}
|