theme_manager.h

Go to the documentation of this file.

 
#ifndef THEME_MANAGER_H
#define THEME_MANAGER_H
 
#include <QColor>
#include <QFont>
#include <QHash>
#include <QMutex>
#include <QObject>
#include <QPalette>
#include <QString>
 
class SystemThemeDetector;
 
struct ThemeInfo {
    QString name;           
    QString internalName;   
    int     version = 0;    
    QString description;    
    QString author;         
};
 
struct ThemeSectionInfo {
    bool required;
    QStringList tokens;
};
 
struct ThemeColorPair {
    QColor light;
    QColor dark;
};
 
class ThemeManager : public QObject {
    Q_OBJECT
public:
 
    enum class ThemeMode {
        System,
        Dark,
        Light
    };
    Q_ENUM(ThemeMode)
 
    enum ThemeToken {
        // Brand
        BrandPrimary,
        BrandDeep,
 
        // Accent
        AccentSuccess,
        AccentWarning,
        AccentError,
        AccentInfo,
 
        // Expert
        ExpertComment,
        ExpertChat,
        ExpertNote,
        ExpertWarn,
        ExpertError,
        ExpertForeground,
 
        // Packets — for each state, <Name> is the row background tint and
        // <Name>Text is the foreground.  Hidden is text-only by design (it
        // dims an item that otherwise renders with the normal row bg).
        // When a theme omits a Text token, ThemeTokenHandler derives it
        // from contrastingText(<Name>) or PaletteText as appropriate.
        PacketsSelection,
        PacketsSelectionText,
        PacketsInactive,
        PacketsInactiveText,
        PacketsMarked,
        PacketsMarkedText,
        PacketsIgnored,
        PacketsIgnoredText,
        PacketsHidden,
 
        // Conversation — same fg/bg convention as Packets.
        ConversationClient,
        ConversationClientText,
        ConversationServer,
        ConversationServerText,
 
        // Filter state (single color per state — use as bg tint; pair
        // with QPalette::Text for foreground).  Derived from accent.
        FilterValid,
        FilterInvalid,
        FilterDeprecated,
 
        // Syntax highlighting — foreground text colours for code- and
        // data-viewers (JSON, hex, Lua debugger, etc.).  Derived so
        // the variant is darker in light mode and lighter in dark
        // mode, keeping enough contrast against PaletteBase.
        SyntaxKey,
        SyntaxString,
        SyntaxNumber,
 
        // Palette Overrides
        PaletteWindow,
        PaletteBase,
        PaletteText,
        PaletteWindowText,
        PaletteAlternateBase,
        PaletteMid,
        PaletteMidLight,
#if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)
        PaletteAccent,
#endif
 
        // Header (derived from brand)
        HeaderGradientStart,
        HeaderGradientEnd,
 
        // Section headers (derived from brand + QPalette)
        SectionHeader,
        SectionHeaderHover,
 
        // Text on dark surfaces (derived from brand)
        TextOnDark,
        TextOnDarkMuted,
 
        // Update bar (derived from accent.success)
        UpdateGradientStart,
        UpdateGradientEnd,
        UpdateBorder,
        UpdateText,
        UpdateTextHighlight,
        UpdateLink,
        UpdateLinkHover,
        UpdateLinkPressed,
        UpdateButtonBg,
        UpdateButtonHover,
        UpdateButtonPressed,
        UpdateButtonDisabledBg,
        UpdateButtonDisabledText,
        UpdateDismissHoverBg,
        UpdateDismissPressedBg,
 
        // Accent aliases (derived)
        HighlightColorOrange,
        HighlightColorGreen,
 
        // None
        NoRole
    };
    Q_ENUM(ThemeToken)
 
    static ThemeManager* instance();
 
    static void init(const QString &theme = QStringLiteral("default"));
 
    void cleanup();
 
    ThemeInfo info() const;
 
    static QList<ThemeInfo> availableThemes();
 
    QColor color(ThemeToken role) const;
 
    bool colorIsAvailable(ThemeToken role) const;
 
    QHash<ThemeToken, QColor> previewTheme(const QString &internalName,
                                           bool wantDark) const;
 
    QString loadStyleSheet(const QString &name) const;
 
    static QString styleSheet(const QString &name);
 
    static void setValidationState(QWidget *w, const QString &state);
 
    static bool isDark();
 
    bool isDarkMode() const;
 
    ThemeMode mode() const;
 
    void setMode(ThemeMode mode);
 
    QColor graphColor(int idx) const;
 
    QColor graphDefaultColor() const;
 
    qsizetype graphColorCount() const;
 
    QFont regularFont() const;
    QFont monospaceFont() const;
 
signals:
    void themeChanged();
 
protected:
    explicit ThemeManager(QObject *parent = nullptr);
    ~ThemeManager();
 
private:
    static ThemeManager* instance_;
    static QMutex mutex_;
 
    ThemeInfo info_;
 
    // Flattened token -> color value, one map per mode
    QHash<ThemeManager::ThemeToken, ThemeColorPair> themeColors_;
    QList<ThemeColorPair> graphColors_;
 
    QFont regular_font_;
    QFont monospace_font_;
 
    QHash<QString, ThemeSectionInfo> sections_;
 
    // mapping caches for role and palette resolution
    QHash<QString, ThemeToken> colorRoleCache_;
    QHash<QString, QPalette::ColorRole> paletteRoleCache_;
 
    // Light/dark selection: user's explicit choice plus the detector
    // that tracks the OS preference when mode == System.  The detector
    // is a private member — external code never sees it.  Lifetime is
    // managed via Qt's parent-child ownership: constructed with `this`
    // as parent, destroyed automatically with the ThemeManager.
    ThemeMode mode_ = ThemeMode::System;
    SystemThemeDetector *detector_ = nullptr;
 
    // Pristine OS palette snapshot used as the baseline when the palette
    // builder constructs a new theme palette.  Captured once at ctor
    // entry (before any setPalette() call could pollute QApplication's
    // live palette), and refreshed from `qApp->style()->standardPalette()`
    // whenever the effective light/dark scheme changes (mode flip or OS
    // notification).  Using this snapshot instead of
    // QApplication::palette() prevents the previous theme's palette
    // overrides from leaking into the next theme's baseline — without it,
    // switching from a theme with palette overrides (e.g. "inverted") to
    // one without (e.g. "default") would leave the prior overrides
    // visible.  Only consulted on platforms where the OS palette is
    // trusted (macOS, Windows Qt ≥ 6.8); ignored elsewhere.
    QPalette osBaseline_;
 
    QPalette baselineForBuild() const;
 
    void reapplyForSchemeChange();
 
    static ThemeMode modeFromPrefs(int gui_color_scheme);
 
    void applyToStyleHints();
 
    void applyApplicationStyleSheet();
 
    bool loadTheme(const QString &themeName = QStringLiteral("default"));
 
};
 
#endif /* THEME_MANAGER_H */