font_manager.h

Go to the documentation of this file.

 
#ifndef FONT_MANAGER_H
#define FONT_MANAGER_H
 
#include <QByteArray>
#include <QFont>
#include <QList>
#include <QMutex>
#include <QObject>
#include <QPair>

class FontManager : public QObject
{
    Q_OBJECT
public:
    enum class ZoomScope {
        AppWide,
        ContentOnly
    };

    static FontManager *instance();
 
    // --- Value accessors: static only (single instance, no instance
    //     duplicates, so there is no static/instance name clash) ---

    static QFont font();
    static QFont monospaceFont();
    static QFont zoomedFont();
    static QFont zoomedMonospaceFont();

    static qreal zoomFactor();

    static QFont scaledFont(const QFont &base);

    static QFont fontFromName(const QString &name);
    static QString displayName(const QFont &font);
    static QFont guaranteeMonospace(const QFont &font);
    static QFont themeFont(const QString &fontName, bool monospace);
    static QFont preferenceMonospaceFont(const QFont &font);
 
    // --- Mutators & queries ---

    void setRegularFont(const QString &fontName);

    void setMonospaceFont(const QString &fontName);
 
    void zoomIn();
    void zoomOut();
    void resetZoom();
    void setZoomLevel(int level);

    void restoreZoomLevel();
    int  zoomLevel() const { return zoom_level_; }

    static constexpr int MinZoomLevel = -10;
    static constexpr int MaxZoomLevel = 10;
    bool canZoomIn() const { return zoom_level_ < MaxZoomLevel; }
    bool canZoomOut() const { return zoom_level_ > MinZoomLevel; }

    void reapplyApplicationFonts();
 
signals:
    void applicationFontChanged(QFont font);
    void monospaceFontChanged(QFont font);
    void zoomChanged();
 
protected:
    explicit FontManager(QObject *parent = nullptr);
    ~FontManager();
 
    // Catches two events on qApp.
    //
    // QEvent::ThemeChange: Qt sends it after a platform theme change (an OS
    // font change, but also a light/dark switch).  The system general font is
    // re-read and, when it differs from the last value seen and no theme/pref
    // overrides regular, adopted as the new base regular font.
    //
    // QEvent::ApplicationFontChange: a third-party QApplication::setFont()
    // call.  Distinguishes our own push from it by comparing the now-current
    // qApp->font() against applicationFont() (the value we would push): when
    // they match the change is ours and is ignored; when they differ the
    // font is adopted (unless a theme/pref overrides regular).
    bool eventFilter(QObject *watched, QEvent *event) override;
 
private:
    static FontManager *instance_;
    static QMutex       mutex_;
 
    QFont     base_regular_;
    QFont     base_monospace_;
    int       zoom_level_ = 0;
    ZoomScope zoom_scope_;
 
    // True when a theme or pref explicitly set the regular font; while set,
    // an external OS font change is NOT adopted (our override wins).
    bool regular_overridden_ = false;
 
    // System general font at construction.  While base_regular_ equals it,
    // the captured class fonts are used as they are (see classFont()).
    QFont base_platform_general_;
    // System general font as last seen by the QEvent::ThemeChange handler.
    QFont last_system_general_;
    // Per-class fonts the platform defined (hash key, font), captured in the
    // constructor before the first QApplication::setFont(), which discards
    // them.  Only keys the platform actually set are listed.
    QList<QPair<QByteArray, QFont>> base_class_fonts_;

    void adoptRegularFont(const QFont &font);
 
    QFont applicationFont() const;          
    QFont zoomed(const QFont &base) const;  
    QFont classFont(const QFont &platformClass) const;
    void  applyApplicationFont(bool force = false);
    void  applyZoom();                      
    void  syncMonospacePref();              
};
 
#endif /* FONT_MANAGER_H */