GraphArea.hpp

#pragma once
#include <eris/types.hpp>
#include <eris/noncopyable.hpp>
#include <eris/WrappedPositional.hpp>
#include <gtkmm/drawingarea.h>
#include <cairomm/matrix.h>
#include <cairomm/pattern.h>
#include <cairomm/refptr.h>
#include <cairomm/surface.h>
#include <cstddef>
#include <vector>

namespace Cairo { class Context; }

namespace creativity { namespace gui {

class GUI;

class GraphArea : public Gtk::DrawingArea, eris::noncopyable {
    public:
        GraphArea() = delete;

        GraphArea(GUI &gui);

        Cairo::Matrix graph_to_canvas() const;

        Cairo::Matrix canvas_to_graph() const;

        eris::Position graph_position(const eris::Position &p);

        virtual bool on_draw(const Cairo::RefPtr<Cairo::Context> &cr) override;

        enum class PointType {
            X, 
            CROSS, 
            SQUARE 
        };

        using Colour = Cairo::RefPtr<Cairo::SolidPattern>;

        void drawPoint(const Cairo::RefPtr<Cairo::Context> &cr, const Cairo::Matrix &trans, const eris::Position &point,
                const PointType &type, const Colour &colour, double radius, double line_width);

        void drawGraphCircle(const Cairo::RefPtr<Cairo::Context> &cr, const Cairo::Matrix &trans,
                double cx, double cy, double r, const Colour &colour, double stroke_width, double radial_stroke_width = 0.0);

        void drawCanvasCircle(const Cairo::RefPtr<Cairo::Context> &cr, const Cairo::Matrix &trans,
                const eris::Position &centre, double r, const Colour &colour, double stroke_width, double radial_stroke_width = 0.0);

        void drawLine(const Cairo::RefPtr<Cairo::Context> &cr, const Cairo::Matrix &trans,
                const eris::Position &from, const eris::Position &to,
                double min_length = 0.0, Colour start_colour = Colour(), Colour end_colour = Colour());

        void drawAxes(const Cairo::RefPtr<Cairo::Context> &cr, const Cairo::Matrix &trans);

        void drawCircularAxis(const Cairo::RefPtr<Cairo::Context> &cr, const Cairo::Matrix &trans);

        struct {
            struct {
                bool
                    reader = true, 
                    friendship = true, 
                    movement = true, 
                    book_live = true, 
                    book_dead = true, 
                    book_public = true, 
                    author_live = true, 
                    author_dead = true, 
                    author_public = true, 
                    reading = true, 
                    utility_gain = true, 
                    utility_loss = true, 
                    axes = true; 
            } enabled;

            struct {
                Colour
                    book_live = Cairo::SolidPattern::create_rgb(0, .4, 1),
                    book_dead = Cairo::SolidPattern::create_rgb(0.5, 0.5, 0.5),
                    book_public = Cairo::SolidPattern::create_rgb(0.306, 0.604, 0.024),
                    author_live = Cairo::SolidPattern::create_rgba(0.5, 0.2, 0.5, 0.5),
                    author_dead = Cairo::SolidPattern::create_rgba(0.75, 0.5, 0.75, 0.5),
                    author_public = Cairo::SolidPattern::create_rgba(0.5, 0.2, 0.5, 0.25),
                    reading = Cairo::SolidPattern::create_rgba(1, 0.55, 0, 0.5),
                    reader = Cairo::SolidPattern::create_rgb(1, 0, 0),
                    friendship = Cairo::SolidPattern::create_rgba(0.75, 0, 0, 0.5),
                    movement = Cairo::SolidPattern::create_rgba(1, 0, 0, 0.75),
                    utility_gain = Cairo::SolidPattern::create_rgba(.133, .545, .133, 0.5),
                    utility_loss = Cairo::SolidPattern::create_rgba(.545, .133, .133, 0.5),
                    axes = Cairo::SolidPattern::create_rgb(0, 0, 0),
                    background = Cairo::SolidPattern::create_rgb(1, 1, 1);
            } colour;

            struct {
                std::vector<double>
                    author_live,
                    author_dead{{3.0, 2.0}},
                    author_public{{3.0, 2.0}},
                    reading,
                    friendship{{12.0, 3.0}},
                    movement,
                    utility;
            } dash;

            struct {
                double
                    book_live = 2.0, 
                    book_dead = 2.0, 
                    book_public = 2.0, 
                    author_live = 2.0, 
                    author_dead = 2.0, 
                    author_public = 2.0, 
                    reading = 2.0, 
                    reader = 2.0, 
                    friendship = 1.0, 
                    movement = 3.0, 
                    utility = 2.0, 
                    utility_radial = 1.0, 
                    axes = 2.0, 
                    axes_ticks = 1.0, 
                    axes_ticks_big = 2.0; 
            } stroke_width;

            struct {
                double
                    reader = 7.071, 

                    book = 5.0,
                    book_scale_a = 3.0,
                    book_scale_b = 0.3,
                    utility_gain_scale = 5.0,
                    utility_loss_scale = 5.0,
                    tick = 6.0,
                    tick_big = 18.0;

            } size;

            struct {
                PointType
                    reader = PointType::X,
                    book_live = PointType::CROSS,
                    book_dead = PointType::CROSS,
                    book_public = PointType::CROSS;

                double
                    tick_every = 1.0,
                    movement_alpha_multiplier = 0.1;

                unsigned int
                    tick_big = 5;
            } style;

            size_t subdimensionX = 0;
            size_t subdimensionY = 1;

        } design;

        void resetCache();

    protected:
        void drawPointSingle(const Cairo::RefPtr<Cairo::Context> &cr, const Cairo::Matrix &trans,
                double x, double y, const PointType &type, const Colour &colour, double radius, double line_width);

        GUI &gui_;
        eris::WrappedPositionalBase wpb_;

        std::list<std::pair<eris::eris_time_t, Cairo::RefPtr<Cairo::ImageSurface>>> drawing_cache_;
        int drawing_cache_width_ = -1;
        int drawing_cache_height_ = -1;

};

} }