#include <fbxpropertypage.h>

Class Description

Definition at line 421 of file fbxpropertypage.h.

Public Types
enum	EValueIndex { eValueMin, eValueSoftMin, eValueMax, eValueSoftMax, eValueCount }

Public Member Functions
	FBXSDK_FRIEND_NEW ()

void	Destroy ()

template<class T >
T *	GetPropertyItem (const T pItemType, FbxInt pIndex, FbxPropertyPage *pFoundIn=0) const

template<class T >
T *	ChangePropertyItemState (const T *pItemType, FbxInt pIndex, FbxPropertyFlags::EInheritType pInheritType)

template<class T >
FbxPropertyPage *	GetFirstPropertyItem (FbxInt pId, const T *pItem) const

const char *	GetName (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT)

const char *	GetLabel (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT)

bool	SetLabel (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT, const char *pLabel="")

void *	GetUserData (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT)

bool	SetUserData (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT, const void *pUserData=0)

int	GetUserTag (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT)

bool	SetUserTag (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT, int pUserTag=0)

EFbxType	GetType (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT) const

FbxInt	GetParent (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT) const

FbxPropertyPage *	GetTypeInfo (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT)

FbxInt	Add (FbxInt pParentId, const char *pName, EFbxType pType)

FbxInt	Add (FbxInt pParentId, const char pName, FbxPropertyPage pTypeInfo)

bool	Reparent (FbxInt, FbxInt)

bool	IsChildOf (FbxInt pId, FbxInt pParentId) const

bool	IsDescendentOf (FbxInt pId, FbxInt pAncestorId) const

FbxInt	GetChild (FbxInt pParentId=FBXSDK_PROPERTY_ID_ROOT) const
	Retrieves the first child property id of a specified property id. More...

FbxInt	GetSibling (FbxInt pId) const
	Retrieves the next sibling property id of a specified property id. More...

FbxInt	GetFirstDescendent (FbxInt pAnscestorId=FBXSDK_PROPERTY_ID_ROOT) const
	Retrieves the first descendent property id of a specified property id. More...

FbxInt	GetNextDescendent (FbxInt pAnscestorId, FbxInt pId) const
	Retrieves the next descendent property id of a specified property id, with given a descendent property id. More...

FbxInt	FastFind (FbxInt pId, const char pName, FbxPropertyPage pTypeInfo, bool pCaseSensitive)

FbxInt	Find (FbxInt pId, const char pName, FbxPropertyPage pTypeInfo, bool pCaseSensitive, const char *pChildrenSeparators)

int	AddEnumValue (FbxInt pId, const char *pStringValue)

void	InsertEnumValue (FbxInt pId, int pIndex, const char *pStringValue)

int	GetEnumCount (FbxInt pId)

void	SetEnumValue (FbxInt pId, int pIndex, const char *pStringValue)

void	RemoveEnumValue (FbxInt pId, int pIndex)

char *	GetEnumValue (FbxInt pId, int pIndex)

void	ClearConnectCache (FbxInt pId)

void	WipeAllConnections (FbxInt pId)

bool	ConnectSrc (FbxInt pDstId, FbxPropertyPage *pSrcPage, FbxInt pSrcId, FbxConnection::EType pType)

bool	DisconnectSrc (FbxInt pDstId, FbxPropertyPage *pSrcPage, FbxInt pSrcId)

bool	IsConnectedSrc (FbxInt pDstId, FbxPropertyPage *pSrcPage, FbxInt pSrcId)

int	GetSrcCount (FbxInt pId, FbxConnectionPointFilter *pFilter)

bool	GetSrc (FbxInt pId, int pIndex, FbxConnectionPointFilter pFilter, FbxPropertyPage pSrcPage, FbxInt pSrcId)

bool	ConnectDst (FbxInt pSrcId, FbxPropertyPage *pDstPage, FbxInt pDstId, FbxConnection::EType pType)

bool	DisconnectDst (FbxInt pSrcId, FbxPropertyPage *pDstPage, FbxInt pDstId)

bool	IsConnectedDst (FbxInt pSrcId, FbxPropertyPage *pDstPage, FbxInt pDstId)

int	GetDstCount (FbxInt pId, FbxConnectionPointFilter *pFilter)

bool	GetDst (FbxInt pId, int pIndex, FbxConnectionPointFilter pFilter, FbxPropertyPage pDstPage, FbxInt pDstId)

bool	HasMinMax (FbxInt pId, FbxPropertyInfo::EValueIndex pValueId) const

bool	GetMinMax (FbxInt pId, FbxPropertyInfo::EValueIndex pValueId, void *pValue, EFbxType pValueType)

bool	SetMinMax (FbxInt pId, FbxPropertyInfo::EValueIndex pValueId, const void *pValue, EFbxType pValueType)

bool	Get (FbxInt pId, void *pValue, EFbxType pValueType)

bool	Set (FbxInt pId, const void *pValue, EFbxType pValueType, bool pCheckValueEquality)

FbxPropertyFlags::EInheritType	GetValueInherit (FbxInt pId, bool pCheckInstanceOf) const

bool	SetValueInherit (FbxInt pId, FbxPropertyFlags::EInheritType pType)

bool	GetDefaultValue (FbxInt pId, void *pValue, EFbxType pValueType) const

template<class T >
bool	Set (FbxInt pId, const T &pValue)

template<class T >
T	Get (FbxInt pId, const T *pFBX_TYPE)

void	SetDataPtr (void *pDataPtr)

void *	GetDataPtr () const

void	PushPropertiesToParentInstance ()

const FbxPropertyPage *	GetInstanceOf () const

FbxPropertyPage *	GetInstanceOf ()

const FbxArray < FbxPropertyPage * > &	GetInstances () const

FbxArray< FbxPropertyPage * > &	GetInstances ()

FbxPropertyFlags::EFlags	GetFlags (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT) const

bool	ModifyFlags (FbxInt pId=FBXSDK_PROPERTY_ID_ROOT, FbxPropertyFlags::EFlags pFlags=FbxPropertyFlags::eNone, bool pValue=true, bool pCheckFlagEquality=true)

FbxPropertyFlags::EInheritType	GetFlagsInheritType (FbxPropertyFlags::EFlags pFlags, bool pCheckInstanceOf, FbxInt pId=FBXSDK_PROPERTY_ID_ROOT) const

bool	SetFlagsInheritType (FbxPropertyFlags::EInheritType pInheritType, FbxPropertyFlags::EFlags pFlags, FbxInt pId=FBXSDK_PROPERTY_ID_ROOT)

void	BeginCreateOrFindProperty ()

void	EndCreateOrFindProperty ()

Static Public Member Functions
static FbxPropertyPage *	Create (FbxPropertyPage *pInstanceOf=0)

static FbxPropertyPage *	Create (const char pName, FbxPropertyPage pTypeInfo)

static FbxPropertyPage *	Create (const char *pName, EFbxType pType=eFbxUndefined)

Protected Member Functions
	FbxPropertyPage (FbxPropertyPage *pInstanceOf=0)

	FbxPropertyPage (const char *pName, EFbxType pType)

	FbxPropertyPage (const char pName, FbxPropertyPage pTypeInfo)

	~FbxPropertyPage ()

bool	Is (FbxPropertyPage *pPage)

Friends
class	FbxPropertyHandle

Member Enumeration Documentation

enum EValueIndex

Enumerator
eValueMin
eValueSoftMin
eValueMax
eValueSoftMax
eValueCount

Definition at line 1080 of file fbxpropertypage.h.

1080 { eValueMin,eValueSoftMin,eValueMax,eValueSoftMax,eValueCount };

FbxPropertyPage::eValueSoftMax

Definition: fbxpropertypage.h:1080

FbxPropertyPage::eValueMax

Definition: fbxpropertypage.h:1080

FbxPropertyPage::eValueCount

Definition: fbxpropertypage.h:1080

FbxPropertyPage::eValueMin

Definition: fbxpropertypage.h:1080

FbxPropertyPage::eValueSoftMin

Definition: fbxpropertypage.h:1080

Constructor & Destructor Documentation

FbxPropertyPage ( FbxPropertyPage * pInstanceOf = 0 )

inlineprotected

Definition at line 1442 of file fbxpropertypage.h.

         : mInstanceOf(0)
         , mDataPtr(0)
         , mPropNextId(0)
     {
         mEntryMap.Reserve(32);
         mNameMap.mFirst = 0;
 
         // instances don't need to create a root property
         if( !pInstanceOf )
         {
             mPropNextId = FbxNew< FbxPropertyIdGenerator >();
             mPropNextId->IncRef();
 
             // First item is the root information
             Add(FBXSDK_PROPERTY_ID_NULL,"",eFbxUndefined);
         }
 
         // Hook the instances
         // ------------------------
         mInstanceOf = pInstanceOf;
         if (mInstanceOf) {
             mInstanceOf->mInstances.Add(this);
 
             mPropNextId = mInstanceOf->mPropNextId;
             mPropNextId->IncRef();
         }
     }

FbxPropertyPage	(	const char *	pName,
		EFbxType	pType
	)

inlineprotected

Definition at line 1470 of file fbxpropertypage.h.

         : mInstanceOf(0)
         , mDataPtr(0)
         , mPropNextId(0)
     {
         mEntryMap.Reserve(32);
         mNameMap.mFirst = 0;
 
         mPropNextId = FbxNew< FbxPropertyIdGenerator >();
         mPropNextId->IncRef();
 
         // First item is the root information
         Add(FBXSDK_PROPERTY_ID_NULL,pName,pType);
     }

FbxPropertyPage	(	const char *	pName,
		FbxPropertyPage *	pTypeInfo
	)

inlineprotected

Definition at line 1484 of file fbxpropertypage.h.

         : mInstanceOf(0)
         , mDataPtr(0)
         , mPropNextId(0)
     {
         mEntryMap.Reserve(32);
         mNameMap.mFirst = 0;
 
         mPropNextId = FbxNew< FbxPropertyIdGenerator >();
         mPropNextId->IncRef();
 
         // First item is the root information
         Add(FBXSDK_PROPERTY_ID_NULL,pName,pTypeInfo);
     }

~FbxPropertyPage ( )

inlineprotected

Definition at line 1498 of file fbxpropertypage.h.

     {
         // Propagate our property entries.
         int i = 0, j = 0;
         for( i = 0; i < mInstances.GetCount(); ++i )
         {
             for( j = 0; j < GetPropertyEntryCount(); ++j )
             {
                 if( mInstances[i]->ChangePropertyEntryState((FbxInt)j, FbxPropertyFlags::eOverride) )
                 {
                     // Clone the info and values. Don't clone the connections,
                     // since they aren't propagated.
                     mInstances[i]->ChangePropertyItemState( FBX_TYPE(FbxPropertyInfo), (FbxInt)j, FbxPropertyFlags::eOverride );
                     mInstances[i]->ChangePropertyItemState( FBX_TYPE(FbxPropertyValue), (FbxInt)j, FbxPropertyFlags::eOverride );
 
                     // Since all entries have their own flags, just override the ones in the instance.
                     mInstances[i]->SetFlagsInheritType(FbxPropertyFlags::eOverride, FbxPropertyFlags::eAllFlags, (FbxInt)j );
                 }
             }
 
             // Instances become their own copies.
             mInstances[i]->mInstanceOf = NULL;
         }
 
         FbxMapDestroy(mEntryMap);
 
         if (mInstanceOf) {
             int lIndex = mInstanceOf->mInstances.Find(this);
             mInstanceOf->mInstances.SetAt(lIndex, mInstanceOf->mInstances[mInstanceOf->mInstances.GetCount()-1]);
             mInstanceOf->mInstances.RemoveAt(mInstanceOf->mInstances.GetCount()-1);
 
             //mInstanceOf->mInstances.RemoveIt(this);
         }
 
         mPropNextId->DecRef();
         mPropNextId = NULL;
 
         mInstanceOf = NULL;
         mInstances.Clear();
     }

Member Function Documentation

FBXSDK_FRIEND_NEW ( )

static FbxPropertyPage* Create ( FbxPropertyPage * pInstanceOf = 0 )

inlinestatic

Definition at line 426 of file fbxpropertypage.h.

426 { return FbxNew< FbxPropertyPage >(pInstanceOf); }

static FbxPropertyPage* Create	(	const char *	pName,
		FbxPropertyPage *	pTypeInfo
	)

inlinestatic

Definition at line 427 of file fbxpropertypage.h.

427 { return FbxNew< FbxPropertyPage >(pName,pTypeInfo); }

static FbxPropertyPage* Create	(	const char *	pName,
		EFbxType	pType = `eFbxUndefined`
	)

inlinestatic

Definition at line 428 of file fbxpropertypage.h.

428 { return FbxNew< FbxPropertyPage >(pName,pType); }

void Destroy ( )

inline

Definition at line 429 of file fbxpropertypage.h.

429 { FbxDelete(this); }

FbxDelete

void FbxDelete(T *p)

Definition: fbxnew.h:341

T* GetPropertyItem	(	const T *	pItemType,
		FbxInt	pIndex,
		FbxPropertyPage **	pFoundIn = `0`
	)		const

inline

Definition at line 431 of file fbxpropertypage.h.

     {
       FbxPropertyPage*     lReferencePage = 0;
       FbxPropertyEntry*    lReferenceEntry = GetPropertyEntry(pIndex,&lReferencePage);
         if (pFoundIn) *pFoundIn = 0;
         if (lReferenceEntry) {
           T* lItem = lReferenceEntry->Get( FBX_TYPE(T) );
             if (lItem) {
                 if (pFoundIn) *pFoundIn = lReferencePage;
                 return lItem;
             } else {
                 return lReferencePage->mInstanceOf ? lReferencePage->mInstanceOf->GetPropertyItem(pItemType,pIndex,pFoundIn) : 0 ;
             }
         }
         return 0;
     }

T* ChangePropertyItemState	(	const T *	pItemType,
		FbxInt	pIndex,
		FbxPropertyFlags::EInheritType	pInheritType
	)

inline

Definition at line 448 of file fbxpropertypage.h.

     {
         FbxPropertyPage*    lReferencePage = NULL;
         T*                  lItem = GetPropertyItem(pItemType, pIndex, &lReferencePage);
         if( pInheritType == FbxPropertyFlags::eOverride )
         {
             if( lReferencePage == this )
             {
                 return lItem;
             }
             else if( lItem )
             {
                 FbxPropertyEntry* lEntry = ChangePropertyEntryState(pIndex, FbxPropertyFlags::eOverride);
                 lEntry->Set(lItem->Clone(this));
                 return lEntry->Get(FBX_TYPE(T));
             }
         }
         else
         {
             // can't inherit entries that were created on our page.
             bool lOwnEntry = !mInstanceOf || (mInstanceOf->GetPropertyItem(pItemType, pIndex) == NULL);
             if( lOwnEntry && FbxPropertyFlags::eInherit == pInheritType) return 0;
 
             if( lItem && (lReferencePage == this) )
             {
                 FbxPropertyEntry* lEntry = GetPropertyEntry(pIndex);
                 lEntry->Set((T*)0);
                 if( lEntry->IsEmpty() )
                 {
                     ChangePropertyEntryState(pIndex, FbxPropertyFlags::eInherit);
                 }
             }
             return 0;
         }
         return 0;
     }

FbxPropertyPage* GetFirstPropertyItem	(	FbxInt	pId,
		const T *	pItem
	)		const

inline

Definition at line 485 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lReferencePage = NULL;
         GetPropertyItem(FBX_TYPE(T), pId, &lReferencePage);
         if( lReferencePage && lReferencePage->mInstanceOf )
         {
             FbxPropertyPage* lReferencePage2 = lReferencePage->mInstanceOf->GetFirstPropertyItem(pId, pItem);
             return lReferencePage2 ? lReferencePage2 : lReferencePage;
         }
         return lReferencePage;
     }

const char* GetName ( FbxInt pId = FBXSDK_PROPERTY_ID_ROOT )

inline

Definition at line 497 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? ((const char*)lPropertyInfo->GetName()) : "";
     }

const char* GetLabel ( FbxInt pId = FBXSDK_PROPERTY_ID_ROOT )

inline

Definition at line 503 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? ((const char*)lPropertyInfo->GetLabel()) : "";
     }

bool SetLabel	(	FbxInt	pId = `FBXSDK_PROPERTY_ID_ROOT`,
		const char *	pLabel = `""`
	)

inline

Definition at line 509 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) {
             lPropertyInfo->SetLabel(pLabel);
             return true;
         } else {
             return false;
         }
     }

void* GetUserData ( FbxInt pId = FBXSDK_PROPERTY_ID_ROOT )

inline

Definition at line 521 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetUserData() : 0;
     }

bool SetUserData	(	FbxInt	pId = `FBXSDK_PROPERTY_ID_ROOT`,
		const void *	pUserData = `0`
	)

inline

Definition at line 527 of file fbxpropertypage.h.

     {
       FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
           // Don't make it writeable (Keep it shared)
           if (lPropertyInfo) {
               lPropertyInfo->SetUserData(pUserData);
               return true;
           } else {
               return false;
           }
     }

int GetUserTag ( FbxInt pId = FBXSDK_PROPERTY_ID_ROOT )

inline

Definition at line 539 of file fbxpropertypage.h.

     {
       FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetUserTag() : 0;
     }

bool SetUserTag	(	FbxInt	pId = `FBXSDK_PROPERTY_ID_ROOT`,
		int	pUserTag = `0`
	)

inline

Definition at line 545 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
           // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) {
             lPropertyInfo->SetUserTag(pUserTag);
             return true;
         } else {
             return false;
         }
     }

EFbxType GetType ( FbxInt pId = FBXSDK_PROPERTY_ID_ROOT ) const

inline

Definition at line 557 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetType() : eFbxUndefined;
     }

FbxInt GetParent ( FbxInt pId = FBXSDK_PROPERTY_ID_ROOT ) const

inline

Definition at line 563 of file fbxpropertypage.h.

     {
         FbxPropertyEntry* lPropertyEntry = GetPropertyEntry( pId );
         return lPropertyEntry ? lPropertyEntry->GetParentId() : FBXSDK_PROPERTY_ID_NULL;
     }

FbxPropertyPage* GetTypeInfo ( FbxInt pId = FBXSDK_PROPERTY_ID_ROOT )

inline

Definition at line 569 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetTypeInfo() : 0;
     }

FbxInt Add	(	FbxInt	pParentId,
		const char *	pName,
		EFbxType	pType
	)

inline

Definition at line 574 of file fbxpropertypage.h.

     {
         return Add(pParentId,FbxPropertyInfo::Create(pName,pType),FbxPropertyValue::Create(0,pType),0);
     }

FbxInt Add	(	FbxInt	pParentId,
		const char *	pName,
		FbxPropertyPage *	pTypeInfo
	)

inline

Definition at line 578 of file fbxpropertypage.h.

     {
         return Add(pParentId,FbxPropertyInfo::Create(pName,pTypeInfo),FbxPropertyValue::Create(0,pTypeInfo->GetType()),0);
     }

bool Reparent	(	FbxInt	,
		FbxInt
	)

inline

Definition at line 583 of file fbxpropertypage.h.

     {
         // Not implemented.
         /*
         if( GetParent(pChildId) != pNewParentId  && pChildId < mEntries.GetCount() )
         {
             FbxPropertyEntry* lChildEntry = mEntries[pChildId];
             lChildEntry->mParentId = pNewParentId;
 
             //@@@@@ TODO: propagate to instances
 
             return true;
         }
         */
         return false;
     }

bool IsChildOf	(	FbxInt	pId,
		FbxInt	pParentId
	)		const

inline

Definition at line 600 of file fbxpropertypage.h.

     {
         return GetParent(pId)==pParentId;
 
     }

bool IsDescendentOf	(	FbxInt	pId,
		FbxInt	pAncestorId
	)		const

inline

Definition at line 606 of file fbxpropertypage.h.

     {
         if (pAncestorId>0) {
             FbxInt lParentId = GetParent(pId);
             while (lParentId != FBXSDK_PROPERTY_ID_NULL ) {
                 if (lParentId==pAncestorId) {
                     return true;
                 }
                 lParentId = GetParent(lParentId);
             }
             return false;
         } else {
             return true;
         }
 
     }

FbxInt GetChild ( FbxInt pParentId = FBXSDK_PROPERTY_ID_ROOT ) const

inline

Retrieves the first child property id of a specified property id.

Parameters

pParentId The specified property id

Returns: the first child property id

Definition at line 629 of file fbxpropertypage.h.

     {
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
             if (pParentId!=FBXSDK_PROPERTY_ID_NULL) {
             FbxInt       lId        = GetMinimumPropertyId(pParentId);
             FbxInt       lParentId  = GetParent(lId);
             const FbxInt lLastId    = GetPropertyEntryCount();
 
             while (lId<lLastId && lParentId!=pParentId) lParentId=GetParent(++lId);
             ret0 = lId<lLastId ? lId : FBXSDK_PROPERTY_ID_NULL;
         } else {
             ret0 = FBXSDK_PROPERTY_ID_NULL;
         }
     #endif
         FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
         if (pParentId != FBXSDK_PROPERTY_ID_NULL)
         {
             FbxPropertyEntry* lEntry;
             FbxInt lId = pParentId;
             do 
             {
                 lId = GetMinimumPropertyIdAndEntry(lId, &lEntry);
             } while (lId != FBXSDK_PROPERTY_ID_NULL && lEntry->GetParentId() != pParentId);
             ret1 = lId;
         }
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FBX_ASSERT(ret0==ret1);
     #endif
         return ret1;
     }

FbxInt GetSibling ( FbxInt pId ) const

inline

Retrieves the next sibling property id of a specified property id.

Parameters

pId	The specified property id

Returns: the next sibling property id

Definition at line 665 of file fbxpropertypage.h.

     {
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FbxInt pIdBackup = pId;
         FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
         if (pId!=FBXSDK_PROPERTY_ID_NULL) {
             FbxInt       lReferenceParentId = GetParent(pId);
             FbxInt       lParentId          = GetParent(++pId);
             const FbxInt lLastId            = GetPropertyEntryCount();
 
             while (pId<lLastId && lReferenceParentId!=FBXSDK_PROPERTY_ID_NULL && lParentId!=lReferenceParentId)
                 lParentId=GetParent(++pId);
             ret0 = pId<lLastId ? pId : FBXSDK_PROPERTY_ID_NULL;
         } else {
             ret0 = FBXSDK_PROPERTY_ID_NULL;
         }
         pId = pIdBackup;
     #endif
         FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
         if (pId != FBXSDK_PROPERTY_ID_NULL)
         {
             FbxInt lReferenceParentId = GetParent(pId);
 
             if (lReferenceParentId != FBXSDK_PROPERTY_ID_NULL)
             {
                 FbxPropertyEntry *lEntry;
                 do 
                 {
                     pId = GetMinimumPropertyIdAndEntry(pId, &lEntry);
                 } while (pId != FBXSDK_PROPERTY_ID_NULL && lEntry->GetParentId() != lReferenceParentId);
 
                 ret1 = pId;
             }
         }
 
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FBX_ASSERT(ret0==ret1);
     #endif
         return ret1;
     }

FbxInt GetFirstDescendent ( FbxInt pAnscestorId = FBXSDK_PROPERTY_ID_ROOT ) const

inline

Retrieves the first descendent property id of a specified property id.

Parameters

pAnscestorId The specified property id

Returns: the first descendent property id

Definition at line 710 of file fbxpropertypage.h.

     {
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
         if (pAnscestorId!=FBXSDK_PROPERTY_ID_NULL) {
             FbxInt       lId        = GetMinimumPropertyId(pAnscestorId);
             FbxInt       lParentId  = GetParent(lId);
             const FbxInt lLastId    = GetPropertyEntryCount();
 
             while (lId<lLastId) {
                 if( lParentId!=FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(lId,pAnscestorId) )
                 {
                     ret0 = lId;
                     break;
                 }
                 lParentId = GetParent(++lId);
             }
         }
     #endif
         FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
         FbxInt lId = pAnscestorId;
         FbxPropertyEntry* lEntry;
         if (pAnscestorId != FBXSDK_PROPERTY_ID_NULL)
         {
             for(;;)
             {
                 lId  = GetMinimumPropertyIdAndEntry(lId, &lEntry);
                 if (lId == FBXSDK_PROPERTY_ID_NULL)
                     break;
                 if(lEntry->GetParentId() != FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(lId, pAnscestorId))
                 {
                     ret1 = lId;
                     break;
                 }
             }
         }
 
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FBX_ASSERT(ret0==ret1);
     #endif
         return ret1;
     }

FbxInt GetNextDescendent	(	FbxInt	pAnscestorId,
		FbxInt	pId
	)		const

inline

Retrieves the next descendent property id of a specified property id, with given a descendent property id.

Parameters

pAnscestorId	The specified property id
pId	The descendent property id

Returns: the next descendent property id

Definition at line 758 of file fbxpropertypage.h.

     {
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FbxInt pIdBackup = pId;
         FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
         if (pId!=FBXSDK_PROPERTY_ID_NULL) {
             FbxInt       lParentId  = GetParent(++pId);
             const FbxInt lLastId    = GetPropertyEntryCount();
 
             while (pId<lLastId) {
                 // GetParent returns null when the given id isn't in our page,
                 // or our ancestor's page.
                 if( lParentId != FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(pId, pAnscestorId) )
                 {
                     ret0 = pId;
                     break;
                 }
 
                 lParentId = GetParent(++pId);
             }
         }
         
         pId = pIdBackup;
     #endif
         FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
         if (pId != FBXSDK_PROPERTY_ID_NULL)
         {
             FbxPropertyEntry* lEntry;
             for(;;)
             {
                 pId = GetMinimumPropertyIdAndEntry(pId, &lEntry);
                 if (pId == FBXSDK_PROPERTY_ID_NULL)
                     break;
                 if(lEntry->GetParentId() != FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(pId, pAnscestorId) )
                 {
                     ret1 = pId;
                     break;
                 }
             }
 
         }
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FBX_ASSERT(ret0==ret1);
     #endif
         return ret1;
 
     }

FbxInt FastFind	(	FbxInt	pId,
		const char *	pName,
		FbxPropertyPage *	pTypeInfo,
		bool	pCaseSensitive
	)

inline

Definition at line 806 of file fbxpropertypage.h.

     {
         FbxInt lId = FBXSDK_PROPERTY_ID_NULL;
 
         bool lSlowQuery = true;
         if( mNameMap.mSecond.GetSize() > 0 )
         {
             lSlowQuery = false;
             // try to use the map if we've got it
             NameMap::RecordType* lIterator = mNameMap.mSecond.Find( FbxNameMapKey( pId, pName ) );
             if( !lIterator )
             {
                 lId = FBXSDK_PROPERTY_ID_NULL;
             }
             else
             {
                 lId = lIterator->GetValue();
                 if (lId != FBXSDK_PROPERTY_ID_NULL && pTypeInfo)
                 {
                     lSlowQuery = true;
 
                     // Try to match types.
                     // If they are mismatched, fall back to the slow query,
                     // since we might have multiple property with the same name but different types
                     FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo), lId );
                     if (lPropertyInfo)
                     {
                         FbxPropertyPage* lTypeInfo2 = lPropertyInfo->GetTypeInfo();
                         if ( lTypeInfo2 && lTypeInfo2->Is(pTypeInfo) )
                         {
                             lSlowQuery = false;
                         }
                     }
                 }
             }
         }
 
         if (!lSlowQuery)
             return lId;
 
         // fall back if there's no map or we got one with a different type
 
         lId = GetChild(pId);
         FbxStringSymbol lSearchSymbol( pName );
         while( lId != FBXSDK_PROPERTY_ID_NULL ) {
             FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo), lId );
             if  ( (!pTypeInfo || lPropertyInfo->GetTypeInfo()->Is(pTypeInfo)) &&
                 ((!pCaseSensitive && FBXSDK_stricmp(lPropertyInfo->GetName(),pName)==0) ||
                 (pCaseSensitive && lPropertyInfo->GetName() == lSearchSymbol)) ) {
                 return lId;
             }
             lId = GetSibling(lId);
         }
 
         return FBXSDK_PROPERTY_ID_NULL;
     }

FbxInt Find	(	FbxInt	pId,
		const char *	pName,
		FbxPropertyPage *	pTypeInfo,
		bool	pCaseSensitive,
		const char *	pChildrenSeparators
	)

inline

Definition at line 863 of file fbxpropertypage.h.

     {
         if (pChildrenSeparators) 
         {
             FbxInt  lId;
             size_t  lFoundIndex = strcspn(pName,pChildrenSeparators);
 
             // Strip the first part of the name and search
             if (lFoundIndex<strlen(pName)) 
             {
                 FbxString   pRootName;
                 pRootName.Append(pName,lFoundIndex);
                 lId = FastFind(pId,pRootName.Buffer(),NULL,pCaseSensitive);
                 return lId != FBXSDK_PROPERTY_ID_NULL ? Find(lId,pName+lFoundIndex+1,pTypeInfo,pCaseSensitive,pChildrenSeparators) : lId;
             } else {
                 return FastFind(pId,pName,pTypeInfo,pCaseSensitive);
             }
         } else {
             return FastFind(pId,pName,pTypeInfo,pCaseSensitive);
         }
     }

int AddEnumValue	(	FbxInt	pId,
		const char *	pStringValue
	)

inline

Definition at line 886 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         return lPropertyInfo ? lPropertyInfo->AddEnumValue(pStringValue) : - 1;
     }

void InsertEnumValue	(	FbxInt	pId,
		int	pIndex,
		const char *	pStringValue
	)

inline

Definition at line 893 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) lPropertyInfo->InsertEnumValue(pIndex,pStringValue);
     }

int GetEnumCount ( FbxInt pId )

inline

Definition at line 900 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         return lPropertyInfo ? lPropertyInfo->GetEnumCount() : 0;
     }

void SetEnumValue	(	FbxInt	pId,
		int	pIndex,
		const char *	pStringValue
	)

inline

Definition at line 907 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) lPropertyInfo->SetEnumValue(pIndex,pStringValue);
     }

void RemoveEnumValue	(	FbxInt	pId,
		int	pIndex
	)

inline

Definition at line 914 of file fbxpropertypage.h.

     {
          FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) lPropertyInfo->RemoveEnumValue(pIndex);
     }

char* GetEnumValue	(	FbxInt	pId,
		int	pIndex
	)

inline

Definition at line 921 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetEnumValue(pIndex) : (char*)"";
     }

void ClearConnectCache ( FbxInt pId )

inline

Definition at line 929 of file fbxpropertypage.h.

     {
         FbxPropertyPage*     lReferencePage = 0;
         FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are not considered propagated so
         // make sure that we own the FbxPropertyConnect objects
         if (lPropertyConnect) {
             lPropertyConnect->ClearConnectCache();
         }
     }

void WipeAllConnections ( FbxInt pId )

inline

Definition at line 941 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage = 0;
         FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         if (lPropertyConnect) {
             lPropertyConnect->WipeAllConnections();
         }
     }

bool ConnectSrc	(	FbxInt	pDstId,
		FbxPropertyPage *	pSrcPage,
		FbxInt	pSrcId,
		FbxConnection::EType	pType
	)

inline

Definition at line 951 of file fbxpropertypage.h.

     {
         FbxPropertyEntry*    lDstEntry = ChangePropertyEntryState(pDstId,FbxPropertyFlags::eOverride);
         FbxPropertyEntry*    lSrcEntry = pSrcPage->ChangePropertyEntryState(pSrcId,FbxPropertyFlags::eOverride);
         FbxPropertyConnect*  lDstConnect= lDstEntry->Get( FBX_TYPE(FbxPropertyConnect) );
         FbxPropertyConnect*  lSrcConnect= lSrcEntry->Get( FBX_TYPE(FbxPropertyConnect) );
 
         // Make sure we have a connection point on both sides of the connection
         if (!lDstConnect) {
             lDstConnect = FbxPropertyConnect::Create( this,pDstId );
             lDstEntry->Set( lDstConnect );
         }
         if (!lSrcConnect) {
             lSrcConnect = FbxPropertyConnect::Create( pSrcPage,pSrcId );
             lSrcEntry->Set( lSrcConnect );
         }
 
         // Must @@@@@@@ Propagate to inherited children
         return lDstConnect->ConnectSrc(lSrcConnect,pType);
 
     }

bool DisconnectSrc	(	FbxInt	pDstId,
		FbxPropertyPage *	pSrcPage,
		FbxInt	pSrcId
	)

inline

Definition at line 973 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lDstReferencePage   = 0;
         FbxPropertyConnect* lDstConnect         = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pDstId,&lDstReferencePage );
         FbxPropertyPage*        lSrcReferencePage   = 0;
         FbxPropertyConnect* lSrcConnect         = pSrcPage->GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pSrcId,&lSrcReferencePage );
 
         // Make sure we have a connection point on both sides of the connection
         if (lDstConnect && lSrcConnect && lDstReferencePage==this && lSrcReferencePage==pSrcPage) {
             // Must @@@@@@@ Remove unused connections
             return lDstConnect->DisconnectSrc(lSrcConnect);
         }
         return false;
     }

bool IsConnectedSrc	(	FbxInt	pDstId,
		FbxPropertyPage *	pSrcPage,
		FbxInt	pSrcId
	)

inline

Definition at line 988 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lDstReferencePage   = 0;
         FbxPropertyConnect* lDstConnect         = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pDstId,&lDstReferencePage );
         FbxPropertyPage*        lSrcReferencePage   = 0;
         FbxPropertyConnect* lSrcConnect         = pSrcPage->GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pSrcId,&lSrcReferencePage );
 
         // Make sure we have a connection point on both sides of the connection
         if (lDstConnect && lSrcConnect && lDstReferencePage==this && lSrcReferencePage==pSrcPage) {
             // Must @@@@@@@ Remove unused connections
             return lDstConnect->IsConnectedSrc(lSrcConnect);
         }
         return false;
     }

int GetSrcCount	(	FbxInt	pId,
		FbxConnectionPointFilter *	pFilter
	)

inline

Definition at line 1003 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage      = 0;
         FbxPropertyConnect* lPropertyConnect    = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are not considered propagated so
         // make sure that we own the FbxPropertyConnect objects
         return (lPropertyConnect && lReferencePage==this) ? lPropertyConnect->GetSrcCount(pFilter) : 0;
     }

bool GetSrc	(	FbxInt	pId,
		int	pIndex,
		FbxConnectionPointFilter *	pFilter,
		FbxPropertyPage **	pSrcPage,
		FbxInt *	pSrcId
	)

inline

Definition at line 1013 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage      = 0;
         FbxPropertyConnect* lPropertyConnect    = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are always overridden
         // make sure that we own the FbxPropertyConnect Item
         if (lPropertyConnect && lReferencePage==this) 
         {
             FbxPropertyConnect* lSrc = lPropertyConnect->GetSrc(pFilter,pIndex);
             if (lSrc) 
             {
                 if (pSrcPage)   *pSrcPage = lSrc->GetPage();
                 if (pSrcId)     *pSrcId   = lSrc->GetPropertyId();
                 return true;
             }
         }
         return false;
     }

bool ConnectDst	(	FbxInt	pSrcId,
		FbxPropertyPage *	pDstPage,
		FbxInt	pDstId,
		FbxConnection::EType	pType
	)

inline

Definition at line 1033 of file fbxpropertypage.h.

     {
         return pDstPage->ConnectSrc(pDstId,this,pSrcId,pType);
     }

bool DisconnectDst	(	FbxInt	pSrcId,
		FbxPropertyPage *	pDstPage,
		FbxInt	pDstId
	)

inline

Definition at line 1038 of file fbxpropertypage.h.

     {
         return pDstPage->DisconnectSrc(pDstId,this,pSrcId);
     }

bool IsConnectedDst	(	FbxInt	pSrcId,
		FbxPropertyPage *	pDstPage,
		FbxInt	pDstId
	)

inline

Definition at line 1043 of file fbxpropertypage.h.

     {
         return pDstPage->IsConnectedSrc(pDstId,this,pSrcId);
     }

int GetDstCount	(	FbxInt	pId,
		FbxConnectionPointFilter *	pFilter
	)

inline

Definition at line 1048 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage   = 0;
         FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are not considered propagated so
         // make sure that we own the FbxPropertyConnect objects
         return (lPropertyConnect && lReferencePage==this) ? lPropertyConnect->GetDstCount(pFilter) : 0;
     }

bool GetDst	(	FbxInt	pId,
		int	pIndex,
		FbxConnectionPointFilter *	pFilter,
		FbxPropertyPage **	pDstPage,
		FbxInt *	pDstId
	)

inline

Definition at line 1058 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage   = 0;
         FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are always overridden
         // make sure that we own the FbxPropertyConnect Item
         if (lPropertyConnect && lReferencePage==this)
         {
             FbxPropertyConnect* lDst = lPropertyConnect->GetDst(pFilter,pIndex);
             if (lDst) 
             {
                 if (pDstPage)   *pDstPage = lDst->GetPage();
                 if (pDstId)     *pDstId   = lDst->GetPropertyId();
                 return true;
             }
         }
         return false;
     }

bool HasMinMax	(	FbxInt	pId,
		FbxPropertyInfo::EValueIndex	pValueId
	)		const

inline

Definition at line 1082 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
     
         return lPropertyInfo ? lPropertyInfo->HasMinMax(pValueId) : false;
     }

bool GetMinMax	(	FbxInt	pId,
		FbxPropertyInfo::EValueIndex	pValueId,
		void *	pValue,
		EFbxType	pValueType
	)

inline

Definition at line 1089 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         return lPropertyInfo ? lPropertyInfo->GetMinMax(pValueId,pValue,pValueType) : false;
     }

bool SetMinMax	(	FbxInt	pId,
		FbxPropertyInfo::EValueIndex	pValueId,
		const void *	pValue,
		EFbxType	pValueType
	)

inline

Definition at line 1096 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         return lPropertyInfo ? lPropertyInfo->SetMinMax(pValueId,pValue,pValueType) : false;
     }

bool Get	(	FbxInt	pId,
		void *	pValue,
		EFbxType	pValueType
	)

inline

Definition at line 1105 of file fbxpropertypage.h.

     {
         FbxPropertyValue* lPropertyValue = GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId );
         return lPropertyValue ? lPropertyValue->Get(pValue,pValueType) : 0;
     }

bool Set	(	FbxInt	pId,
		const void *	pValue,
		EFbxType	pValueType,
		bool	pCheckValueEquality
	)

inline

Definition at line 1111 of file fbxpropertypage.h.

     {
         if( pCheckValueEquality )
         {
             FbxPropertyPage*   lReferencePage  = NULL;
             FbxPropertyValue*  lPropertyValue  = GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId,&lReferencePage );
             void* lCurrentValue = FbxTypeAllocate( pValueType );
             bool lValuesEqual = false;
             bool lValueChanged = false;
             if( lReferencePage && lReferencePage != this )
             {
                 // this page inherits, so check if we have to override the value.
                 if( lPropertyValue )
                 {
                     lPropertyValue->Get( lCurrentValue, pValueType );
                     lValuesEqual = FbxTypeCompare( pValue, lCurrentValue, pValueType );
                 }
             }
             else
             {
                 FbxPropertyPage* lReferencePage2 = NULL;
                 FbxPropertyValue*  lPropertyValue2 = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId,&lReferencePage2 ) : NULL;
                 if( lReferencePage2 && lPropertyValue2 )
                 {
                     // this page is an override, but there is another page before us that overrides the value
                     lPropertyValue2->Get( lCurrentValue, pValueType );
                     lValuesEqual = FbxTypeCompare( pValue, lCurrentValue, pValueType );
 
                     if( lValuesEqual )
                     {
                         ChangePropertyItemState( FBX_TYPE(FbxPropertyValue), pId, FbxPropertyFlags::eInherit );
                         lValueChanged = true;
                     }
 
                 }
                 // else this page is the originator of the property, so no need to check,
             }
 
             FbxTypeDeallocate(pValueType, lCurrentValue);
             lCurrentValue = NULL;
 
             if( lValuesEqual )
                 return lValueChanged;
         }
 
         FbxPropertyValue* lPropertyValue = ChangePropertyItemState( FBX_TYPE(FbxPropertyValue),pId,FbxPropertyFlags::eOverride );
         return lPropertyValue ? lPropertyValue->Set(pValue,pValueType) : false;
     }

FbxPropertyFlags::EInheritType GetValueInherit	(	FbxInt	pId,
		bool	pCheckInstanceOf
	)		const

inline

Definition at line 1160 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lReferencePage = NULL;
         GetPropertyItem(FBX_TYPE(FbxPropertyValue), pId, &lReferencePage);
 
         // check one level
         if( !pCheckInstanceOf )
         {
             return lReferencePage == this ? FbxPropertyFlags::eOverride : FbxPropertyFlags::eInherit;
         }
         else
         {
             if( lReferencePage == this ) return FbxPropertyFlags::eOverride;            // this page is either an override, or the originator
             else if( !lReferencePage->mInstanceOf ) return FbxPropertyFlags::eInherit;  // the reference is the class root, so we must be inheriting
 
             // The reference page is not the class root, might be another override, or the originator.
             FbxPropertyValue* lPropertyValue = lReferencePage->mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyValue), pId );
 
             // if lReferencePage->mInstanceOf has the property value,
             //      lReferencePage is an override
             //  else
             //      its the originator, so this page inherits from it.
             return lPropertyValue ? FbxPropertyFlags::eOverride : FbxPropertyFlags::eInherit;
         }
     }

bool SetValueInherit	(	FbxInt	pId,
		FbxPropertyFlags::EInheritType	pType
	)

inline

Definition at line 1186 of file fbxpropertypage.h.

     {
         // no support for this mode yet
         if( FbxPropertyFlags::eDeleted == pType )
             return false;
 
         ChangePropertyItemState( FBX_TYPE(FbxPropertyValue), pId, pType );
 
         // Above call doesn't return error codes, so just check that we match types.
         return GetValueInherit(pId, false) == pType;
     }

bool GetDefaultValue	(	FbxInt	pId,
		void *	pValue,
		EFbxType	pValueType
	)		const

inline

Definition at line 1198 of file fbxpropertypage.h.

     {
         FbxPropertyPage*    lReferencePage = GetFirstPropertyItem( pId, FBX_TYPE(FbxPropertyValue) );
         FbxPropertyValue*   lPropertyValue = lReferencePage ? lReferencePage->GetPropertyItem( FBX_TYPE(FbxPropertyValue), pId ) : NULL;
 
         return lPropertyValue ? lPropertyValue->Get( pValue, pValueType ) : false;
     }

bool Set	(	FbxInt	pId,
		const T &	pValue
	)

inline

Definition at line 1208 of file fbxpropertypage.h.

1208 { return Set( pId,&pValue,FbxTypeOf(pValue),true ); }

FbxTypeOf

EFbxType FbxTypeOf(const FbxChar &)

Definition: fbxpropertytypes.h:532

FbxPropertyPage::Set

bool Set(FbxInt pId, const void *pValue, EFbxType pValueType, bool pCheckValueEquality)

Definition: fbxpropertypage.h:1111

T Get	(	FbxInt	pId,
		const T *	pFBX_TYPE
	)

inline

Definition at line 1209 of file fbxpropertypage.h.

1209 { T lValue; Get( pId,&lValue,FbxTypeOf(lValue) ); return lValue; }

FbxPropertyPage::Get

bool Get(FbxInt pId, void *pValue, EFbxType pValueType)

Definition: fbxpropertypage.h:1105

FbxTypeOf

EFbxType FbxTypeOf(const FbxChar &)

Definition: fbxpropertytypes.h:532

void SetDataPtr ( void * pDataPtr )

inline

Definition at line 1212 of file fbxpropertypage.h.

1212 { mDataPtr = pDataPtr; }

void* GetDataPtr ( ) const

inline

Definition at line 1213 of file fbxpropertypage.h.

1213 { return mDataPtr; }

void PushPropertiesToParentInstance ( )

inline

Definition at line 1217 of file fbxpropertypage.h.

     {
         if (mInstanceOf) {
             const int lCount = GetPropertyEntryCount();
             // push the existing properties into the parent
             // ----------------------------------------------
             for( int i = 0; i < lCount; ++i )
             {
               FbxPropertyEntry* lParentEntry = mInstanceOf->ChangePropertyEntryState( (FbxInt)i,FbxPropertyFlags::eOverride );
               FbxPropertyEntry* lEntry       = GetPropertyEntry( (FbxInt)i );
 
                 if( !lParentEntry )
                 {
                     lParentEntry = FbxPropertyEntry::Create( lEntry->GetParentId(), 0, 0, 0 );
                     mInstanceOf->mEntryMap.Insert( i, lParentEntry );
 
                     //mInstanceOf->AddChild(i);
 
                 }
 
                 FBX_ASSERT( lParentEntry );
 
                 // Add it to the parent
                 // Don't touch the connections
                 // -----------------------------------------
                 if (lParentEntry) {
                     lParentEntry->Set( lEntry->Get(FBX_TYPE(FbxPropertyInfo))  );
                     lParentEntry->Set( lEntry->Get(FBX_TYPE(FbxPropertyValue)) );
                     lParentEntry->Set( lEntry->Get(FBX_TYPE(FbxPropertyFlags)) );
                 }
 
                 /*
                 else {
                     mInstanceOf->Add(
                         lEntry->GetParentId(),
                         lEntry->Get(FBX_TYPE(FbxPropertyInfo)),        // The info
                         lEntry->Get(FBX_TYPE(FbxPropertyValue)),       // The Value
                         0,                                              // The connections
                         false,
                         false
                     );
                 }
                 */
 
                 // Empty the current entry
                 // Don't touch the connections
                 // -----------------------------------------
                 ChangePropertyItemState(FBX_TYPE(FbxPropertyInfo),  i,FbxPropertyFlags::eInherit);
                 ChangePropertyItemState(FBX_TYPE(FbxPropertyValue), i,FbxPropertyFlags::eInherit);
                 ChangePropertyItemState(FBX_TYPE(FbxPropertyFlags), i,FbxPropertyFlags::eInherit);
             }
         }
     }

const FbxPropertyPage* GetInstanceOf ( ) const

inline

Definition at line 1271 of file fbxpropertypage.h.

1271 { return mInstanceOf; }

FbxPropertyPage* GetInstanceOf ( )

inline

Definition at line 1272 of file fbxpropertypage.h.

1272 { return mInstanceOf; }

const FbxArray<FbxPropertyPage*>& GetInstances ( ) const

inline

Definition at line 1274 of file fbxpropertypage.h.

1274 { return mInstances; }

FbxArray<FbxPropertyPage*>& GetInstances ( )

inline

Definition at line 1275 of file fbxpropertypage.h.

1275 { return mInstances; }

FbxPropertyFlags::EFlags GetFlags ( FbxInt pId = FBXSDK_PROPERTY_ID_ROOT ) const

inline

Definition at line 1280 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lFoundIn = NULL;
         FbxPropertyFlags*  lPropertyFlags = GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn );
         FbxPropertyFlags::EFlags lFlags = FbxPropertyFlags::eNone;
 
         if( lPropertyFlags )
         {
             if( !mInstanceOf ) // no inheritance.
                 lFlags = lPropertyFlags->GetFlags();
             else
             {
                 lFlags = mInstanceOf->GetFlags(pId);
                 lFlags = lPropertyFlags->GetMergedFlags(lFlags);
             }
         }
         return lFlags;
     }

bool ModifyFlags	(	FbxInt	pId = `FBXSDK_PROPERTY_ID_ROOT`,
		FbxPropertyFlags::EFlags	pFlags = `FbxPropertyFlags::eNone`,
		bool	pValue = `true`,
		bool	pCheckFlagEquality = `true`
	)

inline

Definition at line 1299 of file fbxpropertypage.h.

     {
         if( pCheckFlagEquality )
         {
             FbxPropertyPage* lFoundIn = NULL;
             FbxPropertyFlags* lFlag = GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn );
 
             if( lFlag )
             {
                 if( lFoundIn == this )
                 {
                     // set them in us.
                     lFlag->ModifyFlags( pFlags, pValue );
 
                      // we override this entry, check if we need to revert
                     FbxPropertyFlags* lInheritedFlags = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId ) : NULL;
                     if( lInheritedFlags && lInheritedFlags->Equal( *lFlag, pFlags ) )
                     {
                         lFlag->UnsetMask( pFlags );
 
                         if( lFlag->GetMask() == 0 )
                             ChangePropertyItemState( FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eInherit );
 
                         return true;
                     }
                 }
                 else
                 {
                     // its not us. Just check if we need to set.
                     FbxPropertyFlags lNewValues( pFlags );
                     if( lFlag->Equal( lNewValues, pFlags ) )
                         return true;
                 }
             }
         }
 
         FbxPropertyFlags* lPropertyFlags = ChangePropertyItemState(FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eOverride);
         return lPropertyFlags ? lPropertyFlags->ModifyFlags( pFlags, pValue ) : false;
     }

FbxPropertyFlags::EInheritType GetFlagsInheritType	(	FbxPropertyFlags::EFlags	pFlags,
		bool	pCheckInstanceOf,
		FbxInt	pId = `FBXSDK_PROPERTY_ID_ROOT`
	)		const

inline

Definition at line 1339 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lFoundIn = NULL;
         FbxPropertyFlags*  lPropertyFlags = GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn );
 
         if( !pCheckInstanceOf )
             return lFoundIn != this ? FbxPropertyFlags::eInherit : ( lPropertyFlags ? lPropertyFlags->GetFlagsInheritType(pFlags) : FbxPropertyFlags::eInherit );
         else
         {
             // This code basically counts the number of overrides for the
             // given flags. The original entry is always considered an override.
             // so if we see more than one, something overrode the original.
             // and thus we are an override.
             FbxPropertyPage* lRefPage = lFoundIn;
             bool lFoundOverride = false;
             while( lRefPage )
             {
                 lPropertyFlags = lRefPage->GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId );
 
                 if( !lPropertyFlags )
                     break;  // gone too far, break.
 
                 if( lPropertyFlags->GetFlagsInheritType( pFlags ) == FbxPropertyFlags::eOverride )
                 {
                     if( this == lRefPage || lFoundOverride )
                         return FbxPropertyFlags::eOverride;    // found two overrides or this page is the override.
                     else
                         lFoundOverride = true;  // signal that we found the first override.
                 }
                 lRefPage = lRefPage->mInstanceOf;
             }
 
             return FbxPropertyFlags::eInherit;
         }
     }

bool SetFlagsInheritType	(	FbxPropertyFlags::EInheritType	pInheritType,
		FbxPropertyFlags::EFlags	pFlags,
		FbxInt	pId = `FBXSDK_PROPERTY_ID_ROOT`
	)

inline

Definition at line 1375 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lFoundIn = NULL;
         FbxPropertyFlags* lPropertyFlags = NULL;
 
         if( FbxPropertyFlags::eOverride == pInheritType )
         {
             lPropertyFlags = ChangePropertyItemState( FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eOverride );
 
             // we should initialize our flag to the inherited value, if any.
             FbxPropertyFlags* lParentFlags = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId ) : NULL;
             if( lParentFlags && lPropertyFlags )
             {
                 FbxPropertyFlags::EFlags lParentValues = lParentFlags->GetFlags();
                 lPropertyFlags->SetFlags( pFlags, lParentValues );
                 return lPropertyFlags->SetMask( pFlags );
             }
 
             return false;
         }
         else if( FbxPropertyFlags::eInherit == pInheritType )
         {
             lPropertyFlags = GetPropertyItem(FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn);
             if( !lPropertyFlags ) return false;
             if( lFoundIn != this ) return true; // not us
             lPropertyFlags->UnsetMask( pFlags );
             if( lPropertyFlags->GetMask() == 0 )    // revert
                 ChangePropertyItemState( FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eInherit );
 
             return true;
         }
         return false;
     }

void BeginCreateOrFindProperty ( )

inline

Definition at line 1409 of file fbxpropertypage.h.

     {
         if( 0 == mNameMap.mFirst )
         {
             mNameMap.mSecond.Reserve(20);
 
             // push the existing properties into the map. Note: this includes the root property!
             FbxInt lFoundId = FBXSDK_PROPERTY_ID_ROOT;
             FbxPropertyEntry* lEntry = GetPropertyEntry(lFoundId);
             while(lFoundId != FBXSDK_PROPERTY_ID_NULL)
             {
                 FbxPropertyInfo* lInfo = lEntry->Get(FBX_TYPE(FbxPropertyInfo));
                 //FBX_ASSERT( lInfo );
                 if (lInfo)
                 {
                     mNameMap.mSecond.Insert(FbxNameMapKey(lEntry->GetParentId(), lInfo->GetName()), lFoundId);
                 }
                 lFoundId = GetMinimumPropertyIdAndEntry(lFoundId, &lEntry);
             }
             mNameMap.mFirst++;
         }
     }

void EndCreateOrFindProperty ( )

inline

Definition at line 1432 of file fbxpropertypage.h.

     {
         if( mNameMap.mFirst > 0 )
         {
             if( --(mNameMap.mFirst) == 0 )
                 mNameMap.mSecond.Clear();
         }
     }

bool Is ( FbxPropertyPage * pPage )

inlineprotected

Definition at line 1539 of file fbxpropertypage.h.

     {
         // @@@@@@@@@@@@@@@ Must complete for sub types
         return this==pPage;
     }

Friends And Related Function Documentation

friend class FbxPropertyHandle

friend

Definition at line 1731 of file fbxpropertypage.h.

The documentation for this class was generated from the following file:

fbxsdk/core/fbxpropertypage.h

FbxPropertyPage Class Reference

Class Description

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation