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
{
protected:
    static bool access_on_release(const void* value_ptr, char access_mode);
public:
    static bool on_release(const void* value_ptr);
    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>