KoSvgTextShape_p_glyphs.cpp File Reference

#include "KoSvgTextShape.h"
#include "KoSvgTextShape_p.h"
#include "KisTofuGlyph.h"
#include "KoFontLibraryResourceUtils.h"
#include <FlakeDebug.h>
#include <KoPathShape.h>
#include <kis_global.h>
#include <QPainterPath>
#include <QtMath>
#include <utility>
#include <variant>
#include <ft2build.h>
#include <hb.h>
#include <hb-ft.h>
#include <raqm.h>

Go to the source code of this file.

Classes
class	ColorLayersLoader
	Helper class to load CPAL/COLR v0 color layers, functionally based off the sample code in the freetype docs. More...

Functions
static std::pair< QTransform, QTransform >	calcOutlineGlyphTransform (const QTransform &ftTF, const raqm_glyph_t &currentGlyph, const CharacterResult &charResult, const bool isHorizontal)
	Calculate the transformation matrices for an outline glyph, taking synthesized italic into account.
static QImage	convertFromFreeTypeBitmap (FT_GlyphSlotRec *glyphSlot)
static QPainterPath	convertFromFreeTypeOutline (FT_GlyphSlotRec *glyphSlot)
static void	emboldenGlyphIfNeeded (const FT_Face ftface, const CharacterResult &charResult, int *x_advance, int *y_advance)
	Embolden a glyph (synthesize bold) if the font does not have native bold.
bool	faceIsItalic (const FT_Face face)
static QString	glyphFormatToStr (const FT_Glyph_Format _v)

Function Documentation

calcOutlineGlyphTransform()

static std::pair< QTransform, QTransform > calcOutlineGlyphTransform ( const QTransform & ftTF, const raqm_glyph_t & currentGlyph, const CharacterResult & charResult, const bool isHorizontal )

static

Calculate the transformation matrices for an outline glyph, taking synthesized italic into account.

Parameters

ftTF	FT unit to 1/72 unit
currentGlyph
charResult
isHorizontal

Returns

std::pair<QTransform, QTransform> {outlineGlyphTf, glyphObliqueTf}

Definition at line 147 of file KoSvgTextShape_p_glyphs.cpp.

{
    QTransform outlineGlyphTf = QTransform::fromTranslate(currentGlyph.x_offset, currentGlyph.y_offset);
    QTransform glyphObliqueTf;
 
    // Check whether we need to synthesize italic by shearing the glyph:
    if (charResult.fontStyle != QFont::StyleNormal && !faceIsItalic(currentGlyph.ftface)) {
        // CSS Fonts Module Level 4, 2.4. Font style: the font-style property:
        // For `oblique`, "lack of an <angle> represents 14deg".
        constexpr double SLANT_14DEG = 0.24932800284318069162403993780486;
        if (isHorizontal) {
            glyphObliqueTf.shear(SLANT_14DEG, 0);
        } else {
            // For vertical mode, CSSWG says:
            // - Skew around the centre
            // - Right-side down and left-side up
            // https://github.com/w3c/csswg-drafts/issues/2869
            glyphObliqueTf.shear(0, -SLANT_14DEG);
        }
        outlineGlyphTf *= glyphObliqueTf;
    }
    outlineGlyphTf *= ftTF;
    return {outlineGlyphTf, glyphObliqueTf};
}

References faceIsItalic(), and CharacterResult::fontStyle.

convertFromFreeTypeBitmap()

static QImage convertFromFreeTypeBitmap ( FT_GlyphSlotRec * glyphSlot )

static

Definition at line 732 of file KoSvgTextShape_p_glyphs.cpp.

{
    KIS_ASSERT(glyphSlot->bitmap.width <= INT32_MAX);
    KIS_ASSERT(glyphSlot->bitmap.rows <= INT32_MAX);
    QImage img;
    const int height = static_cast<int>(glyphSlot->bitmap.rows);
    const QSize size(static_cast<int>(glyphSlot->bitmap.width), height);
 
    if (glyphSlot->bitmap.pixel_mode == FT_PIXEL_MODE_MONO) {
        img = QImage(size, QImage::Format_Mono);
        uchar *src = glyphSlot->bitmap.buffer;
        KIS_ASSERT(glyphSlot->bitmap.pitch >= 0);
        for (int y = 0; y < height; y++) {
            memcpy(img.scanLine(y), src, static_cast<size_t>(glyphSlot->bitmap.pitch));
            src += glyphSlot->bitmap.pitch;
        }
    } else if (glyphSlot->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY) {
        img = QImage(size, QImage::Format_Grayscale8);
        uchar *src = glyphSlot->bitmap.buffer;
        KIS_ASSERT(glyphSlot->bitmap.pitch >= 0);
        for (int y = 0; y < height; y++) {
            memcpy(img.scanLine(y), src, static_cast<size_t>(glyphSlot->bitmap.pitch));
            src += glyphSlot->bitmap.pitch;
        }
    } else if (glyphSlot->bitmap.pixel_mode == FT_PIXEL_MODE_BGRA) {
        img = QImage(size, QImage::Format_ARGB32_Premultiplied);
        const uint8_t *src = glyphSlot->bitmap.buffer;
        for (int y = 0; y < height; y++) {
            auto *argb = reinterpret_cast<QRgb *>(img.scanLine(y));
            for (unsigned int x = 0; x < glyphSlot->bitmap.width; x++) {
                argb[x] = qRgba(src[2], src[1], src[0], src[3]);
                src += 4;
            }
        }
    }
 
    return img;
}

References KIS_ASSERT, and KoShape::size().

convertFromFreeTypeOutline()

static QPainterPath convertFromFreeTypeOutline ( FT_GlyphSlotRec * glyphSlot )

static

Definition at line 642 of file KoSvgTextShape_p_glyphs.cpp.

{
    QPointF cp = QPointF();
    // convert the outline to a painter path
    // This is taken from qfontengine_ft.cpp.
    QPainterPath glyph;
    glyph.setFillRule(Qt::WindingFill);
    int i = 0;
    for (int j = 0; j < glyphSlot->outline.n_contours; ++j) {
        int last_point = glyphSlot->outline.contours[j];
        // qDebug() << "contour:" << i << "to" << last_point;
        QPointF start = QPointF(glyphSlot->outline.points[i].x, glyphSlot->outline.points[i].y);
        if (!(glyphSlot->outline.tags[i] & 1)) { // start point is not on curve:
            if (!(glyphSlot->outline.tags[last_point] & 1)) { // end point is not on curve:
                // qDebug() << "  start and end point are not on curve";
                start = (QPointF(glyphSlot->outline.points[last_point].x, glyphSlot->outline.points[last_point].y) + start) / 2.0;
            } else {
                // qDebug() << "  end point is on curve, start is not";
                start = QPointF(glyphSlot->outline.points[last_point].x, glyphSlot->outline.points[last_point].y);
            }
            --i; // to use original start point as control point below
        }
        start += cp;
        // qDebug() << "  start at" << start;
        glyph.moveTo(start);
        std::array<QPointF, 4> curve;
        curve[0] = start;
        size_t n = 1;
        while (i < last_point) {
            ++i;
            curve.at(n) = cp + QPointF(glyphSlot->outline.points[i].x, glyphSlot->outline.points[i].y);
            // qDebug() << "    " << i << c[n] << "tag =" <<
            // (int)g->outline.tags[i]
            //                    << ": on curve =" << (bool)(g->outline.tags[i]
            //                    & 1);
            ++n;
            switch (glyphSlot->outline.tags[i] & 3) {
            case 2:
                // cubic bezier element
                if (n < 4)
                    continue;
                curve[3] = (curve[3] + curve[2]) / 2;
                --i;
                break;
            case 0:
                // quadratic bezier element
                if (n < 3)
                    continue;
                curve[3] = (curve[1] + curve[2]) / 2;
                curve[2] = (2 * curve[1] + curve[3]) / 3;
                curve[1] = (2 * curve[1] + curve[0]) / 3;
                --i;
                break;
            case 1:
            case 3:
                if (n == 2) {
                    // qDebug() << "  lineTo" << c[1];
                    glyph.lineTo(curve[1]);
                    curve[0] = curve[1];
                    n = 1;
                    continue;
                } else if (n == 3) {
                    curve[3] = curve[2];
                    curve[2] = (2 * curve[1] + curve[3]) / 3;
                    curve[1] = (2 * curve[1] + curve[0]) / 3;
                }
                break;
            }
            // qDebug() << "  cubicTo" << c[1] << c[2] << c[3];
            glyph.cubicTo(curve[1], curve[2], curve[3]);
            curve[0] = curve[3];
            n = 1;
        }
        if (n == 1) {
            // qDebug() << "  closeSubpath";
            glyph.closeSubpath();
        } else {
            curve[3] = start;
            if (n == 2) {
                curve[2] = (2 * curve[1] + curve[3]) / 3;
                curve[1] = (2 * curve[1] + curve[0]) / 3;
            }
            // qDebug() << "  close cubicTo" << c[1] << c[2] << c[3];
            glyph.cubicTo(curve[1], curve[2], curve[3]);
        }
        ++i;
    }
    return glyph;
}

emboldenGlyphIfNeeded()

static void emboldenGlyphIfNeeded ( const FT_Face ftface, const CharacterResult & charResult, int * x_advance, int * y_advance )

static

Embolden a glyph (synthesize bold) if the font does not have native bold.

Parameters

ftface
charResult
x_advance	Pointer to the X advance to be adjusted if needed.
y_advance	Pointer to the Y advance to be adjusted if needed.

Definition at line 62 of file KoSvgTextShape_p_glyphs.cpp.

{
    constexpr int WEIGHT_SEMIBOLD = 600;
    if (charResult.fontWeight >= WEIGHT_SEMIBOLD) {
        // Simplest check: Bold fonts don't need to be embolden.
        if (ftface->style_flags & FT_STYLE_FLAG_BOLD) {
            return;
        }
 
        // Variable fnots also don't need to be embolden.
        if (FT_HAS_MULTIPLE_MASTERS(ftface)) {
            return;
        }
 
        // Some heavy weight classes don't cause FT_STYLE_FLAG_BOLD to be set,
        // so we have to check the OS/2 and STAT table for its weight class to be sure.
        hb_font_t_sp hbFont(hb_ft_font_create_referenced(ftface));
        if (hb_style_get_value(hbFont.data(), HB_STYLE_TAG_WEIGHT) >= WEIGHT_SEMIBOLD) {
            return;
        }
 
        // This code is somewhat inspired by Firefox.
        FT_Pos strength =
            FT_MulFix(ftface->units_per_EM, ftface->size->metrics.y_scale) / 48;
 
        if (ftface->glyph->format == FT_GLYPH_FORMAT_BITMAP) {
            // This is similar to what FT_GlyphSlot_Embolden does.
 
            // Round down to full pixel.
            strength &= ~63;
            if (strength == 0) {
                // ... but it has to be at least one pixel.
                strength = 64;
            }
 
            FT_GlyphSlot_Own_Bitmap(ftface->glyph);
 
            // Embolden less vertically than horizontally. Especially if
            // strength is only 1px, don't embolden vertically at all.
            // Otherwise it makes the glyph way too heavy, especially for
            // CJK glyphs in small sizes.
            const FT_Pos strengthY = strength - 64;
            FT_Bitmap_Embolden(ftface->glyph->library, &ftface->glyph->bitmap, strength, strengthY);
 
            if (x_advance && *x_advance != 0) {
                *x_advance += strength;
            }
            if (y_advance && *y_advance != 0) {
                *y_advance -= strengthY;
            }
        } else {
            FT_Outline_Embolden(&ftface->glyph->outline, strength);
 
            if (x_advance && *x_advance != 0) {
                *x_advance += strength;
            }
            if (y_advance && *y_advance != 0) {
                *y_advance -= strength;
            }
        }
    }
}

References KisLibraryResourcePointer< T, P >::data(), and CharacterResult::fontWeight.

faceIsItalic()

bool faceIsItalic

(

const FT_Face

face

)

Definition at line 125 of file KoSvgTextShape_p_glyphs.cpp.

                                      {
    hb_font_t_sp hbFont(hb_ft_font_create_referenced(face));
    bool isItalic = hb_style_get_value(hbFont.data(), HB_STYLE_TAG_ITALIC) > 0;
    bool isOblique = false;
 
    if (FT_HAS_MULTIPLE_MASTERS(face)) {
        isOblique = hb_style_get_value(hbFont.data(), HB_STYLE_TAG_SLANT_ANGLE) != 0;
    }
 
    return isItalic || isOblique;
}

References KisLibraryResourcePointer< T, P >::data().

glyphFormatToStr()

static QString glyphFormatToStr ( const FT_Glyph_Format _v )

static

Definition at line 41 of file KoSvgTextShape_p_glyphs.cpp.

{
    const unsigned int v = _v;
    QString s;
    s += QChar((v >> 24) & 0xFF);
    s += QChar((v >> 16) & 0xFF);
    s += QChar((v >> 8) & 0xFF);
    s += QChar((v >> 0) & 0xFF);
    return s;
}

References v.