line_item.hpp

[詳解]

#ifndef TYPESET_INL_LINE_ITEM_HPP
#define TYPESET_INL_LINE_ITEM_HPP
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <vector>
 
#include "typeset/inl/shaped.hpp"
#include "typeset/text/spacing_table.hpp"
 
namespace typeset::inl {
 
constexpr float kInfinitePenalty = 10000.0f;
constexpr float kForcedBreakPenalty = -10000.0f;
 
enum class ItemType : uint8_t { Box, Glue, Penalty };
 
struct LineItem {
    ItemType type = ItemType::Box;
 
    Pt width = 0.0f;
 
    Pt natural = 0.0f;
    Pt stretch = 0.0f;
    Pt shrink = 0.0f;
 
    float penalty = 0.0f;
 
    Pt glyphOffset = 0.0f;
 
    uint32_t clusterIndex = kNoCluster;
 
    size_t charIndex = 0;
 
    int level = -1;
 
    // --- インライン注記 ---
 
    std::vector<PlacedGlyph> glyphs;
    bool ownGlyphs = false;
 
    Pt extentMin = 0.0f;
    Pt extentMax = 0.0f;
 
    std::vector<PlacedGlyph> breakGlyphs;
 
    static constexpr uint32_t kNoCluster = std::numeric_limits<uint32_t>::max();
 
    static LineItem box(Pt w, uint32_t cluster, size_t charIndex) {
        LineItem it;
        it.type = ItemType::Box;
        it.width = w;
        it.clusterIndex = cluster;
        it.charIndex = charIndex;
        return it;
    }
    static LineItem glue(const text::GlueSpec& spec, Pt em, size_t charIndex) {
        return gluePt(spec.natural * em, spec.stretch * em, spec.shrink * em, charIndex);
    }
    static LineItem gluePt(Pt natural, Pt stretch, Pt shrink, size_t charIndex) {
        LineItem it;
        it.type = ItemType::Glue;
        it.natural = natural;
        it.stretch = stretch;
        it.shrink = shrink;
        it.charIndex = charIndex;
        return it;
    }
    static LineItem penaltyItem(float cost, Pt width, size_t charIndex) {
        LineItem it;
        it.type = ItemType::Penalty;
        it.penalty = cost;
        it.width = width;
        it.charIndex = charIndex;
        return it;
    }
 
    bool isBox() const { return type == ItemType::Box; }
    bool isGlue() const { return type == ItemType::Glue; }
    bool isPenalty() const { return type == ItemType::Penalty; }
    bool isForcedBreak() const { return type == ItemType::Penalty && penalty <= kForcedBreakPenalty; }
};
 
} // namespace typeset::inl
 
#endif // TYPESET_INL_LINE_ITEM_HPP