GsBaseVectorizer.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_BASE_VECTORIZER_H_
#define __OD_GS_BASE_VECTORIZER_H_
 
#include "TD_PackPush.h"
 
#include "Gs/GsExport.h"
#include "Gs/GiBaseVectorizerImpl.h"
#include "Gs/GsExtAccum.h"
#include "Gs/GsModel.h"
#include "GsMarkerArray.h"
#include "Gs/GsHighlightData.h"
 
class OdGsBaseModel;
class OdGsLayerNode;
class OdGsUpdateContext;
class OdGiSelectProcBase;
class OdGsEntityNode;
class OdGsBlockReferenceNode;
class OdGsBlockReferenceNodeImpl;
struct OdGsGeomPortion;
class OdGsMaterialNode;
class OdGsBaseVectorizer;
class OdGsBaseContext;
class OdGsDisplayContext;
struct OdSiShape;
class OdSiRecursiveVisitor;
 
class OdGsMtContext;
class OdGsUpdateState;
class OdGsNestedMetafile;
class OdGiSharedRefDesc;
class OdGiHistory;
class OdGiSectionGeometry;
class OdGsApplyModelOverrides;
 
class OdPerfTimerBase;
 

typedef OdSharedPtr< OdGsApplyModelOverrides > OdGsApplyModelOverridesPtr;

class GS_TOOLKIT_EXPORT OdGsWriter
{
public:
  OdGsWriter();

  OdGsExtAccum& extentsAccum()
  {
    return *m_pExtAccum.get();
  }

  OdGsBaseModel* gsModel() const { return m_pGsModel; }

  bool isRecordingMetafile() { return m_pGeomPortion != 0; }

  OdGsGeomPortion *currentGeomPortion() const { return m_pGeomPortion; }

  OdGsGeomPortion *headGeomPortion() const { return m_pGeomPortionHead; }

  void beginMetafileRecording(OdGsGeomPortion* pGeomPortion) { m_pGeomPortionHead = m_pGeomPortion = pGeomPortion; }

  void endMetafileRecording();
  void onNestedDrawable(OdDbStub* layerId, const OdGsNestedMetafile *pNestedMf = NULL);
  void separateMetafile();

  bool isLayerFrozen(OdGsLayerNode *pLayerNode) const;

  bool hasFrozenLayerBefore(OdGsLayerNode *pLayerNode, const OdGsGeomPortion *pTillPortion = NULL) const;
private:
  //DOM-IGNORE-BEGIN
  friend class OdGsBaseVectorizer;
  void set(OdGsBaseVectorizer* v) { m_vectorizer = v; }
  void onLayerModified(OdDbStub* layerId, bool bFrozen, bool bFromSetAttribs);
  void onLayerModified(OdDbStub* layerId) { onLayerModified(layerId, false, false); }
  void onSetAttributesLayer(OdDbStub *layerId) { onLayerModified(layerId, false, true); }
  void onFrozenLayerModified(OdDbStub* layerId) { onLayerModified(layerId, true, false); }
 
public:
  OdGsBaseModel* m_pGsModel;
 
protected:
  bool isCurrentGeomPortionDiscardable();
protected:
  OdGsExtAccumPtr m_pExtAccum;
  OdGsGeomPortion* m_pGeomPortionHead;
  OdGsGeomPortion* m_pGeomPortion;
  OdGsBaseVectorizer* m_vectorizer;
  bool m_bFinalizedMetafile;
  //DOM-IGNORE-END
};
 
class OdGiPointLightTraitsData;
class OdGiSpotLightTraitsData;
class OdGiDistantLightTraitsData;
class OdGiWebLightTraitsData;

class GS_TOOLKIT_EXPORT OdGsBaseVectorizer: public OdGiBaseVectorizerImpl
{
public:
  OdGsBaseVectorizer();
 
protected:
  //DOM-IGNORE-BEGIN
  ODRX_USING_HEAP_OPERATORS(OdGiBaseVectorizer);
  //DOM-IGNORE-END
 
public:  
#ifdef SWIG
  virtual void draw(const OdGiDrawable* pDrawable) {draw(pDrawable);};
#endif
  OdGsWriter& gsWriter() { return m_gsWriter; }

  const OdGsWriter& gsWriter() const { return m_gsWriter; }

  OdGsExtAccum& gsExtentsAccum() { return gsWriter().extentsAccum(); }

  virtual OdRxObjectPtr newGsMetafile();

  virtual void beginMetafile(OdRxObject* pMetafile);

  virtual void endMetafile(OdRxObject* pMetafile);

  virtual void playMetafile(const OdRxObject* pMetafile);

  virtual bool saveMetafile(const OdRxObject* pMetafile, OdGsFiler *pFiler);

  virtual OdRxObjectPtr loadMetafile(OdGsFiler *pFiler);

  bool isMetafileEmpty() const { return m_nMetafileSize == 0; }
  
  OdUInt64 lastMetafileSize() const 
  {
    if( m_nMetafileSize != OdUInt64( -1 ) ) return m_nMetafileSize;
    return 0;
  }

  virtual void loadViewport();
 
  virtual bool forceMetafilesDependence() const;

  virtual bool isViewRegenerated() const;

  virtual void drawViewportFrame();

  virtual void updateViewport();
 
 
  // Materials support

  virtual void processMaterialNode(OdDbStub *materialId, OdGsMaterialNode *pNode);
  
  virtual bool saveMaterialCache(const OdGsMaterialNode *pNode, OdGsFiler *pFiler);

  virtual bool loadMaterialCache(OdGsMaterialNode *pNode, OdGsFiler *pFiler);

  virtual void addPointLight(const OdGiPointLightTraitsData&) {}

  virtual void addSpotLight(const OdGiSpotLightTraitsData&) {}

  virtual void addDistantLight(const OdGiDistantLightTraitsData&) {}

  virtual void addWebLight(const OdGiWebLightTraitsData&);
  // default implementation call's addPointLight

  ~OdGsBaseVectorizer();


  void pushModelTransform(const OdGeMatrix3d& xfm);

  void pushModelTransform(const OdGeVector3d& normal);

  void popModelTransform();

  void pushClipBoundary(OdGiClipBoundary* pBoundary);

  void pushClipBoundary(OdGiClipBoundary* pBoundary, OdGiAbstractClipBoundary* pClipInfo);

  void popClipBoundary();


  virtual void setEntityTraitsDataChanged();

  virtual void setEntityTraitsDataChanged(int bit, bool value = true);

  virtual OdGeMatrix3d objectToDeviceMatrix() const;

  virtual bool pushPaletteOverride(const OdGiPalette* pOverride);

  virtual void popPaletteOverride();

  virtual bool hasPaletteOverrides() const;


  bool disableInfiniteGeomExtents() const { return GETBIT(m_flags, kDisableInfiniteGeomExtents); }
  bool sectionableGeomExtentsOnly() const { return GETBIT(m_flags, kSectionableGeomExtentsOnly); }
  void setSectionableGeomExtentsOnly(bool bOn) { SETBIT(m_flags, kSectionableGeomExtentsOnly, bOn); }

  void playMetafileMode(const OdRxObject* pMetafile, EMetafilePlayMode eMode, OdGsEntityNode& node, OdGsBaseContext* ctx);

  virtual bool playNestedMetafile(const OdGsGeomPortion* pPortion, OdGsBaseContext* pContext, OdGsEntityNode& node);

  EMetafilePlayMode metafilePlayMode() const { return m_eMfPlayMode;  }
 
  enum MetafileTransformFlags
  {
    kSharedRefTransform = (1 << 0),
    kSharedRefUpdate    = (1 << 1),
    kSharedRefSelect    = (1 << 2)
  };

  virtual void pushMetafileTransform(const OdGeMatrix3d&, OdUInt32 = 0);

  virtual void popMetafileTransform(OdUInt32 = 0);

  virtual const OdGeMatrix3d &metafileTransform() const;
 
  virtual bool useSharedBlockReferences() const { return true; }
  virtual bool useMetafileAsGeometry() const { return false; }
  virtual OdGiConveyorOutput& outputForMetafileGeometry();
  virtual void setTransformForMetafileGeometry(const OdGeMatrix3d&) {}
  virtual OdGeMatrix3d getTransformForMetafileGeometry() const { return OdGeMatrix3d::kIdentity; }
  virtual void reportUpdateError(OdDbStub* /*entityId*/, const OdError& error)
  {
#ifdef ODA_DIAGNOSTICS
    throw error;
#else
    ODA_VERIFY(error); // prevent arg unused warning
#endif
  }

  OdGsLayerNode* gsLayerNode(OdDbStub* layerId, OdGsBaseModel* pModel);

  inline bool isFaded() const;

  inline OdUInt32 fadingIntensity() const;

  inline bool isHighlighted() const;

  inline bool isSelecting() const;

  inline bool isHidden() const;

  inline void setHidden( bool bHidden );

  void setSubentityTransform(bool bEnableTf, OdGsMarker refMarker = kNullSubentIndex, const OdGsStateBranch *pTfBranch = NULL);

  virtual void applySubentityTransform(const OdGeMatrix3d *pXform);

  bool isDragging() const;
 
  virtual OdGiConveyorOutput& gsExtentsOutput() { return secondaryOutput(); }

  virtual void setAnalyticLinetypingCircles(bool analytic);

  virtual bool isAnalyticLinetypingCircles() const;

  virtual void setAnalyticLinetypingComplexCurves(bool analytic);

  virtual bool isAnalyticLinetypingComplexCurves() const;
 
  void checkSelection();

  bool handleSelectionByExtents( const OdGeExtents3d& extWc );
 
  virtual bool displayViewportProperties(OdGsPropertiesDirectRenderOutput *pdro = NULL,
      OdUInt32 incFlags = OdGsProperties::kAll);

  OdGiConveyorOutput& secondaryOutput();
 
  // OdGiBaseVectorizerImpl methods

  virtual void setUp(OdGsViewImpl& view);
 
  // OdGiBaseVectorizer methods

  virtual void beginViewVectorization();

  virtual void endViewVectorization();

  virtual void onTraitsModified();

  virtual double deviation(const OdGiDeviationType deviationType, const OdGePoint3d& pointOnCurve) const;

  virtual bool regenAbort() const;

  virtual bool doDraw(OdUInt32 drawableFlags, const OdGiDrawable* pDrawable);

  virtual void setSelectionMarker(OdGsMarker selectionMarker);
  virtual OdGiConveyorOutput& output();

  virtual void setVisualStyle(const OdGiVisualStyle& visualStyle);

  OdGsStateBranch* findSubnodeBranch(OdGsStateBranch::BranchType branchType = OdGsStateBranch::kHighlightingBranch);

  const OdGsStateBranch* currentStateBranch(OdGsStateBranch::BranchType branchType = OdGsStateBranch::kHighlightingBranch) const;

  void highlight(bool bHighlight, OdUInt32 nSelStyle = 0);

  OdUInt32 threadIndex() const;

  OdGsLayerNode *activeLayerNode(bool bSync = false) const;

  OdGsModel::RenderType activeRenderType() const;

  OdGsOverlayId activeOverlay() const;

  virtual bool isSpatialIndexDisabled() const { return false; }

  virtual void beginMetafileRecording(OdGsGeomPortion* pGeomPortion);

  virtual void endMetafileRecording();

  struct BlockScopesCallback
  {
    virtual void blockBegin(const void *pRefId) = 0;
    virtual void blockEnd(const void *pRefId) = 0;
  };
protected:
  //DOM-IGNORE-BEGIN
  void doSelect(const OdGePoint2d* aPtDc, int numPoints,
      OdGsSelectionReactor* pReactor, OdGsView::SelectionMode mode);
  virtual void doRayTrace(const OdGePoint3d &rayOrigin, const OdGeVector3d &rayDirection,
                          OdGsRayTraceReactor *pReactor, bool bSortedSelection,
                          OdGiPathNode const *const *pObjectList, OdUInt32 nObjectListSize);
  bool doViewExtents(OdGeBoundBlock3d& extents);
  virtual void display(bool bUpdate);
  virtual void updateExtents(bool bBuildCache);
 
  // OdGiBaseVectorizer methods
  virtual const OdGiLayerTraitsData& effectiveLayerTraits() const;
  virtual OdDbStub* switchLayer(OdDbStub* layerId) const;
 
  void selectionMarkerOnChange(OdGsMarker nSelectionMarker);
 
  void checkRenderType(const OdGsModel *pModel);
  virtual void renderTypeOnChange(OdGsModel::RenderType renderType);
  virtual void switchOverlay(OdGsOverlayId overlayId);

  void initDeviationMultiplier();
  double handleDeviationMultiplier(const OdGiDeviationType deviationType, double dDeviationValue) const;

  void displayWithoutNesting(OdGsEntityNode *pNode, BlockScopesCallback *pBlockScopesCbk = NULL);
 
  virtual void displayNode(OdGsNode& node, OdGsDisplayContext& ctx);
  virtual void displaySubnode(OdGsEntityNode& node, OdGsDisplayContext& ctx, bool bHighlighted);
 
  void doDrawLight(const OdGiDrawable* pDrawable);
  bool isSharedGraphicsState() const;
  const OdGsUpdateState* currentState() const { return m_curState; }
 
  virtual bool updateExtentsOnly() const ODRX_OVERRIDE;
  //DOM-IGNORE-END
public:

  virtual OdUInt32 setAttributes(const OdGiDrawable* pDrawable);
 
  void updateExtentsInThreadInit(OdGsMtContext& mtContext);
 
private:
  //DOM-IGNORE-BEGIN
  void setInitGsState(bool bOn);
  bool isRecordingHistory();
  void deleteHistory();
  void setThreadIndex(OdUInt32 idx) { m_threadIndex = idx; }
  //FELIX_CHANGE_BEGIN
protected:
  bool FxDrawSectionable(OdGiSectionGeometryManager* pSectionGeometryManager, const OdGiDrawable& drawable, bool& bRes);
private:
  //FELIX_CHANGE_END
  bool drawSectionable(const OdGiDrawable& drawable, bool& bRes);
  bool drawSectionGeometry(OdGiSectionGeometry& geom, bool bVpModelTfAwareBefore);
  void setCurrentState(OdGsUpdateState& newState);
  OdGsUpdateState* currentState() { return m_curState; }
  void applyState(const OdGsUpdateState& s, const OdGsUpdateState& prev);
  //DOM-IGNORE-END
public:
  OdGsStateBranchPtr m_pCurStateBranch[OdGsStateBranch::kNumBranchTypes]; // Current state branches
  bool hasAnyStateBranch(bool bMarkers = false) const;
protected:
  //DOM-IGNORE-BEGIN
  
  OdArray<OdGeMatrix3d> m_metafileTransfStack;
  OdUInt64 m_nMetafileSize;
  OdGsWriter m_gsWriter;
  OdGiSelectProcBase* m_pSelectProc;
  OdGiConveyorGeometry* m_pDetachedOutput;
  OdGiConveyorGeometry* m_pDetachedSecondaryOutput;
  const OdSiShape* m_MfPlayQuery; // Currently playing query
  const OdGsEntityNode* m_MfPlayNode; // Currently playing node
  EMetafilePlayMode m_eMfPlayMode;
  OdGsUpdateState* m_curState;
  OdGsModel::RenderType m_curRenderType;
  OdGsOverlayId m_curOverlay;
  double m_dDeviationMultiplier;
  OdIntPtr m_drawableFilterFunction;
  OdGsMaterialNode *m_pCachedMaterial;
  OdGsBaseModel *m_pRefCacheModel;
  OdGsMarker m_activeSubMarker;
  // Fading support
  enum FadingFlags
  {
    kFfLockedLayer       = (1 << 0),
    kFfXref              = (1 << 1),
    kFfRefEdit           = (1 << 2),
    kFfFlagsMask         = kFfLockedLayer  | kFfXref  | kFfRefEdit,
    kEFfLockedLayer      = (1 << 4),
    kEFfXref             = (1 << 5),
    kEFfRefEdit          = (1 << 6),
    kEFfFlagsMask        = kEFfLockedLayer | kEFfXref | kEFfRefEdit,
    kEFfFlagsOffset      = 4,
    kFvLockedLayerOffset = 8,
    kFvLockedLayerMask   = (0xFF << kFvLockedLayerOffset),
    kFvXrefOffset        = 16,
    kFvXrefMask          = (0xFF << kFvXrefOffset),
    kFvRefEditOffset     = 24,
    kFvRefEditMask       = (0xFF << kFvRefEditOffset)
  };
  OdUInt32 m_fadingFlags;
  template <OdGiContext::FadingType fadingType> friend class OdGsLockFadingFlag;
  
  //DOM-IGNORE-END
  OdUInt32 m_selectionStyle;
  //DOM-IGNORE-END
public:

  OdUInt32 currentSelectionStyle() const { return m_selectionStyle; }

  bool hasSelectionStyle() const { return m_selectionStyle != 0; }

  int highlightingPass() const;

  void setRenderAbort( bool bSet );

  virtual bool renderAbort();
protected:
  //DOM-IGNORE-BEGIN
  
  enum BaseVectorizerFlags
  {
    kRenderAbort            = OdGiBaseVectorizerImpl::kLastImplFlag << 1,
    kViewInteractive        = OdGiBaseVectorizerImpl::kLastImplFlag << 2,
    kHighlightFirstPass     = OdGiBaseVectorizerImpl::kLastImplFlag << 3,
    kHighlightSecondPass    = OdGiBaseVectorizerImpl::kLastImplFlag << 4,
    kAbsoluteDeviation      = OdGiBaseVectorizerImpl::kLastImplFlag << 5,
    kSubMarkerXformSet      = OdGiBaseVectorizerImpl::kLastImplFlag << 6,
 
    kLastBaseVectorizerFlag = kSubMarkerXformSet
  };
  double m_dRenderAbortCondition;
  OdPerfTimerBase* m_viewTimingProcessor;
 
  const OdGsExtAccum *secondaryOutputExtents() const { return m_pOutputExtents.get(); }
  OdGsExtAccum *secondaryOutputExtents() { return m_pOutputExtents.get(); }
 
private:
  mutable const OdGiLayerTraitsData* m_pCachedLayer;
  OdGsLayerNode* m_effectiveLayer;
  OdGsExtAccumPtr m_pOutputExtents;
  OdGiHistory* m_giHistory;
  OdUInt32 m_threadIndex;
  bool m_bTraitsDataChanged;
  bool m_bByBlockTraitsChanged;
  friend class OdGsUpdateContext;
  friend class OdGsDisplayContext;
  friend class OdGsBaseVectorizeView;
  friend class OdGsApplyModelOverrides;
 
protected:
  virtual void doCollide( OdGiPathNode const*const* pInputList, OdUInt32 nInputListSize, OdGsCollisionDetectionReactor* pReactor, OdGiPathNode const*const* pCollisionWithList = NULL, OdUInt32 nCollisionWithListSize = 0, const OdGsCollisionDetectionContext* pCtx = NULL );
  virtual void doCollideAll( OdGsCollisionDetectionReactor* pReactor, const OdGsCollisionDetectionContext* pCtx = NULL );
  void processDrawableForCollide( const OdGiPathNode* pStartNode, const OdGiDrawable* pDrawable, OdGsBaseModel*& pCurModel, OdGsApplyModelOverridesPtr& pCurOverrides, OdSiRecursiveVisitor &siVisitor );
  void processAllDrawablesForCollide( const OdGeExtents3d* pExtents = NULL, OdGiPathNode const*const* pCollisionWithList = NULL, OdUInt32 nCollisionWithListSize = 0, bool bIgnoreViewExtents = false );
 
  void modelChanged( const OdGsModel* pModel );
};
 
template <typename ClientClass = OdGsBaseVectorizer>
class OdGsHighlightingStateSaver
{
  protected:
    ClientClass& m_vect;
    const bool m_bHighlighted;
    const OdUInt32 m_selStyle;
  public:
    OdGsHighlightingStateSaver(ClientClass &vect)
      : m_vect(vect)
      , m_bHighlighted(vect.isHighlighted())
      , m_selStyle(vect.currentSelectionStyle())
    { }
    ~OdGsHighlightingStateSaver()
    { m_vect.highlight(m_bHighlighted, m_selStyle); }
    bool isHighlighted() const { return m_bHighlighted; }
    OdUInt32 selectionStyle() const { return m_selStyle; }
};
 
 
template <OdGiContext::FadingType fadingType>
class OdGsLockFadingFlag
{
  protected:
    OdUInt32 &m_lockedFlags;
    bool m_bSavedBit;
  public:
    OdGsLockFadingFlag(OdGsBaseVectorizer &vectorizer)
      : m_lockedFlags(vectorizer.m_fadingFlags)
      , m_bSavedBit(GETBIT(vectorizer.m_fadingFlags, 1 << fadingType))
    {}
    void set(bool bNewVal) { SETBIT(m_lockedFlags, 1 << fadingType, bNewVal); }
    OdGsLockFadingFlag(OdGsBaseVectorizer &vectorizer, bool bNewVal)
      : m_lockedFlags(vectorizer.m_fadingFlags)
      , m_bSavedBit(GETBIT(vectorizer.m_fadingFlags, 1 << fadingType))
    { set(bNewVal); }
    ~OdGsLockFadingFlag() { set(m_bSavedBit); }
};
//DOM-IGNORE-END
 
inline bool OdGsBaseVectorizer::isFaded() const
{ // Returns true in case if any type of fading is 'true' and fading value is positive
  return !!((m_fadingFlags & kFfFlagsMask) & ((m_fadingFlags & kEFfFlagsMask) >> kEFfFlagsOffset));
}
 
inline OdUInt32 OdGsBaseVectorizer::fadingIntensity() const
{ // Returns percentage in [0-100] range
  OdUInt32 nIntensityMix = 100;
  if (GETBIT(m_fadingFlags, kFfLockedLayer) && GETBIT(m_fadingFlags, kEFfLockedLayer))
  {
    OdUInt32 mix = 100 - ((m_fadingFlags & kFvLockedLayerMask) >> kFvLockedLayerOffset);
    nIntensityMix = mix;
  }
  if (GETBIT(m_fadingFlags, kFfXref) && GETBIT(m_fadingFlags, kEFfXref))
  {
    OdUInt32 mix = 100 - ((m_fadingFlags & kFvXrefMask) >> kFvXrefOffset);
    nIntensityMix = odmin(nIntensityMix, mix);
  }
  if (GETBIT(m_fadingFlags, kFfRefEdit) && GETBIT(m_fadingFlags, kEFfRefEdit))
  {
    OdUInt32 mix = 100 - ((m_fadingFlags & kFvRefEditMask) >> kFvRefEditOffset);
    nIntensityMix = nIntensityMix * mix / 100;
  }
  nIntensityMix = odmax(10, nIntensityMix);
  return 100 - nIntensityMix;
}
 
inline const OdGsStateBranch *OdGsBaseVectorizer::currentStateBranch(OdGsStateBranch::BranchType branchType) const
{
  return m_pCurStateBranch[branchType];
}
 
inline bool OdGsBaseVectorizer::hasAnyStateBranch(bool bMarkers) const
{ bool bHasAnyBranch = false;
  for (OdUInt32 nBranch = 0; nBranch < OdGsStateBranch::kNumBranchTypes; nBranch++)
  { if (!m_pCurStateBranch[nBranch].isNull() && (!bMarkers || !m_pCurStateBranch[nBranch]->markersEmpty()))
    { bHasAnyBranch = true; break; } }
  return bHasAnyBranch;
}
 
inline OdUInt32 OdGsBaseVectorizer::threadIndex() const
{
  return m_threadIndex;
}
 
inline OdGsLayerNode *OdGsBaseVectorizer::activeLayerNode(bool bSync) const
{
  if (bSync)
    updateLayerTraits(m_effectiveEntityTraitsData);
  return m_effectiveLayer;
}
 
inline OdGsModel::RenderType OdGsBaseVectorizer::activeRenderType() const
{
  return m_curRenderType;
}
 
inline OdGsOverlayId OdGsBaseVectorizer::activeOverlay() const
{
  return m_curOverlay;
}
 
inline bool OdGsBaseVectorizer::isSelecting() const
{
    return m_pSelectProc != 0;
}
 
inline void OdGsBaseVectorizer::highlight(bool bHighlight, OdUInt32 nSelStyle)
{
  SETBIT(m_flags, kHighlighted, bHighlight);
  m_selectionStyle = nSelStyle;
}
 
inline bool OdGsBaseVectorizer::isHighlighted() const
{
  return GETBIT(m_flags, kHighlighted);
}
 
inline int OdGsBaseVectorizer::highlightingPass() const
{
  return GETBIT(m_implFlags, kHighlightFirstPass) ? 1 : (GETBIT(m_implFlags, kHighlightSecondPass) ? 2 : 0);
}
 
inline bool OdGsBaseVectorizer::isHidden() const
{
  return GETBIT(m_implFlags, kHiddenImplFlag);
}
 
inline void OdGsBaseVectorizer::setHidden( bool bHidden )
{
  SETBIT( m_implFlags, kHiddenImplFlag, bHidden );
}
 
inline const OdGeMatrix3d &OdGsBaseVectorizer::metafileTransform() const
{ // Metafile transformation matrix
  return m_metafileTransfStack.isEmpty() ? OdGeMatrix3d::kIdentity : m_metafileTransfStack.last();
}
 
#include "TD_PackPop.h"
 
#endif // __OD_GS_BASE_VECTORIZER_H_