C:/development/RenderTools/src/property/PropertyProxy.h

Go to the documentation of this file.

#ifndef RENDERGROUPPROXY_H
#define RENDERGROUPPROXY_H

#include "Types.h"
#include "PointerProperty.h"
#include "Rendergroup.h"
#include "BindingInterface.h"

namespace RenderTools {

template < class T >
class PropertyProxy : public BindingInterface, public PointerProperty< T > {
public:

        PropertyProxy( void ):
                PointerProperty< T >( shared_ptr< T >() ){
        }

        virtual const string getTypeName( bool ofComponent = false ) const {
                T t;
                if( ofComponent ){
                        return( RenderTools::getTypeName( t ) );
                }
                return( RenderTools::getTypeName( t ) + "Proxy" );
        }

        virtual void onInitialize( void ){
                if( ! m_pointer ){
                        PropertyPtr p = find( this->getValue() );
                        if( p ){
                                m_pointer = dynamic_pointer_cast< T >( p );
                        }
                }
        }

        virtual void onBind( int unit = -1 ){
                onInitialize();
        }

        virtual void onUnbind( int unit = -1 ){
                m_pointer.reset();
        }

        virtual const string getValue( int vectorElement = -1 ) const {
                return( m_proxyName );
        }

        virtual bool setValue( const string value, int vectorElement = -1 ){
                string prevName = m_name;
                m_proxyName = value;
                return( m_proxyName != prevName );
        }

        virtual void setPointer( const shared_ptr< T > p ){
                if( p ){
                        m_proxyName = p->getPath();
                        m_pointer = dynamic_pointer_cast< T >( p );
                        sendPropertyEvent( PropertyEvent( PropertyEvent::CHANGED, getSharedPtr< AbstractProperty >() ) );
                }
        }

protected:
        string m_proxyName;
};

template< class T >
inline ostream & operator << ( ostream & os, const shared_ptr< PropertyProxy< T > > rhs ){
        return( os );
}

template< class T >
inline const istream & operator >> ( const istream & is, shared_ptr< PropertyProxy< T > > rhs ){
        return( is );
}

}; // namespace RenderTools

#endif

---