Hello community,
here is the log from the commit of package kwayland-integration for
openSUSE:Factory checked in at 2016-01-03 13:25:53
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/kwayland-integration (Old)
and /work/SRC/openSUSE:Factory/.kwayland-integration.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "kwayland-integration"
Changes:
--------
---
/work/SRC/openSUSE:Factory/kwayland-integration/kwayland-integration.changes
2015-11-24 22:27:01.000000000 +0100
+++
/work/SRC/openSUSE:Factory/.kwayland-integration.new/kwayland-integration.changes
2016-01-03 13:26:11.000000000 +0100
@@ -1,0 +2,24 @@
+Tue Dec 22 22:35:09 UTC 2015 - hrvoje.sen...@gmail.com
+
+- Update to 5.5.2:
+ * Bugfix release
+ * For more details please see:
+ https://www.kde.org/announcements/plasma-5.5.2.php
+
+-------------------------------------------------------------------
+Tue Dec 15 17:49:54 UTC 2015 - hrvoje.sen...@gmail.com
+
+- Update to 5.5.1:
+ * Bugfix release
+ * For more details please see:
+ https://www.kde.org/announcements/plasma-5.5.1.php
+
+-------------------------------------------------------------------
+Sat Dec 12 17:31:54 UTC 2015 - hrvoje.sen...@gmail.com
+
+- Update to 5.5.0:
+ * For more details please see:
+ https://dot.kde.org/2015/12/08/plasma-55-beautiful-new-artwork
+- Move to cmake(...) BuildRequires where possible
+
+-------------------------------------------------------------------
Old:
----
kwayland-integration-5.4.3.tar.xz
New:
----
kwayland-integration-5.5.2.tar.xz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ kwayland-integration.spec ++++++
--- /var/tmp/diff_new_pack.0mFGxF/_old 2016-01-03 13:26:12.000000000 +0100
+++ /var/tmp/diff_new_pack.0mFGxF/_new 2016-01-03 13:26:12.000000000 +0100
@@ -17,7 +17,7 @@
Name: kwayland-integration
-Version: 5.4.3
+Version: 5.5.2
Release: 0
Summary: Integration plugins for various KDE frameworks for wayland
windowing system
License: LGPL-2.1+
@@ -25,13 +25,12 @@
Url: http://www.kde.org
Source: %{name}-%{version}.tar.xz
BuildRequires: cmake >= 2.8.12
-BuildRequires: extra-cmake-modules >= 1.4.0
+BuildRequires: extra-cmake-modules >= 0.0.11
BuildRequires: kf5-filesystem
-BuildRequires: kidletime-devel
-BuildRequires: kwayland-devel
-BuildRequires: kwindowsystem-devel
-BuildRequires: pkgconfig(Qt5Core) >= 5.4.0
-BuildRequires: pkgconfig(Qt5Gui) >= 5.4.0
+BuildRequires: cmake(KF5IdleTime) >= 5.12.0
+BuildRequires: cmake(KF5Wayland) >= %{version}
+BuildRequires: cmake(KF5WindowSystem) >= 5.12.0
+BuildRequires: cmake(Qt5Core) >= 5.4.0
BuildRoot: %{_tmppath}/%{name}-%{version}-build
%description
++++++ kwayland-integration-5.4.3.tar.xz -> kwayland-integration-5.5.2.tar.xz
++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/kwayland-integration-5.4.3/CMakeLists.txt
new/kwayland-integration-5.5.2/CMakeLists.txt
--- old/kwayland-integration-5.4.3/CMakeLists.txt 2015-11-05
13:39:23.000000000 +0100
+++ new/kwayland-integration-5.5.2/CMakeLists.txt 2015-12-22
11:36:10.000000000 +0100
@@ -1,5 +1,5 @@
project(kwayland-integration)
-set(PROJECT_VERSION "5.4.3")
+set(PROJECT_VERSION "5.5.2")
set(PROJECT_VERSION_MAJOR 5)
cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/CMakeLists.txt
new/kwayland-integration-5.5.2/src/windowsystem/CMakeLists.txt
--- old/kwayland-integration-5.4.3/src/windowsystem/CMakeLists.txt
2015-11-05 13:39:23.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/CMakeLists.txt
2015-12-22 11:36:10.000000000 +0100
@@ -1,7 +1,10 @@
set(wayland_plugin_SRCS
logging.cpp
plugin.cpp
+ waylandintegration.cpp
+ windoweffects.cpp
windowsystem.cpp
+ windowinfo.cpp
)
add_library(KF5WindowSystemKWaylandPlugin MODULE ${wayland_plugin_SRCS})
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/plugin.cpp
new/kwayland-integration-5.5.2/src/windowsystem/plugin.cpp
--- old/kwayland-integration-5.4.3/src/windowsystem/plugin.cpp 2015-11-05
13:39:23.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/plugin.cpp 2015-12-22
11:36:10.000000000 +0100
@@ -19,6 +19,8 @@
*/
#include "plugin.h"
#include "windowsystem.h"
+#include "windoweffects.h"
+#include "windowinfo.h"
KWaylandPlugin::KWaylandPlugin(QObject *parent)
: KWindowSystemPluginInterface(parent)
@@ -29,7 +31,17 @@
{
}
+KWindowEffectsPrivate *KWaylandPlugin::createEffects()
+{
+ return new WindowEffects();
+}
+
KWindowSystemPrivate *KWaylandPlugin::createWindowSystem()
{
return new WindowSystem();
}
+
+KWindowInfoPrivate *KWaylandPlugin::createWindowInfo(WId window,
NET::Properties properties, NET::Properties2 properties2)
+{
+ return new WindowInfo(window, properties, properties2);
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/kwayland-integration-5.4.3/src/windowsystem/plugin.h
new/kwayland-integration-5.5.2/src/windowsystem/plugin.h
--- old/kwayland-integration-5.4.3/src/windowsystem/plugin.h 2015-11-05
13:39:23.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/plugin.h 2015-12-22
11:36:10.000000000 +0100
@@ -32,7 +32,9 @@
explicit KWaylandPlugin(QObject *parent = 0);
virtual ~KWaylandPlugin();
+ KWindowEffectsPrivate *createEffects() override;
KWindowSystemPrivate *createWindowSystem() override;
+ KWindowInfoPrivate *createWindowInfo(WId window, NET::Properties
properties, NET::Properties2 properties2) override;
};
#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/waylandintegration.cpp
new/kwayland-integration-5.5.2/src/windowsystem/waylandintegration.cpp
--- old/kwayland-integration-5.4.3/src/windowsystem/waylandintegration.cpp
1970-01-01 01:00:00.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/waylandintegration.cpp
2015-12-22 11:36:10.000000000 +0100
@@ -0,0 +1,206 @@
+/*
+ * Copyright 2014 Martin Gräßlin <mgraess...@kde.org>
+ * Copyright 2015 Marco Martin <m...@kde.org>
+ *
+ * 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.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * 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/>.
+ */
+
+#include "waylandintegration.h"
+#include "logging.h"
+
+#include <KWayland/Client/connection_thread.h>
+#include <KWayland/Client/registry.h>
+#include <KWayland/Client/compositor.h>
+#include <KWayland/Client/plasmawindowmanagement.h>
+#include <KWayland/Client/surface.h>
+#include <KWayland/Client/blur.h>
+#include <KWayland/Client/contrast.h>
+#include <KWayland/Client/region.h>
+#include <KWayland/Client/slide.h>
+#include <KWayland/Client/shell.h>
+
+#include <KWindowSystem/KWindowSystem>
+
+class WaylandIntegrationSingleton
+{
+public:
+ WaylandIntegration self;
+};
+
+Q_GLOBAL_STATIC(WaylandIntegrationSingleton, privateWaylandIntegrationSelf)
+
+WaylandIntegration::WaylandIntegration()
+ : QObject()
+{
+ setupKWaylandIntegration();
+}
+
+WaylandIntegration::~WaylandIntegration()
+{}
+
+void WaylandIntegration::setupKWaylandIntegration()
+{
+ using namespace KWayland::Client;
+ m_waylandConnection = ConnectionThread::fromApplication(this);
+ if (!m_waylandConnection) {
+ qCWarning(KWAYLAND_KWS) << "Failed getting Wayland connection from
QPA";
+ return;
+ }
+ m_registry = new Registry(this);
+ m_registry->create(m_waylandConnection);
+ m_waylandCompositor = Compositor::fromApplication(this);
+
+ m_registry->setup();
+ m_waylandConnection->roundtrip();
+}
+
+WaylandIntegration *WaylandIntegration::self()
+{
+ return &privateWaylandIntegrationSelf()->self;
+}
+
+
+KWayland::Client::ConnectionThread *WaylandIntegration::waylandConnection()
const
+{
+ return m_waylandConnection;
+}
+
+KWayland::Client::BlurManager *WaylandIntegration::waylandBlurManager()
+{
+ if (!m_waylandBlurManager) {
+ const KWayland::Client::Registry::AnnouncedInterface wmInterface =
m_registry->interface(KWayland::Client::Registry::Interface::Blur);
+
+ if (wmInterface.name == 0) {
+ return nullptr;
+ }
+
+ m_waylandBlurManager = m_registry->createBlurManager(wmInterface.name,
wmInterface.version, this);
+
+ connect(m_waylandBlurManager, &KWayland::Client::BlurManager::removed,
this,
+ [this] () {
+ m_waylandBlurManager->deleteLater();
+ m_waylandBlurManager = nullptr;
+ }
+ );
+ }
+
+ return m_waylandBlurManager;
+}
+
+KWayland::Client::ContrastManager *WaylandIntegration::waylandContrastManager()
+{
+ if (!m_waylandContrastManager) {
+ const KWayland::Client::Registry::AnnouncedInterface wmInterface =
m_registry->interface(KWayland::Client::Registry::Interface::Contrast);
+
+ if (wmInterface.name == 0) {
+ return nullptr;
+ }
+
+ m_waylandContrastManager =
m_registry->createContrastManager(wmInterface.name, wmInterface.version, this);
+
+ connect(m_waylandContrastManager,
&KWayland::Client::ContrastManager::removed, this,
+ [this] () {
+ m_waylandContrastManager->deleteLater();
+ m_waylandContrastManager = nullptr;
+ }
+ );
+ }
+
+ return m_waylandContrastManager;
+}
+
+KWayland::Client::SlideManager *WaylandIntegration::waylandSlideManager()
+{
+ if (!m_waylandSlideManager) {
+ const KWayland::Client::Registry::AnnouncedInterface wmInterface =
m_registry->interface(KWayland::Client::Registry::Interface::Slide);
+
+ if (wmInterface.name == 0) {
+ return nullptr;
+ }
+
+ m_waylandSlideManager =
m_registry->createSlideManager(wmInterface.name, wmInterface.version, this);
+
+ connect(m_waylandSlideManager,
&KWayland::Client::SlideManager::removed, this,
+ [this] () {
+ m_waylandSlideManager->deleteLater();
+ m_waylandSlideManager = nullptr;
+ }
+ );
+ }
+
+ return m_waylandSlideManager;
+}
+
+KWayland::Client::Compositor *WaylandIntegration::waylandCompositor() const
+{
+ return m_waylandCompositor;
+}
+
+KWayland::Client::PlasmaWindowManagement
*WaylandIntegration::plasmaWindowManagement()
+{
+ using namespace KWayland::Client;
+
+ if (!m_wm) {
+ const Registry::AnnouncedInterface wmInterface =
m_registry->interface(Registry::Interface::PlasmaWindowManagement);
+
+ if (wmInterface.name == 0) {
+ qCWarning(KWAYLAND_KWS) << "This compositor does not support the
Plasma Window Management interface";
+ return nullptr;
+ }
+
+ m_wm = m_registry->createPlasmaWindowManagement(wmInterface.name,
wmInterface.version, this);
+ connect(m_wm, &PlasmaWindowManagement::windowCreated, this,
+ [this] (PlasmaWindow *w) {
+ emit KWindowSystem::self()->windowAdded(w->internalId());
+ emit KWindowSystem::self()->stackingOrderChanged();
+ connect(w, &PlasmaWindow::unmapped, this,
+ [w] {
+ emit
KWindowSystem::self()->windowRemoved(w->internalId());
+ emit KWindowSystem::self()->stackingOrderChanged();
+ }
+ );
+ }
+ );
+ connect(m_wm, &PlasmaWindowManagement::activeWindowChanged, this,
+ [this] {
+ if (PlasmaWindow *w = m_wm->activeWindow()) {
+ emit
KWindowSystem::self()->activeWindowChanged(w->internalId());
+ } else {
+ emit KWindowSystem::self()->activeWindowChanged(0);
+ }
+ }
+ );
+ connect(m_wm, &PlasmaWindowManagement::showingDesktopChanged,
KWindowSystem::self(), &KWindowSystem::showingDesktopChanged);
+ qCDebug(KWAYLAND_KWS) << "Plasma Window Management interface bound";
+ }
+
+ return m_wm;
+}
+
+KWayland::Client::PlasmaShell *WaylandIntegration::waylandPlasmaShell()
+{
+ if (!m_waylandPlasmaShell) {
+ const KWayland::Client::Registry::AnnouncedInterface wmInterface =
m_registry->interface(KWayland::Client::Registry::Interface::PlasmaShell);
+
+ if (wmInterface.name == 0) {
+ return nullptr;
+ }
+
+ m_waylandPlasmaShell = m_registry->createPlasmaShell(wmInterface.name,
wmInterface.version, this);
+ }
+ return m_waylandPlasmaShell;
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/waylandintegration.h
new/kwayland-integration-5.5.2/src/windowsystem/waylandintegration.h
--- old/kwayland-integration-5.4.3/src/windowsystem/waylandintegration.h
1970-01-01 01:00:00.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/waylandintegration.h
2015-12-22 11:36:10.000000000 +0100
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2014 Martin Gräßlin <mgraess...@kde.org>
+ * Copyright 2015 Marco Martin <m...@kde.org>
+ *
+ * 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.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * 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/>.
+ */
+#ifndef WAYLANDINTEGRATION_H
+#define WAYLANDINTEGRATION_H
+#include <KWindowSystem/private/kwindoweffects_p.h>
+
+
+namespace KWayland
+{
+ namespace Client
+ {
+ class BlurManager;
+ class ContrastManager;
+ class Compositor;
+ class ConnectionThread;
+ class PlasmaWindowManagement;
+ class PlasmaShell;
+ class Registry;
+ class SlideManager;
+ }
+}
+
+class WaylandIntegration : public QObject
+{
+public:
+ explicit WaylandIntegration();
+ ~WaylandIntegration();
+ void setupKWaylandIntegration();
+
+ static WaylandIntegration *self();
+
+ KWayland::Client::ConnectionThread *waylandConnection() const;
+ KWayland::Client::BlurManager *waylandBlurManager();
+ KWayland::Client::ContrastManager *waylandContrastManager();
+ KWayland::Client::SlideManager *waylandSlideManager();
+ KWayland::Client::Compositor *waylandCompositor() const;
+ KWayland::Client::PlasmaWindowManagement *plasmaWindowManagement();
+ KWayland::Client::PlasmaShell *waylandPlasmaShell();
+
+private:
+ KWayland::Client::ConnectionThread *m_waylandConnection = nullptr;
+ KWayland::Client::BlurManager *m_waylandBlurManager = nullptr;
+ KWayland::Client::ContrastManager *m_waylandContrastManager = nullptr;
+ KWayland::Client::SlideManager *m_waylandSlideManager = nullptr;
+ KWayland::Client::Compositor *m_waylandCompositor = nullptr;
+ KWayland::Client::PlasmaWindowManagement *m_wm = nullptr;
+ KWayland::Client::PlasmaShell *m_waylandPlasmaShell = nullptr;
+ KWayland::Client::Registry *m_registry = nullptr;
+};
+
+#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/windoweffects.cpp
new/kwayland-integration-5.5.2/src/windowsystem/windoweffects.cpp
--- old/kwayland-integration-5.4.3/src/windowsystem/windoweffects.cpp
1970-01-01 01:00:00.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/windoweffects.cpp
2015-12-22 11:36:10.000000000 +0100
@@ -0,0 +1,176 @@
+/*
+ * Copyright 2014 Martin Gräßlin <mgraess...@kde.org>
+ * Copyright 2015 Marco Martin <m...@kde.org>
+ *
+ * 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.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * 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/>.
+ */
+
+#include "windoweffects.h"
+#include "waylandintegration.h"
+
+#include <QDebug>
+
+#include <KWayland/Client/connection_thread.h>
+#include <KWayland/Client/plasmawindowmanagement.h>
+#include <KWayland/Client/registry.h>
+#include <KWayland/Client/plasmashell.h>
+#include <KWayland/Client/compositor.h>
+#include <KWayland/Client/surface.h>
+#include <KWayland/Client/blur.h>
+#include <KWayland/Client/contrast.h>
+#include <KWayland/Client/region.h>
+#include <KWayland/Client/slide.h>
+
+WindowEffects::WindowEffects()
+ : QObject(),
+ KWindowEffectsPrivate()
+{
+}
+
+WindowEffects::~WindowEffects()
+{}
+
+bool WindowEffects::isEffectAvailable(KWindowEffects::Effect effect)
+{
+ switch (effect) {
+ case KWindowEffects::BackgroundContrast:
+ return WaylandIntegration::self()->waylandContrastManager() != nullptr;
+ case KWindowEffects::BlurBehind:
+ return WaylandIntegration::self()->waylandBlurManager() != nullptr;
+ default:
+ return false;
+ }
+}
+
+void WindowEffects::slideWindow(WId id, KWindowEffects::SlideFromLocation
location, int offset)
+{
+ if (!WaylandIntegration::self()->waylandSlideManager()) {
+ return;
+ }
+ KWayland::Client::Surface *surface =
KWayland::Client::Surface::fromQtWinId(id);
+ if (surface) {
+ if (location != KWindowEffects::SlideFromLocation::NoEdge) {
+ auto slide =
WaylandIntegration::self()->waylandSlideManager()->createSlide(surface,
surface);
+
+ KWayland::Client::Slide::Location convertedLoc;
+ switch (location) {
+ case KWindowEffects::SlideFromLocation::TopEdge:
+ convertedLoc = KWayland::Client::Slide::Location::Top;
+ break;
+ case KWindowEffects::SlideFromLocation::LeftEdge:
+ convertedLoc = KWayland::Client::Slide::Location::Left;
+ break;
+ case KWindowEffects::SlideFromLocation::RightEdge:
+ convertedLoc = KWayland::Client::Slide::Location::Right;
+ break;
+ case KWindowEffects::SlideFromLocation::BottomEdge:
+ default:
+ convertedLoc = KWayland::Client::Slide::Location::Bottom;
+ break;
+ }
+
+ slide->setLocation(convertedLoc);
+ slide->setOffset(offset);
+ slide->commit();
+ } else {
+
WaylandIntegration::self()->waylandSlideManager()->removeSlide(surface);
+ }
+ surface->commit(KWayland::Client::Surface::CommitFlag::None);
+
+ WaylandIntegration::self()->waylandConnection()->flush();
+ }
+}
+
+void WindowEffects::slideWindow(QWidget *widget,
KWindowEffects::SlideFromLocation location)
+{
+ slideWindow(widget->winId(), location, 0);
+}
+
+QList<QSize> WindowEffects::windowSizes(const QList<WId> &ids)
+{
+ Q_UNUSED(ids)
+ QList<QSize> sizes;
+ return sizes;
+}
+
+void WindowEffects::presentWindows(WId controller, const QList<WId> &ids)
+{
+ Q_UNUSED(controller)
+ Q_UNUSED(ids)
+}
+
+void WindowEffects::presentWindows(WId controller, int desktop)
+{
+ Q_UNUSED(controller)
+ Q_UNUSED(desktop)
+}
+
+void WindowEffects::highlightWindows(WId controller, const QList<WId> &ids)
+{
+ Q_UNUSED(controller)
+ Q_UNUSED(ids)
+}
+
+void WindowEffects::enableBlurBehind(WId window, bool enable, const QRegion
®ion)
+{
+ if (!WaylandIntegration::self()->waylandBlurManager()) {
+ return;
+ }
+ KWayland::Client::Surface *surface =
KWayland::Client::Surface::fromQtWinId(window);
+ if (surface) {
+ if (enable) {
+ auto blur =
WaylandIntegration::self()->waylandBlurManager()->createBlur(surface, surface);
+
blur->setRegion(WaylandIntegration::self()->waylandCompositor()->createRegion(region,
nullptr));
+ blur->commit();
+ } else {
+
WaylandIntegration::self()->waylandBlurManager()->removeBlur(surface);
+ }
+ surface->commit(KWayland::Client::Surface::CommitFlag::None);
+
+ WaylandIntegration::self()->waylandConnection()->flush();
+ }
+}
+
+void WindowEffects::enableBackgroundContrast(WId window, bool enable, qreal
contrast, qreal intensity, qreal saturation, const QRegion ®ion)
+{
+ if (!WaylandIntegration::self()->waylandContrastManager()) {
+ return;
+ }
+ KWayland::Client::Surface *surface =
KWayland::Client::Surface::fromQtWinId(window);
+ if (surface) {
+ if (enable) {
+ auto backgroundContrast =
WaylandIntegration::self()->waylandContrastManager()->createContrast(surface,
surface);
+
backgroundContrast->setRegion(WaylandIntegration::self()->waylandCompositor()->createRegion(region,
nullptr));
+ backgroundContrast->setContrast(contrast);
+ backgroundContrast->setIntensity(intensity);
+ backgroundContrast->setSaturation(saturation);
+ backgroundContrast->commit();
+ } else {
+
WaylandIntegration::self()->waylandContrastManager()->removeContrast(surface);
+ }
+ surface->commit(KWayland::Client::Surface::CommitFlag::None);
+
+ WaylandIntegration::self()->waylandConnection()->flush();
+ }
+}
+
+void WindowEffects::markAsDashboard(WId window)
+{
+ Q_UNUSED(window)
+}
+
+
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/windoweffects.h
new/kwayland-integration-5.5.2/src/windowsystem/windoweffects.h
--- old/kwayland-integration-5.4.3/src/windowsystem/windoweffects.h
1970-01-01 01:00:00.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/windoweffects.h
2015-12-22 11:36:10.000000000 +0100
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2014 Martin Gräßlin <mgraess...@kde.org>
+ * Copyright 2015 Marco Martin <m...@kde.org>
+ *
+ * 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.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * 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/>.
+ */
+#ifndef WINDOWEFFECTS_H
+#define WINDOWEFFECTS_H
+#include <KWindowSystem/private/kwindoweffects_p.h>
+
+
+namespace KWayland
+{
+ namespace Client
+ {
+ class BlurManager;
+ class ContrastManager;
+ class Compositor;
+ class ConnectionThread;
+ }
+}
+
+class WindowEffects : public QObject, public KWindowEffectsPrivate
+{
+public:
+ explicit WindowEffects();
+ ~WindowEffects();
+
+ bool isEffectAvailable(KWindowEffects::Effect effect) override;
+ void slideWindow(WId id, KWindowEffects::SlideFromLocation location, int
offset) override;
+ void slideWindow(QWidget *widget, KWindowEffects::SlideFromLocation
location) override;
+ QList<QSize> windowSizes(const QList<WId> &ids) override;
+ void presentWindows(WId controller, const QList<WId> &ids) override;
+ void presentWindows(WId controller, int desktop = NET::OnAllDesktops)
override;
+ void highlightWindows(WId controller, const QList<WId> &ids) override;
+ void enableBlurBehind(WId window, bool enable = true, const QRegion
®ion = QRegion()) override;
+ void enableBackgroundContrast(WId window, bool enable = true, qreal
contrast = 1, qreal intensity = 1, qreal saturation = 1, const QRegion ®ion
= QRegion()) override;
+ void markAsDashboard(WId window) override;
+};
+
+#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/windowinfo.cpp
new/kwayland-integration-5.5.2/src/windowsystem/windowinfo.cpp
--- old/kwayland-integration-5.4.3/src/windowsystem/windowinfo.cpp
1970-01-01 01:00:00.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/windowinfo.cpp
2015-12-22 11:36:10.000000000 +0100
@@ -0,0 +1,208 @@
+/*
+ This file is part of the KDE libraries
+ Copyright (C) 1999 Matthias Ettrich (ettr...@kde.org)
+ Copyright (C) 2007 Lubos Lunak (l.lu...@kde.org)
+ Copyright 2014 Martin Gräßlin <mgraess...@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "windowinfo.h"
+#include "kwindowsystem.h"
+#include "waylandintegration.h"
+
+#include <config-kwindowsystem.h>
+
+#include <QRect>
+#include <QGuiApplication>
+
+#include <KWayland/Client/plasmashell.h>
+#include <KWayland/Client/surface.h>
+
+
+WindowInfo::WindowInfo(WId window, NET::Properties properties,
NET::Properties2 properties2)
+ : KWindowInfoPrivate(window, properties, properties2),
+ m_valid(false),
+ m_properties(properties),
+ m_properties2(properties2),
+ m_surface(KWayland::Client::Surface::fromQtWinId(window)),
+
m_plasmaShellSurface(KWayland::Client::PlasmaShellSurface::get(m_surface))
+{
+ m_valid = m_surface != nullptr && m_surface->isValid();
+}
+
+WindowInfo::~WindowInfo()
+{
+}
+
+bool WindowInfo::valid(bool withdrawn_is_valid) const
+{
+ Q_UNUSED(withdrawn_is_valid)
+ return m_valid;
+}
+
+NET::States WindowInfo::state() const
+{
+ return 0;
+}
+
+bool WindowInfo::isMinimized() const
+{
+ return false;
+}
+
+NET::MappingState WindowInfo::mappingState() const
+{
+ return NET::Visible;
+}
+
+NETExtendedStrut WindowInfo::extendedStrut() const
+{
+ return NETExtendedStrut();
+}
+
+NET::WindowType WindowInfo::windowType(NET::WindowTypes supported_types) const
+{
+ if (!m_plasmaShellSurface || !m_plasmaShellSurface->isValid()) {
+ return NET::Unknown;
+ }
+
+ if (m_properties & NET::WMWindowType) {
+ switch (m_plasmaShellSurface->role()) {
+ case KWayland::Client::PlasmaShellSurface::Role::Normal:
+ if (supported_types & NET::NormalMask) {
+ return NET::Normal;
+ }
+ break;
+ case KWayland::Client::PlasmaShellSurface::Role::Desktop:
+ if (supported_types & NET::DesktopMask) {
+ return NET::Desktop;
+ }
+ break;
+ case KWayland::Client::PlasmaShellSurface::Role::Panel:
+ if (supported_types & NET::DockMask) {
+ return NET::Dock;
+ }
+ break;
+ case KWayland::Client::PlasmaShellSurface::Role::OnScreenDisplay:
+ if (supported_types & NET::OnScreenDisplayMask) {
+ return NET::OnScreenDisplay;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ return NET::Unknown;
+}
+
+QString WindowInfo::visibleName() const
+{
+ return QString();
+}
+
+QString WindowInfo::visibleNameWithState() const
+{
+ return QString();
+}
+
+QString WindowInfo::name() const
+{
+ return QString();
+}
+
+QString WindowInfo::visibleIconName() const
+{
+ return QString();
+}
+
+QString WindowInfo::visibleIconNameWithState() const
+{
+ return QString();
+}
+
+QString WindowInfo::iconName() const
+{
+ return QString();
+}
+
+bool WindowInfo::onAllDesktops() const
+{
+ return false;
+}
+
+bool WindowInfo::isOnDesktop(int desktop) const
+{
+ Q_UNUSED(desktop)
+ return false;
+}
+
+int WindowInfo::desktop() const
+{
+ return 0;
+}
+
+QStringList WindowInfo::activities() const
+{
+ return QStringList();
+}
+
+QRect WindowInfo::geometry() const
+{
+ return QRect();
+}
+
+QRect WindowInfo::frameGeometry() const
+{
+ return QRect();
+}
+
+WId WindowInfo::transientFor() const
+{
+ return 0;
+}
+
+WId WindowInfo::groupLeader() const
+{
+ return 0;
+}
+
+QByteArray WindowInfo::windowClassClass() const
+{
+ return QByteArray();
+}
+
+QByteArray WindowInfo::windowClassName() const
+{
+ return QByteArray();
+}
+
+QByteArray WindowInfo::windowRole() const
+{
+ return QByteArray();
+}
+
+QByteArray WindowInfo::clientMachine() const
+{
+ return QByteArray();
+}
+
+bool WindowInfo::actionSupported(NET::Action action) const
+{
+ Q_UNUSED(action)
+ return false;
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/windowinfo.h
new/kwayland-integration-5.5.2/src/windowsystem/windowinfo.h
--- old/kwayland-integration-5.4.3/src/windowsystem/windowinfo.h
1970-01-01 01:00:00.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/windowinfo.h
2015-12-22 11:36:10.000000000 +0100
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2014 Martin Gräßlin <mgraess...@kde.org>
+ * Copyright 2015 Marco Martin <m...@kde.org>
+ *
+ * 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.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * 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/>.
+ */
+#ifndef WINDOWINFO_H
+#define WINDOWINFO_H
+
+#include <kwindowinfo.h>
+#include <KWindowSystem/private/kwindowinfo_p.h>
+
+
+namespace KWayland
+{
+ namespace Client
+ {
+ class Surface;
+ class PlasmaShellSurface;
+ }
+}
+
+class WindowInfo : public KWindowInfoPrivate
+{
+public:
+ WindowInfo(WId window, NET::Properties properties, NET::Properties2
properties2);
+ ~WindowInfo();
+
+ bool valid(bool withdrawn_is_valid) const override;
+ NET::States state() const override;
+ bool isMinimized() const override;
+ NET::MappingState mappingState() const override;
+ NETExtendedStrut extendedStrut() const override;
+ NET::WindowType windowType(NET::WindowTypes supported_types) const
override;
+ QString visibleName() const override;
+ QString visibleNameWithState() const override;
+ QString name() const override;
+ QString visibleIconName() const override;
+ QString visibleIconNameWithState() const override;
+ QString iconName() const override;
+ bool onAllDesktops() const override;
+ bool isOnDesktop(int desktop) const override;
+ int desktop() const override;
+ QStringList activities() const override;
+ QRect geometry() const override;
+ QRect frameGeometry() const override;
+ WId transientFor() const override;
+ WId groupLeader() const override;
+ QByteArray windowClassClass() const override;
+ QByteArray windowClassName() const override;
+ QByteArray windowRole() const override;
+ QByteArray clientMachine() const override;
+ bool actionSupported(NET::Action action) const override;
+
+private:
+ bool m_valid;
+ NET::Properties m_properties;
+ NET::Properties2 m_properties2;
+ KWayland::Client::Surface *m_surface;
+ KWayland::Client::PlasmaShellSurface *m_plasmaShellSurface;
+};
+
+#endif
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/windowsystem.cpp
new/kwayland-integration-5.5.2/src/windowsystem/windowsystem.cpp
--- old/kwayland-integration-5.4.3/src/windowsystem/windowsystem.cpp
2015-11-05 13:39:23.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/windowsystem.cpp
2015-12-22 11:36:10.000000000 +0100
@@ -18,6 +18,7 @@
* License along with this library. If not, see
<http://www.gnu.org/licenses/>.
*/
#include "windowsystem.h"
+#include "waylandintegration.h"
#include "logging.h"
#include <KWindowSystem/KWindowSystem>
@@ -25,6 +26,8 @@
#include <KWayland/Client/connection_thread.h>
#include <KWayland/Client/plasmawindowmanagement.h>
#include <KWayland/Client/registry.h>
+#include <KWayland/Client/plasmashell.h>
+#include <KWayland/Client/surface.h>
#include <QPixmap>
#include <QPoint>
@@ -38,66 +41,13 @@
{
}
-void WindowSystem::setupKWaylandIntegration()
-{
- ConnectionThread *connection = ConnectionThread::fromApplication(this);
- if (!connection) {
- qCWarning(KWAYLAND_KWS) << "Failed getting Wayland connection from
QPA";
- return;
- }
- Registry *registry = new Registry(this);
- registry->create(connection);
- connect(registry, &Registry::interfacesAnnounced, this,
- [this] {
- if (!m_wm) {
- qCWarning(KWAYLAND_KWS) << "This compositor does not support
the Plasma Window Management interface";
- }
- }
- );
- connect(registry, &Registry::plasmaWindowManagementAnnounced, this,
- [this, registry] (quint32 name, quint32 version) {
- m_wm = registry->createPlasmaWindowManagement(name, version, this);
- connect(m_wm, &PlasmaWindowManagement::windowCreated, this,
- [this] (PlasmaWindow *w) {
- emit KWindowSystem::self()->windowAdded(w->internalId());
- emit KWindowSystem::self()->stackingOrderChanged();
- connect(w, &PlasmaWindow::unmapped, this,
- [w] {
- emit
KWindowSystem::self()->windowRemoved(w->internalId());
- emit KWindowSystem::self()->stackingOrderChanged();
- }
- );
- }
- );
- connect(m_wm, &PlasmaWindowManagement::activeWindowChanged, this,
- [this] {
- if (PlasmaWindow *w = m_wm->activeWindow()) {
- emit
KWindowSystem::self()->activeWindowChanged(w->internalId());
- } else {
- emit KWindowSystem::self()->activeWindowChanged(0);
- }
- }
- );
- connect(m_wm, &PlasmaWindowManagement::showingDesktopChanged,
KWindowSystem::self(), &KWindowSystem::showingDesktopChanged);
- emit KWindowSystem::self()->compositingChanged(true);
- emit
KWindowSystem::self()->showingDesktopChanged(m_wm->isShowingDesktop());
- emit KWindowSystem::self()->stackingOrderChanged();
- if (PlasmaWindow *w = m_wm->activeWindow()) {
- emit
KWindowSystem::self()->activeWindowChanged(w->internalId());
- }
- qCDebug(KWAYLAND_KWS) << "Plasma Window Management interface
bound";
- }
- );
-
- registry->setup();
-}
-
KWayland::Client::PlasmaWindow *WindowSystem::window(WId wid) const
{
- if (!m_wm) {
+ if (!WaylandIntegration::self()->plasmaWindowManagement()) {
return nullptr;
}
- const auto &windows = m_wm->windows();
+
+ const auto &windows =
WaylandIntegration::self()->plasmaWindowManagement()->windows();
auto it = std::find_if(windows.begin(), windows.end(), [wid] (PlasmaWindow
*w) { return w->internalId() == wid; } );
if (it != windows.end()) {
return *it;
@@ -123,8 +73,9 @@
WId WindowSystem::activeWindow()
{
- if (m_wm && m_wm->activeWindow()) {
- return m_wm->activeWindow()->internalId();
+ KWayland::Client::PlasmaWindowManagement *wm =
WaylandIntegration::self()->plasmaWindowManagement();
+ if (wm && wm->activeWindow()) {
+ return wm->activeWindow()->internalId();
}
return 0;
}
@@ -330,30 +281,164 @@
void WindowSystem::setShowingDesktop(bool showing)
{
- if (m_wm) {
- m_wm->setShowingDesktop(showing);
+ if (!WaylandIntegration::self()->plasmaWindowManagement()) {
+ return;
}
+
WaylandIntegration::self()->plasmaWindowManagement()->setShowingDesktop(showing);
}
void WindowSystem::clearState(WId win, NET::States state)
{
- Q_UNUSED(win)
- Q_UNUSED(state)
- qCDebug(KWAYLAND_KWS) << "This plugin does not support changing window
states";
+ Surface *s = Surface::fromQtWinId(win);
+ if (!s) {
+ return;
+ }
+
+ KWayland::Client::PlasmaShellSurface *plasmaShellSurface = 0;
+
+ if (state & NET::SkipTaskbar) {
+ if (!WaylandIntegration::self()->waylandPlasmaShell()) {
+ return;
+ }
+ plasmaShellSurface = PlasmaShellSurface::get(s);
+ if (!plasmaShellSurface) {
+ plasmaShellSurface =
WaylandIntegration::self()->waylandPlasmaShell()->createSurface(s, this);
+ }
+ if (!plasmaShellSurface) {
+ return;
+ }
+ }
+
+ if (state & NET::SkipTaskbar) {
+ plasmaShellSurface->setSkipTaskbar(false);
+ }
+
+ if (state & NET::Max) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Max
window state";
+ }
+ if (state & NET::FullScreen) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
FullScreen window state";
+ }
+ if (state & NET::Modal) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Modal
window state";
+ }
+ if (state & NET::Sticky) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Sticky
window state";
+ }
+ if (state & NET::Shaded) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Shaded
window state";
+ }
+ if (state & NET::KeepAbove) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
KeepAbove window state";
+ }
+ if (state & NET::StaysOnTop) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
StaysOnTop window state";
+ }
+ if (state & NET::SkipPager) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
SkipPager window state";
+ }
+ if (state & NET::Hidden) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Hidden
window state";
+ }
+ if (state & NET::KeepBelow) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
KeepBelow window state";
+ }
+ if (state & NET::DemandsAttention) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
DemandsAttention window state";
+ }
}
void WindowSystem::setState(WId win, NET::States state)
{
- Q_UNUSED(win)
- Q_UNUSED(state)
- qCDebug(KWAYLAND_KWS) << "This plugin does not support changing window
states";
+ Surface *s = Surface::fromQtWinId(win);
+ if (!s) {
+ return;
+ }
+
+ KWayland::Client::PlasmaShellSurface *plasmaShellSurface = 0;
+
+ if (state & NET::SkipTaskbar) {
+ if (!WaylandIntegration::self()->waylandPlasmaShell()) {
+ return;
+ }
+ plasmaShellSurface = PlasmaShellSurface::get(s);
+ if (!plasmaShellSurface) {
+ plasmaShellSurface =
WaylandIntegration::self()->waylandPlasmaShell()->createSurface(s, this);
+ }
+ if (!plasmaShellSurface) {
+ return;
+ }
+ }
+
+ if (state & NET::SkipTaskbar) {
+ plasmaShellSurface->setSkipTaskbar(true);
+ }
+
+ if (state & NET::Max) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Max
window state";
+ }
+ if (state & NET::FullScreen) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
FullScreen window state";
+ }
+ if (state & NET::Modal) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Modal
window state";
+ }
+ if (state & NET::Sticky) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Sticky
window state";
+ }
+ if (state & NET::Shaded) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Shaded
window state";
+ }
+ if (state & NET::KeepAbove) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
KeepAbove window state";
+ }
+ if (state & NET::StaysOnTop) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
StaysOnTop window state";
+ }
+ if (state & NET::SkipPager) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
SkipPager window state";
+ }
+ if (state & NET::Hidden) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing Hidden
window state";
+ }
+ if (state & NET::KeepBelow) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
KeepBelow window state";
+ }
+ if (state & NET::DemandsAttention) {
+ qCDebug(KWAYLAND_KWS) << "This plugin does not support changing
DemandsAttention window state";
+ }
}
void WindowSystem::setType(WId win, NET::WindowType windowType)
{
- Q_UNUSED(win)
- Q_UNUSED(windowType)
- qCDebug(KWAYLAND_KWS) << "This plugin does not support changing window
types";
+ if (!WaylandIntegration::self()->waylandPlasmaShell()) {
+ return;
+ }
+ KWayland::Client::PlasmaShellSurface::Role role;
+
+ switch (windowType) {
+ case NET::Normal:
+ role = KWayland::Client::PlasmaShellSurface::Role::Normal;
+ break;
+ case NET::Desktop:
+ role = KWayland::Client::PlasmaShellSurface::Role::Desktop;
+ break;
+ case NET::Dock:
+ role = KWayland::Client::PlasmaShellSurface::Role::Panel;
+ break;
+ case NET::OnScreenDisplay:
+ role = KWayland::Client::PlasmaShellSurface::Role::OnScreenDisplay;
+ break;
+ default:
+ return;
+ }
+ Surface *s = Surface::fromQtWinId(win);
+ if (!s) {
+ return;
+ }
+ KWayland::Client::PlasmaShellSurface *shellSurface =
WaylandIntegration::self()->waylandPlasmaShell()->createSurface(s, this);
+
+ shellSurface->setRole(role);
}
void WindowSystem::setUserTime(WId win, long int time)
@@ -365,23 +450,24 @@
bool WindowSystem::showingDesktop()
{
- if (m_wm) {
- return m_wm->isShowingDesktop();
+ if (!WaylandIntegration::self()->plasmaWindowManagement()) {
+ return false;
}
- return false;
+ return
WaylandIntegration::self()->plasmaWindowManagement()->isShowingDesktop();
}
QList< WId > WindowSystem::stackingOrder()
{
- if (m_wm) {
- const auto &windows = m_wm->windows();
- QList<WId> ret;
- for (auto w : windows) {
- ret << w->internalId();
- }
- return ret;
+ if (!WaylandIntegration::self()->plasmaWindowManagement()) {
+ return QList<WId>();
+ }
+
+ const auto &windows =
WaylandIntegration::self()->plasmaWindowManagement()->windows();
+ QList<WId> ret;
+ for (auto w : windows) {
+ ret << w->internalId();
}
- return QList<WId>();
+ return ret;
}
WId WindowSystem::transientFor(WId window)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/kwayland-integration-5.4.3/src/windowsystem/windowsystem.h
new/kwayland-integration-5.5.2/src/windowsystem/windowsystem.h
--- old/kwayland-integration-5.4.3/src/windowsystem/windowsystem.h
2015-11-05 13:39:23.000000000 +0100
+++ new/kwayland-integration-5.5.2/src/windowsystem/windowsystem.h
2015-12-22 11:36:10.000000000 +0100
@@ -30,6 +30,7 @@
{
class PlasmaWindow;
class PlasmaWindowManagement;
+class PlasmaShell;
}
}
@@ -92,7 +93,7 @@
void setupKWaylandIntegration();
KWayland::Client::PlasmaWindow *window(WId window) const;
- KWayland::Client::PlasmaWindowManagement *m_wm = nullptr;
+ KWayland::Client::PlasmaShell *m_waylandPlasmaShell = nullptr;
};
#endif
