DbBaseDatabase.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, 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-2017 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 "Ge/GeBoundBlock3d.h"
#include "OdTimeStamp.h" // dgn dwf export
#include "OdUnitsFormatter.h"
#include "StringArray.h"
#include "DbHandle.h"
 
class OdDbBaseHostAppServices;
class OdGiAnnoScaleSet;
 
typedef OdRxObject OdDbBaseDatabase;
 
typedef OdRxObjectPtr OdDbBaseDatabasePtr;
 
class DBROOT_EXPORT OdDbBaseDatabasePE : public OdRxObject
{
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseDatabasePE);
  //DOM-IGNORE-END
  
  enum ExtentsFlags
  {
    kZeroFlags      = 0, 
    kExactExtents   = 1, 
    kUseViewExtents = 2  
   ,kClipDisabled   = 0x10000000 //FELIX_CHANGE //Support of unclipped PDF export
  };
 
  virtual OdDbBaseHostAppServices* appServices(OdDbBaseDatabase* pDb) const = 0;
 
  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;
  
  virtual OdBaseTextIteratorPtr createTextIterator(OdDbBaseDatabase* db, const OdChar* textString, int length, bool raw, const OdGiTextStyle* pTextStyle) const = 0;
  
  virtual OdGsDevicePtr setupActiveLayoutViews(OdGsDevice* pDevice, OdGiDefaultContext* pGiCtx) = 0;
 
  virtual OdGsDevicePtr setupLayoutView(OdGsDevice* pDevice, OdGiDefaultContext* pGiCtx, OdDbStub* layoutId) = 0;
  
  virtual void setupPalette(OdGsDevice* device, OdGiDefaultContext* giContext, OdDbStub* layoutId = 0, ODCOLORREF palBg = ODRGBA(0,0,0,0)) = 0;
 
  virtual OdDbStub* getNextViewForActiveLayout(OdGiDefaultContext* pGiCtx, OdDbStub* /*objectId*/) = 0;
  
  virtual void applyLayoutSettings(OdGsDCRect& clipBox, OdGsDevice* pDevice, OdDbBaseDatabase* db, OdUInt32 extentsFlags = kZeroFlags, OdUInt32 dpi = 72) = 0;
  
  virtual void zoomToExtents(const OdGsDCRect& outputRect, OdGsDevice* pDevice, OdDbBaseDatabase* db, OdGeBoundBlock3d& plotExtents,
                             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;
 
  virtual OdDbStub* getVisualStyleId(OdDbBaseDatabase* db, const OdString& name) const = 0;
 
  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;
 
  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; //DOM-IGNORE-BEGIN// dgn dwf export//DOM-IGNORE-END
 
  inline OdRxObjectPtr getFirstLayout(OdDbBaseDatabase* db)
  {
    return openObject(getFirstLayoutId(db));
  }
  
  virtual OdDbStub* getFirstLayoutId(OdDbBaseDatabase* db) = 0;   //DOM-IGNORE-BEGIN// dgn dwf export//DOM-IGNORE-END
 
  virtual OdTimeStamp getCreationTime(OdDbBaseDatabase* db) = 0;  //DOM-IGNORE-BEGIN// dgn dwf export//DOM-IGNORE-END
  
  virtual OdTimeStamp getUpdateTime(OdDbBaseDatabase* db) = 0;    //DOM-IGNORE-BEGIN// dgn dwf export//DOM-IGNORE-END
  
  virtual OdString getFingerPrintGuid(OdDbBaseDatabase* db) = 0;  //DOM-IGNORE-BEGIN// dgn dwf export//DOM-IGNORE-END
  
  virtual OdString getVersionGuid(OdDbBaseDatabase* db) = 0;      //DOM-IGNORE-BEGIN// dgn dwf export//DOM-IGNORE-END
 
  virtual int getUnits(OdDbBaseDatabase* db) = 0; //DOM-IGNORE-BEGIN// dgn dwf export//DOM-IGNORE-END
  
  virtual OdUnitsFormatter* baseFormatter(OdDbBaseDatabase* db) = 0; //DOM-IGNORE-BEGIN// dgn dwg common formatter base class//DOM-IGNORE-END
  
  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* getId(const OdRxObject* obj) const = 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;
};
 
typedef OdSmartPtr<OdDbBaseDatabasePE> OdDbBaseDatabasePEPtr;
 
 
class DBROOT_EXPORT OdDbBaseLayerPE : public OdRxObject
{
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseLayerPE);
  //DOM-IGNORE-END
 
  virtual OdString name(const OdRxObject* obj) const = 0;
 
  virtual bool isOff(const OdRxObject* obj) const = 0;
  
  virtual bool isFrozen(const OdRxObject* obj) const = 0;
 
  virtual void setIsOff(OdRxObject* obj, bool off) const = 0;
  
  virtual void setIsFrozen(OdRxObject* obj, bool frozen) const = 0;
 
  virtual bool getLineType(OdRxObject* obj, OdGiLinetype& LType) const = 0;
};
 
typedef OdSmartPtr<OdDbBaseLayerPE> OdDbBaseLayerPEPtr;
 
 
class DBROOT_EXPORT OdDbBaseVisualStylePE : public OdRxObject
{
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseVisualStylePE);
  //DOM-IGNORE-BEGIN
 
  virtual OdString name(const OdRxObject* obj) const = 0;
 
  virtual bool isInternal(const OdRxObject* obj) const = 0;
};
 
typedef OdSmartPtr<OdDbBaseVisualStylePE> OdDbBaseVisualStylePEPtr;
 
class DBROOT_EXPORT OdDbBaseAnnotationScalePE : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdDbBaseAnnotationScalePE);
 
  virtual bool scaleRatio(const OdRxObject* obj, double* scale) const = 0;
};
 
typedef OdSmartPtr<OdDbBaseAnnotationScalePE> OdDbBaseAnnotationScalePEPtr;
 
 
class DBROOT_EXPORT OdDbBaseLayoutPE : public OdRxObject
{
public:
 
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseLayoutPE);
  //DOM-IGNORE-END
  
  enum PlotRotation
  {
    k0degrees       = 0,   
    k90degrees      = 1,   
    k180degrees     = 2,   
    k270degrees     = 3    
  };
  
  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 bool isOverallVPortErased(const OdRxObject*) = 0;
 
  virtual OdResult getGeomExtents(const OdRxObject*,OdGeExtents3d& ext) = 0;
  
 
  //DOM-IGNORE-BEGIN
  // methods inherited by OdDbLayoutImpl class // dgn dwf export
  //DOM-IGNORE-END
  
  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;
 
  //DOM-IGNORE-BEGIN
  // for Gs
  //DOM-IGNORE-END
  
  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;
 
 
class DBROOT_EXPORT OdDbBaseBlockPE : public OdRxObject
{
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseBlockPE);
  //DOM-IGNORE-END
 
  virtual bool isBlockReferenceAdded(OdRxObject *pBlock) const = 0;
 
  virtual bool isFromExternalReference(const OdRxObject *pBlock) const = 0;
  
  virtual OdDbBaseDatabase *xrefDatabase(const OdRxObject *pBlock) const = 0;
 
  virtual OdDbStub *getLayoutId(const OdRxObject *pBlock) const = 0;
};
 
typedef OdSmartPtr<OdDbBaseBlockPE> OdDbBaseBlockPEPtr;
 
 
class DBROOT_EXPORT OdDbBaseBlockRefPE : public OdRxObject
{
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseBlockRefPE);
  //DOM-IGNORE-END
 
  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 bool isGeneric(const OdRxObject *pBlockRef) const = 0;
  
  virtual bool isMInsert(const OdRxObject *pBlockRef) const = 0;
  
  virtual bool isBasic(const OdRxObject *pBlockRef) const = 0;
};
 
typedef OdSmartPtr<OdDbBaseBlockRefPE> OdDbBaseBlockRefPEPtr;
 
 
class DBROOT_EXPORT OdDbBaseSortEntsPE : public OdRxObject
{
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseSortEntsPE);
  //DOM-IGNORE-END
 
  virtual OdDbStub *blockId(const OdRxObject *pSortents) const = 0;
};
 
typedef OdSmartPtr<OdDbBaseSortEntsPE> OdDbBaseSortEntsPEPtr;
 
 
class DBROOT_EXPORT OdDbBaseLongTransactionPE : public OdRxObject
{
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseLongTransactionPE);
  //DOM-IGNORE-END
 
  virtual OdDbStub *destinationBlock(const OdRxObject *pLT) const = 0;
  
  virtual OdDbBaseDatabase *getDatabase(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;
};
 
typedef OdSmartPtr<OdDbBaseLongTransactionPE> OdDbBaseLongTransactionPEPtr;
 
class DBROOT_EXPORT OdDbBaseHatchPE : public OdRxObject
{
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseHatchPE);
  //DOM-IGNORE-END
  
  enum HatchStyle
  {
    kNormal = 0, 
    kOuter  = 1, 
    kIgnore = 2  
  };
 
  enum HatchLoopType
  {
    kDefault = 0,                 
    kExternal = 1,                
    kPolyline = 2,                
    kDerived = 4,                 
    kTextbox = 8,                 
    kOutermost = 0x10,            
    kNotClosed = 0x20,            
    kSelfIntersecting = 0x40,     
    kTextIsland = 0x80,           
    kDuplicate = 0x100,           
    kIsAnnotative = 0x200,        
    kDoesNotSupportScale = 0x400, 
    kForceAnnoAllVisible = 0x800, 
    kOrientToPaper = 0x1000,      
    kIsAnnotativeBlock = 0x2000   
  };
 
  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;
 
  virtual bool isReallyHatch(const OdRxObject* pHatch) const = 0;
};
 
typedef OdSmartPtr<OdDbBaseHatchPE> OdDbBaseHatchPEPtr;
 
 
 
class DBROOT_EXPORT OdDbBaseMaterialPE : public OdRxObject
{
public:
  //DOM-IGNORE-BEGIN
  ODRX_DECLARE_MEMBERS(OdDbBaseMaterialPE);
  //DOM-IGNORE-BEGIN
 
  virtual OdString name(const OdRxObject* obj) const = 0;
 
  virtual bool isDefault(const OdRxObject* obj) const = 0;
};
 
typedef OdSmartPtr<OdDbBaseMaterialPE> OdDbBaseMaterialPEPtr;
 
#endif // _ODDB_BASEDATABASE_INCLUDED_