GUI.hpp

#pragma once
#include "creativity/cmdargs/GUI.hpp"
#include "creativity/gui/GraphArea.hpp"
#include <eris/noncopyable.hpp>
#include <eris/Position.hpp>
#include <eris/types.hpp>
#include <glibmm/refptr.h>
#include <sigc++/connection.h>
#include <gtkmm/widget.h>
#include <gtkmm/builder.h> // IWYU pragma: keep
#include <boost/geometry/core/cs.hpp>
#include <boost/geometry/geometries/point.hpp>
#include <boost/geometry/index/rtree.hpp>
#include <unordered_map>
#include <list>
#include <chrono>
#include <functional>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <memory>

namespace Gdk { class Cursor; }
namespace Glib { class Dispatcher; }
namespace Gtk { class Application; }
namespace Gtk { class FileFilter; }
namespace Gtk { class ScrolledWindow; }
namespace Gtk { class TreeView; }
namespace Gtk { class Window; }
namespace creativity { class Creativity; }
namespace creativity { namespace state { class State; } }

namespace creativity {
namespace gui {

// Forward declarations
class ReaderStore;
class BookStore;
class InfoWindow;

class GUI : eris::noncopyable {
    public:
        struct Parameter; // forward declaration

        GUI(
                Creativity &creativity,

                std::function<void(Parameter param)> configure,

                std::function<void()> initialize,

                std::function<void(eris::eris_time_t end)> change_periods,

                std::function<void()> run,

                std::function<void()> stop,

                std::function<void()> step,

                std::function<void()> quit
        );

        // Destructor: tells the thread to quit and then waits until it does
        virtual ~GUI();

        void start(const cmdargs::GUI &args);

        void checkEvents();

        void waitEvents();

        void newStates(eris::eris_time_t switch_to = (eris::eris_time_t) -1);

        void initialized();

        void running();

        void progress(eris::eris_time_t t, eris::eris_time_t end, double speed);

        void stopped(bool more);

        void error(std::string message);

        enum class ParamType {
            save_as, 
            load, 
            seed, 
            threads 
        };
        struct Parameter {
            ParamType param;
            union {
                bool bl;
                unsigned long ul;
                long l;
                unsigned int ui;
                int i;
                double dbl;
                std::chrono::milliseconds dur_ms;
                void *ptr;
            };
        };

        class Event {
            public:
                enum class Type {
                    configure, 
                    initialize, 
                    periods, 
                    run, 
                    stop, 
                    step, 
                    quit, 
                    none 
                };

                operator bool();

                Type type = Type::none;

                Parameter parameter;

                unsigned long ul;

            private:
                friend class GUI;
                Event() = default;
                Event(Type t);
                Event(const Parameter &p);
                Event(Type t, unsigned long ul);
        };

        void waitForEvent(Event::Type t);

        static std::string pos_to_string(const eris::Position &pos);

    private:
        Creativity &creativity_;

        std::thread gui_thread_{};

        Glib::RefPtr<Gtk::Application> app_;

        Glib::RefPtr<Gtk::Builder> builder_;

        std::shared_ptr<Gtk::Window> main_window_;

        std::string main_window_title_;

        bool thread_running_{false};

        bool piracy_tick_added_ = false;

        bool public_tick_added_ = false;

        std::unordered_map<std::string, double> default_override_;

        std::unique_ptr<Glib::Dispatcher> dispatcher_;

        std::mutex mutex_;

        std::condition_variable cv_;

        void processEvents_(std::unique_lock<decltype(mutex_)> &lock);

        class Signal {
            public:
                enum class Type {
                    new_states,
                    initialized, 
                    running, 
                    progress, 
                    stopped, 
                    error, 
                    quit, 
                    none 
                };

                Type type = Type::none;

                std::string message;
                bool boolean;
                std::vector<uint64_t> uls;
                std::vector<double> doubles;

                Signal() = default;
                Signal(Type type) : type(type) {}
                Signal(Type type, const std::string &message) : type{type}, message{message} {}
                Signal(Type type, bool b) : type{type}, boolean{b} {}
                Signal(Type type, double d) : type{type}, doubles(1, d) {}
                template<typename UIntT, typename = typename std::enable_if<std::is_integral<UIntT>::value and std::is_unsigned<UIntT>::value>::type>
                Signal(Type type, UIntT ul) : type{type}, uls(1, ul) {}
        };

        std::list<Signal> signal_queue_;

        void queueSignal(Signal &&s);

        std::list<Event> event_queue_;

        template <typename... Args>
        void queueEvent(Args&&... args);

        friend class GraphArea;

        void thr_signal();

        void thr_run(const cmdargs::GUI &args);

        void thr_connect_vis_setting(
                const std::string &field,
                bool &enabled,
                GraphArea::Colour &colour,
                bool affects_rtree = false,
                const std::vector<std::string> &needs_all = {},
                const std::vector<std::string> &needs_any = {});

        void thr_connect_vis_enabled(
                const std::string &field,
                bool &enabled,
                bool affects_rtree = false,
                const std::vector<std::string> &needs_all = {},
                const std::vector<std::string> &needs_any = {});

        void thr_connect_vis_colour(
                const std::string &field,
                GraphArea::Colour &colour,
                const std::vector<std::string> &needs_all = {},
                const std::vector<std::string> &needs_any = {});

        void thr_connect_vis_deps(
                Gtk::Widget *widget,
                const std::vector<std::string> &needs_all,
                const std::vector<std::string> &needs_any);

        void thr_update_parameters();

        void thr_set_state(eris::eris_time_t t);

        eris::eris_time_t state_curr_ = (eris::eris_time_t) -1;

        eris::eris_time_t state_num_ = 0;

        void thr_info_dialog(eris::eris_id_t member_id);

        void loadSim();

        void saveSim();

        void initializeSim();

        void runSim();

        std::unique_ptr<GraphArea> graph_;

        Gtk::ScrolledWindow *rdr_win_;

        Gtk::ScrolledWindow *bk_win_;

        template <class T>
        typename std::enable_if<std::is_base_of<Gtk::Widget, T>::value, T*>::type
        widget(const std::string &widget_name) {
            T* widget;
            builder_->get_widget(widget_name, widget);
            return widget;
        }

        double sb(const std::string &widget_name);

        int sb_int(const std::string &widget_name);

        std::string save_, load_;

        // The file filter.  Access via fileFilter().
        mutable Glib::RefPtr<Gtk::FileFilter> ff_;

        decltype(ff_) fileFilter() const;

        // The callbacks for GUI thread events
        std::function<void(GUI::Parameter)> on_configure_;
        std::function<void()> on_initialize_;
        std::function<void(unsigned int count)> on_change_periods_;
        std::function<void()> on_run_;
        std::function<void()> on_stop_;
        std::function<void()> on_step_;
        std::function<void()> on_quit_;

        void handleEvent(const GUI::Event &event);

        std::unordered_map<eris::eris_id_t, std::unique_ptr<InfoWindow>> info_windows_;

        using rt_point = boost::geometry::model::point<double, 2, boost::geometry::cs::cartesian>;
        using rt_val = std::pair<rt_point, eris::eris_id_t>;
        using RTree = boost::geometry::index::rtree<rt_val, boost::geometry::index::rstar<16>>;

        std::vector<rt_val> thr_nearest(const rt_point &point, int n = 1);

        void thr_reset_rtrees();

        void thr_init_rtree(RTree &rt, const std::shared_ptr<const state::State> &state) const;

        std::function<bool(GdkEventMotion* event)> motion_handler_;
        sigc::connection motion_handler_conn_;
        Glib::RefPtr<Gdk::Cursor> hand_;

        struct temporal_data {
            Glib::RefPtr<ReaderStore> rdr_model;
            std::unique_ptr<Gtk::TreeView> rdr_tree;
            Glib::RefPtr<BookStore> bk_model;
            std::unique_ptr<Gtk::TreeView> bk_tree;
            std::unique_ptr<RTree> rtree;
        };

        std::list<std::pair<eris::eris_time_t, temporal_data>> temporal_cache_;
        unsigned int temporal_cache_size_ = 10;

};

template <typename... Args>
void GUI::queueEvent(Args&&... args) {
    std::unique_lock<std::mutex> lock(mutex_);
    event_queue_.push_back(Event(std::forward<Args>(args)...));
    lock.unlock();
    cv_.notify_all();
}

} }