SkShaperJSONWriter Class Reference

#include <SkShaperJSONWriter.h>

Inheritance diagram for SkShaperJSONWriter:

Public Types
using	BreakupClustersCallback = std::function< void(size_t, size_t, uint32_t, uint32_t)>
using	VisualizeClustersCallback = std::function< void(size_t, SkSpan< const char >, SkSpan< const SkGlyphID >)>

Public Member Functions
	SkShaperJSONWriter (SkJSONWriter *JSONWriter, const char *utf8, size_t size)
void	beginLine () override
void	runInfo (const RunInfo &info) override
void	commitRunInfo () override
Buffer	runBuffer (const RunInfo &info) override
void	commitRunBuffer (const RunInfo &info) override
void	commitLine () override
Public Member Functions inherited from SkShaper::RunHandler
virtual	~RunHandler ()=default

Static Public Member Functions
static void	BreakupClusters (size_t utf8Begin, size_t utf8End, SkSpan< const uint32_t > clusters, const BreakupClustersCallback &processMToN)
static void	VisualizeClusters (const char utf8[], size_t utf8Begin, size_t utf8End, SkSpan< const SkGlyphID > glyphIDs, SkSpan< const uint32_t > clusters, const VisualizeClustersCallback &processMToN)

Detailed Description

Definition at line 23 of file SkShaperJSONWriter.h.

Member Typedef Documentation

BreakupClustersCallback

using SkShaperJSONWriter::BreakupClustersCallback = std::function<void(size_t, size_t, uint32_t, uint32_t)>

Definition at line 37 of file SkShaperJSONWriter.h.

VisualizeClustersCallback

using SkShaperJSONWriter::VisualizeClustersCallback = std::function<void(size_t, SkSpan<const char>, SkSpan<const SkGlyphID>)>

Definition at line 46 of file SkShaperJSONWriter.h.

Constructor & Destructor Documentation

SkShaperJSONWriter()

SkShaperJSONWriter::SkShaperJSONWriter	(	SkJSONWriter *	JSONWriter,
		const char *	utf8,
		size_t	size
	)

Definition at line 24 of file SkShaperJSONWriter.cpp.

        : fJSONWriter{JSONWriter}
        , fUTF8{utf8, size} {}

Member Function Documentation

beginLine()

void SkShaperJSONWriter::beginLine ( )

overridevirtual

Called when beginning a line.

Implements SkShaper::RunHandler.

Definition at line 28 of file SkShaperJSONWriter.cpp.

{ }

BreakupClusters()

void SkShaperJSONWriter::BreakupClusters ( size_t  utf8Begin, size_t  utf8End, SkSpan< const uint32_t >  clusters, const BreakupClustersCallback &  processMToN  )

static

Definition at line 137 of file SkShaperJSONWriter.cpp.

                                                                                     {
 
    if (clusters.front() <= clusters.back()) {
        // Handle left-to-right text direction
        size_t glyphStartIndex = 0;
        for (size_t glyphEndIndex = 0; glyphEndIndex < clusters.size(); glyphEndIndex++) {
 
            if (clusters[glyphStartIndex] == clusters[glyphEndIndex]) { continue; }
 
            processMToN(glyphStartIndex, glyphEndIndex,
                        clusters[glyphStartIndex], clusters[glyphEndIndex]);
 
            glyphStartIndex = glyphEndIndex;
        }
 
        processMToN(glyphStartIndex, clusters.size(), clusters[glyphStartIndex], utf8End);
 
    } else {
        // Handle right-to-left text direction.
        SkASSERT(clusters.size() >= 2);
        size_t glyphStartIndex = 0;
        uint32_t utf8EndIndex = utf8End;
        for (size_t glyphEndIndex = 0; glyphEndIndex < clusters.size(); glyphEndIndex++) {
 
            if (clusters[glyphStartIndex] == clusters[glyphEndIndex]) { continue; }
 
            processMToN(glyphStartIndex, glyphEndIndex,
                        clusters[glyphStartIndex], utf8EndIndex);
 
            utf8EndIndex = clusters[glyphStartIndex];
            glyphStartIndex = glyphEndIndex;
        }
        processMToN(glyphStartIndex, clusters.size(), utf8Begin, clusters[glyphStartIndex-1]);
    }
}

commitLine()

void SkShaperJSONWriter::commitLine ( )

inlineoverridevirtual

Called when ending a line.

Implements SkShaper::RunHandler.

Definition at line 35 of file SkShaperJSONWriter.h.

{}

commitRunBuffer()

void SkShaperJSONWriter::commitRunBuffer ( const RunInfo &  info )

overridevirtual

Called after each runBuffer is filled out.

Implements SkShaper::RunHandler.

Definition at line 75 of file SkShaperJSONWriter.cpp.

                                                                              {
    fJSONWriter->beginObject("run", true);
 
    // Font name
    SkString fontName;
    info.fFont.getTypeface()->getFamilyName(&fontName);
    fJSONWriter->appendString("font name", fontName);
 
    // Font size
    fJSONWriter->appendFloat("font size", info.fFont.getSize());
 
    if (info.fBidiLevel > 0) {
        std::string bidiType = info.fBidiLevel % 2 == 0 ? "left-to-right" : "right-to-left";
        std::string bidiOutput = bidiType + " lvl " + std::to_string(info.fBidiLevel);
        fJSONWriter->appendString("BiDi", bidiOutput);
    }
 
    if (is_one_to_one(fUTF8.c_str(), info.utf8Range.begin(), info.utf8Range.end(), fClusters)) {
        std::string utf8{&fUTF8[info.utf8Range.begin()], info.utf8Range.size()};
        fJSONWriter->appendString("UTF8", utf8);
 
        fJSONWriter->beginArray("glyphs", false);
        for (auto glyphID : fGlyphs) {
            fJSONWriter->appendU32(glyphID);
        }
        fJSONWriter->endArray();
 
        fJSONWriter->beginArray("clusters", false);
        for (auto cluster : fClusters) {
            fJSONWriter->appendU32(cluster);
        }
        fJSONWriter->endArray();
    } else {
        VisualizeClusters(fUTF8.c_str(),
                          info.utf8Range.begin(), info.utf8Range.end(),
                          SkSpan(fGlyphs),
                          SkSpan(fClusters),
                          [this](size_t codePointCount, SkSpan<const char> utf1to1,
                                 SkSpan<const SkGlyphID> glyph1to1) {
                              this->displayMToN(codePointCount, utf1to1, glyph1to1);
                          });
    }
 
    if (info.glyphCount > 1) {
        fJSONWriter->beginArray("horizontal positions", false);
        for (auto position : fPositions) {
            fJSONWriter->appendFloat(position.x());
        }
        fJSONWriter->endArray();
    }
 
    fJSONWriter->beginArray("advances", false);
    for (size_t i = 1; i < info.glyphCount; i++) {
        fJSONWriter->appendFloat(fPositions[i].fX - fPositions[i-1].fX);
    }
    SkPoint lastAdvance = info.fAdvance - (fPositions.back() - fPositions.front());
    fJSONWriter->appendFloat(lastAdvance.fX);
    fJSONWriter->endArray();
 
    fJSONWriter->endObject();
}

commitRunInfo()

void SkShaperJSONWriter::commitRunInfo ( )

overridevirtual

Called after all runInfo calls for a line.

Implements SkShaper::RunHandler.

Definition at line 32 of file SkShaperJSONWriter.cpp.

{ }

runBuffer()

SkShaper::RunHandler::Buffer SkShaperJSONWriter::runBuffer ( const RunInfo &  info )

overridevirtual

Called for each run in a line after commitRunInfo. The buffer will be filled out.

Implements SkShaper::RunHandler.

Definition at line 35 of file SkShaperJSONWriter.cpp.

                                                                   {
    fGlyphs.resize(info.glyphCount);
    fPositions.resize(info.glyphCount);
    fClusters.resize(info.glyphCount);
    return {fGlyphs.data(), fPositions.data(), nullptr, fClusters.data(), {0, 0}};
}

runInfo()

void SkShaperJSONWriter::runInfo ( const RunInfo &  info )

overridevirtual

Called once for each run in a line. Can compute baselines and offsets.

Implements SkShaper::RunHandler.

Definition at line 30 of file SkShaperJSONWriter.cpp.

{ }

VisualizeClusters()

void SkShaperJSONWriter::VisualizeClusters ( const char  utf8[], size_t  utf8Begin, size_t  utf8End, SkSpan< const SkGlyphID >  glyphIDs, SkSpan< const uint32_t >  clusters, const VisualizeClustersCallback &  processMToN  )

static

Definition at line 175 of file SkShaperJSONWriter.cpp.

                                                                                         {
 
    size_t glyphRangeStart, glyphRangeEnd;
    uint32_t utf8RangeStart, utf8RangeEnd;
 
    auto resetRanges = [&]() {
        glyphRangeStart = std::numeric_limits<size_t>::max();
        glyphRangeEnd   = 0;
        utf8RangeStart  = std::numeric_limits<uint32_t>::max();
        utf8RangeEnd    = 0;
    };
 
    auto checkRangesAndProcess = [&]() {
        if (glyphRangeStart < glyphRangeEnd) {
            size_t glyphRangeCount = glyphRangeEnd - glyphRangeStart;
            SkSpan<const char> utf8Span{&utf8[utf8RangeStart], utf8RangeEnd - utf8RangeStart};
            SkSpan<const SkGlyphID> glyphSpan{&glyphIDs[glyphRangeStart], glyphRangeCount};
 
            // Glyph count is the same as codepoint count for 1:1.
            processMToN(glyphRangeCount, utf8Span, glyphSpan);
        }
        resetRanges();
    };
 
    auto gatherRuns = [&](size_t glyphStartIndex, size_t glyphEndIndex,
                          uint32_t utf8StartIndex, uint32_t utf8EndIndex) {
        int possibleCount = SkUTF::CountUTF8(&utf8[utf8StartIndex], utf8EndIndex - utf8StartIndex);
        if (possibleCount == -1) { return; }
        size_t codePointCount = SkTo<size_t>(possibleCount);
        if (codePointCount == 1 && glyphEndIndex - glyphStartIndex == 1) {
            glyphRangeStart = std::min(glyphRangeStart, glyphStartIndex);
            glyphRangeEnd   = std::max(glyphRangeEnd,   glyphEndIndex  );
            utf8RangeStart  = std::min(utf8RangeStart,  utf8StartIndex );
            utf8RangeEnd    = std::max(utf8RangeEnd,    utf8EndIndex   );
        } else {
            checkRangesAndProcess();
 
            SkSpan<const char> utf8Span{&utf8[utf8StartIndex], utf8EndIndex - utf8StartIndex};
            SkSpan<const SkGlyphID> glyphSpan{&glyphIDs[glyphStartIndex],
                                              glyphEndIndex - glyphStartIndex};
 
            processMToN(codePointCount, utf8Span, glyphSpan);
        }
    };
 
    resetRanges();
    BreakupClusters(utf8Begin, utf8End, clusters, gatherRuns);
    checkRangesAndProcess();
}

---

The documentation for this class was generated from the following files:

• third_party/skia/modules/skparagraph/tests/SkShaperJSONWriter.h
• third_party/skia/modules/skparagraph/tests/SkShaperJSONWriter.cpp