traverser.h

#pragma once
 
#include "group.h"
#include "action.h"
#include <string>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace base {
 
enum TraversePolicy { 
    TP_ALL,                 
    TP_ONLY_FOCUS,          
    TP_FIRST_FOCUS,         
    TP_AUTO_FOCUS,          
    TP_STOP_ON_SUCCESS = 8, 
    TP_STOP_ON_FAILURE = 16 
};
 
class CGV_API traverse_policy
{
protected:
    TraversePolicy policy;
    bool active;
    int focus;
public:
    traverse_policy(int _policy = TP_ALL+TP_STOP_ON_SUCCESS, bool _active = true, int _focus = -1);
    int get_policy() const;
    bool stop_on_success() const;
    bool stop_on_failure() const;
    void set_policy(int _policy);
    int get_focused_child() const;
    void set_focused_child(int _focused_child);
    bool get_active() const;
    void set_active(bool _active);
};
 
template <class X>
bool grab_focus(X* instance) {
    node* n = dynamic_cast<node*>(instance);
    if (!n)
        return true;
    base_ptr p = n->get_parent();
    if (p.empty())
        return true;
    group_ptr g = p->get_group();
    if (g.empty())
        return true;
    X* pinstance = p->get_interface<X>();
    if (!pinstance)
        return true;
    for (unsigned int i=0; i<g->get_nr_children(); ++i) {
        if (g->get_child(i)->get_interface<X>() == instance) {
            pinstance->set_focused_child(i);
            return grab_focus(pinstance);
        }
    }
    // at this point we did not find the instance in the children of its parent
    return false;
}
 
class CGV_API traverse_callback_handler
{
public:
    virtual bool on_enter_node(base_ptr b);
    virtual bool on_leave_node(base_ptr b);
    virtual bool on_enter_children(group_ptr g);
    virtual bool on_leave_children(group_ptr g);
    virtual bool on_enter_parent(node_ptr n);
    virtual bool on_leave_parent(node_ptr n);
};
 
enum TraverseStrategy
{
    TS_DEPTH_FIRST,
    TS_BREADTH_FIRST
};
 
class CGV_API traverser
{
protected:
    action& a;
    TraverseStrategy strategy;
    std::string visit_order;
    bool stop_if_not_implemented;
    bool ignore_activation_state;
    template <typename TCH>
    bool traverse_tmp_1(base_ptr dest, base_ptr src, bool& force_termination, TCH& tch);
    template <typename TCH>
    bool traverse_tmp_2(base_ptr p, base_ptr dest, base_ptr src, traverse_policy* tp, bool& force_termination, TCH& tch);
public:
    traverser(action& _a, 
              const std::string& _visit_order = "pnc", 
              TraverseStrategy _strategy = TS_DEPTH_FIRST, 
              bool _stop_if_not_implemented = false, bool _ignore_activation_state = false);
    traverser& set_visit_order(const std::string& _visit_order);
    traverser& set_strategy(TraverseStrategy _strategy);
    bool traverse(base_ptr start, traverse_callback_handler* tch = 0);
};
 
    }
}
 
#include <cgv/config/lib_end.h>