TypedTransform.h

Go to the documentation of this file.

/******************************************************************************
 *
 *  Copyright (C) 2008 Boris Iven, Max Hermann
 *
 *  This file is part of the "CEDRIC Event Display" application.
 *
 *****************************************************************************/

#ifndef TYPEDTRANSFORM_H
#define TYPEDTRANSFORM_H

#define TYPEDTRANSFORM_ADDCHILD_MACRO( OSGADDFUNC )                 \
        T* node = dynamic_cast<T*>( child );                            \
        if( node && !childrenAllowed()                                  \
                         && !(node->getClassName().compare(getClassName())==0) )\
                return false;                                               \
    if( !OSGADDFUNC ) return false;                                 \
        if( node ) updateType( node->getType() );                       \
        return true;

#include <osg/MatrixTransform>
#include <osg/Node>

#include <string>

class TypedTransform : public osg::MatrixTransform
{
public:
        typedef TypedTransform T;

        enum ReservedTypes { UNSPECIFIED=-1, GROUP=1 };
        
        TypedTransform( std::string className ): m_className(className) {}

        virtual bool childrenAllowed() { return true; }
        
        const std::string& getClassName() const { return m_className; }
        int getType() const { return m_type; }


        virtual bool addChild( osg::Node* child )                        { TYPEDTRANSFORM_ADDCHILD_MACRO( MatrixTransform::addChild(child) ) }
        virtual bool insertChild( unsigned int index, osg::Node *child ) { TYPEDTRANSFORM_ADDCHILD_MACRO( MatrixTransform::insertChild(index,child) ) }
        virtual bool setChild( unsigned int index, osg::Node *child )    { TYPEDTRANSFORM_ADDCHILD_MACRO( MatrixTransform::setChild(index,child) ) }
        
        virtual bool replaceChild( osg::Node *origChild, osg::Node *child )
        {
                if( !MatrixTransform::replaceChild( origChild, child ) )
                        return false;
                
                updateType();           
                return true;
        }
        
        virtual bool removeChildren( unsigned int pos, unsigned int numChildrenToRemove )
        {
                if( !( (pos+numChildrenToRemove-1) < _children.size() && numChildrenToRemove > 0 ) )
                        return false;
        
                bool atLeastOneTNodeRemoved = false;
                for( unsigned int i=pos; i < pos+numChildrenToRemove; ++i )
                {
                        T* child = dynamic_cast<T*>( getChild( i ) );
                        if( child )
                        {
                                atLeastOneTNodeRemoved = true;
                                break; // leave for-loop
                        }
                }
                
                if( !MatrixTransform::removeChildren( pos, numChildrenToRemove ) )
                        return false;
                
                if( atLeastOneTNodeRemoved ) updateType();              
                return true;
        }
        
protected:
        void updateType( int type=UNSPECIFIED )
        {
                // if type is not specified acquire it from children
                if( type == UNSPECIFIED )
                {
                        int acquired_type = ((getNumChildren()>0) ? GROUP : UNSPECIFIED);
                        for( unsigned int i=0; i < getNumChildren(); ++i )
                        {
                                T* child = dynamic_cast<T*>( getChild(i) );
                                if( child )
                                        acquired_type |= child->getType();
                        }                       
                        m_type = acquired_type;
                }
                else
                        // add to own type
                        m_type |= type;
                
                // tell all parents
                for( unsigned int i=0; i < getNumParents(); ++i )
                {
                        T* parent = dynamic_cast<T*>( getParent(i) );
                        if( parent )
                                parent->updateType( m_type );
                }
        }
        
        int m_type;
        std::string m_className;
};

#endif