renderer.cpp

Go to the documentation of this file.

#include "./renderer.h"
 
#include "resources/config.h"
 
#include <QDebug>
#include <QFile>
#include <QGuiApplication>
#include <QHash>
#include <QIcon>
#include <QMargins>
#include <QPaintDevice>
#include <QPainter>
#include <QPainterPath>
#include <QRawFont>
 
#include <utility>

namespace QtForkAwesome {

 
struct IconOverride {
    void setIcon(const QIcon &icon);
    void addIconName(const QString &iconName);
    const QIcon &locateIcon();
 
private:
    QStringList iconNames;
    QIcon cachedIcon;
};
 
void IconOverride::setIcon(const QIcon &icon)
{
    iconNames.clear();
    cachedIcon = icon;
}
 
void IconOverride::addIconName(const QString &iconName)
{
    iconNames.append(iconName);
    if (!cachedIcon.isNull()) {
        cachedIcon = QIcon();
    }
}
 
const QIcon &IconOverride::locateIcon()
{
    if (!cachedIcon.isNull()) {
        return cachedIcon;
    }
    for (const auto &iconName : std::as_const(iconNames)) {
        cachedIcon = QIcon::fromTheme(iconName);
        if (!cachedIcon.isNull()) {
            return cachedIcon;
        }
    }
    return cachedIcon;
}
 
struct Renderer::InternalData {
    explicit InternalData(const QString &fontFilePath);
    explicit InternalData(const QByteArray &fontData);
 
    QString fontFilePath;
    QHash<QChar, IconOverride> overrides;
    QPaintDevice *paintDevice;
    QRawFont rawFont;
};
 
Renderer::InternalData::InternalData(const QString &fontFilePath)
    : fontFilePath(fontFilePath)
    , paintDevice(nullptr)
    , rawFont(fontFilePath, 12)
{
}
 
Renderer::InternalData::InternalData(const QByteArray &fontData)
    : paintDevice(nullptr)
    , rawFont(fontData, 12)
{
}



Renderer::Renderer(const QString &fontFileName)
    : m_d(std::make_unique<InternalData>(fontFileName.isEmpty() ? QStringLiteral(":/" META_FONT_FILE_NAME) : fontFileName))
{
}

Renderer::Renderer(const QByteArray &fontData)
    : m_d(std::make_unique<InternalData>(fontData))
{
}

Renderer::~Renderer()
{
}

const QString &Renderer::fontFilePath() const
{
    return m_d->fontFilePath;
}

void Renderer::warnIfInvalid() const
{
    if (!*this) {
        const auto &path = m_d->fontFilePath;
        if (!path.isEmpty() && !QFile::exists(path)) {
            qWarning() << "ForkAwesome font file does not exist under:" << path;
        }
        qWarning() << "Unable to load ForkAwesome font from " << (path.isEmpty() ? QStringLiteral("buffer") : path);
    }
}

Renderer::operator bool() const
{
    return m_d->rawFont.isValid();
}

static constexpr auto renderMargins = QMargins(1, 1, 1, 1);

static void renderInternally(QChar character, QPainter *painter, const QRawFont &rawFont, const QRect &rect, const QColor &color)
{
    // create a new font to set the size according to the height of rect
    auto font = QRawFont(rawFont);
    font.setPixelSize(rect.height());
 
    // compute the glyph index and the path and bounds of the glyph
    const auto glyphIndexes = font.glyphIndexesForString(QString(character));
    if (glyphIndexes.isEmpty()) {
        return;
    }
    const auto glyphPath = rawFont.pathForGlyph(glyphIndexes.first());
    const auto glyphBounds = glyphPath.boundingRect();
    if (glyphBounds.isEmpty()) {
        return;
    }
 
    // scale the path to render it centered within rect keeping the aspect ratio
    const auto rectWithMargins = rect - renderMargins;
    const auto scaleX = rectWithMargins.width() / glyphBounds.width();
    const auto scaleY = rectWithMargins.height() / glyphBounds.height();
    const auto scale = qMin(scaleX, scaleY);
    const auto rectCenter = rectWithMargins.center();
    const auto glyphBoundsCenter = glyphBounds.center();
    const auto dx = rectCenter.x() - (glyphBoundsCenter.x() * scale);
    const auto dy = rectCenter.y() - (glyphBoundsCenter.y() * scale);
    const auto scaledPath = QTransform().translate(dx, dy).scale(scale, scale).map(glyphPath);
 
    painter->fillPath(scaledPath, color);
}

void QtForkAwesome::Renderer::render(QChar character, QPainter *painter, const QRect &rect, const QColor &color) const
{
    if (auto override = m_d->overrides.find(character); override != m_d->overrides.end()) {
        if (const auto &overrideIcon = override->locateIcon(); !overrideIcon.isNull()) {
            overrideIcon.paint(painter, rect, Qt::AlignCenter, QIcon::Normal, QIcon::On);
            return;
        }
    }
    if (*this) {
        renderInternally(character, painter, m_d->rawFont, rect, color);
    }
}

QPixmap Renderer::pixmap(QChar icon, const QSize &size, const QColor &color, qreal scaleFactor) const
{
    if (auto override = m_d->overrides.find(icon); override != m_d->overrides.end()) {
        if (const auto &overrideIcon = override->locateIcon(); !overrideIcon.isNull()) {
            return overrideIcon.pixmap(size, QIcon::Normal, QIcon::On);
        }
    }
 
    if (!static_cast<bool>(scaleFactor)) {
        scaleFactor =
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
            !QCoreApplication::testAttribute(Qt::AA_UseHighDpiPixmaps)
            ? 1.0
            :
#endif
            (m_d->paintDevice ? m_d->paintDevice->devicePixelRatioF() : qGuiApp->devicePixelRatio());
    }
 
    const auto scaledSize = QSize(size * scaleFactor);
    auto pm = QPixmap(scaledSize);
    pm.fill(QColor(Qt::transparent));
    if (*this) {
        auto painter = QPainter(&pm);
        painter.setRenderHint(QPainter::Antialiasing);
        renderInternally(icon, &painter, m_d->rawFont, QRect(QPoint(), scaledSize), color);
    }
    pm.setDevicePixelRatio(scaleFactor);
    return pm;
}

QPixmap Renderer::pixmap(Icon icon, const QSize &size, const QColor &color, qreal scaleFactor) const
{
    return pixmap(QChar(static_cast<IconBaseType>(icon)), size, color, scaleFactor);
}

QPixmap QtForkAwesome::Renderer::pixmap(QChar icon, const QSize &size, const QColor &color) const
{
    return pixmap(icon, size, color, 0.0);
}

QPixmap Renderer::pixmap(Icon icon, const QSize &size, const QColor &color) const
{
    return pixmap(QChar(static_cast<IconBaseType>(icon)), size, color, 0.0);
}

void Renderer::addThemeOverride(QChar character, const QString &iconNameInTheme)
{
    m_d->overrides[character].addIconName(iconNameInTheme);
}

void Renderer::addOverride(QChar character, const QIcon &override)
{
    m_d->overrides[character].setIcon(override);
}

void Renderer::clearOverrides()
{
    m_d->overrides.clear();
}

void Renderer::setAssociatedPaintDevice(QPaintDevice *paintDevice)
{
    m_d->paintDevice = paintDevice;
}

Renderer &Renderer::global()
{
    static auto globalRenderer = Renderer();
    return globalRenderer;
}
 
} // namespace QtForkAwesome