control.cxx

#include "view.h"
#include "control.h"
#include <map>
namespace cgv {
    namespace gui {
 
abst_view::abst_view(const std::string& name) : cgv::base::node(name)
{
    next_in_list = 0;
    prev_in_list = 0;
    ptr = 0;
}
 
bool abst_control::access_on_release(const void* value_ptr, char access_mode)
{
    static std::map<const void*, bool> on_release_map;
    auto iter = on_release_map.find(value_ptr);
    if (access_mode == 'q')
        return iter == on_release_map.end() ? false : iter->second;
    if (access_mode == 's') {
        if (iter == on_release_map.end())
            on_release_map[value_ptr] = true;
        else
            iter->second = true;
        return true;
    }
    if (iter != on_release_map.end())
        iter->second = false;
    return false;
}
 
bool abst_control::on_release(const void* value_ptr)
{
    return access_on_release(value_ptr, 'q');
}
 
abst_control::abst_control(const std::string& name) : abst_view(name)
{
}
 
std::map<const void*, abst_view*>& ref_view_map()
{
    static std::map<const void*, abst_view*> view_map;
    return view_map;
}
 
bool abst_control::shows(const void* ptr) const
{
    return controls(ptr);
}
 
abst_view::~abst_view()
{
    if (ptr)
        detach_from_reference();
}
 
void abst_view::attach_to_reference(const void* ptr)
{
    if (this->ptr)
        detach_from_reference();
    std::map<const void*, abst_view*>& vm = ref_view_map();
    if (vm.find(ptr) == vm.end()) {
        vm[ptr] = this;
    }
    else {
        abst_view* v = vm[ptr];
        next_in_list = v->next_in_list;
        prev_in_list = v;
        v->next_in_list = this;
        if (next_in_list)
            next_in_list->prev_in_list = this;
    }
    this->ptr = ptr;
}
 
void abst_view::detach_from_reference()
{
    std::map<const void*, abst_view*>& vm = ref_view_map();
    if (vm.find(ptr) == vm.end())
        return;
    if (vm[ptr] == this) {
        if (next_in_list == 0)
            vm.erase(ptr);
        else {
            vm[ptr] = next_in_list;
            next_in_list->prev_in_list = 0;
        }
    }
    else {
        if (prev_in_list == 0) {
            if (next_in_list == 0)
                return;
            std::cerr << "ups, abst_view::detach_from_reference called for view that is not representative and has no previous element in list" << std::endl;
            next_in_list = 0;
            return;
        }
        prev_in_list->next_in_list = next_in_list;
        if (next_in_list)
            next_in_list->prev_in_list = prev_in_list;
    }
 
    next_in_list = prev_in_list = 0;
    return;
}
 
void update_views(void* member_ptr)
{
    std::map<const void*, abst_view*>& vm = ref_view_map();
    if (vm.find(member_ptr) != vm.end()) {
        abst_view* v = vm[member_ptr];
        v->update();
        v->update_views();
    }
}
 
 
void abst_view::update_views()
{
    abst_view* v = next_in_list;
    while (v != 0) {
        v->update();
        v = v->next_in_list;
    }
    v = prev_in_list;
    while (v != 0) {
        v->update();
        v = v->prev_in_list;
    }
}
 
    }
}