line_breaker.hpp

[詳解]

#ifndef TYPESET_INL_LINE_BREAKER_HPP
#define TYPESET_INL_LINE_BREAKER_HPP
 
#include <cstdint>
#include <vector>
 
#include "typeset/inl/line_item.hpp"
#include "typeset/style.hpp"
 
namespace typeset::inl {
 
struct LineShape {
    Pt length = 0.0f;
    Pt indent = 0.0f;
};
 
class LineShapeProvider {
public:
    virtual ~LineShapeProvider() = default;
    virtual LineShape at(int lineIndex) const = 0;
    virtual LineShape at(int lineIndex, Pt /*extraBlock*/) const { return at(lineIndex); }
};
 
class OffsetLineShape : public LineShapeProvider {
public:
    OffsetLineShape(const LineShapeProvider& base, const std::vector<Pt>& offsets, int firstLineIndex)
        : base_(base), offsets_(offsets), first_(firstLineIndex) {}
    LineShape at(int lineIndex) const override { return at(lineIndex, 0.0f); }
    LineShape at(int lineIndex, Pt extraBlock) const override {
        const int i = lineIndex - first_;
        const Pt extra = (i >= 0 && static_cast<size_t>(i) < offsets_.size()) ? offsets_[static_cast<size_t>(i)]
                       : (offsets_.empty() ? 0.0f : offsets_.back());
        return base_.at(lineIndex, extraBlock + extra);
    }
private:
    const LineShapeProvider& base_;
    const std::vector<Pt>& offsets_;
    int first_;
};
 
class ConstantLineShape : public LineShapeProvider {
public:
    explicit ConstantLineShape(Pt length, Pt indent = 0.0f) : length_(length), indent_(indent) {}
    LineShape at(int) const override { return LineShape{length_, indent_}; }
private:
    Pt length_;
    Pt indent_;
};
 
class IndentedLineShape : public LineShapeProvider {
public:
    IndentedLineShape(const LineShapeProvider& base, int indentLine, Pt indent)
        : base_(base), indentLine_(indentLine), indent_(indent) {}
    LineShape at(int lineIndex) const override { return at(lineIndex, 0.0f); }
    LineShape at(int lineIndex, Pt extraBlock) const override {
        LineShape s = base_.at(lineIndex, extraBlock);
        if (lineIndex == indentLine_) {
            s.length -= indent_;
            s.indent += indent_;
        }
        return s;
    }
private:
    const LineShapeProvider& base_;
    int indentLine_;
    Pt indent_;
};
 
struct BreakLine {
    uint32_t itemStart = 0;     
    uint32_t itemEnd = 0;       
    float ratio = 0.0f;         
    Pt naturalWidth = 0.0f;     
    Pt width = 0.0f;            
    int lineIndex = 0;          
    LineShape shape;            
};
 
std::vector<BreakLine> breakLines(const std::vector<LineItem>& items,
                                  const LineShapeProvider& shape,
                                  const BreakOptions& opts,
                                  int firstLineIndex = 0);
 
} // namespace typeset::inl
 
#endif // TYPESET_INL_LINE_BREAKER_HPP