gempyre_graphics.h

Go to the documentation of this file.

#ifndef GEMPYRE_GRAPHICS_H
#define GEMPYRE_GRAPHICS_H
 
#include <initializer_list>
#include <variant>
#include <array>
#include <string_view>
#include <functional>
#include <vector>
 
#include <gempyre.h>
#include <gempyre_bitmap.h> // for compatibility, not really needed, fwd declaration is sufficient
 
#ifdef WINDOWS_EXPORT
    #ifndef GEMPYRE_EX
        #define GGEMPYRE_EX __declspec( dllexport )
    //#else
    //    #define GEMPYRE_EX
    #endif
#endif
 
namespace  Gempyre {
 
class FrameComposer;
class CanvasData;
class Bitmap;
using CanvasDataPtr = std::shared_ptr<CanvasData>;
 
class GEMPYRE_EX CanvasElement : public Element {
public:
    using Command = std::variant<std::string, double, int>;
    using CommandList = std::vector<Command>;
    using DrawCallback = std::function<void()>;
    
    enum class DrawNotify{NoKick, Kick};
    
    ~CanvasElement();
    
    CanvasElement(const CanvasElement& other);
 
    CanvasElement(CanvasElement&& other);
    
    CanvasElement(Ui& ui, std::string_view id);
    
    CanvasElement(Ui& ui, std::string_view id, const Element& parent);
 
    CanvasElement(Ui& ui, const Element& parent);
 
    CanvasElement& operator=(const CanvasElement& other);
 
    CanvasElement& operator=(CanvasElement&& other);
 
    std::string add_image(std::string_view url, const std::function<void (std::string_view id)>& loaded = nullptr);
    
    void paint_image(std::string_view imageId, int x, int y, const Element::Rect& clippingRect  = {0, 0, 0, 0}) const;
    
    void paint_image(std::string_view imageId, const Element::Rect& targetRect, const Element::Rect& clippingRect = {0, 0, 0, 0}) const;
    
    void draw(const CommandList& canvasCommands);
 
    void draw(const FrameComposer& frameComposer);
 
    void draw(const Bitmap& bmp) {draw(0, 0, bmp);}
    
    void draw(int x, int y, const Bitmap& bmp); 
 
    void draw_completed(const DrawCallback& drawCompletedCallback, DrawNotify kick = DrawNotify::NoKick);
    
    void erase(bool resized = false);
private:
    friend class Bitmap;
    void paint(const CanvasDataPtr& canvas, int x, int y, bool as_draw);
private:
    CanvasDataPtr m_tile{};
    int m_width{0};
    int m_height{0};
};
 
class FrameComposer {
public:
    FrameComposer() {}
    FrameComposer(Gempyre::CanvasElement::CommandList& lst) : m_composition(lst) {}
    FrameComposer(FrameComposer&& other) = default;
    FrameComposer(const FrameComposer& other) = default;
    FrameComposer stroke_rect(const Gempyre::Element::Rect& r) {return push({"strokeRect", r.x, r.y, r.width, r.height});}
    FrameComposer stroke_rect(double x, double y, double w, double h) {return push({"strokeRect", x, y, w, h});}
    FrameComposer clear_rect(const Gempyre::Element::Rect& r) {return push({"clearRect", r.x, r.y, r.width, r.height});}
    FrameComposer clear_rect(double x, double y, double w, double h) {return push({"clearRect", x, y, w, h});}
    FrameComposer fill_rect(const Gempyre::Element::Rect& r) {return push({"fillRect", r.x, r.y, r.width, r.height});}
    FrameComposer fill_rect(double x, double y, double w, double h) {return push({"fillRect", x, y, w, h});}
    FrameComposer fill_text(std::string_view text, double x, double y) {return push({"fillText", std::string{text}, x, y});}
    FrameComposer stroke_text(std::string_view text, double x, double y) {return push({"strokeText", std::string{text}, x, y});}
    FrameComposer arc(double x, double y, double r, double sAngle, double eAngle) {
        return push({"arc", x, y, r, sAngle, eAngle});}
    FrameComposer ellipse(double x, double y, double radiusX, double radiusY, double rotation, double startAngle, double endAngle) {
        return push({"ellipse", x, y, radiusX, radiusY, rotation, startAngle, endAngle});}
    FrameComposer begin_path()  {return push({"beginPath"});}
    FrameComposer close_path() {return push({"closePath"});}
    FrameComposer line_to(double x, double y) {return push({"lineTo", x, y});}
    FrameComposer move_to(double x, double y)  {return push({"moveTo", x, y});}
    FrameComposer bezier_curve_to(double cp1x, double cp1y, double cp2x, double cp2y, double x, double y) {
        return push({"bezierCurveTo", cp1x, cp1y, cp2x, cp2y, x,  y});}
    FrameComposer quadratic_curve_to(double cpx, double cpy, double x, double y) {
        return push({"quadraticCurveTo", cpx, cpy, x, y});}
    FrameComposer arc_to(double x1, double y1, double x2, double y2, double radius) {
        return push({"arcTo", x1, y1, x2, y2, radius});}
    FrameComposer rect(const Gempyre::Element::Rect& r) {return push({"rect", r.x, r.y, r.width, r.height});}
    FrameComposer rect(double x, double y, double w, double h) {return push({"rect", x, y, w, h});}
    FrameComposer stroke() {return push({"stroke"});}
    FrameComposer fill() {return push({"fill"});}
    FrameComposer fill_style(std::string_view color) {return push({"fillStyle", std::string{color}});}
    FrameComposer stroke_style(std::string_view color) {return push({"strokeStyle", std::string{color}});}
    FrameComposer line_width(double width) {return push({"lineWidth", width});}
    FrameComposer font(std::string_view style) {return push({"font", std::string{style}});}
    FrameComposer text_align(std::string_view align) {return push({"textAlign", std::string{align}});}
    FrameComposer save() {return push({"save"});}
    FrameComposer restore() {return push({"restore"});}
    FrameComposer rotate(double angle)  {return push({"rotate", angle});}
    FrameComposer translate(double x, double y)  {return push({"translate", x, y});}
    FrameComposer scale(const double x, double y)  {return push({"scale", x, y});}
    FrameComposer draw_image(std::string_view id, double x, double y)  {return push({"drawImage", std::string{id}, x, y});}
    FrameComposer draw_image(std::string_view id, const Gempyre::Element::Rect& rect)  {return push({"drawImageRect", std::string{id}, rect.x, rect.y, rect.width, rect.height});}
    FrameComposer draw_image(std::string_view id, double x, double y, double w, double h)  {return push({"drawImageRect", std::string{id}, x, y, w, h});}
    FrameComposer draw_image(std::string_view id, const Gempyre::Element::Rect& clip, const Gempyre::Element::Rect& rect) {return push({"drawImageClip", std::string{id}, clip.x, clip.y, clip.width, clip.height, rect.x, rect.y, rect.width, rect.height});}
    FrameComposer draw_image(std::string_view id, double cx, double cy, double cw, double ch, double x, double y, double w, double h) {return push({"drawImageClip", std::string{id}, cx, cy, cw, ch, x, y, w, h});}
    FrameComposer text_baseline(std::string_view textBaseline) {return push({"textBaseline", std::string{textBaseline}});}
    [[nodiscard]] const Gempyre::CanvasElement::CommandList& composed() const {return m_composition;}
private:
    FrameComposer push(const std::initializer_list<Gempyre::CanvasElement::Command>& list) {m_composition.insert(m_composition.end(), list); return *this;}
    Gempyre::CanvasElement::CommandList m_composition{};
};
 
 
}
 
#endif // GEMPYRE_GRAPHICS_H