Function segmentString

src/SFML/Graphics/Text.cpp:119–186

Split string into segments with uniform text properties

// Split string into segments with uniform text properties
std::vector<TextSegment> segmentString(const sf::String& input)
{
    std::vector<TextSegment> segments;

    const SBCodepointSequence codepointSequence{SBStringEncodingUTF32,
                                                static_cast<const void*>(input.getData()),
                                                input.getSize()};
    auto* const               scriptLocator   = SBScriptLocatorCreate();
    const auto* const         algorithm       = SBAlgorithmCreate(&codepointSequence);
    SBUInteger                paragraphOffset = 0;

    while (paragraphOffset < input.getSize())
    {
        SBUInteger paragraphLength{};
        SBUInteger separatorLength{};
        SBAlgorithmGetParagraphBoundary(algorithm,
                                        paragraphOffset,
                                        std::numeric_limits<SBUInteger>::max(),
                                        &paragraphLength,
                                        &separatorLength);

        // If the paragraph contains characters besides the separator,
        // split the separator off into its own paragraph in the next iteration
        // We do this to ensure line breaks are inserted into segments last
        // after all character runs on the same line have already been inserted
        // This allows us to draw our segments in left-to-right top-to-bottom order
        if (separatorLength < paragraphLength)
            paragraphLength -= separatorLength;

        const auto* const paragraph = SBAlgorithmCreateParagraph(algorithm, paragraphOffset, paragraphLength, SBLevelDefaultLTR);
        const auto* const line     = SBParagraphCreateLine(paragraph, paragraphOffset, paragraphLength);
        const auto        runCount = SBLineGetRunCount(line);
        const auto*       runArray = SBLineGetRunsPtr(line);

        for (SBUInteger i = 0; i < runCount; i++)
        {
            // Odd levels are RTL, even levels are LTR
            const auto direction = (runArray[i].level % 2) ? HB_DIRECTION_RTL : HB_DIRECTION_LTR;

            const SBCodepointSequence codepointSubsequence{SBStringEncodingUTF32,
                                                           static_cast<const void*>(input.getData() + runArray[i].offset),
                                                           runArray[i].length};

            SBScriptLocatorLoadCodepoints(scriptLocator, &codepointSubsequence);

            while (SBScriptLocatorMoveNext(scriptLocator))
            {
                const auto* agent  = SBScriptLocatorGetAgent(scriptLocator);
                const auto  script = hb_script_from_iso15924_tag(SBScriptGetUnicodeTag(agent->script));

                segments.emplace_back(TextSegment{runArray[i].offset + agent->offset, agent->length, script, direction});
            }

            SBScriptLocatorReset(scriptLocator);
        }

        SBLineRelease(line);
        SBParagraphRelease(paragraph);