GsNode.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_NODE__
#define __OD_GS_NODE__
 
#include "TD_PackPush.h"
 
#include "Gs/GsBaseModel.h"
#include "ChunkAllocator.h"
 
class OdGsContainerNode;
class OdGsLayerNode;
        
class OdGsBaseModel;
class OdGsUpdateContext;
class OdGsDisplayContext;
class OdSiSpatialIndex;
class OdGsUpdateManager;

class GS_TOOLKIT_EXPORT ODRX_ABSTRACT OdGsNode : public OdGsCache
{
  friend class OdGsBaseModel;
  friend class OdGsViewImpl;
  //FELIX_CHANGE_BEGIN
  friend GS_TOOLKIT_EXPORT OdGiDrawablePtr fxUnderlyingDrawable( const OdGsNode* );
  //FELIX_CHANGE_END
protected:
  //DOM-IGNORE-BEGIN
  
  mutable OdGsNode* m_pPrev;
  mutable OdGsNode* m_pNext;
 
  GS_STATIC_EXPORT static AllocatorArray s_aAlloc;
 
  OdGsBaseModel* m_pModel;
  void*          m_underlyingDrawable;
  enum
  {
    kPersistent = 0x00000001,
    kContainer  = 0x00000002,
    kHLT        = 0x00000004, // Highlight
    kHLT_All    = 0x00000008, // Highlight whole branch
    kSyncDrawable=0x00000010,
    kHidden     = 0x00000020,
    kSelectHidden=0x00000040,
    kHiddenAll    = 0x00000080, // The whole node is hidden
    kSelStyle     = 0x00000100, // Selection style provided
    kLastFlag     = kSelStyle
  };
 
  mutable OdUInt32  m_flags;
 
  // Flags to provide some custom data for OdGsBaseModel-derived class at application level
  OdUInt32 m_userFlags;
 
  enum { kInvalidateVp = 0x80000000 };
  
  //DOM-IGNORE-END
public:
  inline bool invalidVp() const { return GETBIT(m_flags, kInvalidateVp); }
protected:
  inline void setInvalidVp(bool val) { SETBIT(m_flags, kInvalidateVp, val); }

  void clearDrawable();

  void setSelectionStyleImpl(OdUInt32 nStyle);
  OdUInt32 getSelectionStyleImpl() const;
public:
  void setToDrawable(const OdGiDrawable* pUnderlyingDrawable);
 
public:
  ODRX_DECLARE_MEMBERS(OdGsNode);
 
  void* operator new(size_t);
  void operator delete(void *);

  void addRef();

  void release() ODRX_NOEXCEPT;

  OdGsNode(OdGsBaseModel* pModel, const OdGiDrawable* pUnderlyingDrawable);
protected:
  OdGsNode(const OdGsNode& c);
public:
  virtual ~OdGsNode();

  OdGsBaseModel* baseModel() const;

  OdGsModel* model() const;

  bool isContainer() const;
 
  virtual ENodeType nodeType() const = 0;

  bool isSyncDrawable() const;

  virtual void invalidate(OdGsContainerNode* pParent, OdGsViewImpl* pView, OdUInt32 mask) = 0;

  OdGiDrawablePtr underlyingDrawable() const;

  OdDbStub* underlyingDrawableId() const;

  virtual void update(OdGsUpdateContext& ctx, OdGsContainerNode* pParent,
      OdSiSpatialIndex* pParentIndex) = 0;

  virtual void updateVisible( OdGsViewImpl* pViewImpl ) {};

  virtual void display(OdGsDisplayContext& ctx) = 0;

  virtual void propagateLayerChanges(OdGsViewImpl& view) = 0;

  virtual void destroy() = 0;

  virtual void highlight(bool bDoIt, bool bWholeBranch, OdUInt32 nSelStyle = 0);

  bool isHighlighted() const;
  bool isHighlightedAll() const;

  virtual void hide(bool bDoIt, bool bSelectable = false, bool bWholeBranch = true);
  bool isHidden() const;
  bool isSelectableIfHidden() const;
  bool isHiddenAll() const;

  OdUInt32 selectionStyle() const;
  bool hasSelectionStyle() const;

  OdUInt32 userFlags() const;
  void setUserFlags(OdUInt32 val);
 
  virtual bool saveNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer = NULL) const;
  virtual bool loadNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer = NULL);
  virtual bool saveClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer) const;
  virtual bool loadClientNodeState(OdGsFiler *pFiler, OdGsBaseVectorizer *pVectorizer);
  virtual bool postprocessNodeLoading(OdGsFiler *pFiler);
 
  TD_USING(OdGsCache::extents);

  virtual bool extents(const OdGsView* pView, OdGeExtents3d& ext) const;

  bool modelExtents(OdGeExtents3d& ext, bool bUseModelTf = true) const;
  bool modelExtents(const OdGsView* pView, OdGeExtents3d& ext, bool bUseModelTf = true) const;

  virtual OdDb::LineWeight getMaxLineweightUsed() const;

  virtual void setDrawableNull();
 
  struct UpdateManagerContext
  {
    enum ContextType
    {
      kForMemoryLimit = 0,
      kForDrawOrder
    };
    ContextType contextType;
    OdGsViewImpl* pView;
  };

  virtual void addContentToUpdateManager( OdUInt32 viewportId, OdGsUpdateManager* pManager, const UpdateManagerContext& context ) {}

  virtual bool isMetafilesCompatible( const OdGsViewImpl* pView1, const OdGsViewImpl* pView2, OdGsUpdateContext* ctx ) { return true; }
};
//FELIX_CHANGE_BEGIN
GS_TOOLKIT_EXPORT OdGiDrawablePtr fxUnderlyingDrawable( const OdGsNode* );
//FELIX_CHANGE_END
inline OdGiDrawablePtr OdGsNode::underlyingDrawable() const
{
  //FELIX_CHANGE_BEGIN
  /*
  if(GETBIT(m_flags, kPersistent))
    return m_pModel->open(reinterpret_cast<OdDbStub*>(m_underlyingDrawable));
  return reinterpret_cast<OdGiDrawable*>(m_underlyingDrawable);
  */
  return( fxUnderlyingDrawable( this ) );
  //FELIX_CHANGE_END
}
 
inline OdDbStub* OdGsNode::underlyingDrawableId() const
{
  if(GETBIT(m_flags, kPersistent))
    return reinterpret_cast<OdDbStub*>(m_underlyingDrawable);
  return 0;
}
 
inline OdUInt32 OdGsNode::selectionStyle() const
{
  if (hasSelectionStyle())
    return getSelectionStyleImpl();
  return 0;
}
 
inline bool OdGsNode::hasSelectionStyle() const
{
  return GETBIT(m_flags, kSelStyle);
}
 
inline void OdGsNode::highlight(bool bDoIt, bool bWholeBranch, OdUInt32 nSelStyle)
{
  SETBIT(m_flags, kHLT, bDoIt);
  SETBIT(m_flags, kHLT_All, bDoIt ? bWholeBranch : false);
  if ((bDoIt && (nSelStyle || hasSelectionStyle())) || (!bDoIt && hasSelectionStyle()))
    setSelectionStyleImpl(nSelStyle);
}
 
inline bool OdGsNode::isHighlighted() const
{
  return GETBIT(m_flags, kHLT);
}
 
inline bool OdGsNode::isHighlightedAll() const
{
  return GETBIT(m_flags, kHLT_All);
}
 
inline OdGsBaseModel* OdGsNode::baseModel() const
{
  return const_cast<OdGsBaseModel*>(m_pModel);
}
 
inline bool OdGsNode::isContainer() const
{
  return GETBIT(m_flags, kContainer);
}
 
inline bool OdGsNode::isSyncDrawable() const
{
  return GETBIT(m_flags, kSyncDrawable);
}
 
inline bool OdGsNode::isHidden() const
{
  return GETBIT(m_flags, kHidden);
}
 
inline bool OdGsNode::isSelectableIfHidden() const
{
  return GETBIT(m_flags, kSelectHidden);
}
 
inline bool OdGsNode::isHiddenAll() const
{
  return GETBIT(m_flags, kHiddenAll);
}
 
inline OdUInt32 OdGsNode::userFlags() const
{
  return m_userFlags;
}
 
inline void OdGsNode::setUserFlags(OdUInt32 val)
{
  m_userFlags = val;
}
 
#include "TD_PackPop.h"
 
#endif // __OD_GS_NODE__