Series.hpp

#pragma once
#include "creativity/data/graph/style.hpp"
#include "creativity/data/graph/Target.hpp"
#include <cairomm/context.h>
#include <pangomm/fontdescription.h>
#include <pangomm/font.h>
#include <map>
#include <set>

#ifndef DOXYGEN_SHOULD_SEE_THIS
#if CAIROMM_MAJOR_VERSION < 1 || (CAIROMM_MAJOR_VERSION == 1 && CAIROMM_MINOR_VERSION <= 12)
namespace Cairo {

class SaveGuard final {
  public:
    explicit SaveGuard(RefPtr<Context> context) : ctx_{context} { ctx_->save(); }
    SaveGuard(const SaveGuard &) = delete;
    ~SaveGuard() { ctx_->restore(); }
  private:
    RefPtr<Context> ctx_;
};
}
#endif
#endif

namespace creativity { namespace data { namespace graph {

class Series {
    public:
        Series() = delete;

        Series(Target &target, int tmin, int tmax, double ymin, double ymax,
                std::string title = "", std::string x_label = "", std::string y_label = "");

        virtual ~Series();

        void finishPage();

        void newPage();

        static const LineStyle default_line_style;

        void addLine(const std::map<int, double> &points,
                const LineStyle &style = default_line_style);

        static const FillStyle default_region_style;

        void addRegion(const std::map<int, std::pair<double, double>> &intervals,
                const FillStyle &style = default_region_style
                );

        static const RectangleStyle default_legend_box_style;

        void addLegendItem(std::string markup,
                const FillStyle &lower,
                bool preserve = true,
                const RectangleStyle &style = default_legend_box_style);

        using LegendPainterCallback_t = std::function<void(Cairo::RefPtr<Cairo::Context>, const Cairo::Matrix&)>;

        void addLegendItem(std::string name, const LegendPainterCallback_t &legend_painter, bool preserve = true);

        void addLegendItem(std::string name, LegendPainterCallback_t &&legend_painter, bool preserve = true);

        static void drawRectangle(Cairo::RefPtr<Cairo::Context> ctx, double width, double height, const RectangleStyle &style, bool clip = false);

        RGBA background_colour{White};

        LineStyle tick_style{Black, 0.5, 3};

        double tick_label_space{2.0};

        LineStyle tick_grid_style{Transparent, 0.5};

        LineStyle tick_grid_extra_style{RGBA{0.75}, 0.5};

        RGBA tick_font_colour{Black};

        Pango::FontDescription tick_font{"serif 6"};

        RectangleStyle graph_style{White, LineStyle(Black, 1)};
        double graph_padding_left{0.0},
               graph_padding_right{0.0},
               graph_padding_top{2.0},
               graph_padding_bottom{2.0};

        double margin_top{5.0},
               margin_right{5.0},
               margin_bottom{5.0},
               margin_left{5.0};

        enum class LegendPosition {
            None, 
            Inside, 
            Right, 
            Left, 
            Top, 
            Bottom 
        };

        LegendPosition legend_position{LegendPosition::Right};

        double legend_rel_x{0.5};

        double legend_rel_y{0.5};

        double legend_graph_space{5.0};
        double legend_box_width{15.0};
        double legend_box_height{15.0};
        double legend_box_text_gap{5.0};
        double legend_padding_left{3.0},
               legend_padding_right{3.0},
               legend_padding_top{3.0},
               legend_padding_bottom{3.0};
        RectangleStyle legend_style{White, Black};
        double legend_text_max_width{60.0};
        double legend_text_max_height{40.0};
        double legend_spacing{3.0};
        Pango::FontDescription legend_font{"Latin Modern, DejaVu Serif, serif oblique 6"};

        std::string title;
        Pango::FontDescription title_font{"Latin Modern, DejaVu Serif, serif bold 12"};
        std::string x_label;
        std::string y_label;
        bool y_label_rotated = true;

        Pango::FontDescription axis_label_font{"Latin Modern, DejaVu Serif, serif oblique 8"};
        double title_padding{2.0};

        double axis_label_padding{2.0};

        double stray_thickness{1.0};

        std::set<int> t_ticks;

        std::set<double> y_ticks;

        bool y_axis_left = true;

        std::set<int> t_grid;

        std::set<int> t_grid_extra;

        std::set<double> y_grid;

        std::set<double> y_grid_extra;

        enum class TickEnds {
            Add,
            Replace, 
            None 
        };

        void recalcTicks(unsigned xmax = 10, unsigned ymax = 8, TickEnds end_mode = TickEnds::None);

        void recalcTicksT(unsigned max = 10, TickEnds end_mode = TickEnds::None);

        void recalcTicksY(unsigned max = 8, TickEnds end_mode = TickEnds::None);

        void setExtents(int tmin, int tmax, double ymin, double ymax, bool retick = true);

        void updateFonts(const Pango::FontDescription &new_font);

        void updateFontFamily(const std::string &new_font_family);

    private:
        Target &target_;
        int tmin_, tmax_;
        double ymin_, ymax_;

        // If this is true, the current page is done.
        bool page_finished_ = false;

        using LegendItem_t = std::tuple<bool, std::string, LegendPainterCallback_t>;
        // Legend items to add to the page; <preserve, title, callback> tuples.
        std::list<LegendItem_t> legend_items_;
        // Draw callbacks for the graph items; each will be called with the ctx already clipped to
        // the graph region, and surrounded with a save/restore pair.
        std::list<std::function<void(Cairo::RefPtr<Cairo::Context> ctx, const Cairo::Matrix&)>> draw_;

        // Implementation callback for addLegendItem(markup, lower, preserve, bg).
        void drawSimpleLegendItem(Cairo::RefPtr<Cairo::Context> ctx, const Cairo::Matrix &to_box, const FillStyle &lower, const RectangleStyle &bg) const;

        // Draws a legend item at the current position of the context, returning its size (width and height).  If dry_run is true, just returns the size.
        std::pair<double, double> drawLegendItem(Cairo::RefPtr<Cairo::Context> ctx, const LegendItem_t &item, bool dry_run = false) const;

        // Implementation method of addLine() that does the actual drawing
        void drawLine(Cairo::RefPtr<Cairo::Context> ctx, const Cairo::Matrix &translate_graph, const std::map<int, double> &points, const LineStyle &style) const;

        // Implementation method of addRegion() that does the actual drawing
        void drawRegion(Cairo::RefPtr<Cairo::Context> ctx, const Cairo::Matrix &translate_graph, const std::map<int, std::pair<double,double>> &points, const FillStyle &style) const;

    protected:
        static void boundRegion(
                Cairo::RefPtr<Cairo::Context> ctx,
                std::map<int, std::pair<double, double>>::const_iterator first,
                std::map<int, std::pair<double, double>>::const_iterator last,
                std::map<int, std::pair<double, double>> &strays);
};

}}}