REFACTOR:Introduce SchemesTracker for WM

pull/5/head
Michail Vourlakos 6 years ago
parent 4e80801523
commit 48d3728005

@ -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);
}
}

@ -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

@ -21,17 +21,10 @@
#include "abstractwindowinterface.h"
// local
#include "schemestracker.h"
#include "windowstracker.h"
#include "../lattecorona.h"
// Qt
#include <QObject>
#include <QDir>
#include <QQuickWindow>
// KDE
#include <KDirWatch>
#include <KWindowSystem>
namespace Latte {
namespace WindowSystem {
@ -41,77 +34,23 @@ AbstractWindowInterface::AbstractWindowInterface(QObject *parent)
{
m_corona = qobject_cast<Latte::Corona *>(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);
}
}
}
}

@ -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<WindowId> m_windows;
QPointer<KActivities::Consumer> m_activities;
private slots:
void updateDefaultScheme();
private:
//! scheme file and its loaded colors
QMap<QString, SchemeColors *> m_schemes;
//! window id and its corresponding scheme file
QMap<WindowId, QString> m_windowScheme;
Latte::Corona *m_corona;
SchemesTracker *m_schemesTracker;
WindowsTracker *m_windowsTracker;
};

@ -0,0 +1,138 @@
/*
* Copyright 2019 Michail Vourlakos <mvourlakos@gmail.com>
*
* 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 <http://www.gnu.org/licenses/>.
*/
#include "schemestracker.h"
// local
#include "abstractwindowinterface.h"
#include "schemecolors.h"
#include "../lattecorona.h"
// Qt
#include <QDir>
// KDE
#include <KDirWatch>
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);
}
}
}
}

@ -0,0 +1,68 @@
/*
* Copyright 2019 Michail Vourlakos <mvourlakos@gmail.com>
*
* 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 <http://www.gnu.org/licenses/>.
*/
#ifndef SCHEMESTRACKER_H
#define SCHEMESTRACKER_H
#include "windowinfowrap.h"
// Qt
#include <QObject>
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<QString, SchemeColors *> m_schemes;
//! window id and its corresponding scheme file
QMap<WindowId, QString> m_windowScheme;
};
}
}
#endif

@ -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);
}

Loading…
Cancel
Save