block.hpp

[詳解]

#ifndef TYPESET_BLOCK_BLOCK_HPP
#define TYPESET_BLOCK_BLOCK_HPP
 
#include <map>
#include <optional>
#include <variant>
#include <vector>
 
#include "typeset/dl/display_list.hpp"
#include "typeset/geom.hpp"
#include "typeset/inl/paragraph.hpp"
 
namespace typeset::block {
 
enum class BreakKind : uint8_t { Auto, Column, Page };
 
struct BlockStyle {
    Pt spaceBefore = 0.0f;      
    Pt spaceAfter = 0.0f;
    int orphans = 1;            
    int widows = 1;             
    bool keepWithNext = false;  
    bool keepTogether = false;  
    BreakKind breakBefore = BreakKind::Auto;
    BreakKind breakAfter = BreakKind::Auto;
    bool spanColumns = false;   
 
    std::string label;
 
    std::optional<Color> background;
    Pt padding = 0.0f;
};
 
struct ParagraphBlock {
    inl::Paragraph para;
    BlockStyle block;
};
 
struct HeadingBlock {
    inl::Paragraph para;
    int level = 1;
    bool numbered = false;
    bool bookmark = true;
    BlockStyle block = [] { BlockStyle b; b.keepWithNext = true; return b; }();
};
 
struct RuleBlock {
    Pt thickness = 0.5f;
    Color color{0, 0, 0, 255};
    Pt inset = 0.0f;            
    BlockStyle block;
};
 
struct SpacerBlock {
    Pt size = 0.0f;
    BlockStyle block;
};
 
struct LabeledBlock {
    inl::Paragraph label;
    std::vector<inl::Paragraph> body;
    Pt labelWidth = 0.0f;
    Pt gap = 0.0f;
    BlockStyle block;
};
 
struct SectionBlock {
    std::optional<int> columns;
    std::optional<Pt> columnGap;
};
 
enum class ImagePlacement : uint8_t {
    Block,       
    FloatStart,  
    FloatEnd,    
};
 
struct ImageBlock {
    std::shared_ptr<const dl::Image> image;
    Size size;
    ImagePlacement placement = ImagePlacement::Block;
    Align align = Align::Center;            
    Pt gap = 6.0f;                          
    std::optional<inl::Paragraph> caption;
    Pt captionGap = 3.0f;
    BlockStyle block;
};
 
struct ObjectBlock {
    std::string handler;
    std::u16string source;
    std::map<std::string, std::string> params;
    Align align = Align::Center;
    bool numbered = false;
    TextStyle textStyle;
    std::optional<inl::Paragraph> caption;
    Pt captionGap = 3.0f;
    BlockStyle block;
};
 
struct TableColumn {
    Pt width = 0.0f;                
    Align align = Align::Start;     
};
 
enum class VAlign : uint8_t { Top, Middle, Bottom };
 
struct TableCell {
    std::vector<inl::Paragraph> paras;
    int colspan = 1;
    int rowspan = 1;    
    VAlign valign = VAlign::Top;
};
 
struct TableRow {
    std::vector<TableCell> cells;
    bool header = false;            
};
 
struct TableBorders {
    Pt outer = 0.75f;               
    Pt inner = 0.25f;               
    Pt headerRule = 0.75f;          
    bool vertical = true;           
    bool horizontal = true;         
    Color color{0, 0, 0, 255};
};
 
struct TableBlock {
    std::vector<TableColumn> columns;   
    std::vector<TableRow> rows;
    TableBorders borders;
    Pt cellPadding = 3.0f;
    bool fullWidth = true;              
    Align align = Align::Start;
    bool repeatHeader = true;
    std::optional<inl::Paragraph> caption;
    Pt captionGap = 3.0f;
    BlockStyle block;
};
 
struct ListBlock {
    enum class Marker : uint8_t { Bullet, Numbered };
    std::vector<inl::Paragraph> items;
    Marker marker = Marker::Bullet;
    std::u16string bullet = u"・";
    std::u16string numberSuffix = u".";     
    Pt labelWidth = 0.0f;                   
    Pt gap = 0.0f;
    Pt itemGap = 0.0f;                      
    BlockStyle block;
};
 
struct TocBlock {
    int maxLevel = 2;
    TextStyle style;                        
    std::optional<TextStyle> subStyle;      
    Pt indentPerLevel = 0.0f;               
    Pt lineHeight = 1.8f;
    bool leader = true;                     
    BlockStyle block;
};
 
struct IndexBlock {
    TextStyle style;                        
    std::optional<TextStyle> groupStyle;    
    bool grouped = true;                    
    bool leader = true;                     
    Pt lineHeight = 1.6f;
    std::u16string pageSeparator = u", ";
    BlockStyle block;
};
 
using Block = std::variant<ParagraphBlock, HeadingBlock, RuleBlock, SpacerBlock, LabeledBlock,
                           SectionBlock, ImageBlock, TableBlock, ListBlock, TocBlock, ObjectBlock, IndexBlock>;
 
struct Flow {
    std::vector<Block> blocks;
 
    void add(Block b) { blocks.push_back(std::move(b)); }
    void addParagraph(inl::Paragraph p, BlockStyle style = {}) {
        blocks.push_back(ParagraphBlock{std::move(p), std::move(style)});
    }
    void addHeading(inl::Paragraph p, int level = 1, std::optional<BlockStyle> style = std::nullopt,
                    bool numbered = false) {
        HeadingBlock h;
        h.para = std::move(p);
        h.level = level;
        h.numbered = numbered;
        if (style) h.block = *style;
        blocks.push_back(std::move(h));
    }
    void addList(ListBlock list) { blocks.push_back(std::move(list)); }
    void addToc(TocBlock toc) { blocks.push_back(std::move(toc)); }
    void addIndex(IndexBlock idx) { blocks.push_back(std::move(idx)); }
    void addLabeled(inl::Paragraph label, inl::Paragraph body, Pt labelWidth, Pt gap = 0.0f,
                    BlockStyle style = {}) {
        LabeledBlock b;
        b.label = std::move(label);
        b.body.push_back(std::move(body));
        b.labelWidth = labelWidth;
        b.gap = gap;
        b.block = std::move(style);
        blocks.push_back(std::move(b));
    }
    void addRule(Pt thickness = 0.5f, Color color = Color{0, 0, 0, 255}, BlockStyle style = {}) {
        RuleBlock r;
        r.thickness = thickness;
        r.color = color;
        r.block = std::move(style);
        blocks.push_back(std::move(r));
    }
    void addSpacer(Pt size) { blocks.push_back(SpacerBlock{size, {}}); }
    void addImage(ImageBlock img) { blocks.push_back(std::move(img)); }
    void addObject(ObjectBlock obj) { blocks.push_back(std::move(obj)); }
    void addObject(std::string handler, std::u16string source, TextStyle textStyle,
                   std::map<std::string, std::string> params = {}, bool numbered = false,
                   BlockStyle style = {}) {
        ObjectBlock o;
        o.handler = std::move(handler);
        o.source = std::move(source);
        o.params = std::move(params);
        o.textStyle = std::move(textStyle);
        o.numbered = numbered;
        o.block = std::move(style);
        blocks.push_back(std::move(o));
    }
    void addTable(TableBlock table) { blocks.push_back(std::move(table)); }
    void addPageBreak() {
        SpacerBlock s;
        s.block.breakBefore = BreakKind::Page;
        blocks.push_back(std::move(s));
    }
    void addColumnBreak() {
        SpacerBlock s;
        s.block.breakBefore = BreakKind::Column;
        blocks.push_back(std::move(s));
    }
};
 
} // namespace typeset::block
 
#endif // TYPESET_BLOCK_BLOCK_HPP