yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

kcms/tabbox: Handle config directly within the configuration form

Browse source 
By passing the config object to the TabBoxConfigurationForm, we
can handle it directly instead of bouncing information from and
back between the forms and the KCM main class.

Now the user changes in the UI translate to the config objects,
which can directly provide `isSaveNeeded()` and `isDefaults()` info.

This allows to simplify the logic on both classes, reducing the
coupling between them and minimizing the number of exposed public
methods and some boilerplate.
This commit is contained in:
Ismael Asensio 2023-01-16 23:03:22 +01:00
parent 9807c83929
commit 8507e602f3
4 changed files with 178 additions and 356 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

272
src/kcms/tabbox/kwintabboxconfigform.cpp
View file

@ -4,27 +4,26 @@
SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org> SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org>
SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com> SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com>
SPDX-FileCopyrightText: 2023 Ismael Asensio <isma.af@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later SPDX-License-Identifier: GPL-2.0-or-later
*/ */
#include "kwintabboxconfigform.h" #include "kwintabboxconfigform.h"
#include "kwintabboxsettings.h"
#include "ui_main.h" #include "ui_main.h"
#include <QDebug>
#include <KActionCollection> #include <KActionCollection>
#include <KGlobalAccel> #include <KGlobalAccel>
#include <KShortcutsEditor>
namespace KWin namespace KWin
{ {
using namespace TabBox; using namespace TabBox;
KWinTabBoxConfigForm::KWinTabBoxConfigForm(TabboxType type, QWidget *parent) KWinTabBoxConfigForm::KWinTabBoxConfigForm(TabboxType type, TabBoxSettings *config, QWidget *parent)
: QWidget(parent) : QWidget(parent)
, m_type(type) , m_config(config)
, ui(new Ui::KWinTabBoxConfigForm) , ui(new Ui::KWinTabBoxConfigForm)
{ {
ui->setupUi(this); ui->setupUi(this);
@ -36,6 +35,8 @@ KWinTabBoxConfigForm::KWinTabBoxConfigForm(TabboxType type, QWidget *parent)
ui->screenFilter->hide(); ui->screenFilter->hide();
} }
connect(this, &KWinTabBoxConfigForm::configChanged, this, &KWinTabBoxConfigForm::updateDefaultIndicators);
connect(ui->effectConfigButton, &QPushButton::clicked, this, &KWinTabBoxConfigForm::effectConfigButtonClicked); connect(ui->effectConfigButton, &QPushButton::clicked, this, &KWinTabBoxConfigForm::effectConfigButtonClicked);
connect(ui->kcfg_ShowTabBox, &QAbstractButton::clicked, this, &KWinTabBoxConfigForm::tabBoxToggled); connect(ui->kcfg_ShowTabBox, &QAbstractButton::clicked, this, &KWinTabBoxConfigForm::tabBoxToggled);
@ -81,17 +82,19 @@ KWinTabBoxConfigForm::KWinTabBoxConfigForm(TabboxType type, QWidget *parent)
m_actionCollection->setConfigGroup("Navigation"); m_actionCollection->setConfigGroup("Navigation");
m_actionCollection->setConfigGlobal(true); m_actionCollection->setConfigGlobal(true);
if (TabboxType::Main == m_type) { if (TabboxType::Main == type) {
addShortcut("Walk Through Windows", ui->scAll, Qt::ALT | Qt::Key_Tab); addShortcut("Walk Through Windows", ui->scAll, Qt::ALT | Qt::Key_Tab);
addShortcut("Walk Through Windows (Reverse)", ui->scAllReverse, Qt::ALT | Qt::SHIFT | Qt::Key_Backtab); addShortcut("Walk Through Windows (Reverse)", ui->scAllReverse, Qt::ALT | Qt::SHIFT | Qt::Key_Backtab);
addShortcut("Walk Through Windows of Current Application", ui->scCurrent, Qt::ALT | Qt::Key_QuoteLeft); addShortcut("Walk Through Windows of Current Application", ui->scCurrent, Qt::ALT | Qt::Key_QuoteLeft);
addShortcut("Walk Through Windows of Current Application (Reverse)", ui->scCurrentReverse, Qt::ALT | Qt::Key_AsciiTilde); addShortcut("Walk Through Windows of Current Application (Reverse)", ui->scCurrentReverse, Qt::ALT | Qt::Key_AsciiTilde);
} else if (TabboxType::Alternative == m_type) { } else if (TabboxType::Alternative == type) {
addShortcut("Walk Through Windows Alternative", ui->scAll); addShortcut("Walk Through Windows Alternative", ui->scAll);
addShortcut("Walk Through Windows Alternative (Reverse)", ui->scAllReverse); addShortcut("Walk Through Windows Alternative (Reverse)", ui->scAllReverse);
addShortcut("Walk Through Windows of Current Application Alternative", ui->scCurrent); addShortcut("Walk Through Windows of Current Application Alternative", ui->scCurrent);
addShortcut("Walk Through Windows of Current Application Alternative (Reverse)", ui->scCurrentReverse); addShortcut("Walk Through Windows of Current Application Alternative (Reverse)", ui->scCurrentReverse);
} }
updateUiFromConfig();
} }
KWinTabBoxConfigForm::~KWinTabBoxConfigForm() KWinTabBoxConfigForm::~KWinTabBoxConfigForm()
@ -99,6 +102,11 @@ KWinTabBoxConfigForm::~KWinTabBoxConfigForm()
delete ui; delete ui;
} }
TabBoxSettings *KWinTabBoxConfigForm::config() const
{
return m_config;
}
bool KWinTabBoxConfigForm::highlightWindows() const bool KWinTabBoxConfigForm::highlightWindows() const
{ {
return ui->kcfg_HighlightWindows->isChecked(); return ui->kcfg_HighlightWindows->isChecked();
@ -220,21 +228,18 @@ void KWinTabBoxConfigForm::setSwitchingModeChanged(TabBox::TabBoxConfig::ClientS
void KWinTabBoxConfigForm::setLayoutName(const QString &layoutName) void KWinTabBoxConfigForm::setLayoutName(const QString &layoutName)
{ {
ui->effectCombo->setCurrentIndex(ui->effectCombo->findData(layoutName)); const int index = ui->effectCombo->findData(layoutName);
if (index >= 0) {
ui->effectCombo->setCurrentIndex(index);
}
} }
void KWinTabBoxConfigForm::setEffectComboModel(QStandardItemModel *model) void KWinTabBoxConfigForm::setEffectComboModel(QStandardItemModel *model)
{ {
int index = ui->effectCombo->currentIndex(); // We don't want to lose the config layout when resetting the combo model
QVariant data = ui->effectCombo->itemData(index); const QString layout = m_config->layoutName();
ui->effectCombo->setModel(model); ui->effectCombo->setModel(model);
setLayoutName(layout);
if (data.isValid()) {
ui->effectCombo->setCurrentIndex(ui->effectCombo->findData(data));
} else if (index != -1) {
ui->effectCombo->setCurrentIndex(index);
}
} }
QVariant KWinTabBoxConfigForm::effectComboCurrentData(int role) const QVariant KWinTabBoxConfigForm::effectComboCurrentData(int role) const
@ -298,129 +303,6 @@ bool KWinTabBoxConfigForm::isShortcutsDefault() const
return true; return true;
} }
void KWinTabBoxConfigForm::setHighlightWindowsEnabled(bool enabled)
{
m_isHighlightWindowsEnabled = enabled;
ui->kcfg_HighlightWindows->setEnabled(m_isHighlightWindowsEnabled);
}
void KWinTabBoxConfigForm::setFilterScreenEnabled(bool enabled)
{
ui->filterScreens->setEnabled(enabled);
ui->currentScreen->setEnabled(enabled);
ui->otherScreens->setEnabled(enabled);
}
void KWinTabBoxConfigForm::setFilterDesktopEnabled(bool enabled)
{
ui->filterDesktops->setEnabled(enabled);
ui->currentDesktop->setEnabled(enabled);
ui->otherDesktops->setEnabled(enabled);
}
void KWinTabBoxConfigForm::setFilterActivitiesEnabled(bool enabled)
{
ui->filterActivities->setEnabled(enabled);
ui->currentActivity->setEnabled(enabled);
ui->otherActivities->setEnabled(enabled);
}
void KWinTabBoxConfigForm::setFilterMinimizationEnabled(bool enabled)
{
ui->filterMinimization->setEnabled(enabled);
ui->visibleWindows->setEnabled(enabled);
ui->hiddenWindows->setEnabled(enabled);
}
void KWinTabBoxConfigForm::setApplicationModeEnabled(bool enabled)
{
ui->oneAppWindow->setEnabled(enabled);
}
void KWinTabBoxConfigForm::setOrderMinimizedModeEnabled(bool enabled)
{
ui->orderMinimized->setEnabled(enabled);
}
void KWinTabBoxConfigForm::setShowDesktopModeEnabled(bool enabled)
{
ui->showDesktop->setEnabled(enabled);
}
void KWinTabBoxConfigForm::setSwitchingModeEnabled(bool enabled)
{
ui->switchingModeCombo->setEnabled(enabled);
}
void KWinTabBoxConfigForm::setLayoutNameEnabled(bool enabled)
{
ui->effectCombo->setEnabled(enabled);
}
void KWinTabBoxConfigForm::setFilterScreenDefaultIndicatorVisible(bool visible)
{
setDefaultIndicatorVisible(ui->filterScreens, visible);
setDefaultIndicatorVisible(ui->currentScreen, visible);
setDefaultIndicatorVisible(ui->otherScreens, visible);
}
void KWinTabBoxConfigForm::setFilterDesktopDefaultIndicatorVisible(bool visible)
{
setDefaultIndicatorVisible(ui->filterDesktops, visible);
setDefaultIndicatorVisible(ui->currentDesktop, visible);
setDefaultIndicatorVisible(ui->otherDesktops, visible);
}
void KWinTabBoxConfigForm::setFilterActivitiesDefaultIndicatorVisible(bool visible)
{
setDefaultIndicatorVisible(ui->filterActivities, visible);
setDefaultIndicatorVisible(ui->currentActivity, visible);
setDefaultIndicatorVisible(ui->otherActivities, visible);
}
void KWinTabBoxConfigForm::setFilterMinimizationDefaultIndicatorVisible(bool visible)
{
setDefaultIndicatorVisible(ui->filterMinimization, visible);
setDefaultIndicatorVisible(ui->visibleWindows, visible);
setDefaultIndicatorVisible(ui->hiddenWindows, visible);
}
void KWinTabBoxConfigForm::setApplicationModeDefaultIndicatorVisible(bool visible)
{
setDefaultIndicatorVisible(ui->oneAppWindow, visible);
}
void KWinTabBoxConfigForm::setOrderMinimizedDefaultIndicatorVisible(bool visible)
{
setDefaultIndicatorVisible(ui->orderMinimized, visible);
}
void KWinTabBoxConfigForm::setShowDesktopModeDefaultIndicatorVisible(bool visible)
{
setDefaultIndicatorVisible(ui->showDesktop, visible);
}
void KWinTabBoxConfigForm::setSwitchingModeDefaultIndicatorVisible(bool visible)
{
setDefaultIndicatorVisible(ui->switchingModeCombo, visible);
}
void KWinTabBoxConfigForm::setLayoutNameDefaultIndicatorVisible(bool visible)
{
setDefaultIndicatorVisible(ui->effectCombo, visible);
}
void KWinTabBoxConfigForm::setShortcutsDefaultIndicatorVisible(bool visible)
{
for (const auto &widget : {ui->scAll, ui->scAllReverse, ui->scCurrent, ui->scCurrentReverse}) {
const QString actionName = widget->property("shortcutAction").toString();
QAction *action = m_actionCollection->action(actionName);
const bool isDefault = (action->shortcut() == m_actionCollection->defaultShortcut(action));
setDefaultIndicatorVisible(widget, visible && !isDefault);
}
}
void KWinTabBoxConfigForm::tabBoxToggled(bool on) void KWinTabBoxConfigForm::tabBoxToggled(bool on)
{ {
// Highlight Windows options is availabled if no TabBox effect is selected // Highlight Windows options is availabled if no TabBox effect is selected
@ -431,42 +313,50 @@ void KWinTabBoxConfigForm::tabBoxToggled(bool on)
void KWinTabBoxConfigForm::onFilterScreen() void KWinTabBoxConfigForm::onFilterScreen()
{ {
Q_EMIT filterScreenChanged(filterScreen()); m_config->setMultiScreenMode(filterScreen());
Q_EMIT configChanged();
} }
void KWinTabBoxConfigForm::onFilterDesktop() void KWinTabBoxConfigForm::onFilterDesktop()
{ {
Q_EMIT filterDesktopChanged(filterDesktop()); m_config->setDesktopMode(filterDesktop());
Q_EMIT configChanged();
} }
void KWinTabBoxConfigForm::onFilterActivites() void KWinTabBoxConfigForm::onFilterActivites()
{ {
Q_EMIT filterActivitiesChanged(filterActivities()); m_config->setActivitiesMode(filterActivities());
Q_EMIT configChanged();
} }
void KWinTabBoxConfigForm::onFilterMinimization() void KWinTabBoxConfigForm::onFilterMinimization()
{ {
Q_EMIT filterMinimizationChanged(filterMinimization()); m_config->setMinimizedMode(filterMinimization());
Q_EMIT configChanged();
} }
void KWin::KWinTabBoxConfigForm::onApplicationMode() void KWin::KWinTabBoxConfigForm::onApplicationMode()
{ {
Q_EMIT applicationModeChanged(applicationMode()); m_config->setApplicationsMode(applicationMode());
Q_EMIT configChanged();
} }
void KWinTabBoxConfigForm::onOrderMinimizedMode() void KWinTabBoxConfigForm::onOrderMinimizedMode()
{ {
Q_EMIT orderMinimizedModeChanged(orderMinimizedMode()); m_config->setOrderMinimizedMode(orderMinimizedMode());
Q_EMIT configChanged();
} }
void KWinTabBoxConfigForm::onShowDesktopMode() void KWinTabBoxConfigForm::onShowDesktopMode()
{ {
Q_EMIT showDesktopModeChanged(showDesktopMode()); m_config->setShowDesktopMode(showDesktopMode());
Q_EMIT configChanged();
} }
void KWinTabBoxConfigForm::onSwitchingMode() void KWinTabBoxConfigForm::onSwitchingMode()
{ {
Q_EMIT switchingModeChanged(switchingMode()); m_config->setSwitchingMode(switchingMode());
Q_EMIT configChanged();
} }
void KWinTabBoxConfigForm::onEffectCombo() void KWinTabBoxConfigForm::onEffectCombo()
@ -478,7 +368,8 @@ void KWinTabBoxConfigForm::onEffectCombo()
} }
ui->kcfg_HighlightWindows->setEnabled(isAddonEffect && m_isHighlightWindowsEnabled); ui->kcfg_HighlightWindows->setEnabled(isAddonEffect && m_isHighlightWindowsEnabled);
Q_EMIT layoutNameChanged(layoutName()); m_config->setLayoutName(layoutName());
Q_EMIT configChanged();
} }
void KWinTabBoxConfigForm::onShortcutChanged(const QKeySequence &seq) void KWinTabBoxConfigForm::onShortcutChanged(const QKeySequence &seq)
@ -493,13 +384,88 @@ void KWinTabBoxConfigForm::onShortcutChanged(const QKeySequence &seq)
QAction *action = m_actionCollection->action(actionName); QAction *action = m_actionCollection->action(actionName);
action->setShortcut(seq); action->setShortcut(seq);
Q_EMIT shortcutChanged(); Q_EMIT configChanged();
} }
void KWinTabBoxConfigForm::setDefaultIndicatorVisible(QWidget *widget, bool visible) void KWinTabBoxConfigForm::updateUiFromConfig()
{ {
widget->setProperty("_kde_highlight_neutral", visible); setFilterScreen(static_cast<TabBoxConfig::ClientMultiScreenMode>(m_config->multiScreenMode()));
widget->update(); setFilterDesktop(static_cast<TabBoxConfig::ClientDesktopMode>(m_config->desktopMode()));
setFilterActivities(static_cast<TabBoxConfig::ClientActivitiesMode>(m_config->activitiesMode()));
setFilterMinimization(static_cast<TabBoxConfig::ClientMinimizedMode>(m_config->minimizedMode()));
setApplicationMode(static_cast<TabBoxConfig::ClientApplicationsMode>(m_config->applicationsMode()));
setOrderMinimizedMode(static_cast<TabBoxConfig::OrderMinimizedMode>(m_config->orderMinimizedMode()));
setShowDesktopMode(static_cast<TabBoxConfig::ShowDesktopMode>(m_config->showDesktopMode()));
setSwitchingModeChanged(static_cast<TabBoxConfig::ClientSwitchingMode>(m_config->switchingMode()));
setLayoutName(m_config->layoutName());
updateDefaultIndicators();
}
void KWinTabBoxConfigForm::setEnabledUi()
{
m_isHighlightWindowsEnabled = !m_config->isHighlightWindowsImmutable();
ui->kcfg_HighlightWindows->setEnabled(!m_config->isHighlightWindowsImmutable());
ui->filterScreens->setEnabled(!m_config->isMultiScreenModeImmutable());
ui->currentScreen->setEnabled(!m_config->isMultiScreenModeImmutable());
ui->otherScreens->setEnabled(!m_config->isMultiScreenModeImmutable());
ui->filterDesktops->setEnabled(!m_config->isDesktopModeImmutable());
ui->currentDesktop->setEnabled(!m_config->isDesktopModeImmutable());
ui->otherDesktops->setEnabled(!m_config->isDesktopModeImmutable());
ui->filterActivities->setEnabled(!m_config->isActivitiesModeImmutable());
ui->currentActivity->setEnabled(!m_config->isActivitiesModeImmutable());
ui->otherActivities->setEnabled(!m_config->isActivitiesModeImmutable());
ui->filterMinimization->setEnabled(!m_config->isMinimizedModeImmutable());
ui->visibleWindows->setEnabled(!m_config->isMinimizedModeImmutable());
ui->hiddenWindows->setEnabled(!m_config->isMinimizedModeImmutable());
ui->oneAppWindow->setEnabled(!m_config->isApplicationsModeImmutable());
ui->orderMinimized->setEnabled(!m_config->isOrderMinimizedModeImmutable());
ui->showDesktop->setEnabled(!m_config->isShowDesktopModeImmutable());
ui->switchingModeCombo->setEnabled(!m_config->isSwitchingModeImmutable());
ui->effectCombo->setEnabled(!m_config->isLayoutNameImmutable());
}
void KWinTabBoxConfigForm::setDefaultIndicatorVisible(bool show)
{
m_showDefaultIndicator = show;
updateDefaultIndicators();
}
void KWinTabBoxConfigForm::updateDefaultIndicators()
{
applyDefaultIndicator({ui->filterScreens, ui->currentScreen, ui->otherScreens},
m_config->multiScreenMode() == m_config->defaultMultiScreenModeValue());
applyDefaultIndicator({ui->filterDesktops, ui->currentDesktop, ui->otherDesktops},
m_config->desktopMode() == m_config->defaultDesktopModeValue());
applyDefaultIndicator({ui->filterActivities, ui->currentActivity, ui->otherActivities},
m_config->activitiesMode() == m_config->defaultActivitiesModeValue());
applyDefaultIndicator({ui->filterMinimization, ui->visibleWindows, ui->hiddenWindows},
m_config->minimizedMode() == m_config->defaultMinimizedModeValue());
applyDefaultIndicator({ui->oneAppWindow}, m_config->applicationsMode() == m_config->defaultApplicationsModeValue());
applyDefaultIndicator({ui->orderMinimized}, m_config->orderMinimizedMode() == m_config->defaultOrderMinimizedModeValue());
applyDefaultIndicator({ui->showDesktop}, m_config->showDesktopMode() == m_config->defaultShowDesktopModeValue());
applyDefaultIndicator({ui->switchingModeCombo}, m_config->switchingMode() == m_config->defaultSwitchingModeValue());
applyDefaultIndicator({ui->effectCombo}, m_config->layoutName() == m_config->defaultLayoutNameValue());
for (const auto &widget : {ui->scAll, ui->scAllReverse, ui->scCurrent, ui->scCurrentReverse}) {
const QString actionName = widget->property("shortcutAction").toString();
QAction *action = m_actionCollection->action(actionName);
const bool isDefault = (action->shortcut() == m_actionCollection->defaultShortcut(action));
applyDefaultIndicator({widget}, isDefault);
}
}
void KWinTabBoxConfigForm::applyDefaultIndicator(QList<QWidget *> widgets, bool isDefault)
{
for (auto widget : widgets) {
widget->setProperty("_kde_highlight_neutral", m_showDefaultIndicator && !isDefault);
widget->update();
}
} }
} // namespace } // namespace

95
src/kcms/tabbox/kwintabboxconfigform.h
View file

@ -4,6 +4,7 @@
SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org> SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org>
SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com> SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com>
SPDX-FileCopyrightText: 2023 Ismael Asensio <isma.af@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later SPDX-License-Identifier: GPL-2.0-or-later
*/ */
@ -15,7 +16,6 @@
#include "tabboxconfig.h" #include "tabboxconfig.h"
class KShortcutsEditor;
class KActionCollection; class KActionCollection;
namespace Ui namespace Ui
@ -26,6 +26,11 @@ class KWinTabBoxConfigForm;
namespace KWin namespace KWin
{ {
namespace TabBox
{
class TabBoxSettings;
}
class KWinTabBoxConfigForm : public QWidget class KWinTabBoxConfigForm : public QWidget
{ {
Q_OBJECT Q_OBJECT
@ -41,30 +46,14 @@ public:
AddonEffect, // i.e not builtin effects AddonEffect, // i.e not builtin effects
}; };
explicit KWinTabBoxConfigForm(TabboxType type, QWidget *parent = nullptr); explicit KWinTabBoxConfigForm(TabboxType type, TabBox::TabBoxSettings *config, QWidget *parent = nullptr);
~KWinTabBoxConfigForm() override; ~KWinTabBoxConfigForm() override;
TabBox::TabBoxSettings *config() const;
bool highlightWindows() const; bool highlightWindows() const;
bool showTabBox() const;
int filterScreen() const;
int filterDesktop() const;
int filterActivities() const;
int filterMinimization() const;
int applicationMode() const;
int orderMinimizedMode() const;
int showDesktopMode() const;
int switchingMode() const;
QString layoutName() const;
void setFilterScreen(TabBox::TabBoxConfig::ClientMultiScreenMode mode); void updateUiFromConfig();
void setFilterDesktop(TabBox::TabBoxConfig::ClientDesktopMode mode); void setDefaultIndicatorVisible(bool visible);
void setFilterActivities(TabBox::TabBoxConfig::ClientActivitiesMode mode);
void setFilterMinimization(TabBox::TabBoxConfig::ClientMinimizedMode mode);
void setApplicationMode(TabBox::TabBoxConfig::ClientApplicationsMode mode);
void setOrderMinimizedMode(TabBox::TabBoxConfig::OrderMinimizedMode mode);
void setShowDesktopMode(TabBox::TabBoxConfig::ShowDesktopMode mode);
void setSwitchingModeChanged(TabBox::TabBoxConfig::ClientSwitchingMode mode);
void setLayoutName(const QString &layoutName);
// EffectCombo Data Model // EffectCombo Data Model
void setEffectComboModel(QStandardItemModel *model); void setEffectComboModel(QStandardItemModel *model);
@ -76,40 +65,9 @@ public:
bool isShortcutsChanged() const; bool isShortcutsChanged() const;
bool isShortcutsDefault() const; bool isShortcutsDefault() const;
void setHighlightWindowsEnabled(bool enabled);
void setFilterScreenEnabled(bool enabled);
void setFilterDesktopEnabled(bool enabled);
void setFilterActivitiesEnabled(bool enabled);
void setFilterMinimizationEnabled(bool enabled);
void setApplicationModeEnabled(bool enabled);
void setOrderMinimizedModeEnabled(bool enabled);
void setShowDesktopModeEnabled(bool enabled);
void setSwitchingModeEnabled(bool enabled);
void setLayoutNameEnabled(bool enabled);
void setFilterScreenDefaultIndicatorVisible(bool visible);
void setFilterDesktopDefaultIndicatorVisible(bool visible);
void setFilterActivitiesDefaultIndicatorVisible(bool visible);
void setFilterMinimizationDefaultIndicatorVisible(bool visible);
void setApplicationModeDefaultIndicatorVisible(bool visible);
void setOrderMinimizedDefaultIndicatorVisible(bool visible);
void setShowDesktopModeDefaultIndicatorVisible(bool visible);
void setSwitchingModeDefaultIndicatorVisible(bool visible);
void setLayoutNameDefaultIndicatorVisible(bool visible);
void setShortcutsDefaultIndicatorVisible(bool visible);
Q_SIGNALS: Q_SIGNALS:
void filterScreenChanged(int value); void configChanged();
void filterDesktopChanged(int value);
void filterActivitiesChanged(int value);
void filterMinimizationChanged(int value);
void applicationModeChanged(int value);
void orderMinimizedModeChanged(int value);
void showDesktopModeChanged(int value);
void switchingModeChanged(int value);
void layoutNameChanged(const QString &layoutName);
void effectConfigButtonClicked(); void effectConfigButtonClicked();
void shortcutChanged();
private Q_SLOTS: private Q_SLOTS:
void tabBoxToggled(bool on); void tabBoxToggled(bool on);
@ -123,14 +81,41 @@ private Q_SLOTS:
void onSwitchingMode(); void onSwitchingMode();
void onEffectCombo(); void onEffectCombo();
void onShortcutChanged(const QKeySequence &seq); void onShortcutChanged(const QKeySequence &seq);
void updateDefaultIndicators();
private: private:
void setDefaultIndicatorVisible(QWidget *widget, bool visible); void setEnabledUi();
void applyDefaultIndicator(QList<QWidget *> widgets, bool visible);
// UI property getters
bool showTabBox() const;
int filterScreen() const;
int filterDesktop() const;
int filterActivities() const;
int filterMinimization() const;
int applicationMode() const;
int orderMinimizedMode() const;
int showDesktopMode() const;
int switchingMode() const;
QString layoutName() const;
// UI property setters
void setFilterScreen(TabBox::TabBoxConfig::ClientMultiScreenMode mode);
void setFilterDesktop(TabBox::TabBoxConfig::ClientDesktopMode mode);
void setFilterActivities(TabBox::TabBoxConfig::ClientActivitiesMode mode);
void setFilterMinimization(TabBox::TabBoxConfig::ClientMinimizedMode mode);
void setApplicationMode(TabBox::TabBoxConfig::ClientApplicationsMode mode);
void setOrderMinimizedMode(TabBox::TabBoxConfig::OrderMinimizedMode mode);
void setShowDesktopMode(TabBox::TabBoxConfig::ShowDesktopMode mode);
void setSwitchingModeChanged(TabBox::TabBoxConfig::ClientSwitchingMode mode);
void setLayoutName(const QString &layoutName);
private:
KActionCollection *m_actionCollection = nullptr; KActionCollection *m_actionCollection = nullptr;
TabBox::TabBoxSettings *m_config = nullptr;
bool m_showDefaultIndicator = false;
bool m_isHighlightWindowsEnabled = true; bool m_isHighlightWindowsEnabled = true;
TabboxType m_type;
Ui::KWinTabBoxConfigForm *ui; Ui::KWinTabBoxConfigForm *ui;
}; };

158
src/kcms/tabbox/main.cpp
View file

@ -4,6 +4,7 @@
SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org> SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org>
SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com> SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com>
SPDX-FileCopyrightText: 2023 Ismael Asensio <isma.af@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later SPDX-License-Identifier: GPL-2.0-or-later
*/ */
@ -53,8 +54,8 @@ KWinTabBoxConfig::KWinTabBoxConfig(QWidget *parent, const QVariantList &args)
, m_data(new KWinTabboxData(this)) , m_data(new KWinTabboxData(this))
{ {
QTabWidget *tabWidget = new QTabWidget(this); QTabWidget *tabWidget = new QTabWidget(this);
m_primaryTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Main, tabWidget); m_primaryTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Main, m_data->tabBoxConfig(), tabWidget);
m_alternativeTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Alternative, tabWidget); m_alternativeTabBoxUi = new KWinTabBoxConfigForm(KWinTabBoxConfigForm::TabboxType::Alternative, m_data->tabBoxAlternativeConfig(), tabWidget);
tabWidget->addTab(m_primaryTabBoxUi, i18n("Main")); tabWidget->addTab(m_primaryTabBoxUi, i18n("Main"));
tabWidget->addTab(m_alternativeTabBoxUi, i18n("Alternative")); tabWidget->addTab(m_alternativeTabBoxUi, i18n("Alternative"));
@ -85,7 +86,6 @@ KWinTabBoxConfig::KWinTabBoxConfig(QWidget *parent, const QVariantList &args)
initLayoutLists(); initLayoutLists();
connect(this, &KWinTabBoxConfig::defaultsIndicatorsVisibleChanged, this, &KWinTabBoxConfig::updateDefaultIndicator);
createConnections(m_primaryTabBoxUi); createConnections(m_primaryTabBoxUi);
createConnections(m_alternativeTabBoxUi); createConnections(m_alternativeTabBoxUi);
@ -98,9 +98,6 @@ KWinTabBoxConfig::KWinTabBoxConfig(QWidget *parent, const QVariantList &args)
} else { } else {
infoLabel->hide(); infoLabel->hide();
} }
setEnabledUi(m_primaryTabBoxUi, m_data->tabBoxConfig());
setEnabledUi(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
} }
KWinTabBoxConfig::~KWinTabBoxConfig() KWinTabBoxConfig::~KWinTabBoxConfig()
@ -187,106 +184,27 @@ void KWinTabBoxConfig::initLayoutLists()
m_alternativeTabBoxUi->setEffectComboModel(model); m_alternativeTabBoxUi->setEffectComboModel(model);
} }
void KWinTabBoxConfig::setEnabledUi(KWinTabBoxConfigForm *form, const TabBoxSettings *config)
{
form->setHighlightWindowsEnabled(!config->isHighlightWindowsImmutable());
form->setFilterScreenEnabled(!config->isMultiScreenModeImmutable());
form->setFilterDesktopEnabled(!config->isDesktopModeImmutable());
form->setFilterActivitiesEnabled(!config->isActivitiesModeImmutable());
form->setFilterMinimizationEnabled(!config->isMinimizedModeImmutable());
form->setApplicationModeEnabled(!config->isApplicationsModeImmutable());
form->setOrderMinimizedModeEnabled(!config->isOrderMinimizedModeImmutable());
form->setShowDesktopModeEnabled(!config->isShowDesktopModeImmutable());
form->setSwitchingModeEnabled(!config->isSwitchingModeImmutable());
form->setLayoutNameEnabled(!config->isLayoutNameImmutable());
}
void KWinTabBoxConfig::createConnections(KWinTabBoxConfigForm *form) void KWinTabBoxConfig::createConnections(KWinTabBoxConfigForm *form)
{ {
connect(form, &KWinTabBoxConfigForm::effectConfigButtonClicked, this, &KWinTabBoxConfig::configureEffectClicked); connect(form, &KWinTabBoxConfigForm::effectConfigButtonClicked, this, &KWinTabBoxConfig::configureEffectClicked);
connect(form, &KWinTabBoxConfigForm::configChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
connect(form, &KWinTabBoxConfigForm::filterScreenChanged, this, &KWinTabBoxConfig::updateUnmanagedState); connect(this, &KWinTabBoxConfig::defaultsIndicatorsVisibleChanged, form, &KWinTabBoxConfigForm::setDefaultIndicatorVisible);
connect(form, &KWinTabBoxConfigForm::filterDesktopChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
connect(form, &KWinTabBoxConfigForm::filterActivitiesChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
connect(form, &KWinTabBoxConfigForm::filterMinimizationChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
connect(form, &KWinTabBoxConfigForm::applicationModeChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
connect(form, &KWinTabBoxConfigForm::orderMinimizedModeChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
connect(form, &KWinTabBoxConfigForm::showDesktopModeChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
connect(form, &KWinTabBoxConfigForm::switchingModeChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
connect(form, &KWinTabBoxConfigForm::layoutNameChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
connect(form, &KWinTabBoxConfigForm::shortcutChanged, this, &KWinTabBoxConfig::updateUnmanagedState);
} }
void KWinTabBoxConfig::updateUnmanagedState() void KWinTabBoxConfig::updateUnmanagedState()
{ {
bool isNeedSave = false; bool isNeedSave = false;
isNeedSave |= updateUnmanagedIsNeedSave(m_primaryTabBoxUi, m_data->tabBoxConfig()); isNeedSave |= m_data->tabBoxConfig()->isSaveNeeded() || m_primaryTabBoxUi->isShortcutsChanged();
isNeedSave |= updateUnmanagedIsNeedSave(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig()); isNeedSave |= m_data->tabBoxAlternativeConfig()->isSaveNeeded() || m_alternativeTabBoxUi->isShortcutsChanged();
unmanagedWidgetChangeState(isNeedSave); unmanagedWidgetChangeState(isNeedSave);
bool isDefault = true; bool isDefault = true;
isDefault &= updateUnmanagedIsDefault(m_primaryTabBoxUi, m_data->tabBoxConfig()); isDefault &= m_data->tabBoxConfig()->isDefaults() && m_primaryTabBoxUi->isShortcutsDefault();
isDefault &= updateUnmanagedIsDefault(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig()); isDefault &= m_data->tabBoxAlternativeConfig()->isDefaults() && m_alternativeTabBoxUi->isShortcutsDefault();
unmanagedWidgetDefaultState(isDefault); unmanagedWidgetDefaultState(isDefault);
updateDefaultIndicator();
}
void KWinTabBoxConfig::updateDefaultIndicator()
{
const bool visible = defaultsIndicatorsVisible();
updateUiDefaultIndicator(visible, m_primaryTabBoxUi, m_data->tabBoxConfig());
updateUiDefaultIndicator(visible, m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
}
bool KWinTabBoxConfig::updateUnmanagedIsNeedSave(const KWinTabBoxConfigForm *form, const TabBoxSettings *config)
{
bool isNeedSave = false;
isNeedSave |= form->filterScreen() != config->multiScreenMode();
isNeedSave |= form->filterDesktop() != config->desktopMode();
isNeedSave |= form->filterActivities() != config->activitiesMode();
isNeedSave |= form->filterMinimization() != config->minimizedMode();
isNeedSave |= form->applicationMode() != config->applicationsMode();
isNeedSave |= form->orderMinimizedMode() != config->orderMinimizedMode();
isNeedSave |= form->showDesktopMode() != config->showDesktopMode();
isNeedSave |= form->switchingMode() != config->switchingMode();
isNeedSave |= form->layoutName() != config->layoutName();
isNeedSave |= form->isShortcutsChanged();
return isNeedSave;
}
bool KWinTabBoxConfig::updateUnmanagedIsDefault(KWinTabBoxConfigForm *form, const TabBoxSettings *config)
{
bool isDefault = true;
isDefault &= form->filterScreen() == config->defaultMultiScreenModeValue();
isDefault &= form->filterDesktop() == config->defaultDesktopModeValue();
isDefault &= form->filterActivities() == config->defaultActivitiesModeValue();
isDefault &= form->filterMinimization() == config->defaultMinimizedModeValue();
isDefault &= form->applicationMode() == config->defaultApplicationsModeValue();
isDefault &= form->orderMinimizedMode() == config->defaultOrderMinimizedModeValue();
isDefault &= form->showDesktopMode() == config->defaultShowDesktopModeValue();
isDefault &= form->switchingMode() == config->defaultSwitchingModeValue();
isDefault &= form->layoutName() == config->defaultLayoutNameValue();
isDefault &= form->isShortcutsDefault();
return isDefault;
}
void KWinTabBoxConfig::updateUiDefaultIndicator(bool visible, KWinTabBoxConfigForm *form, const TabBoxSettings *config)
{
form->setFilterScreenDefaultIndicatorVisible(visible && form->filterScreen() != config->defaultMultiScreenModeValue());
form->setFilterDesktopDefaultIndicatorVisible(visible && form->filterDesktop() != config->defaultDesktopModeValue());
form->setFilterActivitiesDefaultIndicatorVisible(visible && form->filterActivities() != config->defaultActivitiesModeValue());
form->setFilterMinimizationDefaultIndicatorVisible(visible && form->filterMinimization() != config->defaultMinimizedModeValue());
form->setApplicationModeDefaultIndicatorVisible(visible && form->applicationMode() != config->defaultApplicationsModeValue());
form->setOrderMinimizedDefaultIndicatorVisible(visible && form->orderMinimizedMode() != config->defaultOrderMinimizedModeValue());
form->setShowDesktopModeDefaultIndicatorVisible(visible && form->showDesktopMode() != config->defaultShowDesktopModeValue());
form->setSwitchingModeDefaultIndicatorVisible(visible && form->switchingMode() != config->defaultSwitchingModeValue());
form->setLayoutNameDefaultIndicatorVisible(visible && form->layoutName() != config->defaultLayoutNameValue());
form->setShortcutsDefaultIndicatorVisible(visible);
} }
void KWinTabBoxConfig::load() void KWinTabBoxConfig::load()
@ -296,11 +214,11 @@ void KWinTabBoxConfig::load()
m_data->tabBoxConfig()->load(); m_data->tabBoxConfig()->load();
m_data->tabBoxAlternativeConfig()->load(); m_data->tabBoxAlternativeConfig()->load();
updateUiFromConfig(m_primaryTabBoxUi, m_data->tabBoxConfig());
updateUiFromConfig(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
m_data->pluginsConfig()->load(); m_data->pluginsConfig()->load();
m_primaryTabBoxUi->updateUiFromConfig();
m_alternativeTabBoxUi->updateUiFromConfig();
m_primaryTabBoxUi->loadShortcuts(); m_primaryTabBoxUi->loadShortcuts();
m_alternativeTabBoxUi->loadShortcuts(); m_alternativeTabBoxUi->loadShortcuts();
@ -316,9 +234,6 @@ void KWinTabBoxConfig::save()
m_data->pluginsConfig()->setHighlightwindowEnabled(highlightWindows); m_data->pluginsConfig()->setHighlightwindowEnabled(highlightWindows);
m_data->pluginsConfig()->save(); m_data->pluginsConfig()->save();
updateConfigFromUi(m_primaryTabBoxUi, m_data->tabBoxConfig());
updateConfigFromUi(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig());
m_primaryTabBoxUi->saveShortcuts(); m_primaryTabBoxUi->saveShortcuts();
m_alternativeTabBoxUi->saveShortcuts(); m_alternativeTabBoxUi->saveShortcuts();
@ -335,8 +250,11 @@ void KWinTabBoxConfig::save()
void KWinTabBoxConfig::defaults() void KWinTabBoxConfig::defaults()
{ {
updateUiFromDefaultConfig(m_primaryTabBoxUi, m_data->tabBoxConfig()); m_data->tabBoxConfig()->setDefaults();
updateUiFromDefaultConfig(m_alternativeTabBoxUi, m_data->tabBoxAlternativeConfig()); m_data->tabBoxAlternativeConfig()->setDefaults();
m_primaryTabBoxUi->updateUiFromConfig();
m_alternativeTabBoxUi->updateUiFromConfig();
m_primaryTabBoxUi->resetShortcuts(); m_primaryTabBoxUi->resetShortcuts();
m_alternativeTabBoxUi->resetShortcuts(); m_alternativeTabBoxUi->resetShortcuts();
@ -344,46 +262,6 @@ void KWinTabBoxConfig::defaults()
KCModule::defaults(); KCModule::defaults();
updateUnmanagedState(); updateUnmanagedState();
} }
void KWinTabBoxConfig::updateUiFromConfig(KWinTabBoxConfigForm *form, const KWin::TabBox::TabBoxSettings *config)
{
form->setFilterScreen(static_cast<TabBoxConfig::ClientMultiScreenMode>(config->multiScreenMode()));
form->setFilterDesktop(static_cast<TabBoxConfig::ClientDesktopMode>(config->desktopMode()));
form->setFilterActivities(static_cast<TabBoxConfig::ClientActivitiesMode>(config->activitiesMode()));
form->setFilterMinimization(static_cast<TabBoxConfig::ClientMinimizedMode>(config->minimizedMode()));
form->setApplicationMode(static_cast<TabBoxConfig::ClientApplicationsMode>(config->applicationsMode()));
form->setOrderMinimizedMode(static_cast<TabBoxConfig::OrderMinimizedMode>(config->orderMinimizedMode()));
form->setShowDesktopMode(static_cast<TabBoxConfig::ShowDesktopMode>(config->showDesktopMode()));
form->setSwitchingModeChanged(static_cast<TabBoxConfig::ClientSwitchingMode>(config->switchingMode()));
form->setLayoutName(config->layoutName());
}
void KWinTabBoxConfig::updateConfigFromUi(const KWinTabBoxConfigForm *form, TabBoxSettings *config)
{
config->setMultiScreenMode(form->filterScreen());
config->setDesktopMode(form->filterDesktop());
config->setActivitiesMode(form->filterActivities());
config->setMinimizedMode(form->filterMinimization());
config->setApplicationsMode(form->applicationMode());
config->setOrderMinimizedMode(form->orderMinimizedMode());
config->setShowDesktopMode(form->showDesktopMode());
config->setSwitchingMode(form->switchingMode());
config->setLayoutName(form->layoutName());
}
void KWinTabBoxConfig::updateUiFromDefaultConfig(KWinTabBoxConfigForm *form, const KWin::TabBox::TabBoxSettings *config)
{
form->setFilterScreen(static_cast<TabBoxConfig::ClientMultiScreenMode>(config->defaultMultiScreenModeValue()));
form->setFilterDesktop(static_cast<TabBoxConfig::ClientDesktopMode>(config->defaultDesktopModeValue()));
form->setFilterActivities(static_cast<TabBoxConfig::ClientActivitiesMode>(config->defaultActivitiesModeValue()));
form->setFilterMinimization(static_cast<TabBoxConfig::ClientMinimizedMode>(config->defaultMinimizedModeValue()));
form->setApplicationMode(static_cast<TabBoxConfig::ClientApplicationsMode>(config->defaultApplicationsModeValue()));
form->setOrderMinimizedMode(static_cast<TabBoxConfig::OrderMinimizedMode>(config->defaultOrderMinimizedModeValue()));
form->setShowDesktopMode(static_cast<TabBoxConfig::ShowDesktopMode>(config->defaultShowDesktopModeValue()));
form->setSwitchingModeChanged(static_cast<TabBoxConfig::ClientSwitchingMode>(config->defaultSwitchingModeValue()));
form->setLayoutName(config->defaultLayoutNameValue());
}
void KWinTabBoxConfig::configureEffectClicked() void KWinTabBoxConfig::configureEffectClicked()
{ {
auto form = qobject_cast<KWinTabBoxConfigForm *>(sender()); auto form = qobject_cast<KWinTabBoxConfigForm *>(sender());
@ -392,7 +270,7 @@ void KWinTabBoxConfig::configureEffectClicked()
if (form->effectComboCurrentData(KWinTabBoxConfigForm::AddonEffect).toBool()) { if (form->effectComboCurrentData(KWinTabBoxConfigForm::AddonEffect).toBool()) {
// Show the preview for addon effect // Show the preview for addon effect
new LayoutPreview(form->effectComboCurrentData(KWinTabBoxConfigForm::LayoutPath).toString(), new LayoutPreview(form->effectComboCurrentData(KWinTabBoxConfigForm::LayoutPath).toString(),
form->showDesktopMode(), form->config()->desktopMode(),
this); this);
} }
} }

9
src/kcms/tabbox/main.h
View file

@ -4,6 +4,7 @@
SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org> SPDX-FileCopyrightText: 2009 Martin Gräßlin <mgraesslin@kde.org>
SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com> SPDX-FileCopyrightText: 2020 Cyril Rossi <cyril.rossi@enioka.com>
SPDX-FileCopyrightText: 2023 Ismael Asensio <isma.af@gmail.com>
SPDX-License-Identifier: GPL-2.0-or-later SPDX-License-Identifier: GPL-2.0-or-later
*/ */
@ -38,19 +39,11 @@ public Q_SLOTS:
private Q_SLOTS: private Q_SLOTS:
void updateUnmanagedState(); void updateUnmanagedState();
void updateDefaultIndicator();
void configureEffectClicked(); void configureEffectClicked();
private: private:
void updateUiFromConfig(KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
void updateConfigFromUi(const KWinTabBoxConfigForm *form, TabBox::TabBoxSettings *config);
void updateUiFromDefaultConfig(KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
void initLayoutLists(); void initLayoutLists();
void setEnabledUi(KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
void createConnections(KWinTabBoxConfigForm *form); void createConnections(KWinTabBoxConfigForm *form);
bool updateUnmanagedIsNeedSave(const KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
bool updateUnmanagedIsDefault(KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
void updateUiDefaultIndicator(bool visible, KWinTabBoxConfigForm *form, const TabBox::TabBoxSettings *config);
private: private:
KWinTabBoxConfigForm *m_primaryTabBoxUi = nullptr; KWinTabBoxConfigForm *m_primaryTabBoxUi = nullptr;