GsBlockReferenceNode.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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-2024 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_BLOCKREFERENCE_NODE__
#define __OD_GS_BLOCKREFERENCE_NODE__
 
#include "TD_PackPush.h"
 
#include "GsEntityNode.h"
#include "OdVector.h"
 
class OdGsSpQueryContext;

class GS_TOOLKIT_EXPORT OdSiRecursiveVisitor : public OdSiVisitor
{
public:
  OdSiRecursiveVisitor(): m_pQuery(NULL), m_worldToNode(NULL), m_nodeToWorld(NULL),
      m_worldToModel(NULL), m_modelToWorld(NULL){}
 
  const OdSiShape* query() const { return m_pQuery; }
  void resetQuery(const OdSiShape* pQuery) { m_pQuery = pQuery; }
 
  const OdGeMatrix3d* worldToNode() const { return m_worldToNode; }
  void setWorldToNode(const OdGeMatrix3d* tf) { m_worldToNode = tf; }
  const OdGeMatrix3d* nodeToWorld() const { return m_nodeToWorld; }
  void setNodeToWorld(const OdGeMatrix3d* tf) { m_nodeToWorld = tf; }
  const OdGeMatrix3d* worldToModel() const { return m_worldToModel; }
  void setWorldToModel(const OdGeMatrix3d* tf) { m_worldToModel = tf; }
  const OdGeMatrix3d* modelToWorld() const { return m_modelToWorld; }
  void setModelToWorld(const OdGeMatrix3d* tf) { m_modelToWorld = tf; }
 
protected:
  const OdSiShape* m_pQuery;
  const OdGeMatrix3d* m_worldToNode;
  const OdGeMatrix3d* m_nodeToWorld;
  const OdGeMatrix3d* m_worldToModel;
  const OdGeMatrix3d* m_modelToWorld;
};
 
typedef OdSiRecursiveVisitor OdSiSelBaseVisitor;

class OdSiRecursiveVisitorTf
{
public:
  OdSiRecursiveVisitorTf(OdSiRecursiveVisitor& v, const OdGeMatrix3d& mat);
  ~OdSiRecursiveVisitorTf();
  operator OdSiRecursiveVisitor*() { return &m_visitor; }
 
protected:
  OdSiRecursiveVisitor& m_visitor;
private:
  const OdSiShape* m_prevQuery;
  std::unique_ptr<OdSiShape> m_transformedQuery;
};
typedef OdSiRecursiveVisitorTf OdSiSelectVisitorTf;

class OdGsSpQueryContextTf: public OdSiRecursiveVisitorTf
{
public:
  OdGsSpQueryContextTf(OdSiRecursiveVisitor& v, const OdGeMatrix3d& objectTf, const OdGeMatrix3d& objectTfInv,
      const OdGeScale3d& scale);
  ~OdGsSpQueryContextTf();
 
protected:
  OdGeMatrix3d m_nodeToWorld;
  OdGeMatrix3d m_worldToNode;
  const OdGeMatrix3d* m_prevNodeToWorld;
  const OdGeMatrix3d* m_prevWorldToNode;
  OdGeMatrix3d m_modelToWorld;
  OdGeMatrix3d m_worldToModel;
  const OdGeMatrix3d* m_prevModelToWorld;
  const OdGeMatrix3d* m_prevWorldToModel;
};
 
// forward declarations
class OdGsBlockReferenceNodeImpl;
class OdGsBlockNode;
class WorldDrawBlockRef;
class OdGsUpdateState;

class GS_TOOLKIT_EXPORT OdGsAwareFlagsArray
{
public:
  OdGsAwareFlagsArray(){}
  enum
  {
    kChildrenNotUpToDate = 0x80000000
  };
  void setChildrenUpToDate(bool childrenUpToDate, const OdUInt32 nVpID);
  bool childrenUpToDate(OdUInt32 nVpID) const;
  OdUInt32 get(OdUInt32 nVpID) const;
  void set(OdUInt32 nVpID, OdUInt32 flags);
  void clear() { m_vpAwareFlags.clear(); }
  bool isEmpty() const { return m_vpAwareFlags.isEmpty(); }
  OdUInt32 numAwareFlags() const { return m_vpAwareFlags.size(); }
  bool areInvalid(OdUInt32 nVpID) const;
  void setInvalid(OdUInt32 nVpID)
  {
    if (m_vpAwareFlags.size() > nVpID)
      m_vpAwareFlags[nVpID] = 0xFFFFFFFF;
  }
 
protected:
  bool findFlag(OdUInt32 nVpID) const
  { return nVpID < m_vpAwareFlags.size(); }
 
private:
  // viewport aware flags
  OdUInt32Vector m_vpAwareFlags;
};

class GS_TOOLKIT_EXPORT OdGsBlockReferenceNodeImpl
{
public:
  OdGsBlockReferenceNodeImpl();
  void* operator new(size_t);
  void  operator delete(void*);
 
  void addRef()
  {
    ++m_nRefCounter;
  }
  void release()
  {
        ODA_ASSERT((m_nRefCounter > 0));
        if (!(--m_nRefCounter))
      delete this;
  }
  long numRefs() const { return m_nRefCounter; }
 
  // Main methods, used for OdGsNode interface implementation
 
  //pBlock can be NULL.
  //If is not NULL only when it is passed directly from the function where the drawable is open.
  //If it is NULL and it is required then use blockNode.underlyingDrawable() 
  virtual void updateSubitems(OdGsUpdateContext& ctx,
      OdGsBlockNode& blockNode, const OdGiDrawable* pBlock) = 0;
  virtual void display(OdGsDisplayContext& ctx, bool isHighlightedAll) = 0;
 
  //NS: following methods return true if operation succeded (invalidation
  //or destroying leave the object valid). If they return false, it means that
  //OdGsNode should release the instance and recreate m_pImpl.
  virtual bool invalidate(OdGsContainerNode* pParent, OdGsViewImpl* pView,
          OdUInt32 mask) = 0;
  virtual bool destroy() = 0;
  virtual bool destroySubitems() = 0;
 
  virtual bool select(OdGsBaseVectorizer& view, OdSiSelBaseVisitor* pVisitor,
          bool bHasExtents, OdGsView::SelectionMode mode) = 0;
  virtual void highlight(bool bDoIt, bool bWholeBranch, OdUInt32 nSelStyle = 0) = 0;
  // Methods for traversing internal subitems
  virtual OdGsEntityNode* firstEntity() = 0;
  virtual void playAsGeometry(OdGsBaseVectorizer& view, EMetafilePlayMode eMode) = 0;
  virtual bool isSharedReference() const { return false; }
  virtual bool isSharedDefinition() const { return false; }
  virtual bool layersChanged(OdGsViewImpl& view) const;
 
  virtual void makeStock() = 0;
  virtual void releaseStock() = 0;
  virtual void propagateLayerChangesStock() = 0;
  virtual void doSpatialQuery(OdGsSpQueryContext& ctx) = 0;
 
  virtual bool saveNodeImplState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer) const = 0;
  virtual bool loadNodeImplState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer, OdGsBaseModel *pModel) = 0;
  virtual void postprocessNodeImplLoading(OdGsFiler * /*pFiler*/) { }
protected:
  virtual ~OdGsBlockReferenceNodeImpl();
 
protected:
  OdRefCounter m_nRefCounter;
};

class GS_TOOLKIT_EXPORT OdGsBlockReferenceNode: public OdGsEntityNode,
        protected OdGsAwareFlagsArray
{
public:
  ODRX_DECLARE_MEMBERS(OdGsBlockReferenceNode);
  
  OdGsBlockReferenceNode(OdGsBaseModel* pModel, const OdGiDrawable* pDrawable, bool bSetGsNode = false);
public:
  ~OdGsBlockReferenceNode();
  
  // additional flags for processing of inserts
  enum
  {
    kValid                = OdGsEntityNode::kLastFlag << 1,
    kBrExcludeFromViewExt = OdGsEntityNode::kLastFlag << 2,
    kBrClipped            = OdGsEntityNode::kLastFlag << 3,
    kForceNotEmpty        = OdGsEntityNode::kLastFlag << 4,
    kBrOwnGeom            = OdGsEntityNode::kLastFlag << 5,
    kLastFlag             = kBrOwnGeom
  };
  
  bool isValid() const { return GETBIT(m_flags, kValid); }
  void setValid(bool bSet) { SETBIT(m_flags, kValid, bSet); }
  bool excludeFromViewExt() const { return GETBIT(m_flags, kBrExcludeFromViewExt); }
  void setExcludeFromViewExt(bool bSet) { SETBIT(m_flags, kBrExcludeFromViewExt, bSet); }
 
  bool isForceNotEmpty() const { return GETBIT( m_flags, kForceNotEmpty ); }
  void setForceNotEmpty( bool b ) { SETBIT( m_flags, kForceNotEmpty, b ); }
 
  virtual bool isReference() const { return true; }
  virtual bool isSelfReferential() const;
  virtual bool layersChanged(OdGsViewImpl& view) const;
  // implementation of OdGsEntityNode interface:
  virtual void update(OdGsUpdateContext& ctx, OdGsContainerNode* pParent,
      OdSiSpatialIndex* pParentIndex);
  virtual void propagateLayerChanges(OdGsViewImpl& view);
 
  virtual void invalidate(OdGsContainerNode* pParent, OdGsViewImpl* pView, OdUInt32 mask);
  virtual void destroy();
  virtual void destroySubitems();
 
  virtual bool select(OdGsBaseVectorizer& view, OdSiSelBaseVisitor*,
    OdGsView::SelectionMode mode);

  bool highlightSubnodes(OdUInt32 nSubnodes, bool bHighlight, bool bAll);
  
   virtual OdUInt32 awareFlags(OdUInt32 viewportId) const;

   virtual bool awareFlagsAreInvalid(OdUInt32 viewportId) const;
  
  virtual bool isEmpty();
 
  virtual OdGsEntityNode* firstEntity();
  virtual OdGsEntityNode* firstAttrib() { return m_pFirstAttrib; }
  void updateImpl(OdGsUpdateContext& ctx, const OdGiDrawable* pInsert,
      OdSiSpatialIndex* pParentIndex);
  
  OdGsBlockNode* blockNode() const { return m_pBlockNode; }
  void clearBlockNode();
 
  virtual void makeStock();
  virtual void releaseStock();
  virtual void propagateLayerChangesStock();
  void updateBlockNode(const OdGiDrawable* pBlockTableRecord);
  //For testing purposes
  void* sharedDefinition(const OdGsViewImpl &view);
  virtual bool isMInsert() const { return false; }
  static OdGsBlockReferenceNode* create(OdGsBaseModel* pModel, const OdGiDrawable* pDrawable);
  virtual void doDisplay(OdGsDisplayContext& ctx);
  virtual bool doSelect(OdGsBaseVectorizer& vect, OdGiDrawable* pDrw,
      OdSiSelBaseVisitor* pVisitor, OdGsView::SelectionMode mode);
 
  virtual void spatialQuery(const OdGsView& view, OdSiRecursiveVisitor* pVisitor);

  virtual bool getSharedTransform(OdGeMatrix3d& transform) const;

  virtual void invalidateBlockNode( OdGsContainerNode* pParent,
    OdGsViewImpl* pView, OdUInt32 mask, bool bRecursively = true );
 
protected:
  virtual void setChildrenUpToDate(bool childrenUpToDate, const OdUInt32 nVpID);
  virtual bool childrenUpToDate(OdUInt32 nVpID) const;
  virtual bool childrenRegenDraw(OdUInt32 nVpID) const;
  void updateAttribute(OdGsUpdateContext& ctx, OdGsEntityNode* pNode,
      const OdGiDrawable* pInsert, OdGsMarker marker);
  // Tool methods
  void setAwareFlags(OdUInt32 viewportId, OdUInt32 nAwareFlags);
  virtual void playAsGeometry(OdGsBaseVectorizer& view, EMetafilePlayMode eMode);
  void initBlockNode(const OdGiDrawable* pBlock);
  void setMetafile(OdGsUpdateContext& ctx, OdGsEntityNode::Metafile* pMf,
      OdUInt32 awareFlags, const OdGeExtents3d& ext);
  bool needRegen(OdUInt32 nVpID) const
  {
    if(!childrenUpToDate(nVpID))
        return true;
    OdUInt32 nAF = awareFlags(nVpID);
    if( nAF == 0xFFFFFFFF || (baseModel()->viewChanges(nVpID) & nAF) != 0 )
    {
      const_cast<OdGsBlockReferenceNode*>(this)->setChildrenUpToDate(false, nVpID);
      return true;
    }
    return false;
  }
  virtual void doUpdateImpl(OdGsUpdateContext& ctx, const OdGiDrawable* pBlockTableRecord, unsigned iInstance);
  void drawBlock(OdGsUpdateContext& ctx, const OdGiDrawable* pBlockTableRecord,
      OdGsBlockReferenceNodeImpl* pContainer,
      bool bEnableSharedGraphics);
  void postUpdateStep(OdGsUpdateState& state);
  void addEntPropsFromState(const OdGsUpdateState& state);
  void checkCancelledSharedRef(OdGsUpdateState& state);
  static void actionPostUpdateStep(void* pObj, OdGsUpdateState& state);
  static void actionAddEntPropsFromState(void* pObj, OdGsUpdateState& state);
  static void actionCheckCancelledSharedRef(void* pObj, OdGsUpdateState& state);
  static void actionRestartLocked(void* pObj, OdGsUpdateContext& ctx);
  virtual void doSpatialQuery(OdGsSpQueryContext& ctx);
  OdGsBlockReferenceNodeImpl* getImpl(const OdGsViewImpl& view)
  {
    if(!m_pImpl.get() || !m_pImpl->isSharedReference())
      return m_pImpl;
    return getSharedImpl(view);
  }
 
  bool saveClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer) const;
  bool loadClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer);
  bool postprocessNodeLoading(OdGsFiler *pFiler);
private:
  void createImpl(const OdGsUpdateContext& ctx, bool bTryShared);
  void drawBlockImpl(OdGsUpdateContext& ctx, const OdGiDrawable* pBlockTableRecord,
      OdGsBlockReferenceNodeImpl* pContainer,
      bool bEnableSharedGraphics);
 
  bool isAProxy(OdGiDrawable *pDrw, const OdGiContext *pCtx = NULL) const;
 
  void clearImpl() { m_pImpl = NULL; }
  bool validateSharedRefImpl(const OdGsUpdateContext &ctx, bool &bTryShared);
  OdGsBlockReferenceNodeImpl *getSharedImpl(const OdGsViewImpl &view);
protected:
  // Pointer to implementation object
  TPtr<OdGsBlockReferenceNodeImpl> m_pImpl;
  // Pointer to the node, corresponding to the block table record  
  OdGsBlockNode* m_pBlockNode;
  // list of attributes
  OdGsEntityNode* m_pFirstAttrib;
 
  friend class WorldDrawBlockRef;
  friend class GsDrawableNested;
  friend class OdGsSpQueryContext;
};

class GS_TOOLKIT_EXPORT OdGsMInsertBlockNode: public OdGsBlockReferenceNode
{
public:
  ODRX_DECLARE_MEMBERS(OdGsMInsertBlockNode);
  OdGsMInsertBlockNode(OdGsBaseModel* pModel, const OdGiDrawable* pInsert, bool bSetGsNode = false);
public:
  ~OdGsMInsertBlockNode();
 
  virtual void invalidate(OdGsContainerNode* pParent, OdGsViewImpl* pView, OdUInt32 mask);
  virtual void destroy();
  virtual void destroySubitems();
 
  virtual void highlight(bool bDoIt, bool bWholeBranch, OdUInt32 nSelStyle = 0);
 
  virtual OdGsEntityNode* firstEntity();
  virtual OdGsEntityNode* firstAttrib();
  virtual bool layersChanged(OdGsViewImpl& view) const;
  virtual void playAsGeometry(OdGsBaseVectorizer& view, EMetafilePlayMode eMode);
 
  virtual void makeStock();
  virtual void releaseStock();
  virtual void propagateLayerChangesStock();
  virtual bool isMInsert() const { return true; }
  virtual void doUpdateImpl(OdGsUpdateContext& ctx,
    const OdGiDrawable* pBlockTableRecord, unsigned iInstance);
  OdGsEntityNode*& firstAttrib(unsigned iInstance) { return item(iInstance)->m_pFirstAttrib; }
  void stretchExtents();
  void setParams(const OdGeMatrix3d& blockTf, int nCols, int nRows, double sx, double sy)
  {
    m_blockTf = blockTf;
    m_nCols = nCols;
    m_nRows = nRows;
    m_sx = sx;
    m_sy = sy;
  }
  static void actionStretchExtents(void* pObj, OdGsUpdateState& state);
  virtual void doDisplay(OdGsDisplayContext& ctx);
  virtual bool doSelect(OdGsBaseVectorizer& vect, OdGiDrawable* pDrw,
      OdSiSelBaseVisitor* pVisitor, OdGsView::SelectionMode mode);
 
protected:
  void destroyCollection();
 
  bool selectSubitems(OdGsBaseVectorizer& view,
          OdSiSelBaseVisitor* pVisitor, OdGsView::SelectionMode mode);
  bool selectAttributes(OdGsBaseVectorizer& view);
 
protected:
  class GS_TOOLKIT_EXPORT CollectionItem
  {
  public:
    CollectionItem() : m_nodeImp(0), m_pFirstAttrib(0) { }
    CollectionItem(const CollectionItem& c):
    m_nodeImp(c.m_nodeImp), m_pFirstAttrib(c.m_pFirstAttrib){}
    void copyFrom(const CollectionItem& c);
 
    OdGsBlockReferenceNodeImpl* imp() { return m_nodeImp; }
    const OdGsBlockReferenceNodeImpl* imp() const { return m_nodeImp; }
    OdGsEntityNode* firstAttrib() { return m_pFirstAttrib; }
    const OdGsEntityNode* firstAttrib() const { return m_pFirstAttrib; }
 
  public:
    TPtr<OdGsBlockReferenceNodeImpl> m_nodeImp;
    OdGsEntityNode* m_pFirstAttrib;
 
    bool operator ==(const CollectionItem &it2) const
    {
      return (m_nodeImp == it2.m_nodeImp) && (m_pFirstAttrib == it2.m_pFirstAttrib);
    }
    bool operator !=(const CollectionItem &it2) const
    {
      return (m_nodeImp != it2.m_nodeImp) || (m_pFirstAttrib != it2.m_pFirstAttrib);
    }
  };
  class GS_TOOLKIT_EXPORT Collection: public OdArray<CollectionItem>
  {
  public:
    Collection(): OdArray<CollectionItem>(){}
    Collection(const Collection& c);
    ~Collection();
  };
protected:
  OdGsBlockReferenceNodeImpl* getImpl(unsigned iInstance) { return item(iInstance)->m_nodeImp; }
  CollectionItem* item(unsigned iInstance);
  void clearParams() {m_nCols = m_nRows = 0; m_sx = m_sy = 0.; m_blockTf.setToIdentity(); }
 
  bool saveClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer) const;
  bool loadClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer);
  bool postprocessNodeLoading(OdGsFiler *pFiler);
protected:
  // Collection of implementation objects, representing clipped MINSERT.
  // (If MINSERT is not clipped, it's represented by only implementation 
  // object OdGsBlockReferenceNode::m_pImpl)
  Collection* m_pCollectionImpl;
  OdGeMatrix3d m_xModelToWorld;
  OdGeMatrix3d m_blockTf;
  int m_nCols;
  int m_nRows;
  double m_sx;
  double m_sy;
};
 
inline void OdGsBlockReferenceNode::clearBlockNode()
{
  m_pBlockNode = 0;
}
 
#include "TD_PackPop.h"
 
#endif // __OD_GS_REFERENCE_NODE__