BookStore.hpp

#pragma once
#include "creativity/gui/MemberStore.hpp"
#include "creativity/state/BookState.hpp"
#include <eris/types.hpp>
#include <glibmm/object.h>
#include <glibmm/refptr.h>
#include <gtkmm/enums.h>
#include <gtkmm/treemodel.h>
#include <gtkmm/treemodelcolumn.h>
#include <gtkmm/treepath.h>
#include <memory>
#include <string>

namespace Glib { class ValueBase; }
namespace Gtk { class TreeView; }
namespace creativity { namespace state { class State; } }


namespace creativity { namespace gui {

class BookStore : public MemberStore<state::BookState>, public virtual Glib::Object {
    public:
        BookStore() = delete;

        static Glib::RefPtr<BookStore> create(std::shared_ptr<const state::State> state, eris::eris_id_t author = 0);

        class ColRec : public Gtk::TreeModel::ColumnRecord {
            public:
                Gtk::TreeModelColumn<eris::eris_id_t>
                    id, 
                    author; 

                Gtk::TreeModelColumn<double>
                    pos_x, 
                    pos_y, 
                    quality, 
                    price, 
                    revenue, 
                    revenue_lifetime; 

                Gtk::TreeModelColumn<std::string>
                    pos_str, 
                    market_str; 

                Gtk::TreeModelColumn<bool>
                    market_private, 
                    market_public, 
                    market_any; 

                Gtk::TreeModelColumn<unsigned int>
                    age, 
                    created, 
                    sales, 
                    sales_lifetime_private, 
                    sales_lifetime_public, 
                    sales_lifetime, 
                    pirated, 
                    pirated_lifetime, 
                    copies, 
                    copies_lifetime, 
                    lifetime_private; 

            protected:
                ColRec() {
                    add(id); add(author);
                    add(pos_x); add(pos_y); add(quality); add(price); add(revenue); add(revenue_lifetime);
                    add(pos_str);
                    add(market_private); add(market_public); add(market_any); add(market_str);
                    add(age); add(created); add(sales); add(sales_lifetime_private); add(sales_lifetime_public);
                    add(sales_lifetime); add(pirated); add(pirated_lifetime);
                    add(copies); add(copies_lifetime); add(lifetime_private);
                }
                friend class BookStore;
        };

        std::unique_ptr<ColRec> columns{new ColRec};

        virtual void appendColumnsTo(Gtk::TreeView &v) const override;

    protected:
        BookStore(std::shared_ptr<const state::State> &&state, eris::eris_id_t author);

        BookStore(std::shared_ptr<const state::State> &&state, eris::eris_id_t author, std::unique_ptr<ColRec> &&cols);

        BookStore(std::shared_ptr<const state::State> &&state, std::unique_ptr<ColRec> &&cols);

        void initializeBooks();

        virtual int get_n_columns_vfunc() const override;

        virtual GType get_column_type_vfunc(int index) const override;

        virtual void get_value_vfunc(const iterator &iter, int column, Glib::ValueBase &value) const override;

        // TreeSortable overrides:

        virtual void set_sort_column_id_vfunc(int sort_column_id, Gtk::SortType order) override;


    private:
        // Filter by author, if non-zero; otherwise, this is a global book list (or a subclass
        // handles the list)
        const eris::eris_id_t author_ = 0;

        // The various comparison functions; one of these gets passed to std::stable_sort.
#define LESS_GREATER_METHODS(col) \
        static bool less_##col(const state::BookState &a, const state::BookState &b); \
        static bool greater_##col(const state::BookState &a, const state::BookState &b);
        LESS_GREATER_METHODS(id)
        LESS_GREATER_METHODS(author)
        LESS_GREATER_METHODS(pos_x)
        LESS_GREATER_METHODS(pos_y)
        LESS_GREATER_METHODS(quality)
        LESS_GREATER_METHODS(price)
        LESS_GREATER_METHODS(revenue)
        LESS_GREATER_METHODS(revenue_lifetime)
        LESS_GREATER_METHODS(pos_str)
        LESS_GREATER_METHODS(market_str)
        LESS_GREATER_METHODS(market_private)
        LESS_GREATER_METHODS(market_public)
        LESS_GREATER_METHODS(market_any)
        LESS_GREATER_METHODS(age)
        LESS_GREATER_METHODS(created)
        LESS_GREATER_METHODS(sales)
        LESS_GREATER_METHODS(sales_lifetime_private)
        LESS_GREATER_METHODS(sales_lifetime_public)
        LESS_GREATER_METHODS(sales_lifetime)
        LESS_GREATER_METHODS(pirated)
        LESS_GREATER_METHODS(pirated_lifetime)
        LESS_GREATER_METHODS(copies)
        LESS_GREATER_METHODS(copies_lifetime)
        LESS_GREATER_METHODS(lifetime_private)
#undef LESS_GREATER_METHODS
};

}}