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"
 
using cgv::base::base_ptr;
 
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(base_ptr ci, bool exclusive = false);
 
        virtual bool unselect_child(unsigned ci);
        virtual bool unselect_child(base_ptr ci);
 
        virtual int get_selected_child_index() const;
 
        virtual base_ptr get_selected_child() const;
        virtual bool is_selected(base_ptr c) const;
 
        bool is_selected(unsigned ci) const;
 
        cgv::signal::signal<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 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.up_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.up_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.up_cast<control<T> >(); 
        }
 
        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.up_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.up_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>