gui_group.h

#pragma once
 
#include <cgv/base/group.h>
#include <cgv/type/cond/is_enum.h>
#include <cgv/type/info/type_name.h>
#include <cgv/base/register.h>
#include "button.h"
#include "view.h"
#include "control.h"
 
#include "lib_begin.h"
 
template <typename T, bool is_enum = cgv::type::cond::is_enum<T>::value>
struct enum_aware_type_name : public cgv::type::info::type_name<T>
{
};
 
template <typename T>
struct enum_aware_type_name<T,true> 
{
    static const char* get_name() { return "enum"; }
};
 
namespace cgv {
    namespace gui {
 
class CGV_API gui_group;
class CGV_API provider;

typedef data::ref_ptr<gui_group,true> gui_group_ptr;

typedef data::ref_ptr<const gui_group,true> const_gui_group_ptr;

class CGV_API gui_group : public cgv::base::group, public cgv::base::registration_listener
{
protected:
    friend class provider;
    std::vector<cgv::base::base_ptr> managed_objects;
    static void set_provider_parent(provider* p, gui_group_ptr g);
    static gui_group_ptr get_provider_parent(const provider* p);
public:
    void register_object(cgv::base::base_ptr object, const std::string& options);
    void unregister_object(cgv::base::base_ptr object, const std::string& options);
    gui_group(const std::string& name = "");
    std::string get_type_name() const;
    

    void add_managed_objects(cgv::base::base_ptr object);
    void release_all_managed_objects();
    void release_managed_objects(cgv::base::base_ptr object);
    bool is_managed_object(cgv::base::base_ptr object);
    //@/

    virtual bool multiple_selection() const;

    virtual void select_child(unsigned ci, bool exclusive = false);
    virtual void select_child(cgv::base::base_ptr ci, bool exclusive = false);

    virtual bool unselect_child(unsigned ci);
    virtual bool unselect_child(cgv::base::base_ptr ci);

    virtual int get_selected_child_index() const;

    virtual cgv::base::base_ptr get_selected_child() const;
    virtual bool is_selected(cgv::base::base_ptr c) const;

    bool is_selected(unsigned ci) const;

    cgv::signal::signal<cgv::base::base_ptr, bool> on_selection_change;


    virtual bool can_open_and_close() const;
    virtual bool is_open_child_group(gui_group_ptr g) const;
    bool is_open_child_group(unsigned ci) const;
    virtual bool open_child_group(gui_group_ptr g);
    virtual bool close_child_group(gui_group_ptr g);

    cgv::signal::signal<gui_group_ptr,bool> on_open_state_change;


    virtual void align(const std::string& _align);
    virtual gui_group_ptr add_group(const std::string& label, const std::string& group_type, const std::string& options, const std::string& align);
    virtual cgv::base::base_ptr add_decorator(const std::string& label, const std::string& decorator_type, const std::string& options, const std::string& align);
    virtual button_ptr add_button(const std::string& label, const std::string& options, const std::string& align);
    virtual 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);
    virtual 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);
    template <typename T>
    inline 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") {
        view_ptr vp = add_view_void(label, &value, 
                        enum_aware_type_name<T>::get_name(), 
                        gui_type, options, align);
        return vp.down_cast<view<T> >();
    }

    template <typename T>
    inline 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") {
        control_ptr cp = add_control_void(label, &value, 0,
                    enum_aware_type_name<T>::get_name(), 
                    gui_type, options, align, 0);
        return cp.down_cast<control<T> >(); 
    } 

    template <typename T>
    inline 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) {
        control_ptr cp = add_control_void(label, 0, provider, 
                    enum_aware_type_name<T>::get_name(), 
                    gui_type, options, align, user_data);
        return cp.down_cast<control<T> >();
    }



    cgv::base::base_ptr find_element(const std::string& name);
    view_ptr find_view_void(const void* value_ptr, int* idx_ptr);
    control_ptr find_control_void(void* value_ptr, int* idx_ptr);

    template <typename T>
    inline data::ref_ptr<view<T> > find_view(const T& value, int* idx_ptr=0) {
        view_ptr vp = find_view_void(&value,idx_ptr);
        return vp.down_cast<view<T> >();
    }


    template <typename T>
    inline data::ref_ptr<control<T> > find_control(T& value, int* idx_ptr=0) {
        control_ptr cp = find_control_void(&value,idx_ptr);
        return cp.down_cast<control<T> >();
    }

};
 
 
#if _MSC_VER >= 1400
CGV_TEMPLATE template class CGV_API data::ref_ptr<gui_group>;
CGV_TEMPLATE template class CGV_API data::ref_ptr<const gui_group>;
#endif
 
 
    }
}
 
#include <cgv/config/lib_end.h>