///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, 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 Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2016 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 _ODDB_BASEDATABASE_INCLUDED_
|
#define _ODDB_BASEDATABASE_INCLUDED_
|
|
#include "RxObject.h"
|
#include "DbRootExport.h"
|
#include "OdFont.h"
|
#include "GiDefaultContext.h"
|
#include "Gs/Gs.h"
|
#include "Gi/GiLinetype.h"
|
#include "Ge/GeCurve2d.h"
|
#include "Ge/GeDoubleArray.h"
|
#include "Ge/GePoint2dArray.h"
|
#include "DbDate.h" // dgn dwf export
|
#include "OdUnitsFormatter.h"
|
#include "StringArray.h"
|
#include "DbHandle.h"
|
|
class OdDbBaseHostAppServices;
|
class OdGiAnnoScaleSet;
|
|
typedef OdRxObject OdDbBaseDatabase;
|
typedef OdRxObjectPtr OdDbBaseDatabasePtr;
|
|
/** \details
|
This class is the base Protocol Extension class for database classes.
|
|
\sa
|
TD_DbRoot
|
<group OdDbRoot_Classes>
|
*/
|
class DBROOT_EXPORT OdDbBaseDatabasePE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdDbBaseDatabasePE);
|
|
enum ExtentsFlags
|
{
|
kZeroFlags = 0,
|
kExactExtents = 1, //Zoom to extents exact to device/paper size w/o any margins if this flag is set
|
kUseViewExtents = 2 //Use view extents instead of plot extents (default) for calculation of drawing extents if this flag is set
|
};
|
|
/** \details
|
Returns the OdDbBaseHostAppServices object associated with this database object.
|
*/
|
virtual OdDbBaseHostAppServices* appServices(OdDbBaseDatabase* pDb) const = 0;
|
|
/** \details
|
Returns the name of the file associated with this database object.
|
*/
|
virtual OdString getFilename(OdDbBaseDatabase* pDb) const = 0;
|
|
virtual void startTransaction(OdDbBaseDatabase* pDb) = 0;
|
virtual void abortTransaction(OdDbBaseDatabase* pDb) = 0;
|
|
virtual OdGiDefaultContextPtr createGiContext(OdDbBaseDatabase* pDb) const = 0;
|
|
virtual void putNamedViewInfo(OdDbBaseDatabase* pDb, OdDbStub* layoutId, OdStringArray& names, OdGePoint3dArray& points) = 0;
|
/** \details
|
Creates a TextIterator object for the specified data.
|
|
\param textString [in] Text string to be parsed.
|
\param length [in] Length of string in bytes.
|
\param raw [in] If and only if true, character sequences in the form of %%c will be treated as raw text.
|
\param codePageId [in] Object ID of the Code Page of the text.
|
\param pTextStyle [in] Pointer to the TextStyle object associated with the specified text.
|
|
\remarks
|
Returns a SmartPointer to the new OdDbTextIterator object.
|
*/
|
virtual OdBaseTextIteratorPtr createTextIterator(OdDbBaseDatabase* db, const OdChar* textString, int length, bool raw, const OdGiTextStyle* pTextStyle) const = 0;
|
|
// setup Gs views in the device, according to the active database layout data
|
virtual OdGsDevicePtr setupActiveLayoutViews(OdGsDevice* pDevice, OdGiDefaultContext* pGiCtx) = 0;
|
|
// setup Gs views in the device, according to the specified database layout data
|
virtual OdGsDevicePtr setupLayoutView(OdGsDevice* pDevice, OdGiDefaultContext* pGiCtx, OdDbStub* layoutId) = 0;
|
|
// setup palette associated with the specified layout in the device.
|
// palBg -- optionally specifies background color to write into palette
|
// to overwrite default DB-palette color use non-zero value for alpha component of RGBA color
|
virtual void setupPalette(OdGsDevice* device, OdGiDefaultContext* giContext, OdDbStub* layoutId = 0, ODCOLORREF palBg = ODRGBA(0,0,0,0)) = 0;
|
|
// get next view according to the active layout
|
virtual OdDbStub* getNextViewForActiveLayout(OdGiDefaultContext* pGiCtx, OdDbStub* /*objectId*/) = 0;
|
|
// setup Gs device to display current layout using plot settings stored in it (paper rotation, scale etc.)
|
// returns visible rectangle (measured in device units)
|
virtual void applyLayoutSettings(OdGsDCRect& clipBox, OdGsDevice* pDevice, OdDbBaseDatabase* db, OdUInt32 extentsFlags = kZeroFlags) = 0;
|
|
// setup Gs device to draw current layout zoomed to extents
|
// warning: this function may throw exception, if overall viewport is not found
|
// outputRect is desired printable area (in device units)
|
virtual void zoomToExtents(const OdGsDCRect& outputRect, OdGsDevice* pDevice, OdDbBaseDatabase* db,
|
OdUInt32 extentsFlags = kZeroFlags, OdDbStub* objectId = NULL) = 0;
|
|
virtual void loadPlotstyleTableForActiveLayout(OdGiDefaultContext* pDwgContext, OdDbBaseDatabase* db) = 0;
|
|
virtual OdRxIteratorPtr layers(OdDbBaseDatabase* db) const = 0;
|
virtual OdRxIteratorPtr visualStyles(OdDbBaseDatabase* db) const = 0;
|
|
// Layout here is an abstraction that corresponds to "sheet" in sheet set manager,
|
// "page" in PDF and DWF, "layout"+"block table record" in DWG
|
inline OdRxObjectPtr currentLayout(OdDbBaseDatabase* pDb)
|
{
|
return openObject(currentLayoutId(pDb));
|
}
|
|
virtual void setCurrentLayout(OdDbBaseDatabase* db, const OdString& name) = 0;
|
|
virtual OdRxIteratorPtr layouts(OdDbBaseDatabase* db) const = 0;
|
|
// TODO do it inline (is special for DGN now)
|
virtual OdRxObjectPtr getLayout(OdDbBaseDatabase* pDb, const OdString& name)
|
{
|
return openObject(findLayoutNamed(pDb, name));
|
}
|
|
inline OdRxObjectPtr findLayoutByViewport(OdDbBaseDatabase* db, OdDbStub* pViewportId)
|
{
|
return openObject(findLayoutIdByViewport(db, pViewportId));
|
}
|
virtual OdDbStub* findLayoutIdByViewport(OdDbBaseDatabase* db, OdDbStub* pViewportId) = 0;
|
|
virtual OdDbStub* findLayoutNamed(OdDbBaseDatabase* db, const OdString& name) = 0; // dgn dwf export
|
|
inline OdRxObjectPtr getFirstLayout(OdDbBaseDatabase* db)
|
{
|
return openObject(getFirstLayoutId(db));
|
}
|
virtual OdDbStub* getFirstLayoutId(OdDbBaseDatabase* db) = 0; // dgn dwf export
|
|
virtual OdTimeStamp getCreationTime(OdDbBaseDatabase* db) = 0; // dgn dwf export
|
virtual OdTimeStamp getUpdateTime(OdDbBaseDatabase* db) = 0; // dgn dwf export
|
virtual OdString getFingerPrintGuid(OdDbBaseDatabase* db) = 0; // dgn dwf export
|
virtual OdString getVersionGuid(OdDbBaseDatabase* db) = 0; // dgn dwf export
|
|
virtual int getUnits(OdDbBaseDatabase* db) = 0; // dgn dwf export
|
virtual OdUnitsFormatter* baseFormatter(OdDbBaseDatabase* db) = 0; // dgn dwg common formatter base class
|
virtual int getMeasurement(OdDbBaseDatabase* db) = 0;
|
|
virtual bool getLineTypeById( OdDbBaseDatabase* db, OdDbStub* pLTypeId, OdGiLinetype& LType ) = 0;
|
virtual bool getTextStyleById( OdDbBaseDatabase* db, OdDbStub* idStyle, OdGiTextStyle& shapeInfo ) = 0;
|
|
virtual OdDbStub* getObject(OdDbBaseDatabase* db, OdUInt64 handle) = 0;
|
virtual OdDbHandle getHandle(OdDbStub* id);
|
virtual OdDbBaseDatabase* getDatabase(OdDbStub *id);
|
virtual OdDbStub* getOwner(OdDbStub *id);
|
|
virtual OdCodePageId getCodePage(OdDbBaseDatabase* db) = 0;
|
|
virtual OdDbStub* getModelBlockId(OdDbBaseDatabase* pDb) = 0;
|
virtual OdDbStub* getPaperBlockId(OdDbBaseDatabase* pDb) = 0;
|
virtual OdDbStub* currentLayoutId(OdDbBaseDatabase* pDb) = 0;
|
virtual OdDbStub* xrefBlockId(OdDbBaseDatabase* pDb) = 0;
|
|
virtual void setMultiThreadedRender(OdDbBaseDatabase* pDb, bool bOn) = 0;
|
|
virtual bool isAProxy(OdRxObject* pDrw) = 0;
|
virtual OdRxObjectPtr openObject(OdDbStub* pId) = 0;
|
virtual bool getAnnoScaleSet(OdDbStub* drawableId, OdGiAnnoScaleSet& res) = 0;
|
virtual OdDbStub *getCurrentLongTransation(const OdDbBaseDatabase *pDb) = 0;
|
|
class DatabaseUnloadReactor
|
{
|
public:
|
virtual ~DatabaseUnloadReactor() { }
|
virtual void goodbye(const OdDbBaseDatabase* pDb) = 0;
|
};
|
virtual OdRxObjectPtr addDatabaseUnloadReactor(OdDbBaseDatabase* pDb, OdRxObject *pPrevReactor, DatabaseUnloadReactor *pReactorRedirect) = 0;
|
virtual void removeDatabaseUnloadReactor(OdDbBaseDatabase* pDb, OdRxObject *pReactor) = 0;
|
};
|
|
/** \details
|
This template class is a specialization of the OdSmartPtr class for OdDbBaseDatabasePE object pointers.
|
*/
|
typedef OdSmartPtr<OdDbBaseDatabasePE> OdDbBaseDatabasePEPtr;
|
|
|
/** \details
|
This class is the protocol extension to be used as a layer abstraction,
|
independent of the underlying database (OdDbDatabase or OdDgDatabase).
|
|
\sa
|
TD_DbRoot
|
|
<group OdDbRoot_Classes>
|
*/
|
class DBROOT_EXPORT OdDbBaseLayerPE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdDbBaseLayerPE);
|
|
/** \details
|
Returns name of this Layer object.
|
|
\param obj [in] Layer object
|
*/
|
virtual OdString name(const OdRxObject* obj) const = 0;
|
|
/** \details
|
Returns true if and only if this Layer is off.
|
|
\param obj [in] Layer object
|
*/
|
virtual bool isOff(const OdRxObject* obj) const = 0;
|
/** \details
|
Returns true if and only if this Layer is frozen.
|
|
\param obj [in] Layer object
|
*/
|
virtual bool isFrozen(const OdRxObject* obj) const = 0;
|
|
/** \details
|
Sets the on / off status of this Layer
|
|
\param obj [in] Layer object
|
\param off [in] True for off, false for on.
|
*/
|
virtual void setIsOff(OdRxObject* obj, bool off) const = 0;
|
/** \details
|
Sets the frozen status of this Layer.
|
|
\param obj [in] Layer object
|
\param frozen [in] True to freeze, false to thaw.
|
*/
|
virtual void setIsFrozen(OdRxObject* obj, bool frozen) const = 0;
|
|
/** \details
|
Return true if function set line type description of this Layer.
|
|
\param obj [in] Layer object
|
\param LType [out] Description of layer line type.
|
*/
|
virtual bool getLineType(OdRxObject* obj, OdGiLinetype& LType) const = 0;
|
};
|
|
typedef OdSmartPtr<OdDbBaseLayerPE> OdDbBaseLayerPEPtr;
|
|
|
/** \details
|
This class is the protocol extension to be used as a visual style abstraction,
|
independent of the underlying database (OdDbDatabase or OdDgDatabase).
|
|
\sa
|
TD_DbRoot
|
|
<group OdDbRoot_Classes>
|
*/
|
class DBROOT_EXPORT OdDbBaseVisualStylePE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdDbBaseVisualStylePE);
|
|
/** \details
|
Returns name of this Visual Style.
|
|
\param obj [in] Visual Style object
|
*/
|
virtual OdString name(const OdRxObject* obj) const = 0;
|
|
/** \details
|
Returns true if and only if this Visual Style was marked as internal.
|
|
\param obj [in] Visual Style object
|
*/
|
virtual bool isInternal(const OdRxObject* obj) const = 0;
|
};
|
|
typedef OdSmartPtr<OdDbBaseVisualStylePE> OdDbBaseVisualStylePEPtr;
|
|
|
/** \details
|
This class is the protocol extension to be used as a layout abstraction,
|
independent of the underlying database (OdDbDatabase or OdDgDatabase).
|
|
\sa
|
TD_DbRoot
|
|
<group OdDbRoot_Classes>
|
*/
|
class DBROOT_EXPORT OdDbBaseLayoutPE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdDbBaseLayoutPE);
|
enum PlotRotation
|
{
|
k0degrees = 0, // No rotation
|
k90degrees = 1, // 90° CCW
|
k180degrees = 2, // Inverted
|
k270degrees = 3 // 90° CW
|
};
|
virtual OdString name(const OdRxObject*) = 0;
|
virtual bool isModelLayout(const OdRxObject*) = 0;
|
virtual bool printLineweights(const OdRxObject*) = 0;
|
virtual bool showPlotStyles(const OdRxObject*) = 0;
|
virtual OdString paperName(const OdRxObject*) = 0;
|
virtual void getPaperSize(const OdRxObject*, double& paperWidth, double& paperHeight) const = 0;
|
virtual PlotRotation plotRotation(const OdRxObject*) = 0;
|
virtual double getTopMargin(const OdRxObject*) = 0;
|
virtual double getRightMargin(const OdRxObject*) = 0;
|
virtual double getBottomMargin(const OdRxObject*) = 0;
|
virtual double getLeftMargin(const OdRxObject*) = 0;
|
virtual OdDbStub* getId(const OdRxObject*) = 0;
|
virtual bool isOverallVPortErased(const OdRxObject*) = 0;
|
virtual OdResult getGeomExtents(const OdRxObject*,OdGeExtents3d& ext) = 0;
|
|
// methods inherited by OdDbLayoutImpl class // dgn dwf export
|
virtual bool useStandardScale(const OdRxObject*) = 0;
|
virtual void getStdScale(const OdRxObject*, double& scale) = 0;
|
virtual void getCustomPrintScale(const OdRxObject*, double& numerator, double& denominator) = 0;
|
virtual int plotType(const OdRxObject*) = 0;
|
virtual OdString getPlotViewName(const OdRxObject*) = 0;
|
virtual void getPlotWindowArea(const OdRxObject*, double& xmin, double& ymin, double& xmax, double& ymax) = 0;
|
virtual void getPlotOrigin(const OdRxObject*, double& x, double& y) = 0;
|
virtual void getPlotPaperSize(const OdRxObject*, double& paperWidth, double& paperHeight) = 0;
|
virtual int plotPaperUnits(const OdRxObject*) = 0;
|
|
// for Gs
|
virtual OdDbStub* getBlockId(const OdRxObject*) const = 0;
|
virtual bool scalePSLinetypes(const OdRxObject*) const = 0;
|
virtual bool getApproxExtents(const OdRxObject*, OdGePoint3d& extMin, OdGePoint3d& extMax) const = 0;
|
};
|
|
typedef OdSmartPtr<OdDbBaseLayoutPE> OdDbBaseLayoutPEPtr;
|
|
|
/** \details
|
This class is the protocol extension to be used as a block table record abstraction,
|
independent of the underlying database (OdDbDatabase or OdDgDatabase).
|
|
\sa
|
TD_DbRoot
|
|
<group OdDbRoot_Classes>
|
*/
|
class DBROOT_EXPORT OdDbBaseBlockPE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdDbBaseBlockPE);
|
|
virtual bool isBlockReferenceAdded(OdRxObject *pBlock) const = 0;
|
|
virtual bool isFromExternalReference(const OdRxObject *pBlock) const = 0;
|
virtual OdDbBaseDatabase *xrefDatabase(const OdRxObject *pBlock) const = 0;
|
|
virtual bool isLayout(const OdRxObject *pBlock) const = 0;
|
};
|
|
typedef OdSmartPtr<OdDbBaseBlockPE> OdDbBaseBlockPEPtr;
|
|
|
/** \details
|
This class is the protocol extension to be used as a block reference abstraction,
|
independent of the underlying database (OdDbDatabase or OdDgDatabase).
|
|
\sa
|
TD_DbRoot
|
|
<group OdDbRoot_Classes>
|
*/
|
class DBROOT_EXPORT OdDbBaseBlockRefPE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdDbBaseBlockRefPE);
|
|
virtual OdDbStub *blockId(const OdRxObject *pBlockRef) const = 0;
|
virtual OdGeMatrix3d blockTransform(const OdRxObject *pBlockRef) const = 0;
|
|
virtual OdRxIteratorPtr newAttribIterator(const OdRxObject *pBlockRef, bool bSkipErased = true) const = 0;
|
virtual bool isAttribute(const OdRxObject *pAttrib) const = 0;
|
virtual OdDbStub *getId(const OdRxObject *pObj) const = 0;
|
|
// is generic BlockRef (Gs willn't treat drawable as block reference if this method return false)
|
// this method can be useful to filter out incompatible entities inherited from BlockRef.
|
virtual bool isGeneric(const OdRxObject *pBlockRef) const = 0;
|
// is MInsert block
|
virtual bool isMInsert(const OdRxObject *pBlockRef) const = 0;
|
// is basic BlockRef
|
virtual bool isBasic(const OdRxObject *pBlockRef) const = 0;
|
};
|
|
typedef OdSmartPtr<OdDbBaseBlockRefPE> OdDbBaseBlockRefPEPtr;
|
|
|
/** \details
|
This class is the protocol extension to be used as a entities sorting object abstraction,
|
independent of the underlying database (OdDbDatabase or OdDgDatabase).
|
|
\sa
|
TD_DbRoot
|
|
<group OdDbRoot_Classes>
|
*/
|
class DBROOT_EXPORT OdDbBaseSortEntsPE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdDbBaseSortEntsPE);
|
|
virtual OdDbStub *blockId(const OdRxObject *pSortents) const = 0;
|
};
|
|
typedef OdSmartPtr<OdDbBaseSortEntsPE> OdDbBaseSortEntsPEPtr;
|
|
|
/** \details
|
This class is the protocol extension to be used as a long transaction abstraction,
|
independent of the underlying database (OdDbDatabase or OdDgDatabase).
|
|
\sa
|
TD_DbRoot
|
|
<group OdDbRoot_Classes>
|
*/
|
class DBROOT_EXPORT OdDbBaseLongTransactionPE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdDbBaseLongTransactionPE);
|
|
virtual OdDbStub *destinationBlock(const OdRxObject *pLT) const = 0;
|
|
virtual bool workSetHas(const OdRxObject *pLT, OdDbStub *pId) const = 0;
|
virtual OdRxIteratorPtr newWorkSetIterator(const OdRxObject *pLT, bool incRemoved = false, bool incSecondary = false) const = 0;
|
|
virtual OdDbStub *getOwner(OdDbStub *pId) const = 0;
|
virtual OdDbStub *getId(const OdRxObject *pObj) const = 0;
|
};
|
|
typedef OdSmartPtr<OdDbBaseLongTransactionPE> OdDbBaseLongTransactionPEPtr;
|
|
/** \details
|
This class defines the interface for the Hatch Protocol Extension classes.
|
<group OdDbRoot_Classes>
|
*/
|
class DBROOT_EXPORT OdDbBaseHatchPE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdDbBaseHatchPE);
|
enum HatchStyle
|
{
|
kNormal = 0, // Hatch toggles on each boundary.
|
kOuter = 1, // Hatch turns off after first inner loop.
|
kIgnore = 2 // Hatch ignores inner loop
|
};
|
|
enum HatchLoopType
|
{
|
kDefault = 0, // Not yet specified.
|
kExternal = 1, // Defined by external entities.
|
kPolyline = 2, // Defined by OdGe polyline.
|
kDerived = 4, // Derived from a picked point.
|
kTextbox = 8, // Defined by text.
|
kOutermost = 0x10, // Outermost loop.
|
kNotClosed = 0x20, // Open loop.
|
kSelfIntersecting = 0x40, // Self-intersecting loop.
|
kTextIsland = 0x80, // Text loop surrounded by an even number of loops.
|
kDuplicate = 0x100, // Duplicate loop.
|
kIsAnnotative = 0x200, // The bounding area is an annotative block.
|
kDoesNotSupportScale = 0x400, // The bounding type does not support scaling
|
kForceAnnoAllVisible = 0x800, // Forces all annotatives to be visible
|
kOrientToPaper = 0x1000, // Orients hatch loop to paper
|
kIsAnnotativeBlock = 0x2000 // Describes if the hatch is an annotative block.
|
};
|
|
virtual int numLoops(const OdRxObject* pHatch) const = 0;
|
virtual OdInt32 loopTypeAt(const OdRxObject* pHatch, int loopIndex) const = 0;
|
virtual void getLoopAt(const OdRxObject* pHatch, int loopIndex, OdArray<OdGeCurve2d*>& edgePtrs) const = 0;
|
virtual void getLoopAt(const OdRxObject* pHatch, int loopIndex, OdGePoint2dArray& vertices, OdGeDoubleArray& bulges) const = 0;
|
virtual HatchStyle hatchStyle(const OdRxObject* pHatch) const = 0;
|
virtual bool isGradient(const OdRxObject* pHatch) const = 0;
|
virtual bool isSolidFill(const OdRxObject* pHatch) const = 0;
|
|
//In TD hatch is always hatchPE, but in TG hatchPE can be added to any entity
|
virtual bool isReallyHatch(const OdRxObject* pHatch) const = 0;
|
};
|
|
/** \details
|
This template class is a specialization of the OdSmartPtr class for OdDbHatchPE object pointers.
|
*/
|
typedef OdSmartPtr<OdDbBaseHatchPE> OdDbBaseHatchPEPtr;
|
|
|
#endif // _ODDB_BASEDATABASE_INCLUDED_
|
