geometry.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/canvas/affine_transform.hpp>
 
#include <algorithm>
#include <cctype>
#include <cmath>
#include <optional>
#include <string>
#include <vector>
 
namespace pulp::view {

using AffineTransform = pulp::canvas::AffineTransform;
 
struct Point {
    float x = 0, y = 0;
 
    Point operator+(const Point& p) const { return {x + p.x, y + p.y}; }
    Point operator-(const Point& p) const { return {x - p.x, y - p.y}; }
    bool operator==(const Point& p) const { return x == p.x && y == p.y; }
};
 
struct Size {
    float width = 0, height = 0;
 
    bool operator==(const Size& s) const { return width == s.width && height == s.height; }
    bool is_empty() const { return width <= 0 || height <= 0; }
};
 
struct IntRect;  // below

struct Rect {
    float x = 0, y = 0, width = 0, height = 0;
 
    constexpr float right() const { return x + width; }
    constexpr float bottom() const { return y + height; }
    Point origin() const { return {x, y}; }
    Size size() const { return {width, height}; }
    Point center() const { return {x + width * 0.5f, y + height * 0.5f}; }

    constexpr float center_x() const { return x + width * 0.5f; }
    constexpr float center_y() const { return y + height * 0.5f; }
 
    bool contains(Point p) const {
        return p.x >= x && p.x < right() && p.y >= y && p.y < bottom();
    }
    constexpr bool contains(float px, float py) const {
        return px >= x && px < right() && py >= y && py < bottom();
    }

    constexpr bool encloses(const Rect& r) const {
        return r.x >= x && r.y >= y && r.right() <= right() && r.bottom() <= bottom();
    }
 
    constexpr bool is_empty() const { return width <= 0 || height <= 0; }
 
    Rect inset(float amount) const {
        return {x + amount, y + amount,
                std::max(0.0f, width - 2 * amount),
                std::max(0.0f, height - 2 * amount)};
    }
 
    Rect inset(float h, float v) const {
        return {x + h, y + v,
                std::max(0.0f, width - 2 * h),
                std::max(0.0f, height - 2 * v)};
    }
 
    // ── Non-mutating derivations ─────────────────────────────────────────
    Rect reduced(float d) const { return inset(d); }
    Rect reduced(float dx, float dy) const { return inset(dx, dy); }
    Rect expanded(float d) const { return inset(-d); }
    Rect expanded(float dx, float dy) const { return inset(-dx, -dy); }
 
    constexpr Rect translated(float dx, float dy) const {
        return {x + dx, y + dy, width, height};
    }
 
    constexpr Rect with_x(float v) const      { return {v, y, width, height}; }
    constexpr Rect with_y(float v) const      { return {x, v, width, height}; }
    constexpr Rect with_width(float v) const  { return {x, y, v, height}; }
    constexpr Rect with_height(float v) const { return {x, y, width, v}; }
    constexpr Rect with_size(float w, float h) const { return {x, y, w, h}; }
    constexpr Rect with_position(float nx, float ny) const {
        return {nx, ny, width, height};
    }

    constexpr Rect with_size_keeping_center(float w, float h) const {
        return {x + (width - w) * 0.5f, y + (height - h) * 0.5f, w, h};
    }
 
    // ── The slicing idiom ────────────────────────────────────────────────
    // `remove_from_*` MUTATES this rect and returns the slice taken off. It is
    // the standard way to lay a row of controls out of a bounds rect:
    //
    //     auto header = bounds.remove_from_top(24);
    //     auto footer = bounds.remove_from_bottom(24);
    //     // `bounds` is now just the middle.
    //
    // Asking for more than exists takes everything and leaves an empty rect.
    // Asking for a NEGATIVE amount takes nothing and changes nothing — a
    // deliberate choice: the alternative (a negative-height slice, which is
    // what naive arithmetic produces) is never what a caller wants and turns a
    // simple sign bug into an invisible, badly-clipped widget.
    Rect remove_from_top(float amount) {
        if (amount <= 0) return {x, y, width, 0};
        const float take = std::min(amount, height);
        const Rect taken{x, y, width, take};
        y += take;
        height -= take;
        return taken;
    }
    Rect remove_from_bottom(float amount) {
        if (amount <= 0) return {x, bottom(), width, 0};
        const float take = std::min(amount, height);
        height -= take;
        return {x, y + height, width, take};
    }
    Rect remove_from_left(float amount) {
        if (amount <= 0) return {x, y, 0, height};
        const float take = std::min(amount, width);
        const Rect taken{x, y, take, height};
        x += take;
        width -= take;
        return taken;
    }
    Rect remove_from_right(float amount) {
        if (amount <= 0) return {right(), y, 0, height};
        const float take = std::min(amount, width);
        width -= take;
        return {x + width, y, take, height};
    }
 
    // ── Set operations ───────────────────────────────────────────────────
    constexpr bool intersects(const Rect& o) const {
        if (is_empty() || o.is_empty()) return false;
        return x < o.right() && right() > o.x && y < o.bottom() && bottom() > o.y;
    }

    Rect intersection(const Rect& o) const {
        const float ix = std::max(x, o.x);
        const float iy = std::max(y, o.y);
        const float ir = std::min(right(), o.right());
        const float ib = std::min(bottom(), o.bottom());
        if (ir <= ix || ib <= iy) return {};
        return {ix, iy, ir - ix, ib - iy};
    }

    Rect union_with(const Rect& o) const {
        if (is_empty()) return o;
        if (o.is_empty()) return *this;
        const float ux = std::min(x, o.x);
        const float uy = std::min(y, o.y);
        const float ur = std::max(right(), o.right());
        const float ub = std::max(bottom(), o.bottom());
        return {ux, uy, ur - ux, ub - uy};
    }
 
    // ── Conversion ───────────────────────────────────────────────────────
    IntRect to_nearest_int() const;

    IntRect to_enclosing_int() const;
 
    bool operator==(const Rect& r) const {
        return x == r.x && y == r.y && width == r.width && height == r.height;
    }
    bool operator!=(const Rect& r) const { return !(*this == r); }
};

struct IntRect {
    int x = 0, y = 0, width = 0, height = 0;
 
    constexpr int right() const { return x + width; }
    constexpr int bottom() const { return y + height; }

    constexpr int center_x() const { return x + width / 2; }
    constexpr int center_y() const { return y + height / 2; }
 
    constexpr bool is_empty() const { return width <= 0 || height <= 0; }
 
    constexpr bool contains(int px, int py) const {
        return px >= x && px < right() && py >= y && py < bottom();
    }
    constexpr bool contains(const IntRect& r) const {
        return r.x >= x && r.y >= y && r.right() <= right() && r.bottom() <= bottom();
    }
 
    IntRect reduced(int d) const {
        return {x + d, y + d, std::max(0, width - 2 * d), std::max(0, height - 2 * d)};
    }
    IntRect reduced(int dx, int dy) const {
        return {x + dx, y + dy, std::max(0, width - 2 * dx), std::max(0, height - 2 * dy)};
    }
    IntRect expanded(int d) const { return reduced(-d); }
    IntRect expanded(int dx, int dy) const { return reduced(-dx, -dy); }
 
    constexpr IntRect translated(int dx, int dy) const {
        return {x + dx, y + dy, width, height};
    }
 
    constexpr IntRect with_x(int v) const      { return {v, y, width, height}; }
    constexpr IntRect with_y(int v) const      { return {x, v, width, height}; }
    constexpr IntRect with_width(int v) const  { return {x, y, v, height}; }
    constexpr IntRect with_height(int v) const { return {x, y, width, v}; }
    constexpr IntRect with_size(int w, int h) const { return {x, y, w, h}; }
    constexpr IntRect with_position(int nx, int ny) const {
        return {nx, ny, width, height};
    }

    constexpr IntRect with_size_keeping_center(int w, int h) const {
        return {x + (width - w) / 2, y + (height - h) / 2, w, h};
    }
 
    // ── The slicing idiom (integer) ──────────────────────────────────────
    // Same contract as the float version, including the negative-amount guard.
    IntRect remove_from_top(int amount) {
        if (amount <= 0) return {x, y, width, 0};
        const int take = std::min(amount, height);
        const IntRect taken{x, y, width, take};
        y += take;
        height -= take;
        return taken;
    }
    IntRect remove_from_bottom(int amount) {
        if (amount <= 0) return {x, bottom(), width, 0};
        const int take = std::min(amount, height);
        height -= take;
        return {x, y + height, width, take};
    }
    IntRect remove_from_left(int amount) {
        if (amount <= 0) return {x, y, 0, height};
        const int take = std::min(amount, width);
        const IntRect taken{x, y, take, height};
        x += take;
        width -= take;
        return taken;
    }
    IntRect remove_from_right(int amount) {
        if (amount <= 0) return {right(), y, 0, height};
        const int take = std::min(amount, width);
        width -= take;
        return {x + width, y, take, height};
    }
 
    constexpr bool intersects(const IntRect& o) const {
        if (is_empty() || o.is_empty()) return false;
        return x < o.right() && right() > o.x && y < o.bottom() && bottom() > o.y;
    }
 
    IntRect intersection(const IntRect& o) const {
        const int ix = std::max(x, o.x);
        const int iy = std::max(y, o.y);
        const int ir = std::min(right(), o.right());
        const int ib = std::min(bottom(), o.bottom());
        if (ir <= ix || ib <= iy) return {};
        return {ix, iy, ir - ix, ib - iy};
    }
 
    IntRect union_with(const IntRect& o) const {
        if (is_empty()) return o;
        if (o.is_empty()) return *this;
        const int ux = std::min(x, o.x);
        const int uy = std::min(y, o.y);
        const int ur = std::max(right(), o.right());
        const int ub = std::max(bottom(), o.bottom());
        return {ux, uy, ur - ux, ub - uy};
    }

    constexpr Rect to_float() const {
        return {static_cast<float>(x), static_cast<float>(y),
                static_cast<float>(width), static_cast<float>(height)};
    }
 
    constexpr bool operator==(const IntRect& r) const {
        return x == r.x && y == r.y && width == r.width && height == r.height;
    }
    constexpr bool operator!=(const IntRect& r) const { return !(*this == r); }
};
 
inline IntRect Rect::to_nearest_int() const {
    // Round the EDGES, then derive the extent — so a rect spanning [0.6, 2.4]
    // becomes [1, 2] (width 1), not "width round(1.8) = 2" starting at 1.
    const int l = static_cast<int>(std::lround(x));
    const int t = static_cast<int>(std::lround(y));
    const int r = static_cast<int>(std::lround(right()));
    const int b = static_cast<int>(std::lround(bottom()));
    return {l, t, r - l, b - t};
}
 
inline IntRect Rect::to_enclosing_int() const {
    const int l = static_cast<int>(std::floor(x));
    const int t = static_cast<int>(std::floor(y));
    const int r = static_cast<int>(std::ceil(right()));
    const int b = static_cast<int>(std::ceil(bottom()));
    return {l, t, r - l, b - t};
}
 
// Layout mode
enum class LayoutMode { flex, grid };
 
// Flex layout direction. row_reverse / column_reverse route
// `flexDirection: 'row-reverse' | 'column-reverse'` to
// YGFlexDirectionRowReverse / ColumnReverse.
enum class FlexDirection { row, column, row_reverse, column_reverse };

enum class FlexWrap { no_wrap, wrap, wrap_reverse };

enum class BoxSizing { content_box, border_box };
 
// Flex alignment (auto_ = inherit from parent's align_items).
// `baseline` maps to YGAlignBaseline.
enum class FlexAlign { start, center, end, stretch, auto_, baseline };

enum class FlexJustify {
    start,          
    center,         
    end_,           
    space_between,  
    space_around,   
    space_evenly,   
};

enum class FlexOverflow {
    visible,    
    hidden,     
    scroll,     
    auto_,      
};
 
// ── Viewport-Relative Dimension Units ───────────────────────────────────────
 
enum class DimensionUnit {
    px,      
    percent, 
    vw,      
    vh,      
    vmin,    
    vmax,    
    auto_    
};
 
struct Dimension {
    float value = 0.0f;
    DimensionUnit unit = DimensionUnit::px;
 
    float resolve(float parent_size, float viewport_w, float viewport_h,
                  float dpi_scale = 1.0f) const {
        switch (unit) {
            case DimensionUnit::px:      return value * dpi_scale;
            case DimensionUnit::percent: return value / 100.0f * parent_size;
            case DimensionUnit::vw:      return value / 100.0f * viewport_w;
            case DimensionUnit::vh:      return value / 100.0f * viewport_h;
            case DimensionUnit::vmin:    return value / 100.0f * std::min(viewport_w, viewport_h);
            case DimensionUnit::vmax:    return value / 100.0f * std::max(viewport_w, viewport_h);
            case DimensionUnit::auto_:   return 0.0f;
        }
        return value;
    }
 
    static Dimension parse(const std::string& str) {
        auto trim = [](std::string s) {
            while (!s.empty() && std::isspace(static_cast<unsigned char>(s.front()))) s.erase(0, 1);
            while (!s.empty() && std::isspace(static_cast<unsigned char>(s.back()))) s.pop_back();
            return s;
        };
 
        const auto input = trim(str);
        if (input == "auto") return {0, DimensionUnit::auto_};
        Dimension d;
        size_t pos = 0;
        try { d.value = std::stof(input, &pos); } catch (...) { return d; }
        auto suffix = trim(input.substr(pos));
        if (suffix == "vw") d.unit = DimensionUnit::vw;
        else if (suffix == "vh") d.unit = DimensionUnit::vh;
        else if (suffix == "vmin") d.unit = DimensionUnit::vmin;
        else if (suffix == "vmax") d.unit = DimensionUnit::vmax;
        else if (suffix == "%") d.unit = DimensionUnit::percent;
        else if (suffix.empty() || suffix == "px") d.unit = DimensionUnit::px;
        else return {};
        return d;
    }
};
 
// Flex layout properties for a view
struct FlexStyle {
    FlexDirection direction = FlexDirection::column;
    FlexAlign align_items = FlexAlign::stretch;
    FlexAlign align_self = FlexAlign::auto_;  

    FlexAlign align_content = FlexAlign::start;
    enum class AlignContentSpace { none, space_between, space_around, space_evenly };
    AlignContentSpace align_content_space = AlignContentSpace::none;
 
    FlexJustify justify_content = FlexJustify::start;
 
    float gap = 0;              
    float row_gap = -1;         
    float column_gap = -1;      
 
    float padding = 0;
    float padding_top = -1;     
    float padding_right = -1;
    float padding_bottom = -1;
    float padding_left = -1;
 
    float margin = 0;           
    float margin_top = -1;      
    float margin_right = -1;
    float margin_bottom = -1;
    float margin_left = -1;
 
    float flex_grow = 0;        
    float flex_shrink = 1;      
    float flex_basis = -1;      
 
    float min_width = 0;
    float min_height = 0;
    float preferred_width = 0;
    float preferred_height = 0;
    float max_width = 0;        
    float max_height = 0;       

    Dimension dim_width;
    Dimension dim_height;
    Dimension dim_min_width;
    Dimension dim_min_height;
    Dimension dim_max_width;
    Dimension dim_max_height;
    Dimension dim_flex_basis;

    Dimension dim_margin_top;
    Dimension dim_margin_right;
    Dimension dim_margin_bottom;
    Dimension dim_margin_left;
    Dimension dim_padding_top;
    Dimension dim_padding_right;
    Dimension dim_padding_bottom;
    Dimension dim_padding_left;

    Dimension dim_margin_start;
    Dimension dim_margin_end;
    Dimension dim_padding_start;
    Dimension dim_padding_end;
    Dimension dim_start;
    Dimension dim_end;

    enum class WritingDirection { inherit, ltr, rtl };
    WritingDirection writing_direction = WritingDirection::inherit;

    void resolve_dimensions(float parent_w, float parent_h,
                            float viewport_w, float viewport_h, float dpi = 1.0f) {
        if (dim_width.unit != DimensionUnit::px || dim_width.value != 0)
            preferred_width = dim_width.resolve(parent_w, viewport_w, viewport_h, dpi);
        if (dim_height.unit != DimensionUnit::px || dim_height.value != 0)
            preferred_height = dim_height.resolve(parent_h, viewport_w, viewport_h, dpi);
        if (dim_min_width.unit != DimensionUnit::px || dim_min_width.value != 0)
            min_width = dim_min_width.resolve(parent_w, viewport_w, viewport_h, dpi);
        if (dim_min_height.unit != DimensionUnit::px || dim_min_height.value != 0)
            min_height = dim_min_height.resolve(parent_h, viewport_w, viewport_h, dpi);
    }

    FlexWrap flex_wrap = FlexWrap::no_wrap;
    BoxSizing box_sizing = BoxSizing::border_box;
    int order = 0;              

    std::optional<float> aspect_ratio;
 
    // Helper: resolve per-side margin
    float margin_t() const { return margin_top >= 0 ? margin_top : margin; }
    float margin_r() const { return margin_right >= 0 ? margin_right : margin; }
    float margin_b() const { return margin_bottom >= 0 ? margin_bottom : margin; }
    float margin_l() const { return margin_left >= 0 ? margin_left : margin; }
 
    // Helper: resolve directional gap. row_reverse counts as a row-axis
    // container; the visual reversal doesn't change which gap edge
    // (column-gap) sits between siblings.
    float effective_gap(FlexDirection dir) const {
        if (dir == FlexDirection::row || dir == FlexDirection::row_reverse)
            return column_gap >= 0 ? column_gap : gap;
        return row_gap >= 0 ? row_gap : gap;
    }
 
    // Helper: resolve flex_basis or preferred size
    float basis_or_preferred(bool is_row) const {
        if (flex_basis >= 0) return flex_basis;
        return is_row ? preferred_width : preferred_height;
    }
};

struct GridTrack {
    enum class Type { fixed, fr, auto_ };
    Type type = Type::auto_;
    float value = 1.0f;  
 
    static GridTrack fixed_px(float px) { return {Type::fixed, px}; }
    static GridTrack fractional(float fr) { return {Type::fr, fr}; }
    static GridTrack auto_size() { return {Type::auto_, 0}; }
};

struct GridStyle {
    std::vector<GridTrack> template_columns;  
    std::vector<GridTrack> template_rows;     

    GridTrack auto_columns = GridTrack::auto_size();
    GridTrack auto_rows    = GridTrack::auto_size();

    enum class AutoFlow {
        row,           
        column,        
        row_dense,     
        column_dense,  
    };
    AutoFlow auto_flow = AutoFlow::row;
 
    float column_gap = 0;                     
    float row_gap = 0;                        

    struct NamedArea {
        std::string name;
        int col_start = 1;
        int col_end = 1;
        int row_start = 1;
        int row_end = 1;
    };
    std::vector<NamedArea> template_areas;
 
    // Per-child grid placement
    int grid_column_start = 0;  
    int grid_column_end = 0;    
    int grid_row_start = 0;
    int grid_row_end = 0;
    std::string grid_area_name;

    static std::vector<GridTrack> parse_template(const std::string& tmpl, int depth = 0);

    static std::vector<NamedArea> parse_template_areas(const std::string& css);

    static AutoFlow parse_auto_flow(const std::string& s) {
        if (s == "column")             return AutoFlow::column;
        if (s == "dense" || s == "row dense") return AutoFlow::row_dense;
        if (s == "column dense")       return AutoFlow::column_dense;
        return AutoFlow::row;
    }
};
 
} // namespace pulp::view