/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, 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-2025 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_IMPL_H_
#define _ODDB_BASEDATABASE_IMPL_H_

#include "RxObjectImpl.h"
#include "DbBaseDatabase.h"

#include "TD_PackPush.h"

//----------------------------------------------------------
// OdBaseDatabasePEImpl

class DBROOT_EXPORT OdBaseDatabasePEImpl : public OdDbBaseDatabasePE
{
public:
  ODRX_DECLARE_MEMBERS(OdBaseDatabasePEImpl);

  //virtual OdDbBaseHostAppServices* appServices(OdDbBaseDatabase* pDb) const;
  //virtual OdString getFilename(OdDbBaseDatabase* pDb) const;
  //virtual OdGiDefaultContextPtr createGiContext(OdDbBaseDatabase* pDb) const;
  void putNamedViewInfo(OdDbBaseDatabase* pDb, OdDbStub* layoutInfo, 
                        OdStringArray& names, OdGePoint3dArray& points, const OdGsDevice* pDevice = 0) override;
  OdBaseTextIteratorPtr createTextIterator(OdDbBaseDatabase* db, const OdChar* textString,
                                           int length, bool raw, const OdGiTextStyle* pTextStyle) const override;
  //virtual OdGsDevicePtr setupActiveLayoutViews(OdGsDevice* pDevice, OdGiDefaultContext* pGiCtx);
  OdGsDevicePtr setupLayoutView(OdGsDevice* pDevice, OdGiDefaultContext* pDgnContext,
                                OdDbStub* objectId) override;
  void setupPalette(OdGsDevice* device, OdGiDefaultContext* giContext, 
                    OdDbStub* layoutId = 0, ODCOLORREF palBg = ODRGBA(0,0,0,0)) override;
  OdDbStub* getNextViewForActiveLayout(OdGiDefaultContext* pDgnContext, OdDbStub* objectId) override;
  void loadPlotstyleTableForActiveLayout(OdGiDefaultContext* pTdContext, OdDbBaseDatabase* db) override;

  void startTransaction(OdDbBaseDatabase* pDb) override;
  void abortTransaction(OdDbBaseDatabase* pDb) override;

  OdResult startUndoRecord(OdDbBaseDatabase* pDb) override;
  OdResult undo(OdDbBaseDatabase* pDb) override;

  OdResult evaluateFields(OdDbBaseDatabase* pDb, int nContext) override;

  void applyLayoutSettings(OdGsDCRect& clipBox, OdGsDevice* pDevice, OdDbBaseDatabase* db, OdUInt32 extentsFlags = kZeroFlags, OdUInt32 dpi = 72) override;
  void zoomToExtents(const OdGsDCRect& outputRect, OdGsDevice* pDevice, OdDbBaseDatabase* db, OdGeBoundBlock3d& plotExtents,
                     OdUInt32 extentsFlags = kZeroFlags, OdDbStub* objectId = NULL) override;
  OdRxIteratorPtr layers(OdDbBaseDatabase* db) const override;
  OdRxIteratorPtr visualStyles(OdDbBaseDatabase* db) const override;
  OdDbStub* getVisualStyleId(OdDbBaseDatabase* db, const OdString& name) const override;
  //virtual void setCurrentLayout(OdDbBaseDatabase* db, const OdString& name);
  void setCurrentLayoutId(OdDbBaseDatabase* pDb, OdDbStub* id) override;
  //virtual OdRxIteratorPtr layouts(OdDbBaseDatabase* db) const;

  //virtual OdDbStub* findLayoutIdByViewport(OdDbBaseDatabase* db, OdDbStub* pViewportId);
  //virtual OdDbStub* getFirstLayoutId(OdDbBaseDatabase* db);

  // returns the first visible view Id associated with model named name
  OdDbStub* findLayoutNamed(OdDbBaseDatabase* db, const OdString& name) override;
  OdTimeStamp getCreationTime(OdDbBaseDatabase* db) override;
  OdTimeStamp getUpdateTime(OdDbBaseDatabase* db) override;
  OdString getFingerPrintGuid(OdDbBaseDatabase* db) override;
  OdString getVersionGuid(OdDbBaseDatabase* db) override;
  //virtual OdDbBaseViewTableIteratorPEPtr getViewTableIterator(OdDbBaseDatabase* db);
  int getUnits(OdDbBaseDatabase* db) override;
  OdUnitsFormatter* baseFormatter(OdDbBaseDatabase* db) override;
  //virtual OdDbBaseViewTablePEPtr getViewTable(OdDbBaseDatabase* db);
  virtual OdSmartPtr<class OdDbBaseViewportTablePE> getViewportTable(OdDbBaseDatabase* db);
  //virtual OdString getLayoutName(OdDbStub* elementId);
  //virtual OdDbBaseLayoutIteratorPEPtr newLayoutIteratorPE(OdDbBaseDatabasePE* db);
  int getMeasurement(OdDbBaseDatabase* db) override;
  bool getLineTypeById( OdDbBaseDatabase* db, OdDbStub* pLTypeId, OdGiLinetype& LType ) override;
  bool getTextStyleById( OdDbBaseDatabase* db, OdDbStub* idStyle, OdGiTextStyle& shapeInfo ) override;

  OdDbStub* getId(const OdRxObject* obj) const override;
  OdDbStub *getObject(OdDbBaseDatabase* db, OdUInt64 handle) override;
  OdCodePageId getCodePage(OdDbBaseDatabase* db) override;
  OdDbStub* getModelBlockId(OdDbBaseDatabase* pDb) override;
  OdDbStub* getPaperBlockId(OdDbBaseDatabase* pDb) override;
  //virtual OdDbStub* currentLayoutId(OdDbBaseDatabase* pDb);
  OdDbStub* xrefBlockId(OdDbBaseDatabase* pDb) override;
  void setMultiThreadedRender(OdDbBaseDatabase* pDb, bool bOn) override;
  bool isExclusiveReadingEnabled(const OdDbBaseDatabase* pDb) override;
  bool isAProxy(OdRxObject* pDrw) override;
  //virtual OdRxObjectPtr openObject(OdDbStub* pId);
  TD_USING(OdDbBaseDatabasePE::openObject);
  OdRxObjectPtr openObject(OdDbStub* pId, bool bForWrite) override;
  bool upgradeOpen(OdRxObject* pObj) override;
  void downgradeOpen(OdRxObject* pObj) override;
  bool getAnnoScaleSet(OdDbStub* drawableId, OdGiAnnoScaleSet& res) override;
  OdDbStub* getCurrentLongTransation(const OdDbBaseDatabase* pDb) override;
  OdRxObjectPtr addDatabaseUnloadReactor(OdDbBaseDatabase* pDb, OdRxObject* pPrevReactor, DatabaseUnloadReactor* pReactorRedirect) override;
  void removeDatabaseUnloadReactor(OdDbBaseDatabase* pDb, OdRxObject* pReactor) override;
  OdResult faceConversionHelper(OdDbStub*& material, OdDbBaseDatabase* pSourceDb, OdDbBaseDatabase* pDestinationDb,
                                const OdGiMaterialTraits* pMaterialTraits, const OdGiMapper* pMaterialMapper = 0, const OdCmEntityColor* pMaterialColor = 0) override;

  OdRxObjectPtr getGeoData(const OdDbBaseDatabase* pDb, const OdGsDevice* pDevice = 0, const OdGsView* pView = 0) const ODRX_OVERRIDE;
  OdGiDefaultContextPtr createFilteredGiContextForExport(OdDbBaseDatabase* pDb, const OdRxObjectPtr& pSSet) const ODRX_OVERRIDE;
};

class OdSelectionSet;

class DBROOT_EXPORT OdSSetFilter
{
public:
  OdSSetFilter(const OdSelectionSet*);
  bool CheckSelectionSet(const OdGiPathNode* pPathNode);
protected:
  const OdSelectionSet* m_pSSet;
};

//----------------------------------------------------------
// OdBaseLayerPEImpl

class DBROOT_EXPORT OdBaseLayerPEImpl : public OdDbBaseLayerPE
{
public:
  ODRX_DECLARE_MEMBERS(OdBaseLayerPEImpl);

  OdString name(const OdRxObject* obj) const override;
  bool isOff(const OdRxObject*) const override;
  bool isFrozen(const OdRxObject*) const override;
  void setIsOff(OdRxObject*, bool) const override;
  void setIsFrozen(OdRxObject*, bool) const override;
  bool getLineType(OdRxObject* obj, OdGiLinetype& LType) const override;
};

//----------------------------------------------------------
// OdBaseVisualStylePEImpl

class DBROOT_EXPORT OdBaseVisualStylePEImpl : public OdDbBaseVisualStylePE
{
public:
  ODRX_DECLARE_MEMBERS(OdBaseVisualStylePEImpl);

  OdString name(const OdRxObject* obj) const override;
  bool isInternal(const OdRxObject* obj) const override;
};

//----------------------------------------------------------
// OdBaseLayoutPEImpl

class DBROOT_EXPORT OdBaseLayoutPEImpl : public OdDbBaseLayoutPE
{
public:
  ODRX_DECLARE_MEMBERS(OdBaseLayoutPEImpl);

  //virtual OdString name(const OdRxObject*);
  //virtual bool isModelLayout(const OdRxObject*);
  bool printLineweights(const OdRxObject*) override;
  bool showPlotStyles(const OdRxObject*) override;
  OdString paperName(const OdRxObject*) override;
  void getPaperSize(const OdRxObject*, double& paperWidth, double& paperHeight) const override;
  OdDbBaseLayoutPE::PlotRotation plotRotation(const OdRxObject*) override;
  double getTopMargin(const OdRxObject*) override;
  double getRightMargin(const OdRxObject*) override;
  double getBottomMargin(const OdRxObject*) override;
  double getLeftMargin(const OdRxObject*) override;
  bool isOverallVPortErased(const OdRxObject*) override;
  OdResult getGeomExtents(const OdRxObject*, OdGeExtents3d& ext) override;

  bool useStandardScale(const OdRxObject*) override;
  void getStdScale(const OdRxObject*, double& scale) override;
  void getCustomPrintScale(const OdRxObject*, double& numerator, double& denominator) override;
  int plotType(const OdRxObject*) override;
  OdString getPlotViewName(const OdRxObject*) override;
  void getPlotWindowArea(const OdRxObject*, double& xmin, double& ymin, double& xmax, double& ymax) override;
  void getPlotOrigin(const OdRxObject*, double& x, double& y) override;
  void getPlotPaperSize(const OdRxObject*, double& paperWidth, double& paperHeight) override;
  int plotPaperUnits(const OdRxObject*) override;

  //virtual OdDbStub* getBlockId(const OdRxObject*) const;
  bool scalePSLinetypes(const OdRxObject*) const override;
  bool getApproxExtents(const OdRxObject*, OdGePoint3d& extMin, OdGePoint3d& extMax) const override;

  OdResult getPlotType(const OdRxObject*, OdDbBaseLayoutPE::PlotType&) const override;
  OdResult getPlotPaperUnits(const OdRxObject*, OdDbBaseLayoutPE::PlotPaperUnits&) const override;
  OdResult getStdScaleType(const OdRxObject*, OdDbBaseLayoutPE::StdScaleType&) const override;
  bool scaleLineweights(const OdRxObject*) const override;
};

class DBROOT_EXPORT OdSetBasePlotSettingsPEImpl : public OdDbSetBasePlotSettingsPE
{
public:
  ODRX_DECLARE_MEMBERS(OdSetBasePlotSettingsPEImpl);

  OdResult setPlotCfgName(OdRxObject* pPlotSetObj, const OdString &plotCfgName) override;
  OdResult setPlotLayoutFlags(OdRxObject* pPlotSetObj, OdInt16 flags) override;
  OdResult setMargins(OdRxObject* pPlotSetObj, double left, double bottom, double right, double top) override;
  OdResult setPlotPaperSize(OdRxObject* pPlotSetObj, double paperWidth, double paperHeight) override;
  OdResult setMediaName(OdRxObject* pPlotSetObj, OdString mediaName) override;
  OdResult setOrigin(OdRxObject* pPlotSetObj, const OdGePoint2d &origin) override;
  OdResult setPlotPaperUnits(OdRxObject* pPlotSetObj, OdDbBaseLayoutPE::PlotPaperUnits units) override;
  OdResult setPlotRotation(OdRxObject* pPlotSetObj, OdDbBaseLayoutPE::PlotRotation plotRotation) override;
  OdResult setPlotType(OdRxObject* pPlotSetObj, OdDbBaseLayoutPE::PlotType plotType) override;
  OdResult setPlotWindowArea(OdRxObject* pPlotSetObj, double xmin, double ymin, double xmax, double ymax) override;
  OdResult setPlotView(OdRxObject* pPlotSetObj, OdDbStub* plotViewId) override;
  OdResult setPrintScale(OdRxObject* pPlotSetObj, double numerator, double denominator) override;
  OdResult setStyleSheet(OdRxObject* pPlotSetObj, OdString styleSheet) override;
  OdResult setStdScaleType(OdRxObject* pPlotSetObj, OdDbBaseLayoutPE::StdScaleType scaleType) override;
  OdResult setScaleFactor(OdRxObject* pPlotSetObj, double dScaleFactor) override;
};

template<class ClassIterator>
struct ObjectIteratorWrapper : OdRxIterator
{
  OdSmartPtr<ClassIterator> iter;

  bool done() const override
  {
    return iter.isNull() || iter->done(); 
  }

  bool next() override
  { 
    iter->step(); 
    return !iter->done();
  }

  OdRxObjectPtr object() const override
  {
    OdRxObjectPtr pObject = iter->item().openObject();
    return pObject;
  }
  static OdRxIteratorPtr createObject()
  {
    OdRxIteratorPtr pIterator = OdRxObjectImpl<ObjectIteratorWrapper>::createObject();
    return pIterator;
  }
};

// OdBaseVisualStylePEImpl

class DBROOT_EXPORT OdBaseMaterialPEImpl : public OdDbBaseMaterialPE
{
public:
  ODRX_DECLARE_MEMBERS(OdBaseMaterialPEImpl);

  OdString name(const OdRxObject* obj) const override;
  bool isDefault(const OdRxObject* obj) const override;
};

class DBROOT_EXPORT OdBaseLinetypePEImpl : public OdDbBaseLinetypePE
{
public:
  ODRX_DECLARE_MEMBERS(OdBaseLinetypePEImpl);

  OdString name(const OdRxObject* obj) const override;
};

// possible TODO Inherit OdCmColor and others from next class

class DBROOT_EXPORT OdCmColorBaseImpl : public OdCmColorBase
{
protected:
  OdCmEntityColor::RGBM m_RGBM;
  OdString m_colorName;
  OdString m_bookName;
public:
  ODRX_HEAP_OPERATORS();
  OdCmColorBaseImpl();
  OdCmEntityColor::ColorMethod colorMethod() const override;
  void setColorMethod(OdCmEntityColor::ColorMethod colorMethod) override;
  bool isByColor() const override;
  bool isByLayer() const override;
  bool isByBlock() const override;
  bool isByACI() const override;
  bool isForeground() const override;
  bool isByDgnIndex() const override;
  virtual bool isNone() const;
  OdUInt32 color() const override;
  void setColor(OdUInt32 color) override;
  void setRGB(OdUInt8 red, OdUInt8 green, OdUInt8 blue) override;
  void setRed(OdUInt8 red) override;
  void setGreen(OdUInt8 green) override;
  void setBlue(OdUInt8 blue) override;
  OdUInt8 red() const override;
  OdUInt8 green() const override;
  OdUInt8 blue() const override;
  OdUInt16 colorIndex() const override;
  void setColorIndex(OdUInt16 colorIndex) override;
  bool  setNames(const OdString& colorName, const OdString& bookName = OdString::kEmpty) override;
  OdString colorName() const override;
  OdString bookName() const override;
  OdString colorNameForDisplay() const override;
  bool hasColorName() const override;
  bool hasBookName() const override;
};

class DBROOT_EXPORT OdBaseHatchPEImpl : public OdDbBaseHatchPE
{
  ODRX_DECLARE_MEMBERS(OdBaseHatchPEImpl);

  int numLoops(const OdRxObjectPtr& pHatch) const override;
  OdInt32 loopTypeAt(const OdRxObjectPtr& pHatch, int loopIndex) const override;
  void getLoopAt(const OdRxObjectPtr& pHatch, int loopIndex, OdArray<OdGeCurve2d*>& edgePtrs) const override;
  void getLoopAt(const OdRxObjectPtr& pHatch, int loopIndex, OdGePoint2dArray& vertices, OdGeDoubleArray& bulges) const override;
  OdDbBaseHatchPE::HatchStyle hatchStyle(const OdRxObjectPtr& pHatch) const override;
  bool isGradient(const OdRxObjectPtr& pHatch) const override;
  bool isSolidFill(const OdRxObjectPtr& pHatch) const override;
  bool isReallyHatch(const OdRxObjectPtr& pHatch) const override;
  bool hasBackgroundColor(const OdRxObjectPtr& pHatch) const override;
  bool isTooDense(const OdRxObjectPtr& pHatch) const override;
};

#include "TD_PackPop.h"

#endif //_ODDB_BASEDATABASE_IMPL_H_