fbproperties.h

Go to the documentation of this file.

#ifndef __FBPROPERTIES_H__
#define __FBPROPERTIES_H__
/**************************************************************************
Copyright (c) 1994 - 2009 Autodesk, Inc. and/or its licensors.
All Rights Reserved.

The coded instructions, statements, computer programs, and/or related 
material (collectively the "Data") in these files contain unpublished 
information proprietary to Autodesk, Inc. and/or its licensors, which is 
protected by Canada and United States of America federal copyright law 
and by international treaties.

The Data may not be disclosed or distributed to third parties, in whole 
or in part, without the prior written consent of Autodesk, Inc. 
("Autodesk").

THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO 
WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR 
ARISING BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES 
OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
PURPOSE OR USE. WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT 
WARRANT THAT THE OPERATION OF THE DATA WILL BE UNINTERRUPTED OR ERROR 
FREE.

IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS 
OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR 
EXPENSES OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE 
DAMAGES OR OTHER SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS 
OF PROFITS, REVENUE OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR 
DAMAGES OF ANY KIND), HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF 
LIABILITY, WHETHER DERIVED FROM CONTRACT, TORT (INCLUDING, BUT NOT 
LIMITED TO, NEGLIGENCE), OR OTHERWISE, ARISING OUT OF OR RELATING TO THE 
DATA OR ITS USE OR ANY OTHER PERFORMANCE, WHETHER OR NOT AUTODESK HAS 
BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS OR DAMAGE.

**************************************************************************/

#include <kaydaradef.h>

#ifndef FBSDK_DLL

#define FBSDK_DLL K_DLLIMPORT
#endif

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

#include <fbsdk/fbplug.h>
#include <fbsdk/fbarray.h>
#include <fbsdk/fbstring.h>
#include <fbsdk/fbtime.h>
#include <fbsdk/fbevaluateinfo.h>

K_FORWARD( KEventBase );
K_FORWARD( KObject );
K_FORWARD( KProperty );
K_FORWARD( KEvaluationProperty );
K_FORWARD( KDataType );
K_FORWARD( IFBObject );
K_FORWARD( IRegister );

#ifdef FBSDKUseNamespace
namespace FBSDKNamespace {
#endif


    enum FBPropertyType
    {
        kFBPT_unknown,  
        kFBPT_int,      
        kFBPT_int64,    
        kFBPT_uint64,   
        kFBPT_bool,     
        kFBPT_float,    
        kFBPT_double,   
        kFBPT_charptr,  
        kFBPT_enum,     
        kFBPT_Time,     
        kFBPT_TimeCode, 
        kFBPT_object,   
        kFBPT_event,    
        kFBPT_stringlist,
        kFBPT_Vector4D, 
        kFBPT_Vector3D, 
        kFBPT_ColorRGB, 
        kFBPT_ColorRGBA,
        kFBPT_Action,   
        kFBPT_Reference,
        kFBPT_TimeSpan, 
        kFBPT_kReference,
        kFBPT_Vector2D  
    };


    enum FBDataAsStringFlag
    {
        kFBDataAsStringUI              = 0,        
        kFBDataAsStringPersistence     = 1,        
    };

    enum FBPropertyFlag
    {
        kFBPropertyFlagNotSet = 0,
        kFBPropertyFlagHideProperty = (1 << 0),       
        kFBPropertyFlagForceStaticProperty = (1 << 1),
        kFBPropertyFlagDisableProperty = (1 << 2),
        kFBPropertyFlagSlavedProperty = (1 << 3),     
        kFBPropertyFlagAnimated = (1 << 4),
        kFBPropertyFlagNotSavable = (1 << 5),         
        kFBPropertyFlagReadOnly = (1 << 6),
        kFBPropertyFlagNotUserDeletable = (1 << 7),
        kFBValueAllocated = (1 << 8),                 
        kFBDynamicHidden = (1 << 9),                  
        kFBSlaveSetByMaster = (1 << 10),              
        kFBLoadedUserProperty = (1 << 11)             
    };

#define FB_DEFINE_COMPONENT( DllTag, Type )                                             \
    class FB##Type;                                                                     \
    typedef class DllTag FBPropertyBase< FB##Type*,kFBPT_object > FBPropertyBase##Type; \
    typedef class DllTag FBPropertyBaseComponent< FB##Type* > FBProperty##Type

#define FB_DEFINE_ENUM( DllTag, Type ) \
    typedef class DllTag FBPropertyBaseEnum< enum FB##Type > FBProperty##Type;

#define FB_DEFINE_CLASS_ENUM( EnumName ) \
    typedef class FBPropertyBaseEnum< enum __FBClassType::e##EnumName > Property##EnumName;

#define FB_DEFINE_LIST( DllTag, Type )  \
    typedef class DllTag FBPropertyBaseList< FB##Type* > FBPropertyBaseList##Type;

    typedef void (*fbGetSetHandler)(void);
    typedef void (*fbExternalGetSetHandler)(HIObject pObject);

    FB_FORWARD( FBComponent );
    __FB_FORWARD( FBProperty );

    class FBSDK_DLL FBProperty : public FBPlug
    {
        FBClassDeclare( FBProperty, FBPlug );

    protected:
        FBString        mName;
        void*           mParent;

    public:
        FBProperty();    

#ifndef DOXYGEN_SHOULD_SKIP_THIS
        IObject_Declare(K_IMPLEMENTATION);      

        FBProperty* InitInternal( KProperty* pProperty );

        KProperty* GetInternal() const;

        void* GetValuePtr() const;

        FBProperty* CreateInternal( FBComponent* pParent, const char* pName, fbExternalGetSetHandler pGet = NULL, fbExternalGetSetHandler pSet = NULL);

        FBProperty* CreateTextureConnectable( FBComponent* pParent, const char* pName );

        void SetInternal( KProperty* pInternal );
#endif

        void SetEnable( bool pValue );

        const char* GetName();

        void SetName(const char *pName);

        virtual FBPropertyType GetPropertyType( );

        const char* GetPropertyTypeName();

        virtual KDataType* GetDataType();


        virtual void SetData( void* pData );


        virtual void GetData( void* pData, int pSize, FBEvaluateInfo *pEvalInfo = NULL ) const;

        int         AsInt();

        bool        SetInt(int pInt);

        virtual const char* AsString( FBDataAsStringFlag pFlag = kFBDataAsStringUI );

        virtual bool SetString( const char* pString );

        const char* OriValueAsString();

        bool IsAnimated() const;

        bool OriIsAnimated() const;


        virtual bool IsList();
        virtual bool IsAnimatable();
        bool IsInternal() const;
        bool IsUserProperty();
        bool IsTextureConnectableProperty();
        bool IsReferenceProperty();

        bool IsMinClamp();  

        bool IsMaxClamp();

        bool IsTemporaryProperty();

        bool AcceptTemporaryProperty(const char* pEnumList[] = NULL, fbExternalGetSetHandler pGet=NULL, fbExternalGetSetHandler pSet=NULL);

        bool IsObjectList();

        virtual bool IsReadOnly();

        virtual const char* EnumList( int pIndex );

        FBStringList* GetEnumStringList(bool pCreateIt = false);

        void NotifyEnumStringListChanged();

        void            ModifyPropertyFlag(FBPropertyFlag pFlag, bool pValue);

        FBPropertyFlag  GetPropertyFlags();

        bool            GetPropertyFlag(FBPropertyFlag pFlag);

        void    SetMinMax( double pMin, double pMax, bool pForceMinClamp = false, bool pForceMaxClamp = false );

        void    SetMin( double pMin, bool pForceMinClamp = false );

        void    SetMax( double pMax, bool pForceMaxClamp = false );

        double  GetMin();

        double  GetMax();

        inline void* GetParent()    { return mParent; } 


        int     GetSubMemberCount() const;

        bool    AllowsLocking() const;

        bool    HasSomethingLocked() const;

        bool    IsLocked() const;

        bool    IsMemberLocked( int pIndex ) const;

        void    SetLocked( bool pLocked );

        void    SetMemberLocked( int pIndex , bool pLocked );


    private:
        //  FBProperty(FBProperty&); // Make sure no copy constructor is use
    };

    template<class T> inline T* FBCast(FBProperty* pProperty, bool pAutoCreate = false)
    {
        HIObject lProperty = pProperty ? FBGetFBObject(pProperty->GetHIObject(), pAutoCreate) : NULL;
        // Should also validate type but not available for now
        return (T*)lProperty;
    }

    __FB_FORWARD( FBPropertyAnimatable );
    FB_FORWARD( FBBox );
    FB_FORWARD( FBAnimationNode );
    FB_FORWARD( FBTake );

    // PropertyEvent
    __FB_FORWARD(FBPropertyEvent);

    class FBSDK_DLL FBPropertyEvent : public FBProperty
    {
    protected:
#ifndef DOXYGEN_SHOULD_SKIP_THIS

        HIRegister  mParentRegister;
        int         mType;              
        int         mSubType;
#endif
    public:
        FBPropertyEvent();

        FBPropertyEvent *Init( FBComponent* pComponent, HIRegister pParent,const char *pName, int pType, int pSubType=K_INT_MAX );  

        FBPropertyEvent *InitGlobal( const char* pName, const char* pGlobalEventName ); 

        virtual ~FBPropertyEvent();


        virtual void Add        ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove     ( HICallback pOwner, kICallbackHandler pHandler );

        virtual void InvalidateParent();

        virtual FBPropertyType GetPropertyType() override { return kFBPT_event; }

    private:

        DataFBPropertyEvent* mLocalPtr; 
    };

    class FBSDK_DLL FBPropertyEventUIIdle : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };

    class FBSDK_DLL FBPropertyEventVideoFrameRendering : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };

    class FBSDK_DLL FBPropertyEventConnectionNotify : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };

    class FBSDK_DLL FBPropertyEventConnectionDataNotify : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };

    class FBSDK_DLL FBPropertyEventConnectionStateNotify : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };

    class FBSDK_DLL FBPropertyEventConnectionKeyingNotify : public FBPropertyEvent
    {
    public:
        virtual void Add    ( HICallback pOwner, kICallbackHandler pHandler );
        virtual void Remove ( HICallback pOwner, kICallbackHandler pHandler );
    };

    template <class tType, FBPropertyType pPT> class FBPropertyBase : public FBProperty 
    { 
    protected: 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
        void  (* Set)(void *, tType);   
        tType (* Get)(void *);          
#endif
    public: 

        typedef tType ValueType;

        inline FBPropertyBase() { Set = NULL; Get = NULL; }  

        inline FBPropertyBase(const FBPropertyBase<tType,pPT> &pValue)  { operator=((tType)pValue ); }

        ~FBPropertyBase() 
        {     
        }

        inline FBPropertyBase *Init( void* pParent, const char *pName,tType (* pGet)(void *)=NULL,void (* pSet)(void *,tType)=NULL  )
        {  
            mParent = pParent;  
            mName   = pName ;   
            Get     = pGet;     
            Set     = pSet;     
            return this;
        } 


        inline void operator=(tType pValue)                 { SetData( &pValue ); }


        inline void operator=(const FBPropertyBase<tType,pPT> &pProperty)   { operator=((tType)pProperty ); }

        inline operator tType() const                       { tType Value; GetData( &Value,sizeof(Value) ); return Value; } 

        virtual FBPropertyType GetPropertyType( ) override { return pPT; }

        inline virtual void SetPropertyValue( tType pValue )
        {
            if(IsInternal() && GetValuePtr())
            {
                *(tType*)GetValuePtr() = pValue;
            }
        }

        inline tType GetPropertyValue( )
        {
            if(IsInternal() && GetValuePtr())
            {
                return *(tType*)GetValuePtr();
            } else
            {
                return (tType)0;
            }
        }

        inline virtual bool IsReadOnly()  { return IsInternal() ? (FBProperty::IsReadOnly()) : (Set == NULL); }

        inline virtual void GetData(void* pData, int pSize, FBEvaluateInfo *pEvalInfo = NULL) const
        {
            if(Get)
            { 
                *((tType*)pData) = (*Get)(mParent); 
            } 
            else if (IsInternal())
            {
                FBProperty::GetData( pData, pSize, pEvalInfo );
            } 
            else
            {
                assert(Get != NULL || IsInternal());
                *((tType*)pData) = (tType)0; 
            }
        }
        inline virtual void SetData(void* pData)
        { 
            if(Set) 
            { 
                (*Set)( mParent,*(tType*)pData ); 
            } 
            else if (IsInternal())
            {
                FBProperty::SetData( pData );
            } 
            else
            { 
                assert( Set != NULL || IsInternal() ); 
            } 
        } 
    };

    template <class tType> class FBPropertyBaseEnum : public FBPropertyBase<tType,kFBPT_enum>
    {
    public: 
#ifndef DOXYGEN_SHOULD_SKIP_THIS

        static const char *mStrings[];
#endif
        inline FBPropertyBaseEnum(){}  

        inline ~FBPropertyBaseEnum()
        {

        }  

        inline FBPropertyBaseEnum(const FBPropertyBaseEnum<tType> &pValue)  { operator=((tType)pValue ); }


        inline void operator=(tType pValue)                 { SetData( &pValue ); }

        inline operator tType() const                       { tType Value; GetData( &Value,sizeof(Value) ); return Value; } 

        virtual const char* EnumList( int pIndex ) override 
        {   
            if( FBPropertyBaseEnum::IsInternal() )
            {
                return FBProperty::EnumList( pIndex );
            }
            // NOTE: 
            // --> replacing test for if(mStrings) by if(mStrings[0])
            // This is safe to do as we should always have at least 1 item
            // in the list based on our base class implementation. And 
            // the compiler should throw a linker error if mStrings is not found. 
            // mStrings[0] == NULL for enum kDefaultEnum but mStrings can never be NULL
            else if(mStrings[0])
            {
                return mStrings[pIndex]; 
            }
            else
            {
                assert(mStrings[0] || FBPropertyBaseEnum::IsInternal());
                return NULL;
            }
        }

        virtual const char* AsString( FBDataAsStringFlag pFlag = kFBDataAsStringUI ) override { return EnumList( FBPropertyBaseEnum::AsInt() );}

        virtual bool SetString( const char *pString ) override
        {
            int         Count=0;
            const char *    tmpstr;
            while ((tmpstr=EnumList( Count ))!=NULL) {
                if (strcmp(tmpstr,pString)==0) {
                    FBPropertyBaseEnum::SetData( &Count );
                    return true;
                }
                Count++;
            }
            return false;
        }

    };


    class FBSDK_DLL FBPropertyBasicList : public FBProperty
    {
    public:
        FBPropertyBasicList();
        ~FBPropertyBasicList();
        FBPropertyBasicList( HIObject pParent, const char *pName );
        FBProperty* Init( void* pParent, const char *pName );

        void RemoveAll();

        virtual int GetCount()=0;

        virtual void RemoveAt( int pIndex )=0;

        virtual bool IsList();
    };

    template <class tType> class FBPropertyBaseList : public FBPropertyBasicList
    {
    public:
        FBPropertyBaseList( ):FBPropertyBasicList( ) {}

        ~FBPropertyBaseList( )
        {

        }
        FBPropertyBaseList( HIObject pParent, const char *pName ):FBPropertyBasicList( pParent, pName ) {}

    public:  
        //***
        //--- These functions require overloads in derived classes. 
        //***

        virtual int Add( tType pItem )=0;

        virtual tType operator[]( int pIndex )=0;

    public: 
        //***
        //--- These functions can be optionally overloaded in derived classes.
        //***

        inline virtual int Find( tType pItem )      
        { 
            int Index;
            for(Index=0; Index<GetCount(); Index++ ) 
            {
                if( operator[](Index)==pItem ) 
                {
                    return Index; 
                }
            }
            return -1;
        }

        inline virtual int Remove( tType pItem )        
        {
            int Index = Find( pItem ); 
            if (Index!=-1)
            {
                RemoveAt( Index );
            }
            return Index;
        }

        inline virtual tType GetAt(int pIndex)  
        {
            return operator[](pIndex); 
        }
    };

    enum kDefaultEnum { 
        kDefaultItemNone    
    };


    typedef class FBSDK_DLL FBPropertyBaseEnum< enum kDefaultEnum > FBPropertyEnum;
    FB_FORWARD( FBPropertyStringList );

    class FBSDK_DLL FBPropertyStringList : public FBProperty
    {
    public:
        FBPropertyStringList();

        virtual ~FBPropertyStringList();

        FBPropertyStringList* Init( FBComponent* pComponent, const char *pName );

    public:
        kReference  GetReferenceAt( int pIndex );
        void SetReferenceAt( int pIndex,kReference pRef );

        int Find( kReference pRef );

        int Find( const char *S );

        virtual const char *GetAt( int pIndex );

        const char *operator[](int pIndex);

        void Sort( );

        int GetCount();

        int Remove( const char *S );

    public:  // Needs to be overriden for special behaviors
        virtual int Add( const char *S,kReference pRef = 0 );

        virtual void Clear();

        virtual void RemoveAt( int pIndex );

        virtual int IndexOf(const char *S);

        virtual void InsertAt( int pIndex, const char *S,kReference pRef = 0 );

        virtual bool SetAt( int pIndex,const char *pString );

        virtual bool IsList() override;

        virtual const char* AsString( FBDataAsStringFlag pFlag = kFBDataAsStringUI ) override;

        virtual bool SetString( const char *pString ) override;

        virtual FBPropertyType GetPropertyType() override { return kFBPT_stringlist; }
    };

    // FBPropertyManager
    __FB_FORWARD( FBPropertyManager );

    class FBSDK_DLL FBPropertyManager 
    {
    public:
        FBPropertyManager();

        ~FBPropertyManager();

        int Add( FBProperty* Property );

        FBProperty* operator[](int pIndex);

        int GetCount();

        FBProperty* Find( const char *pPropertyName, bool pMultilangLookup=true );

        void FindPropertiesByName( const char* pPropertyNamePattern, FBArrayTemplate<FBProperty*>& pPropList, bool pMultilangLookup=true );

        int Remove( FBProperty* pProperty );

        void AddToCache( FBProperty* pProperty );

        void RemoveFromCache( KProperty* pProperty );

        FBProperty* FindInCache( KProperty* pProperty );

    private:
        void ClearCache();

        void SetParent( HIObject pParent );

#ifndef DOXYGEN_SHOULD_SKIP_THIS
        KObject*                        mObject;        
        FBArrayTemplate< FBProperty* >  mPropertyCache; 
        FBArrayTemplate< FBProperty* >  mPropertyLocal; 
#endif
        friend class FBComponent;
        friend class FBVisualComponent;
    };

    template <class tType> class FBPropertyBaseComponent : public FBPropertyBase< tType, kFBPT_object > 
    {
    public:
        int *TypeInfo;  
    public:
        inline FBPropertyBaseComponent() {}

        inline FBPropertyBaseComponent(const FBPropertyBaseComponent<tType> &pValue)    { FBPropertyBase< tType,kFBPT_object >::operator=((tType)pValue ); }

        ~FBPropertyBaseComponent()
        {
        }


        inline void operator=(tType pValue)                             { FBPropertyBase< tType,kFBPT_object >::operator=(pValue); } 

        inline tType operator -> ()                                 { return FBPropertyBase< tType,kFBPT_object >::operator tType(); } 

        inline operator tType() const                                   { return FBPropertyBase< tType,kFBPT_object >::operator tType(); } 
    };

#if defined(KARCH_DEV_INTEL)
#define FBImplementPropertyComponent( DllTag, Type ) 
#else
#define FBImplementPropertyComponent( DllTag, Type ) \
    template class DllTag FBSDKNamespaceFunc(FBPropertyBase)< FB##Type*,kFBPT_object >; \
    template class DllTag FBSDKNamespaceFunc(FBPropertyBaseComponent)< FB##Type* >;
#endif

#if defined(KARCH_DEV_INTEL)
#define FBImplementPropertyEnum( DllTag, Type ) // On SGI by having mString defined for each enum already instantiates the template.
#define FBImplementClassPropertyEnum( DllTag, Class, EnumName )
#else
#define FBImplementPropertyEnum( DllTag, Type ) \
    template class DllTag FBSDKNamespaceFunc(FBPropertyBaseEnum)< enum FB##Type >
#define FBImplementClassPropertyEnum( DllTag, Class, EnumName ) \
    template class DllTag FBSDKNamespaceFunc(FBPropertyBaseEnum)< enum Class::E##EnumName >
#endif

#if defined(KARCH_DEV_INTEL)
#define FBImplementPropertyList( DllTag, Type )
#else
#define FBImplementPropertyList( DllTag, Type ) \
    template class DllTag FBSDKNamespaceFunc(FBPropertyBaseList) < FB##Type* >
#endif


    class FBSDK_DLL FBPropertyString : public FBPropertyBase< const char *, kFBPT_charptr > 
    {
    public:


        inline void operator=(const char* pValue)                   { SetData( &pValue ); }

        inline operator const char* () const                            { char* Value; GetData( &Value,sizeof(Value) ); return Value; } 

        inline bool operator==(const char* pValue) const                { char* Value; GetData( &Value,sizeof(Value) ); return (Value == pValue) || (strcmp(Value, pValue) == 0); }
        inline bool operator!=(const char* pValue) const                { return ! operator==(pValue); }

        virtual void SetPropertyValue( const char* pValue ) override;
    };

    typedef class FBSDK_DLL FBPropertyBase< bool,kFBPT_bool > FBPropertyBool;

    class FBSDK_DLL FBPropertyAction : public FBPropertyBase< bool, kFBPT_Action > 
    {
    public:
        inline FBPropertyAction() {}

        ~FBPropertyAction()
        {
        }

        bool operator ()();
    };

    typedef class FBSDK_DLL FBPropertyBase< int,kFBPT_int > FBPropertyInt;

    typedef class FBSDK_DLL FBPropertyBase< long long,kFBPT_int64 > FBPropertyInt64;

    typedef class FBSDK_DLL FBPropertyBase< unsigned long long,kFBPT_uint64 > FBPropertyUInt64;

    typedef class FBSDK_DLL FBPropertyBase< double,kFBPT_double > FBPropertyDouble;

    typedef class FBSDK_DLL FBPropertyBase< float,kFBPT_float > FBPropertyFloat;

    typedef class FBSDK_DLL FBPropertyBase< FBTime,kFBPT_Time > FBPropertyTime;

    typedef class FBSDK_DLL FBPropertyBase< FBTimeCode,kFBPT_TimeCode > FBPropertyTimeCode;

    typedef class FBSDK_DLL FBPropertyBase< FBTimeSpan,kFBPT_TimeSpan > FBPropertyTimeSpan;

    typedef class FBSDK_DLL FBPropertyBase< kReference,kFBPT_kReference >   FBPropertykReference;

    typedef class FBSDK_DLL FBPropertyBase< FBProperty*,kFBPT_Reference >           FBPropertyReference;
    typedef class FBSDK_DLL FBPropertyBase< FBComponent*,kFBPT_object >         _FBPropertyBaseComponent;
    typedef class FBSDK_DLL FBPropertyBaseComponent< FBComponent* > FBPropertyComponent;
    typedef class FBSDK_DLL FBPropertyBase< FBPlug*,kFBPT_object >           _FBPropertyBasePlug;
    typedef class FBPropertyBaseComponent< FBPlug* >  FBPropertyPlug;

#define FBPropertyInit( Param,Type,PropName,Get,Set ) \
    { \
    PropertyAdd(PropName.Init( (void*)Param,#PropName,(Type (*)(void *))Get,(void (*)(void *,Type))Set )); \
    }

#define FBPropertyInitList( Param,PropName ) \
    { \
    PropertyAdd(PropName.Init( Param,#PropName )); \
    }

#define FBPropertyInitStringList( Param,PropName ) \
    { \
    PropertyAdd(PropName.Init( Param, #PropName )); \
    }

#define FBPropertyInitEvent( Param,Type,SubType,PropName ) \
    { \
    PropertyAdd(PropName.Init( this, IQ(Param,IRegister),#PropName,Type,SubType )); \
    }

#define FBPropertyInitEventGlobal( GlobalEventName,PropName ) \
    { \
    PropertyAdd(PropName.InitGlobal( #PropName,GlobalEventName )); \
    }

#define FBPropertyInitInternal( Parent, PropName, MBProperty ) \
    {\
    PropertyAdd(PropName.InitInternal( MBProperty ));\
    }

#define FBPropertyInitInternalEnum( Param,Type,PropName,MBProperty,Get,Set  ) \
    {\
    PropName.InitInternal( MBProperty ); \
    PropertyAdd(PropName.Init( (void*)Param,#PropName,(Type (*)(void *))Get,(void (*)(void *,Type))Set )); \
    }

#define FBPropertyPublish( Parent,Prop,PropName,Get,Set ) \
    { \
    PropertyAdd(Prop.CreateInternal( Parent,PropName,(fbExternalGetSetHandler)Get,(fbExternalGetSetHandler)Set )); \
    }

#define FBPropertyInitTextureConnectable( Parent,Prop,PropName ) \
    { \
    PropertyAdd(Prop.CreateTextureConnectable( Parent,PropName )); \
    }

    typedef class FBSDK_DLL FBPropertyBase< FBColor,kFBPT_ColorRGB >    FBPropertyColor;
    typedef class FBSDK_DLL FBPropertyBase< FBColorAndAlpha,kFBPT_ColorRGBA >   FBPropertyColorAndAlpha;
    typedef class FBSDK_DLL FBPropertyBase< FBVector2d,kFBPT_Vector2D > FBPropertyVector2d;
    typedef class FBSDK_DLL FBPropertyBase< FBVector3d,kFBPT_Vector3D > FBPropertyVector3d;
    typedef class FBSDK_DLL FBPropertyBase< FBVector4d,kFBPT_Vector4D > FBPropertyVector4d;
    class FBSDK_DLL FBPropertyAnimatable : public FBProperty
    {
    public:
        FBPropertyAnimatable();

        virtual ~FBPropertyAnimatable();

    public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
        FBPropertyAnimatable* InitInternal( KEvaluationProperty* pProperty );
#endif

        FBPropertyAnimatable* Init( FBBox* pOwner, const char* pName, const char* pType, double* pInit );

        void Destroy();

        virtual KDataType* GetDataType() override;

        const char* GetDataTypeName();

        bool IsFocused();

        void SetFocus( bool pState );

        void Key();

        void KeyAt( FBTime pTime );

        void KeyRemoveAt( FBTime pTime );

        int GetDataSize() const;


        virtual bool IsAnimatable() override { return true; }

        bool IsAnimated();

        void SetAnimated( bool pState, bool pCheckLocked = false );

        FBAnimationNode* GetAnimationNode(FBTake* pTake=NULL);

        FBBox* GetBox();

        virtual void SetData( void* pData ) override;

        virtual void GetData( void* pData, int pSize, FBEvaluateInfo* pEvalInfo = NULL ) const override;

        void SetCandidate( void* pData, int pSize, FBEvaluateInfo* pEvalInfo = NULL );

        void SetGlobalCandidate( void* pData, int pSize, FBEvaluateInfo* pEvalInfo = NULL );



        bool    AllowsMuting() const;

        bool    HasSomethingMuted() const;

        bool    IsMuted() const;

        bool    IsMemberMuted( int pIndex ) const;

        void    SetMuted( bool pMuted );

        void    SetMemberMuted( int pIndex , bool pMuted );


    };

    template <class tType, FBPropertyType pPT> class FBPropertyBaseAnimatable : public FBPropertyAnimatable
    {
    public:

        typedef tType ValueType;

        FBPropertyBaseAnimatable( );
        FBPropertyBaseAnimatable( const FBPropertyBaseAnimatable<tType,pPT> &pValue);

        ~FBPropertyBaseAnimatable( );


        void operator=(tType pValue);

        operator tType() const;

        virtual FBPropertyType GetPropertyType( ) override { return pPT; }
    };


    typedef class FBSDK_DLL FBPropertyBaseAnimatable< bool,kFBPT_Action > FBPropertyAnimatableAction;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< bool,kFBPT_bool > FBPropertyAnimatableBool;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< int,kFBPT_int > FBPropertyAnimatableInt;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< long long,kFBPT_int64 > FBPropertyAnimatableInt64;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< unsigned long long,kFBPT_uint64 > FBPropertyAnimatableUInt64;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< int,kFBPT_enum > FBPropertyAnimatableEnum;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< double,kFBPT_double >  FBPropertyAnimatableDouble;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< FBTime,kFBPT_Time >    FBPropertyAnimatableTime;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< FBTimeCode,kFBPT_TimeCode >   FBPropertyAnimatableTimeCode;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< FBVector2d,kFBPT_Vector2D > FBPropertyAnimatableVector2d;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< FBVector3d,kFBPT_Vector3D > FBPropertyAnimatableVector3d;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< FBVector4d,kFBPT_Vector4D > FBPropertyAnimatableVector4d;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< FBColor,kFBPT_ColorRGB >  FBPropertyAnimatableColor;
    typedef class FBSDK_DLL FBPropertyBaseAnimatable< FBColorAndAlpha,kFBPT_ColorRGBA > FBPropertyAnimatableColorAndAlpha;
    template <class tType> class FBPropertyBaseAnimatableEnum : public  FBPropertyBaseAnimatable<int,kFBPT_enum>
    {
    public: 
#ifndef DOXYGEN_SHOULD_SKIP_THIS

        static const char *mStrings[];
#endif

        inline FBPropertyBaseAnimatableEnum(){}  

        inline ~FBPropertyBaseAnimatableEnum()
        {
        }  

        inline FBPropertyBaseAnimatableEnum(const FBPropertyBaseAnimatableEnum<tType> &pValue)  { operator=((tType)pValue ); }


        inline void operator=(tType pValue)                 { SetData( &pValue ); }

        inline operator tType() const                       { tType Value; GetData( &Value,sizeof(Value) ); return Value; } 

        virtual const char* EnumList( int pIndex ) override
        {   
            if( IsInternal() )
            {
                return FBProperty::EnumList( pIndex );
            }
            // NOTE: 
            // --> replacing test for if(mStrings) by if(mStrings[0])
            // This is safe to do as we should always have at least 1 item
            // in the list based on our base class implementation. And 
            // the compiler should throw a linker error if mStrings is not found. 
            // mStrings[0] == NULL for enum kDefaultEnum but mStrings can never be NULL
            else if(mStrings[0])
            {
                return mStrings[pIndex]; 
            }
            else
            {
                assert(mStrings[0] || IsInternal());
                return NULL;
            }
        }

        virtual const char* AsString( FBDataAsStringFlag pFlag = kFBDataAsStringUI ) override { return EnumList( AsInt() );}

        virtual bool SetString( const char *pString ) override
        {
            int         Count=0;
            const char *    tmpstr;
            while ((tmpstr=EnumList( Count ))!=NULL) {
                if (strcmp(tmpstr,pString)==0) {
                    SetData( &Count );
                    return true;
                }
                Count++;
            }
            return false;
        }


    };

    // Global
#ifdef FBSDKUseNamespace
}
#endif

#endif