GsBlockNode.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, 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 Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 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 "GsBlockRefNodeDesc.h"
#define STL_USING_SET
#define STL_USING_MAP
#include "OdaSTL.h"
#include "ThreadsCounter.h"
 
class OdGsSharedRefDefinition;
class OdGsReferenceImpl;
 
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);
 
  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(const 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(const OdGsSharedRefDefinition* pDef, OdGsBlockRefNodeDesc& d);
    void invalidateSectionable();
    void invalidateAwareFlags(OdGsViewImpl* pView, OdUInt32 nViewChanges, const OdDbStub* layoutId, OdGsBaseModel* pModel);
    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__