FxDbExtension.h

Go to the documentation of this file.

//FELIX_CHANGE_BEGIN
#if !defined(_FXEXTENSIONS_H_INCLUDED_)
#define _FXEXTENSIONS_H_INCLUDED_
 
#include "FxGeExtension.h"
 
#include "OdaCommon.h"
 
#include "TD_PackPush.h"
#include "DbExport.h"
#include "DbEvalWatchers.h"
#include "DbDimension.h"
#include "Db3dSolid.h"
#include <ModelerGeometry.h>
#include "Gi/GiRasterImage.h"
#include "DbBlockReference.h"
#include "Gs/Gs.h"
#include "DbMLeader.h"
#include "DbFcf.h"
#include "DbSpline.h"
#include "DbEllipse.h"
#include <DbMPolygon.h>
 
#include <vector>
#include <list>
#include <functional>
 
class OdGiLinetyper;
class OdRxDynamicLinker;
class OdDbPlotSettingsValidator;
class OdEdCommandStack;
class OdEdCommandContext;
 
class OdEdCommand;
typedef OdSmartPtr<OdEdCommand> OdEdCommandPtr;
 
class OdDbPlotSettings;
typedef OdRxObject OdDbBaseDatabase;
class OdDbBaseDatabasePE;
 
class OdDbLine;
class OdDbXline;
class OdDbRay;
class OdDbArc;
class OdDbCircle;
class OdDbEllipse;
class OdDbPolyline;
class OdDb2dPolyline;
class OdDb3dPolyline;
class OdDbSpline;
class OdGeExtents3d;
class OdDbGroup;
class OdDbFcf;
class OdDbMText;
class OdDbLeader;
class OdDbTable;
class OdDbMPolygon;
 
class OdDbEntity;
class OdDbBlockReference;
class OdDbRasterImageDef;
class OdModelerGeometry;
 
class OdGeCircArc3d;
class OdGeEllipArc3d;
class OdDbRadialDimension;
class OdDbDimensionObjectContextData;
 
class OdDbBlockGrip;
class OdDbAttributeDefinition;
class ENTITY_LIST;
class EDGE;
class SPAposition;
class SPApar_pos;
class SPAvector; 
class SPAunit_vector;
class SPApar_vec;
class SPAunit_vector;
class SPAtransf;
class OdGeMatrix3d;
class BODY;
 
class OdDbHatchImpl;
class OdGiContextForDbDatabase;
 
// The special filter for removing extra entities from the
// selection set before transformations
class TOOLKIT_EXPORT CFxDbModificationFilter
{
public:
    CFxDbModificationFilter();
    virtual ~CFxDbModificationFilter();
    virtual OdDbObjectIdArray FilterObjects( const OdDbObjectIdArray& objectIds ) const = 0;
 
};
 
class TOOLKIT_EXPORT CFxDbUndoReactor
{
public:
    virtual void undoWriteStarted( OdDbDatabase* pDatabase, OdDbDwgFiler* pFiler ) = 0;
    virtual void undoWriteFinished( OdDbDatabase* pDatabase, OdDbDwgFiler* pFiler ) = 0;
    virtual void redoWriteStarted( OdDbDatabase* pDatabase, OdDbDwgFiler* pFiler ) = 0;
    virtual void redoWriteFinished( OdDbDatabase* pDatabase, OdDbDwgFiler* pFiler ) = 0;
};
 
class TOOLKIT_EXPORT CFxDbExtension
{
public:
    virtual ~CFxDbExtension() = 0;
 
public:
    virtual bool getFilename(const OdDbDatabase* pDatabase, OdString& result) const = 0;
    virtual bool purge(const OdDbDatabase* pDatabase,
        OdDbObjectIdArray& objectIds) const = 0;
    virtual bool countHardReferences(const OdDbDatabase* pDatabase,
        const OdDbObjectIdArray& objectIds,
        OdUInt32* counts) const = 0;
 
    virtual void fire_layoutToBeActivated(OdDbLayoutManagerReactor* pReactor, const OdString& s, const OdDbObjectId& id) const = 0;
    virtual void fire_layoutToBeDeactivated(OdDbLayoutManagerReactor* pReactor, const OdString& s, const OdDbObjectId& id) const = 0;
 
    virtual OdResult setPlotViewId(OdDbPlotSettingsValidator* pValidator, OdDbPlotSettings* pPlotSet, const OdDbObjectId& id) const = 0;
    virtual OdResult setPlotPaperSize(OdDbPlotSettingsValidator* pValidator, OdDbPlotSettings* pPlotSet, double paperWidth, double paperHeight) const = 0;
    virtual OdResult setMargins(OdDbPlotSettingsValidator* pValidator, OdDbPlotSettings* pPlotSet, double leftMargin, double topMargin, double rightMargin, double bottomMargin) const = 0;
    //29524: need this functions to keep not existing plot style in plot settings
    virtual OdResult setStyleSheet(OdDbPlotSettingsValidator* pValidator, OdDbPlotSettings* pPlotSet, const OdString& styleSheetName) const = 0;
 
    virtual void OnObjectAboutToDestroy( OdDbDatabase* pDatabase, const OdDbObject* pObject ) = 0;
    virtual void OnObjectModified( OdDbDatabase* pDatabase, const OdDbObject* pObject ) = 0;
    virtual void OnObjectAppended( OdDbDatabase* pDatabase, const OdDbObject* pObject ) = 0;
    virtual void OnObjectUnappended( OdDbDatabase* pDatabase, const OdDbObject* pObject ) = 0;
    virtual void OnObjectReappended( OdDbDatabase* pDatabase, const OdDbObject* pObject ) = 0;
    virtual void OnObjectErased( OdDbDatabase* pDatabase, const OdDbObject* pObject ) = 0;
 
    virtual void FlushGraphics( OdDbDatabase* pDatabase, const OdDbObject* pObject );
 
    virtual bool intersectWith( const OdDbSpline* pThis, const OdGeCurve3d* intersectingCurve, int& intn, OdGePoint3dArray& IntPtArr, const OdGeTol& tol ) const = 0;
 
    virtual OdResult getGeomExtents(const OdDbLine* pLine,OdGeExtents3d& extents) = 0;
    virtual OdResult getGeomExtents(const OdDbXline* pXline,OdGeExtents3d& extents,bool referenceGeometryExtents) = 0;
    virtual OdResult getGeomExtents(const OdDbRay* pRay,OdGeExtents3d& extents,bool referenceGeometryExtents) = 0;
    virtual OdResult getGeomExtents(const OdDbArc* pArc,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache) = 0;
    virtual OdResult getGeomExtents(const OdDbCircle* pCircle,OdGeExtents3d& extents,bool canQueryCache) = 0;
    virtual OdResult getGeomExtents(const OdDbEllipse* pEllipse,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache) = 0;
    virtual OdResult getGeomExtents(const OdDbPolyline* pPline,OdGeExtents3d& extents,bool canQueryCache) = 0;
    virtual OdResult getGeomExtents(const OdDb2dPolyline* pPline,OdGeExtents3d& extents,bool canQueryCache) = 0;
    virtual OdResult getGeomExtents(const OdDb3dPolyline* pPline,OdGeExtents3d& extents,bool canQueryCache) = 0;
    virtual OdResult getGeomExtents(const OdDbSpline* pSpline,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache) = 0;
 
    virtual OdResult getGeomExtents(const OdDbBlockReference* pBlockRef,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache) = 0;
 
    virtual OdResult getGeomExtents(const OdDbEntity* pEntity,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache) = 0;
 
    virtual OdResult GetSimplifiedExtents(const OdDbEntity* pEnt,OdGeExtents3d& extents) = 0;
 
    virtual bool XrefHasCircularReference( OdDbDatabase* pHostDb, OdDbBlockTableRecord* pBTR ) = 0;
    virtual bool BlockHasSelfReferences( OdDbObjectId idBlock, const OdString& sBlockName ) = 0;
 
    virtual bool& SuppressWriteFileEvents() = 0;
    virtual OdString& ActualWriteFileName() = 0;
 
    virtual void SetIsInsideXrefReload( bool bInsideReload ) = 0;
    virtual bool IsInsideXrefReload() = 0;
 
    virtual void OnOle2FrameCreate() = 0;
    virtual void InitOle2FrameCount() = 0;
    virtual int Ole2FrameCount() = 0;
 
    virtual OdString GetPDFFontsPath() = 0;
    virtual bool IsPDFUnderlayEnabled() = 0;
 
    virtual OdGiRasterImagePtr GetThumbnailImage( OdDbDatabase* pDb, int width, int height ) = 0;
    virtual OdGiRasterImagePtr GetThumbnailImage2( OdDbDatabase* pDb, int width, int height ) = 0;
 
    virtual void OnUndoGroupBegin( OdDbDatabase* pDb ) = 0;
    virtual void OnUndoGroupEnd( OdDbDatabase* pDb ) = 0;
 
    virtual OdGsViewPtr GetGsView( OdDbDatabase* pDb, bool isModelSpace ) = 0;
 
  //FELIX_CHANGE_BEGIN #03097
    virtual int AddIdToLastUsedDimStyleIdArray(OdDbDimStyleTable* pTable, OdDbObjectId &id);
    virtual int GetLastUsedDimStyleIdArray(OdDbDimStyleTable* pTable, OdHardPtrIdArray &out);
  //FELIX_CHANGE_END #03097
 
    virtual void HighlightEntity( const OdDbObject* pObject, bool bDoIt, const OdDbFullSubentPath* pPath ) = 0;
 
    virtual  const OdUInt8Array& GetRecordData( OdDbUndoController* pController , OdUInt32 i  ) const = 0;
 
    virtual  OdUInt32 GetRecordCount( OdDbUndoController* pController  ) const = 0;
 
    virtual void SetBoundaryInverted( OdUInt32 numoints, const OdGePoint2d* pPoints ) = 0;
    virtual const OdGePoint2dArray& GetBoundaryInverted() const = 0;
public:
    virtual double fxGetAttMTextWidth( const OdDbAttributeDefinition* pDef );
    virtual void fxSetAttMTextWidth( OdDbAttributeDefinition* pDef, double width );
    virtual int AuditMTextContents( OdString& sMTextContents );
 
    virtual void fxSetIgnoreTableMergeLines( OdDbTable* pTable, bool bIgnore );
 
 
    virtual void SetTransformOnlyCurrentAnnotativeContextData( bool bEnable);
    virtual bool IsTransformOnlyCurrentAnnotativeContextData( ) const;
    virtual int  GetSupportedAnnotationScales(OdDbObject* pObject, OdArray<OdString>& scales );
 
    void SetCachePointer( const OdDbObject* pObject, void* pCache );
    void* GetCachePointer( const OdDbObject* pObject );
 
    void SetDrawOrder( const OdDbObject* pObject, int iDrawOrder );
    int GetDrawOrder( const OdDbObject* pObject );
 
    void SetDrawModes( const OdDbObject* pObject, OdUInt32 iDrawModes );
    OdUInt32 GetDrawModes( const OdDbObject* pObject );
    
    // no need to support AcRx anymore
    //void OdDbStub_setAcRxPtr( void *pOdDbStub, void *pArxPtr );
    //void* OdDbStub_getArxPtr( void* pOdDbStub );
 
    typedef bool(* FxAssertReadEnabledCallback)( const OdDbObject* pObject );
 
    void SetFxAssertReadEnabledCallback( FxAssertReadEnabledCallback pCallback );
    FxAssertReadEnabledCallback GetFxAssertReadEnabledCallback();
 
    OdDbObjectId fxGetDimstyleChildId( const OdRxClass* pDimClass, const OdDbObjectId& style );
    OdResult fxGetDimstyleChildData( const OdRxClass* pDimClass, OdDbDimStyleTableRecordPtr& pRec, const OdDbObjectId& style );
    OdDbObjectId fxGetDimstyleParentId( const OdDbObjectId& childStyle );
 
    void applyColor( OdDbEntityPtr pThis, OdDbEntityPtr pOther );
 
    void AddAnonymousGroup( OdDbDictionary* pDestDict, OdDbGroup* pGroup, const OdString& sName );
    OdString GetNextAnonymousRecordName( OdDbDictionary* pDict );
 
    // Modifies 1011 group of object xdata whithout notification. Called from STRETCH and GRIP_EDIT commands
    void MoveXDataHidden( OdDbObject* pObj, const OdGePoint3dArray& arrStretchWindow, const OdGeMatrix3d& mToPlane, const OdGeVector3d& offset );
    void MoveXDataHidden( OdDbObject* pObj, const OdGePoint3d& ptGripPoint, const OdGeVector3d& offset );
 
    // Transfrom entity without calling xDataTransformBy.
    OdResult TranslateEntity( OdDbEntity* pObj, const OdGeVector3d& offset );
 
    void LockXDataTransformation();
    void UnlockXDataTransformation();
    bool IsXDataTransformationLocked();
 
    typedef void(* FxBlockWorldDrawCallback)( const OdDbBlockTableRecord* pObject, OdGiWorldDraw* pWd );
    void SetFxBlockWorldDrawCallback( FxBlockWorldDrawCallback pCallback );
    FxBlockWorldDrawCallback GetFxBlockWorldDrawCallback();
 
    bool IsUndoingBlock( const OdDbDatabase* pDb );
 
    OdDbHatchPtr CreateHatchFromBlkRef( OdDbBlockReferencePtr pObj );
 
    double fxZeroDimscale( OdDbDatabase* pDb );
 
    static OdDbBlockTableRecordPtr fxGetDimBlock(OdDbDimension* pDim, bool bCreateIfNotFound = false, OdDbDimensionObjectContextData* ctx = 0);
 
    // Displays the special icon for constrained dimension
    virtual void DrawDimensionalConstraintIcon( OdGiViewportDraw* pVd,
                                                const OdDbBlockTableRecord* pBTR,
                                                const OdDbDimension* pDimension,
                                                bool bIsDynamic ) = 0;
 
    // Returns true if dimensional constraint is annotational
    virtual bool IsConstrainedDimension( const OdDbDimension* pDimension ) = 0;
 
    // Dynamic DC viewportDraw override
    virtual bool DrawDynamicConstraint( OdGiViewportDraw* pVd, const OdDbDimension* pOrigDim ) = 0;
 
    // Audit for constraints
    virtual void ConstraintAuditDatabase( OdDbDatabase* pDb, OdDbAuditInfo* pInfo ) = 0;
 
    // Audit for incorrect DIMAPOST value ("<>" instead of "[]")
    virtual OdResult AuditDualDimPlaceholder( OdDbDatabase* pDb, OdDbAuditInfo* pInfo );
 
    // Returns true if the constraint module is loaded
    virtual bool IsConstraintsEnabled() = 0;
 
    // Returns the property value from the block constraint parameter
    virtual OdResBufPtr GetConstraintBlockParameter( const OdString& sVarName, const OdString& sPropertyName, const OdGeMatrix3d& m = OdGeMatrix3d::kIdentity ) = 0;
 
    // Sets the new property value to the block constraint parameter
    virtual bool SetConstraintBlockParameter( const OdString& sVarName, const OdString& sPropertyName, const OdResBuf* rb, const OdGeMatrix3d& m = OdGeMatrix3d::kIdentity ) = 0;
 
    // Evaluate the constraint block parameter by the grip editing
    virtual bool EvaluateConstraintBlockParameterFromGripPoint( const OdString& sVarName, OdDbBlockGrip* pGrip ) = 0;
 
    virtual bool IsDynamicDimensionVisibleOnLoading( const OdDbDimension* pDimension ) = 0;
 
    virtual void EnableDrawAttDefs( bool bEnable ) = 0;
    virtual bool IsDrawAttDefsEnabled() const = 0;
 
    virtual void EnableDrawImageFrame( bool bEnable );
    virtual bool IsDrawImageFrameEnabled() const;
 
    virtual OdDbFcfPtr fxGetToleranceFromMLeader( OdDbMLeader* ); 
    virtual void fxSetToleranceToMLeader( OdDbMLeader*, const OdDbFcf*, int );
    virtual void fxRecomputeMLeader( OdDbMLeader* );
 
    virtual bool GetUndoList( OdDbDatabase* pDb, OdStringArray& commands, bool bRedo = false );
 
    bool& GetHatchSolidFill( OdDbHatchPtr pHatch );
    bool& GetHatchGradientFill( OdDbHatchPtr pHatch );
 
    enum PatternQuality
    {
        kSolid = 0x0,
        kNotRecognizableY,
        kNotRecognizableX,
        kFullyRecognizable
    };
 
    virtual PatternQuality CheckPattern( OdHatchPattern* pPattern, double pixelSize ) = 0;
 
    void EnableHatchOptimization( bool bEnable = true );
 
    bool IsHatchOptimizationEnabled() const;
 
    void EnablePermanentUndo( bool bEnable );
 
    bool IsPermanentUndoEnabled() const;
 
    OdDbUndoController* GetFxUndoController( OdDbDatabase* pDatabase );
 
    OdDbUndoController* GetFxRedoController( OdDbDatabase* pDatabase );
 
    void SetFxUndoReactor( OdDbDatabase* pDatabase, CFxDbUndoReactor* pReactor );
 
    unsigned int GetBlockChildCount( OdDbBlockTableRecord* pRecord );
 
    unsigned int GetBlockNumRefs( OdDbBlockTableRecord* pRecord );
 
    virtual void GetPaperProperties( OdDbPlotSettings* pLayout, OdGePoint3dArray& points, OdGePoint3dArray& margins ) = 0;
 
    virtual void AddModificationFilter( CFxDbModificationFilter* pFilter ) = 0;
    virtual void RemoveModificationFilter( CFxDbModificationFilter* pFilter ) = 0;
    virtual OdDbObjectIdArray ApplyModificationFilters( const OdDbObjectIdArray& objectIds ) = 0;
    
#ifdef FX_TOUCH_VERSION
    void ResetImageDefFoundFlag( OdDbRasterImageDef* pDef );
    virtual void ResolveCloudReferenceInBackground( OdDbObjectId idUnresolved, const OdString& strMasterPath, const OdString& sreReferencePath ) = 0;
#endif
 
#ifdef XENON
    // XENON-440
    virtual void AssertThreadIsCorrect(OdDbObjectId, OdDb::OpenMode) const;
 
    // XENON-13388 etc.
    void DrawMTextBackground( OdDbMText*, OdGiWorldDraw* pWd ) const;
 
    // XENON-13248
    void GetOdDbLeaderPoints( OdDbLeader* pLeader, OdGiCommonDraw* pWd, OdGePoint3dArray& pts ) const;
 
    // A callback for overriding dimension measurements for broken-view dimensions.
    virtual bool GetDimensionMeasurementOverride( const OdDbDimension* pDim, double& dMeasurement, const double dDimLFAC ) const;
 
    // XENON-18942: a callback for handling singular cases of 2-line angular dimension. Returns false by default.
    virtual bool IsSingular2LineAngularDim( const OdGePoint3d& line1Start, const OdGePoint3d& line1End,
        const OdGePoint3d& line2Start, const OdGePoint3d& line2End,
        const OdGeVector3d& vNormal, OdGePoint3d* pptSingularCenter = 0 ) const;
 
    // Copy fields in extension dictionary. Supports non-DBRO objects and may be used in trackers/previews.
    virtual void CopyFields( OdDbObject* pSrc, OdDbObject* pDst ) const;
 
    //XENON-6368: suppress aligned dimension leader in some cases
    virtual bool IsAlignedDimensionTextLeaderEnabled() const;
    
    //FELIX_CHANGE_BEGIN
    //Get holes indexes from total number of hatch loops
    bool getHoleLoopsIndexes(OdDbHatchPtr pHatch, OdGeIntArray& holes) const;
    //FELIX_CHANGE_END
#endif
 
    // Check if any highlight draw decoration is required
    // TODO: support highlight method by GS
    virtual bool IsHighlighted( OdGiCommonDraw* pWd ) const = 0;
 
    virtual bool OnCOMObjectUpdate( const OdDbObject* pDbObj ) = 0;
    virtual bool AutoloadApp( const OdString appName) = 0;
 
    virtual bool DrawSolidHatch( OdDbHatchImpl* pImpl, OdGiContextForDbDatabase* pGiContext, OdGiGeometry& geom );
    enum
    {
        eDSHNone = 0x0,
        eDSHDrawAsPolygons = 0x1,
    };
    virtual int DrawSolidHatchFlags();
 
    virtual void GetHatchPatternSize( const OdDbHatch* pHatch, double& dPatternSize, double& dMaxDashLength, bool& bCanUseSolidOptimization );
 
    static void StaticExecuteInMainThread( std::function< void() > f );
    virtual void ExecuteInMainThread( std::function< void() > f );
 
    virtual bool IsMechanical() const;
 
public:
    // Missing methods for MPolygon
    virtual double GetMPolygonPerimeter( const OdDbMPolygon* pMPolygon );
    virtual int GetMPolygonClosestLoopTo( const OdDbMPolygon* pMPolygon, const OdGePoint3d& worldPt );
    virtual OdResult GetMPolygonArea(const OdDbMPolygon* pMPolygon, double & area);
 
//SystemVariable collection
public:
    virtual bool GetSystemVariableRange( OdResBufPtr &Min, OdResBufPtr &Max, const OdString& Name );
    virtual int GetSysVarStorageType( const OdString& Name );
    virtual void OnSetPlotDevice( const OdString& sPlotDeviceName );
 
protected:
    CFxDbExtension();
 
private:
    bool m_bXDataTransformationLocked;
    bool m_bTransformCurrentContextDataOnly;
    bool m_bDrawImageFrameEnabled;
    bool m_bHatchOptimizationEnabled = false;
};
 
class OdHandleTree;
TOOLKIT_EXPORT OdHandleTree* oddbGetHandleTree(OdDbDatabase* pDb);
 
TOOLKIT_EXPORT bool fxIsPerformingDbUndo(const OdDbDatabase* pDb);
 
// XENON Garbage collection.
TOOLKIT_EXPORT int fxDatabasePurgeEx( OdDbDatabase* pDb, int( *pCallback )( OdDbDatabase*, void* ), void* pCookie = 0 );
 
TOOLKIT_EXPORT CFxDbExtension* GetFxDbExtension();
TOOLKIT_EXPORT void SetFxDbExtension( CFxDbExtension* pExtension );
 
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbLine* pLine,OdGeExtents3d& extents);
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbXline* pXline,OdGeExtents3d& extents,bool referenceGeometryExtents);
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbRay* pRay,OdGeExtents3d& extents,bool referenceGeometryExtents);
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbArc* pArc,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache);
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbCircle* pCircle,OdGeExtents3d& extents,bool canQueryCache);
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbEllipse* pEllipse,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache);
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbPolyline* pPline,OdGeExtents3d& extents,bool canQueryCache);
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDb2dPolyline* pPline,OdGeExtents3d& extents,bool canQueryCache);
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDb3dPolyline* pPline,OdGeExtents3d& extents,bool canQueryCache);
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbSpline* pSpline,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache);
 
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbBlockReference* pBlockRef,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache);
 
bool TOOLKIT_EXPORT geGetObjectExtents(const OdDbEntity* pEntity,OdGeExtents3d& extents,bool referenceGeometryExtents,bool canQueryCache);
 
bool TOOLKIT_EXPORT geCompareArcs(const OdDbArc* pDbArc1,const OdGeCircArc3d& geArc2,OdGeX::ArcComparisonType type,const OdGeTol& geTol);
bool TOOLKIT_EXPORT geCompareArcs(const OdDbEllipse* pDbArc1,const OdGeEllipArc3d& geArc2,OdGeX::ArcComparisonType type,const OdGeTol& geTol);
 
bool TOOLKIT_EXPORT geConvertToGeObject(const OdDbArc* pDbArc,OdGeCircArc3d& geArc,bool canQueryDbExtents = true);
bool TOOLKIT_EXPORT geConvertToGeObject(const OdDbCircle* pDbCircle,OdGeCircArc3d& geCircle);
bool TOOLKIT_EXPORT geConvertToGeObject(const OdDbEllipse* ellipse,OdGeEllipArc3d& geEllipse,bool canQueryDbExtents = true);
 
// returns tolerance adjusted for FPU comparison of values like dSampleValue
// returns original dTol value for small enough dSampleValue.
double TOOLKIT_EXPORT geGetReasonableTolerance(double dSampleValue, double dTol = 1e-10 );
 
class TOOLKIT_EXPORT OdDbFlipDimensionPE : public OdRxObject
{
public:
    ODRX_DECLARE_MEMBERS(OdDbFlipDimensionPE);
// Issues 27388, 27702, 27428
// These function retrieve the flip points by invoking
// OdDimRecomputor::buildDimension
   virtual void getFlipPoints(
        OdDbDimension* pDimension,
        OdGePoint3dArray &flip_points);
protected:
    virtual void getFlipPoints(
        OdDbDimension* pDimension,
        OdDbDimensionObjectContextData* ctx,
        OdGePoint3dArray &flip_points) = 0;
};
typedef OdSmartPtr<OdDbFlipDimensionPE> OdDbFlipDimensionPEPtr;
 
class OdDbFlipDimensionPELoader : public OdDbFlipDimensionPE
{
public:
    ODRX_DECLARE_MEMBERS(OdDbFlipDimensionPELoader);
    virtual void getFlipPoints(
        OdDbDimension* pDimension,
        OdGePoint3dArray &flip_points);
protected:
    virtual void getFlipPoints(
        OdDbDimension* pDimension,
        OdDbDimensionObjectContextData* ctx,
        OdGePoint3dArray &flip_points);
private:
    OdDbFlipDimensionPEPtr getRecomputer(OdDbDimension* pDim);
};
 
//---------------------------------------------------------------------------------------------------------------------
 
class TOOLKIT_EXPORT CFxSilhouetteVisiblityCallback
{
public:
    virtual ~CFxSilhouetteVisiblityCallback();
 
    virtual bool NeedDraw( bool bVisible, bool bOnEdge, bool bOnSilg ) = 0;
 
};
 
class TOOLKIT_EXPORT CFxModelerExtension
{
public:
    virtual ~CFxModelerExtension() = 0;
 
    //FELIX_CHANGE_BEGIN
    virtual OdResult generateEDGES( const OdRxObjectPtrArray& curveSegments, ENTITY_LIST &edges, OdRxObjectPtr pPar = 0 ) = 0;
 
    virtual OdResult generateEDGES( const OdRxObjectPtr& pIt, EDGE *&edge, bool negative = false ) = 0;
 
    virtual OdResult generateWire( const OdDbEntity* pPathCurve, BODY *&pBody ) = 0;
 
    virtual bool getBodyTransform( const BODY *body, OdGeMatrix3d &mx ) = 0;
 
    virtual OdResult generateCurve( EDGE *pEdge, OdGeCurve3d *&o_pCurve ) = 0;
 
    virtual void StartModellerInThread() = 0;
 
    // Cast result pointer to proper class before using. Pointer can also be null depending on the implementation.
    virtual void *getSpaBodyEntity( OdDbEntityPtr pEnt ) = 0;
 
    virtual void *getBodyFromEntity( OdDbEntityPtr i_pEnt ) = 0;
 
    virtual OdResult  getWiresFromRegion( OdDbRegionPtr pR, std::vector<BODY *> &OuterWires, std::vector<std::vector<BODY *>> &IslandsToEntity ) = 0;
 
    virtual void setBodyFor( ENTITY_LIST* pNewFile, AfTypeVer typeVer, OdDbRegionPtr &offsetregion ) = 0;
 
    virtual BODY *getBodyFrom( const OdDbRegion *pRegion ) = 0;
    virtual BODY *getBodyFrom( const OdDbSurface *pSurface ) = 0;
    virtual BODY *getBodyFrom( const OdDb3dSolid *pSolid ) = 0;
 
    virtual OdResult rayTest2( OdDbEntityPtr           i_pObj,
                               const OdGePoint3d&      rayBasePoint,
                               const OdGeVector3d&     rayDir,
                               double                  rayRadius,
                               OdArray<OdDbSubentId> & subEntIds,
                               OdGeDoubleArray&        parameters ) = 0;
 
    //FELIX_CHANGE_END
 
    virtual void applyColor( OdDbEntityPtr pThis, OdDbEntityPtr pOther );
 
    virtual OdResult flatShot( const OdDb3dSolidPtr pBody,
        const OdGePoint3d& eye_pos, const OdGePoint3d& target_pos, bool bPersepcitveProjection, OdDbEntityPtrArray& result );
 
    virtual OdResult flatShot( const OdDbSurfacePtr pSurface,
        const OdGePoint3d& eye_pos, const OdGePoint3d& target_pos, bool bPersepcitveProjection, OdDbEntityPtrArray& result );
 
    struct HLData
    {
        OdDbObjectPtr _entity;
        int _flags;
        struct HLOriginal
        {
            OdDbObjectPtr _p;
            OdDbSubentId _subId;
        };
        OdArray<HLOriginal> _original;
    };
 
    virtual OdResult flatShotHL( const OdDbEntityPtrArray& input,
        const OdGePoint3d& eye_pos, const OdGePoint3d& target_pos, bool bPersepcitveProjection, OdArray<HLData>& output );
 
    virtual int initialize_acis();
 
    virtual int terminate_acis(int level);
 
    // finds Center of i_region
    virtual bool getCentroid( OdDbRegionPtr i_region, OdGePoint2d &o_center );
 
    // separates i_region to a set of connected components (lumbs)
    virtual bool separateRegion( OdDbRegionPtr i_region, OdRxObjectPtrArray &o_entitySet );
    // get all faces or all edges for OdDb3dSolid
    virtual OdResult getSubentities( OdDb3dSolidPtr i_pSolid,
                                     OdDb::SubentType i_type,
                                     OdDbFullSubentPathArray& o_subentPaths );
 
    virtual OdResult drawShells( OdGiViewportDraw* pViewportDraw, OdDbEntityPtr pEntity );
    virtual OdResult drawEdges( OdGiViewportDraw* pViewportDraw, OdDbEntityPtr pEntity );
 
    virtual OdResult drawSilhouettes( OdGiViewportDraw* pViewportDraw, OdDbEntityPtr pEntity, CFxSilhouetteVisiblityCallback* pCallback = 0 );
 
protected:
    virtual void applyColor( OdModelerGeometry* p, OdCmColor color ) = 0;
 
    OdModelerGeometryPtr GetModeler(const OdDb3dSolidPtr pBody);
 
    OdModelerGeometryPtr GetModeler(const OdDbSurfacePtr pSurface);
 
    OdModelerGeometryPtr GetModeler( const OdDbRegionPtr pRegion );
 
    CFxModelerExtension();
};
 
TOOLKIT_EXPORT CFxModelerExtension* GetFxModelerExtension();
TOOLKIT_EXPORT void SetFxModelerExtension( CFxModelerExtension* pExtension );
 
class TOOLKIT_EXPORT CFxObjectPE : public OdRxObject
{
public:
    ODRX_DECLARE_MEMBERS(CFxObjectPE);
 
    virtual void setDatabaseDefaults( OdDbEntity* pThis, OdDbDatabase *pDb,bool bSubEnt) = 0;    
};
typedef OdSmartPtr<CFxObjectPE> CFxObjectPEPtr;
 
#endif
//FELIX_CHANGE_END