///////////////////////////////////////////////////////////////////////////////
// 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.
///////////////////////////////////////////////////////////////////////////////

#include <OdaCommon.h>
#include <RxDispatchImpl.h>
#include <RxVariantValue.h>
#include <DbDictionary.h>
#include <RxDynamicModule.h>
#include <Ed/EdCommandStack.h>
#include <Ed/EdCommandContext.h>
#include <Ed/EdUserIO.h>
#include <DbCommandContext.h>
#include <OdModuleNames.h>
#include <StaticRxObject.h>
#include "DgnImportImpl.h"
#include "DgnImportLS.h"
#include <DgDatabase.h>
#include <ExDgnHostAppServices.h>
#include <ExHostAppServices.h>
#include "DgnImportCommon.h"
#include "DgnImportContext.h"
#include <DbViewportTable.h>
#include <DbViewportTableRecord.h>

#include "DgLine.h"
#include "DgArc.h"
#include "DgLineString.h"
#include "DgShape.h"
#include "DgEllipse.h"
#include "DgText.h"
#include "DgTextNode.h"
#include "DgReferenceAttach.h"
#include "DgRasterAttach.h"
#include "DgRasterFrame.h"
#include "DgOle2Frame.h"
#include "DgTagElement.h"
#include "DgMesh.h"
#include "DgDimension.h"
#include "DgSharedCellReference.h"
#include "DgComplexShape.h"
#include "DgComplexString.h"
#include "Dg3DObject.h"
#include "DgTable.h"
#include "DgMultiline.h"
#include "DgCurve.h"
#include "DbRotatedDimension.h"
#include "DbArcDimension.h"
#include "Db3PointAngularDimension.h"
#include "DbRadialDimension.h"
#include "DbDiametricDimension.h"
#include "DbOrdinateDimension.h"
#include "DgLight.h"
#include "DgRaster.h"
#include "DgBSplineSurface.h"
#include "DgCone.h"
#include "DbLayerTableRecord.h"
#include "DgProxyElement.h"
#include "DgExtendedElement.h"

#include "DgnImportPE.h"
#include "DgnImportLine.h"
#include "DgnImportTableElement.h"
#include "DgnImportArc.h"
#include "DgnImportLineString.h"
#include "DgnImportRasterAttach.h"
#include "DgnImportSharedCell.h"
#include "DgnImportText.h"
#include "DgnImportEllipse.h"
#include "DgnImportMesh.h"
#include "DgnImportBSplineCurve.h"
#include "DgnImportOle.h"
#include "DgnImportCellHeader.h"
#include "DgnImportXRef.h"
#include "DgnImportTextNode.h"
#include "DgnImportComplexShape.h"
#include "DgnImportComplexString.h"
#include "DgnImportShape.h"
#include "DgnImportDimensions.h"
#include "DgnImport3dObject.h"
#include "DgnImportMultiline.h"
#include "DgnImportDimAssoc.h"
#include "DgnImportLight.h"
#include "DgnImportGeoData.h"
#include <DgGeoData.h>
#include "OdUtilAds.h"
#include <DbLayerTable.h>

namespace TD_DGN_IMPORT{

class OdExDgnImportHostAppServices : public OdExDgnHostAppServices
{
  public:
    OdExDgnImportHostAppServices()          { m_strAltFont = OdString::kEmpty; }
    virtual ~OdExDgnImportHostAppServices() {}

    virtual OdString getAlternateFontName() const
    {
      if (!m_strAltFont.isEmpty())
        return m_strAltFont;
      else
        return OdExDgnHostAppServices::getAlternateFontName();
    }

    virtual void setAlternateFontName(const OdString& strFontName) { m_strAltFont = strFontName;}

  private:
    OdString m_strAltFont;
};

double setDwgActiveUnitSettingsToModel(OdDgModelPtr& pModel, OdDbDatabase* pDb)
{
  double dRet = getUnitConversionScale(pModel, pDb);

  if (!OdEqual(dRet, 1.0))
  {
    pModel->upgradeOpen();
    pModel->transformBy(OdGeMatrix3d::scaling(dRet));
  }

  return dRet;
}

void setActiveUnits(const OdDgModelPtr& pModel, OdDbDatabase* pDb)
{
  OdDgModel::UnitMeasure masterUnitsEnum = pModel->getMasterUnit();
  OdDb::UnitsValue insUnit = OdDb::kUnitsInches;
  OdUInt16 uLUnitType = 0;
  OdUInt16 uLUnitAccur = 0;
  OdUInt16 uAUnitType = 0;
  OdUInt16 uAUnitAccur = 0;

  switch( masterUnitsEnum )
  {
    case OdDgModel::kMegameters: insUnit = OdDb::kUnitsUndefined; break;
    case OdDgModel::kKilometers: insUnit = OdDb::kUnitsKilometers; break;
    case OdDgModel::kMeters: insUnit = OdDb::kUnitsMeters; break;
    case OdDgModel::kDecimeters: insUnit = OdDb::kUnitsDecimeters; break;
    case OdDgModel::kCentimeters: insUnit = OdDb::kUnitsCentimeters; break;
    case OdDgModel::kMillimeters: insUnit = OdDb::kUnitsMillimeters; break;
    case OdDgModel::kMicrometers: insUnit = OdDb::kUnitsMicrons; break;
    case OdDgModel::kNanometers: insUnit = OdDb::kUnitsNanometers; break;
    case OdDgModel::kMiles: insUnit = OdDb::kUnitsMiles; break;
    case OdDgModel::kYards: insUnit = OdDb::kUnitsYards; break;
    case OdDgModel::kFeet: insUnit = OdDb::kUnitsFeet; break;
    case OdDgModel::kInches: insUnit = OdDb::kUnitsInches; break;
    case OdDgModel::kMils: insUnit = OdDb::kUnitsMils; break;
    case OdDgModel::kUSSurveyFeet: insUnit = OdDb::kUnitsUSSurveyFeet; break;
    case OdDgModel::kMicroinches: insUnit = OdDb::kUnitsMicroinches; break;
    default:
    {
      OdDgModel::UnitDescription unitDesc;
      pModel->getMasterUnit(unitDesc);
      double dUnitScale = unitDesc.m_numerator / unitDesc.m_denominator;
      double dDeviation = dUnitScale / 1e5;

      if( dDeviation > 1e-10 )
        dDeviation = 1e-10;

      bool bSetUndefinedUnits = true;

      for (OdUInt32 i = OdDb::kUnitsInches; i <= OdDb::kUnitsMax; i++)
      {
        double dCurScale = oddbGetUnitsConversion(OdDb::kUnitsMeters, (OdDb::UnitsValue)(i));

        if (OdEqual(dUnitScale, dCurScale, dDeviation))
        {
          bSetUndefinedUnits = false;
          insUnit = (OdDb::UnitsValue)(i);
          break;
        }
      }

      if( bSetUndefinedUnits )
        insUnit = OdDb::kUnitsUndefined;
    } break;
  }

  switch( pModel->getWorkingUnitAccuracy() )
  {
    case OdDgModel::kAccuracyDecimal1: uLUnitType = 2; uLUnitAccur = 1; break;
    case OdDgModel::kAccuracyDecimal2: uLUnitType = 2; uLUnitAccur = 2; break;
    case OdDgModel::kAccuracyDecimal3: uLUnitType = 2; uLUnitAccur = 3; break;
    case OdDgModel::kAccuracyDecimal4: uLUnitType = 2; uLUnitAccur = 4; break;
    case OdDgModel::kAccuracyDecimal5: uLUnitType = 2; uLUnitAccur = 5; break;
    case OdDgModel::kAccuracyDecimal6: uLUnitType = 2; uLUnitAccur = 6; break;
    case OdDgModel::kAccuracyDecimal7: uLUnitType = 2; uLUnitAccur = 7; break;
    case OdDgModel::kAccuracyDecimal8: uLUnitType = 2; uLUnitAccur = 8; break;
    case OdDgModel::kAccuracyFractional2: uLUnitType = 5; uLUnitAccur = 1; break;
    case OdDgModel::kAccuracyFractional4: uLUnitType = 5; uLUnitAccur = 2; break;
    case OdDgModel::kAccuracyFractional8: uLUnitType = 5; uLUnitAccur = 3; break;
    case OdDgModel::kAccuracyFractional16: uLUnitType = 5; uLUnitAccur = 4; break;
    case OdDgModel::kAccuracyFractional32: uLUnitType = 5; uLUnitAccur = 5; break;
    case OdDgModel::kAccuracyFractional64: uLUnitType = 5; uLUnitAccur = 6; break;
    case OdDgModel::kAccuracyFractional128: uLUnitType = 5; uLUnitAccur = 7; break;
    case OdDgModel::kAccuracyFractional256: uLUnitType = 5; uLUnitAccur = 8; break;
    case OdDgModel::kAccuracyExponential1: uLUnitType = 1; uLUnitAccur = 1; break;
    case OdDgModel::kAccuracyExponential2: uLUnitType = 1; uLUnitAccur = 2; break;
    case OdDgModel::kAccuracyExponential3: uLUnitType = 1; uLUnitAccur = 3; break;
    case OdDgModel::kAccuracyExponential4: uLUnitType = 1; uLUnitAccur = 4; break;
    case OdDgModel::kAccuracyExponential5: uLUnitType = 1; uLUnitAccur = 5; break;
    case OdDgModel::kAccuracyExponential6: uLUnitType = 1; uLUnitAccur = 6; break;
    case OdDgModel::kAccuracyExponential7: uLUnitType = 1; uLUnitAccur = 7; break;
    case OdDgModel::kAccuracyExponential8: uLUnitType = 1; uLUnitAccur = 8; break;
    default: uLUnitType = 2; uLUnitAccur = 0; break;
  }

  switch (pModel->getAngleAccuracy())
  {
    case OdDgModel::kAngleAccuracy1: uAUnitAccur = 1; break;
    case OdDgModel::kAngleAccuracy2: uAUnitAccur = 2; break;
    case OdDgModel::kAngleAccuracy3: uAUnitAccur = 3; break;
    case OdDgModel::kAngleAccuracy4: uAUnitAccur = 4; break;
    case OdDgModel::kAngleAccuracy5: uAUnitAccur = 5; break;
    case OdDgModel::kAngleAccuracy6: uAUnitAccur = 6; break;
    case OdDgModel::kAngleAccuracy7: uAUnitAccur = 7; break;
    case OdDgModel::kAngleAccuracy8: uAUnitAccur = 8; break;
    default: uAUnitType = 0; break;
  }

  switch( pModel->getAngleFormat() )
  {
    case OdDgModel::kAngle_D: uAUnitType = 0; break;
    case OdDgModel::kAngle_DM: uAUnitType = 1; break;
    case OdDgModel::kAngle_DMS: uAUnitType = 1; break;
    case OdDgModel::kAngle_Gradian: uAUnitType = 2; break;
    default: uAUnitType = 3; break;
  }

  pDb->setINSUNITS(insUnit);
  pDb->setLUNITS(uLUnitType);
  pDb->setAUNITS(uAUnitType);
  pDb->setAUPREC(uAUnitAccur);

  OdUInt16 flags = pModel->database()->getAutoDimFlags();
  OdInt16  valData = (flags & 0x7) - 1;

  if( valData == -1 )
    valData = 4;

  pDb->setLUPREC(valData);
}

//==========================================================================

bool hasNamedPlotStyles(const OdDgDatabase* pDgnDb)
{
  OdDgDictionaryPtr pRootDict = pDgnDb->getDictionaryTable(OdDg::kForRead);

  if( pRootDict.isNull() )
    return false;

  OdDgElementId idStbPlotStyleDict = pRootDict->getAt(L"ACAD_PLOTSTYLENAME");

  if (idStbPlotStyleDict.isNull())
    return false;

  return true;
}

//==========================================================================

void setZeroLevelForCellHeader(OdDgDatabase* pDgnDb, OdDbDatabase* pDb)
{
  if( !pDb || !pDgnDb)
    return;

  OdDgLevelTablePtr pLevelTable = pDgnDb->getLevelTable(OdDg::kForRead);

  if( pLevelTable->getAt(L"0").isNull() )
    return;

  OdDbObjectId      idZeroLayer = pDb->getLayerZeroId();

  if( idZeroLayer.isNull() )
    return;

  OdDbLayerTableRecordPtr pZeroLayer = idZeroLayer.openObject(OdDb::kForRead);
  OdDbLayerTablePtr       pLayerTable = pDb->getLayerTableId().openObject(OdDb::kForWrite);

  OdString strName = L"CellHeaderBase";

  if( pLayerTable->getAt(strName).isNull() && !pZeroLayer.isNull() )
  {
    OdDbLayerTableRecordPtr pVisibleZeroLayer = pZeroLayer->clone();
    pVisibleZeroLayer->setIsFrozen(false);
    pVisibleZeroLayer->setIsOff(false);
    pVisibleZeroLayer->setName(strName);
    pLayerTable->add(pVisibleZeroLayer);
    OdDgnImportContext::setCellHeaderZeroId(pVisibleZeroLayer->id());
  }
}

//==========================================================================

OdDgnImport::ImportResult DgnImporter::import()
{
  OdSmartPtr<OdDbHostAppServices> svc = _properties->get_Services();
  if (svc.isNull())
    return OdDgnImport::fail;

  registerElementLoaders( svc );

  OdDgnImportContext::prepareToImport(this);
  OdDgnImportContext::setConvertColorIndexToTrueColorFlag( _properties->get_ConvertDgnColorIndicesToTrueColors() );
  OdDgnImportContext::setConvertEmptyDataFieldsToSpacesFlag( _properties->get_ConvertEmptyDataFieldsToSpaces() );
  OdDgnImportContext::setCropXRefExtraClipByExtentsFlag(_properties->get_CropXRefExtraClipByExtents());
  OdDgnImportContext::setUnderlineDataFieldsFlag(_properties->get_UnderlineTextDataFields());
  OdDgnImportContext::setViewportImportMode(_properties->get_ViewportImportMode());
  OdDgnImportContext::setSupportPriorityFor2dElementsFlag(_properties->get_SupportPriorityFor2dElements());
  OdDgnImportContext::setKeepComplexStringInvisibleItemsFlag(_properties->get_KeepComplexStringInvisibleItems());
  OdDgnImportContext::setMaxXRefNumberToKeepInMemory(_properties->get_MaxXRefNumberToKeepInMemory());
  OdDgnImportContext::setMaxXRefNestedDepthToKeepInMemory(2);

  _idMap.clear();
  OdDbDatabasePtr pDb = _properties->get_Database();
  bool isInitialized = !pDb.isNull();
  if (!isInitialized)
    pDb = svc->createDatabase(false);
  OdSmartPtr<OdDgHostAppServices> _services = _properties->get_DgnServices();

  OdDgnImportContext::setCurrentDatabase(pDb);

  if (_services.isNull())
  {
    _services = OdRxObjectImpl<OdExDgnImportHostAppServices>::createObject();
//    OdExDgnImportHostAppServices* pDgnServises = (OdExDgnImportHostAppServices*)(_services.get());
//    pDgnServises->setAlternateFontName(svc->getAlternateFontName());
  }

  OdDgDatabasePtr dgn = _properties->get_DgnDatabase();

  if( !OdDgnImportContext::getInternalImportFlag() && dgn.isNull() )
  {
    _services->cleanupLineStyleDefRscMap();
    _services->cleanupRscFontMap();

    if (!_properties->get_MS_SYMBRSRC().isEmpty())
      _services->setMS_SYMBRSRC(const_cast<OdStringArray&>(_properties->get_MS_SYMBRSRC()));

    if (!_properties->get_dgnFastFont().isEmpty())
      _services->setFAST_FONT(_properties->get_dgnFastFont());

    _services->setMS_REF_NEWLEVELDISPLAY(_properties->get_ShowNewXRefLevels());
  }

  OdDgnImportContext::setShowNewXRefLevelsFlag(_properties->get_ShowNewXRefLevels());

  if( _properties->get_EnableDgnFileMTLoading() )
    _services->setMtMode(1);
  else
    _services->setMtMode(0);

  try
  {    
    if( dgn.isNull() )
      dgn = _services->readFile(_properties->get_DgnPath());

    if (dgn.isNull())
      return OdDgnImport::bad_file;

    m_pDgnDb           = dgn.get();
    m_pHostAppServices = svc.get();

    DgnLSImporter::prepareLS(dgn); // Populate additional database-resident objects before getting handseed
    pDb->getOdDbObjectId(dgn->getHandseed(), true);

    if (!isInitialized)
    {
      pDb->initialize();

      if( hasNamedPlotStyles(dgn) )
        odDbSetPSTYLEMODE(*pDb, false);
    }

    OdDgnImportContext::setPalette( dgn );
    OdDgnImportContext::setImportInvisible( !_properties->get_DontImportInvisibleElements() );
    OdDgnImportContext::setImportDgTextAsDbMText( _properties->get_ImportDgTextsAsDbMTexts() );
    OdDgnImportContext::setImportFilledRscFonts(_properties->get_ConvertFilledRscFonts());

    // Get dgn model to import it to dwg model space.

    OdDgModelPtr pModelSpaceModel;
    OdDgModelPtr pActiveSpaceModel;
    OdDgElementId idModelSpaceModel;

    bool modelSpaceFound = false;
    bool bSetActivePaperSpaceLayout = false;
    bool bImportActiveModel = _properties->get_ImportActiveModelToModelSpace();

    if( bImportActiveModel )
    {
      idModelSpaceModel = dgn->getActiveModelId();

      if( !idModelSpaceModel.isNull() )
      {
        pModelSpaceModel = idModelSpaceModel.safeOpenObject();
        pActiveSpaceModel = pModelSpaceModel;
        modelSpaceFound = true;

        if( !pModelSpaceModel.isNull() && pModelSpaceModel->isKindOf(OdDgSheetModel::desc()) && _properties->get_ImportPaperSpaceModels() )
        {
          OdUInt32 nDesignModels = 0;

          for (OdDgElementIteratorPtr mi = dgn->getModelTable()->createIterator(); !mi->done(); mi->step())
          {
            OdDgModelPtr m = mi->item().safeOpenObject();

            if( !m.isNull() && !m->isKindOf(OdDgSheetModel::desc()))
              nDesignModels++;
          }

          if (nDesignModels == 1)
          {
            modelSpaceFound = false;
            idModelSpaceModel = NULL;
            bSetActivePaperSpaceLayout = true;
          }
        }
      }
    }

    if( !modelSpaceFound )
    {
      for( OdDgElementIteratorPtr mi = dgn->getModelTable()->createIterator(); !mi->done(); mi->step())
      {
        OdDgModelPtr m = mi->item().safeOpenObject();

        if( !m->isKindOf(OdDgSheetModel::desc()) )
        {
          pModelSpaceModel = m;
          idModelSpaceModel = m->elementId();
          modelSpaceFound = true;
          break;
        }
        else
        {
          pModelSpaceModel = m;
        }
      }
    }

    // Initialize scale for block definition conversion

    OdDgElementId idDefaultModel = dgn->getDefaultModelId();

    if (idDefaultModel.isNull())
      idDefaultModel = dgn->getActiveModelId();

    if( !idDefaultModel.isNull() )
    {
      OdDgModelPtr pDefaultModel = idDefaultModel.openObject(OdDg::kForRead);

      if (!pDefaultModel.isNull())
      {
        double dUORsToModelScale = pDefaultModel->convertUORsToWorkingUnits(1.0);

        if( dUORsToModelScale > 1e-8 )
          OdDgnImportContext::setUORsToModelBlockScale(dUORsToModelScale);
      }
    }

    // Copy tables
    copyRegApps(dgn, pDb);
    copyTextStyles(dgn, pDb, !isInitialized);
    copyMaterials(dgn, pDb);
    copyLineStyles(dgn, pDb); // Should be called after text styles processed because import blocks
    copyLayers(dgn->getLevelTable(OdDg::kForRead), pDb); // Should be called after line styles, because depends from id's
    setZeroLevelForCellHeader(dgn, pDb);
    copyDisplayStyles(dgn, pDb);
    copyViewports(dgn, pDb, pModelSpaceModel);
    copyNamedViews(dgn, pDb);
    copyMLineStyles(dgn, pDb, pModelSpaceModel);
    copyBlocks(dgn, pDb, true, false);
    copyDimStyles(dgn, pDb, isInitialized);
    copyBlocks(dgn, pDb, false, true);
    pushResourcesByFileName(dgn, dgn->getLevelTable(OdDg::kForRead));

    double dDgnModelScale = 1.0;

    if( !isInitialized )
      copyDatabaseDefaults(dgn, pDb);

    if (!isInitialized)
      setActiveUnits(pModelSpaceModel, pDb);
    else
      dDgnModelScale = setDwgActiveUnitSettingsToModel(pModelSpaceModel, pDb);

    pDb->setLWDISPLAY( true );
    pDb->setXCLIPFRAME(0);

		setLevelVisibilityByLevelMaskMode( dgn );

    double dOldDimBlockScale = OdDgnImportContext::getDimDataScale();
    OdDgnImportContext::setDimDataScale(1.0 / dDgnModelScale);

    if( modelSpaceFound )
    {
      copyModelSpace(pModelSpaceModel, pDb);
    }

    OdDgnImportContext::setDimDataScale(dOldDimBlockScale);

    if (!OdEqual(dDgnModelScale, 1.0))
      pModelSpaceModel->transformBy(OdGeMatrix3d::scaling(1.0/dDgnModelScale));

    pDb->startTransaction();

    bool bRemoveEmptyLayouts = true;

    if( !modelSpaceFound || _properties->get_ImportPaperSpaceModels() )
    {
      for( OdDgElementIteratorPtr mi = dgn->getModelTable()->createIterator(); !mi->done(); mi->step())
      {
        if( mi->item() == idModelSpaceModel )
        {
          continue;
        }

        OdDgModelPtr m = mi->item().safeOpenObject();

        if (m->isKindOf(OdDgSheetModel::desc()) && _properties->get_ImportPaperSpaceModels() )
        {
          OdDbObjectId idLayout = copyLayout(m, pDb);

          if( !isInitialized && bRemoveEmptyLayouts && (pDb->appServices()->layoutManager()->countLayouts(pDb) > 2) )
          {
            pDb->appServices()->layoutManager()->deleteLayout(pDb, OD_T("Layout1"));
            pDb->appServices()->layoutManager()->deleteLayout(pDb, OD_T("Layout2"));
            bRemoveEmptyLayouts = false;
          }

          if (bSetActivePaperSpaceLayout && (m == pActiveSpaceModel))
          {
            pDb->appServices()->layoutManager()->setCurrentLayout(pDb, idLayout);
            setLayoutViewport(dgn, idLayout, pActiveSpaceModel);
          }
        }
        else
        {
          if( modelSpaceFound )
          {
            continue;
          }
          
          copyModelSpace(m, pDb);
          modelSpaceFound = true;
        }
      }
    }
    pDb->endTransaction();
    if( !_properties->get_BreakDimensionAssociation() )
    {
      setDimensionAssociation( dgn, pDb);
    }
    else
    {
      OdDgnImportContext::clearDimAssocDescriptors();
    }
  }
  catch (OdError& e)
  {
    OdDgnImportContext::clearDimAssocDescriptors();
    OdDgnImportContext::clearBlockForSharedCellOverrideMap();
    OdDgnImportContext::restoreAfterImport();

    unregisterElementLoaders( svc );
    svc->warning(e);
    return OdDgnImport::fail;
  }
  catch(...)
  {
    unregisterElementLoaders( svc );
    throw;
  }

  OdDgnImportContext::clearBlockForSharedCellOverrideMap();
  OdDgnImportContext::restoreAfterImport();

  unregisterElementLoaders( svc );

  if( !OdDgnImportContext::getInternalImportFlag() )
  {
    if (_properties->get_EraseUnusedResources())
      removeUnusedResources();
    else
      removeUnusedDgnInternalLineStyles(pDb);
  }
 
  resetPreloadFlagFromTestStyles(pDb);
  _properties->put_Database(pDb);
  return OdDgnImport::success;
}

//-----------------------------------------------------------------------------------------------------

OdDgnImportPtr DgnImporter::clone()
{
  OdDgnImportModulePtr pModule = ::odrxDynamicLinker()->loadApp(OdDgnImportModuleName, false);
  return pModule->create();
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::updateLayerVisibilityByLevelMask( const OdDgDatabase* pDg )
{
	if (!OdDgnImportContext::isLevelMask())
		return;

	OdDgLevelTablePtr pLevelTable = pDg->getLevelTable(OdDg::kForRead);
	OdDgElementIteratorPtr pLevelIter = pLevelTable->createIterator();

	for (; !pLevelIter->done(); pLevelIter->step())
	{
		OdDgLevelTableRecordPtr pLevel = pLevelIter->item().openObject(OdDg::kForRead);
		OdDbObjectId idLayer = OdDgnImportContext::getObjectId(pLevelIter->item());

		if (idLayer.isNull())
			continue;

		OdDbLayerTableRecordPtr pLayer = idLayer.openObject(OdDb::kForWrite);

		if( (pLevel->getEntryId() != 0) && (pLevel->getEntryId() != 0x40))
		{
			bool bLayerFrozen = !OdDgnImportContext::checkLevelMask(pLevel->getEntryId(), !pLayer->isFrozen());

     if( !pLayer->isFrozen() || (OdDgnImportContext::getXRefNestedDepth() != 0) )
			  pLayer->setIsFrozen(bLayerFrozen);
		}
	}
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::setLevelVisibilityByLevelMaskMode( OdDgDatabase* pDg )
{
	if (!OdDgnImportContext::getInternalImportFlag())
	{
		if (!_properties->get_ImportPaperSpaceModels())
			OdDgnImportContext::setLevelVisibilityByLevelMask(true);
		else
		{
			bool bAllowToSetLevelVisibilityByLevelMask = true;

			for (OdDgElementIteratorPtr mi = pDg->getModelTable()->createIterator(); !mi->done(); mi->step())
			{
				OdDgModelPtr m = mi->item().safeOpenObject();

				if (m->isKindOf(OdDgSheetModel::desc()))
				{
					bAllowToSetLevelVisibilityByLevelMask = false;
					break;
				}
			}

			OdDgnImportContext::setLevelVisibilityByLevelMask(bAllowToSetLevelVisibilityByLevelMask);
		}
	}
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::createShxFontFromRscFont( const OdString& strFontName )
{
  if( !m_pDgnDb )
  {
    return;
  }

  OdDgnImportContext::createShxFontFromRscFont( strFontName, m_pDgnDb, m_pHostAppServices, _properties->get_shxFontsPath() );
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::registerElementLoaders( OdDbHostAppServices* pHostAppServices )
{
  if( OdDgnImportContext::getInternalImportFlag() )
  {
    return;
  }

  if( !_properties->get_RecomputeDimensionsAfterImport() )
  {
    bReloadRecomputeDim = pHostAppServices->getRecomputeDimBlocksRequired();

    ::odrxDynamicLinker()->unloadModule(OdRecomputeDimBlockModuleName);
    pHostAppServices->setRecomputeDimBlocksRequired(false);
  }

  setImportPEToElements( _properties->get_ExplodeTextNodes() );
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::resetPreloadFlagFromTestStyles(OdDbDatabase* pDb)
{
  if( OdDgnImportContext::getInternalImportFlag() )
    return;

  OdDbObjectId idTextStyleTable = pDb->getTextStyleTableId();

  if (idTextStyleTable.isNull())
    return;

  OdDbTextStyleTablePtr pTextStyleTable = idTextStyleTable.openObject(OdDb::kForWrite);
  OdDbSymbolTableIteratorPtr pIter = pTextStyleTable->newIterator();

  for(; !pIter->done(); pIter->step())
  {
    OdDbTextStyleTableRecordPtr pTextStyle = pIter->getRecord(OdDb::kForWrite);
    bool bBackwards = pTextStyle->isBackwards();
    pTextStyle->setIsBackwards(bBackwards);
  }
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::unregisterElementLoaders( OdDbHostAppServices* pHostAppServices )
{
  if( OdDgnImportContext::getInternalImportFlag() )
  {
    return;
  }

  removeImportPEFromElements();
  clearFileResources();

  if( !_properties->get_RecomputeDimensionsAfterImport() && bReloadRecomputeDim )
  {
    pHostAppServices->setRecomputeDimBlocksRequired(true); 
    ::odrxDynamicLinker()->loadApp(OdRecomputeDimBlockModuleName, false);
  }

  OdDgnImportContext::clearRscFontArray();
  OdDgnImportContext::clearMultilineStyles();
  OdClearFontTable();
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::setImportPEToElements( bool bExplodeTextNode )
{
  static OdStaticRxObject<IgnoredElementImportPE> ignoreImp;
  static OdStaticRxObject<OdDgnImportPE> defaultImporter;
  OdDgElement::desc()->addX(OdDgnImportPE::desc(), &defaultImporter);
  static OdStaticRxObject<OdDgnLine2dImportPE> line2dImp;
  OdDgLine2d::desc()->addX(OdDgnImportPE::desc(), &line2dImp);
  static OdStaticRxObject<OdDgnLine3dImportPE> line3dImp;
  OdDgLine3d::desc()->addX(OdDgnImportPE::desc(), &line3dImp);
  static OdStaticRxObject<OdDgnArc3dImportPE> arc3dImp;
  OdDgArc3d::desc()->addX(OdDgnImportPE::desc(), &arc3dImp);
  static OdStaticRxObject<OdDgnArc2dImportPE> arc2dImp;
  OdDgArc2d::desc()->addX(OdDgnImportPE::desc(), &arc2dImp);
  static OdStaticRxObject<OdDgLineString2dImportPE> linestring2dImp;
  OdDgLineString2d::desc()->addX(OdDgnImportPE::desc(), &linestring2dImp);
  static OdStaticRxObject<OdDgLineString3dImportPE> linestring3dImp;
  OdDgLineString3d::desc()->addX(OdDgnImportPE::desc(), &linestring3dImp);
  static OdStaticRxObject<OdDgSharedCellReferenceImportPE> blockReferenceImp;
  OdDgSharedCellReference::desc()->addX(OdDgnImportPE::desc(), &blockReferenceImp);
  static OdStaticRxObject<OdDgText2dImportPE> text2dImp;
  OdDgText2d::desc()->addX(OdDgnImportPE::desc(), &text2dImp);
  static OdStaticRxObject<OdDgText3dImportPE> text3dImp;
  OdDgText3d::desc()->addX(OdDgnImportPE::desc(), &text3dImp);
  static OdStaticRxObject<OdDgnEllipse2dImportPE> ellipse2dImp;
  OdDgEllipse2d::desc()->addX(OdDgnImportPE::desc(), &ellipse2dImp);
  static OdStaticRxObject<OdDgnEllipse3dImportPE> ellipse3dImp;
  OdDgEllipse3d::desc()->addX(OdDgnImportPE::desc(), &ellipse3dImp);
  static OdStaticRxObject<OdDgMeshFaceLoopsImportPE> meshFaceLoopsImp;
  OdDgMeshFaceLoops::desc()->addX(OdDgnImportPE::desc(), &meshFaceLoopsImp);
  OdDgMeshPointCloud::desc()->addX(OdDgnImportPE::desc(), &ignoreImp);
  static OdStaticRxObject<OdDgMeshTriangleListImportPE> meshTriangleListImp;
  OdDgMeshTriangleList::desc()->addX(OdDgnImportPE::desc(), &meshTriangleListImp);
  static OdStaticRxObject<OdDgMeshQuadListImportPE> meshQuadListImp;
  OdDgMeshQuadList::desc()->addX(OdDgnImportPE::desc(), &meshQuadListImp);
  static OdStaticRxObject<OdDgMeshTriangleGridImportPE> meshTriangleGridImp;
  OdDgMeshTriangleGrid::desc()->addX(OdDgnImportPE::desc(), &meshTriangleGridImp);
  static OdStaticRxObject<OdDgMeshQuadGridImportPE> meshQuadGridImp;
  OdDgMeshQuadGrid::desc()->addX(OdDgnImportPE::desc(), &meshQuadGridImp);
  static OdStaticRxObject<OdDgBSplineCurveImportPE<OdDgBSplineCurve2d> > bspline2dImp;
  OdDgBSplineCurve2d::desc()->addX(OdDgnImportPE::desc(), &bspline2dImp);
  static OdStaticRxObject<OdDgBSplineCurveImportPE<OdDgBSplineCurve3d> > bspline3dImp;
  OdDgBSplineCurve3d::desc()->addX(OdDgnImportPE::desc(), &bspline3dImp);
  static OdStaticRxObject<OdDgTagImportPE> tagImp;
  OdDgTagElement::desc()->addX(OdDgnImportPE::desc(), &tagImp);
  static OdStaticRxObject<OdDgOle2FrameImportPE<OdDgOle2Frame2d> > ole2Frame2dImp;
  OdDgOle2Frame2d::desc()->addX(OdDgnImportPE::desc(), &ole2Frame2dImp);
  static OdStaticRxObject<OdDgOle2FrameImportPE<OdDgOle2Frame3d> > ole2Frame3dImp;
  OdDgOle2Frame3d::desc()->addX(OdDgnImportPE::desc(), &ole2Frame3dImp);
  static OdStaticRxObject<OdDgRasterFrameImportPE> rasterImp;
  OdDgRasterFrame::desc()->addX(OdDgnImportPE::desc(), &rasterImp);
  static OdStaticRxObject<OdDgRasterHeader2dImportPE> rasterHeader2dImp;
  OdDgRasterHeader2d::desc()->addX(OdDgnImportPE::desc(), &rasterHeader2dImp);
  static OdStaticRxObject<OdDgRasterHeader3dImportPE> rasterHeader3dImp;
  OdDgRasterHeader3d::desc()->addX(OdDgnImportPE::desc(), &rasterHeader3dImp);
  static OdStaticRxObject<OdDgnRasterAttachmentImportPE> rasterHeaderImp;
  OdDgRasterAttachmentHeader::desc()->addX(OdDgnImportPE::desc(), &rasterHeaderImp);
  static OdStaticRxObject<OdDgnCellHeaderImportPE<OdDgCellHeader2d> > cellHeader2dImp;
  OdDgCellHeader2d::desc()->addX(OdDgnImportPE::desc(), &cellHeader2dImp);
  static OdStaticRxObject<OdDgnCellHeaderImportPE<OdDgCellHeader3d> > cellHeader3dImp;
  OdDgCellHeader3d::desc()->addX(OdDgnImportPE::desc(), &cellHeader3dImp);
  static OdStaticRxObject<OdDgReferenceAttachmentImportPE> referenceAttachmentImp;
  OdDgReferenceAttachmentHeader::desc()->addX(OdDgnImportPE::desc(), &referenceAttachmentImp);  
  static OdStaticRxObject<OdDgShapeImportPE<OdDgShape2d> > shape2dImp;
  OdDgShape2d::desc()->addX(OdDgnImportPE::desc(), &shape2dImp);
  static OdStaticRxObject<OdDgShapeImportPE<OdDgShape3d> > shape3dImp;
  OdDgShape3d::desc()->addX(OdDgnImportPE::desc(), &shape3dImp); 
  static OdStaticRxObject<OdDgComplexShapeImportPE> complexShapeImp;
  OdDgComplexShape::desc()->addX(OdDgnImportPE::desc(), &complexShapeImp); 
  static OdStaticRxObject<OdDgComplexStringImportPE> complexStringImp;
  OdDgComplexString::desc()->addX(OdDgnImportPE::desc(), &complexStringImp); 
  static OdStaticRxObject<OdDgnSolidImportPE> solidImp;
  OdDgSolid::desc()->addX(OdDgnImportPE::desc(), &solidImp); 
  static OdStaticRxObject<OdDgnSurfaceImportPE> surfaceImp;
  OdDgSurface::desc()->addX(OdDgnImportPE::desc(), &surfaceImp);
  static OdStaticRxObject<OdDgCurveImportPE<OdDgCurve2d> > curve2dImp;
  OdDgCurve2d::desc()->addX(OdDgnImportPE::desc(), &curve2dImp);
  static OdStaticRxObject<OdDgCurveImportPE<OdDgCurve3d> > curve3dImp;
  OdDgCurve3d::desc()->addX(OdDgnImportPE::desc(), &curve3dImp);
  static OdStaticRxObject<OdDgnBSplineSurfaceImportPE> bSplineSurfaceImp;
  OdDgBSplineSurface::desc()->addX(OdDgnImportPE::desc(), &bSplineSurfaceImp);
  static OdStaticRxObject<OdDgnConeImportPE> coneImp;
  OdDgCone::desc()->addX(OdDgnImportPE::desc(), &coneImp);

  if( !bExplodeTextNode )
  {
    static OdStaticRxObject<OdDgnTextNodeImportPE<OdDgTextNode2d> > textNode2dImp;
    OdDgTextNode2d::desc()->addX(OdDgnImportPE::desc(), &textNode2dImp);
    static OdStaticRxObject<OdDgnTextNodeImportPE<OdDgTextNode3d> > textNode3dImp;
    OdDgTextNode3d::desc()->addX(OdDgnImportPE::desc(), &textNode3dImp);
  }
  else
  {
    static OdStaticRxObject<OdDgnComplexElementImportPE<OdDgTextNode3d> > textNode3dImp;
    OdDgTextNode3d::desc()->addX(OdDgnImportPE::desc(), &textNode3dImp);
    static OdStaticRxObject<OdDgnComplexElementImportPE<OdDgTextNode2d> > textNode2dImp;
    OdDgTextNode2d::desc()->addX(OdDgnImportPE::desc(), &textNode2dImp);
  }

  static OdStaticRxObject<OdDgnLinearDimensionImportPE> dimensionLinearImp;
  OdDgDimSizeArrow::desc()->addX(OdDgnImportPE::desc(), &dimensionLinearImp);
  OdDgDimSizeStroke::desc()->addX(OdDgnImportPE::desc(), &dimensionLinearImp);
  OdDgDimSingleLocation::desc()->addX(OdDgnImportPE::desc(), &dimensionLinearImp);
  OdDgDimCustomLinear::desc()->addX(OdDgnImportPE::desc(), &dimensionLinearImp);
  OdDgDimStackedLocation::desc()->addX(OdDgnImportPE::desc(), &dimensionLinearImp);

  static OdStaticRxObject<OdDgnAngularDimensionImportPE> dimensionAngularImp;
  OdDgDimAngleSize::desc()->addX(OdDgnImportPE::desc(), &dimensionAngularImp);
  OdDgDimArcSize::desc()->addX(OdDgnImportPE::desc(), &dimensionAngularImp);
  OdDgDimAngleLocation::desc()->addX(OdDgnImportPE::desc(), &dimensionAngularImp);
  OdDgDimArcLocation::desc()->addX(OdDgnImportPE::desc(), &dimensionAngularImp);
  OdDgDimAngleLines::desc()->addX(OdDgnImportPE::desc(), &dimensionAngularImp);
  OdDgDimAngleAxisX::desc()->addX(OdDgnImportPE::desc(), &dimensionAngularImp);
  OdDgDimAngleAxisY::desc()->addX(OdDgnImportPE::desc(), &dimensionAngularImp);

  static OdStaticRxObject<OdDgnDiameterPerpDimensionImportPE> dimensionDiamPerpImp;
  OdDgDimDiameterPerpendicular::desc()->addX(OdDgnImportPE::desc(), &dimensionDiamPerpImp);

  static OdStaticRxObject<OdDgnDiameterParallelDimensionImportPE> dimensionDiamParallelImp;
  OdDgDimDiameterParallel::desc()->addX(OdDgnImportPE::desc(), &dimensionDiamParallelImp);

  static OdStaticRxObject<OdDgnDiameterDimensionImportPE> dimensionDiamImp;
  OdDgDimDiameter::desc()->addX(OdDgnImportPE::desc(), &dimensionDiamImp);
  OdDgDimDiameterExtended::desc()->addX(OdDgnImportPE::desc(), &dimensionDiamImp);

  static OdStaticRxObject<OdDgnRadiusDimensionImportPE> dimensionRadiusImp;
  OdDgDimRadius::desc()->addX(OdDgnImportPE::desc(), &dimensionRadiusImp);
  OdDgDimRadiusExtended::desc()->addX(OdDgnImportPE::desc(), &dimensionRadiusImp);

  static OdStaticRxObject<OdDgnOrdinateDimensionImportPE> dimensionOrdinateImp;
  OdDgDimOrdinate::desc()->addX(OdDgnImportPE::desc(), &dimensionOrdinateImp);

  static OdStaticRxObject<OdDgnCenterMarkDimensionImportPE> dimensionCenterMarkImp;
  OdDgDimCenter::desc()->addX(OdDgnImportPE::desc(), &dimensionCenterMarkImp);

  static OdStaticRxObject<OdDgnLabelLineDimensionImportPE> dimensionLabelLineImp;
  OdDgDimLabelLine::desc()->addX(OdDgnImportPE::desc(), &dimensionLabelLineImp);

  static OdStaticRxObject<OdDgnNoteDimensionImportPE> dimensionNoteImp;
  OdDgDimNote::desc()->addX(OdDgnImportPE::desc(), &dimensionNoteImp);

  static OdStaticRxObject<OdDgnMultilineImportPE> multilineImpl;
  OdDgMultiline::desc()->addX(OdDgnImportPE::desc(), &multilineImpl);

  static OdStaticRxObject<OdDgnPointLightImportPE> pointLightImpl;
  OdDgLightPoint::desc()->addX(OdDgnImportPE::desc(), &pointLightImpl);

  static OdStaticRxObject<OdDgnDirectionLightImportPE> directionLightImpl;
  OdDgLightDistant::desc()->addX(OdDgnImportPE::desc(), &directionLightImpl);

  static OdStaticRxObject<OdDgnSpotLightImportPE> spotLightImpl;
  OdDgLightSpot::desc()->addX(OdDgnImportPE::desc(), &spotLightImpl);

  static OdStaticRxObject<OdDgnAreaLightImportPE> areaLightImpl;
  OdDgLightArea::desc()->addX(OdDgnImportPE::desc(), &areaLightImpl);

  static OdStaticRxObject<OdDgnTableElementImportPE> tableElementImp;
  OdDgTableElement::desc()->addX(OdDgnImportPE::desc(), &tableElementImp);

  static OdStaticRxObject<OdDgnProxyGraphicsElementImportPE> proxyElementImp;
  OdDgProxyGraphicsElement::desc()->addX(OdDgnImportPE::desc(), &proxyElementImp);
  OdDgComplexProxyGraphicsElement::desc()->addX(OdDgnImportPE::desc(), &proxyElementImp);
  OdDgExtendedGraphicsElement::desc()->addX(OdDgnImportPE::desc(), &proxyElementImp);

  static OdStaticRxObject<OdDgnGeoDataImportPE> geoDataElementImp;
  OdDgGeoDataInfo::desc()->addX(OdDgnImportPE::desc(), &geoDataElementImp);
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::removeImportPEFromElements()
{
  OdDgElement::desc()->delX(OdDgnImportPE::desc());
  OdDgLine2d::desc()->delX(OdDgnImportPE::desc());
  OdDgLine3d::desc()->delX(OdDgnImportPE::desc());
  OdDgArc3d::desc()->delX(OdDgnImportPE::desc());
  OdDgArc2d::desc()->delX(OdDgnImportPE::desc());
  OdDgLineString2d::desc()->delX(OdDgnImportPE::desc());
  OdDgLineString3d::desc()->delX(OdDgnImportPE::desc());
  OdDgSharedCellReference::desc()->delX(OdDgnImportPE::desc());
  OdDgText2d::desc()->delX(OdDgnImportPE::desc());
  OdDgText3d::desc()->delX(OdDgnImportPE::desc());
  OdDgEllipse2d::desc()->delX(OdDgnImportPE::desc());
  OdDgEllipse3d::desc()->delX(OdDgnImportPE::desc());
  OdDgMeshFaceLoops::desc()->delX(OdDgnImportPE::desc());
  OdDgMeshPointCloud::desc()->delX(OdDgnImportPE::desc());
  OdDgMeshTriangleList::desc()->delX(OdDgnImportPE::desc());
  OdDgMeshQuadList::desc()->delX(OdDgnImportPE::desc());
  OdDgMeshTriangleGrid::desc()->delX(OdDgnImportPE::desc());
  OdDgMeshQuadGrid::desc()->delX(OdDgnImportPE::desc());
  OdDgBSplineCurve3d::desc()->delX(OdDgnImportPE::desc());
  OdDgBSplineCurve2d::desc()->delX(OdDgnImportPE::desc());
  OdDgTagElement::desc()->delX(OdDgnImportPE::desc());
  OdDgOle2Frame2d::desc()->delX(OdDgnImportPE::desc());
  OdDgOle2Frame3d::desc()->delX(OdDgnImportPE::desc());
  OdDgTextNode3d::desc()->delX(OdDgnImportPE::desc());
  OdDgTextNode2d::desc()->delX(OdDgnImportPE::desc());
  OdDgRasterFrame::desc()->delX(OdDgnImportPE::desc());
  OdDgRasterHeader2d::desc()->delX(OdDgnImportPE::desc());
  OdDgRasterHeader3d::desc()->delX(OdDgnImportPE::desc());
  OdDgRasterAttachmentHeader::desc()->delX(OdDgnImportPE::desc());
  OdDgCellHeader2d::desc()->delX(OdDgnImportPE::desc());
  OdDgCellHeader3d::desc()->delX(OdDgnImportPE::desc());
  OdDgShape2d::desc()->delX(OdDgnImportPE::desc());
  OdDgShape3d::desc()->delX(OdDgnImportPE::desc());
  OdDgSolid::desc()->delX(OdDgnImportPE::desc());
  OdDgSurface::desc()->delX(OdDgnImportPE::desc());
  OdDgReferenceAttachmentHeader::desc()->delX(OdDgnImportPE::desc());
  OdDgComplexShape::desc()->delX(OdDgnImportPE::desc());
  OdDgComplexString::desc()->delX(OdDgnImportPE::desc());
  OdDgDimSizeArrow::desc()->delX(OdDgnImportPE::desc());
  OdDgDimSizeStroke::desc()->delX(OdDgnImportPE::desc());
  OdDgDimSingleLocation::desc()->delX(OdDgnImportPE::desc());
  OdDgDimCustomLinear::desc()->delX(OdDgnImportPE::desc());
  OdDgDimStackedLocation::desc()->delX(OdDgnImportPE::desc());
  OdDgDimAngleSize::desc()->delX(OdDgnImportPE::desc());
  OdDgDimArcSize::desc()->delX(OdDgnImportPE::desc());
  OdDgDimAngleLocation::desc()->delX(OdDgnImportPE::desc());
  OdDgDimArcLocation::desc()->delX(OdDgnImportPE::desc());
  OdDgDimAngleLines::desc()->delX(OdDgnImportPE::desc());
  OdDgDimAngleAxisX::desc()->delX(OdDgnImportPE::desc());
  OdDgDimAngleAxisY::desc()->delX(OdDgnImportPE::desc());
  OdDgDimDiameterPerpendicular::desc()->delX(OdDgnImportPE::desc());
  OdDgDimDiameterParallel::desc()->delX(OdDgnImportPE::desc());
  OdDgDimDiameter::desc()->delX(OdDgnImportPE::desc());
  OdDgDimRadius::desc()->delX(OdDgnImportPE::desc());
  OdDgDimDiameterExtended::desc()->delX(OdDgnImportPE::desc());
  OdDgDimRadiusExtended::desc()->delX(OdDgnImportPE::desc());
  OdDgDimOrdinate::desc()->delX(OdDgnImportPE::desc());
  OdDgDimCenter::desc()->delX(OdDgnImportPE::desc());
  OdDgDimLabelLine::desc()->delX(OdDgnImportPE::desc());
  OdDgDimNote::desc()->delX(OdDgnImportPE::desc());
  OdDgMultiline::desc()->delX(OdDgnImportPE::desc());
  OdDgCurve3d::desc()->delX(OdDgnImportPE::desc());
  OdDgCurve2d::desc()->delX(OdDgnImportPE::desc());
  OdDgLightPoint::desc()->delX(OdDgnImportPE::desc());
  OdDgLightArea::desc()->delX(OdDgnImportPE::desc());
  OdDgLightDistant::desc()->delX(OdDgnImportPE::desc());
  OdDgLightSpot::desc()->delX(OdDgnImportPE::desc());
  OdDgTableElement::desc()->delX(OdDgnImportPE::desc());
  OdDgBSplineSurface::desc()->delX(OdDgnImportPE::desc());
  OdDgCone::desc()->delX(OdDgnImportPE::desc());
  OdDgProxyGraphicsElement::desc()->delX(OdDgnImportPE::desc());
  OdDgComplexProxyGraphicsElement::desc()->delX(OdDgnImportPE::desc());
  OdDgExtendedGraphicsElement::desc()->delX(OdDgnImportPE::desc());
  OdDgGeoDataInfo::desc()->delX(OdDgnImportPE::desc());
}

//-----------------------------------------------------------------------------------------------------

bool DgnImporter::setTextNodeToMTextImportPE()
{
  bool bRet = _properties->get_ExplodeTextNodes();

  if( bRet )
  {
    OdDgTextNode3d::desc()->delX(OdDgnImportPE::desc());
    OdDgTextNode2d::desc()->delX(OdDgnImportPE::desc());

    static OdStaticRxObject<OdDgnTextNodeImportPE<OdDgTextNode2d> > textNode2dToMTextImp;
    OdDgTextNode2d::desc()->addX(OdDgnImportPE::desc(), &textNode2dToMTextImp);
    static OdStaticRxObject<OdDgnTextNodeImportPE<OdDgTextNode3d> > textNode3dToMTextImp;
    OdDgTextNode3d::desc()->addX(OdDgnImportPE::desc(), &textNode3dToMTextImp);
  }

  return bRet;
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::setTextNodeToEntitySetImportPE()
{
  OdDgTextNode3d::desc()->delX(OdDgnImportPE::desc());
  OdDgTextNode2d::desc()->delX(OdDgnImportPE::desc());

  static OdStaticRxObject<OdDgnComplexElementImportPE<OdDgTextNode3d> > textNode3dToEntitySetImp;
  OdDgTextNode3d::desc()->addX(OdDgnImportPE::desc(), &textNode3dToEntitySetImp);
  static OdStaticRxObject<OdDgnComplexElementImportPE<OdDgTextNode2d> > textNode2dToEntitySetImp;
  OdDgTextNode2d::desc()->addX(OdDgnImportPE::desc(), &textNode2dToEntitySetImp);
}

//-----------------------------------------------------------------------------------------------------

void DgnImporter::setDimensionAssociation( OdDgDatabase* pDg, OdDbDatabase* pDb )
{
  OdUInt32 nDimensionToUpdateAssoc = OdDgnImportContext::getDimAssocDescriptorCount();

  for( OdUInt32 i = 0; i < nDimensionToUpdateAssoc; i++ )
  {
    OdDbObjectId                  idDimension;
    OdDgnImportDimAssocDescriptor assocDiscr;

    OdDgnImportContext::getDimAssocDescriptor( i, idDimension, assocDiscr );

    OdDbDimensionPtr pDimension = idDimension.openObject(OdDb::kForWrite);

    if( !pDimension.isNull() )
    {
      if( pDimension->isKindOf(OdDbRotatedDimension::desc()) )
      {
        createLinearDimensionAssoc( pDimension, assocDiscr, pDg );
      }
      else if( pDimension->isKindOf(OdDb3PointAngularDimension::desc()) ||
               pDimension->isKindOf(OdDbArcDimension::desc())
             )
      {
        createAngularDimensionAssoc( pDimension, assocDiscr, pDg );
      }
      else if( pDimension->isKindOf(OdDbRadialDimension::desc()) ||
               pDimension->isKindOf(OdDbDiametricDimension::desc())
             )
      {
        createRadialDimensionAssoc( pDimension, assocDiscr, pDg );
      }
      else if( pDimension->isKindOf(OdDbOrdinateDimension::desc()) )
      {
        createOrdinateDimensionAssoc( pDimension, assocDiscr, pDg );
      }
    }
  }

  OdDgnImportContext::clearDimAssocDescriptors();
}

//-----------------------------------------------------------------------------------------------------

OdDb::LineWeight DgnImporter::getLineWeightByDgnIndex( OdUInt32 uIndex )
{
  OdDgnImportLineWeightsMapPtr pLWMap = _properties->get_LineWeightsMap();
  return pLWMap->getLineWeightByDgnIndex( uIndex );
}

//-----------------------------------------------------------------------------------------------------

OdString DgnImporter::getTrueTypeFontNameByRscFontName(const OdString& strRscFontName) const
{
  OdDgnImportRscFontExchangeMapPtr pFontMap = _properties->get_RscFontExchangeMap();
  return pFontMap->getTrueTypeFontByRscFont(strRscFontName);
}

//-----------------------------------------------------------------------------------------------------

OdRxDictionaryPtr DgnProperties::createObject()
{
  return OdRxObjectImpl<DgnProperties, OdRxDictionary>::createObject();
}

ODRX_DECLARE_PROPERTY(DgnPath)
ODRX_DECLARE_PROPERTY(DgnDatabase)
ODRX_DECLARE_PROPERTY(Database)
ODRX_DECLARE_PROPERTY(Services)
ODRX_DECLARE_PROPERTY(DgnServices)
ODRX_DECLARE_PROPERTY(ImportActiveModelToModelSpace)
ODRX_DECLARE_PROPERTY(ImportPaperSpaceModels)
ODRX_DECLARE_PROPERTY(XRefImportMode)
ODRX_DECLARE_PROPERTY(ExplodeTextNodes)
ODRX_DECLARE_PROPERTY(RecomputeDimensionsAfterImport)
ODRX_DECLARE_PROPERTY(MS_SYMBRSRC)
ODRX_DECLARE_PROPERTY(DontImportInvisibleElements)
ODRX_DECLARE_PROPERTY(ImportViewIndex)
ODRX_DECLARE_PROPERTY( 3dEllipseImportMode )
ODRX_DECLARE_PROPERTY( 2dEllipseImportMode )
ODRX_DECLARE_PROPERTY( 3dShapeImportMode )
ODRX_DECLARE_PROPERTY( 2dShapeImportMode )
ODRX_DECLARE_PROPERTY( 3dObjectImportMode )
ODRX_DECLARE_PROPERTY( 3dClosedBSplineCurveImportMode )
ODRX_DECLARE_PROPERTY( 2dClosedBSplineCurveImportMode )
ODRX_DECLARE_PROPERTY( shxFontsPath )
ODRX_DECLARE_PROPERTY( dgnFastFont )
ODRX_DECLARE_PROPERTY( BreakDimensionAssociation )
ODRX_DECLARE_PROPERTY( LineStyleImporter )
ODRX_DECLARE_PROPERTY( LineWeightsMap )
ODRX_DECLARE_PROPERTY( ConvertDgnColorIndicesToTrueColors )
ODRX_DECLARE_PROPERTY( ConvertEmptyDataFieldsToSpaces )
ODRX_DECLARE_PROPERTY( EraseUnusedResources )
ODRX_DECLARE_PROPERTY( ImportDgTextsAsDbMTexts )
ODRX_DECLARE_PROPERTY( CropXRefExtraClipByExtents )
ODRX_DECLARE_PROPERTY( EnableDgnFileMTLoading )
ODRX_DECLARE_PROPERTY( ShowNewXRefLevels )
ODRX_DECLARE_PROPERTY( ConvertFilledRscFonts )
ODRX_DECLARE_PROPERTY( RscFontExchangeMap)
ODRX_DECLARE_PROPERTY( UnderlineTextDataFields)
ODRX_DECLARE_PROPERTY( ViewportImportMode)
ODRX_DECLARE_PROPERTY( SupportPriorityFor2dElements )
ODRX_DECLARE_PROPERTY( KeepComplexStringInvisibleItems )
ODRX_DECLARE_PROPERTY( MaxXRefNumberToKeepInMemory )

ODRX_DEFINE_PROPERTY(DgnPath, DgnProperties, getString)
ODRX_DEFINE_PROPERTY_OBJECT(DgnDatabase, DgnProperties,  get_DgnDatabase, put_DgnDatabase, OdDgDatabase)
ODRX_DEFINE_PROPERTY_OBJECT(Database, DgnProperties,  get_Database, put_Database, OdDbDatabase)
ODRX_DEFINE_PROPERTY_OBJECT(Services, DgnProperties,  get_Services, put_Services, OdDbHostAppServices)
ODRX_DEFINE_PROPERTY_OBJECT(DgnServices, DgnProperties,  get_DgnServices, put_DgnServices, OdDgHostAppServices)
ODRX_DEFINE_PROPERTY(XRefImportMode, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(ExplodeTextNodes, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(ImportDgTextsAsDbMTexts, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(RecomputeDimensionsAfterImport, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(ImportPaperSpaceModels, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(ImportActiveModelToModelSpace, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(MS_SYMBRSRC, DgnProperties, getStringArray)
ODRX_DEFINE_PROPERTY(DontImportInvisibleElements, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(ImportViewIndex, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(3dEllipseImportMode, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(2dEllipseImportMode, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(3dShapeImportMode, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(3dObjectImportMode, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(2dShapeImportMode, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(3dClosedBSplineCurveImportMode, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(2dClosedBSplineCurveImportMode, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(shxFontsPath, DgnProperties, getString)
ODRX_DEFINE_PROPERTY(dgnFastFont, DgnProperties, getString)
ODRX_DEFINE_PROPERTY(BreakDimensionAssociation, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY_OBJECT(LineStyleImporter, DgnProperties,  get_LineStyleImporter, put_LineStyleImporter, OdDgnImportLineStyle)
ODRX_DEFINE_PROPERTY_OBJECT(LineWeightsMap, DgnProperties,  get_LineWeightsMap, put_LineWeightsMap, OdDgnImportLineWeightsMap)
ODRX_DEFINE_PROPERTY(ConvertDgnColorIndicesToTrueColors, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(ConvertEmptyDataFieldsToSpaces, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(EraseUnusedResources, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(CropXRefExtraClipByExtents, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(EnableDgnFileMTLoading, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(ShowNewXRefLevels, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(ConvertFilledRscFonts, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY_OBJECT(RscFontExchangeMap, DgnProperties, get_RscFontExchangeMap, put_RscFontExchangeMap, OdDgnImportRscFontExchangeMap)
ODRX_DEFINE_PROPERTY(UnderlineTextDataFields, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(ViewportImportMode, DgnProperties, getInt8)
ODRX_DEFINE_PROPERTY(SupportPriorityFor2dElements, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(KeepComplexStringInvisibleItems, DgnProperties, getBool)
ODRX_DEFINE_PROPERTY(MaxXRefNumberToKeepInMemory, DgnProperties, getInt8)

ODRX_BEGIN_DYNAMIC_PROPERTY_MAP( DgnProperties );
  ODRX_GENERATE_PROPERTY( DgnPath )
  ODRX_GENERATE_PROPERTY( DgnDatabase )
  ODRX_GENERATE_PROPERTY( Database )
  ODRX_GENERATE_PROPERTY( Services )
  ODRX_GENERATE_PROPERTY( DgnServices )
  ODRX_GENERATE_PROPERTY( ImportActiveModelToModelSpace )
  ODRX_GENERATE_PROPERTY( ImportPaperSpaceModels )
  ODRX_GENERATE_PROPERTY( XRefImportMode )
  ODRX_GENERATE_PROPERTY( ExplodeTextNodes )
  ODRX_GENERATE_PROPERTY( ImportDgTextsAsDbMTexts )
  ODRX_GENERATE_PROPERTY( RecomputeDimensionsAfterImport )
  ODRX_GENERATE_PROPERTY( MS_SYMBRSRC )
  ODRX_GENERATE_PROPERTY( DontImportInvisibleElements )
  ODRX_GENERATE_PROPERTY( ImportViewIndex )
  ODRX_GENERATE_PROPERTY( 3dEllipseImportMode )
  ODRX_GENERATE_PROPERTY( 2dEllipseImportMode )
  ODRX_GENERATE_PROPERTY( 3dShapeImportMode )
  ODRX_GENERATE_PROPERTY( 3dObjectImportMode )
  ODRX_GENERATE_PROPERTY( 2dShapeImportMode )
  ODRX_GENERATE_PROPERTY( 3dClosedBSplineCurveImportMode )
  ODRX_GENERATE_PROPERTY( 2dClosedBSplineCurveImportMode )
  ODRX_GENERATE_PROPERTY( shxFontsPath )
  ODRX_GENERATE_PROPERTY( dgnFastFont )
  ODRX_GENERATE_PROPERTY( BreakDimensionAssociation )
  ODRX_GENERATE_PROPERTY( LineStyleImporter )
  ODRX_GENERATE_PROPERTY( LineWeightsMap )
  ODRX_GENERATE_PROPERTY( ConvertDgnColorIndicesToTrueColors )
  ODRX_GENERATE_PROPERTY( ConvertEmptyDataFieldsToSpaces )
  ODRX_GENERATE_PROPERTY( EraseUnusedResources )  
  ODRX_GENERATE_PROPERTY( CropXRefExtraClipByExtents )
  ODRX_GENERATE_PROPERTY( EnableDgnFileMTLoading )  
  ODRX_GENERATE_PROPERTY( ShowNewXRefLevels )
  ODRX_GENERATE_PROPERTY( ConvertFilledRscFonts )
  ODRX_GENERATE_PROPERTY( RscFontExchangeMap )
  ODRX_GENERATE_PROPERTY( UnderlineTextDataFields )
  ODRX_GENERATE_PROPERTY( ViewportImportMode )
  ODRX_GENERATE_PROPERTY( SupportPriorityFor2dElements )
  ODRX_GENERATE_PROPERTY( KeepComplexStringInvisibleItems )
  ODRX_GENERATE_PROPERTY( MaxXRefNumberToKeepInMemory )
ODRX_END_DYNAMIC_PROPERTY_MAP( DgnProperties );

DgnImporter::DgnImporter() : _properties( DgnProperties::createObject() )
{
  bReloadRecomputeDim = true;
}

OdRxDictionaryPtr DgnImporter::properties() { return _properties; }

OdDgnImportLineStylePtr g_pDgnImportLS;

class DgnImportModule : public OdDgnImportModule
{
  OdRxModulePtr m_pDGNDirect;
  OdRxModulePtr m_pDgnLS;

public:
  virtual void initApp()
  {
    m_pDGNDirect = ::odrxDynamicLinker()->loadModule(OdDgnDbModuleName);
    OdDgnImportPE::rxInit();
    m_pDgnLS = ::odrxDynamicLinker()->loadModule(OdDgnLSModuleName);

    g_pDgnImportLS = OdRxObjectImpl<OdDgnImportLineStyleImpl>::createObject();
  }
  virtual void uninitApp()
  {
    m_pDGNDirect.release();
    ::odrxDynamicLinker()->unloadModule(OdDgnDbModuleName);
    OdDgnImportPE::rxUninit();
    m_pDgnLS.release();

    g_pDgnImportLS.release();
  }
  
  virtual OdDgnImportPtr create ()
  {
      return OdRxObjectImpl<DgnImporter>::createObject();
  }
};
}
using namespace TD_DGN_IMPORT;
ODRX_DEFINE_DYNAMIC_MODULE(DgnImportModule)