control.h

#pragma once
 
#include "view.h"
 
#include <cgv/signal/signal.h>
 
#include "lib_begin.h"
 
namespace cgv {
        namespace gui {
 
class CGV_API abst_control : public abst_view
{
public:
        abst_control(const std::string& name);
        bool shows(const void* ptr) const;
        virtual bool controls(const void* ptr) const = 0;
        virtual void attach_to_value_change(cgv::signal::functor_base* func) = 0;
        virtual void attach_to_check_value(cgv::signal::functor_base* bool_func) = 0;
};
 
typedef data::ref_ptr<abst_control> control_ptr;
 
#if _MSC_VER >= 1400
CGV_TEMPLATE template class CGV_API data::ref_ptr<abst_control>;
#endif
 
struct abst_control_provider
{
 
        virtual bool controls(const void* ptr, void* user_data) const = 0;
};
 
template <typename T>
struct control_provider : public abst_control_provider
{
        virtual void set_value(const T& value, void* user_data) = 0;
        virtual const T get_value(void* user_data) const = 0;
        virtual bool controls(const void* ptr, void* user_data) const { return false; }
};
 
template <typename T>
class control : public abst_control
{
private:
        T* value_ptr;
        control_provider<T>* cp;
        T  new_value;
protected:
        // protected function for the setter
        void set_value(const T& v) { 
                if (cp)
                        cp->set_value(v, value_ptr); 
                else {
                        *value_ptr = v;
                        update_views();
                }
        }
        // return pointer to value or 0 if not available
        const T* get_value_ptr() const { return cp ? 0 : value_ptr; }
public:
        typedef cgv::signal::bool_signal<control<T>&> value_check_signal_type;
        typedef cgv::signal::signal<control<T>&> value_change_signal_type;
        control(const std::string& _name, T& _value) : abst_control(_name), value_ptr(&_value), new_value(_value), cp(0) {
                attach_to_reference(value_ptr);
        }
        control(const std::string& _name, T* _value) : abst_control(_name) {
                value_ptr = _value;
                new_value = *_value;
                cp = 0;
                attach_to_reference(value_ptr);
        }
        control(const std::string& _name, abst_control_provider* _cp, void* user_data) : abst_control(_name), cp(0) {
                if (_cp) {
                        cp = static_cast<control_provider<T>*>(_cp);
                        (void*&)value_ptr = user_data;
                        new_value = cp->get_value(user_data);
                }
                else {
                        value_ptr = (T*)user_data;
                        new_value = *value_ptr;
                        attach_to_reference(value_ptr);
                }
        }
 
        cgv::signal::bool_signal<control<T>&> check_value;
 
        cgv::signal::signal<control<T>&> value_change;
        const T get_value() const { return cp ? cp->get_value(value_ptr) : *value_ptr; }
        const T& get_new_value() const { return new_value; }
        void set_new_value(const T& nv) { new_value = nv; }
        const T& get_old_value() const { return new_value; }
        bool check_and_set_value(const T& nv) {
                set_new_value(nv);
                if (check_value(*this)) {
                        T tmp_value = get_value();
                        set_value(this->get_new_value());
                        set_new_value(tmp_value);
                        value_change(*this);
                        return true;
                }
                return false;
        }
        bool controls(const void* ptr) const { return cp ? cp->controls(ptr,value_ptr) : (value_ptr == ptr); }
        void attach_to_value_change(cgv::signal::functor_base* func) {
                value_change.connect_abst(func);
        }
        void attach_to_check_value(cgv::signal::functor_base* bool_func) {
                check_value.connect_abst(bool_func);
        }
};
 
        }
}
 
#include <cgv/config/lib_end.h>