style.hpp

[詳解]

#ifndef TYPESET_STYLE_HPP
#define TYPESET_STYLE_HPP
 
#include <map>
#include <optional>
#include <string>
#include <vector>
 
namespace typeset::text { class HyphenationDictionary; }
 
#include "typeset/geom.hpp"
#include "typeset/writing_mode.hpp"
 
namespace typeset {
 
struct FontSpec {
    std::vector<std::string> family;
    int weight = 400;
    bool italic = false;
    std::map<std::string, float> variations;
};
 
struct TextLayer {
    std::optional<Paint> fill;
    std::optional<Stroke> stroke;
    Point offset;
    Pt blur = 0.0f;
 
    static TextLayer filled(Paint c) { TextLayer l; l.fill = std::move(c); return l; }
    static TextLayer outlined(Stroke s) { TextLayer l; l.stroke = s; return l; }
};
 
struct TextShadow {
    Color color{0, 0, 0, 128};
    Point offset{1.0f, 1.0f};
    Pt blur = 0.0f;
};
 
struct TextDecoration {
    std::optional<Paint> color;     
    Pt thickness = 0.0f;            
    float offset = 0.0f;
};
 
enum class EmojiPresentation : uint8_t { Auto, Text, Emoji };
 
struct TextStyle {
    FontSpec font;
    Pt size = 10.0f;
    Paint fill{Color{0, 0, 0, 255}};        
    std::optional<Stroke> stroke;           
 
    std::optional<TextShadow> shadow;
    std::vector<TextLayer> layers;
 
    std::optional<TextDecoration> underline;
    std::optional<TextDecoration> strikethrough;
 
    float letterSpacing = 0.0f;
 
    std::optional<TextOrientation> orientation;
 
    float scaleX = 1.0f;
    float scaleY = 1.0f;
 
    bool fakeBold = false;
    bool fakeItalic = false;
 
    float baselineShift = 0.0f;
 
    std::string language = "ja";
 
    EmojiPresentation emojiPresentation = EmojiPresentation::Auto;
 
    std::vector<std::string> features;
 
    bool hasProportionalFeature() const {
        for (const std::string& f : features) {
            std::string tag = f;
            bool on = true;
            if (!tag.empty() && (tag[0] == '+' || tag[0] == '-')) { on = tag[0] == '+'; tag = tag.substr(1); }
            const size_t eq = tag.find('=');
            if (eq != std::string::npos) { on = tag.substr(eq + 1) != "0"; tag = tag.substr(0, eq); }
            const size_t br = tag.find('[');
            if (br != std::string::npos) tag = tag.substr(0, br);
            if (!on) continue;
            if (tag == "palt" || tag == "halt" || tag == "pwid" || tag == "hwid" || tag == "vpal" ||
                tag == "vhal" || tag == "twid" || tag == "qwid") return true;
        }
        return false;
    }
 
    std::vector<TextLayer> resolvedLayers() const {
        std::vector<TextLayer> out;
        if (shadow) {
            TextLayer l;
            l.fill = shadow->color;
            l.offset = shadow->offset;
            l.blur = shadow->blur;
            out.push_back(l);
        }
        if (layers.empty()) {
            TextLayer l;
            l.fill = fill;
            l.stroke = stroke;
            out.push_back(l);
        } else {
            out.insert(out.end(), layers.begin(), layers.end());
        }
        return out;
    }
};
 
enum class KinsokuLevel : uint8_t { Strict, Normal, Loose };
 
struct SpacingOptions {
    bool punctuationSpacing = true;
    KinsokuLevel kinsoku = KinsokuLevel::Strict;
    float weakKinsokuPenalty = 500.0f;
    std::u16string lineStartProhibited;     
    std::u16string lineStartAllowed;        
    std::u16string lineEndProhibited;       
    std::u16string lineEndAllowed;          
    bool hangingPunctuation = false;
    bool latinGap = true;
    float kanjiSkipStretch = 0.125f;
    float kanjiSkipShrink = 0.0f;
};
 
enum class LineBreakStrategy : uint8_t {
    Greedy,       
    KnuthPlass,   
};
 
enum class WrapMode : uint8_t { Mixed, Char, Word, None };
 
struct BreakOptions {
    LineBreakStrategy strategy = LineBreakStrategy::Greedy;
    WrapMode wrap = WrapMode::Mixed;
 
    const text::HyphenationDictionary* hyphenation = nullptr;
    float hyphenPenalty = 50.0f;
    int hyphenMinLeft = 2;
    int hyphenMinRight = 3;
    bool justify = true;
    float tolerance = 3.0f;
    float linePenalty = 10.0f;
};
 
enum class Align : uint8_t { Start, End, Center, Justify };
 
enum class BlockAlign : uint8_t { Start, Center, End };
 
enum class TabAlign : uint8_t { Left, Center, Right, Decimal };
struct TabStop {
    Pt position = 0.0f;             
    TabAlign align = TabAlign::Left;
    char32_t decimalChar = U'.';    
};
 
enum class Direction : uint8_t { Auto, Ltr, Rtl };
 
struct ParagraphStyle {
    Align align = Align::Justify;
 
    Direction direction = Direction::Auto;
 
    float firstLineIndent = 0.0f;
    float hangingIndent = 0.0f;
 
    std::u16string ellipsis;
 
    std::vector<TabStop> tabStops;
 
    Pt linePitch = 0.0f;
    float lineHeight = 1.7f;
 
    TextOrientation orientation = TextOrientation::Mixed;
 
    SpacingOptions spacing;
    BreakOptions lineBreak;
 
    bool preserveSpaces = false;
    int tabWidth = 4;
 
    float rotation = 0.0f;
 
    Pt resolvedLinePitch(Pt fontSize) const {
        return linePitch > 0.0f ? linePitch : fontSize * lineHeight;
    }
};
 
} // namespace typeset
 
#endif // TYPESET_STYLE_HPP