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;
        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);
        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>