paragraph.hpp

[詳解]

#ifndef TYPESET_INL_PARAGRAPH_HPP
#define TYPESET_INL_PARAGRAPH_HPP
 
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "typeset/dl/display_list.hpp"
#include "typeset/font/font_set.hpp"
#include "typeset/inl/annotation.hpp"
#include "typeset/inl/line_breaker.hpp"
#include "typeset/inl/shaped.hpp"
#include "typeset/style.hpp"
#include "typeset/writing_mode.hpp"
 
namespace typeset::inl {
 
struct Paragraph;
 
struct ObjectRef {
    std::string handler;
    std::u16string source;
    std::map<std::string, std::string> params;
};
 
struct InlineRun {
    std::u16string text;
    TextStyle style;
    std::shared_ptr<const dl::Image> image;
    Size imageSize;         
    std::shared_ptr<const obj::ObjectResult> object;    
    std::optional<ObjectRef> objectRef;                 
    std::shared_ptr<const Paragraph> footnote;
    bool literal = false;
    bool placeholder = false;
    std::string placeholderId;
};
 
struct Paragraph {
    std::vector<InlineRun> runs;
    std::vector<Annotation> annotations;    
    ParagraphStyle style;
 
    std::u16string text() const;
    const TextStyle& baseStyle() const;
 
    static Paragraph plain(std::u16string text, TextStyle style, ParagraphStyle pstyle = {}) {
        Paragraph p;
        p.runs.push_back(InlineRun{std::move(text), std::move(style)});
        p.style = std::move(pstyle);
        return p;
    }
 
    void addImage(std::shared_ptr<const dl::Image> image, Size size, TextStyle style) {
        InlineRun r;
        r.text = u"\uFFFC";
        r.style = std::move(style);
        r.image = std::move(image);
        r.imageSize = size;
        runs.push_back(std::move(r));
    }
 
    void addPlaceholder(Size size, TextStyle style, std::string id = std::string()) {
        InlineRun r;
        r.text = u"\uFFFC";
        r.style = std::move(style);
        r.placeholder = true;
        r.placeholderId = std::move(id);
        r.imageSize = size;
        runs.push_back(std::move(r));
    }
 
    void addObject(std::string handler, std::u16string source, std::map<std::string, std::string> params,
                   TextStyle style) {
        InlineRun r;
        r.text = u"\uFFFC";
        r.style = std::move(style);
        r.objectRef = ObjectRef{std::move(handler), std::move(source), std::move(params)};
        runs.push_back(std::move(r));
    }
    void addObject(std::shared_ptr<const obj::ObjectResult> object, TextStyle style) {
        InlineRun r;
        r.text = u"\uFFFC";
        r.style = std::move(style);
        r.object = std::move(object);
        runs.push_back(std::move(r));
    }
 
    void addFootnote(Paragraph note, TextStyle markerStyle);
};
 
inline TextStyle superscriptStyle(TextStyle s) {
    s.size *= 0.6f;
    s.baselineShift = 0.6f;
    return s;
}
 
inline void Paragraph::addFootnote(Paragraph note, TextStyle markerStyle) {
    InlineRun r;
    r.text = u"{fn}";
    r.style = std::move(markerStyle);
    r.footnote = std::make_shared<Paragraph>(std::move(note));
    runs.push_back(std::move(r));
}
 
dl::Group objectGroup(const obj::ObjectResult& ob, const Rect& box, bool sideways);
 
struct LineBox {
    std::vector<PlacedGlyph> glyphs;    
    Pt length = 0.0f;                   
    Pt naturalLength = 0.0f;            
    Pt blockMin = 0.0f;                 
    Pt blockMax = 0.0f;                 
    size_t charStart = 0;               
    size_t charEnd = 0;
    bool hanging = false;               
    Pt hangWidth = 0.0f;
    bool hyphenated = false;            
    int lineIndex = 0;                  
    Pt indent = 0.0f;                   
    bool paragraphEnd = false;          
    Pt extraBefore = 0.0f;
    Pt extraAfter = 0.0f;
};
 
struct StyleMetrics {
    Pt baseline = 0.0f;                 
    font::DecorationMetrics decoration; 
};
 
struct ParagraphFragment {
    std::vector<LineBox> lines;
    std::vector<TextStyle> styles;      
    std::vector<StyleMetrics> styleMetrics;   
    std::vector<std::string> placeholderIds;  
    std::vector<bool> placeholders;           
    size_t charStart = 0;               
    size_t charEnd = 0;
    bool complete = false;              
    Pt linePitch = 0.0f;                
    float rotation = 0.0f;              
    Pt baseSize = 0.0f;
    std::shared_ptr<const std::u16string> text;   
 
    Pt lineAdvance(size_t li) const {
        return linePitch + lines[li].extraBefore + lines[li].extraAfter;
    }
    Pt lineCenterOffset(size_t li) const {
        Pt off = 0.0f;
        for (size_t j = 0; j < li && j < lines.size(); ++j) off += lineAdvance(j);
        return off + (li < lines.size() ? lines[li].extraBefore : 0.0f);
    }
    Pt blockExtent() const {
        Pt s = 0.0f;
        for (size_t j = 0; j < lines.size(); ++j) s += lineAdvance(j);
        return s;
    }
};
 
class ParagraphLayouter {
public:
    explicit ParagraphLayouter(font::FontSet& fonts) : fonts_(fonts) {}
 
    ParagraphFragment layout(const Paragraph& para, WritingMode wm,
                             const LineShapeProvider& shape,
                             size_t charStart = 0, int maxLines = -1,
                             int firstLineIndex = 0);
 
private:
    ParagraphFragment layoutOnce(const Paragraph& para, WritingMode wm,
                                 const LineShapeProvider& shape,
                                 size_t charStart, int maxLines, int firstLineIndex);
    void applyEllipsis(ParagraphFragment& frag, const Paragraph& para, WritingMode wm,
                       const LineShapeProvider& shape);
    font::FontSet& fonts_;
    std::vector<Pt> lineIndents_;   
};
 
Point lineOrigin(WritingMode wm, Point origin, int lineOffset, Pt linePitch, Pt indent);
Point lineOriginAt(WritingMode wm, Point origin, Pt adv, Pt indent);
 
void emitParagraph(dl::DisplayList& out, const ParagraphFragment& frag, WritingMode wm,
                   Point origin, int lineOffset = 0, size_t maxChars = static_cast<size_t>(-1));
 
//------------------------------------------------------------------------------
// 取り出し口（ホストがリンク・ヒットテスト・キャレット・段階表示を作るための問い合わせ）
//------------------------------------------------------------------------------
 
struct CharBox {
    size_t lineIndex = 0;           
    uint32_t charIndex = 0;         
    Pt inlineStart = 0.0f;          
    Pt inlineEnd = 0.0f;            
    Pt blockMin = 0.0f;             
    Pt blockMax = 0.0f;
    uint32_t styleIndex = 0;
    uint32_t gid = 0;
    Pt size = 0.0f;
    std::shared_ptr<glyphware::Face> face;
    bool image = false;
    bool object = false;
    bool placeholder = false;
    Rect rect(WritingMode wm, Point lineOrigin) const;
};
 
std::vector<CharBox> charBoxes(const ParagraphFragment& frag, WritingMode wm, size_t lineIndex);
 
Point lineOriginOf(const ParagraphFragment& frag, WritingMode wm, Point origin, size_t lineIndex,
                   int lineOffset = 0);
 
std::vector<Rect> rectsFor(const ParagraphFragment& frag, WritingMode wm, Point origin,
                           size_t charStart, size_t charEnd, int lineOffset = 0);
 
struct PlaceholderRect {
    std::string id;
    uint32_t charIndex = 0;
    Rect rect;
};
std::vector<PlaceholderRect> placeholderRects(const ParagraphFragment& frag, WritingMode wm, Point origin,
                                              int lineOffset = 0);
 
struct HitResult {
    size_t lineIndex = 0;
    uint32_t charIndex = 0;         
    bool inside = false;            
    bool after = false;             
};
std::optional<HitResult> hitTest(const ParagraphFragment& frag, WritingMode wm, Point origin, Point p,
                                 int lineOffset = 0);
 
std::optional<Rect> caretRect(const ParagraphFragment& frag, WritingMode wm, Point origin, size_t charIndex,
                              int lineOffset = 0, Pt thickness = 1.0f);
 
Point originInBox(const ParagraphFragment& frag, WritingMode wm, const Rect& box,
                  BlockAlign blockAlign = BlockAlign::Start, Align align = Align::Start);
 
struct FitResult {
    ParagraphFragment fragment;
    float scale = 1.0f;             
    bool fits = true;               
};
FitResult fitParagraph(ParagraphLayouter& layouter, const Paragraph& para, WritingMode wm,
                       const LineShapeProvider& shape, int maxLines,
                       float minScale = 0.5f, float step = 0.05f);
 
struct TextMetrics {
    Pt advance = 0.0f;              
    Pt ascent = 0.0f;               
    Pt descent = 0.0f;              
    size_t clusterCount = 0;        
    size_t glyphCount = 0;
};
TextMetrics measureText(font::FontSet& fonts, const std::u16string& text, const TextStyle& style,
                        WritingMode wm = WritingMode::HorizontalTb,
                        TextOrientation orientation = TextOrientation::Mixed);
 
} // namespace typeset::inl
 
#endif // TYPESET_INL_PARAGRAPH_HPP