svg_path_widget.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/view/view.hpp>
#include <pulp/canvas/canvas.hpp>
#include <pulp/canvas/path.hpp>
#include <optional>
#include <string>
#include <vector>
 
namespace pulp::view {

struct SvgPathSegment {
    enum class Op {
        move_to,    
        line_to,    
        quad_to,    
        cubic_to,   
        close_path
    };
    Op op = Op::move_to;
    float p[6] = {};
};

class SvgPathWidget : public View {
public:
    SvgPathWidget() = default;

    void set_path(std::string data);

    Rect paint_extent() const;

    void set_viewbox(float width, float height);

    void set_stretch_to_bounds(bool stretch);
    bool stretch_to_bounds() const { return stretch_to_bounds_; }

    void set_fill_color(canvas::Color c);
    void clear_fill();

    void set_fill_gradient(std::string css_linear_gradient);
    void clear_fill_gradient();
    const std::string& fill_gradient() const { return fill_gradient_; }

    void set_stroke_color(canvas::Color c);
    void clear_stroke();

    void set_stroke_gradient(std::string css_linear_gradient);
    void clear_stroke_gradient();
    const std::string& stroke_gradient() const { return stroke_gradient_; }

    void set_stroke_width(float w);

    void set_stroke_cap(canvas::LineCap cap);
    void set_stroke_join(canvas::LineJoin join);
    void set_stroke_miter_limit(float limit);
    std::optional<canvas::LineCap> stroke_cap() const {
        return stroke_cap_;
    }
    std::optional<canvas::LineJoin> stroke_join() const {
        return stroke_join_;
    }
    std::optional<float> stroke_miter_limit() const {
        return stroke_miter_limit_;
    }

    void set_fill_rule(canvas::FillRule rule);
 
    // Accessors used by tests.
    const std::string& path_data() const { return path_data_; }
    const std::vector<SvgPathSegment>& segments() const { return segments_; }
    bool has_fill() const { return has_fill_; }
    bool has_stroke() const { return has_stroke_; }
    canvas::Color fill_color() const { return fill_color_; }
    canvas::Color stroke_color() const { return stroke_color_; }
    float stroke_width() const { return stroke_width_; }
    canvas::FillRule fill_rule() const { return fill_rule_; }
    float viewbox_width() const { return viewbox_w_; }
    float viewbox_height() const { return viewbox_h_; }
 
    void paint(canvas::Canvas& canvas) override;

    float intrinsic_width() const override  { return viewbox_w_ > 0 ? viewbox_w_ : 0; }
    float intrinsic_height() const override { return viewbox_h_ > 0 ? viewbox_h_ : 0; }
 
private:
    void reparse();
    canvas::Path stroke_geometry() const;
    void repaint_extent_change(const Rect& before);
 
    std::string path_data_;
    std::vector<SvgPathSegment> segments_;
    canvas::Color fill_color_{0.0f, 0.0f, 0.0f, 1.0f};
    canvas::Color stroke_color_{0.0f, 0.0f, 0.0f, 1.0f};
    std::string   fill_gradient_;    // non-empty overrides solid fill
    std::string   stroke_gradient_;  // non-empty overrides solid stroke
    float stroke_width_ = 1.0f;
    std::optional<canvas::LineCap> stroke_cap_;
    std::optional<canvas::LineJoin> stroke_join_;
    std::optional<float> stroke_miter_limit_;
    canvas::FillRule fill_rule_ = canvas::FillRule::nonzero;  // pulp #3656
    float viewbox_w_ = 0.0f;   // 0 means "use widget bounds 1:1"
    float viewbox_h_ = 0.0f;
    bool stretch_to_bounds_ = false;  // preserveAspectRatio="none"
    bool has_fill_ = true;
    bool has_stroke_ = false;
};
 
} // namespace pulp::view