qsvgfont.cpp - mozsearch

++ // Copyright (C) 2016 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:significant reason:default

++

++

++ #include "qsvgfont_p.h"

++

++ #include "qpainter.h"

++ #include "qpen.h"

++ #include "qdebug.h"

++

++ QT_BEGIN_NAMESPACE

++

++ QSvgGlyph::QSvgGlyph(const QString &unicode, const QPainterPath &path, qreal horizAdvX)

++     : m_unicode(unicode), m_path(path), m_horizAdvX(horizAdvX)

++ {

++

++ }

++

++

++ QSvgFont::QSvgFont(qreal horizAdvX)

++     : m_horizAdvX(horizAdvX)

++ {

++ }

++

++ QSvgFont::~QSvgFont()

++     = default;

++

++ void QSvgFont::addGlyph(const QString &unicode, const QPainterPath &path, qreal horizAdvX)

++ {

++     m_glyphs.emplaceBack(unicode, path, (horizAdvX == -1) ? m_horizAdvX : horizAdvX);

++ }

++

++ bool QSvgFont::addMissingGlyph(const QPainterPath &path, qreal horizAdvX)

++ {

++     if (m_missingGlyph) {

++         qWarning("The font already has a 'missing-glyph' element.");

++         return false;

++     }

++     m_missingGlyph.reset(new QSvgGlyph(QChar(), path, (horizAdvX == -1) ? m_horizAdvX : horizAdvX));

++     return true;

++ }

++

++

++ void QSvgFont::draw(QPainter *p, const QPointF &point, const QList<const QSvgGlyph *> &glyphs,

++                     qreal pixelSize, Qt::Alignment alignment) const

++ {

++     draw_helper(p, point, glyphs, pixelSize, alignment, nullptr);

++ }

++

++ QRectF QSvgFont::boundingRect(QPainter *p, const QPointF &point,

++                               const QList<const QSvgGlyph *> &glyphs,

++                               qreal pixelSize, Qt::Alignment alignment) const

++ {

++     QRectF bounds;

++     draw_helper(p, point, glyphs, pixelSize, alignment, &bounds);

++     return bounds;

++ }

++

++ // text must not be empty

++ char32_t firstUcs4(QStringView text)

++ {

++     if (text.size() > 1 && text.at(0).isHighSurrogate() && text.at(1).isLowSurrogate())

++         return QChar::surrogateToUcs4(text.at(0), text.at(1));

++

++     return text.first().unicode();

++ }

++

++ // returns a pointer to the first QSvgGlyph to be used in the text

++ // or nullptr if none can be found

++ const QSvgGlyph *QSvgFont::findFirstGlyphFor(QStringView text) const

++ {

++     const auto possibleIndices = m_possibleGlyphIndicesForChar.value(firstUcs4(text));

++     for (const qsizetype i : possibleIndices) {

++         const QSvgGlyph &currentGlyph = m_glyphs.at(i);

++         if (text.startsWith(currentGlyph.m_unicode)) {

++             return &currentGlyph;

++         }

++     }

++

++     for (; m_firstUnscannedGlyphIdx < m_glyphs.size(); ++m_firstUnscannedGlyphIdx) {

++         const QSvgGlyph &currentGlyph = m_glyphs.at(m_firstUnscannedGlyphIdx);

++         m_possibleGlyphIndicesForChar[firstUcs4(currentGlyph.m_unicode)].push_back(m_firstUnscannedGlyphIdx);

++         if (text.startsWith(currentGlyph.m_unicode)) {

++             ++m_firstUnscannedGlyphIdx;

++             return &currentGlyph;

++         }

++     }

++     return nullptr;

++ }

++

++ QList<const QSvgGlyph *> QSvgFont::toGlyphs(QStringView text) const

++ {

++     QList<const QSvgGlyph *> glyphs;

++     glyphs.reserve(text.length());

++     while (text.length()) {

++         const QSvgGlyph *foundGlyph = findFirstGlyphFor(text);

++         if (foundGlyph) {

++             glyphs.append(foundGlyph);

++             text.slice(foundGlyph->m_unicode.length());

++         } else {

++             if (m_missingGlyph)

++                 glyphs.append(m_missingGlyph.get());

++             if (text.size() > 1

++                 && text.at(0).isHighSurrogate() && text.at(1).isLowSurrogate()) {

++                 text.slice(2);

++             } else {

++                 text.slice(1);

++             }

++         }

++     }

++     return glyphs;

++ }

++

++ void QSvgFont::draw_helper(QPainter *p, const QPointF &point,

++                            const QList<const QSvgGlyph *> &glyphs, qreal pixelSize,

++                            Qt::Alignment alignment, QRectF *boundingRect) const

++ {

++     const bool isPainting = (boundingRect == nullptr);

++

++     p->save();

++     p->translate(point);

++     p->scale(pixelSize / m_unitsPerEm, -pixelSize / m_unitsPerEm);

++

++     // Calculate the text width to be used for alignment

++     int textWidth = 0;

++     for (const auto *glyph : glyphs)

++         textWidth += static_cast<int>(glyph->m_horizAdvX);

++

++     QPoint alignmentOffset(0, 0);

++     if (alignment == Qt::AlignHCenter) {

++         alignmentOffset.setX(-textWidth / 2);

++     } else if (alignment == Qt::AlignRight) {

++         alignmentOffset.setX(-textWidth);

++     }

++

++     p->translate(alignmentOffset);

++

++     // since in SVG the embedded font ain't really a path

++     // the outline has got to stay untransformed...

++     qreal penWidth = p->pen().widthF();

++     penWidth /= (pixelSize/m_unitsPerEm);

++     QPen pen = p->pen();

++     pen.setWidthF(penWidth);

++     p->setPen(pen);

++

++     for (const auto *glyph : glyphs) {

++         if (isPainting)

++             p->drawPath(glyph->m_path);

++

++         if (boundingRect) {

++             QPainterPathStroker stroker;

++             stroker.setWidth(penWidth);

++             stroker.setJoinStyle(p->pen().joinStyle());

++             stroker.setMiterLimit(p->pen().miterLimit());

++             QPainterPath stroke = stroker.createStroke(glyph->m_path);

++             *boundingRect |= p->transform().map(stroke).boundingRect();

++         }

++

++         p->translate(glyph->m_horizAdvX, 0);

++     }

++

++     p->restore();

++ }

++

++ void QSvgFont::setUnitsPerEm(qreal upem)

++ {

++     m_unitsPerEm = upem;

++ }

++

++ QT_END_NAMESPACE

Revision control