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

#define FB_DEFINE_COMPONENT( DllTag, Type )                                             \
    class FB##Type; typedef  FB##Type *HFB##Type;                                       \
    typedef class DllTag FBPropertyBase< HFB##Type,kFBPT_object > FBPropertyBase##Type; \
    typedef class DllTag FBPropertyBaseComponent< HFB##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< HFB##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(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();

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

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

__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:

    HDataFBPropertyEvent 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 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: 
    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 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 );
        }
        else if(mStrings)
        {
            return mStrings[pIndex]; 
        }
        else
        {
            assert(mStrings || FBPropertyBaseEnum::IsInternal());
            return NULL;
        }
    }

    virtual const char* AsString() 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() 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 );

    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)< HFB##Type,kFBPT_object >; \
        template class DllTag FBSDKNamespaceFunc(FBPropertyBaseComponent)< HFB##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) < HFB##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); }

};

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 FBPropertyComponent *HFBPropertyComponent;
typedef class FBSDK_DLL FBPropertyBase< FBPlug*,kFBPT_object >           _FBPropertyBasePlug;
typedef class FBPropertyBaseComponent< FBPlug* >  FBPropertyPlug;
typedef FBPropertyPlug *HFBPropertyPlug;

#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( HFBBox 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 );

    FBAnimationNode* GetAnimationNode(FBTake* pTake=NULL);

    HFBBox GetBox();

    virtual void SetData( void* pData ) override;

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

template <class tType, FBPropertyType pPT> class FBPropertyBaseAnimatable : public FBPropertyAnimatable
{
  public:
    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 );
        }
        else if(mStrings)
        {
            return mStrings[pIndex]; 
        }
        else
        {
            assert(mStrings || IsInternal());
            return NULL;
        }
    }

    virtual const char* AsString() 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