MemberStore.hpp

#pragma once
#include <memory>
#include <algorithm>
#include <gtkmm/treemodel.h>
#include <gtkmm/treesortable.h>
#include <gtkmm/treeview.h>
#include <gtkmm/treepath.h>
#include "creativity/state/State.hpp"

namespace creativity { namespace gui {

template <class M>
class MemberStore : public virtual Gtk::TreeModel, public virtual Gtk::TreeSortable {
    public:
        MemberStore() = delete;

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

        const M& member(const Path &path) const;

        const M& member(const iterator &iter) const;

        Path find(eris::eris_id_t id, size_t hint = 0) const;

        Path find(eris::eris_id_t id, const iterator &iter) const;

        Path find(eris::eris_id_t id, const Path &hint) const;

    protected:
        MemberStore(std::shared_ptr<const state::State> &&state);

        virtual Gtk::TreeModelFlags get_flags_vfunc() const override;

        virtual int get_n_columns_vfunc() const override = 0;

        virtual GType get_column_type_vfunc(int index) const override = 0;

        virtual bool get_iter_vfunc(const Path &path, iterator& iter) const override;

        virtual bool iter_next_vfunc(const iterator &iter, iterator &iter_next) const override;
        virtual bool iter_children_vfunc(const iterator&, iterator&) const override;
        virtual bool iter_parent_vfunc(const iterator&, iterator&) const override;
        virtual bool iter_nth_child_vfunc(const iterator&, int, iterator&) const override;
        virtual bool iter_has_child_vfunc(const iterator &) const override;
        virtual int iter_n_children_vfunc(const iterator &) const override;
        virtual bool iter_nth_root_child_vfunc(int n, iterator &iter) const override;
        virtual int iter_n_root_children_vfunc() const override;
        virtual Path get_path_vfunc(const iterator &iter) const override;

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

        template <typename T>
        static void copy_value_(Glib::ValueBase &valueobj, const T &val);

        virtual bool get_sort_column_id_vfunc(int *sort_column_id, Gtk::SortType *order) const override;

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

        virtual void sort_members(
                std::function<bool(const M &a, const M &b)> &compare,
                int sort_column_id,
                Gtk::SortType order);

        template <typename T, typename = typename std::enable_if<std::is_base_of<Gtk::TreeModelColumnBase, T>::value>>
        void appendCol(Gtk::TreeView &v, const std::string &label, T &col, int width, bool sortable = true) const {
            v.append_column(label, col);
            auto *c = v.get_column(v.get_n_columns()-1);
            c->set_sizing(Gtk::TREE_VIEW_COLUMN_FIXED);
            c->set_fixed_width(width);
            if (sortable)
                c->set_sort_column(col);
        }

        const std::shared_ptr<const state::State> state_;
        std::vector<std::reference_wrapper<const M>> members_;
        int stamp_ = 1;

    private:
        int sort_by_ = Gtk::TreeSortable::DEFAULT_UNSORTED_COLUMN_ID;
        Gtk::SortType sort_order_ = Gtk::SORT_ASCENDING;
};

template <class M> MemberStore<M>::MemberStore(std::shared_ptr<const state::State> &&state) : state_{std::move(state)} {}

template <class M> Gtk::TreeModelFlags MemberStore<M>::get_flags_vfunc() const {
    return Gtk::TREE_MODEL_LIST_ONLY;
}

template <class M> const M& MemberStore<M>::member(const Path &path) const {
    return members_.at(path.back());
}

template <class M> const M& MemberStore<M>::member(const iterator &iter) const {
    return members_.at((size_t) iter.gobj()->user_data);
}

template <class M> Gtk::TreeModel::Path MemberStore<M>::find(eris::eris_id_t id, size_t hint) const {
    Gtk::TreeModel::Path p;
    const long max = members_.size();
    // Loop through members_ starting at hint with two counters: one starting at hint and going down
    // to 0, the other starting at hint+1 and going up to max.  This makes us search positions
    // closer to hint first.
    long a = std::min<long>(hint, max-1), b = hint + 1;
    while (b < max or a >= 0) {
        if (a >= 0) {
            if (members_[a].get().id == id) {
                p.push_back(a);
                break;
            }
            a--;
        }
        if (b < max) {
            if (members_[b].get().id == id) {
                p.push_back(b);
                break;
            }
            b++;
        }
    }
    return p;
}
template <class M> Gtk::TreeModel::Path MemberStore<M>::find(eris::eris_id_t id, const iterator &hint) const {
    return find(id, (size_t) hint.gobj()->user_data);
}
template <class M> Gtk::TreeModel::Path MemberStore<M>::find(eris::eris_id_t id, const Path &hint) const {
    return find(id, hint.empty() ? 0 : hint.back());
}

template <class M> bool MemberStore<M>::get_iter_vfunc(const Path &path, iterator& iter) const {
    size_t i = path.back();
    if (i >= members_.size()) return false;

    iter.set_stamp(stamp_);
    iter.gobj()->user_data = (void*) i;
    return true;
}

template <class M> bool MemberStore<M>::iter_next_vfunc(const iterator &iter, iterator &iter_next) const {
    if (iter.get_stamp() != stamp_) return false;
    size_t i = 1 + (size_t) iter.gobj()->user_data;
    if (i >= members_.size()) return false;

    iter_next.set_stamp(stamp_);
    iter_next.gobj()->user_data = (void*) i;
    return true;
}

template <class M> bool MemberStore<M>::iter_children_vfunc(const iterator&, iterator&) const {
    return false; // No nesting
}

template <class M> bool MemberStore<M>::iter_parent_vfunc(const iterator&, iterator&) const {
    return false; // No nesting
}

template <class M> bool MemberStore<M>::iter_nth_child_vfunc(const iterator&, int, iterator&) const {
    return false; // No nesting
}

template <class M> bool MemberStore<M>::iter_nth_root_child_vfunc(int n, iterator &iter) const {
    size_t i = n;
    if (i >= members_.size()) return false;

    iter.set_stamp(stamp_);
    iter.gobj()->user_data = (void*) i;
    return true;
}

template <class M> bool MemberStore<M>::iter_has_child_vfunc(const iterator &) const {
    return false; // No nesting
}

template <class M> int MemberStore<M>::iter_n_children_vfunc(const iterator &) const {
    return 0; // No nesting
}

template <class M> int MemberStore<M>::iter_n_root_children_vfunc() const {
    return (int) members_.size();
}

template <class M> Gtk::TreeModel::Path MemberStore<M>::get_path_vfunc(const iterator &iter) const {
    size_t i = (size_t) iter.gobj()->user_data;
    Gtk::TreeModel::Path ret;
    ret.push_back(i);
    return ret;
}

template <class M> bool MemberStore<M>::get_sort_column_id_vfunc(int *sort_column_id, Gtk::SortType *order) const {
    if (sort_column_id) *sort_column_id = sort_by_;
    if (order) *order = sort_order_;
    return not(sort_by_ == DEFAULT_UNSORTED_COLUMN_ID or sort_by_ == DEFAULT_SORT_COLUMN_ID);
}

template <class M> void MemberStore<M>::sort_members(
                std::function<bool(const M &a, const M &b)> &compare,
                int sort_column_id,
                Gtk::SortType order) {
    if (not compare) return;

    // The rows_reordered signal needs a vector where v[new_pos] == old_pos,
    // so store all the old positions before we sort.
    std::unordered_map<eris::eris_id_t, int> old_pos;
    int i = 0;
    for (const M &m : members_)
        old_pos[m.id] = i++;

    if (sort_by_ != sort_column_id or sort_order_ != order) {
        sort_by_ = sort_column_id;
        sort_order_ = order;
        sort_column_changed();
    }

    std::stable_sort(members_.begin(), members_.end(), compare);

    // The sort invalidates our tree iterators, so increment the stamp
    stamp_++;

    std::vector<int> new_order;
    new_order.reserve(members_.size());
    bool actual_reordering = false;
    for (const M &m : members_) {
        if (not actual_reordering and old_pos[m.id] != (int) new_order.size()) actual_reordering = true;
        new_order.push_back(old_pos[m.id]);
    }

    // If sorting actually changed anything, fire the rows-reordered signal
    if (actual_reordering) rows_reordered(Path(), new_order);
}

template <class M> template <class T> void MemberStore<M>::copy_value_(Glib::ValueBase &valueobj, const T &val) {
    Glib::Value<T> v;
    v.init(v.value_type());
    v.set(val);
    valueobj.init(v.gobj());
}

}}