GsBlockNode.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, 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-2017 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_BLOCK_NODE__
#define __OD_GS_BLOCK_NODE__
 
#include "TD_PackPush.h"
 
#include "GsBlockReferenceNode.h"
#include "Ge/GeScale3d.h"
#include "Gi/GiSubEntityTraitsData.h"
#include "Gi/GiAnnoScaleSet.h"
#define STL_USING_SET
#define STL_USING_MAP
#include "OdaSTL.h"
#include "ThreadsCounter.h"
 
class OdGsSharedRefDefinition;
class OdGsReferenceImpl;
 
class GS_TOOLKIT_EXPORT OdGsBlockRefNodeDescMem
{
public:
  OdGsBlockRefNodeDescMem(const OdDbStub* layoutBlockId, const OdGiSubEntityTraitsData& tr,
    const OdGeScale3d& scale, bool bUsePlotStyles):
      m_layoutBlockId(layoutBlockId),
      m_layerId(tr.layer())
    , m_lineTypeId(tr.lineType())
    , m_cmColor(tr.trueColor().color())
    , m_lineWeight(tr.lineWeight())
    , m_lineTypeScale(tr.lineTypeScale())
    , m_plotStyleNameType(bUsePlotStyles ? tr.plotStyleNameType() : OdDb::kPlotStyleNameIsDictDefault)
    , m_plotStyleNameId(bUsePlotStyles ? tr.plotStyleNameId() : NULL)
    , m_materialId(tr.material()), m_cmTransparency(tr.transparency().serializeOut())
    , m_scale(scale)
  {
  }
  OdGsBlockRefNodeDescMem(const OdGsBlockRefNodeDescMem& c)
  {
    ::memcpy(this, &c, sizeof(OdGsBlockRefNodeDescMem));
  }
  OdGsBlockRefNodeDescMem(){ ::memset(this, 0, sizeof(OdGsBlockRefNodeDescMem)); }
 
protected:
  bool lessOrEqual(const OdGsBlockRefNodeDescMem& v, bool& bEqual) const;
 
public:
  const OdDbStub* m_layoutBlockId;
  OdDbStub* m_layerId;
  OdDbStub* m_lineTypeId;
  OdUInt32 m_cmColor;
  OdDb::LineWeight m_lineWeight;
  double m_lineTypeScale;
 
  OdDb::PlotStyleNameType m_plotStyleNameType;
  OdDbStub* m_plotStyleNameId;
 
  OdDbStub* m_materialId;
  OdUInt32 m_cmTransparency;
 
  OdGeScale3d m_scale;
};
 
class GS_TOOLKIT_EXPORT OdGsBlockRefNodeDesc: public OdGsBlockRefNodeDescMem
{
public:
  OdGsBlockRefNodeDesc(const OdDbStub* layoutBlockId, const OdGiSubEntityTraitsData& tr,
    const OdGeScale3d& scale, bool bUsePlotStyles, const OdGiAnnoScaleSet& annoScales):
    OdGsBlockRefNodeDescMem(layoutBlockId, tr, scale, bUsePlotStyles), m_annoScales(annoScales)
  {
  }
  OdGsBlockRefNodeDesc(const OdGsBlockRefNodeDesc& c): OdGsBlockRefNodeDescMem(c), m_annoScales(c.m_annoScales)
  {
  }
  OdGsBlockRefNodeDesc(){}
 
  bool operator < (const OdGsBlockRefNodeDesc& v) const
  {
    bool bEqual = false;
    if(lessOrEqual(v, bEqual) && !bEqual)
      return true;
    return bEqual ? m_annoScales < v.m_annoScales : false;
  }
public:
  OdGiAnnoScaleSet m_annoScales;
};
 
class GS_TOOLKIT_EXPORT OdGsBlockNode: public OdGsNode
{
protected:
  enum
  {
    kUnloaded   = OdGsNode::kLastFlag << 1,
    kLastFlag   = kUnloaded
  };
public:
  enum
  {
    kInvalidateRefExtentsMask = (kVpLastPropBit << 1)
        //NS: use this mask in invalidate() to invalidate extents of corresponding
        //references when block is modified
  };
 
  ODRX_DECLARE_MEMBERS(OdGsBlockNode);
 
  OdGsBlockNode(OdGsBaseModel* pModel, const OdGiDrawable* pUnderlyingDrawable,
    bool bSetGsNode): OdGsNode(pModel, pUnderlyingDrawable), m_bModelTfDependent(0)
  {
    if(bSetGsNode)
      setToDrawable(pUnderlyingDrawable);
  }
  ~OdGsBlockNode()
  {
    if (isUnloaded())
    {
      // this block-node corresponds to block in xreffed db;
      // here db can be unloaded, so prevent access to the associated block table record.
      SETBIT(m_flags, kSyncDrawable, false);
    }
    clearInserts();
  }
 
  void setUnloaded(bool isUnloaded);
  bool isUnloaded() const;
  void setModelTfDependent(bool bOn);
  bool isModelTfDependent() const;
 
  virtual ENodeType nodeType() const { return kBlockNode; }
 
  void invalidate(OdGsContainerNode* pParent, OdGsViewImpl* view, OdUInt32 mask);
 
  void addRef(OdGsBlockReferenceNode* pEntity)
  {
    if(odThreadsCounter())
    {
      TD_AUTOLOCK_P(m_insertsMt.get());
      m_inserts.insert(pEntity);
    }
    else
    {
      m_inserts.insert(pEntity);
    }
  }
 
  void release(OdGsBlockReferenceNode* pEntity)
  {
    TD_AUTOLOCK_P_DEF(m_insertsMt);
    m_inserts.erase(pEntity);
    if(!isUnloaded() || !m_inserts.empty())
      return;
    // this block-node corresponds to block in xreffed db;
    // here db can be unloaded, so prevent access to the associated block table record.
    SETBIT(m_flags, kSyncDrawable, false);
    baseModel()->detach(this);
  }
 
  void update(OdGsUpdateContext&, OdGsContainerNode*, OdSiSpatialIndex*)
  {
    ODA_ASSERT(false);
  }
 
  void display(OdGsDisplayContext&)
  {
    ODA_ASSERT(false);
  }
 
  bool extents(OdGeExtents3d&) const
  {
    ODA_ASSERT(false);
    return false;
  }
 
  virtual void propagateLayerChanges(OdGsViewImpl& /*view*/);
 
  void destroy();
 
  void invalidateShared()
  {
    m_sharedImp.destroy();
  }
 
  OdGsSharedRefDefinition* createDef(const OdGsBlockRefNodeDesc& d);
  OdGsSharedRefDefinition* findCreateDef(const OdGsBlockRefNodeDesc& d)
  {
    if(odThreadsCounter())
    {
      TD_AUTOLOCK_P(m_sharedMt.get());
      OdGsSharedRefDefinition* pRes = m_sharedImp.findAt(d);
      return pRes ? pRes : createDef(d);
    }
    OdGsSharedRefDefinition* pRes = m_sharedImp.findAt(d);
    return pRes ? pRes : createDef(d);
  }
 
  void invalidateSharedSubents(OdUInt32 vpID, OdUInt32 nViewChanges);
 
  void invalidateSharedRegenDraw(OdUInt32 vpID, const OdDbStub* layoutId);
  void invalidateSharedSectionable();
  void invalidateSharedAwareFlags(OdGsViewImpl* pView, OdUInt32 nViewChanges, const OdDbStub* layoutId);
 
  void removeDef(OdGsSharedRefDefinition* pDef)
  {
    if(odThreadsCounter())
    {
      TD_AUTOLOCK_P(m_sharedMt.get());
      m_sharedImp.removeDef(pDef);
    }
    else
    {
      m_sharedImp.removeDef(pDef);
    }
  }
  bool findDef(OdGsSharedRefDefinition* pDef, OdGsBlockRefNodeDesc& d)
  {
    if(odThreadsCounter())
    {
      TD_AUTOLOCK_P(m_sharedMt.get());
      return m_sharedImp.findDef(pDef, d);
    }
    return m_sharedImp.findDef(pDef, d);
  }
 
  bool saveNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer = NULL) const;
  bool loadNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer = NULL);
  bool postprocessNodeLoading(OdGsFiler *pFiler);
 
protected:
  void clearInserts();
 
protected:
  class GS_TOOLKIT_EXPORT ImpMap
  {
  public:
    ~ImpMap() { clear(); }
    void clear();
    void destroy();
    OdGsSharedRefDefinition* findAt(const OdGsBlockRefNodeDesc& d)
    {
      _map::iterator it = m_map.find(d);
      return (it == m_map.end() ? NULL : it->second);
    }
    OdGsSharedRefDefinition* insertAt(const OdGsBlockRefNodeDesc& d,
        OdGsReferenceImpl* pImp);
    bool layersChanged(OdGsViewImpl& view, OdGsBaseModel* pModel);
    void invalidateSubents(OdUInt32 vpID, OdUInt32 nViewChanges);
    void invalidateRegenDraw(OdUInt32 vpID, const OdDbStub* layoutId);
    void removeDef(OdGsSharedRefDefinition* pDef);
    bool findDef(OdGsSharedRefDefinition* pDef, OdGsBlockRefNodeDesc& d);
    void invalidateSectionable();
#ifndef ODGS_LOCAL_IDS
    void invalidateAwareFlags(OdGsViewImpl* pView, OdUInt32 nViewChanges, const OdDbStub* layoutId);
#else
    void invalidateAwareFlags(OdGsViewImpl* pView, OdUInt32 nViewChanges, const OdDbStub* layoutId, OdGsBaseModel* pModel);
#endif
    void propagateLayerChangesStock();
 
  public:
    typedef std::map<OdGsBlockRefNodeDesc, OdGsSharedRefDefinition*,
        std::less<OdGsBlockRefNodeDesc> > _map;
    _map m_map;
  };
 
protected:
  typedef std::set<OdGsBlockReferenceNode*> Inserts;
  typedef Inserts::iterator InsertIterator;
  Inserts m_inserts;
  ImpMap m_sharedImp;
  OdMutexPtr m_sharedMt;
  OdMutexPtr m_insertsMt;
  volatile int m_bModelTfDependent;
};
 
inline void OdGsBlockNode::setUnloaded(bool isUnloaded)
{
  SETBIT(m_flags, kUnloaded, isUnloaded);
}
 
inline bool OdGsBlockNode::isUnloaded() const
{
  return GETBIT(m_flags, kUnloaded);
}
 
inline void OdGsBlockNode::setModelTfDependent(bool bOn)
{
  if(isModelTfDependent() == bOn)
      return;
#ifndef TD_SINGLE_THREAD
  OdInterlockedExchangeAdd(&m_bModelTfDependent, bOn ? 1 : -1);
#else
  m_bModelTfDependent = bOn;
#endif
  if(bOn)
  {
    //don't keep content of m_sharedImp anymore. These definitions remain 
    //on inserts, if any, and will be released in the course of their update()
    if(odThreadsCounter())
    {
      TD_AUTOLOCK_P(m_sharedMt.get());
      m_sharedImp.clear();
    }
    else
    {
      m_sharedImp.clear();
    }
  }
}
 
inline bool OdGsBlockNode::isModelTfDependent() const
{
  //atomic function is required, called in MT mode (update)
#ifndef TD_SINGLE_THREAD
  return OdInterlockedExchangeAdd(&const_cast<OdGsBlockNode*>(this)->m_bModelTfDependent, 0) != 0;
#else
  return m_bModelTfDependent;
#endif
}
 
#include "TD_PackPop.h"
 
#endif // __OD_GS_BLOCK_NODE__