provider.h

#pragma once
 
#include <cgv/base/base.h>
#include <cgv/type/info/type_name.h>
#include <cgv/signal/rebind.h>
#include <cgv/utils/convert.h>
#include "gui_group.h"
#include "shortcut.h"
#include "gui_creator.h"
 
#include "lib_begin.h"
 
namespace cgv {
    namespace gui {
 
 
template <typename T>
struct with_index_struct
{
    const T&  value;
    int index;
    with_index_struct(const T& _value, int _index) : value(_value), index(_index) {}
};
 
template <typename T>
with_index_struct<T> with_index(const T& _value, int _index)
{
    return with_index_struct<T>(_value, _index);
}
 
 
template <typename T> 
struct with_index_traits
{
    typedef const T* pointer_type;
    static pointer_type get_value_ptr(const T& value) { return &value; }
    static int get_index(const T& value) { return -1; }
};
 
template <typename T> 
struct with_index_traits<with_index_struct<T> >
{
    typedef const T* pointer_type;
    static pointer_type get_value_ptr(const with_index_struct<T>& value) { return &value.value; }
    static int get_index(const with_index_struct<T>& value) { return value.index; }
};
 
template <typename T> 
typename with_index_traits<T>::pointer_type wi_get_value_ptr(const T& value)
{
    return with_index_traits<T>::get_value_ptr(value);
}
 
template <typename T>
int wi_get_index(const T& value)
{
    return with_index_traits<T>::get_index(value);
}
 
class CGV_API provider : virtual public cgv::signal::tacker
{
protected:
    gui_group_ptr parent_group;
    provider* parent_provider;
    void set_parent(gui_group_ptr);
    void update_parent();
    friend class gui_group;
public:
    gui_group_ptr get_parent_group() const { return parent_group; }
    view_ptr add_view_void(const std::string& label, const void* value_ptr, const std::string& value_type, const std::string& gui_type, const std::string& options, const std::string& align);
    control_ptr add_control_void(const std::string& label, void* value_ptr, abst_control_provider* acp, const std::string& value_type, const std::string& gui_type, const std::string& options, const std::string& align, void* user_data);
    void align(const std::string& _align);
    // gui_group_ptr add_group(const std::string& label, const std::string& group_type, const std::string& options, const std::string& align);
 
    std::string concat_enum_def(const std::vector<std::string>& names, const std::string& additional_first_name = "", const std::string& additional_last_name = "");
 
    gui_group_ptr add_object_gui(cgv::base::base_ptr object, const std::string& label, const std::string& group_type, const std::string& options, const std::string& align);
    void integrate_object_gui(cgv::base::base_ptr object);
    void inline_object_gui(cgv::base::base_ptr object);
    gui_group_ptr add_group(const std::string& label, const std::string& group_type, const std::string& options = "", const std::string& align = "\n");
    cgv::base::base_ptr add_decorator(const std::string& label, const std::string& decorator_type, const std::string& options = "", const std::string& align = "\n");
    button_ptr add_button(const std::string& label, const std::string& options = "", const std::string& align = "\n");
    template <typename T>
    data::ref_ptr<view<T> > add_view(const std::string& label, const T& value, const std::string& gui_type = "", const std::string& options = "", const std::string& align = "\n") {
        if (parent_group.empty())
            return data::ref_ptr<view<T> >();
        return parent_group->add_view(label, value, gui_type, options, align);
    }
    template <typename T>
    data::ref_ptr<control<T> > add_control(const std::string& label, T& value, const std::string& gui_type = "", const std::string& options = "", const std::string& align = "\n") {
        if (parent_group.empty())
            return data::ref_ptr<control<T> >();
        return parent_group->add_control(label, value, gui_type, options,align); 
    }
    template <typename T>
    data::ref_ptr<control<T> > add_control(const std::string& label, 
        control_provider<T>* provider, const std::string& gui_type = "", 
        const std::string& options = "", const std::string& align = "\n", void* user_data = 0) {
        if (parent_group.empty())
            return data::ref_ptr<control<T> >();
        return parent_group->add_control(label, provider, gui_type, options,align,user_data); 
    }
 
    template <typename T>
    data::ref_ptr<control<T> > add_member_control(cgv::base::base* base_ptr, const std::string& label, T& value, const std::string& gui_type = "", const std::string& options = "", const std::string& align = "\n") {
        data::ref_ptr<control<T> > cp = add_control(label, value, gui_type, options, align);
        if (cp)
            connect_copy(cp->value_change,
                cgv::signal::rebind(base_ptr, &cgv::base::base::on_set, &value));
        return cp;
    }
 
    bool add_tree_node(const std::string& label, bool& toggle, int level, const std::string& a= "\n", gui_group_ptr ggp = gui_group_ptr());
 
    template <typename T>
    bool begin_tree_node(const std::string& label, const T& value, bool initial_visibility = false, const std::string& options = "", gui_group_ptr ggp = gui_group_ptr()) { return begin_tree_node_void(label, wi_get_value_ptr(value), wi_get_index(value), initial_visibility, options, ggp); }
 
    template <typename T>
    static bool& ref_tree_node_visible_flag(const T& value) { return ref_tree_node_visible_flag_void(wi_get_value_ptr(value), wi_get_index(value)); }
 
    template <typename T>
    void end_tree_node(const T& value) { end_tree_node_void(wi_get_value_ptr(value), wi_get_index(value)); }
    template <typename T>
    bool is_tree_node_visible(const T& value) const { return is_tree_node_visible_void(wi_get_value_ptr(value), wi_get_index(value)); }
    template <typename T>
    void set_tree_node_visibility(const T& value, bool is_visible) { set_tree_node_visibility_void(wi_get_value_ptr(value), wi_get_index(value), is_visible); }
    bool begin_tree_node_void(const std::string& label, const void* value_ptr, int index = -1, bool initial_visibility = false, const std::string& options = "", gui_group_ptr ggp = gui_group_ptr());
    static bool& ref_tree_node_visible_flag_void(const void* value_ptr, int index = -1);
    void end_tree_node_void(const void* value_ptr, int index = -1);
    bool is_tree_node_visible_void(const void* value_ptr, int index) const;
    void set_tree_node_visibility_void(const void* value_ptr, int index, bool is_visible);
 
 
    template <typename T>
    bool add_gui(const std::string& label, T& value, const std::string& gui_type = "", const std::string& options = "") 
    {
        return cgv::gui::create_gui(this, label, &value, cgv::type::info::type_name<T>::get_name(), gui_type, options, 0);
    }
protected:
    virtual void on_select();
    virtual void on_deselect();
    virtual void selection_change_cb(cgv::base::base_ptr new_child, bool selected);
public:
    provider();
    ~provider();
 
    virtual std::string get_gui_name() const;
 
    virtual std::string get_parent_type() const;
    virtual bool ensure_selected_in_tab_group_parent();
    virtual void update_member(void* member_ptr);
    virtual void update_all_members();
    virtual std::string get_menu_path() const;
    virtual shortcut get_shortcut() const;
    virtual void create_gui() = 0;
 
    virtual void recreate_gui();
 
    virtual void post_recreate_gui();
 
    void remove_element(cgv::base::base_ptr);
    void remove_all_elements();
    cgv::base::base_ptr find_element(const std::string& name);
 
    template <typename T>
    data::ref_ptr<view<T> > find_view(const T& value, int* idx_ptr=0) { 
        if (parent_group.empty())
            return data::ref_ptr<view<T> >();
        return parent_group->find_view(value,idx_ptr); 
    }
 
    template <typename T>
    data::ref_ptr<control<T> > find_control(T& value, int* idx_ptr=0) { 
        if (parent_group.empty())
            return data::ref_ptr<control<T> >();
        return parent_group->find_control(value,idx_ptr); 
    }
    control_ptr find_control_void(void* value_ptr, int* idx_ptr);
    view_ptr find_view_void(void* value_ptr, int* idx_ptr);
 
    template <typename T>
    void set_control_property(T& value, const std::string& property_name, const std::string& property_value) {
        int idx = 0;
        data::ref_ptr<control<T> > control_ptr = find_control(value, &idx);
        while(control_ptr) {
            ++idx;
            control_ptr->set(property_name, property_value);
            control_ptr = find_control(value, &idx);
        }
    }
};
 
 
 
    }
}
 
#include <cgv/config/lib_end.h>