FBX C++ API Reference
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Friends
FbxPropertyPage Class Reference

#include <fbxpropertypage.h>

Class Description

Definition at line 432 of file fbxpropertypage.h.

Public Types

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

Public Member Functions

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=0)
 
const char * GetLabel (FbxInt pId=0)
 
bool SetLabel (FbxInt pId=0, const char *pLabel="")
 
void * GetUserData (FbxInt pId=0)
 
bool SetUserData (FbxInt pId=0, const void *pUserData=0)
 
int GetUserTag (FbxInt pId=0)
 
bool SetUserTag (FbxInt pId=0, int pUserTag=0)
 
EFbxType GetType (FbxInt pId=0) const
 
FbxInt GetParent (FbxInt pId=0) const
 
FbxPropertyPage * GetTypeInfo (FbxInt pId=0)
 
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=0) 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=0) 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=0) const
 
bool ModifyFlags (FbxInt pId=0, FbxPropertyFlags::EFlags pFlags=FbxPropertyFlags::eNone, bool pValue=true, bool pCheckFlagEquality=true)
 
FbxPropertyFlags::EInheritType GetFlagsInheritType (FbxPropertyFlags::EFlags pFlags, bool pCheckInstanceOf, FbxInt pId=0) const
 
bool SetFlagsInheritType (FbxPropertyFlags::EInheritType pInheritType, FbxPropertyFlags::EFlags pFlags, FbxInt pId=0)
 
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
 
template<typename T >
T * fbxsdk ::FbxNew ()
 
template<typename T , typename T1 >
T * fbxsdk ::FbxNew (T1 &p1)
 
template<typename T , typename T1 >
T * fbxsdk ::FbxNew (const T1 &p1)
 
template<typename T , typename T1 , typename T2 >
T * fbxsdk ::FbxNew (T1 &p1, T2 &p2)
 
template<typename T , typename T1 , typename T2 >
T * fbxsdk ::FbxNew (T1 &p1, const T2 &p2)
 
template<typename T , typename T1 , typename T2 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2)
 
template<typename T , typename T1 , typename T2 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2)
 
template<typename T , typename T1 , typename T2 , typename T3 >
T * fbxsdk ::FbxNew (T1 &p1, T2 &p2, T3 &p3)
 
template<typename T , typename T1 , typename T2 , typename T3 >
T * fbxsdk ::FbxNew (T1 &p1, T2 &p2, const T3 &p3)
 
template<typename T , typename T1 , typename T2 , typename T3 >
T * fbxsdk ::FbxNew (T1 &p1, const T2 &p2, T3 &p3)
 
template<typename T , typename T1 , typename T2 , typename T3 >
T * fbxsdk ::FbxNew (T1 &p1, const T2 &p2, const T3 &p3)
 
template<typename T , typename T1 , typename T2 , typename T3 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, T3 &p3)
 
template<typename T , typename T1 , typename T2 , typename T3 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, const T3 &p3)
 
template<typename T , typename T1 , typename T2 , typename T3 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, T3 &p3)
 
template<typename T , typename T1 , typename T2 , typename T3 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (T1 &p1, T2 &p2, T3 &p3, T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (T1 &p1, T2 &p2, T3 &p3, const T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (T1 &p1, T2 &p2, const T3 &p3, T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (T1 &p1, T2 &p2, const T3 &p3, const T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (T1 &p1, const T2 &p2, T3 &p3, T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (T1 &p1, const T2 &p2, T3 &p3, const T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (T1 &p1, const T2 &p2, const T3 &p3, T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, T3 &p3, T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, T3 &p3, const T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, const T3 &p3, T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, const T3 &p3, const T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, const T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, T4 &p4, T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, const T3 &p3, T4 &p4, T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, T3 &p3, const T4 &p4, T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, T2 &p2, T3 &p3, T4 &p4, const T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, T4 &p4, T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, const T4 &p4, T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, T4 &p4, const T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, T4 &p4, const T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8)
 
template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
T * fbxsdk ::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9)
 
template<typename T >
void fbxsdk ::FbxDelete (T *p)
 
template<typename T >
void fbxsdk ::FbxDelete (const T *p)
 
template<typename T >
T * fbxsdk ::FbxNewArray (const int n)
 
template<typename T >
void fbxsdk ::FbxDeleteArray (T *p)
 

Member Enumeration Documentation

◆ EValueIndex

enum EValueIndex
Enumerator
eValueMin 
eValueSoftMin 
eValueMax 
eValueSoftMax 
eValueCount 

Definition at line 1091 of file fbxpropertypage.h.

1091 { eValueMin,eValueSoftMin,eValueMax,eValueSoftMax,eValueCount };
FbxPropertyPage::eValueSoftMax
Definition: fbxpropertypage.h:1091
FbxPropertyPage::eValueMax
Definition: fbxpropertypage.h:1091
FbxPropertyPage::eValueCount
Definition: fbxpropertypage.h:1091
FbxPropertyPage::eValueMin
Definition: fbxpropertypage.h:1091
FbxPropertyPage::eValueSoftMin
Definition: fbxpropertypage.h:1091

Constructor & Destructor Documentation

◆ FbxPropertyPage() [1/3]

FbxPropertyPage ( FbxPropertyPage *  pInstanceOf = 0)
inlineprotected

Definition at line 1453 of file fbxpropertypage.h.

1454  : mInstanceOf(0)
1455  , mDataPtr(0)
1456  , mPropNextId(0)
1457  {
1458  mEntryMap.Reserve(32);
1459  mNameMap.mFirst = 0;
1460 
1461  // instances don't need to create a root property
1462  if( !pInstanceOf )
1463  {
1464  mPropNextId = FbxNew< FbxPropertyIdGenerator >();
1465  mPropNextId->IncRef();
1466 
1467  // First item is the root information
1468  Add(FBXSDK_PROPERTY_ID_NULL,"",eFbxUndefined);
1469  }
1470 
1471  // Hook the instances
1472  // ------------------------
1473  mInstanceOf = pInstanceOf;
1474  if (mInstanceOf) {
1475  mInstanceOf->mInstances.Add(this);
1476 
1477  mPropNextId = mInstanceOf->mPropNextId;
1478  mPropNextId->IncRef();
1479  }
1480  }
FbxPropertyPage::Add
FbxInt Add(FbxInt pParentId, const char *pName, EFbxType pType)
Definition: fbxpropertypage.h:585
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
eFbxUndefined
Unidentified.
Definition: fbxpropertytypes.h:30
FbxArray::Add
int Add(const T &pElement)
Append an element at the end of the array, doubling the array if capacity is not sufficient.
Definition: fbxarray.h:83
FbxMap::Reserve
void Reserve(unsigned int pRecordCount)
Preallocate memory.
Definition: fbxmap.h:104
FbxPair::mFirst
First mFirst
The first object in the pair.
Definition: fbxpair.h:56

◆ FbxPropertyPage() [2/3]

FbxPropertyPage ( const char *  pName,
EFbxType  pType 
)
inlineprotected

Definition at line 1481 of file fbxpropertypage.h.

1482  : mInstanceOf(0)
1483  , mDataPtr(0)
1484  , mPropNextId(0)
1485  {
1486  mEntryMap.Reserve(32);
1487  mNameMap.mFirst = 0;
1488 
1489  mPropNextId = FbxNew< FbxPropertyIdGenerator >();
1490  mPropNextId->IncRef();
1491 
1492  // First item is the root information
1493  Add(FBXSDK_PROPERTY_ID_NULL,pName,pType);
1494  }
FbxPropertyPage::Add
FbxInt Add(FbxInt pParentId, const char *pName, EFbxType pType)
Definition: fbxpropertypage.h:585
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxMap::Reserve
void Reserve(unsigned int pRecordCount)
Preallocate memory.
Definition: fbxmap.h:104
FbxPair::mFirst
First mFirst
The first object in the pair.
Definition: fbxpair.h:56

◆ FbxPropertyPage() [3/3]

FbxPropertyPage ( const char *  pName,
FbxPropertyPage *  pTypeInfo 
)
inlineprotected

Definition at line 1495 of file fbxpropertypage.h.

1496  : mInstanceOf(0)
1497  , mDataPtr(0)
1498  , mPropNextId(0)
1499  {
1500  mEntryMap.Reserve(32);
1501  mNameMap.mFirst = 0;
1502 
1503  mPropNextId = FbxNew< FbxPropertyIdGenerator >();
1504  mPropNextId->IncRef();
1505 
1506  // First item is the root information
1507  Add(FBXSDK_PROPERTY_ID_NULL,pName,pTypeInfo);
1508  }
FbxPropertyPage::Add
FbxInt Add(FbxInt pParentId, const char *pName, EFbxType pType)
Definition: fbxpropertypage.h:585
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxMap::Reserve
void Reserve(unsigned int pRecordCount)
Preallocate memory.
Definition: fbxmap.h:104
FbxPair::mFirst
First mFirst
The first object in the pair.
Definition: fbxpair.h:56

◆ ~FbxPropertyPage()

~FbxPropertyPage ( )
inlineprotected

Definition at line 1509 of file fbxpropertypage.h.

1510  {
1511  // Propagate our property entries.
1512  int i = 0, j = 0;
1513  for( i = 0; i < mInstances.GetCount(); ++i )
1514  {
1515  for( j = 0; j < GetPropertyEntryCount(); ++j )
1516  {
1517  if( mInstances[i]->ChangePropertyEntryState((FbxInt)j, FbxPropertyFlags::eOverride) )
1518  {
1519  // Clone the info and values. Don't clone the connections,
1520  // since they aren't propagated.
1521  mInstances[i]->ChangePropertyItemState( FBX_TYPE(FbxPropertyInfo), (FbxInt)j, FbxPropertyFlags::eOverride );
1522  mInstances[i]->ChangePropertyItemState( FBX_TYPE(FbxPropertyValue), (FbxInt)j, FbxPropertyFlags::eOverride );
1523 
1524  // Since all entries have their own flags, just override the ones in the instance.
1525  mInstances[i]->SetFlagsInheritType(FbxPropertyFlags::eOverride, FbxPropertyFlags::eAllFlags, (FbxInt)j );
1526  }
1527  }
1528 
1529  // Instances become their own copies.
1530  mInstances[i]->mInstanceOf = NULL;
1531  }
1532 
1533  FbxMapDestroy(mEntryMap);
1534 
1535  if (mInstanceOf) {
1536  int lIndex = mInstanceOf->mInstances.Find(this);
1537  mInstanceOf->mInstances.SetAt(lIndex, mInstanceOf->mInstances[mInstanceOf->mInstances.GetCount()-1]);
1538  mInstanceOf->mInstances.RemoveAt(mInstanceOf->mInstances.GetCount()-1);
1539 
1540  //mInstanceOf->mInstances.RemoveIt(this);
1541  }
1542 
1543  mPropNextId->DecRef();
1544  mPropNextId = NULL;
1545 
1546  mInstanceOf = NULL;
1547  mInstances.Clear();
1548  }
FbxMapDestroy
void FbxMapDestroy(FbxMap< K, V, C, A > &pMap)
Call Destroy on each element of the map, and then clear it.
Definition: fbxmap.h:394
NULL
#define NULL
Definition: fbxarch.h:210
FbxArray::Find
int Find(const T &pElement, const int pStartIndex=0) const
Find first matching element, from first to last.
Definition: fbxarray.h:164
FbxArray::RemoveAt
T RemoveAt(const int pIndex)
Remove an element at the given position in the array.
Definition: fbxarray.h:239
FbxPropertyFlags::eOverride
Property override this flag from its reference property.
Definition: fbxpropertydef.h:33
FbxArray::Clear
void Clear()
Reset the number of element to zero and free the memory allocated.
Definition: fbxarray.h:352
FbxArray::SetAt
void SetAt(const int pIndex, const T &pElement)
Set the element at given position in the array.
Definition: fbxarray.h:212
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39

Member Function Documentation

◆ Create() [1/3]

static FbxPropertyPage* Create ( FbxPropertyPage *  pInstanceOf = 0)
inlinestatic

Definition at line 437 of file fbxpropertypage.h.

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

◆ Create() [2/3]

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

Definition at line 438 of file fbxpropertypage.h.

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

◆ Create() [3/3]

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

Definition at line 439 of file fbxpropertypage.h.

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

◆ Destroy()

void Destroy ( )
inline

Definition at line 440 of file fbxpropertypage.h.

440 { FbxDelete(this); }
FbxDelete
void FbxDelete(T *p)
Deletion policy for pointer template classes that uses the FbxDelete() function.
Definition: fbxnew.h:341

◆ GetPropertyItem()

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

Definition at line 442 of file fbxpropertypage.h.

443  {
444  FbxPropertyPage* lReferencePage = 0;
445  FbxPropertyEntry* lReferenceEntry = GetPropertyEntry(pIndex,&lReferencePage);
446  if (pFoundIn) *pFoundIn = 0;
447  if (lReferenceEntry) {
448  T* lItem = lReferenceEntry->Get( FBX_TYPE(T) );
449  if (lItem) {
450  if (pFoundIn) *pFoundIn = lReferencePage;
451  return lItem;
452  } else {
453  return lReferencePage->mInstanceOf ? lReferencePage->mInstanceOf->GetPropertyItem(pItemType,pIndex,pFoundIn) : 0 ;
454  }
455  }
456  return 0;
457  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FbxPropertyEntry::Get
FbxPropertyInfo * Get(const FbxPropertyInfo *)
Definition: fbxpropertypage.h:353
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ ChangePropertyItemState()

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

Definition at line 459 of file fbxpropertypage.h.

460  {
461  FbxPropertyPage* lReferencePage = NULL;
462  T* lItem = GetPropertyItem(pItemType, pIndex, &lReferencePage);
463  if( pInheritType == FbxPropertyFlags::eOverride )
464  {
465  if( lReferencePage == this )
466  {
467  return lItem;
468  }
469  else if( lItem )
470  {
471  FbxPropertyEntry* lEntry = ChangePropertyEntryState(pIndex, FbxPropertyFlags::eOverride);
472  lEntry->Set(lItem->Clone(this));
473  return lEntry->Get(FBX_TYPE(T));
474  }
475  }
476  else
477  {
478  // can't inherit entries that were created on our page.
479  bool lOwnEntry = !mInstanceOf || (mInstanceOf->GetPropertyItem(pItemType, pIndex) == NULL);
480  if( lOwnEntry && FbxPropertyFlags::eInherit == pInheritType) return 0;
481 
482  if( lItem && (lReferencePage == this) )
483  {
484  FbxPropertyEntry* lEntry = GetPropertyEntry(pIndex);
485  lEntry->Set((T*)0);
486  if( lEntry->IsEmpty() )
487  {
488  ChangePropertyEntryState(pIndex, FbxPropertyFlags::eInherit);
489  }
490  }
491  return 0;
492  }
493  return 0;
494  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FbxPropertyEntry::Get
FbxPropertyInfo * Get(const FbxPropertyInfo *)
Definition: fbxpropertypage.h:353
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
NULL
#define NULL
Definition: fbxarch.h:210
FbxPropertyEntry::Set
void Set(FbxPropertyInfo *pInfo)
Definition: fbxpropertypage.h:355
FbxPropertyFlags::eOverride
Property override this flag from its reference property.
Definition: fbxpropertydef.h:33
FbxPropertyFlags::eInherit
Property inherit this flag from its reference property.
Definition: fbxpropertydef.h:34
FbxPropertyEntry::IsEmpty
bool IsEmpty()
Definition: fbxpropertypage.h:351
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ GetFirstPropertyItem()

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

Definition at line 496 of file fbxpropertypage.h.

497  {
498  FbxPropertyPage* lReferencePage = NULL;
499  GetPropertyItem(FBX_TYPE(T), pId, &lReferencePage);
500  if( lReferencePage && lReferencePage->mInstanceOf )
501  {
502  FbxPropertyPage* lReferencePage2 = lReferencePage->mInstanceOf->GetFirstPropertyItem(pId, pItem);
503  return lReferencePage2 ? lReferencePage2 : lReferencePage;
504  }
505  return lReferencePage;
506  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
NULL
#define NULL
Definition: fbxarch.h:210
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage::GetFirstPropertyItem
FbxPropertyPage * GetFirstPropertyItem(FbxInt pId, const T *pItem) const
Definition: fbxpropertypage.h:496
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ GetName()

const char* GetName ( FbxInt  pId = 0)
inline

Definition at line 508 of file fbxpropertypage.h.

509  {
510  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
511  return lPropertyInfo ? ((const char*)lPropertyInfo->GetName()) : "";
512  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyInfo::GetName
FbxStringSymbol GetName() const
Definition: fbxpropertypage.h:64

◆ GetLabel()

const char* GetLabel ( FbxInt  pId = 0)
inline

Definition at line 514 of file fbxpropertypage.h.

515  {
516  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
517  return lPropertyInfo ? ((const char*)lPropertyInfo->GetLabel()) : "";
518  }
FbxPropertyInfo::GetLabel
const char * GetLabel() const
Definition: fbxpropertypage.h:69
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ SetLabel()

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

Definition at line 520 of file fbxpropertypage.h.

521  {
522  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
523  // Don't make it writeable (Keep it shared)
524  if (lPropertyInfo) {
525  lPropertyInfo->SetLabel(pLabel);
526  return true;
527  } else {
528  return false;
529  }
530  }
FbxPropertyInfo::SetLabel
void SetLabel(const char *pLabel)
Definition: fbxpropertypage.h:68
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ GetUserData()

void* GetUserData ( FbxInt  pId = 0)
inline

Definition at line 532 of file fbxpropertypage.h.

533  {
534  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
535  return lPropertyInfo ? lPropertyInfo->GetUserData() : 0;
536  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyInfo::GetUserData
void * GetUserData() const
Definition: fbxpropertypage.h:75

◆ SetUserData()

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

Definition at line 538 of file fbxpropertypage.h.

539  {
540  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
541  // Don't make it writeable (Keep it shared)
542  if (lPropertyInfo) {
543  lPropertyInfo->SetUserData(pUserData);
544  return true;
545  } else {
546  return false;
547  }
548  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyInfo::SetUserData
void SetUserData(const void *pUserData)
Definition: fbxpropertypage.h:74
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ GetUserTag()

int GetUserTag ( FbxInt  pId = 0)
inline

Definition at line 550 of file fbxpropertypage.h.

551  {
552  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
553  return lPropertyInfo ? lPropertyInfo->GetUserTag() : 0;
554  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyInfo::GetUserTag
int GetUserTag() const
Definition: fbxpropertypage.h:72
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ SetUserTag()

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

Definition at line 556 of file fbxpropertypage.h.

557  {
558  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
559  // Don't make it writeable (Keep it shared)
560  if (lPropertyInfo) {
561  lPropertyInfo->SetUserTag(pUserTag);
562  return true;
563  } else {
564  return false;
565  }
566  }
FbxPropertyInfo::SetUserTag
void SetUserTag(int pUserTag)
Definition: fbxpropertypage.h:71
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ GetType()

EFbxType GetType ( FbxInt  pId = 0) const
inline

Definition at line 568 of file fbxpropertypage.h.

569  {
570  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
571  return lPropertyInfo ? lPropertyInfo->GetType() : eFbxUndefined;
572  }
eFbxUndefined
Unidentified.
Definition: fbxpropertytypes.h:30
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyInfo::GetType
EFbxType GetType() const
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ GetParent()

FbxInt GetParent ( FbxInt  pId = 0) const
inline

Definition at line 574 of file fbxpropertypage.h.

575  {
576  FbxPropertyEntry* lPropertyEntry = GetPropertyEntry( pId );
577  return lPropertyEntry ? lPropertyEntry->GetParentId() : FBXSDK_PROPERTY_ID_NULL;
578  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxPropertyEntry::GetParentId
FbxInt GetParentId()
Definition: fbxpropertypage.h:350

◆ GetTypeInfo()

FbxPropertyPage* GetTypeInfo ( FbxInt  pId = 0)
inline

Definition at line 580 of file fbxpropertypage.h.

581  {
582  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
583  return lPropertyInfo ? lPropertyInfo->GetTypeInfo() : 0;
584  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyInfo::GetTypeInfo
FbxPropertyPage * GetTypeInfo() const
Definition: fbxpropertypage.h:66
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ Add() [1/2]

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

Definition at line 585 of file fbxpropertypage.h.

586  {
587  return Add(pParentId,FbxPropertyInfo::Create(pName,pType),FbxPropertyValue::Create(0,pType),0);
588  }
FbxPropertyPage::Add
FbxInt Add(FbxInt pParentId, const char *pName, EFbxType pType)
Definition: fbxpropertypage.h:585
FbxPropertyInfo::Create
static FbxPropertyInfo * Create(const char *pName, FbxPropertyPage *pTypeInfo)
Definition: fbxpropertypage.h:41
FbxPropertyValue::Create
static FbxPropertyValue * Create(void *pData, EFbxType pType)

◆ Add() [2/2]

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

Definition at line 589 of file fbxpropertypage.h.

590  {
591  return Add(pParentId,FbxPropertyInfo::Create(pName,pTypeInfo),FbxPropertyValue::Create(0,pTypeInfo->GetType()),0);
592  }
FbxPropertyPage::Add
FbxInt Add(FbxInt pParentId, const char *pName, EFbxType pType)
Definition: fbxpropertypage.h:585
FbxPropertyInfo::Create
static FbxPropertyInfo * Create(const char *pName, FbxPropertyPage *pTypeInfo)
Definition: fbxpropertypage.h:41
FbxPropertyPage::GetType
EFbxType GetType(FbxInt pId=0) const
Definition: fbxpropertypage.h:568
FbxPropertyValue::Create
static FbxPropertyValue * Create(void *pData, EFbxType pType)

◆ Reparent()

bool Reparent ( FbxInt  ,
FbxInt   
)
inline

Definition at line 594 of file fbxpropertypage.h.

595  {
596  // Not implemented.
597  /*
598  if( GetParent(pChildId) != pNewParentId && pChildId < mEntries.GetCount() )
599  {
600  FbxPropertyEntry* lChildEntry = mEntries[pChildId];
601  lChildEntry->mParentId = pNewParentId;
602 
603  //@@@@@ TODO: propagate to instances
604 
605  return true;
606  }
607  */
608  return false;
609  }

◆ IsChildOf()

bool IsChildOf ( FbxInt  pId,
FbxInt  pParentId 
) const
inline

Definition at line 611 of file fbxpropertypage.h.

612  {
613  return GetParent(pId)==pParentId;
614 
615  }
FbxPropertyPage::GetParent
FbxInt GetParent(FbxInt pId=0) const
Definition: fbxpropertypage.h:574

◆ IsDescendentOf()

bool IsDescendentOf ( FbxInt  pId,
FbxInt  pAncestorId 
) const
inline

Definition at line 617 of file fbxpropertypage.h.

618  {
619  if (pAncestorId>0) {
620  FbxInt lParentId = GetParent(pId);
621  while (lParentId != FBXSDK_PROPERTY_ID_NULL ) {
622  if (lParentId==pAncestorId) {
623  return true;
624  }
625  lParentId = GetParent(lParentId);
626  }
627  return false;
628  } else {
629  return true;
630  }
631 
632  }
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxPropertyPage::GetParent
FbxInt GetParent(FbxInt pId=0) const
Definition: fbxpropertypage.h:574
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39

◆ GetChild()

FbxInt GetChild ( FbxInt  pParentId = 0) const
inline

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

Parameters
pParentIdThe specified property id
Returns
the first child property id

Definition at line 640 of file fbxpropertypage.h.

641  {
642  #ifdef PROPERTY_PAGE_SANITY_CHECK
643  FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
644  if (pParentId!=FBXSDK_PROPERTY_ID_NULL) {
645  FbxInt lId = GetMinimumPropertyId(pParentId);
646  FbxInt lParentId = GetParent(lId);
647  const FbxInt lLastId = GetPropertyEntryCount();
648 
649  while (lId<lLastId && lParentId!=pParentId) lParentId=GetParent(++lId);
650  ret0 = lId<lLastId ? lId : FBXSDK_PROPERTY_ID_NULL;
651  } else {
652  ret0 = FBXSDK_PROPERTY_ID_NULL;
653  }
654  #endif
655  FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
656  if (pParentId != FBXSDK_PROPERTY_ID_NULL)
657  {
658  FbxPropertyEntry* lEntry;
659  FbxInt lId = pParentId;
660  do
661  {
662  lId = GetMinimumPropertyIdAndEntry(lId, &lEntry);
663  } while (lId != FBXSDK_PROPERTY_ID_NULL && lEntry->GetParentId() != pParentId);
664  ret1 = lId;
665  }
666  #ifdef PROPERTY_PAGE_SANITY_CHECK
667  FBX_ASSERT(ret0==ret1);
668  #endif
669  return ret1;
670  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxPropertyPage::GetParent
FbxInt GetParent(FbxInt pId=0) const
Definition: fbxpropertypage.h:574
FbxPropertyEntry::GetParentId
FbxInt GetParentId()
Definition: fbxpropertypage.h:350
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39

◆ GetSibling()

FbxInt GetSibling ( FbxInt  pId) const
inline

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

Parameters
pIdThe specified property id
Returns
the next sibling property id

Definition at line 676 of file fbxpropertypage.h.

677  {
678  #ifdef PROPERTY_PAGE_SANITY_CHECK
679  FbxInt pIdBackup = pId;
680  FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
681  if (pId!=FBXSDK_PROPERTY_ID_NULL) {
682  FbxInt lReferenceParentId = GetParent(pId);
683  FbxInt lParentId = GetParent(++pId);
684  const FbxInt lLastId = GetPropertyEntryCount();
685 
686  while (pId<lLastId && lReferenceParentId!=FBXSDK_PROPERTY_ID_NULL && lParentId!=lReferenceParentId)
687  lParentId=GetParent(++pId);
688  ret0 = pId<lLastId ? pId : FBXSDK_PROPERTY_ID_NULL;
689  } else {
690  ret0 = FBXSDK_PROPERTY_ID_NULL;
691  }
692  pId = pIdBackup;
693  #endif
694  FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
695  if (pId != FBXSDK_PROPERTY_ID_NULL)
696  {
697  FbxInt lReferenceParentId = GetParent(pId);
698 
699  if (lReferenceParentId != FBXSDK_PROPERTY_ID_NULL)
700  {
701  FbxPropertyEntry *lEntry;
702  do
703  {
704  pId = GetMinimumPropertyIdAndEntry(pId, &lEntry);
705  } while (pId != FBXSDK_PROPERTY_ID_NULL && lEntry->GetParentId() != lReferenceParentId);
706 
707  ret1 = pId;
708  }
709  }
710 
711  #ifdef PROPERTY_PAGE_SANITY_CHECK
712  FBX_ASSERT(ret0==ret1);
713  #endif
714  return ret1;
715  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxPropertyPage::GetParent
FbxInt GetParent(FbxInt pId=0) const
Definition: fbxpropertypage.h:574
FbxPropertyEntry::GetParentId
FbxInt GetParentId()
Definition: fbxpropertypage.h:350
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39

◆ GetFirstDescendent()

FbxInt GetFirstDescendent ( FbxInt  pAnscestorId = 0) const
inline

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

Parameters
pAnscestorIdThe specified property id
Returns
the first descendent property id

Definition at line 721 of file fbxpropertypage.h.

722  {
723  #ifdef PROPERTY_PAGE_SANITY_CHECK
724  FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
725  if (pAnscestorId!=FBXSDK_PROPERTY_ID_NULL) {
726  FbxInt lId = GetMinimumPropertyId(pAnscestorId);
727  FbxInt lParentId = GetParent(lId);
728  const FbxInt lLastId = GetPropertyEntryCount();
729 
730  while (lId<lLastId) {
731  if( lParentId!=FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(lId,pAnscestorId) )
732  {
733  ret0 = lId;
734  break;
735  }
736  lParentId = GetParent(++lId);
737  }
738  }
739  #endif
740  FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
741  FbxInt lId = pAnscestorId;
742  FbxPropertyEntry* lEntry;
743  if (pAnscestorId != FBXSDK_PROPERTY_ID_NULL)
744  {
745  for(;;)
746  {
747  lId = GetMinimumPropertyIdAndEntry(lId, &lEntry);
748  if (lId == FBXSDK_PROPERTY_ID_NULL)
749  break;
750  if(lEntry->GetParentId() != FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(lId, pAnscestorId))
751  {
752  ret1 = lId;
753  break;
754  }
755  }
756  }
757 
758  #ifdef PROPERTY_PAGE_SANITY_CHECK
759  FBX_ASSERT(ret0==ret1);
760  #endif
761  return ret1;
762  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxPropertyPage::IsDescendentOf
bool IsDescendentOf(FbxInt pId, FbxInt pAncestorId) const
Definition: fbxpropertypage.h:617
FbxPropertyPage::GetParent
FbxInt GetParent(FbxInt pId=0) const
Definition: fbxpropertypage.h:574
FbxPropertyEntry::GetParentId
FbxInt GetParentId()
Definition: fbxpropertypage.h:350
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39

◆ GetNextDescendent()

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
pAnscestorIdThe specified property id
pIdThe descendent property id
Returns
the next descendent property id

Definition at line 769 of file fbxpropertypage.h.

770  {
771  #ifdef PROPERTY_PAGE_SANITY_CHECK
772  FbxInt pIdBackup = pId;
773  FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
774  if (pId!=FBXSDK_PROPERTY_ID_NULL) {
775  FbxInt lParentId = GetParent(++pId);
776  const FbxInt lLastId = GetPropertyEntryCount();
777 
778  while (pId<lLastId) {
779  // GetParent returns null when the given id isn't in our page,
780  // or our ancestor's page.
781  if( lParentId != FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(pId, pAnscestorId) )
782  {
783  ret0 = pId;
784  break;
785  }
786 
787  lParentId = GetParent(++pId);
788  }
789  }
790 
791  pId = pIdBackup;
792  #endif
793  FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
794  if (pId != FBXSDK_PROPERTY_ID_NULL)
795  {
796  FbxPropertyEntry* lEntry;
797  for(;;)
798  {
799  pId = GetMinimumPropertyIdAndEntry(pId, &lEntry);
800  if (pId == FBXSDK_PROPERTY_ID_NULL)
801  break;
802  if(lEntry->GetParentId() != FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(pId, pAnscestorId) )
803  {
804  ret1 = pId;
805  break;
806  }
807  }
808 
809  }
810  #ifdef PROPERTY_PAGE_SANITY_CHECK
811  FBX_ASSERT(ret0==ret1);
812  #endif
813  return ret1;
814 
815  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxPropertyPage::IsDescendentOf
bool IsDescendentOf(FbxInt pId, FbxInt pAncestorId) const
Definition: fbxpropertypage.h:617
FbxPropertyPage::GetParent
FbxInt GetParent(FbxInt pId=0) const
Definition: fbxpropertypage.h:574
FbxPropertyEntry::GetParentId
FbxInt GetParentId()
Definition: fbxpropertypage.h:350
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39

◆ FastFind()

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

Definition at line 817 of file fbxpropertypage.h.

818  {
819  FbxInt lId = FBXSDK_PROPERTY_ID_NULL;
820 
821  bool lSlowQuery = true;
822  if( mNameMap.mSecond.GetSize() > 0 )
823  {
824  lSlowQuery = false;
825  // try to use the map if we've got it
826  NameMap::RecordType* lIterator = mNameMap.mSecond.Find( FbxNameMapKey( pId, pName ) );
827  if( !lIterator )
828  {
829  lId = FBXSDK_PROPERTY_ID_NULL;
830  }
831  else
832  {
833  lId = lIterator->GetValue();
834  if (lId != FBXSDK_PROPERTY_ID_NULL && pTypeInfo)
835  {
836  lSlowQuery = true;
837 
838  // Try to match types.
839  // If they are mismatched, fall back to the slow query,
840  // since we might have multiple property with the same name but different types
841  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo), lId );
842  if (lPropertyInfo)
843  {
844  FbxPropertyPage* lTypeInfo2 = lPropertyInfo->GetTypeInfo();
845  if ( lTypeInfo2 && lTypeInfo2->Is(pTypeInfo) )
846  {
847  lSlowQuery = false;
848  }
849  }
850  }
851  }
852  }
853 
854  if (!lSlowQuery)
855  return lId;
856 
857  // fall back if there's no map or we got one with a different type
858 
859  lId = GetChild(pId);
860  FbxStringSymbol lSearchSymbol( pName );
861  while( lId != FBXSDK_PROPERTY_ID_NULL ) {
862  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo), lId );
863  if ( (!pTypeInfo || lPropertyInfo->GetTypeInfo()->Is(pTypeInfo)) &&
864  ((!pCaseSensitive && FBXSDK_stricmp(lPropertyInfo->GetName(),pName)==0) ||
865  (pCaseSensitive && lPropertyInfo->GetName() == lSearchSymbol)) ) {
866  return lId;
867  }
868  lId = GetSibling(lId);
869  }
870 
871  return FBXSDK_PROPERTY_ID_NULL;
872  }
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxStringSymbol
This class is to mark a string as symbol.
Definition: fbxsymbol.h:81
FbxNameMapKey
FbxPair< FbxInt, const char * > FbxNameMapKey
Definition: fbxpropertypage.h:25
FbxPropertyPage::GetChild
FbxInt GetChild(FbxInt pParentId=0) const
Retrieves the first child property id of a specified property id.
Definition: fbxpropertypage.h:640
FbxMap::Find
const RecordType * Find(const KeyType &pKey) const
Query a key.
Definition: fbxmap.h:171
FbxPropertyInfo::GetTypeInfo
FbxPropertyPage * GetTypeInfo() const
Definition: fbxpropertypage.h:66
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPair::mSecond
Second mSecond
The second object in the pair.
Definition: fbxpair.h:57
FbxPropertyInfo::GetName
FbxStringSymbol GetName() const
Definition: fbxpropertypage.h:64
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39
FbxMap::GetSize
int GetSize() const
Retrieve the number of key-value pairs it holds.
Definition: fbxmap.h:110
FbxPropertyPage::Is
bool Is(FbxPropertyPage *pPage)
Definition: fbxpropertypage.h:1550
FbxMap::RecordType
StorageType::RecordType RecordType
Definition: fbxmap.h:98
FbxPropertyPage
Definition: fbxpropertypage.h:432
FbxPropertyPage::GetSibling
FbxInt GetSibling(FbxInt pId) const
Retrieves the next sibling property id of a specified property id.
Definition: fbxpropertypage.h:676

◆ Find()

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

Definition at line 874 of file fbxpropertypage.h.

875  {
876  if (pChildrenSeparators)
877  {
878  FbxInt lId;
879  size_t lFoundIndex = strcspn(pName,pChildrenSeparators);
880 
881  // Strip the first part of the name and search
882  if (lFoundIndex<strlen(pName))
883  {
884  FbxString pRootName;
885  pRootName.Append(pName,lFoundIndex);
886  lId = FastFind(pId,pRootName.Buffer(),NULL,pCaseSensitive);
887  return lId != FBXSDK_PROPERTY_ID_NULL ? Find(lId,pName+lFoundIndex+1,pTypeInfo,pCaseSensitive,pChildrenSeparators) : lId;
888  } else {
889  return FastFind(pId,pName,pTypeInfo,pCaseSensitive);
890  }
891  } else {
892  return FastFind(pId,pName,pTypeInfo,pCaseSensitive);
893  }
894  }
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
NULL
#define NULL
Definition: fbxarch.h:210
FbxString
Utility class to manipulate strings.
Definition: fbxstring.h:66
FbxString::Buffer
char * Buffer()
Non-const buffer access.
FbxString::Append
const FbxString & Append(const char *pString, size_t pLength)
Append as "C" strncat().
FbxPropertyPage::FastFind
FbxInt FastFind(FbxInt pId, const char *pName, FbxPropertyPage *pTypeInfo, bool pCaseSensitive)
Definition: fbxpropertypage.h:817
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39
FbxPropertyPage::Find
FbxInt Find(FbxInt pId, const char *pName, FbxPropertyPage *pTypeInfo, bool pCaseSensitive, const char *pChildrenSeparators)
Definition: fbxpropertypage.h:874

◆ AddEnumValue()

int AddEnumValue ( FbxInt  pId,
const char *  pStringValue 
)
inline

Definition at line 897 of file fbxpropertypage.h.

898  {
899  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
900  // Don't make it writeable (Keep it shared)
901  return lPropertyInfo ? lPropertyInfo->AddEnumValue(pStringValue) : - 1;
902  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyInfo::AddEnumValue
int AddEnumValue(const char *pStringValue)
Definition: fbxpropertypage.h:78

◆ InsertEnumValue()

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

Definition at line 904 of file fbxpropertypage.h.

905  {
906  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
907  // Don't make it writeable (Keep it shared)
908  if (lPropertyInfo) lPropertyInfo->InsertEnumValue(pIndex,pStringValue);
909  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyInfo::InsertEnumValue
void InsertEnumValue(int pIndex, const char *pStringValue)
Definition: fbxpropertypage.h:93
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ GetEnumCount()

int GetEnumCount ( FbxInt  pId)
inline

Definition at line 911 of file fbxpropertypage.h.

912  {
913  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
914  // Don't make it writeable (Keep it shared)
915  return lPropertyInfo ? lPropertyInfo->GetEnumCount() : 0;
916  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ SetEnumValue()

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

Definition at line 918 of file fbxpropertypage.h.

919  {
920  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
921  // Don't make it writeable (Keep it shared)
922  if (lPropertyInfo) lPropertyInfo->SetEnumValue(pIndex,pStringValue);
923  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyInfo::SetEnumValue
void SetEnumValue(int pIndex, const char *pStringValue)
Definition: fbxpropertypage.h:112

◆ RemoveEnumValue()

void RemoveEnumValue ( FbxInt  pId,
int  pIndex 
)
inline

Definition at line 925 of file fbxpropertypage.h.

926  {
927  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
928  // Don't make it writeable (Keep it shared)
929  if (lPropertyInfo) lPropertyInfo->RemoveEnumValue(pIndex);
930  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyInfo::RemoveEnumValue
void RemoveEnumValue(int pIndex)
Definition: fbxpropertypage.h:126

◆ GetEnumValue()

char* GetEnumValue ( FbxInt  pId,
int  pIndex 
)
inline

Definition at line 932 of file fbxpropertypage.h.

933  {
934  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
935  return lPropertyInfo ? lPropertyInfo->GetEnumValue(pIndex) : (char*)"";
936  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyInfo::GetEnumValue
char * GetEnumValue(int pIndex)
Definition: fbxpropertypage.h:138

◆ ClearConnectCache()

void ClearConnectCache ( FbxInt  pId)
inline

Definition at line 940 of file fbxpropertypage.h.

941  {
942  FbxPropertyPage* lReferencePage = 0;
943  FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
944 
945  // Connections are not considered propagated so
946  // make sure that we own the FbxPropertyConnect objects
947  if (lPropertyConnect) {
948  lPropertyConnect->ClearConnectCache();
949  }
950  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ WipeAllConnections()

void WipeAllConnections ( FbxInt  pId)
inline

Definition at line 952 of file fbxpropertypage.h.

953  {
954  FbxPropertyPage* lReferencePage = 0;
955  FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
956 
957  if (lPropertyConnect) {
958  lPropertyConnect->WipeAllConnections();
959  }
960  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyConnect::WipeAllConnections
void WipeAllConnections()
Clear all connect without sending any notification (Internal use ONLY)
Definition: fbxpropertypage.h:273
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ ConnectSrc()

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

Definition at line 962 of file fbxpropertypage.h.

963  {
964  FbxPropertyEntry* lDstEntry = ChangePropertyEntryState(pDstId,FbxPropertyFlags::eOverride);
965  FbxPropertyEntry* lSrcEntry = pSrcPage->ChangePropertyEntryState(pSrcId,FbxPropertyFlags::eOverride);
966  FbxPropertyConnect* lDstConnect= lDstEntry->Get( FBX_TYPE(FbxPropertyConnect) );
967  FbxPropertyConnect* lSrcConnect= lSrcEntry->Get( FBX_TYPE(FbxPropertyConnect) );
968 
969  // Make sure we have a connection point on both sides of the connection
970  if (!lDstConnect) {
971  lDstConnect = FbxPropertyConnect::Create( this,pDstId );
972  lDstEntry->Set( lDstConnect );
973  }
974  if (!lSrcConnect) {
975  lSrcConnect = FbxPropertyConnect::Create( pSrcPage,pSrcId );
976  lSrcEntry->Set( lSrcConnect );
977  }
978 
979  // Must @@@@@@@ Propagate to inherited children
980  return lDstConnect->ConnectSrc(lSrcConnect,pType);
981 
982  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FbxPropertyEntry::Get
FbxPropertyInfo * Get(const FbxPropertyInfo *)
Definition: fbxpropertypage.h:353
FbxPropertyEntry::Set
void Set(FbxPropertyInfo *pInfo)
Definition: fbxpropertypage.h:355
FbxPropertyFlags::eOverride
Property override this flag from its reference property.
Definition: fbxpropertydef.h:33
FbxPropertyConnect::Create
static FbxPropertyConnect * Create(FbxPropertyPage *pPage, FbxInt pId)
Definition: fbxpropertypage.h:250
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyConnect::ConnectSrc
bool ConnectSrc(FbxPropertyConnect *pSrc, FbxConnection::EType pType)
Definition: fbxpropertypage.h:279

◆ DisconnectSrc()

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

Definition at line 984 of file fbxpropertypage.h.

985  {
986  FbxPropertyPage* lDstReferencePage = 0;
987  FbxPropertyConnect* lDstConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pDstId,&lDstReferencePage );
988  FbxPropertyPage* lSrcReferencePage = 0;
989  FbxPropertyConnect* lSrcConnect = pSrcPage->GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pSrcId,&lSrcReferencePage );
990 
991  // Make sure we have a connection point on both sides of the connection
992  if (lDstConnect && lSrcConnect && lDstReferencePage==this && lSrcReferencePage==pSrcPage) {
993  // Must @@@@@@@ Remove unused connections
994  return lDstConnect->DisconnectSrc(lSrcConnect);
995  }
996  return false;
997  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyConnect::DisconnectSrc
bool DisconnectSrc(FbxPropertyConnect *pSrc)
Definition: fbxpropertypage.h:283
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ IsConnectedSrc()

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

Definition at line 999 of file fbxpropertypage.h.

1000  {
1001  FbxPropertyPage* lDstReferencePage = 0;
1002  FbxPropertyConnect* lDstConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pDstId,&lDstReferencePage );
1003  FbxPropertyPage* lSrcReferencePage = 0;
1004  FbxPropertyConnect* lSrcConnect = pSrcPage->GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pSrcId,&lSrcReferencePage );
1005 
1006  // Make sure we have a connection point on both sides of the connection
1007  if (lDstConnect && lSrcConnect && lDstReferencePage==this && lSrcReferencePage==pSrcPage) {
1008  // Must @@@@@@@ Remove unused connections
1009  return lDstConnect->IsConnectedSrc(lSrcConnect);
1010  }
1011  return false;
1012  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyConnect::IsConnectedSrc
bool IsConnectedSrc(FbxPropertyConnect *pSrc)
Definition: fbxpropertypage.h:287
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ GetSrcCount()

int GetSrcCount ( FbxInt  pId,
FbxConnectionPointFilter *  pFilter 
)
inline

Definition at line 1014 of file fbxpropertypage.h.

1015  {
1016  FbxPropertyPage* lReferencePage = 0;
1017  FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
1018 
1019  // Connections are not considered propagated so
1020  // make sure that we own the FbxPropertyConnect objects
1021  return (lPropertyConnect && lReferencePage==this) ? lPropertyConnect->GetSrcCount(pFilter) : 0;
1022  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyConnect::GetSrcCount
int GetSrcCount(FbxConnectionPointFilter *pFilter)
Definition: fbxpropertypage.h:291
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ GetSrc()

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

Definition at line 1024 of file fbxpropertypage.h.

1025  {
1026  FbxPropertyPage* lReferencePage = 0;
1027  FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
1028 
1029  // Connections are always overridden
1030  // make sure that we own the FbxPropertyConnect Item
1031  if (lPropertyConnect && lReferencePage==this)
1032  {
1033  FbxPropertyConnect* lSrc = lPropertyConnect->GetSrc(pFilter,pIndex);
1034  if (lSrc)
1035  {
1036  if (pSrcPage) *pSrcPage = lSrc->GetPage();
1037  if (pSrcId) *pSrcId = lSrc->GetPropertyId();
1038  return true;
1039  }
1040  }
1041  return false;
1042  }
FbxPropertyConnect::GetSrc
FbxPropertyConnect * GetSrc(FbxConnectionPointFilter *pFilter, int pIndex)
Definition: fbxpropertypage.h:295
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyConnect::GetPage
FbxPropertyPage * GetPage()
Definition: fbxpropertypage.h:262
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ ConnectDst()

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

Definition at line 1044 of file fbxpropertypage.h.

1045  {
1046  return pDstPage->ConnectSrc(pDstId,this,pSrcId,pType);
1047  }
FbxPropertyPage::ConnectSrc
bool ConnectSrc(FbxInt pDstId, FbxPropertyPage *pSrcPage, FbxInt pSrcId, FbxConnection::EType pType)
Definition: fbxpropertypage.h:962

◆ DisconnectDst()

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

Definition at line 1049 of file fbxpropertypage.h.

1050  {
1051  return pDstPage->DisconnectSrc(pDstId,this,pSrcId);
1052  }
FbxPropertyPage::DisconnectSrc
bool DisconnectSrc(FbxInt pDstId, FbxPropertyPage *pSrcPage, FbxInt pSrcId)
Definition: fbxpropertypage.h:984

◆ IsConnectedDst()

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

Definition at line 1054 of file fbxpropertypage.h.

1055  {
1056  return pDstPage->IsConnectedSrc(pDstId,this,pSrcId);
1057  }
FbxPropertyPage::IsConnectedSrc
bool IsConnectedSrc(FbxInt pDstId, FbxPropertyPage *pSrcPage, FbxInt pSrcId)
Definition: fbxpropertypage.h:999

◆ GetDstCount()

int GetDstCount ( FbxInt  pId,
FbxConnectionPointFilter *  pFilter 
)
inline

Definition at line 1059 of file fbxpropertypage.h.

1060  {
1061  FbxPropertyPage* lReferencePage = 0;
1062  FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
1063 
1064  // Connections are not considered propagated so
1065  // make sure that we own the FbxPropertyConnect objects
1066  return (lPropertyConnect && lReferencePage==this) ? lPropertyConnect->GetDstCount(pFilter) : 0;
1067  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyConnect::GetDstCount
int GetDstCount(FbxConnectionPointFilter *pFilter)
Definition: fbxpropertypage.h:312
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ GetDst()

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

Definition at line 1069 of file fbxpropertypage.h.

1070  {
1071  FbxPropertyPage* lReferencePage = 0;
1072  FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
1073 
1074  // Connections are always overridden
1075  // make sure that we own the FbxPropertyConnect Item
1076  if (lPropertyConnect && lReferencePage==this)
1077  {
1078  FbxPropertyConnect* lDst = lPropertyConnect->GetDst(pFilter,pIndex);
1079  if (lDst)
1080  {
1081  if (pDstPage) *pDstPage = lDst->GetPage();
1082  if (pDstId) *pDstId = lDst->GetPropertyId();
1083  return true;
1084  }
1085  }
1086  return false;
1087  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyConnect::GetPage
FbxPropertyPage * GetPage()
Definition: fbxpropertypage.h:262
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyConnect::GetDst
FbxPropertyConnect * GetDst(FbxConnectionPointFilter *pFilter, int pIndex)
Definition: fbxpropertypage.h:316
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ HasMinMax()

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

Definition at line 1093 of file fbxpropertypage.h.

1094  {
1095  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
1096 
1097  return lPropertyInfo ? lPropertyInfo->HasMinMax(pValueId) : false;
1098  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyInfo::HasMinMax
bool HasMinMax(EValueIndex pId) const
Definition: fbxpropertypage.h:153
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ GetMinMax()

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

Definition at line 1100 of file fbxpropertypage.h.

1101  {
1102  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
1103  // Don't make it writeable (Keep it shared)
1104  return lPropertyInfo ? lPropertyInfo->GetMinMax(pValueId,pValue,pValueType) : false;
1105  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyInfo::GetMinMax
bool GetMinMax(EValueIndex pId, void *pValue, EFbxType pValueType) const
Definition: fbxpropertypage.h:158

◆ SetMinMax()

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

Definition at line 1107 of file fbxpropertypage.h.

1108  {
1109  FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
1110  // Don't make it writeable (Keep it shared)
1111  return lPropertyInfo ? lPropertyInfo->SetMinMax(pValueId,pValue,pValueType) : false;
1112  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyInfo::SetMinMax
bool SetMinMax(EValueIndex pId, const void *pValue, EFbxType pValueType)
Definition: fbxpropertypage.h:166
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471

◆ Get() [1/2]

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

Definition at line 1116 of file fbxpropertypage.h.

1117  {
1118  FbxPropertyValue* lPropertyValue = GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId );
1119  return lPropertyValue ? lPropertyValue->Get(pValue,pValueType) : 0;
1120  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyValue::Get
bool Get(void *pValue, EFbxType pValueType)

◆ Set() [1/2]

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

Definition at line 1122 of file fbxpropertypage.h.

1123  {
1124  if( pCheckValueEquality )
1125  {
1126  FbxPropertyPage* lReferencePage = NULL;
1127  FbxPropertyValue* lPropertyValue = GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId,&lReferencePage );
1128  void* lCurrentValue = FbxTypeAllocate( pValueType );
1129  bool lValuesEqual = false;
1130  bool lValueChanged = false;
1131  if( lReferencePage && lReferencePage != this )
1132  {
1133  // this page inherits, so check if we have to override the value.
1134  if( lPropertyValue )
1135  {
1136  lPropertyValue->Get( lCurrentValue, pValueType );
1137  lValuesEqual = FbxTypeCompare( pValue, lCurrentValue, pValueType );
1138  }
1139  }
1140  else
1141  {
1142  FbxPropertyPage* lReferencePage2 = NULL;
1143  FbxPropertyValue* lPropertyValue2 = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId,&lReferencePage2 ) : NULL;
1144  if( lReferencePage2 && lPropertyValue2 )
1145  {
1146  // this page is an override, but there is another page before us that overrides the value
1147  lPropertyValue2->Get( lCurrentValue, pValueType );
1148  lValuesEqual = FbxTypeCompare( pValue, lCurrentValue, pValueType );
1149 
1150  if( lValuesEqual )
1151  {
1152  ChangePropertyItemState( FBX_TYPE(FbxPropertyValue), pId, FbxPropertyFlags::eInherit );
1153  lValueChanged = true;
1154  }
1155 
1156  }
1157  // else this page is the originator of the property, so no need to check,
1158  }
1159 
1160  FbxTypeDeallocate(pValueType, lCurrentValue);
1161  lCurrentValue = NULL;
1162 
1163  if( lValuesEqual )
1164  return lValueChanged;
1165  }
1166 
1167  FbxPropertyValue* lPropertyValue = ChangePropertyItemState( FBX_TYPE(FbxPropertyValue),pId,FbxPropertyFlags::eOverride );
1168  return lPropertyValue ? lPropertyValue->Set(pValue,pValueType) : false;
1169  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
FbxPropertyValue::Set
bool Set(const void *pValue, EFbxType pValueType)
NULL
#define NULL
Definition: fbxarch.h:210
FbxPropertyFlags::eOverride
Property override this flag from its reference property.
Definition: fbxpropertydef.h:33
FbxPropertyFlags::eInherit
Property inherit this flag from its reference property.
Definition: fbxpropertydef.h:34
FbxPropertyPage::ChangePropertyItemState
T * ChangePropertyItemState(const T *pItemType, FbxInt pIndex, FbxPropertyFlags::EInheritType pInheritType)
Definition: fbxpropertypage.h:459
FbxTypeCompare
bool FbxTypeCompare(const void *pA, const void *pB, const EFbxType pType)
Compare two values of the same type.
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxTypeDeallocate
bool FbxTypeDeallocate(const EFbxType pType, void *pData)
Destroys an fbx primitive type.
FbxTypeAllocate
void * FbxTypeAllocate(const EFbxType pType)
Creates a fbx primitive type and initializes its memory.
FbxPropertyValue::Get
bool Get(void *pValue, EFbxType pValueType)
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ GetValueInherit()

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

Definition at line 1171 of file fbxpropertypage.h.

1172  {
1173  FbxPropertyPage* lReferencePage = NULL;
1174  GetPropertyItem(FBX_TYPE(FbxPropertyValue), pId, &lReferencePage);
1175 
1176  // check one level
1177  if( !pCheckInstanceOf )
1178  {
1179  return lReferencePage == this ? FbxPropertyFlags::eOverride : FbxPropertyFlags::eInherit;
1180  }
1181  else
1182  {
1183  if( lReferencePage == this ) return FbxPropertyFlags::eOverride; // this page is either an override, or the originator
1184  else if( !lReferencePage->mInstanceOf ) return FbxPropertyFlags::eInherit; // the reference is the class root, so we must be inheriting
1185 
1186  // The reference page is not the class root, might be another override, or the originator.
1187  FbxPropertyValue* lPropertyValue = lReferencePage->mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyValue), pId );
1188 
1189  // if lReferencePage->mInstanceOf has the property value,
1190  // lReferencePage is an override
1191  // else
1192  // its the originator, so this page inherits from it.
1193  return lPropertyValue ? FbxPropertyFlags::eOverride : FbxPropertyFlags::eInherit;
1194  }
1195  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
NULL
#define NULL
Definition: fbxarch.h:210
FbxPropertyFlags::eOverride
Property override this flag from its reference property.
Definition: fbxpropertydef.h:33
FbxPropertyFlags::eInherit
Property inherit this flag from its reference property.
Definition: fbxpropertydef.h:34
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ SetValueInherit()

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

Definition at line 1197 of file fbxpropertypage.h.

1198  {
1199  // no support for this mode yet
1200  if( FbxPropertyFlags::eDeleted == pType )
1201  return false;
1202 
1203  ChangePropertyItemState( FBX_TYPE(FbxPropertyValue), pId, pType );
1204 
1205  // Above call doesn't return error codes, so just check that we match types.
1206  return GetValueInherit(pId, false) == pType;
1207  }
FbxPropertyPage::GetValueInherit
FbxPropertyFlags::EInheritType GetValueInherit(FbxInt pId, bool pCheckInstanceOf) const
Definition: fbxpropertypage.h:1171
FbxPropertyPage::ChangePropertyItemState
T * ChangePropertyItemState(const T *pItemType, FbxInt pIndex, FbxPropertyFlags::EInheritType pInheritType)
Definition: fbxpropertypage.h:459
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyFlags::eDeleted
Property has been deleted, so inheritance is invalid.
Definition: fbxpropertydef.h:35

◆ GetDefaultValue()

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

Definition at line 1209 of file fbxpropertypage.h.

1210  {
1211  FbxPropertyPage* lReferencePage = GetFirstPropertyItem( pId, FBX_TYPE(FbxPropertyValue) );
1212  FbxPropertyValue* lPropertyValue = lReferencePage ? lReferencePage->GetPropertyItem( FBX_TYPE(FbxPropertyValue), pId ) : NULL;
1213 
1214  return lPropertyValue ? lPropertyValue->Get( pValue, pValueType ) : false;
1215  }
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
NULL
#define NULL
Definition: fbxarch.h:210
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage::GetFirstPropertyItem
FbxPropertyPage * GetFirstPropertyItem(FbxInt pId, const T *pItem) const
Definition: fbxpropertypage.h:496
FbxPropertyValue::Get
bool Get(void *pValue, EFbxType pValueType)
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ Set() [2/2]

bool Set ( FbxInt  pId,
const T &  pValue 
)
inline

Definition at line 1219 of file fbxpropertypage.h.

1219 { return Set( pId,&pValue,FbxTypeOf(pValue),true ); }
FbxTypeOf
EFbxType FbxTypeOf(const FbxChar &)
Definition: fbxpropertytypes.h:533
FbxPropertyPage::Set
bool Set(FbxInt pId, const void *pValue, EFbxType pValueType, bool pCheckValueEquality)
Definition: fbxpropertypage.h:1122

◆ Get() [2/2]

T Get ( FbxInt  pId,
const T *  pFBX_TYPE 
)
inline

Definition at line 1220 of file fbxpropertypage.h.

1220 { T lValue; Get( pId,&lValue,FbxTypeOf(lValue) ); return lValue; }
FbxPropertyPage::Get
bool Get(FbxInt pId, void *pValue, EFbxType pValueType)
Definition: fbxpropertypage.h:1116
FbxTypeOf
EFbxType FbxTypeOf(const FbxChar &)
Definition: fbxpropertytypes.h:533

◆ SetDataPtr()

void SetDataPtr ( void *  pDataPtr)
inline

Definition at line 1223 of file fbxpropertypage.h.

1223 { mDataPtr = pDataPtr; }

◆ GetDataPtr()

void* GetDataPtr ( ) const
inline

Definition at line 1224 of file fbxpropertypage.h.

1224 { return mDataPtr; }

◆ PushPropertiesToParentInstance()

void PushPropertiesToParentInstance ( )
inline

Definition at line 1228 of file fbxpropertypage.h.

1229  {
1230  if (mInstanceOf) {
1231  const int lCount = GetPropertyEntryCount();
1232  // push the existing properties into the parent
1233  // ----------------------------------------------
1234  for( int i = 0; i < lCount; ++i )
1235  {
1236  FbxPropertyEntry* lParentEntry = mInstanceOf->ChangePropertyEntryState( (FbxInt)i,FbxPropertyFlags::eOverride );
1237  FbxPropertyEntry* lEntry = GetPropertyEntry( (FbxInt)i );
1238 
1239  if( !lParentEntry )
1240  {
1241  lParentEntry = FbxPropertyEntry::Create( lEntry->GetParentId(), 0, 0, 0 );
1242  mInstanceOf->mEntryMap.Insert( i, lParentEntry );
1243 
1244  //mInstanceOf->AddChild(i);
1245 
1246  }
1247 
1248  FBX_ASSERT( lParentEntry );
1249 
1250  // Add it to the parent
1251  // Don't touch the connections
1252  // -----------------------------------------
1253  if (lParentEntry) {
1254  lParentEntry->Set( lEntry->Get(FBX_TYPE(FbxPropertyInfo)) );
1255  lParentEntry->Set( lEntry->Get(FBX_TYPE(FbxPropertyValue)) );
1256  lParentEntry->Set( lEntry->Get(FBX_TYPE(FbxPropertyFlags)) );
1257  }
1258 
1259  /*
1260  else {
1261  mInstanceOf->Add(
1262  lEntry->GetParentId(),
1263  lEntry->Get(FBX_TYPE(FbxPropertyInfo)), // The info
1264  lEntry->Get(FBX_TYPE(FbxPropertyValue)), // The Value
1265  0, // The connections
1266  false,
1267  false
1268  );
1269  }
1270  */
1271 
1272  // Empty the current entry
1273  // Don't touch the connections
1274  // -----------------------------------------
1275  ChangePropertyItemState(FBX_TYPE(FbxPropertyInfo), i,FbxPropertyFlags::eInherit);
1276  ChangePropertyItemState(FBX_TYPE(FbxPropertyValue), i,FbxPropertyFlags::eInherit);
1277  ChangePropertyItemState(FBX_TYPE(FbxPropertyFlags), i,FbxPropertyFlags::eInherit);
1278  }
1279  }
1280  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FbxPropertyEntry::Get
FbxPropertyInfo * Get(const FbxPropertyInfo *)
Definition: fbxpropertypage.h:353
FbxMap::Insert
FbxPair< RecordType *, bool > Insert(const KeyType &pKey, const ValueType &pValue)
Insert a key-value pair.
Definition: fbxmap.h:119
FbxPropertyEntry::Set
void Set(FbxPropertyInfo *pInfo)
Definition: fbxpropertypage.h:355
FbxPropertyFlags::eOverride
Property override this flag from its reference property.
Definition: fbxpropertydef.h:33
FbxPropertyEntry::Create
static FbxPropertyEntry * Create(FbxInt pParentId, FbxPropertyInfo *pInfo, FbxPropertyValue *pValue, FbxPropertyConnect *pConnect)
Definition: fbxpropertypage.h:346
FbxPropertyFlags::eInherit
Property inherit this flag from its reference property.
Definition: fbxpropertydef.h:34
FbxPropertyPage::ChangePropertyItemState
T * ChangePropertyItemState(const T *pItemType, FbxInt pIndex, FbxPropertyFlags::EInheritType pInheritType)
Definition: fbxpropertypage.h:459
FbxPropertyEntry::GetParentId
FbxInt GetParentId()
Definition: fbxpropertypage.h:350
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39

◆ GetInstanceOf() [1/2]

const FbxPropertyPage* GetInstanceOf ( ) const
inline

Definition at line 1282 of file fbxpropertypage.h.

1282 { return mInstanceOf; }

◆ GetInstanceOf() [2/2]

FbxPropertyPage* GetInstanceOf ( )
inline

Definition at line 1283 of file fbxpropertypage.h.

1283 { return mInstanceOf; }

◆ GetInstances() [1/2]

const FbxArray<FbxPropertyPage*>& GetInstances ( ) const
inline

Definition at line 1285 of file fbxpropertypage.h.

1285 { return mInstances; }

◆ GetInstances() [2/2]

FbxArray<FbxPropertyPage*>& GetInstances ( )
inline

Definition at line 1286 of file fbxpropertypage.h.

1286 { return mInstances; }

◆ GetFlags()

FbxPropertyFlags::EFlags GetFlags ( FbxInt  pId = 0) const
inline

Definition at line 1291 of file fbxpropertypage.h.

1292  {
1293  FbxPropertyPage* lFoundIn = NULL;
1294  FbxPropertyFlags* lPropertyFlags = GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn );
1295  FbxPropertyFlags::EFlags lFlags = FbxPropertyFlags::eNone;
1296 
1297  if( lPropertyFlags )
1298  {
1299  if( !mInstanceOf ) // no inheritance.
1300  lFlags = lPropertyFlags->GetFlags();
1301  else
1302  {
1303  lFlags = mInstanceOf->GetFlags(pId);
1304  lFlags = lPropertyFlags->GetMergedFlags(lFlags);
1305  }
1306  }
1307  return lFlags;
1308  }
FbxPropertyFlags::GetMergedFlags
FbxPropertyFlags::EFlags GetMergedFlags(FbxPropertyFlags::EFlags pFlags) const
FbxPropertyFlags::EFlags
EFlags
Property flags that affect their behaviors.
Definition: fbxpropertydef.h:39
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
NULL
#define NULL
Definition: fbxarch.h:210
FbxPropertyPage::GetFlags
FbxPropertyFlags::EFlags GetFlags(FbxInt pId=0) const
Definition: fbxpropertypage.h:1291
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyFlags::GetFlags
FbxPropertyFlags::EFlags GetFlags() const
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ ModifyFlags()

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

Definition at line 1310 of file fbxpropertypage.h.

1311  {
1312  if( pCheckFlagEquality )
1313  {
1314  FbxPropertyPage* lFoundIn = NULL;
1315  FbxPropertyFlags* lFlag = GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn );
1316 
1317  if( lFlag )
1318  {
1319  if( lFoundIn == this )
1320  {
1321  // set them in us.
1322  lFlag->ModifyFlags( pFlags, pValue );
1323 
1324  // we override this entry, check if we need to revert
1325  FbxPropertyFlags* lInheritedFlags = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId ) : NULL;
1326  if( lInheritedFlags && lInheritedFlags->Equal( *lFlag, pFlags ) )
1327  {
1328  lFlag->UnsetMask( pFlags );
1329 
1330  if( lFlag->GetMask() == 0 )
1331  ChangePropertyItemState( FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eInherit );
1332 
1333  return true;
1334  }
1335  }
1336  else
1337  {
1338  // its not us. Just check if we need to set.
1339  FbxPropertyFlags lNewValues( pFlags );
1340  if( lFlag->Equal( lNewValues, pFlags ) )
1341  return true;
1342  }
1343  }
1344  }
1345 
1346  FbxPropertyFlags* lPropertyFlags = ChangePropertyItemState(FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eOverride);
1347  return lPropertyFlags ? lPropertyFlags->ModifyFlags( pFlags, pValue ) : false;
1348  }
FbxPropertyFlags::UnsetMask
bool UnsetMask(FbxPropertyFlags::EFlags pFlags)
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
NULL
#define NULL
Definition: fbxarch.h:210
FbxPropertyFlags::ModifyFlags
bool ModifyFlags(FbxPropertyFlags::EFlags pFlags, bool pValue)
FbxPropertyFlags::eOverride
Property override this flag from its reference property.
Definition: fbxpropertydef.h:33
FbxPropertyFlags::eInherit
Property inherit this flag from its reference property.
Definition: fbxpropertydef.h:34
FbxPropertyPage::ChangePropertyItemState
T * ChangePropertyItemState(const T *pItemType, FbxInt pIndex, FbxPropertyFlags::EInheritType pInheritType)
Definition: fbxpropertypage.h:459
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyFlags::GetMask
FbxPropertyFlags::EFlags GetMask() const
FbxPropertyFlags::Equal
bool Equal(const FbxPropertyFlags &pOther, FbxPropertyFlags::EFlags pFlags) const
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ GetFlagsInheritType()

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

Definition at line 1350 of file fbxpropertypage.h.

1351  {
1352  FbxPropertyPage* lFoundIn = NULL;
1353  FbxPropertyFlags* lPropertyFlags = GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn );
1354 
1355  if( !pCheckInstanceOf )
1356  return lFoundIn != this ? FbxPropertyFlags::eInherit : ( lPropertyFlags ? lPropertyFlags->GetFlagsInheritType(pFlags) : FbxPropertyFlags::eInherit );
1357  else
1358  {
1359  // This code basically counts the number of overrides for the
1360  // given flags. The original entry is always considered an override.
1361  // so if we see more than one, something overrode the original.
1362  // and thus we are an override.
1363  FbxPropertyPage* lRefPage = lFoundIn;
1364  bool lFoundOverride = false;
1365  while( lRefPage )
1366  {
1367  lPropertyFlags = lRefPage->GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId );
1368 
1369  if( !lPropertyFlags )
1370  break; // gone too far, break.
1371 
1372  if( lPropertyFlags->GetFlagsInheritType( pFlags ) == FbxPropertyFlags::eOverride )
1373  {
1374  if( this == lRefPage || lFoundOverride )
1375  return FbxPropertyFlags::eOverride; // found two overrides or this page is the override.
1376  else
1377  lFoundOverride = true; // signal that we found the first override.
1378  }
1379  lRefPage = lRefPage->mInstanceOf;
1380  }
1381 
1382  return FbxPropertyFlags::eInherit;
1383  }
1384  }
FbxPropertyFlags::GetFlagsInheritType
FbxPropertyFlags::EInheritType GetFlagsInheritType(FbxPropertyFlags::EFlags pFlags) const
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
NULL
#define NULL
Definition: fbxarch.h:210
FbxPropertyFlags::eOverride
Property override this flag from its reference property.
Definition: fbxpropertydef.h:33
FbxPropertyFlags::eInherit
Property inherit this flag from its reference property.
Definition: fbxpropertydef.h:34
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ SetFlagsInheritType()

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

Definition at line 1386 of file fbxpropertypage.h.

1387  {
1388  FbxPropertyPage* lFoundIn = NULL;
1389  FbxPropertyFlags* lPropertyFlags = NULL;
1390 
1391  if( FbxPropertyFlags::eOverride == pInheritType )
1392  {
1393  lPropertyFlags = ChangePropertyItemState( FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eOverride );
1394 
1395  // we should initialize our flag to the inherited value, if any.
1396  FbxPropertyFlags* lParentFlags = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId ) : NULL;
1397  if( lParentFlags && lPropertyFlags )
1398  {
1399  FbxPropertyFlags::EFlags lParentValues = lParentFlags->GetFlags();
1400  lPropertyFlags->SetFlags( pFlags, lParentValues );
1401  return lPropertyFlags->SetMask( pFlags );
1402  }
1403 
1404  return false;
1405  }
1406  else if( FbxPropertyFlags::eInherit == pInheritType )
1407  {
1408  lPropertyFlags = GetPropertyItem(FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn);
1409  if( !lPropertyFlags ) return false;
1410  if( lFoundIn != this ) return true; // not us
1411  lPropertyFlags->UnsetMask( pFlags );
1412  if( lPropertyFlags->GetMask() == 0 ) // revert
1413  ChangePropertyItemState( FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eInherit );
1414 
1415  return true;
1416  }
1417  return false;
1418  }
FbxPropertyFlags::UnsetMask
bool UnsetMask(FbxPropertyFlags::EFlags pFlags)
FbxPropertyFlags::EFlags
EFlags
Property flags that affect their behaviors.
Definition: fbxpropertydef.h:39
FbxPropertyPage::GetPropertyItem
T * GetPropertyItem(const T *pItemType, FbxInt pIndex, FbxPropertyPage **pFoundIn=0) const
Definition: fbxpropertypage.h:442
NULL
#define NULL
Definition: fbxarch.h:210
FbxPropertyFlags::SetMask
bool SetMask(FbxPropertyFlags::EFlags pFlags)
FbxPropertyFlags::eOverride
Property override this flag from its reference property.
Definition: fbxpropertydef.h:33
FbxPropertyFlags::eInherit
Property inherit this flag from its reference property.
Definition: fbxpropertydef.h:34
FbxPropertyFlags::SetFlags
bool SetFlags(FbxPropertyFlags::EFlags pMask, FbxPropertyFlags::EFlags pFlags)
FbxPropertyPage::ChangePropertyItemState
T * ChangePropertyItemState(const T *pItemType, FbxInt pIndex, FbxPropertyFlags::EInheritType pInheritType)
Definition: fbxpropertypage.h:459
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FbxPropertyFlags::GetFlags
FbxPropertyFlags::EFlags GetFlags() const
FbxPropertyFlags::GetMask
FbxPropertyFlags::EFlags GetMask() const
FbxPropertyPage
Definition: fbxpropertypage.h:432

◆ BeginCreateOrFindProperty()

void BeginCreateOrFindProperty ( )
inline

Definition at line 1420 of file fbxpropertypage.h.

1421  {
1422  if( 0 == mNameMap.mFirst )
1423  {
1424  mNameMap.mSecond.Reserve(20);
1425 
1426  // push the existing properties into the map. Note: this includes the root property!
1427  FbxInt lFoundId = FBXSDK_PROPERTY_ID_ROOT;
1428  FbxPropertyEntry* lEntry = GetPropertyEntry(lFoundId);
1429  while(lFoundId != FBXSDK_PROPERTY_ID_NULL)
1430  {
1431  FbxPropertyInfo* lInfo = lEntry->Get(FBX_TYPE(FbxPropertyInfo));
1432  //FBX_ASSERT( lInfo );
1433  if (lInfo)
1434  {
1435  mNameMap.mSecond.Insert(FbxNameMapKey(lEntry->GetParentId(), lInfo->GetName()), lFoundId);
1436  }
1437  lFoundId = GetMinimumPropertyIdAndEntry(lFoundId, &lEntry);
1438  }
1439  mNameMap.mFirst++;
1440  }
1441  }
FbxPropertyEntry
Definition: fbxpropertypage.h:343
FBXSDK_PROPERTY_ID_NULL
#define FBXSDK_PROPERTY_ID_NULL
Definition: fbxpropertydef.h:22
FbxPropertyEntry::Get
FbxPropertyInfo * Get(const FbxPropertyInfo *)
Definition: fbxpropertypage.h:353
FbxMap::Insert
FbxPair< RecordType *, bool > Insert(const KeyType &pKey, const ValueType &pValue)
Insert a key-value pair.
Definition: fbxmap.h:119
FbxNameMapKey
FbxPair< FbxInt, const char * > FbxNameMapKey
Definition: fbxpropertypage.h:25
FbxMap::Reserve
void Reserve(unsigned int pRecordCount)
Preallocate memory.
Definition: fbxmap.h:104
FbxPropertyEntry::GetParentId
FbxInt GetParentId()
Definition: fbxpropertypage.h:350
FBX_TYPE
#define FBX_TYPE(class)
Convert the class type parameter into a C class parameter for other function inputs.
Definition: fbxobject.h:1471
FBXSDK_PROPERTY_ID_ROOT
#define FBXSDK_PROPERTY_ID_ROOT
Definition: fbxpropertydef.h:23
FbxPair::mSecond
Second mSecond
The second object in the pair.
Definition: fbxpair.h:57
FbxPropertyInfo::GetName
FbxStringSymbol GetName() const
Definition: fbxpropertypage.h:64
FbxInt
signed int FbxInt
Definition: fbxtypes.h:39
FbxPair::mFirst
First mFirst
The first object in the pair.
Definition: fbxpair.h:56

◆ EndCreateOrFindProperty()

void EndCreateOrFindProperty ( )
inline

Definition at line 1443 of file fbxpropertypage.h.

1444  {
1445  if( mNameMap.mFirst > 0 )
1446  {
1447  if( --(mNameMap.mFirst) == 0 )
1448  mNameMap.mSecond.Clear();
1449  }
1450  }
FbxPair::mSecond
Second mSecond
The second object in the pair.
Definition: fbxpair.h:57
FbxMap::Clear
void Clear()
Clear the map.
Definition: fbxmap.h:133
FbxPair::mFirst
First mFirst
The first object in the pair.
Definition: fbxpair.h:56

◆ Is()

bool Is ( FbxPropertyPage *  pPage)
inlineprotected

Definition at line 1550 of file fbxpropertypage.h.

1551  {
1552  // @@@@@@@@@@@@@@@ Must complete for sub types
1553  return this==pPage;
1554  }

Friends And Related Function Documentation

◆ FbxPropertyHandle

friend class FbxPropertyHandle
friend

Definition at line 1742 of file fbxpropertypage.h.

◆ fbxsdk ::FbxNew [1/47]

T* fbxsdk ::FbxNew ( )
friend

◆ fbxsdk ::FbxNew [2/47]

T* fbxsdk ::FbxNew ( T1 &  p1)
friend

◆ fbxsdk ::FbxNew [3/47]

T* fbxsdk ::FbxNew ( const T1 &  p1)
friend

◆ fbxsdk ::FbxNew [4/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
T2 &  p2 
)
friend

◆ fbxsdk ::FbxNew [5/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
const T2 &  p2 
)
friend

◆ fbxsdk ::FbxNew [6/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2 
)
friend

◆ fbxsdk ::FbxNew [7/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2 
)
friend

◆ fbxsdk ::FbxNew [8/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
T2 &  p2,
T3 &  p3 
)
friend

◆ fbxsdk ::FbxNew [9/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
T2 &  p2,
const T3 &  p3 
)
friend

◆ fbxsdk ::FbxNew [10/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
const T2 &  p2,
T3 &  p3 
)
friend

◆ fbxsdk ::FbxNew [11/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
const T2 &  p2,
const T3 &  p3 
)
friend

◆ fbxsdk ::FbxNew [12/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
T3 &  p3 
)
friend

◆ fbxsdk ::FbxNew [13/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
const T3 &  p3 
)
friend

◆ fbxsdk ::FbxNew [14/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
T3 &  p3 
)
friend

◆ fbxsdk ::FbxNew [15/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3 
)
friend

◆ fbxsdk ::FbxNew [16/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
T2 &  p2,
T3 &  p3,
T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [17/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
T2 &  p2,
T3 &  p3,
const T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [18/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
T2 &  p2,
const T3 &  p3,
T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [19/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
T2 &  p2,
const T3 &  p3,
const T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [20/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
const T2 &  p2,
T3 &  p3,
T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [21/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
const T2 &  p2,
T3 &  p3,
const T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [22/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
const T2 &  p2,
const T3 &  p3,
T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [23/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
const T2 &  p2,
const T3 &  p3,
const T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [24/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
T3 &  p3,
T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [25/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
T3 &  p3,
const T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [26/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
const T3 &  p3,
T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [27/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
const T3 &  p3,
const T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [28/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
T3 &  p3,
T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [29/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
T3 &  p3,
const T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [30/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [31/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
const T4 &  p4 
)
friend

◆ fbxsdk ::FbxNew [32/47]

T* fbxsdk ::FbxNew ( T1 &  p1,
T2 &  p2,
T3 &  p3,
T4 &  p4,
T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [33/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
T3 &  p3,
T4 &  p4,
T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [34/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
T3 &  p3,
T4 &  p4,
T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [35/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
const T3 &  p3,
T4 &  p4,
T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [36/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
T3 &  p3,
const T4 &  p4,
T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [37/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
T2 &  p2,
T3 &  p3,
T4 &  p4,
const T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [38/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
T4 &  p4,
T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [39/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
T3 &  p3,
const T4 &  p4,
T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [40/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
T3 &  p3,
T4 &  p4,
const T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [41/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
const T4 &  p4,
T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [42/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
T4 &  p4,
const T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [43/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
const T4 &  p4,
const T5 &  p5 
)
friend

◆ fbxsdk ::FbxNew [44/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
const T4 &  p4,
const T5 &  p5,
const T6 &  p6 
)
friend

◆ fbxsdk ::FbxNew [45/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
const T4 &  p4,
const T5 &  p5,
const T6 &  p6,
const T7 &  p7 
)
friend

◆ fbxsdk ::FbxNew [46/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
const T4 &  p4,
const T5 &  p5,
const T6 &  p6,
const T7 &  p7,
const T8 &  p8 
)
friend

◆ fbxsdk ::FbxNew [47/47]

T* fbxsdk ::FbxNew ( const T1 &  p1,
const T2 &  p2,
const T3 &  p3,
const T4 &  p4,
const T5 &  p5,
const T6 &  p6,
const T7 &  p7,
const T8 &  p8,
const T9 &  p9 
)
friend

◆ fbxsdk ::FbxDelete [1/2]

void fbxsdk ::FbxDelete ( T *  p)
friend

◆ fbxsdk ::FbxDelete [2/2]

void fbxsdk ::FbxDelete ( const T *  p)
friend

◆ fbxsdk ::FbxNewArray

T* fbxsdk ::FbxNewArray ( const int  n)
friend

◆ fbxsdk ::FbxDeleteArray

void fbxsdk ::FbxDeleteArray ( T *  p)
friend
The documentation for this class was generated from the following file: