kfbxproperty.h

Go to the documentation of this file.

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXPROPERTY_H
#define FBXFILESDK_KFBXPLUGINS_KFBXPROPERTY_H

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

 Copyright (C) 2001 - 2010 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 <fbxfilesdk/fbxfilesdk_def.h>

#include <fbxfilesdk/kfbxplugins/kfbxplug.h>
#include <fbxfilesdk/kfbxplugins/kfbxtypes.h>

// FBX includes
#include <fbxfilesdk/components/kfcurve/kfcurvenode.h>
#include <fbxfilesdk/kfbxplugins/kfbxdatatypes.h>
#include <fbxfilesdk/fbxcore/kfbxpropertydef.h>

// FBX namespace
#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

// Forward declarations
class KFbxObject;
class KFbxColor;
class KFbxCriteria;
class KFbxAnimLayer;
class KFbxAnimCurveNode;
class KFbxAnimCurve;

    class KFBX_DLL KFbxProperty : private FbxPropertyFlags
    {
        public:
            using FbxPropertyFlags::eFbxPropertyFlags;
            using FbxPropertyFlags::eNO_FLAG;
            using FbxPropertyFlags::eANIMATABLE;
            using FbxPropertyFlags::eUSER;
            using FbxPropertyFlags::eTEMPORARY;
            using FbxPropertyFlags::ePUBLISHED;
            using FbxPropertyFlags::ePSTATIC;

            using FbxPropertyFlags::eNOT_SAVABLE;
            using FbxPropertyFlags::eHIDDEN;

            using FbxPropertyFlags::eUI_DISABLED;
            using FbxPropertyFlags::eUI_GROUP;
            using FbxPropertyFlags::eUI_BOOLGROUP;
            using FbxPropertyFlags::eUI_EXPANDED;
            using FbxPropertyFlags::eUI_NOCAPTION;
            using FbxPropertyFlags::eUI_PANEL;
            using FbxPropertyFlags::eUI_HIDDEN;

            typedef FbxPropertyFlags::eFbxPropertyFlags EFlags;

            static KFbxProperty Create(KFbxProperty const &pCompoundProperty, KFbxDataType const &pDataType, char const* pName, char const* pLabel="", bool pCheckForDup=true, bool* pWasFound=NULL);

            static KFbxProperty Create(KFbxObject* pObject, KFbxDataType const &pDataType, char const* pName, char const* pLabel="", bool pCheckForDup=true, bool* pWasFound=NULL);

            static KFbxProperty CreateFrom(KFbxProperty const& pCompoundProperty, KFbxProperty& pFromProperty, bool pCheckForDup=true);

            static KFbxProperty CreateFrom(KFbxObject* pObject, KFbxProperty& pFromProperty, bool pCheckForDup=true);

            void Destroy();

            void DestroyRecursively();

            void DestroyChildren();

            KFbxProperty();

            KFbxProperty(KFbxProperty const &pProperty);

            KFbxProperty(KFbxPropertyHandle const &pPropertyHandle);

            ~KFbxProperty();

        public:

        public:
            KFbxDataType        GetPropertyDataType() const;

            KString         GetName() const;

            KString             GetHierarchicalName() const;

            KString         GetLabel(bool pReturnNameIfEmpty=true) const;


            void                SetLabel(const KString & pLabel);

            KFbxObject*         GetFbxObject() const;


            void                SetUserTag(int pTag);
                
            int                 GetUserTag();

            void  SetUserDataPtr(void* pUserData);

            void* GetUserDataPtr();

            void ModifyFlag(eFbxPropertyFlags pFlag, bool pValue);

            bool GetFlag(eFbxPropertyFlags pFlag) const;

            KFbxInheritType GetFlagInheritType( eFbxPropertyFlags pFlag ) const;

            bool SetFlagInheritType( eFbxPropertyFlags pFlag, KFbxInheritType pType );

            bool ModifiedFlag( eFbxPropertyFlags pFlag ) const;


            KFbxProperty &      operator=  (KFbxProperty const &pKProperty);

            bool                operator== (KFbxProperty const &pKProperty) const;

            bool                operator!= (KFbxProperty const &pKProperty) const;

            inline bool         operator== (int pValue) const { return pValue==0 ? !IsValid() : IsValid(); }

            inline bool         operator!= (int pValue) const { return pValue!=0 ? !IsValid() : IsValid(); }

            bool CompareValue(KFbxProperty const& pProp) const;

        bool CopyValue(KFbxProperty const& pProp);

        public:

            bool            IsValid() const;

            static bool HasDefaultValue( KFbxProperty& pProperty );

            bool Set(void const *pValue,EFbxType pValueType, bool pCheckForValueEquality);

            inline bool Set(void const *pValue,EFbxType pValueType) { return Set( pValue, pValueType, true ); }

            bool Get(void *pValue,EFbxType pValueType) const;

            template <class T> inline bool  Set( T const &pValue )  { return Set( &pValue,FbxTypeOf(pValue), true ); }

            template <class T> inline T     Get( T const *pFBX_TYPE) const { T lValue; Get( &lValue,FbxTypeOf(lValue) ); return lValue; }

            KFbxInheritType GetValueInheritType() const;

            bool SetValueInheritType( KFbxInheritType pType );

            bool Modified() const;


        public:
            void                SetMinLimit(double pMin);

         bool           HasMinLimit() const;

            double          GetMinLimit() const;

         bool           HasMaxLimit() const;

            void                SetMaxLimit(double pMax);

            double          GetMaxLimit() const;

            void                SetLimits(double pMin, double pMax);

        public:
            int                 AddEnumValue(char const *pStringValue);

            void                InsertEnumValue(int pIndex, char const *pStringValue);

            int                 GetEnumCount() const;

            void                SetEnumValue(int pIndex, char const *pStringValue);

            void                RemoveEnumValue(int pIndex);

            const char *              GetEnumValue(int pIndex) const;

            inline bool                 IsRoot() const                                          { return mPropertyHandle.IsRoot(); }

            inline bool                 IsChildOf(KFbxProperty  const & pParent) const          { return mPropertyHandle.IsChildOf(pParent.mPropertyHandle); }

            inline bool                 IsDescendentOf(KFbxProperty const & pAncestor) const    { return mPropertyHandle.IsDescendentOf(pAncestor.mPropertyHandle); }

            inline KFbxProperty         GetParent() const                                       { return KFbxProperty(mPropertyHandle.GetParent());  }

            bool                        SetParent( const KFbxProperty& pOther );

            inline KFbxProperty         GetChild() const                                        { return KFbxProperty(mPropertyHandle.GetChild());   }

            inline KFbxProperty         GetSibling() const                                      { return KFbxProperty(mPropertyHandle.GetSibling()); }

            inline KFbxProperty         GetFirstDescendent() const                              { return KFbxProperty(mPropertyHandle.GetFirstDescendent());   }

            inline KFbxProperty         GetNextDescendent(KFbxProperty const &pProperty) const  { return KFbxProperty(mPropertyHandle.GetNextDescendent(pProperty.mPropertyHandle)); }

            inline KFbxProperty         Find (char const *pName,bool pCaseSensitive = true) const { return KFbxProperty(mPropertyHandle.Find(pName,pCaseSensitive));  }

            inline KFbxProperty         Find (char const *pName,KFbxDataType const &pDataType, bool pCaseSensitive = true) const { return KFbxProperty(mPropertyHandle.Find(pName,pDataType.GetTypeInfoHandle(),pCaseSensitive));  }

            inline KFbxProperty         FindHierarchical (char const *pName,bool pCaseSensitive = true) const { return KFbxProperty(mPropertyHandle.Find(pName,sHierarchicalSeparator,pCaseSensitive));  }

            inline KFbxProperty         FindHierarchical (char const *pName,KFbxDataType const &pDataType, bool pCaseSensitive = true) const { return KFbxProperty(mPropertyHandle.Find(pName,sHierarchicalSeparator,pDataType.GetTypeInfoHandle(),pCaseSensitive));  }



            inline void     BeginCreateOrFindProperty() { mPropertyHandle.BeginCreateOrFindProperty();  }

            inline void     EndCreateOrFindProperty()   { mPropertyHandle.EndCreateOrFindProperty();    }

         struct KFbxPropertyNameCache
         {
            KFbxPropertyNameCache(const KFbxProperty& prop) :
               mProp(const_cast<KFbxProperty&>(prop))
            {
               mProp.BeginCreateOrFindProperty();
            }

            ~KFbxPropertyNameCache()
            {
               mProp.EndCreateOrFindProperty();
            }

         private:
            KFbxProperty & mProp;

            KFbxPropertyNameCache& operator=(const KFbxPropertyNameCache &other) { mProp = other.mProp; mProp.BeginCreateOrFindProperty(); return *this; }
         };

            bool            SetArraySize( int pSize, bool pVariableArray );

            int             GetArraySize() const;

            KFbxProperty    GetArrayItem(int pIndex) const;

            inline KFbxProperty operator[](int pIndex) const { return GetArrayItem(pIndex); }

            K_DEPRECATED
            KFCurveNode* CreateKFCurveNode(const char* pTakeName=NULL);

            K_DEPRECATED
            KFCurveNode* GetKFCurveNode(bool pCreateAsNeeded=false, const char* pTakeName=NULL);

            K_DEPRECATED
            KFCurve* GetKFCurve(const char* pChannel = NULL, bool pCreateAsNeeded=true);

            K_DEPRECATED
            KFCurve* GetKFCurve(const char* pChannel, const char* pTakeName, bool pCreateAsNeeded=true);

            KFbxAnimCurveNode* CreateCurveNode(KFbxAnimLayer* pAnimLayer);

            KFbxAnimCurveNode* GetCurveNode(KFbxAnimLayer* pAnimLayer, bool pCreateAsNeeded=false);

            KFbxAnimCurveNode* GetCurveNode(bool pCreateAsNeeded=false, const char* pAnimStackName = NULL);

            template <class T> inline T* GetCurve(KFbxAnimLayer* pAnimLayer, bool pCreateAsNeeded=false)
            {
                return KFbxCast<T>(GetCurve(pAnimLayer, GetName(), NULL, pCreateAsNeeded));
            }

            template <class T> inline T* GetCurve(KFbxAnimLayer* pAnimLayer, const char* pChannel, bool pCreateAsNeeded=false)
            {
                return KFbxCast<T>(GetCurve(pAnimLayer, GetName(), pChannel, pCreateAsNeeded));
            }

            template <class T> inline T* GetCurve(KFbxAnimLayer* pAnimLayer, const char* pName, const char* pChannel, bool pCreateAsNeeded=false)
            {
                return KFbxCast<T>(GetCurve(pAnimLayer, pName, pChannel, pCreateAsNeeded));
            }

        public:
            // SrcObjects
            bool ConnectSrcObject       (KFbxObject* pObject,kFbxConnectionType pType=eFbxConnectionNone);

            bool IsConnectedSrcObject   (const KFbxObject* pObject) const;

            bool DisconnectSrcObject    (KFbxObject* pObject);

            bool DisconnectAllSrcObject();

            bool DisconnectAllSrcObject(KFbxCriteria const &pCriteria);

            bool DisconnectAllSrcObject(const kFbxClassId& pClassId);

            bool DisconnectAllSrcObject(const kFbxClassId& pClassId,KFbxCriteria const &pCriteria);

            int GetSrcObjectCount()const;

            int GetSrcObjectCount(KFbxCriteria const &pCriteria)const;

            int GetSrcObjectCount(const kFbxClassId& pClassId)const;

            int GetSrcObjectCount(const kFbxClassId& pClassId,KFbxCriteria const &pCriteria)const;

            KFbxObject* GetSrcObject(int pIndex=0) const;

            KFbxObject* GetSrcObject(KFbxCriteria const &pCriteria,int pIndex=0) const;

            KFbxObject* GetSrcObject(const kFbxClassId& pClassId,int pIndex=0) const;

            KFbxObject* GetSrcObject(const kFbxClassId& pClassId,KFbxCriteria const &pCriteria,int pIndex=0) const;

            KFbxObject* FindSrcObject(const char *pName,int pStartIndex=0) const;

            KFbxObject* FindSrcObject(KFbxCriteria const &pCriteria,const char *pName,int pStartIndex=0) const;

            KFbxObject* FindSrcObject(const kFbxClassId& pClassId,const char *pName,int pStartIndex=0) const;

            KFbxObject* FindSrcObject(const kFbxClassId& pClassId,KFbxCriteria const &pCriteria,const char *pName,int pStartIndex=0) const;

            template < class T > inline bool DisconnectAllSrcObject (T const *pFBX_TYPE){ return DisconnectAllSrcObject(T::ClassId);}

            template < class T > inline bool DisconnectAllSrcObject (T const *pFBX_TYPE,KFbxCriteria const &pCriteria)  { return DisconnectAllSrcObject(T::ClassId,pCriteria);  }

            template < class T > inline int  GetSrcObjectCount(T const *pFBX_TYPE) const{ return GetSrcObjectCount(T::ClassId); }

            template < class T > inline int  GetSrcObjectCount(T const *pFBX_TYPE,KFbxCriteria const &pCriteria) const { return GetSrcObjectCount(T::ClassId,pCriteria); }

            template < class T > inline T*   GetSrcObject(T const *pFBX_TYPE,int pIndex=0) const { return (T*)GetSrcObject(T::ClassId,pIndex); }

            template < class T > inline T*   GetSrcObject(T const *pFBX_TYPE,KFbxCriteria const &pCriteria,int pIndex=0) const { return (T*)GetSrcObject(T::ClassId,pCriteria,pIndex); }

            template < class T > inline T*   FindSrcObject(T const *pFBX_TYPE,const char *pName,int pStartIndex=0) const { return (T*)FindSrcObject(T::ClassId,pName,pStartIndex); }

            template < class T > inline T*   FindSrcObject(T const *pFBX_TYPE,KFbxCriteria const &pCriteria,const char *pName,int pStartIndex=0) const { return (T*)FindSrcObject(T::ClassId,pCriteria,pName,pStartIndex); }

            // DstObjects
            bool ConnectDstObject       (KFbxObject* pObject,kFbxConnectionType pType=eFbxConnectionNone);

            bool IsConnectedDstObject   (const KFbxObject* pObject) const;

            bool DisconnectDstObject    (KFbxObject* pObject);

            bool DisconnectAllDstObject();

            bool DisconnectAllDstObject(KFbxCriteria const &pCriteria);

            bool DisconnectAllDstObject(const kFbxClassId& pClassId);

            bool DisconnectAllDstObject(const kFbxClassId& pClassId,KFbxCriteria const &pCriteria);

            int GetDstObjectCount() const;

            int GetDstObjectCount(KFbxCriteria const &pCriteria) const;

            int GetDstObjectCount(const kFbxClassId& pClassId) const;

            int GetDstObjectCount(const kFbxClassId& pClassId,KFbxCriteria const &pCriteria) const;

            KFbxObject* GetDstObject(int pIndex=0) const;

            KFbxObject* GetDstObject(KFbxCriteria const &pCriteria,int pIndex=0) const;

            KFbxObject* GetDstObject(const kFbxClassId& pClassId,int pIndex=0) const;

            KFbxObject* GetDstObject(const kFbxClassId& pClassId,KFbxCriteria const &pCriteria,int pIndex=0)const;

            KFbxObject* FindDstObject(const char *pName,int pStartIndex=0) const;

            KFbxObject* FindDstObject(KFbxCriteria const &pCriteria,const char *pName,int pStartIndex=0) const;

            KFbxObject* FindDstObject(const kFbxClassId& pClassId,const char *pName,int pStartIndex=0) const;

            KFbxObject* FindDstObject(const kFbxClassId& pClassId,KFbxCriteria const &pCriteria,const char *pName,int pStartIndex=0) const;

            template < class T > inline bool DisconnectAllDstObject (T const *pFBX_TYPE){ return DisconnectAllDstObject(T::ClassId);    }

            template < class T > inline bool DisconnectAllDstObject (T const *pFBX_TYPE,KFbxCriteria const &pCriteria)  { return DisconnectAllDstObject(T::ClassId,pCriteria);  }

            template < class T > inline int  GetDstObjectCount(T const *pFBX_TYPE) const { return GetDstObjectCount(T::ClassId); }

            template < class T > inline int  GetDstObjectCount(T const *pFBX_TYPE,KFbxCriteria const &pCriteria) const { return GetDstObjectCount(T::ClassId,pCriteria); }

            template < class T > inline T*   GetDstObject(T const *pFBX_TYPE,int pIndex=0) const { return (T*)GetDstObject(T::ClassId,pIndex); }

            template < class T > inline T*   GetDstObject(T const *pFBX_TYPE,KFbxCriteria const &pCriteria,int pIndex=0) const { return (T*)GetDstObject(T::ClassId,pCriteria,pIndex); }

            template < class T > inline T*   FindDstObject(T const *pFBX_TYPE,const char *pName,int pStartIndex=0) const { return (T*)FindDstObject(T::ClassId,pName,pStartIndex); }

            template < class T > inline T*   FindDstObject(T const *pFBX_TYPE,KFbxCriteria const &pCriteria,const char *pName,int pStartIndex=0) const { return (T*)FindDstObject(T::ClassId,pCriteria,pName,pStartIndex); }

        public:
            // Properties
            bool            ConnectSrcProperty      (KFbxProperty const & pProperty);

            bool            IsConnectedSrcProperty  (KFbxProperty const & pProperty);

            bool            DisconnectSrcProperty   (KFbxProperty const & pProperty);

            int             GetSrcPropertyCount     () const;

            KFbxProperty    GetSrcProperty          (int pIndex=0) const;

            KFbxProperty    FindSrcProperty         (const char *pName,int pStartIndex=0) const;

            bool            ConnectDstProperty      (KFbxProperty const & pProperty);

            bool            IsConnectedDstProperty  (KFbxProperty const & pProperty);

            bool            DisconnectDstProperty   (KFbxProperty const & pProperty);

            int             GetDstPropertyCount     () const;

            KFbxProperty    GetDstProperty          (int pIndex=0) const;

            KFbxProperty    FindDstProperty         (const char *pName,int pStartIndex=0) const;

            void            ClearConnectCache();


        static const char* sHierarchicalSeparator;

        //  WARNING!
        //  Anything beyond these lines may not be documented accurately and is
        //  subject to change without notice.
        #ifndef DOXYGEN_SHOULD_SKIP_THIS

        protected:
            KFbxProperty(KFbxObject* pObject, char const* pName, KFbxDataType const &pDataType=KFbxDataType(), char const* pLabel="");
            KFbxProperty(KFbxProperty const & pParent, char const* pName, KFbxDataType const &pDataType, char const* pLabel);

        // General Property Connection and Relationship Management
        private:
            bool            ConnectSrc      (KFbxProperty const &pProperty,kFbxConnectionType pType=eFbxConnectionNone);
            bool            DisconnectSrc   (KFbxProperty const &pProperty);
            bool            DisconnectAllSrc();
            bool            DisconnectAllSrc(KFbxCriteria const &pCriteria);
            bool            IsConnectedSrc  (KFbxProperty const &pProperty) const;
            int             GetSrcCount     () const;
            int             GetSrcCount     (KFbxCriteria const &pCriteria) const;
            KFbxProperty    GetSrc          (int pIndex=0) const;
            KFbxProperty    GetSrc          (KFbxCriteria const &pCriteria,int pIndex=0) const;
            KFbxProperty    FindSrc         (KFbxCriteria const &pCriteria,const char *pName,int pStartIndex=0) const;

            bool            ConnectDst      (KFbxProperty const &pProperty,kFbxConnectionType pType=eFbxConnectionNone);
            bool            DisconnectDst   (KFbxProperty const &pProperty);
            bool            DisconnectAllDst();
            bool            DisconnectAllDst(KFbxCriteria const &pCriteria);
            bool            IsConnectedDst  (KFbxProperty const &pProperty) const;
            int             GetDstCount     () const;
            int             GetDstCount     (KFbxCriteria const &pCriteria) const;
            KFbxProperty    GetDst          (int pIndex=0) const;
            KFbxProperty    GetDst          (KFbxCriteria const &pCriteria,int pIndex=0) const;
            KFbxProperty    FindDst         (KFbxCriteria const &pCriteria,const char *pName,int pStartIndex=0) const;

            KFbxAnimCurve*  GetCurve(KFbxAnimLayer* pAnimLayer, const char* pName, const char* pChannel, bool pCreateAsNeeded);

        private:
            mutable KFbxPropertyHandle  mPropertyHandle;

            friend class KFbxObject;
        #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
    };

    typedef KFbxProperty* HKFbxProperty;

    template <class T> inline bool  KFbxSet( KFbxProperty &pProperty,T const &pValue, bool pCheckValueEquality = true ) { return pProperty.Set( &pValue,FbxTypeOf(pValue),pCheckValueEquality ); }
    template <class T> inline bool  KFbxGet( KFbxProperty const& pProperty,T &pValue ) { return pProperty.Get( &pValue,FbxTypeOf(pValue) ); }
    template <class T> inline T     KFbxGet( KFbxProperty const& pProperty)            { T pValue; pProperty.Get( &pValue,FbxTypeOf(pValue) ); return pValue; }

    template <class T> class KFbxTypedProperty : public KFbxProperty {
        public:


            inline KFbxTypedProperty() : KFbxProperty()                                         {}

            inline KFbxTypedProperty(KFbxProperty const &pProperty) : KFbxProperty(pProperty)   {}

            inline ~KFbxTypedProperty() {}



            inline KFbxProperty const & StaticInit(KFbxObject* pObject, char const* pName,eFbxPropertyFlags pFlags=eNO_FLAG)
            {
                *this = Create(pObject, GetFbxDataType(FbxTypeOf(*((T *)0))), pName, "");
                ModifyFlag(pFlags, true);
                return *this;
            }

            inline KFbxProperty const & StaticInit(KFbxObject* pObject, char const* pName,T const &pValue,bool pForceSet=true,eFbxPropertyFlags pFlags=eNO_FLAG)
            {
                bool lWasFound = false;
                *this = Create(pObject, GetFbxDataType(FbxTypeOf(*((T *)0))), pName, "", true, &lWasFound);

                if( pForceSet || !lWasFound )
                {
                    ModifyFlag(pFlags, true); // modify the flags before we set the value
                    Set(pValue,false);
                }

                return *this;
            }

            inline KFbxProperty const & StaticInit(KFbxObject* pObject, char const* pName, KFbxDataType const &pDataType,eFbxPropertyFlags pFlags=eNO_FLAG)
            {
                *this = Create(pObject, pDataType, pName, "");
                ModifyFlag(pFlags, true);
                return *this;
            }

            inline KFbxProperty const & StaticInit(KFbxObject* pObject, char const* pName, KFbxDataType const &pDataType,T const &pValue, bool pForceSet=true, eFbxPropertyFlags pFlags=eNO_FLAG)
            {
                bool lWasFound = false;
                *this = Create(pObject, pDataType, pName, "", true, &lWasFound);

                if( pForceSet || !lWasFound )
                {
                    ModifyFlag(pFlags, true); // modify the flags before we set the value
                    // since we will trigger callbacks in there!
                    Set(pValue,false);
                }

                return *this;
            }

            inline KFbxProperty const & StaticInit(KFbxProperty pCompound, char const* pName, KFbxDataType const &pDataType,T const &pValue, bool pForceSet=true, eFbxPropertyFlags pFlags=eNO_FLAG)
            {
                bool lWasFound = false;
                *this = Create(pCompound, pDataType, pName, "", true, &lWasFound);

                if( pForceSet || !lWasFound )
                {
                    ModifyFlag(pFlags, true); // modify the flags before we set the value
                    // since we will trigger callbacks in there!
                    Set(pValue,false);
                }

                return *this;
            }

        public:

            KFbxTypedProperty &operator=(T const &pValue)      { KFbxSet(*this,pValue); return *this; }

            bool     Set(T const &pValue, bool pCheckValueEquality )    { return KFbxSet(*this,pValue,pCheckValueEquality); }

            bool     Set(T const &pValue )  { return KFbxSet(*this,pValue,true); }

            T        Get() const            { T lValue; KFbxGet(*this,lValue); return lValue; }

        friend class KFbxObject;
    };

    // For use with deprecated type functions
    //KFBX_DLL KFbxDataType                       EUserPropertyTypeToDataType(KFbxProperty::EUserPropertyType);
    //KFBX_DLL KFbxProperty::EUserPropertyType        DataTypeToEUserPropertyType(const KFbxDataType &pDataType);

    template <> class KFbxTypedProperty<fbxReference*> : public KFbxProperty
    {
    public:

        inline KFbxTypedProperty() : KFbxProperty()
        {}

        inline KFbxTypedProperty(KFbxProperty const &pProperty)
            : KFbxProperty(pProperty)
        {}

        inline ~KFbxTypedProperty()
        {}

        inline KFbxProperty const & StaticInit(KFbxObject* pObject, char const* pName, eFbxPropertyFlags pFlags=eNO_FLAG)
        {
            *this = KFbxProperty::Create(pObject, GetFbxDataType(FbxTypeOf(*((fbxReference* *)0))), pName);
            ModifyFlag(pFlags, true);
            return *this;
        }

        inline KFbxProperty const & StaticInit(KFbxObject* pObject, char const* pName, fbxReference* const &pValue, bool pForceSet=true, eFbxPropertyFlags pFlags=eNO_FLAG)
        {
            bool lWasFound = false;
            *this = KFbxProperty::Create(pObject, GetFbxDataType(FbxTypeOf(*((fbxReference* *)0))), pName, "", true, &lWasFound);
            if( pForceSet || !lWasFound )
            {
                ModifyFlag(pFlags, true);
                Set(pValue,false);
            }
            return *this;
        }

        inline KFbxProperty const & StaticInit(KFbxObject* pObject, char const* pName, KFbxDataType const &pDataType, eFbxPropertyFlags pFlags=eNO_FLAG)
        {
            *this = KFbxProperty::Create(pObject, pDataType, pName, "");
//          KFbxProperty::StaticInit(pObject, pName, pDataType, "");
            ModifyFlag(pFlags, true);
            return *this;
        }

        inline KFbxProperty const & StaticInit(KFbxObject* pObject, char const* pName, KFbxDataType const &pDataType, fbxReference* const &pValue, bool pForceSet=true, eFbxPropertyFlags pFlags=eNO_FLAG)
        {
            bool lWasFound = false;
            *this = KFbxProperty::Create(pObject, pDataType, pName, "", true, &lWasFound);
            if( pForceSet || !lWasFound )
            {
                ModifyFlag(pFlags, true);
                Set(pValue,false);
            }
            return *this;
        }

    public:

        KFbxTypedProperty &operator=(fbxReference* const &pValue)
        {
            KFbxSet(*this,pValue);
            return *this;
        }

        inline bool Set(fbxReference* const &pValue ) { return Set(pValue, true); }

        bool Set(fbxReference* const &pValue, bool pCheckValueEquality )
        {
            KFbxObject* lValue = reinterpret_cast<KFbxObject*>(pValue);
            DisconnectAllSrcObject();
            if (lValue) {
                return ConnectSrcObject(lValue);
            }

            return false;
        }

        fbxReference* Get() const
        {
            KFbxObject* lValue = GetSrcObjectCount() > 0 ? GetSrcObject(0) : NULL;
            return reinterpret_cast<fbxReference*>(lValue);
        }

        friend class KFbxObject;
    };


    typedef KFbxTypedProperty<fbxBool1>         KFbxPropertyBool1;
    typedef KFbxTypedProperty<fbxInteger1>      KFbxPropertyInteger1;
    typedef KFbxTypedProperty<fbxDouble1>       KFbxPropertyDouble1;
    typedef KFbxTypedProperty<fbxDouble3>       KFbxPropertyDouble3;
    typedef KFbxTypedProperty<fbxDouble4>       KFbxPropertyDouble4;
    typedef KFbxTypedProperty<fbxString>        KFbxPropertyString;
    typedef KFbxTypedProperty<fbxReference*>    KFbxPropertyReference;

    enum eFbxConnectEventType {
        eFbxConnectRequest,
        eFbxConnect,
        eFbxConnected,
        eFbxDisconnectRequest,
        eFbxDisconnect,
        eFbxDisconnected
    };

    enum eFbxConnectEventDirection {
        eConnectEventSrc,
        eConnectEventDst
    };

    class KFBX_DLL KFbxConnectEvent
    {
        public:

            inline KFbxConnectEvent(eFbxConnectEventType pType,eFbxConnectEventDirection pDir,KFbxProperty *pSrc,KFbxProperty *pDst)
                : mType(pType)
                , mDirection(pDir)
                , mSrc(pSrc)
                , mDst(pDst)
            {
            }

        public:

            inline eFbxConnectEventType GetType() const { return mType; }

            inline eFbxConnectEventDirection GetDirection() const { return mDirection; }

            inline KFbxProperty &GetSrc()  const    { return *mSrc;  }

            inline KFbxProperty &GetDst()  const    { return *mDst;  }

            template < class T > inline T*  GetSrcIfObject(T const *pFBX_TYPE) const    { return mSrc->IsRoot() ? KFbxCast<T>(mSrc->GetFbxObject()) : (T*)0; }

            template < class T > inline T*  GetDstIfObject(T const *pFBX_TYPE) const    { return mDst->IsRoot() ? KFbxCast<T>(mDst->GetFbxObject()) : (T*)0; }

        private:
            eFbxConnectEventType        mType;
            eFbxConnectEventDirection   mDirection;
            KFbxProperty*               mSrc;
            KFbxProperty*               mDst;
    };



#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXPROPERTY_H