From 48d37280054e182ab28aa10fad022afc6d2e184a Mon Sep 17 00:00:00 2001 From: Michail Vourlakos Date: Sun, 12 May 2019 02:17:22 +0300 Subject: [PATCH] REFACTOR:Introduce SchemesTracker for WM --- app/lattecorona.cpp | 5 +- app/wm/CMakeLists.txt | 3 +- app/wm/abstractwindowinterface.cpp | 97 ++------------------ app/wm/abstractwindowinterface.h | 14 +-- app/wm/schemestracker.cpp | 138 +++++++++++++++++++++++++++++ app/wm/schemestracker.h | 68 ++++++++++++++ app/wm/windowstracker.cpp | 9 +- 7 files changed, 224 insertions(+), 110 deletions(-) create mode 100644 app/wm/schemestracker.cpp create mode 100644 app/wm/schemestracker.h diff --git a/app/lattecorona.cpp b/app/lattecorona.cpp index 6ad4cb61f..370c89d10 100644 --- a/app/lattecorona.cpp +++ b/app/lattecorona.cpp @@ -39,6 +39,7 @@ #include "settings/universalsettings.h" #include "view/view.h" #include "wm/abstractwindowinterface.h" +#include "wm/schemestracker.h" #include "wm/waylandinterface.h" #include "wm/xwindowinterface.h" @@ -967,10 +968,10 @@ void Corona::windowColorScheme(QString windowIdAndScheme) //! otherwise the active window id may not be the same with the one trigerred //! the color scheme dbus signal QString windowIdStr = m_wm->activeWindow().toString(); - m_wm->setColorSchemeForWindow(windowIdStr.toUInt(), schemeStr); + m_wm->schemesTracker()->setColorSchemeForWindow(windowIdStr.toUInt(), schemeStr); }); } else { - m_wm->setColorSchemeForWindow(windowIdStr.toUInt(), schemeStr); + m_wm->schemesTracker()->setColorSchemeForWindow(windowIdStr.toUInt(), schemeStr); } } diff --git a/app/wm/CMakeLists.txt b/app/wm/CMakeLists.txt index 1884db8c9..a6818c612 100644 --- a/app/wm/CMakeLists.txt +++ b/app/wm/CMakeLists.txt @@ -1,7 +1,8 @@ set(lattedock-app_SRCS ${lattedock-app_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/abstractwindowinterface.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/schemecolors.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/schemecolors.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/schemestracker.cpp ${CMAKE_CURRENT_SOURCE_DIR}/waylandinterface.cpp ${CMAKE_CURRENT_SOURCE_DIR}/windowinfowrap.cpp ${CMAKE_CURRENT_SOURCE_DIR}/windowstracker.cpp diff --git a/app/wm/abstractwindowinterface.cpp b/app/wm/abstractwindowinterface.cpp index c39cc4fd3..9dff51dc2 100644 --- a/app/wm/abstractwindowinterface.cpp +++ b/app/wm/abstractwindowinterface.cpp @@ -21,17 +21,10 @@ #include "abstractwindowinterface.h" // local +#include "schemestracker.h" #include "windowstracker.h" #include "../lattecorona.h" -// Qt -#include -#include -#include - -// KDE -#include -#include namespace Latte { namespace WindowSystem { @@ -41,77 +34,23 @@ AbstractWindowInterface::AbstractWindowInterface(QObject *parent) { m_corona = qobject_cast(parent); m_windowsTracker = new WindowsTracker(this); - - updateDefaultScheme(); - - connect(this, &AbstractWindowInterface::windowRemoved, this, [&](WindowId wid) { - m_windowScheme.remove(wid); - }); - - //! track for changing default scheme - QString kdeSettingsFile = QDir::homePath() + "/.config/kdeglobals"; - - KDirWatch::self()->addFile(kdeSettingsFile); - - connect(KDirWatch::self(), &KDirWatch::dirty, this, [ &, kdeSettingsFile](const QString & path) { - if (path == kdeSettingsFile) { - this->updateDefaultScheme(); - } - }); - - connect(KDirWatch::self(), &KDirWatch::created, this, [ &, kdeSettingsFile](const QString & path) { - if (path == kdeSettingsFile) { - this->updateDefaultScheme(); - } - }); + m_schemesTracker = new SchemesTracker(this); } AbstractWindowInterface::~AbstractWindowInterface() { - m_windowScheme.clear(); - //! it is just a reference to a real scheme file - m_schemes.take("kdeglobals"); - qDeleteAll(m_schemes); - m_schemes.clear(); - + m_schemesTracker->deleteLater(); m_windowsTracker->deleteLater(); } -//! Scheme support for windows -void AbstractWindowInterface::updateDefaultScheme() -{ - QString defaultSchemePath = SchemeColors::possibleSchemeFile("kdeglobals"); - - qDebug() << " Windows default color scheme :: " << defaultSchemePath; - - SchemeColors *dScheme; - - if (!m_schemes.contains(defaultSchemePath)) { - dScheme = new SchemeColors(this, defaultSchemePath); - m_schemes[defaultSchemePath] = dScheme; - } else { - dScheme = m_schemes[defaultSchemePath]; - } - - if (!m_schemes.contains("kdeglobals") || m_schemes["kdeglobals"]->schemeFile() != defaultSchemePath) { - m_schemes["kdeglobals"] = dScheme; - } -} - Latte::Corona *AbstractWindowInterface::corona() { return m_corona; } -SchemeColors *AbstractWindowInterface::schemeForWindow(WindowId wid) +SchemesTracker *AbstractWindowInterface::schemesTracker() { - if (!m_windowScheme.contains(wid)) { - return m_schemes["kdeglobals"]; - } else { - return m_schemes[m_windowScheme[wid]]; - } - - return nullptr; + return m_schemesTracker; } WindowsTracker *AbstractWindowInterface::windowsTracker() @@ -119,32 +58,6 @@ WindowsTracker *AbstractWindowInterface::windowsTracker() return m_windowsTracker; } -void AbstractWindowInterface::setColorSchemeForWindow(WindowId wid, QString scheme) -{ - if (scheme == "kdeglobals" && !m_windowScheme.contains(wid)) { - //default scheme does not have to be set - return; - } - - if (scheme == "kdeglobals") { - //! a window that previously had an explicit set scheme now is set back to default scheme - m_windowScheme.remove(wid); - } else { - QString schemeFile = SchemeColors::possibleSchemeFile(scheme); - - if (!m_schemes.contains(schemeFile)) { - //! when this scheme file has not been loaded yet - m_schemes[schemeFile] = new SchemeColors(this, schemeFile); - } - - m_windowScheme[wid] = schemeFile; - } - - if (wid == activeWindow()) { - emit activeWindowChanged(wid); - } -} - } } diff --git a/app/wm/abstractwindowinterface.h b/app/wm/abstractwindowinterface.h index 70f281170..b88bb57d4 100644 --- a/app/wm/abstractwindowinterface.h +++ b/app/wm/abstractwindowinterface.h @@ -50,6 +50,7 @@ namespace Latte { class Corona; namespace WindowSystem { +class SchemesTracker; class WindowsTracker; } } @@ -102,9 +103,8 @@ public: virtual WindowId winIdFor(QString appId, QRect geometry) const = 0; Latte::Corona *corona(); - SchemeColors *schemeForWindow(WindowId wId); + SchemesTracker *schemesTracker(); WindowsTracker *windowsTracker(); - void setColorSchemeForWindow(WindowId wId, QString scheme); signals: void activeWindowChanged(WindowId wid); @@ -118,17 +118,9 @@ protected: std::list m_windows; QPointer m_activities; -private slots: - void updateDefaultScheme(); - private: - //! scheme file and its loaded colors - QMap m_schemes; - - //! window id and its corresponding scheme file - QMap m_windowScheme; - Latte::Corona *m_corona; + SchemesTracker *m_schemesTracker; WindowsTracker *m_windowsTracker; }; diff --git a/app/wm/schemestracker.cpp b/app/wm/schemestracker.cpp new file mode 100644 index 000000000..269563f7a --- /dev/null +++ b/app/wm/schemestracker.cpp @@ -0,0 +1,138 @@ +/* +* Copyright 2019 Michail Vourlakos +* +* This file is part of Latte-Dock +* +* Latte-Dock 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. +* +* Latte-Dock 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 . +*/ + +#include "schemestracker.h" + +// local +#include "abstractwindowinterface.h" +#include "schemecolors.h" +#include "../lattecorona.h" + +// Qt +#include + +// KDE +#include + + +namespace Latte { +namespace WindowSystem { + +SchemesTracker::SchemesTracker(AbstractWindowInterface *parent) + : QObject(parent) +{ + m_wm = parent; + init(); +} + +SchemesTracker::~SchemesTracker() +{ + m_windowScheme.clear(); + //! it is just a reference to a real scheme file + m_schemes.take("kdeglobals"); + qDeleteAll(m_schemes); + m_schemes.clear(); +} + +void SchemesTracker::init() +{ + updateDefaultScheme(); + + connect(m_wm, &AbstractWindowInterface::windowRemoved, this, [&](WindowId wid) { + m_windowScheme.remove(wid); + }); + + //! track for changing default scheme + QString kdeSettingsFile = QDir::homePath() + "/.config/kdeglobals"; + + KDirWatch::self()->addFile(kdeSettingsFile); + + connect(KDirWatch::self(), &KDirWatch::dirty, this, [ &, kdeSettingsFile](const QString & path) { + if (path == kdeSettingsFile) { + this->updateDefaultScheme(); + } + }); + + connect(KDirWatch::self(), &KDirWatch::created, this, [ &, kdeSettingsFile](const QString & path) { + if (path == kdeSettingsFile) { + this->updateDefaultScheme(); + } + }); +} + +//! Scheme support for windows +void SchemesTracker::updateDefaultScheme() +{ + QString defaultSchemePath = SchemeColors::possibleSchemeFile("kdeglobals"); + + qDebug() << " Windows default color scheme :: " << defaultSchemePath; + + SchemeColors *dScheme; + + if (!m_schemes.contains(defaultSchemePath)) { + dScheme = new SchemeColors(this, defaultSchemePath); + m_schemes[defaultSchemePath] = dScheme; + } else { + dScheme = m_schemes[defaultSchemePath]; + } + + if (!m_schemes.contains("kdeglobals") || m_schemes["kdeglobals"]->schemeFile() != defaultSchemePath) { + m_schemes["kdeglobals"] = dScheme; + } +} + +SchemeColors *SchemesTracker::schemeForWindow(WindowId wid) +{ + if (!m_windowScheme.contains(wid)) { + return m_schemes["kdeglobals"]; + } else { + return m_schemes[m_windowScheme[wid]]; + } + + return nullptr; +} + +void SchemesTracker::setColorSchemeForWindow(WindowId wid, QString scheme) +{ + if (scheme == "kdeglobals" && !m_windowScheme.contains(wid)) { + //default scheme does not have to be set + return; + } + + if (scheme == "kdeglobals") { + //! a window that previously had an explicit set scheme now is set back to default scheme + m_windowScheme.remove(wid); + } else { + QString schemeFile = SchemeColors::possibleSchemeFile(scheme); + + if (!m_schemes.contains(schemeFile)) { + //! when this scheme file has not been loaded yet + m_schemes[schemeFile] = new SchemeColors(this, schemeFile); + } + + m_windowScheme[wid] = schemeFile; + } + + if (wid == m_wm->activeWindow()) { + emit m_wm->activeWindowChanged(wid); + } +} + +} +} diff --git a/app/wm/schemestracker.h b/app/wm/schemestracker.h new file mode 100644 index 000000000..bcef94db1 --- /dev/null +++ b/app/wm/schemestracker.h @@ -0,0 +1,68 @@ +/* +* Copyright 2019 Michail Vourlakos +* +* This file is part of Latte-Dock +* +* Latte-Dock 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. +* +* Latte-Dock 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 . +*/ + +#ifndef SCHEMESTRACKER_H +#define SCHEMESTRACKER_H + +#include "windowinfowrap.h" + +// Qt +#include + + +namespace Latte { +namespace WindowSystem { +class AbstractWindowInterface; +class SchemeColors; +} +} + +namespace Latte { +namespace WindowSystem { + +class SchemesTracker : public QObject { + Q_OBJECT + +public: + SchemesTracker(AbstractWindowInterface *parent); + ~SchemesTracker() override; + + SchemeColors *schemeForWindow(WindowId wId); + void setColorSchemeForWindow(WindowId wId, QString scheme); + +private slots: + void updateDefaultScheme(); + +private: + void init(); + +private: + AbstractWindowInterface *m_wm; + + //! scheme file and its loaded colors + QMap m_schemes; + + //! window id and its corresponding scheme file + QMap m_windowScheme; +}; + +} +} + +#endif diff --git a/app/wm/windowstracker.cpp b/app/wm/windowstracker.cpp index 26f6184cf..d488c6934 100644 --- a/app/wm/windowstracker.cpp +++ b/app/wm/windowstracker.cpp @@ -22,6 +22,7 @@ // local #include "abstractwindowinterface.h" #include "schemecolors.h" +#include "schemestracker.h" #include "../lattecorona.h" #include "../layouts/manager.h" #include "../view/view.h" @@ -506,14 +507,14 @@ void WindowsTracker::updateHints(Latte::View *view) setExistsWindowTouching(view, (foundTouchInCurScreen || foundActiveTouchInCurScreen)); //! update color schemes for active and touching windows - setActiveWindowScheme(view, (foundActiveInCurScreen ? m_wm->schemeForWindow(activeWinId) : nullptr)); + setActiveWindowScheme(view, (foundActiveInCurScreen ? m_wm->schemesTracker()->schemeForWindow(activeWinId) : nullptr)); if (foundActiveTouchInCurScreen) { - setTouchingWindowScheme(view, m_wm->schemeForWindow(activeTouchWinId)); + setTouchingWindowScheme(view, m_wm->schemesTracker()->schemeForWindow(activeTouchWinId)); } else if (foundMaximizedInCurScreen) { - setTouchingWindowScheme(view, m_wm->schemeForWindow(maxWinId)); + setTouchingWindowScheme(view, m_wm->schemesTracker()->schemeForWindow(maxWinId)); } else if (foundTouchInCurScreen) { - setTouchingWindowScheme(view, m_wm->schemeForWindow(touchWinId)); + setTouchingWindowScheme(view, m_wm->schemesTracker()->schemeForWindow(touchWinId)); } else { setTouchingWindowScheme(view, nullptr); }