[WIP] Application theming support

app/src/filedialog.cpp

@@ -74,7 +74,7 @@ void FileDialog::setLastSavePaths(const QString& filePath)
     QFileInfo filePathInfo(filePath);
     QDir projectPath = filePathInfo.absoluteDir();
     QString baseName = filePathInfo.baseName();
-    QList<FileType> fileTypes = { FileType::IMAGE, FileType::IMAGE_SEQUENCE, FileType::GIF, FileType::MOVIE, FileType::SOUND, FileType::PALETTE };
+    QList<FileType> fileTypes = { FileType::IMAGE, FileType::IMAGE_SEQUENCE, FileType::GIF, FileType::MOVIE, FileType::SOUND, FileType::PALETTE, FileType::THEME_PALETTE };
     for (FileType& fileType : fileTypes)
     {
         setLastSavePath(fileType, projectPath.absoluteFilePath(defaultFileName(fileType, baseName)));
@@ -123,6 +123,7 @@ QString FileDialog::getDefaultExtensionByFileType(const FileType fileType)
     case FileType::PALETTE: return PFF_DEFAULT_PALETTE_EXT;
     case FileType::MOVIE: return PFF_DEFAULT_MOVIE_EXT;
     case FileType::SOUND: return PFF_DEFAULT_SOUND_EXT;
+    case FileType::THEME_PALETTE: return PFF_DEFAULT_THEME_PALETTE_EXT;
     default:
         Q_UNREACHABLE();
     }
@@ -172,6 +173,7 @@ QString FileDialog::openDialogCaption(FileType fileType)
     case FileType::MOVIE: return tr("Import movie");
     case FileType::SOUND: return tr("Import sound");
     case FileType::PALETTE: return tr("Open palette");
+    case FileType::THEME_PALETTE: return tr("Import color palette");
     }
     return "";
 }
@@ -188,6 +190,7 @@ QString FileDialog::saveDialogCaption(FileType fileType)
     case FileType::MOVIE: return tr("Export movie");
     case FileType::SOUND: return "";
     case FileType::PALETTE: return tr("Export palette");
+    case FileType::THEME_PALETTE: return "";
     }
     return "";
 }
@@ -204,6 +207,7 @@ QString FileDialog::openFileFilters(FileType fileType)
     case FileType::MOVIE: return PFF_MOVIE_EXT;
     case FileType::SOUND: return PFF_SOUND_EXT_FILTER;
     case FileType::PALETTE: return PFF_PALETTE_EXT_FILTER;
+    case FileType::THEME_PALETTE: return PFF_THEME_PALETTE_EXT_FILTER;
     }
     return "";
 }
@@ -220,6 +224,7 @@ QString FileDialog::saveFileFilters(FileType fileType)
     case FileType::MOVIE: return "MP4 (*.mp4);; AVI (*.avi);; WebM (*.webm);; APNG (*.apng)";
     case FileType::SOUND: return "";
     case FileType::PALETTE: return PFF_PALETTE_EXT_FILTER;
+    case FileType::THEME_PALETTE: return "";
     }
     return "";
 }
@@ -295,6 +300,7 @@ QString FileDialog::toSettingKey(FileType fileType)
     case FileType::MOVIE: return "Movie";
     case FileType::SOUND: return "Sound";
     case FileType::PALETTE: return "Palette";
+    case FileType::THEME_PALETTE: return "ThemePalette";
     }
     return "";
 }

app/src/generalpage.cpp

@@ -18,12 +18,16 @@ GNU General Public License for more details.
 #include "generalpage.h"
 
 #include <memory>
+#include <QFileInfo>
 #include <QMessageBox>
 #include <QSettings>
 #include <QTranslator>
 
+#include "errordialog.h"
+#include "filedialog.h"
 #include "pencildef.h"
 #include "preferencemanager.h"
+#include "theming.h"
 
 #include "ui_generalpage.h"
 
@@ -33,6 +37,11 @@ GeneralPage::GeneralPage() : ui(new Ui::GeneralPage)
 
     QSettings settings(PENCIL2D, PENCIL2D);
 
+    ui->styleCombo->addItem("System Default", "");
+    ui->styleCombo->addItems(Theming::availableStyles());
+
+    populatePaletteCombo(false);
+
     QString languages [][3]
         {
             // translatable string, endonym, locale code
@@ -77,6 +86,10 @@ GeneralPage::GeneralPage() : ui(new Ui::GeneralPage)
         ui->languageCombo->addItem(itemText, localeCode);
     }
 
+    QIcon warningIcon = style()->standardIcon(QStyle::SP_MessageBoxWarning);
+    ui->paletteWarningLabel->setPixmap(warningIcon.pixmap(28, 28));
+    ui->paletteWarningLabel->setVisible(false);
+
     int value = settings.value("windowOpacity").toInt();
     ui->windowOpacityLevel->setValue(100 - value);
 
@@ -109,6 +122,10 @@ GeneralPage::GeneralPage() : ui(new Ui::GeneralPage)
     connect(ui->languageCombo, curIndexChanged, this, &GeneralPage::languageChanged);
     connect(ui->windowOpacityLevel, &QSlider::valueChanged, this, &GeneralPage::windowOpacityChange);
     connect(ui->backgroundButtons, buttonClicked, this, &GeneralPage::backgroundChanged);
+    connect(ui->styleCombo, curIndexChanged, this, &GeneralPage::styleChanged);
+    connect(ui->paletteCombo, curIndexChanged, this, &GeneralPage::paletteChanged);
+    connect(ui->addPaletteButton, &QPushButton::pressed, this, &GeneralPage::addPalette);
+    connect(ui->removePaletteButton, &QPushButton::pressed, this, &GeneralPage::removePalette);
     connect(ui->shadowsBox, &QCheckBox::stateChanged, this, &GeneralPage::shadowsCheckboxStateChanged);
     connect(ui->toolCursorsBox, &QCheckBox::stateChanged, this, &GeneralPage::toolCursorsCheckboxStateChanged);
     connect(ui->antialiasingBox, &QCheckBox::stateChanged, this, &GeneralPage::antiAliasCheckboxStateChanged);
@@ -150,6 +167,13 @@ void GeneralPage::updateValues()
     ui->curveSmoothingLevel->setValue(mManager->getInt(SETTING::CURVE_SMOOTHING));
     QSignalBlocker b2(ui->windowOpacityLevel);
     ui->windowOpacityLevel->setValue(100 - mManager->getInt(SETTING::WINDOW_OPACITY));
+    QSignalBlocker b19(ui->styleCombo);
+    int styleIndex = ui->styleCombo->findText(mManager->getString(SETTING::STYLE_ID), Qt::MatchFixedString);
+    ui->styleCombo->setCurrentIndex(qMax(0, styleIndex));
+    QSignalBlocker b20(ui->styleCombo);
+    QString paletteKey = mManager->getString(SETTING::PALETTE_ID);
+    setCurrentPalette(paletteKey);
+    ui->removePaletteButton->setEnabled(!paletteKey.isEmpty() && !Theming::getPalette(paletteKey).isBuiltIn());
     QSignalBlocker b3(ui->shadowsBox);
     ui->shadowsBox->setChecked(mManager->isOn(SETTING::SHADOW));
     QSignalBlocker b4(ui->toolCursorsBox);
@@ -249,6 +273,60 @@ void GeneralPage::highResCheckboxStateChanged(int b)
     mManager->set(SETTING::HIGH_RESOLUTION, b != Qt::Unchecked);
 }
 
+void GeneralPage::styleChanged(int index)
+{
+    mManager->set(SETTING::STYLE_ID, ui->styleCombo->itemText(index));
+}
+
+void GeneralPage::paletteChanged(int index)
+{
+    QString paletteKey = ui->paletteCombo->itemData(index).toString();
+    mManager->set(SETTING::PALETTE_ID, paletteKey);
+    ui->removePaletteButton->setEnabled(!paletteKey.isEmpty() && !Theming::getPalette(paletteKey).isBuiltIn());
+    if (m_showMissingPalette)
+    {
+        ui->paletteWarningLabel->setVisible(index == 1);
+    }
+}
+
+void GeneralPage::addPalette()
+{
+    QString filePath = FileDialog::getOpenFileName(this, FileType::THEME_PALETTE);
+    if (!filePath.isEmpty())
+    {
+        QFileInfo fileInfo(filePath);
+        auto result = Theming::addPalette(filePath);
+        Status st = result.first;
+        ThemeColorPalette newPalette = result.second;
+        if (st.ok())
+        {
+            mManager->set(SETTING::PALETTE_ID, newPalette.id());
+            populatePaletteCombo();
+        }
+        else
+        {
+            ErrorDialog errorDialog(st.title(), st.description(), st.details().html());
+            errorDialog.exec();
+        }
+    }
+}
+
+void GeneralPage::removePalette()
+{
+    QString key = ui->paletteCombo->currentData().toString();
+    Status st = Theming::removePalette(key);
+    if (st.ok())
+    {
+        ui->paletteCombo->removeItem(ui->paletteCombo->currentIndex());
+        ui->paletteCombo->setCurrentIndex(0);
+    }
+    else
+    {
+        ErrorDialog errorDialog(st.title(), st.description(), st.details().html());
+        errorDialog.exec();
+    }
+}
+
 void GeneralPage::shadowsCheckboxStateChanged(int b)
 {
     mManager->set(SETTING::SHADOW, b != Qt::Unchecked);
@@ -408,3 +486,57 @@ void GeneralPage::undoRedoCancelButtonPressed()
     ui->undoRedoGroupCancelButton->setDisabled(true);
     ui->undoRedoGroupApplyButton->setDisabled(true);
 }
+
+void GeneralPage::populatePaletteCombo(bool usePreference)
+{
+    {
+        QSignalBlocker b(ui->paletteCombo);
+
+        ui->paletteCombo->clear();
+        m_showMissingPalette = false;
+        ui->paletteCombo->addItem("Default", "");
+        ui->paletteCombo->insertSeparator(1);
+        QList<ThemeColorPalette> palettes = Theming::availablePalettes();
+        std::sort(palettes.begin(), palettes.end(), [](ThemeColorPalette a, ThemeColorPalette b) { return a.displayName().toLower() < b.displayName().toLower(); });
+        for (const auto& palette : palettes)
+        {
+            if (palette.isDark()) continue;
+            ui->paletteCombo->addItem(palette.displayName(), palette.id());
+        }
+        ui->paletteCombo->insertSeparator(ui->paletteCombo->count());
+        for (const auto& palette : palettes)
+        {
+            if (!palette.isDark()) continue;
+            ui->paletteCombo->addItem(palette.displayName(), palette.id());
+        }
+    }
+
+    if (usePreference)
+    {
+        setCurrentPalette(mManager->getString(SETTING::PALETTE_ID));
+        QString paletteKey = mManager->getString(SETTING::PALETTE_ID);
+    }
+}
+
+void GeneralPage::setCurrentPalette(const QString& paletteKey)
+{
+    int paletteIndex = ui->paletteCombo->findData(paletteKey, Qt::UserRole, Qt::MatchFixedString);
+    ThemeColorPalette palette = Theming::getPalette(paletteKey);
+    if (paletteIndex >= 0)
+    {
+        ui->paletteCombo->setCurrentIndex(paletteIndex);
+    }
+    else if (palette.isValid())
+    {
+        populatePaletteCombo(false);
+        paletteIndex = ui->paletteCombo->findData(paletteKey, Qt::UserRole, Qt::MatchFixedString);
+        ui->paletteCombo->setCurrentIndex(paletteIndex);
+    }
+    else
+    {
+        ui->paletteCombo->insertItem(1, palette.displayName(), paletteKey);
+        ui->paletteCombo->setCurrentIndex(1);
+        m_showMissingPalette = true;
+        ui->paletteWarningLabel->setVisible(true);
+    }
+}

app/src/generalpage.h

@@ -48,6 +48,10 @@ public slots:
 
 private slots:
     void languageChanged(int i);
+    void styleChanged(int index);
+    void paletteChanged(int index);
+    void addPalette();
+    void removePalette();
     void shadowsCheckboxStateChanged(int b);
     void antiAliasCheckboxStateChanged(int b);
     void toolCursorsCheckboxStateChanged(int b);
@@ -65,12 +69,15 @@ private slots:
     void undoRedoCancelButtonPressed();
 
 private:
+    void populatePaletteCombo(bool usePreference = true);
+    void setCurrentPalette(const QString& paletteKey);
 
     bool canApplyOrCancelUndoRedoChanges() const;
     void updateSafeHelperTextEnabledState();
 
     Ui::GeneralPage* ui = nullptr;
     PreferenceManager* mManager = nullptr;
+    bool m_showMissingPalette = false;
 };
 
 #endif // GENERALPAGE_H

app/src/pencil2d.cpp

@@ -24,6 +24,7 @@ GNU General Public License for more details.
 #include <QIcon>
 #include <QLibraryInfo>
 #include <QSettings>
+#include <QStyle>
 #include <QTranslator>
 #include <QLockFile>
 #include <QStandardPaths>
@@ -32,17 +33,20 @@ GNU General Public License for more details.
 
 #include "commandlineexporter.h"
 #include "commandlineparser.h"
+#include "editor.h"
 #include "mainwindow2.h"
 #include "pencildef.h"
 #include "platformhandler.h"
+#include "theming.h"
 
 
 #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
 #include <clocale>
 #endif
 
 Pencil2D::Pencil2D(int& argc, char** argv) :
-    QApplication(argc, argv)
+    QApplication(argc, argv),
+    DEFAULT_STYLE(style()->objectName())
 {
     // Set organization and application name
     setOrganizationName("Pencil2D");
@@ -134,6 +138,32 @@ bool Pencil2D::event(QEvent* event)
     return QApplication::event(event);
 }
 
+void Pencil2D::setTheme(const QString styleId, const QString paletteId)
+{
+    QStyle* newStyle = Theming::getStyle(styleId);
+    if (newStyle != nullptr)
+    {
+        setStyle(newStyle);
+    }
+    else
+    {
+        newStyle = setStyle(DEFAULT_STYLE);
+    }
+
+    // Palette should be set after style is set
+    ThemeColorPalette palette(Theming::getPalette(paletteId));
+    if (palette.isValid())
+    {
+        setPalette(palette.palette());
+    }
+    else
+    {
+        setPalette(newStyle->standardPalette());
+    }
+
+    mainWindow->update();
+}
+
 void Pencil2D::installTranslators()
 {
     QSettings setting(PENCIL2D, PENCIL2D);
@@ -171,7 +201,21 @@ void Pencil2D::prepareGuiStartup(const QString& inputPath)
     PlatformHandler::configurePlatformSpecificSettings();
 
     mainWindow.reset(new MainWindow2);
+    PreferenceManager* prefs = mainWindow->mEditor->preference();
+    setTheme(prefs->getString(SETTING::STYLE_ID), prefs->getString(SETTING::PALETTE_ID));
+
     connect(this, &Pencil2D::openFileRequested, mainWindow.get(), &MainWindow2::openFile);
+    connect(prefs, &PreferenceManager::optionChanged, [=](SETTING setting) {
+        switch (setting)
+        {
+        case SETTING::STYLE_ID:
+        case SETTING::PALETTE_ID:
+            setTheme(prefs->getString(SETTING::STYLE_ID), prefs->getString(SETTING::PALETTE_ID));
+            break;
+        default:
+            break;
+        }
+    });
     mainWindow->show();
 
     mainWindow->openStartupFile(inputPath);

app/src/pencil2d.h

@@ -72,6 +72,7 @@ class Pencil2D : public QApplication
 
     bool event(QEvent* event) override;
 
+    void setTheme(const QString styleId, const QString paletteId);
 signals:
     /**
      * Emitted when the operating system requests that a file should be opened.
@@ -93,6 +94,8 @@ class Pencil2D : public QApplication
      */
     void prepareGuiStartup(const QString &inputPath);
 
+    const QString DEFAULT_STYLE;
+
     std::unique_ptr<MainWindow2> mainWindow;
 
     std::unique_ptr<QLockFile> mProcessLock;