///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance").
|
// All rights reserved.
|
//
|
// This software and its documentation and related materials are owned by
|
// the Alliance. The software may only be incorporated into application
|
// programs owned by members of the Alliance, subject to a signed
|
// Membership Agreement and Supplemental Software License Agreement with the
|
// Alliance. The structure and organization of this software are the valuable
|
// trade secrets of the Alliance and its suppliers. The software is also
|
// protected by copyright law and international treaty provisions. Application
|
// programs incorporating this software must include the following statement
|
// with their copyright notices:
|
//
|
// This application incorporates Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance.
|
// All rights reserved.
|
//
|
// By use of this software, its documentation or related materials, you
|
// acknowledge and accept the above terms.
|
///////////////////////////////////////////////////////////////////////////////
|
|
#ifndef __OD_GS_ENTITY_NODE__
|
#define __OD_GS_ENTITY_NODE__
|
|
#include "Gs/GsNode.h"
|
#include "Si/SiSpatialIndex.h"
|
#include "OdArrayMemAlloc.h"
|
#include "Gs/GsHighlightData.h"
|
|
class OdGsBaseVectorizer;
|
|
#include "TD_PackPush.h"
|
|
/** <group !!RECORDS_TD_APIRef>
|
*/
|
struct OdGsGeomPortion
|
{
|
OdGsLayerNode* m_pLayer;
|
OdRxObjectPtr m_pGsMetafile;
|
OdGsGeomPortion* m_pNext;
|
|
OdGsGeomPortion()
|
: m_pLayer(0)
|
, m_pGsMetafile(0)
|
, m_pNext(0)
|
{
|
}
|
|
void copyFrom(OdGsGeomPortion& c)
|
{
|
m_pLayer = c.m_pLayer;
|
m_pGsMetafile = c.m_pGsMetafile;
|
m_pNext = c.m_pNext;
|
}
|
|
void clear()
|
{
|
m_pLayer = NULL;
|
m_pGsMetafile = NULL;
|
m_pNext = NULL;
|
}
|
};
|
|
class OdGsBaseContext;
|
|
/** \details
|
This class implements OdGsNode descendant objects that
|
can serve as containers for other OdGsNode objects.
|
|
Library: TD_Gs
|
<group OdGs_Classes>
|
*/
|
class GS_TOOLKIT_EXPORT OdGsEntityNode : public OdGsNode, public OdSiEntity
|
{
|
OdGsEntityNode* m_pNextEntity;
|
|
struct NextEntityEntry
|
{
|
OdGsEntityNode* m_pNextEntity;
|
OdUInt32 m_entFlags;
|
};
|
void allocNextEntityArray(OdUInt32 nMaxVpId);
|
inline NextEntityEntry *firstEntEntry() { return reinterpret_cast<NextEntityEntry*>(m_pNextEntity); }
|
inline const NextEntityEntry *firstEntEntry() const { return reinterpret_cast<const NextEntityEntry*>(m_pNextEntity); }
|
inline void checkEntEntry(OdUInt32 nVpId) const { if ((OdUInt32)OdPtrToInt32(firstEntEntry()->m_pNextEntity) <= nVpId) throw OdError(eInvalidIndex); }
|
inline NextEntityEntry *nextEntEntry(OdUInt32 nVpId) { checkEntEntry(nVpId); return reinterpret_cast<NextEntityEntry*>(m_pNextEntity) + (nVpId + 1); }
|
inline const NextEntityEntry *nextEntEntry(OdUInt32 nVpId) const { checkEntEntry(nVpId); return reinterpret_cast<const NextEntityEntry*>(m_pNextEntity) + (nVpId + 1); }
|
protected:
|
mutable OdGeExtents3d m_extents;
|
|
public:
|
class GS_TOOLKIT_EXPORT Metafile : public OdRxObject
|
{
|
public:
|
void* operator new(size_t);
|
void operator delete(void *);
|
|
Metafile();
|
~Metafile();
|
|
bool play(OdGsBaseVectorizer& view, EMetafilePlayMode eMode, OdGsEntityNode& node, OdGsBaseContext* ctx = NULL);
|
bool playNested(const OdGsView& view, OdGsEntityNode& node, OdGsBaseContext& ctx);
|
bool hasDataToPlay(OdGsBaseVectorizer& view, EMetafilePlayMode eMode = kMfDisplay);
|
bool layersChanged(OdUInt32 nVpId) const;
|
bool containsVpFrozenLayers() const;
|
bool containsFrozenLayers() const;
|
|
bool isEmpty() const;
|
|
OdUInt32 m_nAwareFlags;
|
OdGeExtents3d m_extents;
|
OdGsGeomPortion m_first;
|
};
|
friend class Metafile;
|
|
/** \details
|
This template class is a specialization of the OdSmartPtr class for Metafile object pointers.
|
*/
|
typedef OdSmartPtr<Metafile> MetafilePtr;
|
|
friend class OdGsModuleObject;
|
friend class OdGsBlockReferenceNode;
|
public:
|
static void* Alloc(size_t nBytes) { return OdGsNode::s_aAlloc.getAt(1)->alloc((int)nBytes); }
|
static void Free(void* pMemBlock) { OdGsNode::s_aAlloc.getAt(1)->release(pMemBlock); }
|
static void* Realloc(void* pMemBlock, size_t newSize, size_t)
|
{
|
if(pMemBlock)
|
OdGsNode::s_aAlloc.getAt(1)->release(pMemBlock);
|
return OdGsNode::s_aAlloc.getAt(1)->alloc((int)newSize);
|
}
|
/** \details
|
This template class is a specialization of the OdArray class for MetafilePtr objects.
|
*/
|
class MetafilePtrArray: public OdArrayMemAlloc<MetafilePtr, OdObjectsAllocator<MetafilePtr>, OdGsEntityNode>
|
{
|
public:
|
~MetafilePtrArray(){}
|
};
|
|
class GS_TOOLKIT_EXPORT MetafileHolder
|
{
|
public:
|
enum
|
{
|
kArray = 1,
|
kVpDependent = 2,
|
kAwareFlagsRegenType = 4,
|
|
kRegenTypeStandard = 8,
|
kRegenTypeHideOrShade = 16,
|
kRegenTypeRenderCommand = 32,
|
kRegenTypeMask = kRegenTypeStandard | kRegenTypeHideOrShade | kRegenTypeRenderCommand,
|
|
kDependentGeometry = 64, // Marks PaperSpace entities
|
kLayerDependent = 128 // Marks compound entities w/o blocks cache (#15036)
|
};
|
MetafileHolder(): m_flags(0)
|
{
|
*reinterpret_cast<Metafile**>(rawPtr()) = 0;
|
}
|
MetafileHolder(const MetafileHolder& c): m_flags(0)
|
{
|
*reinterpret_cast<Metafile**>(rawPtr()) = 0;
|
if(!c.isValid())
|
return;
|
if(c.isArray())
|
{
|
allocateArray();
|
getArray() = const_cast<MetafileHolder&>(c).getArray();
|
}
|
else
|
{
|
*reinterpret_cast<Metafile**>(rawPtr()) = const_cast<MetafileHolder&>(c).get();
|
get()->addRef();
|
}
|
m_flags = c.m_flags;
|
}
|
~MetafileHolder()
|
{
|
destroy();
|
}
|
|
bool isValid() const { return *((const Metafile**)rawPtr()) != NULL; }
|
bool isArray() const { return GETBIT(flags(), kArray); }
|
|
bool isVpDependent() const { return GETBIT(flags(), kVpDependent); }
|
void setVpDependent(bool bOn)
|
{
|
SETBIT(m_flags, kVpDependent, bOn);
|
if(bOn)
|
{
|
SETBIT(m_flags, kRegenTypeMask, false);
|
setAwareFlagsRegenType(false);
|
}
|
}
|
|
bool isAwareFlagsRegenType() const { return GETBIT(flags(), kAwareFlagsRegenType); }
|
bool isRegenTypeDependent() const { return GETBIT(flags(), kRegenTypeMask); }
|
|
void setDependentGeometry(bool bSet) { SETBIT(m_flags, kDependentGeometry, bSet); }
|
bool isDependentGeometry() const { return GETBIT(flags(), kDependentGeometry); }
|
|
void setLayerDependent(bool bSet) { SETBIT(m_flags, kLayerDependent, bSet); }
|
bool isLayerDependent() const { return GETBIT(m_flags, kLayerDependent); }
|
|
Metafile* get()
|
{
|
ODA_ASSERT(!isArray());
|
return *reinterpret_cast<Metafile**>(rawPtr());
|
}
|
const Metafile* get() const
|
{
|
ODA_ASSERT(!isArray());
|
return *reinterpret_cast<Metafile**>(const_cast<MetafileHolder*>(this)->rawPtr());
|
}
|
MetafilePtrArray& getArray()
|
{
|
ODA_ASSERT(isArray());
|
return *reinterpret_cast<MetafilePtrArray*>(rawPtr());
|
}
|
const MetafilePtrArray& getArray() const
|
{
|
ODA_ASSERT(isArray());
|
return *reinterpret_cast<const MetafilePtrArray*>(rawPtr());
|
}
|
void set(Metafile* pMf)
|
{
|
destroy();
|
*reinterpret_cast<Metafile**>(rawPtr()) = pMf;
|
if(pMf)
|
pMf->addRef();
|
}
|
|
void setAtRegenType(Metafile* pMf, OdGiRegenType eRegenType)
|
{
|
int index = eRegenType - kOdGiStandardDisplay;
|
if(isArray())
|
{
|
ODA_ASSERT(isRegenTypeDependent());
|
setAt(index, pMf);
|
}
|
else if(isRegenTypeDependent())
|
{
|
if(GETBIT(m_flags , kRegenTypeStandard << index))
|
{
|
set(pMf);
|
if(!pMf)
|
setAwareFlagsRegenType(false);
|
return;
|
}
|
allocateArray();
|
setAt(index, pMf);
|
}
|
else
|
{
|
set(pMf);
|
}
|
if(pMf)
|
{
|
m_flags |= kRegenTypeStandard << index;
|
if(pMf->m_nAwareFlags & kVpRegenType)
|
setAwareFlagsRegenType(true);
|
}
|
}
|
|
Metafile* getAtRegenType(OdGiRegenType& eRegenType)
|
{
|
ODA_ASSERT(isRegenTypeDependent());
|
ODA_ASSERT(!isArray());
|
if(GETBIT(flags(), kRegenTypeStandard))
|
eRegenType = kOdGiStandardDisplay;
|
else if(GETBIT(flags(), kRegenTypeHideOrShade))
|
eRegenType = kOdGiHideOrShadeCommand;
|
else
|
eRegenType = kOdGiRenderCommand;
|
return get();
|
}
|
|
void allocateArray();
|
|
void destroy();
|
int checkValid();
|
|
void moveTo(MetafileHolder& c, int& n);
|
OdUInt32 awareFlags(OdUInt32 nVpID) const
|
{
|
if(isArray())
|
{
|
if(isVpDependent())
|
return getArray().at(nVpID)->m_nAwareFlags;
|
return kVpRenderMode | (isAwareFlagsRegenType() ? kVpRegenType : 0);
|
}
|
return isValid() ? get()->m_nAwareFlags : 0;
|
}
|
|
void setAt(int n, Metafile* pMf)
|
{
|
ODA_ASSERT(isArray());
|
if(getArray().size() <= OdUInt32(n))
|
getArray().resize(n + 1);
|
getArray()[n] = pMf;
|
}
|
|
protected:
|
int flags() const { return (int)m_flags; }
|
void* rawPtr() { return &m_data; }
|
const void* rawPtr() const { return &m_data; }
|
bool isValidMf(const Metafile& mf) const;
|
void setAwareFlagsRegenType(bool bOn) { SETBIT(m_flags, kAwareFlagsRegenType, bOn); }
|
|
protected:
|
OdUInt8 m_flags;
|
#ifdef TD_STRICT_ALIGNMENT
|
OdIntPtr m_data[odmax(sizeof(MetafilePtrArray),sizeof(OdRxObject*)) / sizeof(OdIntPtr)];
|
#else
|
OdUInt8 m_data[odmax(sizeof(MetafilePtrArray),sizeof(OdRxObject*))];
|
#endif
|
};
|
|
protected:
|
OdGsHlBranchPtr m_hlBranch;
|
|
virtual void propagateLayerChanges(OdGsViewImpl& view);
|
protected:
|
/** \details
|
Returns a reference to the metafile array of this EntityNode object as an array of MetafilePtr.
|
*/
|
MetafilePtrArray& metafileArray();
|
|
mutable MetafileHolder m_metafile;
|
/** \details
|
Returns a reference to the metafile array of this EntityNode object as an array of MetafilePtr.
|
*/
|
const MetafilePtrArray& metafileArray() const;
|
|
/** \details
|
Returns the array the objects in the metafile array of this EntityNode object.
|
*/
|
OdGsEntityNode::MetafilePtr metafile() const;
|
|
void setExtentsFromMetafiles();
|
public:
|
static OdGsEntityNode::MetafilePtr getEmptyMetafile(OdUInt32 flags, OdGsLayerNode *pLayerNode = NULL);
|
|
/** \details
|
Returns the specified MetafilePtr from the metafile array of this EntityNode object.
|
\param metafileIndex [in] Metafile index.
|
*/
|
OdGsEntityNode::MetafilePtr metafileAt(int metafileIndex) const;
|
|
/** \details
|
Sets the metafile array for this EntityNode object from the specified array of objects.
|
\param metafiles [in] Array of metafile objects.
|
*/
|
void setMetafile(OdGsEntityNode::Metafile* metafiles);
|
|
/** \details
|
Sets the specified entry in the metafile array of this EntityNode object.
|
\param metafileIndex [in] Metafile index.
|
\param pMetafile [in] Pointer to the Metafile object
|
*/
|
void setMetafileAt(int metafileIndex, OdGsEntityNode::Metafile* pMetafile);
|
|
/** \details
|
Convert a RegenType dependent cache to Viewport dependent cache.
|
\param view [in] VectorizeView object for which cache is to be converted.
|
*/
|
void convertToViewportDependent(const OdGsUpdateContext& ctx);
|
|
/** \param view [in] view object for which metafile is to be returned.
|
\param ctx [in] Check for viewport changes if and only if true.
|
*/
|
OdGsEntityNode::Metafile* metafile(const OdGsViewImpl& view,
|
OdGsUpdateContext* ctx, bool bFindCompatible = true);
|
/** \param view [in] VectorizeView object for which metafile is to be returned.
|
*/
|
void setMetafile(OdGsUpdateContext& ctx, OdGsEntityNode::Metafile* metafiles);
|
OdRxObject* findCompatibleCache(const OdGsViewImpl& keyView, OdGsUpdateContext* ctx, OdUInt32 awareMask = 0);
|
protected:
|
// m_flags (don't add new flags here, we already utilized ~30 bits)
|
enum
|
{
|
kHasExtents = OdGsNode::kLastFlag << 1,
|
kSpatiallyIndexed = OdGsNode::kLastFlag << 2,
|
kInWorkset = OdGsNode::kLastFlag << 3,
|
kSingleThreaded = OdGsNode::kLastFlag << 4,
|
kOwned = OdGsNode::kLastFlag << 5,
|
kDrawableRegenDraw = OdGsNode::kLastFlag << 6,
|
kEntityUnerased = OdGsNode::kLastFlag << 7,
|
kInvisible = OdGsNode::kLastFlag << 8,
|
kExtentsOutOfMS = OdGsNode::kLastFlag << 9,
|
kNonSelectable = OdGsNode::kLastFlag << 10,
|
kSkipSelection = OdGsNode::kLastFlag << 11,
|
kErased = OdGsNode::kLastFlag << 12,
|
kDrawableIsXref = OdGsNode::kLastFlag << 13,
|
kMultilistNextPtr = OdGsNode::kLastFlag << 14,
|
kLastFlag = kMultilistNextPtr
|
};
|
// m_entFlags (add all new flags related to EntityNode here, keep some free space inside m_flags for inherited classes)
|
enum
|
{
|
kLineweightBit1 = (1 << 0), // reserve 5 bits for maximal lineweight
|
kLineweightBit2 = (1 << 1),
|
kLineweightBit3 = (1 << 2),
|
kLineweightBit4 = (1 << 3),
|
kLineweightBit5 = (1 << 4),
|
kLineweightBitMask = kLineweightBit1 | kLineweightBit2 | kLineweightBit3 | kLineweightBit4 | kLineweightBit5,
|
kLastEntFlag = kLineweightBit5
|
};
|
// m_markToSkipFlags
|
enum
|
{
|
kMarkedToSkipFirst = 0x00000001,
|
kMarkedToSkipLast = kMarkedToSkipFirst << 30,
|
kMarkedToSkipAll = 0x7FFFFFFF
|
};
|
|
public:
|
ODRX_DECLARE_MEMBERS(OdGsEntityNode);
|
|
/** \param pModel [in] Pointer to the BaseModel object.
|
\param pUnderlyingDrawable [in] Pointer to the underlying Drawable object.
|
*/
|
OdGsEntityNode(OdGsBaseModel* pModel, const OdGiDrawable* pUnderlyingDrawable, bool bSetGsNode = false);
|
public:
|
~OdGsEntityNode();
|
|
/** \details
|
Sets the next entity for this EntityNode object to the specified EntityNode object.
|
\param pNextEntity [in] Pointer to the next EntityNode.
|
\param nVpId [in] Viewport ID.
|
*/
|
void setNextEntity(OdGsEntityNode* pNextEntity);
|
void setNextEntity(OdUInt32 nVpId, OdGsEntityNode* pNextEntity);
|
/** \details
|
Returns the next entity for this EntityNode object.
|
\param nVpId [in] Viewport ID.
|
*/
|
OdGsEntityNode* nextEntity();
|
OdGsEntityNode* nextEntity(OdUInt32 nVpId);
|
/** \details
|
Returns the next entity for this EntityNode object.
|
\param nVpId [in] Viewport ID.
|
*/
|
const OdGsEntityNode* nextEntity() const;
|
const OdGsEntityNode* nextEntity(OdUInt32 nVpId) const;
|
/** \details
|
Returns number of next entities.
|
*/
|
OdUInt32 numNextEntity() const;
|
/** \details
|
Enable multiple entity links.
|
*/
|
void enableMultipleNextEntities(OdUInt32 nMaxVpId);
|
|
void update(OdGsUpdateContext& ctx, OdGsContainerNode* pParent,
|
OdSiSpatialIndex* pParentIndex);
|
|
/** \details
|
Returns the Aware flags for the specified Viewport for this ContainerNode object.
|
|
\param viewportId [in] Viewport ID.
|
|
\remarks
|
awareFlags() returns a combination of zero or more of the following:
|
|
<table>
|
Name Value
|
kSuppressViewportDraw 0x01
|
kDrawInvisibleEnts 0x02
|
kDrawLayerOff 0x04
|
kDrawLayerFrozen 0x08
|
kIgnoreFillPlane 0x10
|
kFillPlaneSet 0x20
|
</table>
|
*/
|
virtual OdUInt32 awareFlags(OdUInt32 viewportId) const;
|
|
virtual ENodeType nodeType() const { return kEntityNode; }
|
|
virtual bool isReference() const { return false; }
|
virtual bool isLight() const { return false; }
|
|
void display(OdGsDisplayContext& ctx);
|
|
void select(OdGsBaseVectorizer& view);
|
|
void invalidate(OdGsContainerNode* pParent, OdGsViewImpl* pView, OdUInt32 mask);
|
|
bool extents(OdGeExtents3d& extents) const;
|
|
/** \details
|
Returns true if and only if this EntityNode object is spatially indexed.
|
\param nVpId [in] Viewport ID.
|
*/
|
bool spatiallyIndexed() const;
|
bool spatiallyIndexed(OdUInt32 nVpId) const;
|
/** \details
|
Controls the spatial indexing of this EntityNode object.
|
\param nVpId [in] Viewport ID.
|
\param spatiallyIndexed [in] Controls spatially indexed.
|
*/
|
void setSpatiallyIndexed(bool spatiallyIndexed);
|
void setSpatiallyIndexed(OdUInt32 nVpId, bool spatiallyIndexed);
|
|
/** \details
|
Returns true if and only if this EntityNode object is the child of a ContainerNode object.
|
\param nVpId [in] Viewport ID.
|
*/
|
bool owned() const;
|
bool owned(OdUInt32 nVpId) const;
|
/** \details
|
Controls the owned status of this EntityNode object.
|
\param nVpId [in] Viewport ID.
|
\param owned [in] Controls owned status.
|
*/
|
void setOwned(bool owned);
|
void setOwned(OdUInt32 nVpId, bool owned);
|
|
/** \remarks
|
Returns true if and only if the underlying GiDrawable object(s) have extents.
|
*/
|
bool hasExtents() const;
|
|
const OdGeExtents3d& extents() const;
|
|
/** \details
|
Returns true if the node has no graphical content.
|
*/
|
virtual bool isEmpty();
|
|
/** \details
|
Returns true if the node has no graphical content.
|
*/
|
virtual bool hasFrozenLayers();
|
|
/** \details
|
Returns true if and only if this EntityNode object is marked to be skipped
|
with the given mask (thread).
|
*/
|
inline bool markedToSkip(unsigned mask);
|
|
/** \details
|
Controls the MarkToSkip status of this EntityNode object.
|
\param markToSkip [in] Controls MarkToSkip.
|
\param mask [in] the mask(thread).
|
*/
|
inline void markToSkip(unsigned mask, bool markToSkip);
|
|
inline void markToSkipAll();
|
|
static unsigned markToSkipMask(OdUInt32 threadIndex)
|
{
|
ODA_ASSERT(threadIndex >= 0 && threadIndex < 31);
|
return kMarkedToSkipFirst << threadIndex;
|
}
|
|
void destroy(){}
|
|
virtual bool layersChanged(OdGsViewImpl& view) const;
|
|
bool markedAsNonSelectable() const;
|
void markAsNonSelectable(bool val);
|
bool isMarkedSkipSelection() const;
|
void markSkipSelection(bool val);
|
bool isMarkedErased() const;
|
void markErased(bool val);
|
|
bool isInWorkset() const;
|
void setInWorkset(bool val);
|
|
bool isRegenOnDraw() const;
|
void setRegenOnDraw(bool val);
|
|
bool isSingleThreaded() const;
|
void setSingleThreaded(bool val);
|
|
virtual void highlight(bool bDoIt, bool bWholeBranch);
|
void setHlBranch(OdGsHlBranch* pBr) { m_hlBranch = pBr; }
|
OdGsHlBranch* hlBranch() { return m_hlBranch; }
|
const OdGsHlBranch* hlBranch() const { return m_hlBranch; }
|
|
virtual void playAsGeometry(OdGsBaseVectorizer& view, EMetafilePlayMode eMode);
|
|
bool extents(const OdGsView* pView, OdGeExtents3d& ext) const;
|
OdDb::LineWeight getMaxLineweightUsed() const;
|
inline void addLineweight(OdUInt32 lwd);
|
|
friend inline OdUInt32 getLineweight(const OdGsEntityNode& entNode);
|
friend inline void setLineweight(OdGsEntityNode& entNode, OdUInt32 lwd);
|
void setLineweight(OdUInt32 lwd);
|
OdUInt32 getLineweight() const;
|
|
bool entityUnerased() const;
|
void setEntityUnerased(bool flag);
|
|
bool isInvisible() const;
|
|
bool isDrawableRegenDraw() const;
|
|
bool isExtentsOutOfModelSpace() const;
|
void setExtentsOutOfModelSpace(bool flag);
|
|
void resetInvalidVpFlag();
|
|
public:
|
virtual void makeStock();
|
virtual void releaseStock();
|
virtual void propagateLayerChangesStock();
|
|
bool saveNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer = NULL) const;
|
bool loadNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer = NULL);
|
protected:
|
bool findMetafileInStock(OdGsUpdateContext& ctx);
|
void insertToSpatialIndex(OdUInt32 nVpId, OdSiSpatialIndex& parentIndex,
|
const OdGeExtents3d& prevExtents);
|
inline void setExtentsFlags();
|
|
private:
|
MetafileHolder m_mfStock;
|
volatile int m_markToSkipFlags;
|
protected:
|
// This flags willn't increase memory usage (at least on Win32) since utilize free space in 8 bytes alignment (__alignof(entity_node) == 8).
|
OdUInt32 m_entFlags;
|
};
|
|
/** \details
|
This template class is a specialization of the OdSmartPtr class for OdGsEntityNode object pointers.
|
*/
|
typedef OdSmartPtr<OdGsEntityNode> OdGsEntityNodePtr;
|
|
|
inline void OdGsEntityNode::setNextEntity(OdGsEntityNode* pNextEntity)
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
throw OdError(eInvalidIndex);
|
m_pNextEntity = pNextEntity;
|
}
|
|
inline void OdGsEntityNode::setNextEntity(OdUInt32 nVpId, OdGsEntityNode* pNextEntity)
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
nextEntEntry(nVpId)->m_pNextEntity = pNextEntity;
|
else
|
m_pNextEntity = pNextEntity;
|
}
|
|
inline void OdGsEntityNode::enableMultipleNextEntities(OdUInt32 nMaxVpId)
|
{
|
if (nMaxVpId == 0xFFFFFFFF) nMaxVpId = 0;
|
if ((numNextEntity() <= nMaxVpId) || ((nMaxVpId == 0) && GETBIT(m_flags, kMultilistNextPtr)))
|
allocNextEntityArray(nMaxVpId);
|
}
|
|
inline OdGsEntityNode* OdGsEntityNode::nextEntity()
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
throw OdError(eInvalidIndex);
|
return m_pNextEntity;
|
}
|
|
inline OdGsEntityNode* OdGsEntityNode::nextEntity(OdUInt32 nVpId)
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
return nextEntEntry(nVpId)->m_pNextEntity;
|
//if (nVpId > 0) // Normal case, since we can request from non-VpDep container
|
// throw OdError(eInvalidIndex);
|
return m_pNextEntity;
|
}
|
|
inline const OdGsEntityNode* OdGsEntityNode::nextEntity() const
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
throw OdError(eInvalidIndex);
|
return m_pNextEntity;
|
}
|
|
inline const OdGsEntityNode* OdGsEntityNode::nextEntity(OdUInt32 nVpId) const
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
return nextEntEntry(nVpId)->m_pNextEntity;
|
//if (nVpId > 0) // Normal case, since we can request from non-VpDep container
|
// throw OdError(eInvalidIndex);
|
return m_pNextEntity;
|
}
|
|
inline OdUInt32 OdGsEntityNode::numNextEntity() const
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
return (OdUInt32)OdPtrToInt32(firstEntEntry()->m_pNextEntity);
|
return 1;
|
}
|
|
inline bool OdGsEntityNode::hasExtents() const
|
{
|
return GETBIT(m_flags, kHasExtents);
|
}
|
|
inline const OdGeExtents3d& OdGsEntityNode::extents() const
|
{
|
return m_extents;
|
}
|
|
inline bool OdGsEntityNode::markedToSkip(unsigned mask)
|
{
|
ODA_ASSERT((mask >= kMarkedToSkipFirst) && (mask <= kMarkedToSkipLast));
|
//atomic function is required, called in MT mode (display)
|
#ifndef TD_SINGLE_THREAD
|
return (mask & OdInterlockedExchangeAdd(&m_markToSkipFlags, 0)) != 0;
|
#else
|
return GETBIT(m_markToSkipFlags, mask);
|
#endif
|
}
|
|
inline void OdGsEntityNode::markToSkip(unsigned mask, bool bSkip)
|
{
|
ODA_ASSERT((mask >= kMarkedToSkipFirst) && (mask <= kMarkedToSkipLast));
|
if(markedToSkip(mask) != bSkip)
|
{
|
//atomic function is required, called in MT mode (display)
|
#ifndef TD_SINGLE_THREAD
|
if(bSkip)
|
OdInterlockedExchangeAdd(&m_markToSkipFlags, mask);
|
else
|
OdInterlockedExchangeAdd(&m_markToSkipFlags, -(int)mask);
|
#else
|
SETBIT(m_markToSkipFlags, mask, bSkip);
|
#endif
|
}
|
}
|
|
inline void OdGsEntityNode::markToSkipAll()
|
{
|
//atomic function is NOT required, is NOT called in MT mode
|
m_markToSkipFlags = kMarkedToSkipAll;
|
}
|
|
inline bool OdGsEntityNode::spatiallyIndexed() const
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
throw OdError(eInvalidIndex);
|
return GETBIT(m_flags, kSpatiallyIndexed);
|
}
|
|
inline bool OdGsEntityNode::spatiallyIndexed(OdUInt32 nVpId) const
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
return GETBIT(nextEntEntry(nVpId)->m_entFlags, kSpatiallyIndexed);
|
//if (nVpId > 0) // Normal case, since we can request from non-VpDep container
|
// throw OdError(eInvalidIndex);
|
return GETBIT(m_flags, kSpatiallyIndexed);
|
}
|
|
inline void OdGsEntityNode::setSpatiallyIndexed(bool bIndexed)
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
throw OdError(eInvalidIndex);
|
SETBIT(m_flags, kSpatiallyIndexed, bIndexed);
|
}
|
|
inline void OdGsEntityNode::setSpatiallyIndexed(OdUInt32 nVpId, bool bIndexed)
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
SETBIT(nextEntEntry(nVpId)->m_entFlags, kSpatiallyIndexed, bIndexed);
|
else
|
SETBIT(m_flags, kSpatiallyIndexed, bIndexed);
|
}
|
|
inline bool OdGsEntityNode::owned() const
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
throw OdError(eInvalidIndex);
|
return GETBIT(m_flags, kOwned);
|
}
|
|
inline bool OdGsEntityNode::owned(OdUInt32 nVpId) const
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
return GETBIT(nextEntEntry(nVpId)->m_entFlags, kOwned);
|
//if (nVpId > 0) // Normal case, since we can request from non-VpDep container
|
// throw OdError(eInvalidIndex);
|
return GETBIT(m_flags, kOwned);
|
}
|
|
inline void OdGsEntityNode::setOwned(bool bOwned)
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
throw OdError(eInvalidIndex);
|
SETBIT(m_flags, kOwned, bOwned);
|
}
|
|
inline void OdGsEntityNode::setOwned(OdUInt32 nVpId, bool bOwned)
|
{
|
if (GETBIT(m_flags, kMultilistNextPtr))
|
SETBIT(nextEntEntry(nVpId)->m_entFlags, kOwned, bOwned);
|
else
|
SETBIT(m_flags, kOwned, bOwned);
|
}
|
|
inline OdGsEntityNode::MetafilePtrArray& OdGsEntityNode::metafileArray()
|
{
|
return m_metafile.getArray();
|
}
|
|
inline const OdGsEntityNode::MetafilePtrArray& OdGsEntityNode::metafileArray() const
|
{
|
return m_metafile.getArray();
|
}
|
|
inline OdGsEntityNode::MetafilePtr OdGsEntityNode::metafile() const
|
{
|
return m_metafile.get();
|
}
|
|
inline OdGsEntityNode::MetafilePtr OdGsEntityNode::metafileAt(int metafileIndex) const
|
{
|
return metafileArray()[metafileIndex];
|
}
|
|
#define VPMETAFILEHOLDERARRAY_DESTRUCTOR ~MetafilePtrArray
|
|
inline void OdGsEntityNode::setMetafile(OdGsEntityNode::Metafile* pMetafile)
|
{
|
m_metafile.set(pMetafile);
|
}
|
|
inline bool OdGsEntityNode::entityUnerased() const
|
{
|
return GETBIT(m_flags, kEntityUnerased);
|
}
|
|
inline void OdGsEntityNode::setEntityUnerased(bool flag)
|
{
|
SETBIT(m_flags, kEntityUnerased, flag);
|
}
|
|
inline bool OdGsEntityNode::isInvisible() const
|
{
|
return GETBIT(m_flags, kInvisible);
|
}
|
|
inline bool OdGsEntityNode::isDrawableRegenDraw() const
|
{
|
return GETBIT(m_flags, kDrawableRegenDraw);
|
}
|
|
inline void OdGsEntityNode::resetInvalidVpFlag()
|
{
|
if (invalidVp())
|
{
|
setInvalidVp(false);
|
}
|
}
|
|
inline bool OdGsEntityNode::markedAsNonSelectable() const
|
{
|
return GETBIT(m_flags, kNonSelectable);
|
}
|
|
inline void OdGsEntityNode::markAsNonSelectable(bool val)
|
{
|
SETBIT(m_flags, kNonSelectable, val);
|
}
|
|
inline bool OdGsEntityNode::isMarkedSkipSelection() const
|
{
|
return GETBIT(m_flags, kSkipSelection);
|
}
|
|
inline void OdGsEntityNode::markSkipSelection(bool val)
|
{
|
SETBIT(m_flags, kSkipSelection, val);
|
}
|
|
inline bool OdGsEntityNode::isMarkedErased() const
|
{
|
return GETBIT(m_flags, kErased);
|
}
|
|
inline void OdGsEntityNode::markErased(bool val)
|
{
|
SETBIT(m_flags, kErased, val);
|
}
|
|
inline bool OdGsEntityNode::Metafile::isEmpty() const
|
{
|
for(const OdGsGeomPortion* ptr = &m_first; ptr; ptr = ptr->m_pNext)
|
{
|
if(ptr->m_pGsMetafile.get())
|
return false;
|
}
|
return true;
|
}
|
|
inline bool OdGsEntityNode::isExtentsOutOfModelSpace() const
|
{
|
return GETBIT(m_flags, kExtentsOutOfMS);
|
}
|
|
inline void OdGsEntityNode::setExtentsOutOfModelSpace(bool val)
|
{
|
SETBIT(m_flags, kExtentsOutOfMS, val);
|
}
|
|
inline bool OdGsEntityNode::isInWorkset() const
|
{
|
return GETBIT(m_flags, kInWorkset);
|
}
|
|
inline void OdGsEntityNode::setInWorkset(bool val)
|
{
|
SETBIT(m_flags, kInWorkset, val);
|
}
|
|
inline bool OdGsEntityNode::isSingleThreaded() const
|
{
|
return GETBIT(m_flags, kSingleThreaded);
|
}
|
|
inline void OdGsEntityNode::setSingleThreaded(bool val)
|
{
|
SETBIT(m_flags, kSingleThreaded, val);
|
}
|
|
inline bool OdGsEntityNode::isRegenOnDraw() const
|
{
|
return GETBIT(m_flags, kDrawableRegenDraw);
|
}
|
|
inline void OdGsEntityNode::setRegenOnDraw(bool val)
|
{
|
SETBIT(m_flags, kDrawableRegenDraw, val);
|
}
|
|
inline void OdGsEntityNode::highlight(bool bDoIt, bool bWholeBranch)
|
{
|
OdGsNode::highlight(bDoIt, bWholeBranch);
|
if(hlBranch() && (!bDoIt || bWholeBranch))
|
setHlBranch(NULL);
|
}
|
|
inline void OdGsEntityNode::setExtentsFlags()
|
{
|
SETBIT(m_flags, kHasExtents, m_extents.isValidExtents());
|
SETBIT(m_flags, kExtentsOutOfMS, !OdSi::properExtents(m_extents));
|
}
|
|
inline OdUInt32 getLineweight(const OdGsEntityNode& entNode)
|
{
|
return entNode.m_entFlags & OdGsEntityNode::kLineweightBitMask;
|
}
|
|
inline void setLineweight(OdGsEntityNode& entNode, OdUInt32 lwd)
|
{
|
entNode.m_entFlags = ((lwd & OdGsEntityNode::kLineweightBitMask) | (entNode.m_entFlags & ~OdGsEntityNode::kLineweightBitMask));
|
}
|
|
inline void OdGsEntityNode::addLineweight(OdUInt32 lwd)
|
{
|
if (lwd)
|
{
|
OdUInt32 maxLwd = ::getLineweight(*this);
|
if (lwd > maxLwd)
|
::setLineweight(*this, lwd);
|
}
|
}
|
|
#include "TD_PackPop.h"
|
|
#endif // __OD_GS_ENTITY_NODE__
|
