From a12ce7d3ab3767c0b7376153479f1210ce4836ba Mon Sep 17 00:00:00 2001 From: audoban Date: Fri, 24 Feb 2017 21:40:47 -0500 Subject: [PATCH] #199, AbstractWindowInterface is now a shared resource --- app/CMakeLists.txt | 1 - app/abstractwindowinterface.cpp | 30 ++++- app/abstractwindowinterface.h | 40 +++++-- app/dockconfigview.cpp | 30 +++-- app/dockcorona.cpp | 2 +- app/dockview.cpp | 5 +- app/visibilitymanager.cpp | 51 +++++---- app/visibilitymanager_p.h | 2 +- app/windowinfowrap.cpp | 128 --------------------- app/windowinfowrap.h | 196 ++++++++++++++++++++++++++------ app/xwindowinterface.cpp | 119 ++++++++++++------- app/xwindowinterface.h | 22 ++-- 12 files changed, 347 insertions(+), 279 deletions(-) diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt index 456adaccb..e5561d1ac 100644 --- a/app/CMakeLists.txt +++ b/app/CMakeLists.txt @@ -1,6 +1,5 @@ set(lattedock-app_SRCS ../liblattedock/dock.cpp - ../liblattedock/windowsystem.cpp windowinfowrap.cpp abstractwindowinterface.cpp xwindowinterface.cpp diff --git a/app/abstractwindowinterface.cpp b/app/abstractwindowinterface.cpp index a3dc294b3..7f0c81997 100644 --- a/app/abstractwindowinterface.cpp +++ b/app/abstractwindowinterface.cpp @@ -28,8 +28,8 @@ namespace Latte { -AbstractWindowInterface::AbstractWindowInterface(QQuickWindow *const view, QObject *parent) - : QObject(parent), m_view(view) +AbstractWindowInterface::AbstractWindowInterface(QObject *parent) + : QObject(parent) { } @@ -37,15 +37,33 @@ AbstractWindowInterface::~AbstractWindowInterface() { } -AbstractWindowInterface *AbstractWindowInterface::getInstance(QQuickWindow *const view, QObject *parent) +void AbstractWindowInterface::addDock(WId wid) { + m_docks.push_back(wid); +} + +void AbstractWindowInterface::removeDock(WId wid) +{ + auto it = std::find(m_docks.begin(), m_docks.end(), wid); + + if (it != m_docks.end()) + m_docks.erase(it); +} + +AbstractWindowInterface &AbstractWindowInterface::self() +{ + if (m_wm) + return *m_wm; + if (KWindowSystem::isPlatformWayland()) { //! TODO: WaylandWindowInterface - return nullptr; + } else /* if(KWindowSystem::isPlatformX11) */ { + m_wm = new XWindowInterface; } - /* if(KWindowSystem::isPlatformX11) */ - return new XWindowInterface(view, parent); + return *m_wm; } } + +QPointer Latte::AbstractWindowInterface::m_wm; diff --git a/app/abstractwindowinterface.h b/app/abstractwindowinterface.h index 584b92303..8a9bb2493 100644 --- a/app/abstractwindowinterface.h +++ b/app/abstractwindowinterface.h @@ -23,16 +23,19 @@ #include "windowinfowrap.h" #include "../liblattedock/dock.h" +#include "../liblattedock/extras.h" #include -#include #include #include +#include #include -#include +#include +#include #include +#include namespace Latte { @@ -42,10 +45,20 @@ class AbstractWindowInterface : public QObject { Q_OBJECT public: - explicit AbstractWindowInterface(QQuickWindow *const view, QObject *parent = nullptr); + enum class Slide { + None, + Top, + Left, + Bottom, + Right, + }; + + explicit AbstractWindowInterface(QObject *parent = nullptr); virtual ~AbstractWindowInterface(); - virtual void setDockDefaultFlags() = 0; + virtual void setDockExtraFlags(QQuickWindow &view) = 0; + virtual void setDockStruts(WId dockId, const QRect &dockRect, Plasma::Types::Location location) const = 0; + virtual void removeDockStruts(WId dockId) const = 0; virtual WId activeWindow() const = 0; virtual WindowInfoWrap requestInfo(WId wid) const = 0; @@ -53,10 +66,14 @@ public: virtual bool isOnCurrentDesktop(WId wid) const = 0; virtual const std::list &windows() const = 0; - virtual void setDockStruts(const QRect &dockRect, Plasma::Types::Location location) const = 0; - virtual void removeDockStruts() const = 0; + virtual void skipTaskBar(const QDialog &dialog) const = 0; + virtual void slideWindow(QQuickWindow &view, Slide location) const = 0; + virtual void enableBlurBehind(QQuickWindow &view) const = 0; - static AbstractWindowInterface *getInstance(QQuickWindow *const view, QObject *parent = nullptr); + void addDock(WId wid); + void removeDock(WId wid); + + static AbstractWindowInterface &self(); signals: void activeWindowChanged(WId wid); @@ -67,10 +84,15 @@ signals: void currentActivityChanged(); protected: - QQuickWindow *const m_view; std::list m_windows; + std::list m_docks; + QPointer m_activities; + + static QPointer m_wm; }; -} +// namespace alias +using WindowSystem = AbstractWindowInterface; +} #endif // ABSTRACTWINDOWINTERFACE_H diff --git a/app/dockconfigview.cpp b/app/dockconfigview.cpp index 13cd1e543..702e417f8 100644 --- a/app/dockconfigview.cpp +++ b/app/dockconfigview.cpp @@ -22,6 +22,7 @@ #include "dockview.h" #include "dockcorona.h" #include "panelshadows_p.h" +#include "abstractwindowinterface.h" #include #include @@ -30,8 +31,6 @@ #include #include -#include -#include #include @@ -52,15 +51,11 @@ DockConfigView::DockConfigView(Plasma::Containment *containment, DockView *dockV connections << connect(dockView, SIGNAL(screenChanged(QScreen *)), &m_screenSyncTimer, SLOT(start())); connections << connect(&m_screenSyncTimer, &QTimer::timeout, this, [this]() { setScreen(m_dockView->screen()); - KWindowSystem::setType(winId(), NET::Dock); + WindowSystem::self().setDockExtraFlags(*this); setFlags(wFlags()); syncGeometry(); syncSlideEffect(); }); - KWindowSystem::setType(winId(), NET::Dock); - KWindowSystem::setState(winId(), NET::KeepAbove); - setFlags(wFlags()); - KWindowSystem::forceActiveWindow(winId()); connections << connect(dockView->visibility(), &VisibilityManager::modeChanged, this, &DockConfigView::syncGeometry); connections << connect(containment, &Plasma::Containment::immutabilityChanged, this, &DockConfigView::immutabilityChanged); connections << connect(containment, &Plasma::Containment::locationChanged, [&]() { @@ -154,23 +149,23 @@ void DockConfigView::syncSlideEffect() if (!m_dockView->containment()) return; - KWindowEffects::SlideFromLocation slideLocation{KWindowEffects::NoEdge}; + auto slideLocation = WindowSystem::Slide::None; switch (m_dockView->containment()->location()) { case Plasma::Types::TopEdge: - slideLocation = KWindowEffects::TopEdge; + slideLocation = WindowSystem::Slide::Top; break; case Plasma::Types::RightEdge: - slideLocation = KWindowEffects::RightEdge; + slideLocation = WindowSystem::Slide::Right; break; case Plasma::Types::BottomEdge: - slideLocation = KWindowEffects::BottomEdge; + slideLocation = WindowSystem::Slide::Bottom; break; case Plasma::Types::LeftEdge: - slideLocation = KWindowEffects::LeftEdge; + slideLocation = WindowSystem::Slide::Left; break; default: @@ -178,17 +173,18 @@ void DockConfigView::syncSlideEffect() break; } - KWindowEffects::slideWindow(winId(), slideLocation, -1); + WindowSystem::self().slideWindow(*this, slideLocation); } void DockConfigView::showEvent(QShowEvent *ev) { QQuickWindow::showEvent(ev); - KWindowSystem::setType(winId(), NET::Dock); + + WindowSystem::self().setDockExtraFlags(*this); setFlags(wFlags()); - KWindowSystem::setState(winId(), NET::KeepAbove | NET::SkipPager | NET::SkipTaskbar); - KWindowSystem::forceActiveWindow(winId()); - KWindowEffects::enableBlurBehind(winId(), true); + + WindowSystem::self().enableBlurBehind(*this); + syncGeometry(); syncSlideEffect(); diff --git a/app/dockcorona.cpp b/app/dockcorona.cpp index faeb7b634..f6fbac776 100644 --- a/app/dockcorona.cpp +++ b/app/dockcorona.cpp @@ -21,7 +21,7 @@ #include "dockcorona.h" #include "dockview.h" #include "packageplugins/shell/dockpackage.h" -#include "../liblattedock/windowsystem.h" +#include "abstractwindowinterface.h" #include "alternativeshelper.h" #include diff --git a/app/dockview.cpp b/app/dockview.cpp index c7588c82b..a226cfa93 100644 --- a/app/dockview.cpp +++ b/app/dockview.cpp @@ -24,7 +24,6 @@ #include "visibilitymanager.h" #include "panelshadows_p.h" #include "../liblattedock/extras.h" -#include "../liblattedock/windowsystem.h" #include #include @@ -54,6 +53,10 @@ DockView::DockView(Plasma::Corona *corona, QScreen *targetScreen) setIcon(QIcon::fromTheme(corona->kPackage().metadata().iconName())); setResizeMode(QuickViewSharedEngine::SizeRootObjectToView); setClearBeforeRendering(true); + setFlags(Qt::FramelessWindowHint + | Qt::WindowStaysOnTopHint + | Qt::NoDropShadowWindowHint + | Qt::WindowDoesNotAcceptFocus); if (targetScreen) adaptToScreen(targetScreen); diff --git a/app/visibilitymanager.cpp b/app/visibilitymanager.cpp index fd5a1ca3c..1bd547187 100644 --- a/app/visibilitymanager.cpp +++ b/app/visibilitymanager.cpp @@ -30,7 +30,7 @@ namespace Latte { //! BEGIN: VisiblityManagerPrivate implementation VisibilityManagerPrivate::VisibilityManagerPrivate(PlasmaQuick::ContainmentView *view, VisibilityManager *q) - : QObject(q), q(q), view(view), wm(AbstractWindowInterface::getInstance(view, nullptr)) + : QObject(q), q(q), view(view), wm(&AbstractWindowInterface::self()) { DockView *dockView = qobject_cast(view); @@ -56,13 +56,14 @@ VisibilityManagerPrivate::VisibilityManagerPrivate(PlasmaQuick::ContainmentView emit this->q->mustBeHide(); } }); - wm->setDockDefaultFlags(); + wm->setDockExtraFlags(*view); + wm->addDock(view->winId()); } VisibilityManagerPrivate::~VisibilityManagerPrivate() { - wm->removeDockStruts(); - wm->deleteLater(); + wm->removeDockStruts(view->winId()); + wm->removeDock(view->winId()); } inline void VisibilityManagerPrivate::setMode(Dock::Visibility mode) @@ -72,7 +73,7 @@ inline void VisibilityManagerPrivate::setMode(Dock::Visibility mode) // clear mode if (this->mode == Dock::AlwaysVisible) - wm->removeDockStruts(); + wm->removeDockStruts(view->winId()); for (auto &c : connections) { disconnect(c); @@ -86,52 +87,52 @@ inline void VisibilityManagerPrivate::setMode(Dock::Visibility mode) switch (this->mode) { case Dock::AlwaysVisible: { if (view->containment() && !view->containment()->isUserConfiguring()) - wm->setDockStruts(dockGeometry, view->location()); + wm->setDockStruts(view->winId(), dockGeometry, view->location()); connections[0] = connect(view->containment(), &Plasma::Containment::locationChanged , this, [&]() { if (view->containment()->isUserConfiguring()) - wm->removeDockStruts(); + wm->removeDockStruts(view->winId()); }); connections[1] = connect(view->containment(), &Plasma::Containment::userConfiguringChanged , this, [&](bool configuring) { if (!configuring) - wm->setDockStruts(dockGeometry, view->containment()->location()); + wm->setDockStruts(view->winId(), dockGeometry, view->containment()->location()); }); raiseDock(true); } break; case Dock::AutoHide: { - connections[0] = connect(wm.get(), &AbstractWindowInterface::currentDesktopChanged + connections[0] = connect(wm, &AbstractWindowInterface::currentDesktopChanged , this, &VisibilityManagerPrivate::raiseDockTemporarily); - connections[1] = connect(wm.get(), &AbstractWindowInterface::currentActivityChanged + connections[1] = connect(wm, &AbstractWindowInterface::currentActivityChanged , this, &VisibilityManagerPrivate::raiseDockTemporarily); raiseDock(containsMouse); } break; case Dock::DodgeActive: { - connections[0] = connect(wm.get(), &AbstractWindowInterface::activeWindowChanged + connections[0] = connect(wm, &AbstractWindowInterface::activeWindowChanged , this, &VisibilityManagerPrivate::dodgeActive); - connections[1] = connect(wm.get(), &AbstractWindowInterface::windowChanged + connections[1] = connect(wm, &AbstractWindowInterface::windowChanged , this, &VisibilityManagerPrivate::dodgeActive); - connections[2] = connect(wm.get(), &AbstractWindowInterface::currentDesktopChanged + connections[2] = connect(wm, &AbstractWindowInterface::currentDesktopChanged , this, &VisibilityManagerPrivate::raiseDockTemporarily); - connections[3] = connect(wm.get(), &AbstractWindowInterface::currentActivityChanged + connections[3] = connect(wm, &AbstractWindowInterface::currentActivityChanged , this, &VisibilityManagerPrivate::raiseDockTemporarily); dodgeActive(wm->activeWindow()); } break; case Dock::DodgeMaximized: { - connections[0] = connect(wm.get(), &AbstractWindowInterface::activeWindowChanged + connections[0] = connect(wm, &AbstractWindowInterface::activeWindowChanged , this, &VisibilityManagerPrivate::dodgeMaximized); - connections[1] = connect(wm.get(), &AbstractWindowInterface::windowChanged + connections[1] = connect(wm, &AbstractWindowInterface::windowChanged , this, &VisibilityManagerPrivate::dodgeMaximized); - connections[2] = connect(wm.get(), &AbstractWindowInterface::currentDesktopChanged + connections[2] = connect(wm, &AbstractWindowInterface::currentDesktopChanged , this, &VisibilityManagerPrivate::raiseDockTemporarily); - connections[3] = connect(wm.get(), &AbstractWindowInterface::currentActivityChanged + connections[3] = connect(wm, &AbstractWindowInterface::currentActivityChanged , this, &VisibilityManagerPrivate::raiseDockTemporarily); dodgeMaximized(wm->activeWindow()); } @@ -142,21 +143,21 @@ inline void VisibilityManagerPrivate::setMode(Dock::Visibility mode) windows.insert({wid, wm->requestInfo(wid)}); } - connections[0] = connect(wm.get(), &AbstractWindowInterface::windowChanged + connections[0] = connect(wm, &AbstractWindowInterface::windowChanged , this, &VisibilityManagerPrivate::dodgeWindows); - connections[1] = connect(wm.get(), &AbstractWindowInterface::windowRemoved + connections[1] = connect(wm, &AbstractWindowInterface::windowRemoved , this, [&](WId wid) { windows.erase(wid); timerCheckWindows.start(); }); - connections[2] = connect(wm.get(), &AbstractWindowInterface::windowAdded + connections[2] = connect(wm, &AbstractWindowInterface::windowAdded , this, [&](WId wid) { windows.insert({wid, wm->requestInfo(wid)}); timerCheckWindows.start(); }); - connections[3] = connect(wm.get(), &AbstractWindowInterface::currentDesktopChanged + connections[3] = connect(wm, &AbstractWindowInterface::currentDesktopChanged , this, &VisibilityManagerPrivate::raiseDockTemporarily); - connections[4] = connect(wm.get(), &AbstractWindowInterface::currentActivityChanged + connections[4] = connect(wm, &AbstractWindowInterface::currentActivityChanged , this, &VisibilityManagerPrivate::raiseDockTemporarily); timerCheckWindows.start(); @@ -292,7 +293,7 @@ inline void VisibilityManagerPrivate::setDockGeometry(const QRect &geometry) this->dockGeometry = geometry; if (mode == Dock::AlwaysVisible && !view->containment()->isUserConfiguring()) { - wm->setDockStruts(this->dockGeometry, view->containment()->location()); + wm->setDockStruts(view->winId(), this->dockGeometry, view->containment()->location()); } } @@ -454,7 +455,7 @@ bool VisibilityManagerPrivate::event(QEvent *ev) break; case QEvent::Show: - wm->setDockDefaultFlags(); + wm->setDockExtraFlags(*view); restoreConfig(); break; } diff --git a/app/visibilitymanager_p.h b/app/visibilitymanager_p.h index 587979742..7552518fa 100644 --- a/app/visibilitymanager_p.h +++ b/app/visibilitymanager_p.h @@ -55,7 +55,7 @@ public: VisibilityManager *q; PlasmaQuick::ContainmentView *view; - std::unique_ptr wm; + AbstractWindowInterface *wm; Dock::Visibility mode{Dock::None}; std::array connections; std::unordered_map windows; diff --git a/app/windowinfowrap.cpp b/app/windowinfowrap.cpp index 64ec0368b..40c1250a3 100644 --- a/app/windowinfowrap.cpp +++ b/app/windowinfowrap.cpp @@ -19,131 +19,3 @@ */ #include "windowinfowrap.h" - -namespace Latte { - -WindowInfoWrap::WindowInfoWrap() - : m_isValid(false) - , m_isActive(false) - , m_isMinimized(false) - , m_isMaximized(false) - , m_isFullscreen(false) - , m_isPlasmaDesktop(false) - , m_wid(0) -{ -} - -WindowInfoWrap::WindowInfoWrap(const WindowInfoWrap &other) -{ - *this = other; -} - -WindowInfoWrap &WindowInfoWrap::operator=(const WindowInfoWrap &rhs) -{ - m_isValid = rhs.m_isValid; - m_isActive = rhs.m_isActive; - m_isMinimized = rhs.m_isMinimized; - m_isMaximized = rhs.m_isMaximized; - m_isFullscreen = rhs.m_isFullscreen; - m_isPlasmaDesktop = rhs.m_isPlasmaDesktop; - m_geometry = rhs.m_geometry; - m_wid = rhs.m_wid; - return *this; -} - -bool WindowInfoWrap::operator==(const WindowInfoWrap &rhs) const -{ - return m_wid == rhs.m_wid; -} - -bool WindowInfoWrap::operator<(const WindowInfoWrap &rhs) const -{ - return m_wid < rhs.m_wid; -} - -bool WindowInfoWrap::operator>(const WindowInfoWrap &rhs) const -{ - return m_wid > rhs.m_wid; -} - -bool WindowInfoWrap::isValid() const -{ - return m_isValid; -} - -void WindowInfoWrap::setIsValid(bool isValid) -{ - m_isValid = isValid; -} - -bool WindowInfoWrap::isActive() const -{ - return m_isActive; -} - -void WindowInfoWrap::setIsActive(bool isActive) -{ - m_isActive = isActive; -} - -bool WindowInfoWrap::isMinimized() const -{ - return m_isMinimized; -} - -void WindowInfoWrap::setIsMinimized(bool isMinimized) -{ - m_isMinimized = isMinimized; -} - -bool WindowInfoWrap::isMaximized() const -{ - return m_isMaximized; -} - -void WindowInfoWrap::setIsMaximized(bool isMaximized) -{ - m_isMaximized = isMaximized; -} - -bool WindowInfoWrap::isFullscreen() const -{ - return m_isFullscreen; -} - -void WindowInfoWrap::setIsFullscreen(bool isFullscreen) -{ - m_isFullscreen = isFullscreen; -} - -bool WindowInfoWrap::isPlasmaDesktop() const -{ - return m_isPlasmaDesktop; -} - -void WindowInfoWrap::setIsPlasmaDesktop(bool isPlasmaDesktop) -{ - m_isPlasmaDesktop = isPlasmaDesktop; -} - -QRect WindowInfoWrap::geometry() const -{ - return m_geometry; -} - -void WindowInfoWrap::setGeometry(const QRect &geometry) -{ - m_geometry = geometry; -} - -void WindowInfoWrap::setWid(WId wid) -{ - m_wid = wid; -} - -WId WindowInfoWrap::wid() const -{ - return m_wid; -} - -} diff --git a/app/windowinfowrap.h b/app/windowinfowrap.h index bdbe1b7da..d34a52f90 100644 --- a/app/windowinfowrap.h +++ b/app/windowinfowrap.h @@ -21,8 +21,7 @@ #ifndef WINDOWINFOWRAP_H #define WINDOWINFOWRAP_H -#include -#include +#include #include namespace Latte { @@ -30,50 +29,179 @@ namespace Latte { class WindowInfoWrap { public: - explicit WindowInfoWrap(); - WindowInfoWrap(const WindowInfoWrap &other); + constexpr WindowInfoWrap() + : m_isValid(false) + , m_isActive(false) + , m_isMinimized(false) + , m_isMaximized(false) + , m_isFullscreen(false) + , m_isPlasmaDesktop(false) + , m_wid(0) + { + } + + constexpr WindowInfoWrap(const WindowInfoWrap &other) + : m_isValid(other.m_isValid) + , m_isActive(other.m_isActive) + , m_isMinimized(other.m_isMinimized) + , m_isMaximized(other.m_isMaximized) + , m_isFullscreen(other.m_isFullscreen) + , m_isPlasmaDesktop(other.m_isPlasmaDesktop) + , m_wid(other.m_wid) + { + } + + inline WindowInfoWrap &operator=(const WindowInfoWrap &rhs); + constexpr bool operator==(const WindowInfoWrap &rhs) const; + constexpr bool operator<(const WindowInfoWrap &rhs) const; + constexpr bool operator>(const WindowInfoWrap &rhs) const; + + constexpr bool isValid() const; + inline void setIsValid(bool isValid); + + constexpr bool isActive() const; + inline void setIsActive(bool isActive); + + constexpr bool isMinimized() const; + inline void setIsMinimized(bool isMinimized); + + constexpr bool isMaximized() const; + inline void setIsMaximized(bool isMaximized); + + constexpr bool isFullscreen() const; + inline void setIsFullscreen(bool isFullscreen); + + constexpr bool isPlasmaDesktop() const; + inline void setIsPlasmaDesktop(bool isPlasmaDesktop); + + constexpr QRect geometry() const; + inline void setGeometry(const QRect &geometry); + + constexpr WId wid() const; + inline void setWid(WId wid); - WindowInfoWrap &operator=(const WindowInfoWrap &rhs); +private: + bool m_isValid : 1; + bool m_isActive : 1; + bool m_isMinimized : 1; + bool m_isMaximized : 1; + bool m_isFullscreen : 1; + bool m_isPlasmaDesktop : 1; + WId m_wid; + QRect m_geometry; +}; - bool operator==(const WindowInfoWrap &rhs) const; - bool operator<(const WindowInfoWrap &rhs) const; - bool operator>(const WindowInfoWrap &rhs) const; +// BEGIN: definitions + +inline WindowInfoWrap &WindowInfoWrap::operator=(const WindowInfoWrap &rhs) +{ + m_isValid = rhs.m_isValid; + m_isActive = rhs.m_isActive; + m_isMinimized = rhs.m_isMinimized; + m_isMaximized = rhs.m_isMaximized; + m_isFullscreen = rhs.m_isFullscreen; + m_isPlasmaDesktop = rhs.m_isPlasmaDesktop; + m_wid = rhs.m_wid; + m_geometry = rhs.m_geometry; + return *this; +} - bool isValid() const; - void setIsValid(bool isValid); +constexpr bool WindowInfoWrap::operator==(const WindowInfoWrap &rhs) const +{ + return m_wid == rhs.m_wid; +} - bool isActive() const; - void setIsActive(bool isActive); +constexpr bool WindowInfoWrap::operator<(const WindowInfoWrap &rhs) const +{ + return m_wid < rhs.m_wid; +} - bool isMinimized() const; - void setIsMinimized(bool isMinimized); +constexpr bool WindowInfoWrap::operator>(const WindowInfoWrap &rhs) const +{ + return m_wid > rhs.m_wid; +} - bool isMaximized() const; - void setIsMaximized(bool isMaximized); +constexpr bool WindowInfoWrap::isValid() const +{ + return m_isValid; +} - bool isFullscreen() const; - void setIsFullscreen(bool isFullscreen); +inline void WindowInfoWrap::setIsValid(bool isValid) +{ + m_isValid = isValid; +} - bool isPlasmaDesktop() const; - void setIsPlasmaDesktop(bool isPlasmaDesktop); +constexpr bool WindowInfoWrap::isActive() const +{ + return m_isActive; +} - QRect geometry() const; - void setGeometry(const QRect &geometry); +inline void WindowInfoWrap::setIsActive(bool isActive) +{ + m_isActive = isActive; +} - WId wid() const; - void setWid(WId wid); +constexpr bool WindowInfoWrap::isMinimized() const +{ + return m_isMinimized; +} -private: - bool m_isValid : 1; - bool m_isActive : 1; - bool m_isMinimized : 1; - bool m_isMaximized : 1; - bool m_isFullscreen : 1; - bool m_isPlasmaDesktop : 1; - QRect m_geometry; - WId m_wid{0}; -}; +inline void WindowInfoWrap::setIsMinimized(bool isMinimized) +{ + m_isMinimized = isMinimized; +} + +constexpr bool WindowInfoWrap::isMaximized() const +{ + return m_isMaximized; +} + +inline void WindowInfoWrap::setIsMaximized(bool isMaximized) +{ + m_isMaximized = isMaximized; +} + +constexpr bool WindowInfoWrap::isFullscreen() const +{ + return m_isFullscreen; +} + +inline void WindowInfoWrap::setIsFullscreen(bool isFullscreen) +{ + m_isFullscreen = isFullscreen; +} + +constexpr bool WindowInfoWrap::isPlasmaDesktop() const +{ + return m_isPlasmaDesktop; +} + +inline void WindowInfoWrap::setIsPlasmaDesktop(bool isPlasmaDesktop) +{ + m_isPlasmaDesktop = isPlasmaDesktop; +} + +constexpr QRect WindowInfoWrap::geometry() const +{ + return m_geometry; +} + +inline void WindowInfoWrap::setGeometry(const QRect &geometry) +{ + m_geometry = geometry; +} + +constexpr WId WindowInfoWrap::wid() const +{ + return m_wid; +} + +inline void WindowInfoWrap::setWid(WId wid) +{ + m_wid = wid; +} +// END: definitions } #endif // WINDOWINFOWRAP_H diff --git a/app/xwindowinterface.cpp b/app/xwindowinterface.cpp index de7e9b37d..9a54795ba 100644 --- a/app/xwindowinterface.cpp +++ b/app/xwindowinterface.cpp @@ -31,17 +31,17 @@ namespace Latte { -XWindowInterface::XWindowInterface(QQuickWindow *const view, QObject *parent) - : AbstractWindowInterface(view, parent), activities(new KActivities::Consumer(this)) +XWindowInterface::XWindowInterface(QObject *parent) + : AbstractWindowInterface(parent) { - Q_ASSERT(view != nullptr); - - connections << connect(KWindowSystem::self(), &KWindowSystem::activeWindowChanged + m_activities = new KActivities::Consumer(this); + connect(KWindowSystem::self(), &KWindowSystem::activeWindowChanged , this, &AbstractWindowInterface::activeWindowChanged); - connections << connect(KWindowSystem::self() + connect(KWindowSystem::self() , static_cast (&KWindowSystem::windowChanged) , this, &XWindowInterface::windowChangedProxy); + auto addWindow = [&](WId wid) { if (std::find(m_windows.cbegin(), m_windows.cend(), wid) == m_windows.cend()) { if (isValidWindow(KWindowInfo(wid, NET::WMWindowType))) { @@ -50,16 +50,17 @@ XWindowInterface::XWindowInterface(QQuickWindow *const view, QObject *parent) } } }; - connections << connect(KWindowSystem::self(), &KWindowSystem::windowAdded, this, addWindow); - connections << connect(KWindowSystem::self(), &KWindowSystem::windowRemoved, [this](WId wid) { + + connect(KWindowSystem::self(), &KWindowSystem::windowAdded, this, addWindow); + connect(KWindowSystem::self(), &KWindowSystem::windowRemoved, [this](WId wid) { if (std::find(m_windows.cbegin(), m_windows.cend(), wid) != m_windows.end()) { m_windows.remove(wid); emit windowRemoved(wid); } }); - connections << connect(KWindowSystem::self(), &KWindowSystem::currentDesktopChanged + connect(KWindowSystem::self(), &KWindowSystem::currentDesktopChanged , this, &XWindowInterface::currentDesktopChanged); - connections << connect(activities.data(), &KActivities::Consumer::currentActivityChanged + connect(m_activities.data(), &KActivities::Consumer::currentActivityChanged , this, &XWindowInterface::currentActivityChanged); // fill windows list @@ -71,42 +72,23 @@ XWindowInterface::XWindowInterface(QQuickWindow *const view, QObject *parent) XWindowInterface::~XWindowInterface() { qDebug() << "x window interface deleting..."; - - foreach (auto var, connections) { - QObject::disconnect(var); - } - - qDebug() << "x window interface connections removed..."; } -void XWindowInterface::setDockDefaultFlags() +void XWindowInterface::setDockExtraFlags(QQuickWindow &view) { - m_view->setFlags(Qt::FramelessWindowHint - | Qt::WindowStaysOnTopHint - | Qt::NoDropShadowWindowHint - | Qt::WindowDoesNotAcceptFocus); NETWinInfo winfo(QX11Info::connection() - , static_cast(m_view->winId()) - , static_cast(m_view->winId()) + , static_cast(view.winId()) + , static_cast(view.winId()) , 0, 0); - winfo.setAllowedActions(NET::ActionChangeDesktop); - KWindowSystem::setType(m_view->winId(), NET::Dock); - KWindowSystem::setState(m_view->winId(), NET::SkipTaskbar | NET::SkipPager); - KWindowSystem::setOnAllDesktops(m_view->winId(), true); - KWindowSystem::setOnActivities(m_view->winId(), {"0"}); -} - -WId XWindowInterface::activeWindow() const -{ - return KWindowSystem::self()->activeWindow(); -} -const std::list &XWindowInterface::windows() const -{ - return m_windows; + winfo.setAllowedActions(NET::ActionChangeDesktop); + KWindowSystem::setType(view.winId(), NET::Dock); + KWindowSystem::setState(view.winId(), NET::SkipTaskbar | NET::SkipPager); + KWindowSystem::setOnAllDesktops(view.winId(), true); + KWindowSystem::setOnActivities(view.winId(), {"0"}); } -void XWindowInterface::setDockStruts(const QRect &dockRect, Plasma::Types::Location location) const +void XWindowInterface::setDockStruts(WId dockId, const QRect &dockRect, Plasma::Types::Location location) const { NETExtendedStrut strut; @@ -123,7 +105,7 @@ void XWindowInterface::setDockStruts(const QRect &dockRect, Plasma::Types::Locat strut.bottom_end = dockRect.x() + dockRect.width() - 1; break; - case Plasma::Types::LeftEdge: + case Plasma::Types::Left: strut.left_width = dockRect.width(); strut.left_start = dockRect.y(); strut.left_end = dockRect.y() + dockRect.height() - 1; @@ -140,7 +122,7 @@ void XWindowInterface::setDockStruts(const QRect &dockRect, Plasma::Types::Locat return; } - KWindowSystem::setExtendedStrut(m_view->winId(), + KWindowSystem::setExtendedStrut(dockId, strut.left_width, strut.left_start, strut.left_end, strut.right_width, strut.right_start, strut.right_end, strut.top_width, strut.top_start, strut.top_end, @@ -148,10 +130,59 @@ void XWindowInterface::setDockStruts(const QRect &dockRect, Plasma::Types::Locat ); } -void XWindowInterface::removeDockStruts() const +void XWindowInterface::removeDockStruts(WId dockId) const +{ + KWindowSystem::setStrut(dockId, 0, 0, 0, 0); +} + +WId XWindowInterface::activeWindow() const +{ + return KWindowSystem::self()->activeWindow(); +} + +const std::list &XWindowInterface::windows() const +{ + return m_windows; +} + +void XWindowInterface::skipTaskBar(const QDialog &dialog) const +{ + KWindowSystem::setState(dialog.winId(), NET::SkipTaskbar); +} + +void XWindowInterface::slideWindow(QQuickWindow &view, AbstractWindowInterface::Slide location) const +{ + auto slideLocation = KWindowEffects::NoEdge; + + switch (location) { + case Slide::Top: + slideLocation = KWindowEffects::TopEdge; + break; + + case Slide::Bottom: + slideLocation = KWindowEffects::BottomEdge; + break; + + case Slide::Left: + slideLocation = KWindowEffects::LeftEdge; + break; + + case Slide::Right: + slideLocation = KWindowEffects::RightEdge; + break; + + default: + break; + } + + KWindowEffects::slideWindow(view.winId(), slideLocation, -1); +} + +void XWindowInterface::enableBlurBehind(QQuickWindow &view) const { - KWindowSystem::setStrut(m_view->winId(), 0, 0, 0, 0); + KWindowEffects::enableBlurBehind(view.winId()); } + WindowInfoWrap XWindowInterface::requestInfoActive() const { return requestInfo(KWindowSystem::activeWindow()); @@ -211,10 +242,9 @@ bool XWindowInterface::isValidWindow(const KWindowInfo &winfo) const void XWindowInterface::windowChangedProxy(WId wid, NET::Properties prop1, NET::Properties2 prop2) { //! if the dock changed is ignored - if (wid == m_view->winId()) + if (std::find(m_docks.cbegin(), m_docks.cend(), wid) != m_docks.cend()) return; - //! ignore when, eg: the user presses a key const auto winType = KWindowInfo(wid, NET::WMWindowType).windowType(NET::DesktopMask); if (winType != -1 && (winType & NET::Desktop)) { @@ -223,6 +253,7 @@ void XWindowInterface::windowChangedProxy(WId wid, NET::Properties prop1, NET::P return; } + //! ignore when, eg: the user presses a key if (prop1 == 0 && prop2 == NET::WM2UserTime) { return; } diff --git a/app/xwindowinterface.h b/app/xwindowinterface.h index dae740225..17f529bf9 100644 --- a/app/xwindowinterface.h +++ b/app/xwindowinterface.h @@ -22,13 +22,12 @@ #define XWINDOWINTERFACE_H #include "abstractwindowinterface.h" +#include "windowinfowrap.h" #include -#include #include -#include -#include +#include namespace Latte { @@ -36,10 +35,12 @@ class XWindowInterface : public AbstractWindowInterface { Q_OBJECT public: - XWindowInterface(QQuickWindow *const view, QObject *parent); - virtual ~XWindowInterface(); + explicit XWindowInterface(QObject *parent = nullptr); + ~XWindowInterface() override; - void setDockDefaultFlags() override; + void setDockExtraFlags(QQuickWindow &view) override; + void setDockStruts(WId dockId, const QRect &dockRect, Plasma::Types::Location location) const override; + void removeDockStruts(WId dockId) const override; WId activeWindow() const override; WindowInfoWrap requestInfo(WId wid) const override; @@ -47,18 +48,15 @@ public: bool isOnCurrentDesktop(WId wid) const override; const std::list &windows() const override; - void setDockStruts(const QRect &dockRect, Plasma::Types::Location location) const override; - void removeDockStruts() const override; - + void skipTaskBar(const QDialog &dialog) const override; + void slideWindow(QQuickWindow &view, Slide location) const override; + void enableBlurBehind(QQuickWindow &view) const override; private: bool isValidWindow(const KWindowInfo &winfo) const; void windowChangedProxy(WId wid, NET::Properties prop1, NET::Properties2 prop2); WId m_desktopId; - QPointer activities; - - QList connections; }; }