/////////////////////////////////////////////////////////////////////////////// 
// 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 _EX_DGNDUMPER_H_
#define _EX_DGNDUMPER_H_

#include "OdaCommon.h"
#include "RxObject.h"

#include "Gi/GiDrawable.h"
#include "RxVariant.h"
#include "DgDatabase.h"
#include "DgLine.h"
#include "DgLineString.h"
#include "DgText.h"
#include "DgTextNode.h"
#include "DgShape.h"
#include "DgCurve.h"
#include "DgEllipse.h"
#include "DgArc.h"
#include "DgCone.h"
#include "DgComplexString.h"
#include "DgComplexShape.h"
#include "DgPointString.h"
#include "DgDimension.h"
#include "DgMultiline.h"
#include "DgBSplineCurve.h"
#include "Dg3DObject.h"
#include "DgRasterAttach.h"
#include "DgRaster.h"
#include "DgTagElement.h"
#include "DgCellHeader.h"
#include "DgBSplineSurface.h"
#include "DgLevelTableRecord.h"
#include "DgFontTableRecord.h"
#include "DgTextStyleTableRecord.h"
#include "DgDimStyleTableRecord.h"
#include "DgMultilineStyleTableRecord.h"
#include "DgLineStyleTableRecord.h"
#include "DgLineStyleDefTableRecord.h"
#include "DgRegAppTableRecord.h"
#include "DgView.h"
#include "DgSharedCellDefinition.h"
#include "DgSharedCellReference.h"
#include "DgTagSetDefinition.h"
#include "DgReferenceAttach.h"
#include "Ge/GeExtents3d.h"
#include "DgAttributeLinkage.h"
#include "DgRasterFrame.h"
#include "DgOle2Frame.h"
#include "DgNamedGroup.h"
#include "DgRasterAttach.h"
#include "DgElementTemplate.h"
#include "DgEnvironmentMap.h"
#include "Gi/GiMaterial.h"
#include "DgMaterialTableRecord.h"
#include "Ge/GeScale2d.h"
#include "Ge/GeScale3d.h"
#include "DgXAttribute.h"
#include "DgDisplayStyle.h"
#include "DgTerrain.h"
#include "DgItemTypeLibrary.h"
#include "DgPrintStyleTableRecord.h"
#include "DgLine.h"
#include "DgECSchema.h"
#include "DgGeoData.h"
#include "DgFeatureSolidNode.h"

/** \details
  Library: Source code provided.
  <group Dg_Extension_Classes>
*/
class TG_EXPORT OdExDgnDumper
{
public:

  virtual void dumpFieldName( const OdString& fieldName ) = 0;
  virtual void dumpFieldValue( const OdString& fieldName ) = 0;

  // output for different types
  inline void writeFieldValue( const OdString& name, const OdString& value );
  inline void writeFieldValue( const OdString& name, OdUInt16 value );
  inline void writeFieldValueHex( const OdString& name, OdUInt16 value );
  inline void writeFieldValue( const OdString& name, OdUInt32 value );
  inline void writeFieldValueHex( const OdString& name, OdUInt32 value );
  inline void writeFieldValue( const OdString& name, double value );
  inline void writeFieldValue( const OdString& name, OdGePoint2d const& value );
  inline void writeFieldValue( const OdString& name, OdGePoint3d const& value );
  inline void writeFieldValue( const OdString& name, OdGeVector2d const& value );
  inline void writeFieldValue( const OdString& name, OdGeVector3d const& value );
  inline void writeFieldValue( const OdString& name, OdCmEntityColor const& value );
  inline void writeFieldValue( const OdString& name, OdDgLineStyleInfo const& value );
  inline void writeFieldValue( const OdString& name, OdUInt64 value );
  inline void writeFieldValueHex( const OdString& name, OdUInt64 value );
  inline void writeFieldValue( const OdString& name, OdUInt8 value );
  inline void writeFieldValueHex( const OdString& name, OdUInt8 value );
  inline void writeFieldValue( const OdString& name, OdDgLightColor const& value );
  inline void writeFieldValue( const OdString& name, bool value );
  inline void writeFieldValue( const OdString& name, OdAngleCoordinate const& value );
  inline void writeFieldValue( const OdString& name, OdInt16 value );
#if defined(ANDROID)
  inline void writeFieldValue( const OdString& name, OdChar value );
#endif
  inline void writeFieldValue( const OdString& name, OdInt32 value );
#if !(defined(ODA_UNIXOS) && (OD_SIZEOF_LONG == 8))
  inline void writeFieldValue( const OdString& name, int value );
#endif
  inline void writeFieldValue( const OdString& name, OdInt64 value );
  inline void writeFieldValue( const OdString& name, OdDgModel::WorkingUnit value );
  inline void writeFieldValue( const OdString& name, OdDg::TextJustification value );
  inline void writeFieldValue( const OdString& name, OdGeQuaternion const& value );
  //void writeFieldValue( const OdString& name, TextAttributes const& value );
  inline void writeFieldValue( const OdString& name, OdDgGraphicsElement::Class value );
  inline void writeFieldValue( const OdString& name, OdGeMatrix2d const& value );
  //void writeFieldValue( const OdString& name, OdDgDimension::ToolType value );
  inline void writeFieldValue( const OdString& name, OdDgDimPoint& value );
  inline void writeFieldValue( const OdString& name, OdDgDimTextInfo const& value );
  inline void writeFieldValue( const OdString& name, OdDgDimTextFormat const& value );
  inline void writeFieldValue( const OdString& name, OdDgDimTextFormat::Accuracy value );
  inline void writeFieldValue( const OdString& name, OdDgDimGeometry const& value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionPtr& value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionSymbolPtr& value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionPrefixSuffixSymbolPtr& value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionTerminatorSymbologyPtr& value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionTolerancePtr& value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionTerminatorsPtr& value );
  inline void writeFieldValue( const OdString& name, OdDimOptionPrefixSuffixPtr& value );
  inline void writeFieldValue( const OdString& name, OdDgModel::UnitSystem value );
  inline void writeFieldValue( const OdString& name, OdDgModel::UnitBase value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionUnitsPtr& value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionAltFormatPtr& value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionOffsetPtr& value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionProxyCellPtr& value );
  inline void writeFieldValue( const OdString& name, OdDgMultilineSymbology const& value );
  inline void writeFieldValue( const OdString& name, OdDgMultilinePoint const& value );
  inline void writeFieldValue( const OdString& name, OdDgMultilineBreak const& value );
  inline void writeFieldValue( const OdString& name, OdDgMultilineProfile const& value );
  inline void writeFieldValue( const OdString& name, OdDgSurface::Type value );
  inline void writeFieldValue( const OdString& name, OdDgRaster::RasterFormat value );
  inline void writeFieldValue( const OdString& name, OdDgTagDefinition::Type value );
  inline void writeFieldValue( const OdString& name, OdDg::TextDirection value );
  inline void writeFieldValue( const OdString& name, OdGeMatrix3d const& value );
  inline void writeFieldValue( const OdString& name, OdGsDCRect const& value );
  inline void writeFieldValue( const OdString& name, OdDgElementId const& value );
  inline void writeFieldValue( const OdString& name, const OdVariant& value );
  inline void writeFieldValue( const OdString& name, OdGeExtents2d const& value );
  inline void writeFieldValue( const OdString& name, OdGeExtents3d const& value );
  inline void writeFieldValue( const OdString& name, OdDgTextExtendedProperties::LineSpacingType value );
  inline void writeFieldValue( const OdString& name, OdDg::LineStyleType value );
  inline void writeFieldValue( const OdString& name, OdDg::LineStyleUnitsType value );
  inline void writeFieldValue( const OdString& name, OdDgLineStyleResource::OdLsResourceType value );
  inline void writeFieldValue( const OdString& name, OdDgLineCodeResourceStrokeData::OdLsStrokeWidthMode value );
  inline void writeFieldValue( const OdString& name, OdDgLineCodeResourceStrokeData::OdLsStrokeCapsType value );
  inline void writeFieldValue( const OdString& name, OdDgLinePointResourceSymInfo::OdLsSymbolPosOnStroke value );
  inline void writeFieldValue( const OdString& name, OdDgDimLabelLine::LabelLineDimensionMode value );
  inline void writeFieldValue( const OdString& name, OdDgDimTextInfo::FitOptions value );
  inline void writeFieldValue( const OdString& name, OdDgDimension::PlacementAlignment value );
  inline void writeFieldValue( const OdString& name, OdDgDimTextInfo::TextLocation value );
  inline void writeFieldValue( const OdString& name, OdDgDimTool::TerminatorType iType );
  inline void writeFieldValue( const OdString& name, OdDgDimTool::TextType iType );
  inline void writeFieldValue( const OdString& name, OdDgDimTool::CustomSymbol iSymbol );
  inline void writeFieldValue( const OdString& name, OdDgDimTool::Leader iLeader );
  inline void writeFieldValue( const OdString& name, OdDgDimensionPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimSizeArrowPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimSizeStrokePtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimSingleLocationPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimStackedLocationPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimCustomLinearPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimAngleSizePtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimArcSizePtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimAngleLinesPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimAngleLocationPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimArcLocationPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimAngleAxisXPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimAngleAxisYPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimRadiusPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimRadiusExtendedPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimDiameterPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimDiameterExtendedPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimDiameterParallelPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimDiameterPerpendicularPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimOrdinatePtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimCenterPtr pElement );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionOffset::ChainType value );
  inline void writeFieldValue( const OdString& name, OdDgDimOptionOffset::LeaderAlignment value );
  inline void writeFieldValue( const OdString& name, OdDgDimTextInfo::TextAlignment value );
  inline void writeFieldValue( const OdString& name, OdDgDimTextFormat::LabelDisplayMode value );
  inline void writeFieldValue( const OdString& name, OdDgLevelFilterTable::OdDgFilterMemberType value );
  inline void writeFieldValue( const OdString& name, OdDgGradientFill::OdDgGradientType value );
  inline void writeFieldValue( const OdString& name, OdDgLineStyleModificationLinkage::OdDgLsModWidthMode value );
  inline void writeFieldValue( const OdString& name, OdDgLineStyleModificationLinkage::OdDgLsModShiftMode value );
  inline void writeFieldValue( const OdString& name, OdDgLineStyleModificationLinkage::OdDgLsModCornerMode value );
  inline void writeFieldValue( const OdString& name, OdDgDependencyLinkage::RootDataType value );
  inline void writeFieldValue( const OdString& name, OdDgAssocPointRoot::OdDgAssocPointRootType value );
  inline void writeFieldValue( const OdString& name, OdDgArcAssociation::OdDgArcAssociationKeyPoint value );
  inline void writeFieldValue( const OdString& name, OdDgOriginAssociation::OdDgOriginAssocOption value );
  inline void writeFieldValue( const OdString& name, OdDgLineStyleModificationLinkage::OdDgLsMultilineDataType value );
  inline void writeFieldValue( const OdString& name, OdDgRasterFrame::OdDgGeoPriority value );
  inline void writeFieldValue( const OdString& name, OdDgRasterFrame::OdDgRasterDrawingPlane value );
  inline void writeFieldValue( const OdString& name, OdDgRasterFrame::OdDgRasterColorMode value );
  inline void writeFieldValue( const OdString& name, OdDgOle2Frame::OdDgDrawAspect value );
  inline void writeFieldValue( const OdString& name, OdDgOle2Frame::OdDgOleObjectType value );
  inline void writeFieldValue( const OdString& name, OdDgOle2Frame::OdDgOleViewRotationMode value );
  inline void writeFieldValue( const OdString& name, OdDgNamedGroupItem::OdDgNamedGroupPropagateType value );
  inline void writeFieldValue( const OdString& name, OdDgRasterAttachmentHeader::OdDgRasterAttachmentPlane value );
  inline void writeFieldValue( const OdString& name, OdDgTemplateValueVariant value );
  inline void writeFieldValue( const OdString& name, OdDgModel::OdDgGridOrientationType value );
  inline void writeFieldValue( const OdString& name, OdDgModel::AcsType value );
  inline void writeFieldValue( const OdString& name,  OdDg::OdDgMaterialType value );
  inline void writeFieldValue( const OdString& name,  OdDgLinkNode::OdDgLinkNodeType value );
  inline void writeFieldValue( const OdString& name,  OdDgLinkNodePtr value );
  inline void writeFieldValue( const OdString& name,  OdDgFileLinkNode* value );
  inline void writeFieldValue( const OdString& name,  OdDgModelLinkNode* value );
  inline void writeFieldValue( const OdString& name,  OdDgRegionLinkNode* value );
  inline void writeFieldValue( const OdString& name,  OdDgPdfRegionLinkNode* value );
  inline void writeFieldValue( const OdString& name,  OdDgExcelSheetLinkNode* value );
  inline void writeFieldValue( const OdString& name,  OdDgWordHeadingLinkNode* value );
  inline void writeFieldValue( const OdString& name,  OdDgWordRegionLinkNode* value );
  inline void writeFieldValue( const OdString& name,  OdDgURLLinkNode* value );
  inline void writeFieldValue( const OdString& name,  OdDgLinkSetLinkNode* value);
  inline void writeFieldValue( const OdString& name,  OdDgLinkToFolderNode* value);
  inline void writeFieldValue( const OdString& name,  OdDgDrawingLinkNode* value);
  inline void writeFieldValue( const OdString& name,  OdDgConfigurationVariableLinkNode* value);
  inline void writeFieldValue( const OdString& name,  OdDgUnknownLinkNode* value );
  inline void writeFieldValue( const OdString& name,  OdDgModelLinkNode::OdDgModelLinkNodeType value );
  inline void writeFieldValue( const OdString& name,  OdDgRegionLinkNode::OdDgRegionLinkNodeType value );
  inline void writeFieldValue( const OdString& name,  OdDgPdfRegionInfoItem::OdDgPdfRegionType value );
  inline void writeFieldValue( const OdString& name,  OdDgWordHeadingInfoItem::OdDgWordHeadingItemType value );
  inline void writeFieldValue( const OdString& name,  OdDgTextExtendedProperties::OdDgSpecialSymbol value );
  inline void writeFieldValue( const OdString& name,  OdDgEnvMapBackground::OdDgEnvMapBackgroungMode value );
  inline void writeFieldValue( const OdString& name,  OdDgEnvMapFog::OdDgEnvMapFogMode value );
  inline void writeFieldValue( const OdString& name,  OdDgEnvMapImage::OdDgEnvMapProjectionType value );
  inline void writeFieldValue( const OdString& name,  OdDgEnvMapImage::OdDgEnvMapFilterType value );
  inline void writeFieldValue( const OdString& name,  OdDgEnvMapGradient::OdDgEnvMapGradientMode value );
  inline void writeFieldValue( const OdString& name,  OdDgEnvMapLayer::OdDgEnvMapLayerType value );
  inline void writeFieldValue( const OdString& name,  OdDgView::OdDgDisplayMode value );
  inline void writeFieldValue( const OdString& name,  const OdGiMaterialColor& value);
  inline void writeFieldValue( const OdString& name,  const OdDgMaterialParam& value);
  inline void writeFieldValue( const OdString& name,  const OdGeScale2d& value);
  inline void writeFieldValue( const OdString& name,  const OdGeScale3d& value);
  inline void writeFieldValue( const OdString& name,  const OdDoubleColor& value);
  inline void writeFieldValue( const OdString& name,  OdDgMaterialPattern::OdDgMaterialPatternType value);
  inline void writeFieldValue( const OdString& name,  OdDgMaterialMap::MappingType value);
  inline void writeFieldValue( const OdString& name,  OdDgMaterialMap::ScaleMode value);
  inline void writeFieldValue( const OdString& name,  OdDgMaterialLayerPattern::OdDgMaterialLayerPatternType value);
  inline void writeFieldValue( const OdString& name,  OdDgModel::Type value);
  inline void writeFieldValue( const OdString& name,  OdDgModel::CellType value);
  inline void writeFieldValue( const OdString& name,  OdDgDimTextFormat::AngleValueDisplayMode value);
  inline void writeFieldValue( const OdString& name,  OdDg::OdDgDecimalAccuracy value);
  inline void writeFieldValue( const OdString& name,  OdDg::OdDgAngleReadoutDirectionMode value);
  inline void writeFieldValue( const OdString& name,  const OdDgXMLNode& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleTableRecord::OdDgDisplayStyleDisplayHeader& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleTableRecord::OdDgDisplayMode& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleTableRecord::OdDgEnvironmentTypeDisplayed& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleLegendXAttribute::OdDgLegendCoordinateAxis& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleLegendXAttribute::OdDgSlopeDisplayMode& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleLegendXAttribute::OdDgLegendColorScheme& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleLegendXAttribute::OdDgLegendEdgeOverride& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleLegendXAttribute::OdDgLegendValuesCalcMethod& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleLegendXAttribute::OdDgSteppedDisplayMethod& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleLegendXAttribute::OdDgLegendItem& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleTypeFilterXAttribute::OdDgFilterApplyToType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgDisplayStyleTypeFilterXAttribute::OdDgFilterElementType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTerrainFeature::OdDgTerrainFeatureType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTerrainControlElement::OdDgTerrainEdgeMethod& value);
  inline void writeFieldValue( const OdString& name,  const OdDgExtendedElementTypeXAttribute::OdDgExtendedElementType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTerrainGraphicsSettingsXAttribute::OdDgTerrainGraphicsType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTerrainSourceFeatureSettings::OdDgSourceFeatureType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTerrainVertexFeatureSettings::OdDgTerrainVertexFeatureType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTerrainOptions::OdDgTerrainPointDisplayType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTerrainContourFeatureSettings::OdDgTerrainContourFeatureType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTerrainOptions::OdDgTerrainContourSmoothingType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTerrainOptions::OdDgTerrainOptionsType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgItemType::OdDgItemTypeCategory& value);
  inline void writeFieldValue( const OdString& name,  const OdDgItemTypePropertyValue& value);
  inline void writeFieldValue( const OdString& name,  const OdDgItemTypePropertyUnits& value);
  inline void writeFieldValue( const OdString& name,  const OdTimeStamp& value);
  inline void writeFieldValue( const OdString& name,  const OdBinaryData& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<OdBinaryData>& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<bool>& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<OdInt8>& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<OdInt16>& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<OdInt32>& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<OdInt64>& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<double>& value);
  inline void writeFieldValue( const OdString& name,  const OdBoolArray& value);
  inline void writeFieldValue( const OdString& name,  const OdInt8Array& value);
  inline void writeFieldValue( const OdString& name,  const OdInt16Array& value);
  inline void writeFieldValue( const OdString& name,  const OdInt32Array& value);
  inline void writeFieldValue( const OdString& name,  const OdInt64Array& value);
  inline void writeFieldValue( const OdString& name,  const OdDoubleArray& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<OdString>& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<OdAnsiString>& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<OdGePoint3d>& value);
  inline void writeFieldValue( const OdString& name,  const OdArray<OdTimeStamp>& value);
  inline void writeFieldValue( const OdString& name,  const OdDgBinXMLNode* pValue);
  inline void writeFieldValue( const OdString& name,  const OdDgBinXMLValue* pValue);
  inline void writeFieldValue( const OdString& name,  const OdDgGeometryCacheActionPtr& pValue, OdDgDatabase* pDb);
  inline void writeFieldValue( const OdString& name,  const OdDgEdgeRunTableElementSchema::OdDgEdgeRunSide& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTableCellElement::OdDgTableCellElementTextAlignment& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTableCellElement::OdDgTableCellElementTextOrientation& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTableElement::OdDgTableElementBreakType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTableElement::OdDgTableElementSubTablePosition& value);
  inline void writeFieldValue( const OdString& name,  const OdDgTableSchemaDescriptionItem::OdDgTableSchemaDescriptionItemType& value);
  inline void writeFieldValue( const OdString& name,  const OdDgSchemaItemVariant& value);
  inline void writeFieldColorValue( const OdString& name, OdUInt32 value );
  inline void writeFieldLineStyleValue( const OdString& name, OdUInt32 value );
  inline void writeFieldLineWeightValue( const OdString& name, OdUInt32 value );
  inline void writeFieldValue( const OdString& name, OdDg::OdDgInfiniteLineType type );
  inline void writeFieldValue( const OdString& name, OdDgVariable::OdDgVariableType type );
  inline void writeFieldValue( const OdString& name, OdDgVariable::OdDgVariableScope type );
  inline void writeFieldValue( const OdString& name, OdDgVariableValueVariant type );
  inline void writeFieldValue( const OdString& name, OdDgItemTypeBasedVariable::OdDgItemTypeBasedVariableUnits type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePrintArea type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyle3StateBoolean type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePaperOrientation type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutUnits type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutSizeScaleMode type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutOriginMode type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutMirrorMode type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutFenceAlign type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleColorMode type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePropertyPubMethod type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePrintDefCreationMode type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleFenceCreationData::OdDgPrintStyleFenceCreationMode type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePdfPaperSizeMode type );
  inline void writeFieldValue( const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleRasterRotation type );
  inline void writeFieldValue( const OdString& name, OdDgConstraintsDataXAttr::OdDgConstraintsXAttributeType type );
  inline void writeFieldValue( const OdString& name, OdDg2dConstraintRepresentation::OdDgConstraintType type );
  inline void writeFieldValue( const OdString& name, OdDgAssocRegion::OdDgAssocRegionType type );
  inline void writeFieldValue( const OdString& name, OdDgAssocRegion::OdDgAssocRegionFillModeInteriorShapes type );
  inline void writeFieldValue( const OdString& name, OdDgLevelTableRecord::ElementAccess type);
  inline void writeFieldValue( const OdString& name, const OdDgConstraintRepPoint& ptConstraint );
  inline void writeFieldValue( const OdString& name, const OdDgDimensionalConstraintRepresentation::OdDgDimensionalConstraintRepAngleQuadrant& uQuad );
  inline void writeFieldValue( const OdString& name, const OdDgDimensionalConstraintRepresentation::OdDgDimensionalConstraintYOffsetAlignment& uAlign );
  inline void writeFieldValue( const OdString& name, const OdGiDgLinetypeModifiers& lsModifiers );
  inline void writeFieldValue( const OdString& name, const OdArray<OdString>& arrData, bool bHideIfEmpty );
  inline void writeFieldValue( const OdString& name, const OdArray<OdUInt64>& arrData, bool bHideIfEmpty );
  inline void writeFieldValue( const OdString& name, const OdArray<OdUInt32>& arrData, bool bHideIfEmpty );
  inline void writeFieldValue( const OdString& name, const OdArray<OdInt32>& arrData, bool bHideIfEmpty );
  inline void writeFieldValue( const OdString& name, const OdArray<double>& arrData, bool bHideIfEmpty );
  inline void writeFieldValue( const OdString& name, const OdArray<bool>& arrData, bool bHideIfEmpty );
  inline void writeFieldValue( const OdString& name, OdDgECClass::OdDgECClassType type);
  inline void writeFieldValue( const OdString& name, OdDgECRelationshipClass::OdDgECRelationshipStrength type);
  inline void writeFieldValue( const OdString& name, OdDgECRelationshipClass::OdDgECRelationshipDirection type);
  inline void writeFieldValue( const OdString& name, OdDgModel::OdDgAngleAccuracy type);
  inline void writeFieldValue( const OdString& name, OdDgModel::OdDgAngleDirectionMode type);
  inline void writeFieldValue( const OdString& name, OdDgModel::OdDgAngleFormat type);
  inline void writeFieldValue( const OdString& name, OdDgModel::OdDgUnitsFormat type);
  inline void writeFieldValue( const OdString& name, OdDgModel::OdDgUnitsAccuracy type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureLinkage::OdDgFeatureElementType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidHelixNode::OdDgFetureSolidHelixThreadType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidHelixNode::OdDgFetureSolidHelixPitchType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidThicknessNode::OdDgFeatureSolidThicknessApplyToType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidChamferNode::OdDgFeatureSolidChamferMode type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidHoleNode::OdDgFeatureSolidHoleType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidHoleNode::OdDgFeatureSolidHoleDrillType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidHoleNode::OdDgFeatureSolidHoleCounterType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidCutNode::OdDgFeatureSolidCutMethod type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidCutNode::OdDgFeatureSolidCutThroughType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidCutNode::OdDgFeatureSolidCutOffsetType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidProtrusionNode::OdDgFeatureSolidProtrusionMethod type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidProtrusionNode::OdDgFeatureSolidProtrusionThroughType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidProtrusionNode::OdDgFeatureSolidProtrusionOffsetType type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidSweepEdgeNode::OdDgFeatureSolidSweepEdgeMode type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidSweepEdgeNode::OdDgFeatureSolidSweepEdgeMethod type);
  inline void writeFieldValue( const OdString& name, OdDgFeatureSolidArrayNode::OdDgFeatureSolidArrayType type);
  inline void writeFieldValue( const OdString& name, const OdDgVolumeClipSettings& value);

  void writeFieldValue( const OdString& name, const OdDgFeatureSolidVariablePtr& pVar);
  void writeFieldValue( const OdString& name, const OdDgFeatureSolidVertexMarkerPtr& pVar);
  void writeFieldValue( const OdString& name, const OdDgFeatureSolidEdgeMarkerPtr& pVar);
  void writeFieldValue( const OdString& name, const OdDgFeatureSolidFaceMarkerPtr& pVar);
  void writeFieldValue( const OdString& name, const OdDgFeatureSolidBodyMarkerPtr& pVar);

  void writeFieldValue(const OdString& name, const OdDgECRelationshipInstancePtr& pClass);
  void writeFieldValue(const OdString& name, const OdDgECClassInstancePtr& pClass);
  void writeFieldValue(const OdString& name, const OdDgECClassPtr& pClass);
  void writeFieldValue(const OdString& name, const OdDgECPropertyPtr& pProperty);
  void writeFieldValue(const OdString& name, const OdDgECRelationshipPtr& pRelationship, bool bSource);
  void writeFieldValue(const OdString& name, OdDgECProperty::OdDgECPropertyType uType, const OdDgECClassReference& typeRef);
  void writeFieldValue(const OdString& name, const OdDgECRelationshipInstanceNodePtr& pNode);
  void writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystemPtr& pNode);
  void writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystemParam::OdDgGeoDataCoordSystemQuadrantValue& uType);
  void writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystemParam::OdDgGeoDataCoordSystemHemisphereValue& uType);
  void writeFieldValue(const OdString& name, const OdDgGeoDataDatum::OdDgGeoDataConversionMethod& uType);
  void writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystem::OdDgGeoDataCoordSystemProjectionType& uType);
  void writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystem::OdDgGeoDataCoordSystemUnitType& uType);
  void writeFieldValue(const OdString& name, const OdDgGeoDataInfo::OdDgGeoDataVerticalDataType& uType);
  void writeFieldValue(const OdString& name, const OdDgGeoDataInfo::OdDgGeoDataLocalTransformType& uType);
  void writeFieldValue(const OdString& name, const OdDgGeoDataDatum& uDatum);
  void writeFieldValue(const OdString& name, const OdDgGeoDataEllipsoid& uEllipsoid);
  void writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystemParam& uParam);
};


inline void OdExDgnDumper::writeFieldValue(const OdString& name, const OdString& value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%s", value.c_str());
  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdUInt16 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%u", OdUInt32(value));
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValueHex(const OdString& name, OdUInt16 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%04X", OdUInt32(value));
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdUInt32 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%u", value);
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValueHex(const OdString& name, OdUInt32 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%08X", value);
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, double value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%g", value);
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdGePoint2d const& value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%g; %g", value.x, value.y);
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdGePoint3d const& value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%g; %g; %g", value.x, value.y, value.z);
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdGeVector2d const& value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%g; %g", value.x, value.y);
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdGeVector3d const& value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%g; %g; %g", value.x, value.y, value.z);
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdCmEntityColor const& value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"R: %u G: %u B: %u",
    unsigned(value.red()), unsigned(value.green()), unsigned(value.blue()));
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLineStyleInfo const& value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"Modifiers: %08X Scale: %g Shift: %g Start width: %g End width: %g",
    value.getModifiers(), value.getScale(), value.getShift(), value.getStartWidth(), value.getEndWidth());
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdUInt64 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%I64u", value);
  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValueHex(const OdString& name, OdUInt64 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%I64X", value);
  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdUInt8 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%u", unsigned(value));
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValueHex(const OdString& name, OdUInt8 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%02X", unsigned(value));
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLightColor const& value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"R: %g G: %g B: %g Intensity: %g",
    value.getRed(), value.getGreen(), value.getBlue(), value.getIntensityScale());
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, bool value)
{
  dumpFieldName(name);
  dumpFieldValue(value ? L"true" : L"false");
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdAngleCoordinate const& value)
{
  dumpFieldName(name);
  OdString val;
  OdString wsym("^");
  val.format(L"%d%s %u' %u\"",
    unsigned(value.getDegrees()), wsym.c_str(), unsigned(value.getMinutes()), unsigned(value.getSeconds()));
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdInt16 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%i", int(value));
  dumpFieldValue(val);
}

#if defined(ANDROID)
inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdChar value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%c", value);
  dumpFieldValue(val);
}
#endif

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdInt32 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%li", int(value));
  dumpFieldValue(val);
}

#if !(defined(ODA_UNIXOS) && (OD_SIZEOF_LONG == 8))
inline void OdExDgnDumper::writeFieldValue(const OdString& name, int value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%li", value);
  dumpFieldValue(val);
}
#endif


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdInt64 value)
{
  dumpFieldName(name);
  OdString val;
  val.format(L"%iI64", int(value));
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::WorkingUnit value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgModel::kWuUnitOfResolution: val.format(L"unit of resolution"); break;
  case OdDgModel::kWuStorageUnit: val.format(L"storage unit"); break;
  case OdDgModel::kWuWorldUnit: val.format(L"world unit"); break;
  case OdDgModel::kWuMasterUnit: val.format(L"master unit"); break;
  case OdDgModel::kWuSubUnit: val.format(L"sub unit"); break;
  }
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDg::TextJustification value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDg::kLeftTop: val.format(L"left top"); break;
  case OdDg::kLeftCenter: val.format(L"left center"); break;
  case OdDg::kLeftBottom: val.format(L"left bottom"); break;
  case OdDg::kLeftDescender: val.format(L"left descender"); break;
  case OdDg::kLeftMarginTop: val.format(L"left margin top"); break;
  case OdDg::kLeftMarginCenter: val.format(L"left margin center"); break;
  case OdDg::kLeftMarginBottom: val.format(L"left margin bottom"); break;
  case OdDg::kCenterTop: val.format(L"center top"); break;
  case OdDg::kCenterCenter: val.format(L"center center"); break;
  case OdDg::kCenterBottom: val.format(L"center bottom"); break;
  case OdDg::kCenterDescender: val.format(L"center descender"); break;
  case OdDg::kRightMarginTop: val.format(L"right margin top"); break;
  case OdDg::kRightMarginCenter: val.format(L"right margin center"); break;
  case OdDg::kRightMarginBottom: val.format(L"right margin bottom"); break;
  case OdDg::kRightTop: val.format(L"right top"); break;
  case OdDg::kRightCenter: val.format(L"right center"); break;
  case OdDg::kRightBottom: val.format(L"right bottom"); break;
  case OdDg::kRightDescender: val.format(L"right descender"); break;
  }
  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimLabelLine::LabelLineDimensionMode value)
{
  dumpFieldName(name);
  OdString val;

  switch (value)
  {
  case OdDgDimLabelLine::kAngleLength:
    val = OD_T("Angle/Length"); break;
  case OdDgDimLabelLine::kLengthAbove:
    val = OD_T("Length above"); break;
  case OdDgDimLabelLine::kAngleAbove:
    val = OD_T("Angle above"); break;
  case OdDgDimLabelLine::kLengthBelow:
    val = OD_T("Length below"); break;
  case OdDgDimLabelLine::kAngleBelow:
    val = OD_T("Angle below"); break;
  case OdDgDimLabelLine::kLengthAngleAbove:
    val = OD_T("Length Angle above"); break;
  case OdDgDimLabelLine::kLengthAngleBelow:
    val = OD_T("Length Angle below"); break;
  default:
    val = OD_T("Length/Angle"); break;
  }

  dumpFieldValue(val);
}

inline void getXYZAnglesByQuaternion(const OdGeQuaternion& quat, double& dXAngle, double& dYAngle, double& dZAngle)
{
  OdGeMatrix3d matRotation = quat.getMatrix();
  matRotation.transposeIt();
  OdGeVector3d vrXAxis = OdGeVector3d::kXAxis;
  OdGeVector3d vrYAxis = OdGeVector3d::kYAxis;
  OdGeVector3d vrZAxis = OdGeVector3d::kZAxis;

  vrXAxis.transformBy(matRotation);
  vrYAxis.transformBy(matRotation);
  vrZAxis.transformBy(matRotation);
  vrXAxis.normalize();
  vrYAxis.normalize();
  vrZAxis.normalize();

  if (vrZAxis.x > 1)
    vrZAxis.x = 1.0;

  if (vrZAxis.x < -1)
    vrZAxis.x = -1.0;

  double dXAngle1 = 0;
  double dXAngle2 = 0;
  double dYAngle1 = OD_ASIN(vrZAxis.x);
  double dYAngle2 = dYAngle1 + OdaPI;
  double dZAngle1 = 0;
  double dZAngle2 = 0;

  if( !OdZero(cos(dYAngle1), 1e-6) )
  {
    double dSin1X = -1.0 * vrZAxis.y / cos(dYAngle1);
    double dSin2X = -1.0 * vrZAxis.y / cos(dYAngle2);
    double dCos1X = vrZAxis.z / cos(dYAngle1);
    double dCos2X = vrZAxis.z / cos(dYAngle2);

    if (dCos1X > 1)
      dCos1X = 1;

    if (dCos1X < -1)
      dCos1X = -1;

    if (dCos2X > 1)
      dCos2X = 1;

    if (dCos2X < -1)
      dCos2X = -1;

    dXAngle1 = OD_ACOS(dCos1X);
    dXAngle2 = OD_ACOS(dCos2X);

    if (((dXAngle1 > 0 || dZAngle1 < OdaPI) && (dSin1X < 0)) ||
        ((dXAngle1 > OdaPI || dZAngle1 < 0) && (dSin1X > 0))
      )
    {
      dXAngle1 = -dXAngle1;
    }

    if (((dXAngle2 > 0 || dXAngle2 < OdaPI) && (dSin2X < 0)) ||
        ((dXAngle2 > OdaPI || dXAngle2 < 0) && (dSin2X > 0))
      )
    {
      dXAngle2 = -dXAngle2;
    }

    double dSin1Z = -1.0 * vrYAxis.x / cos(dYAngle1);
    double dSin2Z = -1.0 * vrYAxis.x / cos(dYAngle2);
    double dCos1Z = vrXAxis.x / cos(dYAngle1);
    double dCos2Z = vrXAxis.x / cos(dYAngle2);

    if( dCos1Z > 1 )
      dCos1Z = 1;

    if( dCos1Z < -1 )
      dCos1Z = -1;

    if( dCos2Z > 1 )
      dCos2Z = 1;

    if( dCos2Z < -1 )
      dCos2Z = -1;

    dZAngle1 = acos(dCos1Z);
    dZAngle2 = acos(dCos2Z);

    dZAngle1 = OD_ACOS(dCos1Z);
    dZAngle2 = OD_ACOS(dCos2Z);

    if (((dZAngle1 > 0 || dZAngle1 < OdaPI) && (dSin1Z < 0)) ||
        ((dZAngle1 > OdaPI || dZAngle1 < 0) && (dSin1Z > 0))
      )
    {
      dZAngle1 = -dZAngle1;
    }

    if (((dZAngle2 > 0 || dZAngle2 < OdaPI) && (dSin2Z < 0)) ||
        ((dZAngle2 > OdaPI || dZAngle2 < 0) && (dSin2Z > 0))
      )
    {
      dZAngle2 = -dZAngle2;
    }
  }
  else
  {
    dYAngle2 = dYAngle1;

    dXAngle1 = OdGeVector3d::kZAxis.angleTo(vrXAxis, OdGeVector3d::kXAxis);
    dXAngle2 = dXAngle1;

    dZAngle1 = OdaPI;
    dZAngle2 = 0;
  }

  double dYy1 = cos(dXAngle1)*cos(dZAngle1) - sin(dXAngle1)*sin(dYAngle1)*sin(dZAngle1);
  double dYz1 = sin(dXAngle1)*cos(dZAngle1) + cos(dXAngle1)*sin(dYAngle1)*sin(dZAngle1);
  double dXy1 = cos(dXAngle1)*sin(dZAngle1) + sin(dXAngle1)*sin(dYAngle1)*cos(dZAngle1);
  double dXz1 = sin(dXAngle1)*sin(dZAngle1) - cos(dXAngle1)*sin(dYAngle1)*cos(dZAngle1);

  if( OdZero(dYy1 - vrYAxis.y, 1e-6) &&
      OdZero(dYz1 - vrYAxis.z, 1e-6) &&
      OdZero(dXy1 - vrXAxis.y, 1e-6) &&
      OdZero(dXz1 - vrXAxis.z, 1e-6)
    )
  {
    dXAngle = dXAngle1;
    dYAngle = dYAngle1;
    dZAngle = dZAngle1;
  }
  else
  {
    dXAngle = dXAngle2;
    dYAngle = dYAngle2;
    dZAngle = dZAngle2;
  }
}

inline OdGeQuaternion getQuaternionByXYZAngles(double dXAngle, double dYAngle, double dZAngle)
{
  OdGeMatrix3d matRotation = OdGeMatrix3d::rotation(dXAngle, OdGeVector3d::kXAxis) * OdGeMatrix3d::rotation(dYAngle, OdGeVector3d::kYAxis) * OdGeMatrix3d::rotation(dZAngle, OdGeVector3d::kZAxis);
  matRotation.transposeIt();
  OdGeQuaternion quatRotation;
  quatRotation.set(matRotation);
  return quatRotation;
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdGeQuaternion const& value)
{
  dumpFieldName(name);

  double dXAngle, dYAngle, dZAngle;
  getXYZAnglesByQuaternion(value, dXAngle, dYAngle, dZAngle);
  OdGeQuaternion quatNew = getQuaternionByXYZAngles(dXAngle, dYAngle, dZAngle);

  dXAngle *= 180.0 / OdaPI;
  dYAngle *= 180.0 / OdaPI;
  dZAngle *= 180.0 / OdaPI;

  OdString val;
  val.format(L"%f; %f; %f; %f (%7.4f, %7.4f, %7.4f)", value.w, value.x, value.y, value.z, dXAngle, dYAngle, dZAngle);
  dumpFieldValue(val);
}


//#pragma MARKMESSAGE("TODO: Examples. TextAttributes interface was modified.");
//inline void OdExDgnDumper::writeFieldValue( const OdString& name, TextAttributes const& value )
//{
//  writeShift();
//  val.format( L"%s:", name.c_str() );
//
//  m_nesting++;
//
//  writeFieldValue( "Is interchar", value.isInterchar );
//  writeFieldValue( "Interchar spacing", value.intercharSpacing );
//  writeFieldValue( "Is fixed width spacing", value.isFixedWidthSpacing );
//  writeFieldValue( "Is underlined", value.isUnderlined );
//  writeFieldValue( "Underline offset", value.underlineOffset );
//  writeFieldValue( "Is overlined", value.isOverlined );
//  writeFieldValue( "Overline offset", value.overlineOffset );
//  writeFieldValue( "Is slant", value.isSlant );
//  writeFieldValue( "Slang angle", value.slantAngle );
//  writeFieldValue( "Is vertical", value.isVertical );
//  writeFieldValue( "Is right-to-left", value.isRightToLeft );
//  writeFieldValue( "Codepage presents", value.isCodepagePresented );
//  writeFieldValue( "Codepage", value.codePage );
//  writeFieldValue( "Background presents", value.isBackgroundPresented );
//  writeFieldValue( "Background fill color", value.backgroundFillColor );
//  writeFieldValue( "Background border color", value.backgroundBorderColor );
//  writeFieldValue( "Background border style", value.backgroundBorderStyle );
//  writeFieldValue( "Background border weight", value.backgroundBorderWeight );
//  writeFieldValue( "Background border X", value.backgroundBorderX );
//  writeFieldValue( "Background border Y", value.backgroundBorderY );
//  writeFieldValue( "Is subscript", value.isSubscript );
//  writeFieldValue( "Is superscript", value.isSuperscript );
//  writeFieldValue( "Has text style", value.hasTextStyle );
//  writeFieldValue( "Text style", value.textStyle );
//  writeFieldValue( "Count of line breaks", value.lineBreakCount );
//  writeFieldValue( "Is bold", value.isBold );
//  writeFieldValue( "Has underline style", value.hasUnderlineStyle );
//  writeFieldValue( "Underline color", value.underlineColor );
//  writeFieldValue( "Underline style", value.underlineStyle );
//  writeFieldValue( "Underline weight", value.underlineWeight );
//  writeFieldValue( "Has overline style", value.hasOverlineStyle );
//  writeFieldValue( "Overline color", value.overlineColor );
//  writeFieldValue( "Overline style", value.overlineStyle );
//  writeFieldValue( "Overline weight", value.overlineWeight );
//  writeFieldValue( "Is word-wrap text node", value.isWordWrapTextNode );
//  writeFieldValue( "Is full justification", value.isFullJustification );
//  writeFieldValue( "Has color", value.hasColor );
//  writeFieldValue( "Color", value.color );
//  writeFieldValue( "Is ACAD interchar spacing", value.isAcadIntercharSpacing );
//  writeFieldValue( "Is backwards", value.isBackwards );
//  writeFieldValue( "Is upside-down", value.isUpsideDown );
//
//  m_nesting--;
//}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgGraphicsElement::Class value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgGraphicsElement::kClassPrimary: val.format(L"Primary"); break;
  case OdDgGraphicsElement::kClassPatternComponent: val.format(L"Pattern component"); break;
  case OdDgGraphicsElement::kClassConstruction: val.format(L"Construction"); break;
  case OdDgGraphicsElement::kClassDimension: val.format(L"Dimension"); break;
  case OdDgGraphicsElement::kClassPrimaryRule: val.format(L"Primary rule"); break;
  case OdDgGraphicsElement::kClassLinearPatterned: val.format(L"Linear patterned"); break;
  case OdDgGraphicsElement::kClassConstructionRule: val.format(L"Construction rule"); break;
  }
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdGeMatrix2d const& value)
{
  dumpFieldName(name);

  OdString val;
  val.format(L"%g; %g; %g; %g", value[0][0], value[1][0], value[0][1], value[1][1]);
  dumpFieldValue(val);
}


//inline void OdExDgnDumper::writeFieldValue( OdString const& name, OdDgDimension::ToolType value )
//{
//  dumpFieldName( name );
//  OdDgDimTool tool;
//  OdDgDimensionPtr pDim = OdDgDimension::cast( m_object );
//  OdString val;
//  switch( value )
//  {
//  case OdDgDimension::kToolTypeInvalid             : val.format( LInvalid" ); break;
//  case OdDgDimension::kToolTypeSizeArrow          : val.format( LSize arrow" ); break;
//    m_nesting++;
//    pDim->getDimensionTool( tool );
//    if(static_cast<OdDgDimToolSizeArrow*>( &tool )->getArcSymbolFlag())
//      val.format( LTool Arc Symbol Flag set" );
//    val.format( LTool Datum Value: %d", static_cast<OdDgDimToolOrdinate*>( &tool )->getDatumValue() );
//    if(static_cast<OdDgDimToolSizeArrow*>( &tool )->getStackExtLinesFlag())
//      val.format( LTool StackExtLines Flag set" );
//    if(static_cast<OdDgDimToolSizeArrow*>( &tool )->getLeftExtLinesPresentFlag())
//      val.format( LTool LeftExtLinesPresent Flag set" );
//    if(static_cast<OdDgDimToolSizeArrow*>( &tool )->getRightExtLinesPresentFlag())
//      val.format( LTool RightExtLinesPresent Flag set" );
//    //static_cast<OdDgDimToolSizeArrow*>( &tool )->getFirstTerminator();
//    switch(static_cast<OdDgDimToolSizeArrow*>( &tool )->getFirstTerminator())
//    {      //OdDgDimTool::TerminatorType     kTtNone           = 0,  kTtArrow          = 1,  kTtStroke         = 2,  kTtCircle         = 3,  kTtFilledCircle   = 4,
//    case OdDgDimTool::kTtNone:
//      fprintf(DumpStream, "Tool First Terminator Type: kTtNone");
//      break;
//    case OdDgDimTool::kTtArrow:
//      fprintf(DumpStream, "Tool First Terminator Type: kTtArrow");
//      break;
//    case OdDgDimTool::kTtStroke:
//      fprintf(DumpStream, "Tool First Terminator Type: kTtStroke");
//      break;
//    case OdDgDimTool::kTtCircle:
//      fprintf(DumpStream, "Tool First Terminator Type: kTtCircle");
//      break;
//    case OdDgDimTool::kTtFilledCircle:
//      fprintf(DumpStream, "Tool First Terminator Type: kTtFilledCircle");
//      break;
//    }
//    //static_cast<OdDgDimToolSizeArrow*>( &tool )->getJointTerminator();
//    switch(static_cast<OdDgDimToolSizeArrow*>( &tool )->getJointTerminator())
//    {      //OdDgDimTool::TerminatorType     kTtNone           = 0,  kTtArrow          = 1,  kTtStroke         = 2,  kTtCircle         = 3,  kTtFilledCircle   = 4,
//    case OdDgDimTool::kTtNone:
//      fprintf(DumpStream, "Tool Joint Terminator Type: kTtNone");
//      break;
//    case OdDgDimTool::kTtArrow:
//      fprintf(DumpStream, "Tool Joint Terminator Type: kTtArrow");
//      break;
//    case OdDgDimTool::kTtStroke:
//      fprintf(DumpStream, "Tool Joint Terminator Type: kTtStroke");
//      break;
//    case OdDgDimTool::kTtCircle:
//      fprintf(DumpStream, "Tool Joint Terminator Type: kTtCircle");
//      break;
//    case OdDgDimTool::kTtFilledCircle:
//      fprintf(DumpStream, "Tool Joint Terminator Type: kTtFilledCircle");
//      break;
//    }
//    //static_cast<OdDgDimToolSizeArrow*>( &tool )->getLeftTerminator();
//    switch(static_cast<OdDgDimToolSizeArrow*>( &tool )->getLeftTerminator())
//    {      //OdDgDimTool::TerminatorType     kTtNone           = 0,  kTtArrow          = 1,  kTtStroke         = 2,  kTtCircle         = 3,  kTtFilledCircle   = 4,
//    case OdDgDimTool::kTtNone:
//      fprintf(DumpStream, "Tool Left Terminator Type: kTtNone");
//      break;
//    case OdDgDimTool::kTtArrow:
//      fprintf(DumpStream, "Tool Left Terminator Type: kTtArrow");
//      break;
//    case OdDgDimTool::kTtStroke:
//      fprintf(DumpStream, "Tool Left Terminator Type: kTtStroke");
//      break;
//    case OdDgDimTool::kTtCircle:
//      fprintf(DumpStream, "Tool Left Terminator Type: kTtCircle");
//      break;
//    case OdDgDimTool::kTtFilledCircle:
//      fprintf(DumpStream, "Tool Left Terminator Type: kTtFilledCircle");
//      break;
//    }
//    //static_cast<OdDgDimToolSizeArrow*>( &tool )->getRightTerminator();
//    switch(static_cast<OdDgDimToolSizeArrow*>( &tool )->getRightTerminator())
//    {      //OdDgDimTool::TerminatorType     kTtNone           = 0,  kTtArrow          = 1,  kTtStroke         = 2,  kTtCircle         = 3,  kTtFilledCircle   = 4,
//    case OdDgDimTool::kTtNone:
//      fprintf(DumpStream, "Tool Right Terminator Type: kTtNone");
//      break;
//    case OdDgDimTool::kTtArrow:
//      fprintf(DumpStream, "Tool Right Terminator Type: kTtArrow");
//      break;
//    case OdDgDimTool::kTtStroke:
//      fprintf(DumpStream, "Tool Right Terminator Type: kTtStroke");
//      break;
//    case OdDgDimTool::kTtCircle:
//      fprintf(DumpStream, "Tool Right Terminator Type: kTtCircle");
//      break;
//    case OdDgDimTool::kTtFilledCircle:
//      fprintf(DumpStream, "Tool Right Terminator Type: kTtFilledCircle");
//      break;
//    }
//    //static_cast<OdDgDimToolSizeArrow*>( &tool )->getPrefix();
//    switch(static_cast<OdDgDimToolSizeArrow*>( &tool )->getPrefix())
//    {      //OdDgDimTool::CustomSymbol       kCsNone         = 0    , kCsDiameter     = 1    , kCsRadius       = 2    , kCsSquare       = 3    , kCsSR           = 4    , kCsSDiameter    = 5
//    case OdDgDimTool::kCsNone:
//      fprintf(DumpStream, "Tool Prefix: kCsNone");
//      break;
//    case OdDgDimTool::kCsDiameter:
//      fprintf(DumpStream, "Tool Prefix: kCsDiameter");
//      break;
//    case OdDgDimTool::kCsRadius:
//      fprintf(DumpStream, "Tool Prefix: kCsRadius");
//      break;
//    case OdDgDimTool::kCsSquare:
//      fprintf(DumpStream, "Tool Prefix: kCsSquare");
//      break;
//    case OdDgDimTool::kCsSR:
//      fprintf(DumpStream, "Tool Prefix: kCsSR");
//      break;
//    case OdDgDimTool::kCsSDiameter:
//      fprintf(DumpStream, "Tool Prefix: kCsSDiameter");
//      break;
//    }
//    //static_cast<OdDgDimToolSizeArrow*>( &tool )->getSuffix();
//    switch(static_cast<OdDgDimToolSizeArrow*>( &tool )->getSuffix())
//    {      //OdDgDimTool::CustomSymbol       kCsNone         = 0    , kCsDiameter     = 1    , kCsRadius       = 2    , kCsSquare       = 3    , kCsSR           = 4    , kCsSDiameter    = 5
//    case OdDgDimTool::kCsNone:
//      fprintf(DumpStream, "Tool Suffix: kCsNone");
//      break;
//    case OdDgDimTool::kCsDiameter:
//      fprintf(DumpStream, "Tool Suffix: kCsDiameter");
//      break;
//    case OdDgDimTool::kCsRadius:
//      fprintf(DumpStream, "Tool Suffix: kCsRadius");
//      break;
//    case OdDgDimTool::kCsSquare:
//      fprintf(DumpStream, "Tool Suffix: kCsSquare");
//      break;
//    case OdDgDimTool::kCsSR:
//      fprintf(DumpStream, "Tool Suffix: kCsSR");
//      break;
//    case OdDgDimTool::kCsSDiameter:
//      fprintf(DumpStream, "Tool Suffix: kCsSDiameter");
//      break;
//    }
//    //static_cast<OdDgDimToolSizeArrow*>( &tool )->getTextType();
//    switch(static_cast<OdDgDimToolSizeArrow*>( &tool )->getTextType())
//    {      //kStandard = 0    , kVertical = 1    , kMixed    = 2
//    case OdDgDimTool::kStandard:
//      fprintf(DumpStream, "Tool Text Type: kStandard");
//      break;
//    case OdDgDimTool::kVertical:
//      fprintf(DumpStream, "Tool Text Type: kVertical");
//      break;
//    case OdDgDimTool::kMixed:
//      fprintf(DumpStream, "Tool Text Type: kMixed");
//      break;
//    }
//    m_nesting--;
//    break;
//  case OdDgDimension::kToolTypeSizeStroke         : val.format( LSize stroke" ); break;
//  case OdDgDimension::kToolTypeLocateSingle       : val.format( LLocate single" ); break;
//  case OdDgDimension::kToolTypeLocateStacked      : val.format( LLocate stacked" ); break;
//  case OdDgDimension::kToolTypeAngleSize          : val.format( LAngle size" ); break;
//  case OdDgDimension::kToolTypeArcSize            : val.format( LArc size" ); break;
//  case OdDgDimension::kToolTypeAngleLocation      : val.format( LAngle location" ); break;
//  case OdDgDimension::kToolTypeArcLocation        : val.format( LArc location" ); break;
//  case OdDgDimension::kToolTypeAngleLines         : val.format( LAngle lines" ); break;
//  case OdDgDimension::kToolTypeAngleAxis          : val.format( LAngle axis" ); break;
//  case OdDgDimension::kToolTypeRadius             : val.format( LRadius" ); break;
//  case OdDgDimension::kToolTypeDiameter           : val.format( LDiameter" ); break;
//  case OdDgDimension::kToolTypeDiameterPara       : val.format( LDiameter para" ); break;
//  case OdDgDimension::kToolTypeDiameterPerp       : val.format( LDiameter perp" ); break;
//  case OdDgDimension::kToolTypeCustomLinear       : val.format( LCustom linear" ); break;
//  case OdDgDimension::kToolTypeOrdinate           : val.format( LOrdinate" ); 
//    m_nesting++;
//    pDim->getDimensionTool( tool );
//    if(static_cast<OdDgDimToolOrdinate*>( &tool )->getArcSymbolFlag())
//      val.format( LTool Arc Symbol Flag set" );
//    val.format( LTool Datum Value: %d", static_cast<OdDgDimToolOrdinate*>( &tool )->getDatumValue() );
//    if(static_cast<OdDgDimToolOrdinate*>( &tool )->getDecrementInReverseDirectionFlag())
//      val.format( LTool DecrementInReverse Direction Flag set" );
//    if(static_cast<OdDgDimToolOrdinate*>( &tool )->getFreeLocationOfTxtFlag())
//      val.format( LTool FreeLocationOfTxt Flag set" );
//    if(static_cast<OdDgDimToolOrdinate*>( &tool )->getStackExtLinesFlag())
//      val.format( LTool StackExtLines Flag set" );
//    m_nesting--;
//    break;
//  case OdDgDimension::kToolTypeRadiusExtended     : val.format( LRadius extended" ); break;
//  case OdDgDimension::kToolTypeDiameterExtended   : val.format( LDiameter extended" ); break;
//  case OdDgDimension::kToolTypeCenter              : val.format( LCenter" ); break;
//  }
//  dumpFieldValue( val );
//}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimPoint& value)
{
  OdString val;
  val.format(L"%s:", name.c_str());
  dumpFieldName(val);
  writeFieldValue("  Point", value.getPoint());
  writeFieldValue("  Offset to dimension line", value.getOffsetToDimLine());
  writeFieldValue("  Offset Y", value.getOffsetY());
  writeFieldValue("  Text alignment", value.getJustification());
  dumpFieldName("  Flags:");
  writeFieldValue("    Associative", value.getAssociativeFlag());
  writeFieldValue("    Relative", value.getRelative() != 0);
  writeFieldValue("    WitnessControlLocal", value.getWitnessControlLocalFlag());
  writeFieldValue("    NoWitnessLine", value.getNoWitnessLineFlag());
  writeFieldValue("    UseAltSymbology", value.getUseAltSymbologyFlag());

  if (value.getPrimaryTextFlag())
  {
    writeFieldValue("  Primary text", value.getPrimaryText());
  }

  if (value.getPrimaryTopToleranceTextFlag())
  {
    writeFieldValue("  Primary Top text", value.getPrimaryTopToleranceText());
  }

  if (value.getPrimaryBottomToleranceTextFlag())
  {
    writeFieldValue("  Primary Bottom text", value.getPrimaryBottomToleranceText());
  }

  if (value.getSecondaryTextFlag())
  {
    writeFieldValue("  Secondary text", value.getSecondaryText());
  }

  if (value.getSecondaryTopToleranceTextFlag())
  {
    writeFieldValue("  Secondary Top text", value.getSecondaryTopToleranceText());
  }

  if (value.getSecondaryBottomToleranceTextFlag())
  {
    writeFieldValue("  Secondary Bottom text", value.getSecondaryBottomToleranceText());
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTextInfo::TextAlignment value)
{
  OdString strJust;

  switch (value)
  {
  case OdDgDimTextInfo::kLeftText:
  {
    strJust = OD_T("kLeftText");
  } break;

  case OdDgDimTextInfo::kCenterLeftText:
  {
    strJust = OD_T("kCenterLeftText");
  } break;

  case OdDgDimTextInfo::kCenterRightText:
  {
    strJust = OD_T("kCenterRightText");
  } break;

  case OdDgDimTextInfo::kRightText:
  {
    strJust = OD_T("kRightText");
  } break;

  case OdDgDimTextInfo::kManualText:
  {
    strJust = OD_T("kManualText");
  } break;
  }

  writeFieldValue(name, strJust);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTextInfo const& value)
{
  OdString val;
  val.format(L"%s:", name.c_str());
  dumpFieldName(val);
  writeFieldValue("  Width", value.getWidth());
  writeFieldValue("  Height", value.getHeight());
  writeFieldValue("  Font ID", value.getFontEntryId());
  writeFieldValue("  Color", value.getColorIndex());
  writeFieldValue("  Weight", value.getWeight());

  switch (value.getStackedFractionType())
  {
  case OdDgDimTextInfo::kFractionFromText:
  {
    writeFieldValue("  Stacked Fraction Type", OdString(L"kFractionFromText"));
  } break;

  case OdDgDimTextInfo::kFractionHorizontal:
  {
    writeFieldValue("  Stacked Fraction Type", OdString(L"kFractionHorizontal"));
  } break;

  case OdDgDimTextInfo::kFractionDiagonal:
  {
    writeFieldValue("  Stacked Fraction Type", OdString(L"kFractionDiagonal"));
  } break;
  }

  switch (value.getStackFractAlignment())
  {
  case OdDgDimTextInfo::kFractAlignmentTop:
  {
    writeFieldValue("  Stacked Fraction Alignment", OdString(L"kFractAlignmentTop"));
  } break;

  case OdDgDimTextInfo::kFractAlignmentCenter:
  {
    writeFieldValue("  Stacked Fraction Alignment", OdString(L"kFractAlignmentCenter"));
  } break;

  case OdDgDimTextInfo::kFractAlignmentBottom:
  {
    writeFieldValue("  Stacked Fraction Alignment", OdString(L"kFractAlignmentBottom"));
  } break;
  }

  dumpFieldName(L"  Text flags:");
  writeFieldValue("    Use text color", value.getUseColorFlag());
  writeFieldValue("    Use weight ", value.getUseWeightFlag());
  writeFieldValue("    Show primary master units ", !value.getPrimaryNoMasterUnitsFlag());
  writeFieldValue("    Has primary alt format ", value.getHasAltFormatFlag());
  writeFieldValue("    Show secondary master units ", !value.getSecNoMasterUnitsFlag());
  writeFieldValue("    Has secondary alt format ", value.getHasSecAltFormatFlag());
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTextFormat const& value)
{
  OdString val;
  val.format(L"%s:", name.c_str());
  dumpFieldName(val);

  writeFieldValue("  Primary accuracy", value.getPrimaryAccuracy());
  writeFieldValue("  Secondary accuracy", value.getSecondaryAccuracy());

  switch (value.getAngleMode())
  {
  case OdDgDimTextFormat::kAngle_D:
  {
    writeFieldValue("  Angle display mode", OdString(L"kAngle_D"));
  } break;

  case OdDgDimTextFormat::kAngle_DM:
  {
    writeFieldValue("  Angle display mode", OdString(L"kAngle_DM"));
  } break;

  case OdDgDimTextFormat::kAngle_DMS:
  {
    writeFieldValue("  Angle display mode", OdString(L"kAngle_DMS"));
  } break;

  case OdDgDimTextFormat::kAngle_C:
  {
    writeFieldValue("  Angle display mode", OdString(L"kAngle_C"));
  } break;

  case OdDgDimTextFormat::kAngle_Radian:
  {
    writeFieldValue("  Angle display mode", OdString(L"kAngle_Radian"));
  } break;
  }

  dumpFieldName("  Text Format Flags:");
  writeFieldValue("    AngleMeasure", value.getAngleMeasureFlag());
  writeFieldValue("    AngleFormat", value.getAngleFormatFlag());
  writeFieldValue("    PrimarySubUnits", value.getPrimarySubUnitsFlag());
  writeFieldValue("    PrimaryLabels", value.getPrimaryLabelsFlag());
  writeFieldValue("    PrimaryDelimiter", value.getPrimaryDelimiterFlag());
  writeFieldValue("    DecimalComma", value.getDecimalCommaFlag());
  writeFieldValue("    SuperScriptLSD", value.getSuperScriptLSDFlag());
  writeFieldValue("    RoundLSD", value.getRoundLSDFlag());
  writeFieldValue("    OmitLeadDelimiter", value.getOmitLeadDelimiterFlag());
  writeFieldValue("    LocalFileUnits", value.getLocalFileUnitsFlag());
  writeFieldValue("    UnusedDeprecated", value.getUnusedDeprecatedFlag());
  writeFieldValue("    ThousandSeparator", value.getThousandSepFlag());
  writeFieldValue("    MetricSpace", value.getMetricSpaceFlag());
  writeFieldValue("    SecondarySubUnits", value.getSecondarySubUnitsFlag());
  writeFieldValue("    SecondaryLabels", value.getSecondaryLabelsFlag());
  writeFieldValue("    SecondaryDelimiter", value.getSecondaryDelimiterFlag());
  writeFieldValue("    Radians", value.getRadiansFlag());
  writeFieldValue("    Show primary master units if zero", value.getPriAllowZeroMastFlag());
  writeFieldValue("    Show secondary master units if zero", value.getSecAllowZeroMastFlag());
  writeFieldValue("    Show primary sub units if zero", !value.getPriSubForbidZeroMastFlag());
  writeFieldValue("    Show secondary sub units if zero", !value.getSecSubForbidZeroMastFlag());
  writeFieldValue("    HideAngleSeconds", !value.getHideAngleSecondsFlag());
  writeFieldValue("    SkipNonStackedFractionSpace", !value.getSkipNonStackedFractionSpaceFlag());
}


inline void OdExDgnDumper::writeFieldValue(OdString const& name, OdDgDimTextFormat::Accuracy value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgDimTextFormat::kAccuracyNone: val.format(L"1 digit"); break;

  case OdDgDimTextFormat::kDecimal1: val.format(L"Decimal, 2 digit"); break;
  case OdDgDimTextFormat::kDecimal2: val.format(L"Decimal, 3 digit"); break;
  case OdDgDimTextFormat::kDecimal3: val.format(L"Decimal, 4 digit"); break;
  case OdDgDimTextFormat::kDecimal4: val.format(L"Decimal, 5 digit"); break;
  case OdDgDimTextFormat::kDecimal5: val.format(L"Decimal, 6 digit"); break;
  case OdDgDimTextFormat::kDecimal6: val.format(L"Decimal, 7 digit"); break;
  case OdDgDimTextFormat::kDecimal7: val.format(L"Decimal, 8 digit"); break;
  case OdDgDimTextFormat::kDecimal8: val.format(L"Decimal, 9 digit"); break;

  case OdDgDimTextFormat::kFractional2: val.format(L"Fractional, 2-th"); break;
  case OdDgDimTextFormat::kFractional4: val.format(L"Fractional, 4-th"); break;
  case OdDgDimTextFormat::kFractional8: val.format(L"Fractional, 8-th"); break;
  case OdDgDimTextFormat::kFractional16: val.format(L"Fractional, 16-th"); break;
  case OdDgDimTextFormat::kFractional32: val.format(L"Fractional, 32-th"); break;
  case OdDgDimTextFormat::kFractional64: val.format(L"Fractional, 64-th"); break;

  case OdDgDimTextFormat::kExponential1: val.format(L"Exponential, 1 digit for mantissa"); break;
  case OdDgDimTextFormat::kExponential2: val.format(L"Exponential, 2 digit for mantissa"); break;
  case OdDgDimTextFormat::kExponential3: val.format(L"Exponential, 3 digit for mantissa"); break;
  case OdDgDimTextFormat::kExponential4: val.format(L"Exponential, 4 digit for mantissa"); break;
  case OdDgDimTextFormat::kExponential5: val.format(L"Exponential, 5 digit for mantissa"); break;
  case OdDgDimTextFormat::kExponential6: val.format(L"Exponential, 6 digit for mantissa"); break;
  case OdDgDimTextFormat::kExponential7: val.format(L"Exponential, 7 digit for mantissa"); break;
  case OdDgDimTextFormat::kExponential8: val.format(L"Exponential, 8 digit for mantissa"); break;
  }
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimGeometry const& value)
{
  OdString val;
  val.format(L"%s:", name.c_str());
  dumpFieldName(val);

  writeFieldValue("  Witness line offset", value.getWitnessLineOffset());
  writeFieldValue("  Witness line extend", value.getWitnessLineExtend());
  writeFieldValue("  Text lift", value.getTextLift());
  writeFieldValue("  Text margin", value.getTextMargin());
  writeFieldValue("  Terminator width", value.getTerminatorWidth());
  writeFieldValue("  Terminator height", value.getTerminatorHeight());
  writeFieldValue("  Stack offset", value.getStackOffset());
  writeFieldValue("  Center size", value.getCenterSize());

  if (value.getUseMargin())
    writeFieldValue("  Min leader", value.getMargin());
  else
    writeFieldValue("  Min leader", value.getTerminatorWidth()*2.0);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimOptionPtr& value)
{
  OdString val;
  val.format(L"%s:", name.c_str());
  dumpFieldName(val);

  if (!value.isNull())
  {
    switch (value->getType())
    {
    case OdDgDimOption::kNone:
    {
      writeFieldValue("  Type", OdString(OD_T("kNone")));
    } break;

    case OdDgDimOption::kTolerance:
    {
      OdDgDimOptionTolerancePtr pTolerOptions = value;
      writeFieldValue("", pTolerOptions);
    } break;

    case OdDgDimOption::kTerminators:
    {
      OdDgDimOptionTerminatorsPtr pTermOptions = value;
      writeFieldValue("", pTermOptions);
    } break;

    case OdDgDimOption::kPrefixSymbol:
    {
      OdDgDimOptionPrefixSuffixSymbolPtr pSymbolOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kPrefixSymbol")));
      writeFieldValue("", pSymbolOptions);
    } break;

    case OdDgDimOption::kSuffixSymbol:
    {
      OdDgDimOptionPrefixSuffixSymbolPtr pSymbolOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kSuffixSymbol")));
      writeFieldValue("", pSymbolOptions);
    } break;

    case OdDgDimOption::kDiameterSymbol:
    {
      OdDgDimOptionSymbolPtr pSymbolOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kDiameterSymbol")));
      writeFieldValue("", pSymbolOptions);
    } break;

    case OdDgDimOption::kPrefixSuffix:
    {
      OdDimOptionPrefixSuffixPtr pPrefixSuffixOptions = value;
      writeFieldValue("", pPrefixSuffixOptions);
    } break;

    case OdDgDimOption::kPrimaryUnits:
    {
      OdDgDimOptionUnitsPtr pUnitsOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kPrimaryUnits")));
      writeFieldValue("", pUnitsOptions);
    } break;

    case OdDgDimOption::kSecondaryUnits:
    {
      OdDgDimOptionUnitsPtr pUnitsOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kSecondaryUnits")));
      writeFieldValue("", pUnitsOptions);
    } break;

    case OdDgDimOption::kTerminatorSymbology:
    {
      OdDgDimOptionTerminatorSymbologyPtr pTermSymbolOptions = value;
      writeFieldValue("", pTermSymbolOptions);
    } break;

    case OdDgDimOption::kView:
    {
      OdDgDimOptionViewPtr pViewOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kView")));

      if (!pViewOptions.isNull())
        writeFieldValue("  Rotation", pViewOptions->getQuaternion());
    } break;

    case OdDgDimOption::kAlternatePrimaryUnits:
    {
      OdDgDimOptionAltFormatPtr pAltOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kAlternativePrimaryUnits")));
      writeFieldValue("", pAltOptions);
    } break;

    case OdDgDimOption::kOffset:
    {
      OdDgDimOptionOffsetPtr pOffsetOptions = value;
      writeFieldValue("", pOffsetOptions);
    } break;

    case OdDgDimOption::kAlternateSecondaryUnits:
    {
      OdDgDimOptionAltFormatPtr pAltOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kAlternativeSecondaryUnits")));
      writeFieldValue("", pAltOptions);
    } break;

    case OdDgDimOption::kAlternatePrefixSymbol:
    {
      OdDgDimOptionSymbolPtr pSymbolOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kAlternatePrefixSymbol")));
      writeFieldValue("", pSymbolOptions);
    } break;

    case OdDgDimOption::kAlternateSuffixSymbol:
    {
      OdDgDimOptionSymbolPtr pSymbolOptions = value;
      writeFieldValue("  Type", OdString(OD_T("kAlternateSuffixSymbol")));
      writeFieldValue("", pSymbolOptions);
    } break;

    case OdDgDimOption::kProxyCell:
    {
      OdDgDimOptionProxyCellPtr pCellOptions = value;
      writeFieldValue("", pCellOptions);
    } break;
    }
  }
  else
  {
    writeFieldValue("  Type", OdString(OD_T("[value unknown]")));
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString&, OdDgDimOptionTolerancePtr& value)
{
  writeFieldValue("  Type", OdString(OD_T("kTolerance")));

  if (value.isNull())
    return;

  writeFieldValue("  Upper value", value->getToleranceUpper());
  writeFieldValue("  Lower value", value->getToleranceLower());
  writeFieldValue("  Stack if equal", value->getStackEqualFlag());
  writeFieldValue("  Show sign for zero", value->getShowSignForZeroFlag());
  writeFieldValue("  Left margin", value->getToleranceHorizSep());
  writeFieldValue("  Separator margin", value->getToleranceVertSep());
  writeFieldValue("  Font entry Id", value->getFontEntryId());
  writeFieldValue("  Text Width", value->getToleranceTextWidth());
  writeFieldValue("  Text Height", value->getToleranceTextHeight());

  if (value->getTolerancePlusMinusSymbol())
    writeFieldValue("  Plus/Minus symbol", value->getTolerancePlusMinusSymbol());

  if (value->getTolerancePrefixSymbol())
    writeFieldValue("  Prefix symbol", value->getTolerancePrefixSymbol());

  if (value->getToleranceSuffixSymbol())
    writeFieldValue("  Suffix symbol", value->getToleranceSuffixSymbol());

  writeFieldValue("  Stack align", value->getStackAlign());
}

inline void OdExDgnDumper::writeFieldValue(const OdString&, OdDgDimOptionTerminatorsPtr& value)
{
  writeFieldValue("  Type", OdString(OD_T("kTerminators")));

  if (value.isNull())
    return;

  if (value->getArrowTermStyle() == OdDgDimOptionTerminators::kTermDefault)
  {
    writeFieldValue("  Arrow style", OdString(OD_T("kTermDefault")));
  }
  else if (value->getArrowTermStyle() == OdDgDimOptionTerminators::kTermSymbol)
  {
    writeFieldValue("  Arrow style", OdString(OD_T("kTermSymbol")));
    writeFieldValue("  Arrow Font entry Id", value->getArrowFontID());
    writeFieldValue("  Arrow Symbol code", value->getArrowSymbol());
  }
  else if (value->getArrowTermStyle() == OdDgDimOptionTerminators::kTermCell)
  {
    writeFieldValue("  Arrow style", OdString(OD_T("kTermCell")));
    writeFieldValueHex("  Arrow Cell Id", value->getArrowCellID());
  }
  else
  {
    writeFieldValue("  Arrow style", OdString(OD_T("kTermScaledCell")));
    writeFieldValueHex("  Arrow Cell Id", value->getArrowCellID());
    writeFieldValue("  Arrow Cell scale", value->getSharedCellScale());
  }

  if (value->getStrokeTermStyle() == OdDgDimOptionTerminators::kTermDefault)
  {
    writeFieldValue("  Stroke style", OdString(OD_T("kTermDefault")));
  }
  else if (value->getStrokeTermStyle() == OdDgDimOptionTerminators::kTermSymbol)
  {
    writeFieldValue("  Stroke style", OdString(OD_T("kTermSymbol")));
    writeFieldValue("  Stroke Font entry Id", value->getStrokeFontID());
    writeFieldValue("  Stroke Symbol code", value->getStrokeSymbol());
  }
  else if (value->getStrokeTermStyle() == OdDgDimOptionTerminators::kTermCell)
  {
    writeFieldValue("  Stroke style", OdString(OD_T("kTermCell")));
    writeFieldValueHex("  Stroke Cell Id", value->getStrokeCellID());
  }
  else
  {
    writeFieldValue("  Stroke style", OdString(OD_T("kTermScaledCell")));
    writeFieldValueHex("  Stroke Cell Id", value->getStrokeCellID());
    writeFieldValue("  Stroke Cell scale", value->getSharedCellScale());
  }

  if (value->getOriginTermStyle() == OdDgDimOptionTerminators::kTermDefault)
  {
    writeFieldValue("  Origin style", OdString(OD_T("kTermDefault")));
  }
  else if (value->getOriginTermStyle() == OdDgDimOptionTerminators::kTermSymbol)
  {
    writeFieldValue("  Origin style", OdString(OD_T("kTermSymbol")));
    writeFieldValue("  Origin Font entry Id", value->getOriginFontID());
    writeFieldValue("  Origin Symbol code", value->getOriginSymbol());
  }
  else if (value->getOriginTermStyle() == OdDgDimOptionTerminators::kTermCell)
  {
    writeFieldValue("  Origin style", OdString(OD_T("kTermCell")));
    writeFieldValueHex("  Origin Cell Id", value->getOriginCellID());
  }
  else
  {
    writeFieldValue("  Origin style", OdString(OD_T("kTermScaledCell")));
    writeFieldValueHex("  Origin Cell Id", value->getOriginCellID());
    writeFieldValue("  Origin Cell scale", value->getSharedCellScale());
  }

  if (value->getDotTermStyle() == OdDgDimOptionTerminators::kTermDefault)
  {
    writeFieldValue("  Dot style", OdString(OD_T("kTermDefault")));
  }
  else if (value->getDotTermStyle() == OdDgDimOptionTerminators::kTermSymbol)
  {
    writeFieldValue("  Dot style", OdString(OD_T("kTermSymbol")));
    writeFieldValue("  Dot Font entry Id", value->getDotFontID());
    writeFieldValue("  Dot Symbol code", value->getDotSymbol());
  }
  else if (value->getDotTermStyle() == OdDgDimOptionTerminators::kTermCell)
  {
    writeFieldValue("  Dot style", OdString(OD_T("kTermCell")));
    writeFieldValueHex("  Dot Cell Id", value->getDotCellID());
  }
  else
  {
    writeFieldValue("  Dot style", OdString(OD_T("kTermScaledCell")));
    writeFieldValueHex("  Dot Cell Id", value->getDotCellID());
    writeFieldValue("  Dot Cell scale", value->getSharedCellScale());
  }

  if (value->getNoteTermStyle() == OdDgDimOptionTerminators::kTermDefault)
  {
    writeFieldValue("  Note style", OdString(OD_T("kTermDefault")));
  }
  else if (value->getNoteTermStyle() == OdDgDimOptionTerminators::kTermSymbol)
  {
    writeFieldValue("  Note style", OdString(OD_T("kTermSymbol")));
    writeFieldValue("  Note Font entry Id", value->getNoteFontID());
    writeFieldValue("  Note Symbol code", value->getNoteSymbol());
  }
  else if (value->getNoteTermStyle() == OdDgDimOptionTerminators::kTermCell)
  {
    writeFieldValue("  Note style", OdString(OD_T("kTermCell")));
    writeFieldValueHex("  Note Cell Id", value->getNoteCellID());
  }
  else
  {
    writeFieldValue("  Note style", OdString(OD_T("kTermScaledCell")));
    writeFieldValueHex("  Note Cell Id", value->getNoteCellID());
    writeFieldValue("  Note Cell scale", value->getSharedCellScale());
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString&, OdDgDimOptionTerminatorSymbologyPtr& value)
{
  writeFieldValue("  Type", OdString(OD_T("kTerminatorSymbology")));

  if (value.isNull())
    return;

  writeFieldValue("  Use Line type", value->getStyleFlag());
  writeFieldValue("  Use Line weight", value->getWeightFlag());
  writeFieldValue("  Use Color", value->getColorFlag());

  if (value->getStyleFlag())
    writeFieldValue("  Line Type entry Id", value->getStyle());

  if (value->getWeightFlag())
    writeFieldValue("  Line Weight", value->getWeight());

  if (value->getColorFlag())
    writeFieldValue("  Color", value->getColor());
}

inline void OdExDgnDumper::writeFieldValue(const OdString&, OdDgDimOptionSymbolPtr& value)
{
  if (value.isNull())
    return;

  writeFieldValue("  Font entry Id", value->getSymbolFont());
  writeFieldValue("  Symbol code", value->getSymbolChar());
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimOptionPrefixSuffixSymbolPtr& value)
{
  if (value.isNull())
    return;

  switch (value->getStyle())
  {
  case OdDgDimOptionPrefixSuffixSymbol::kNone:
  {
    writeFieldValue("  Style", OdString(OD_T("kNone")));
  } break;

  case OdDgDimOptionPrefixSuffixSymbol::kSymbol:
  {
    writeFieldValue("  Style", OdString(OD_T("kSymbol")));
    writeFieldValue("  Font entry Id", value->getSymbolFont());
    writeFieldValue("  Symbol code", value->getSymbolChar());
  } break;

  case OdDgDimOptionPrefixSuffixSymbol::kScaledCell:
  {
    writeFieldValue("  Style", OdString(OD_T("kScaledCell")));
    writeFieldValueHex("  Cell Id", value->getCellId());
    writeFieldValue("  Cell Scale", value->getCellScale());
  } break;
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString&, OdDimOptionPrefixSuffixPtr& value)
{
  writeFieldValue("  Type", OdString(OD_T("kPrefixSuffix")));

  if (value.isNull())
    return;

  if (value->getMainPrefix())
  {
    writeFieldValue("  Main prefix", value->getMainPrefix());
  }

  if (value->getMainSuffix())
  {
    writeFieldValue("  Main suffix", value->getMainSuffix());
  }

  if (value->getUpperPrefix())
  {
    writeFieldValue("  Upper prefix", value->getUpperPrefix());
  }

  if (value->getUpperSuffix())
  {
    writeFieldValue("  Upper suffix", value->getUpperSuffix());
  }

  if (value->getLowerPrefix())
  {
    writeFieldValue("  Lower prefix", value->getLowerPrefix());
  }

  if (value->getLowerSuffix())
  {
    writeFieldValue("  Lower suffix", value->getLowerSuffix());
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::UnitBase value)
{
  if (value == OdDgModel::kNone)
  {
    writeFieldValue(name, OdString(OD_T("kNone")));
  }
  else if (value == OdDgModel::kMeter)
  {
    writeFieldValue(name, OdString(OD_T("kMeter")));
  }
  else
  {
    writeFieldValue(name, OdString(OD_T("Unknown")));
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::UnitSystem value)
{
  if (value == OdDgModel::kCustom)
  {
    writeFieldValue(name, OdString(OD_T("kCustom")));
  }
  else if (value == OdDgModel::kMetric)
  {
    writeFieldValue(name, OdString(OD_T("kMetric")));
  }
  else if (value == OdDgModel::kEnglish)
  {
    writeFieldValue(name, OdString(OD_T("kEnglish")));
  }
  else
  {
    writeFieldValue(name, OdString(OD_T("Unknown")));
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString&, OdDgDimOptionUnitsPtr& value)
{
  if (value.isNull())
    return;

  OdDgModel::UnitDescription descr;
  value->getMasterUnit(descr);
  dumpFieldName(L"  Master units:");
  writeFieldValue(L"    Unit base", descr.m_base);
  writeFieldValue(L"    Unit system", descr.m_system);
  writeFieldValue(L"    Numerator", descr.m_numerator);
  writeFieldValue(L"    Denominator", descr.m_denominator);
  writeFieldValue(L"    Name", descr.m_name);
  value->getSubUnit(descr);
  dumpFieldName(L"  Sub units:");
  writeFieldValue(L"    Unit base", descr.m_base);
  writeFieldValue(L"    Unit system", descr.m_system);
  writeFieldValue(L"    Numerator", descr.m_numerator);
  writeFieldValue(L"    Denominator", descr.m_denominator);
  writeFieldValue(L"    Name", descr.m_name);
}

inline void OdExDgnDumper::writeFieldValue(const OdString&, OdDgDimOptionAltFormatPtr& value)
{
  if (value.isNull())
    return;

  writeFieldValue("  Accuracy", value->getAccuracy());
  writeFieldValue("  Show sub units", value->getSubUnits());
  writeFieldValue("  Show unit labels", value->getLabel());
  writeFieldValue("  Show delimiter", value->getDelimiter());
  writeFieldValue("  Show sub units only", value->getNoMasterUnits());
  writeFieldValue("  Allow zero master units", value->getAllowZeroMasterUnits());

  if (value->getMoreThanThreshold())
  {
    if (value->getEqualToThreshold())
    {
      writeFieldValue("  Condition", OdString(OD_T(">=")));
    }
    else
    {
      writeFieldValue("  Condition", OdString(OD_T(">")));
    }
  }
  else
  {
    if (value->getEqualToThreshold())
    {
      writeFieldValue("  Condition", OdString(OD_T("<=")));
    }
    else
    {
      writeFieldValue("  Condition", OdString(OD_T("<")));
    }
  }

  writeFieldValue("  Threshold", value->getThreshold());
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimOptionOffset::ChainType value)
{
  dumpFieldName(name);

  OdString strValue;

  switch (value)
  {
  case OdDgDimOptionOffset::kNone:
  {
    strValue = OD_T("kNone");
  } break;

  case OdDgDimOptionOffset::kLine:
  {
    strValue = OD_T("kLine");
  } break;

  case OdDgDimOptionOffset::kArc:
  {
    strValue = OD_T("kArc");
  } break;

  case OdDgDimOptionOffset::kBSpline:
  {
    strValue = OD_T("kBSpline");
  } break;
  }

  dumpFieldValue(strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimOptionOffset::LeaderAlignment value)
{
  dumpFieldName(name);

  OdString strValue;

  switch (value)
  {
  case OdDgDimOptionOffset::kAutoAlignment:
  {
    strValue = OD_T("kAutoAlignment");
  } break;

  case OdDgDimOptionOffset::kLeftAlignment:
  {
    strValue = OD_T("kLeftAlignment");
  } break;

  case OdDgDimOptionOffset::kRightAlignment:
  {
    strValue = OD_T("kRightAlignment");
  } break;
  }

  dumpFieldValue(strValue);
}


inline void OdExDgnDumper::writeFieldValue(const OdString&, OdDgDimOptionOffsetPtr& value)
{
  writeFieldValue("  Type", OdString(OD_T("kOffset")));

  if (value.isNull())
    return;

  writeFieldValue("  Terminator", value->getTerminator());
  writeFieldValue("  Chain type", value->getChainType());
  writeFieldValue("  Elbow", value->getElbowFlag());
  writeFieldValue("  Alignment", value->getAlignment());
  writeFieldValue("  No dock on dim line", value->getNoDockOnDimLineFlag());
}

inline void OdExDgnDumper::writeFieldValue(const OdString&, OdDgDimOptionProxyCellPtr& value)
{
  writeFieldValue("  Type", OdString(OD_T("kProxyCell")));

  if (value.isNull())
    return;

  writeFieldValue("  Origin", value->getOrigin());
  writeFieldValue("  Rotation Matrix", value->getRotScale());
  writeFieldValueHex("  Check Sum", value->getCheckSum());
  writeFieldValueHex("  Cell Id", value->getProxyCellId());
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgMultilineSymbology const& value)
{
  OdString val;
  val.format(L"%s:", name.c_str());
  dumpFieldName(val);

  writeFieldValue("Style", value.getLineStyleEntryId());
  writeFieldValue("Weight", value.getLineWeight());
  writeFieldValue("Color", value.getColorIndex());
  writeFieldValue("Use style", value.getUseStyleFlag());
  writeFieldValue("Use weight", value.getUseWeightFlag());
  writeFieldValue("Use color", value.getUseColorFlag());
  writeFieldValue("Use class", value.getUseClassFlag());
  writeFieldValue("Inside arc", value.getCapInArcFlag());
  writeFieldValue("Outside arc", value.getCapOutArcFlag());
  writeFieldValue("Cap line", value.getCapLineFlag());
  writeFieldValue("Custom style", value.getCustomStyleFlag());
  writeFieldValue("Cap color from segment", value.getCapColorFromSegmentFlag());
  writeFieldValue("Construction class", value.getConstructionClassFlag());
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgMultilinePoint const& value)
{
  OdString val;
  val.format(L"%s:", name.c_str());
  dumpFieldName(val);

  {
    OdGePoint3d point;

    value.getPoint(point);
    writeFieldValue("Point", point);
  }

  {
    OdUInt32            i, j = value.getBreaksCount();
    OdDgMultilineBreak  break_;
    char                fieldName[20];

    writeFieldValue("Number of breaks", j);

    for (i = 0; i < j; i++)
    {
#if OD_SIZEOF_LONG == 4
      sprintf(fieldName, "Break %lu", i);
#else
      sprintf(fieldName, "Break %u", i);
#endif
      value.getBreak(i, break_);
      writeFieldValue(fieldName, break_);
    }
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTextInfo::FitOptions value)
{
  dumpFieldName(name);

  OdString strVal;

  switch (value)
  {
  case OdDgDimTextInfo::kTermMovesFirst: strVal = "kTermMovesFirst"; break;
  case OdDgDimTextInfo::kTermReversed: strVal = "kTermReversed"; break;
  case OdDgDimTextInfo::kTermInside: strVal = "kTermInside"; break;
  case OdDgDimTextInfo::kTermOutside: strVal = "kTermOutside"; break;
  case OdDgDimTextInfo::kTextInside: strVal = "kTextInside"; break;
  case OdDgDimTextInfo::kTextMovesFirst: strVal = "kTextMovesFirst"; break;
  case OdDgDimTextInfo::kBothMoves: strVal = "kBothMoves"; break;
  case OdDgDimTextInfo::kSmallestMoves: strVal = "kSmallestMoves"; break;
  }

  dumpFieldValue(strVal);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTextInfo::TextLocation value)
{
  dumpFieldName(name);

  OdString strVal;

  switch (value)
  {
  case OdDgDimTextInfo::kTextInline: strVal = "kTextInline"; break;
  case OdDgDimTextInfo::kTextAbove: strVal = "kTextAbove"; break;
  case OdDgDimTextInfo::kTextOutside: strVal = "kTextOutside"; break;
  default: strVal = "kTextTopLeft"; break;
  }

  dumpFieldValue(strVal);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgMultilineBreak const& value)
{
  OdString val;
  val.format(L"%s:", name.c_str());
  dumpFieldName(val);

  writeFieldValue("Lines mask", value.getLinesMask());
  writeFieldValue("Offset", value.getOffset());
  writeFieldValue("Length", value.getLength());

  {
    OdString flagValue;

    switch (value.getFlags())
    {
    case OdDgMultilineBreak::kStandardByDistance: flagValue = "Standard by distance"; break;
    case OdDgMultilineBreak::kFromJoint: flagValue = "from joint"; break;
    case OdDgMultilineBreak::kToJoint: flagValue = "to joing"; break;
    }

    writeFieldValue("Flag", flagValue);
  }
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgMultilineProfile const& value)
{
  OdString val;
  val.format(L"%s:", name.c_str());
  dumpFieldValue(val);

  writeFieldValue("Distance", value.getDistance());

  {
    OdDgMultilineSymbology symbology;

    value.getSymbology(symbology);
    writeFieldValue("Symbology", symbology);
  }
}


//#pragma MARKMESSAGE("TODO: Examples. SurfaceType interface was modified.");
//
//inline void OdExDgnDumper::writeFieldValue( const OdString& name, Dgn8::SurfaceType value )
//{
//  dumpFieldName( name );
//
//  switch( value )
//  {
//  case Dgn8::SURF_PROJECTION     : val.format( LSurface (or solid) of projection" ); break;
//  case Dgn8::SOLID_REVOLUTION    : val.format( LSolid of revolution" ); break;
//  case Dgn8::SURF_REVOLUTION     : val.format( LSurface of revolution" ); break;
//  case Dgn8::SURF_FORCEDWORD     : val.format( LUnknown type" ); break;
//  }
//}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgTextExtendedProperties::LineSpacingType value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgTextExtendedProperties::kExact: val.format(L"Exact"); break;
  case OdDgTextExtendedProperties::kAutomatic: val.format(L"Automatic"); break;
  case OdDgTextExtendedProperties::kFromLineTop: val.format(L"FromLineTop"); break;
  case OdDgTextExtendedProperties::kAtLeast: val.format(L"AtLeast"); break;
  }
  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgRaster::RasterFormat value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgRaster::kBitmap: val.format(L"Bitmap raster"); break;
  case OdDgRaster::kByteData: val.format(L"Byte data raster"); break;
  case OdDgRaster::kBinaryRLE: val.format(L"Binary RLE raster"); break;
  case OdDgRaster::kByteRLE: val.format(L"Byte RLE raster"); break;
  }
  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgTagDefinition::Type value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgTagDefinition::kChar: val.format(L"Char"); break;
  case OdDgTagDefinition::kInt16: val.format(L"Short int"); break;
  case OdDgTagDefinition::kInt32: val.format(L"Long int"); break;
  case OdDgTagDefinition::kDouble: val.format(L"Double"); break;
  case OdDgTagDefinition::kBinary: val.format(L"Binary"); break;
  }
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDg::TextDirection value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDg::kHorizontal: val.format(L"Horizontal"); break;
  case OdDg::kVertical: val.format(L"Vertical"); break;
  case OdDg::kJapanese: val.format(L"Japanese"); break;
  case OdDg::kRightToLeft: val.format(L"Right-to-left"); break;
  }
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdGeMatrix3d const& value)
{
  dumpFieldName(name);

  OdString val;
  val.format(L"%g; %g; %g; %g; %g; %g; %g; %g; %g",
    value(0, 0), value(1, 0), value(2, 0),
    value(0, 1), value(1, 1), value(2, 1),
    value(0, 2), value(1, 2), value(2, 2));
  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdGsDCRect const& value)
{
  dumpFieldName(name);

  OdString val;
  val.format(L"( 0x%X; 0x%X ) - ( 0x%X; 0x%X )\n", value.m_min.x, value.m_min.y, value.m_max.x, value.m_max.y);

  dumpFieldValue(val);
}


inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgElementId const& value)
{
  writeFieldValue(name, L"0x" + value.getHandle().ascii());
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, const OdVariant& val)
{
  switch (val.type())
  {
  case OdVariant::kBool:
  {
    if (val.isArray())
      writeFieldValue(name, val.getBoolArray());
    else
      writeFieldValue(name, val.getBool());
  }
  break;

  case OdVariant::kInt8:
  {
    if (val.isArray())
      writeFieldValue(name, val.getInt8Array());
    else
      writeFieldValue(name, val.getInt8());
  }
  break;

  case OdVariant::kInt16:
  {
    if (val.isArray())
      writeFieldValue(name, val.getInt16Array());
    else
      writeFieldValue(name, val.getInt16());
  }
  break;

  case OdVariant::kInt32:
  {
    if (val.isArray())
      writeFieldValue(name, val.getInt32Array());
    else
      writeFieldValue(name, val.getInt32());
  }
  break;

  case OdVariant::kInt64:
  {
    if (val.isArray())
      writeFieldValue(name, val.getInt64Array());
    else
      writeFieldValue(name, val.getInt64());
  }
  break;

  case OdVariant::kDouble:
  {
    if (val.isArray())
      writeFieldValue(name, val.getDoubleArray());
    else
      writeFieldValue(name, val.getDouble());
  }
  break;

  case OdVariant::kString:
  {
    if (val.isArray())
      writeFieldValue(name, val.getStringArray());
    else
      writeFieldValue(name, val.getString());
  }
  break;

  case OdVariant::kAnsiString:
  {
    if (val.isArray())
      writeFieldValue(name, val.getAnsiStringArray());
    else
      writeFieldValue(name, OdString(val.getAnsiString()));
  }
  break;
  }
}

inline void OdExDgnDumper::writeFieldValue(OdString const& name, OdGeExtents2d const& value)
{
  dumpFieldName(name);

  OdGePoint2d min = value.minPoint(), max = value.maxPoint();

  OdString val;
  val.format(L"Low point: %g; %g;  High point: %g; %g",
    min.x, min.y,
    max.x, max.y
  );
  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(OdString const& name, OdGeExtents3d const& value)
{
  dumpFieldName(name);

  OdGePoint3d min = value.minPoint(), max = value.maxPoint();

  OdString val;
  val.format(L"Low point: %g; %g; %g;  High point: %g; %g; %g",
    min.x, min.y, min.z,
    max.x, max.y, max.z
  );
  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDg::LineStyleType value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDg::kLsTypePointSymbol:
    val = L"kPointSymbol";
    break;
  case OdDg::kLsTypeCompound:
    val = L"kCompound";
    break;
  case OdDg::kLsTypeLineCode:
    val = L"kLineCode";
    break;
  case OdDg::kLsTypeLinePoint:
    val = L"kLinePoint";
    break;
  }

  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDg::LineStyleUnitsType value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDg::kLsMasterUnits:
    val = L"kMasterUnits";
    break;
  case OdDg::kLsUORS:
    val = L"kUORs";
    break;
  case OdDg::kLsDeviceUnits:
    val = L"kDeviceUnits";
    break;
  }

  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLineStyleResource::OdLsResourceType value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgLineStyleResource::kLsUnknownRes:
    val = L"kUnknownRes";
    break;
  case OdDgLineStyleResource::kLsPointSymbolResV7:
    val = L"kPointSymbolV7Res";
    break;
  case OdDgLineStyleResource::kLsPointSymbolRes:
    val = L"kPointSymbolRes";
    break;
  case OdDgLineStyleResource::kLsCompoundRes:
    val = L"kCompoundRes";
    break;
  case OdDgLineStyleResource::kLsLineCodeRes:
    val = L"kLineCodeRes";
    break;
  case OdDgLineStyleResource::kLsLinePointRes:
    val = L"kLinePointRes";
    break;
  case OdDgLineStyleResource::kLsInternalRes:
    val = L"kInternalRes";
    break;
  }

  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLineCodeResourceStrokeData::OdLsStrokeWidthMode value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgLineCodeResourceStrokeData::kLsNoWidth:
    val = L"kNoWidth";
    break;
  case OdDgLineCodeResourceStrokeData::kLsWidthLeft:
    val = L"kLeftWidth";
    break;
  case OdDgLineCodeResourceStrokeData::kLsWidthRight:
    val = L"kRightWidth";
    break;
  case OdDgLineCodeResourceStrokeData::kLsWidthFull:
    val = L"kFullWidth";
    break;
  }

  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLineCodeResourceStrokeData::OdLsStrokeCapsType value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgLineCodeResourceStrokeData::kLsCapsClosed:
    val = L"kCapsClosed";
    break;
  case OdDgLineCodeResourceStrokeData::kLsCapsOpen:
    val = L"kCapsOpen";
    break;
  case OdDgLineCodeResourceStrokeData::kLsCapsExtended:
    val = L"kCapsExtended";
    break;
  case OdDgLineCodeResourceStrokeData::kLsCapsHexagon:
    val = L"kCapsHexagon";
    break;
  case OdDgLineCodeResourceStrokeData::kLsCapsOctagon:
    val = L"kCapsOctagon";
    break;
  case OdDgLineCodeResourceStrokeData::kLsCapsDecagon:
    val = L"kCapsDecagon";
    break;
  case OdDgLineCodeResourceStrokeData::kLsCapsArc:
    val = L"kCapsArc";
    break;
  }

  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLinePointResourceSymInfo::OdLsSymbolPosOnStroke value)
{
  dumpFieldName(name);

  OdString val;
  switch (value)
  {
  case OdDgLinePointResourceSymInfo::kLsNoSymbol:
    val = L"kNoSymbol";
    break;
  case OdDgLinePointResourceSymInfo::kLsAtOriginOfStroke:
    val = L"kAtOriginOfStroke";
    break;
  case OdDgLinePointResourceSymInfo::kLsAtEndOfStroke:
    val = L"kAtEndOfStroke";
    break;
  case OdDgLinePointResourceSymInfo::kLsAtCenterOfStroke:
    val = L"kAtCenterOfStroke";
    break;
  }

  dumpFieldValue(val);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTool::TerminatorType iType)
{
  switch (iType)
  {
  case OdDgDimTool::kTtNone:
  {
    writeFieldValue(name, OdString(OD_T("kTtNone")));
  } break;

  case OdDgDimTool::kTtArrow:
  {
    writeFieldValue(name, OdString(OD_T("kTtArrow")));
  } break;

  case OdDgDimTool::kTtStroke:
  {
    writeFieldValue(name, OdString(OD_T("kTtStroke")));
  } break;

  case OdDgDimTool::kTtCircle:
  {
    writeFieldValue(name, OdString(OD_T("kTtCircle")));
  } break;

  case OdDgDimTool::kTtFilledCircle:
  {
    writeFieldValue(name, OdString(OD_T("kTtFilledCircle")));
  } break;
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTool::TextType iType)
{
  switch (iType)
  {
  case OdDgDimTool::kStandard:
  {
    writeFieldValue(name, OdString(OD_T("kStandard")));
  } break;

  case OdDgDimTool::kVertical:
  {
    writeFieldValue(name, OdString(OD_T("kVertical")));
  } break;

  case OdDgDimTool::kMixed:
  {
    writeFieldValue(name, OdString(OD_T("kMixed")));
  } break;
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTool::CustomSymbol iSymbol)
{
  switch (iSymbol)
  {
  case OdDgDimTool::kCsNone:
  {
    writeFieldValue(name, OdString(OD_T("kCsNone")));
  } break;

  case OdDgDimTool::kCsDiameter:
  {
    writeFieldValue(name, OdString(OD_T("kCsDiameter")));
  } break;

  case OdDgDimTool::kCsRadius:
  {
    writeFieldValue(name, OdString(OD_T("kCsRadius")));
  } break;

  case OdDgDimTool::kCsSquare:
  {
    writeFieldValue(name, OdString(OD_T("kCsSquare")));
  } break;

  case OdDgDimTool::kCsSR:
  {
    writeFieldValue(name, OdString(OD_T("kCsSR")));
  } break;

  case OdDgDimTool::kCsSDiameter:
  {
    writeFieldValue(name, OdString(OD_T("kCsSDiameter")));
  } break;
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTool::Leader iLeader)
{
  switch (iLeader)
  {
  case OdDgDimTool::kRadius:
  {
    writeFieldValue(name, OdString(OD_T("kRadius")));
  } break;

  case OdDgDimTool::kRadiusExt1:
  {
    writeFieldValue(name, OdString(OD_T("kRadiusExt1")));
  } break;

  case OdDgDimTool::kRadiusExt2:
  {
    writeFieldValue(name, OdString(OD_T("kRadiusExt2")));
  } break;

  case OdDgDimTool::kDiameter:
  {
    writeFieldValue(name, OdString(OD_T("kDiameter")));
  } break;
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimensionPtr pElement)
{
  switch (pElement->getDimensionType())
  {
  case OdDgDimension::kToolTypeSizeArrow:
  {
    OdDgDimSizeArrowPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeSizeStroke:
  {
    OdDgDimSizeStrokePtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeLocateSingle:
  {
    OdDgDimSingleLocationPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeLocateStacked:
  {
    OdDgDimStackedLocationPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeCustomLinear:
  {
    OdDgDimCustomLinearPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeAngleSize:
  {
    OdDgDimAngleSizePtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeAngleLines:
  {
    OdDgDimAngleLinesPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeAngleLocation:
  {
    OdDgDimAngleLocationPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeArcLocation:
  {
    OdDgDimArcLocationPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeAngleAxisX:
  {
    OdDgDimAngleAxisXPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeAngleAxisY:
  {
    OdDgDimAngleAxisYPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeArcSize:
  {
    OdDgDimArcSizePtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeRadius:
  {
    OdDgDimRadiusPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeRadiusExtended:
  {
    OdDgDimRadiusExtendedPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeDiameter:
  {
    OdDgDimDiameterPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeDiameterExtended:
  {
    OdDgDimDiameterExtendedPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeDiameterPara:
  {
    OdDgDimDiameterParallelPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeDiameterPerp:
  {
    OdDgDimDiameterPerpendicularPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeOrdinate:
  {
    OdDgDimOrdinatePtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;

  case OdDgDimension::kToolTypeCenter:
  {
    OdDgDimCenterPtr pDimSize = pElement;

    if (!pDimSize.isNull())
      writeFieldValue(name, pDimSize);
  } break;
  }
}

#undef  OUT_LINEAR_DIM_TOOL_FIELDS
#define OUT_LINEAR_DIM_TOOL_FIELDS( type ) \
inline void OdExDgnDumper::writeFieldValue( const OdString& name, type pElement ) \
{ \
  dumpFieldName( name ); \
  writeFieldValue("  StackExtLinesFlag", pElement->getStackExtLinesFlag() );  \
  writeFieldValue("  LeftExtLinesPresentFlag", pElement->getLeftExtLinesPresentFlag() );  \
  writeFieldValue("  RightExtLinesPresentFlag", pElement->getRightExtLinesPresentFlag() );  \
  writeFieldValue("  ArcSymbolFlag", pElement->getArcSymbolFlag() );  \
  writeFieldValue("  FirstTerminator", pElement->getFirstTerminator() );  \
  writeFieldValue("  LeftTerminator", pElement->getLeftTerminator() );  \
  writeFieldValue("  RightTerminator", pElement->getRightTerminator() );  \
  writeFieldValue("  JointTerminator", pElement->getJointTerminator() );  \
  writeFieldValue("  TextType", pElement->getTextType() );  \
  writeFieldValue("  Prefix", pElement->getPrefix() );  \
  writeFieldValue("  Suffix", pElement->getSuffix() );  \
}

OUT_LINEAR_DIM_TOOL_FIELDS(OdDgDimSizeArrowPtr)
OUT_LINEAR_DIM_TOOL_FIELDS(OdDgDimSizeStrokePtr)
OUT_LINEAR_DIM_TOOL_FIELDS(OdDgDimSingleLocationPtr)
OUT_LINEAR_DIM_TOOL_FIELDS(OdDgDimStackedLocationPtr)
OUT_LINEAR_DIM_TOOL_FIELDS(OdDgDimCustomLinearPtr)

#undef  OUT_ANGULAR_SHORT_DIM_TOOL_FIELDS
#define OUT_ANGULAR_SHORT_DIM_TOOL_FIELDS( type ) \
inline void OdExDgnDumper::writeFieldValue( const OdString& name, type pElement ) \
{ \
  dumpFieldName( name ); \
  writeFieldValue("  StackExtLinesFlag", pElement->getStackExtLinesFlag() );  \
  writeFieldValue("  LeftExtLinesPresentFlag", pElement->getLeftExtLinesPresentFlag() );  \
  writeFieldValue("  RightExtLinesPresentFlag", pElement->getRightExtLinesPresentFlag() ); \
  writeFieldValue("  ArcSymbolFlag", pElement->getArcSymbolFlag() );  \
  writeFieldValue("  LeftTerminator", pElement->getLeftTerminator() ); \
  writeFieldValue("  RightTerminator", pElement->getRightTerminator() ); \
  writeFieldValue("  Prefix", pElement->getPrefix() );  \
  writeFieldValue("  Suffix", pElement->getSuffix() );  \
}

OUT_ANGULAR_SHORT_DIM_TOOL_FIELDS(OdDgDimAngleSizePtr)
OUT_ANGULAR_SHORT_DIM_TOOL_FIELDS(OdDgDimAngleLinesPtr)
OUT_ANGULAR_SHORT_DIM_TOOL_FIELDS(OdDgDimDiameterParallelPtr)
OUT_ANGULAR_SHORT_DIM_TOOL_FIELDS(OdDgDimDiameterPerpendicularPtr)

#undef  OUT_ANGULAR_DIM_TOOL_FIELDS
#define OUT_ANGULAR_DIM_TOOL_FIELDS( type ) \
inline void OdExDgnDumper::writeFieldValue( const OdString& name, type pElement ) \
{ \
  dumpFieldName( name ); \
  writeFieldValue("  StackExtLinesFlag", pElement->getStackExtLinesFlag() );  \
  writeFieldValue("  LeftExtLinesPresentFlag", pElement->getLeftExtLinesPresentFlag() );  \
  writeFieldValue("  RightExtLinesPresentFlag", pElement->getRightExtLinesPresentFlag() ); \
  writeFieldValue("  ArcSymbolFlag", pElement->getArcSymbolFlag() );  \
  writeFieldValue("  FirstTerminator", pElement->getFirstTerminator() );  \
  writeFieldValue("  LeftTerminator", pElement->getLeftTerminator() ); \
  writeFieldValue("  RightTerminator", pElement->getRightTerminator() ); \
  writeFieldValue("  Prefix", pElement->getPrefix() );  \
  writeFieldValue("  Suffix", pElement->getSuffix() );  \
}

OUT_ANGULAR_DIM_TOOL_FIELDS(OdDgDimAngleLocationPtr)
OUT_ANGULAR_DIM_TOOL_FIELDS(OdDgDimArcLocationPtr)
OUT_ANGULAR_DIM_TOOL_FIELDS(OdDgDimAngleAxisXPtr)
OUT_ANGULAR_DIM_TOOL_FIELDS(OdDgDimAngleAxisYPtr)

#undef  OUT_RADIAL_DIM_TOOL_FIELDS
#define OUT_RADIAL_DIM_TOOL_FIELDS( type ) \
  inline void OdExDgnDumper::writeFieldValue( const OdString& name, type pElement ) \
{ \
  dumpFieldName( name ); \
  writeFieldValue("  StackExtLinesFlag", pElement->getStackExtLinesFlag() );  \
  writeFieldValue("  CenterMarkFlag", pElement->getCenterMarkFlag() );  \
  writeFieldValue("  CenterMarkLeftExtendFlag", pElement->getCenterMarkLeftExtendFlag() );  \
  writeFieldValue("  CenterMarkRightExtendFlag", pElement->getCenterMarkRightExtendFlag() );  \
  writeFieldValue("  CenterMarkTopExtendFlag", pElement->getCenterMarkTopExtendFlag() );  \
  writeFieldValue("  CenterMarkBottomExtendFlag", pElement->getCenterMarkBottomExtendFlag() );  \
  writeFieldValue("  ArcSymbolFlag", pElement->getArcSymbolFlag() );  \
  writeFieldValue("  RightTerminator", pElement->getRightTerminator() ); \
  writeFieldValue("  Prefix", pElement->getPrefix() );  \
  writeFieldValue("  Suffix", pElement->getSuffix() );  \
  writeFieldValue("  Leader", pElement->getLeader() );  \
}

OUT_RADIAL_DIM_TOOL_FIELDS(OdDgDimRadiusPtr)
OUT_RADIAL_DIM_TOOL_FIELDS(OdDgDimRadiusExtendedPtr)
OUT_RADIAL_DIM_TOOL_FIELDS(OdDgDimDiameterPtr)
OUT_RADIAL_DIM_TOOL_FIELDS(OdDgDimDiameterExtendedPtr)

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimArcSizePtr pElement)
{
  dumpFieldName(name);
  writeFieldValue("  StackExtLinesFlag", pElement->getStackExtLinesFlag());
  writeFieldValue("  LeftExtLinesPresentFlag", pElement->getLeftExtLinesPresentFlag());
  writeFieldValue("  RightExtLinesPresentFlag", pElement->getRightExtLinesPresentFlag());
  writeFieldValue("  ArcSymbolFlag", pElement->getArcSymbolFlag());
  writeFieldValue("  ChordAlignFlag", pElement->getChordAlignFlag());
  writeFieldValue("  LeftTerminator", pElement->getLeftTerminator());
  writeFieldValue("  RightTerminator", pElement->getRightTerminator());
  writeFieldValue("  Prefix", pElement->getPrefix());
  writeFieldValue("  Suffix", pElement->getSuffix());
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimOrdinatePtr pElement)
{
  dumpFieldName(name);
  writeFieldValue("  StackExtLinesFlag", pElement->getStackExtLinesFlag());
  writeFieldValue("  ArcSymbolFlag", pElement->getArcSymbolFlag());
  writeFieldValue("  DecrementInReverseDirectionFlag", pElement->getDecrementInReverseDirectionFlag());
  writeFieldValue("  FreeLocationOfTxtFlag", pElement->getFreeLocationOfTxtFlag());
  writeFieldValue("  Datum value", pElement->getDatumValue());
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimCenterPtr pElement)
{
  dumpFieldName(name);
  writeFieldValue("  CenterMarkLeftExtendFlag", pElement->getCenterMarkLeftExtendFlag());
  writeFieldValue("  CenterMarkRightExtendFlag", pElement->getCenterMarkRightExtendFlag());
  writeFieldValue("  CenterMarkTopExtendFlag", pElement->getCenterMarkTopExtendFlag());
  writeFieldValue("  CenterMarkBottomExtendFlag", pElement->getCenterMarkBottomExtendFlag());
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimension::PlacementAlignment value)
{
  OdString strAlign;

  switch (value)
  {
  case OdDgDimension::kPaView:
  {
    strAlign = OD_T("kPaView");
  }
  break;

  case OdDgDimension::kPaDrawing:
  {
    strAlign = OD_T("kPaDrawing");
  }
  break;

  case OdDgDimension::kPaTrue:
  {
    strAlign = OD_T("kPaTrue");
  }
  break;

  case OdDgDimension::kPaArbitrary:
  {
    strAlign = OD_T("kPaArbitrary");
  }
  break;
  }

  writeFieldValue(name, strAlign);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTextFormat::LabelDisplayMode value)
{
  OdString strAlign;

  switch (value)
  {
  case OdDgDimTextFormat::kMu:
  {
    strAlign = OD_T("Mu");
  }
  break;

  case OdDgDimTextFormat::kMuLabel:
  {
    strAlign = OD_T("Mu Label");
  }
  break;

  case OdDgDimTextFormat::kSu:
  {
    strAlign = OD_T("Su");
  }
  break;

  case OdDgDimTextFormat::kSuLabel:
  {
    strAlign = OD_T("Su Label");
  }
  break;

  case OdDgDimTextFormat::kMu_Su:
  {
    strAlign = OD_T("Mu-Su");
  }
  break;

  case OdDgDimTextFormat::kMuLabelSuLabel:
  {
    strAlign = OD_T("Mu Label Su Label");
  }
  break;

  case OdDgDimTextFormat::kMuLabel_SuLabel:
  {
    strAlign = OD_T("Mu Label-Su Label");
  }
  break;
  }

  writeFieldValue(name, strAlign);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLevelFilterTable::OdDgFilterMemberType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgLevelFilterTable::kMemberTypeShort:
  {
    strValue = OD_T("kTypeShort");
  } break;

  case OdDgLevelFilterTable::kMemberTypeInt:
  {
    strValue = OD_T("kTypeInt");
  } break;

  case OdDgLevelFilterTable::kMemberTypeBool:
  {
    strValue = OD_T("kTypeBool");
  } break;

  case OdDgLevelFilterTable::kMemberTypeChar:
  {
    strValue = OD_T("kTypeChar");
  } break;

  case OdDgLevelFilterTable::kMemberTypeWChar:
  {
    strValue = OD_T("kTypeWChar");
  } break;

  case OdDgLevelFilterTable::kMemberTypeDouble:
  {
    strValue = OD_T("kTypeDouble");
  } break;

  case OdDgLevelFilterTable::kMemberTypeTime:
  {
    strValue = OD_T("kTypeTime");
  } break;

  default:
  {
    strValue = OD_T("kTypeNull");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgGradientFill::OdDgGradientType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgGradientFill::kCurved:
  {
    strValue = OD_T("kCurved");
  } break;

  case OdDgGradientFill::kCylindrical:
  {
    strValue = OD_T("kCylindrical");
  } break;

  case OdDgGradientFill::kSpherical:
  {
    strValue = OD_T("kSpherical");
  } break;

  case OdDgGradientFill::kHemispherical:
  {
    strValue = OD_T("kHemispherical");
  } break;

  default:
  {
    strValue = OD_T("kLinear");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLineStyleModificationLinkage::OdDgLsModWidthMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgLineStyleModificationLinkage::kLsModConstantWidth:
  {
    strValue = OD_T("kConstantWidth");
  } break;

  case OdDgLineStyleModificationLinkage::kLsModTaperedWidth:
  {
    strValue = OD_T("kTaperedWidth");
  } break;

  default:
  {
    strValue = OD_T("kNoWidth");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLineStyleModificationLinkage::OdDgLsModShiftMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgLineStyleModificationLinkage::kLsModCentered:
  {
    strValue = OD_T("kCentered");
  } break;

  case OdDgLineStyleModificationLinkage::kLsModDistance:
  {
    strValue = OD_T("kDistance");
  } break;

  case OdDgLineStyleModificationLinkage::kLsModFraction:
  {
    strValue = OD_T("kFraction");
  } break;

  default:
  {
    strValue = OD_T("kNoShift");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLineStyleModificationLinkage::OdDgLsModCornerMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgLineStyleModificationLinkage::kLsModBreakAtCorners:
  {
    strValue = OD_T("kBreakAtCorners");
  } break;

  case OdDgLineStyleModificationLinkage::kLsModRunThroughCorners:
  {
    strValue = OD_T("kRunThroughCorners");
  } break;

  default:
  {
    strValue = OD_T("kFromLineStyle");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDg::OdDgInfiniteLineType type)
{
  OdString strValue;

  switch (type)
  {
  case OdDg::kFromStartPoint:
  {
    strValue = OD_T("kFromStartPoint");
  } break;

  case OdDg::kFromEndPoint:
  {
    strValue = OD_T("kFromEndPoint");
  } break;

  case OdDg::kInfiniteLine:
  {
    strValue = OD_T("kInfiniteLine");
  } break;

  default:
  {
    strValue = OD_T("kLineSegment");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDependencyLinkage::RootDataType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDependencyLinkage::kElementId:
  {
    strValue = OD_T("kElementId");
  } break;

  case OdDgDependencyLinkage::kElementId_V:
  {
    strValue = OD_T("kElementId V");
  } break;

  case OdDgDependencyLinkage::kAssocPoint:
  {
    strValue = OD_T("kAssocPoint");
  } break;

  case OdDgDependencyLinkage::kAssocPoint_I:
  {
    strValue = OD_T("kAssocPoint I");
  } break;

  case OdDgDependencyLinkage::kFarElementId:
  {
    strValue = OD_T("kFarElementId");
  } break;

  case OdDgDependencyLinkage::kFarElementId_V:
  {
    strValue = OD_T("kFarElementId V");
  } break;

  case OdDgDependencyLinkage::kPath_V:
  {
    strValue = OD_T("kPath V");
  } break;

  default:
  {
    strValue = OD_T("kUnknownType");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgAssocPointRoot::OdDgAssocPointRootType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgAssocPointRoot::kLinearAssociation:
  {
    strValue = OD_T("kLinearAssociation");
  } break;

  case OdDgAssocPointRoot::kIntersectAssociation:
  {
    strValue = OD_T("kIntersectAssociation");
  } break;

  case OdDgAssocPointRoot::kArcAssociation:
  {
    strValue = OD_T("kArcAssociation");
  } break;

  case OdDgAssocPointRoot::kMultilineAssociation:
  {
    strValue = OD_T("kMultilineAssociation");
  } break;

  case OdDgAssocPointRoot::kBSplineCurveAssociation:
  {
    strValue = OD_T("kBSplineCurveAssociation");
  } break;

  case OdDgAssocPointRoot::kProjectionAssociation:
  {
    strValue = OD_T("kProjectionAssociation");
  } break;

  case OdDgAssocPointRoot::kOriginAssociation:
  {
    strValue = OD_T("kOriginAssociation");
  } break;

  case OdDgAssocPointRoot::kIntersect2Association:
  {
    strValue = OD_T("kIntersect2Association");
  } break;

  case OdDgAssocPointRoot::kMeshVertexAssociation:
  {
    strValue = OD_T("kMeshVertexAssociation");
  } break;

  case OdDgAssocPointRoot::kMeshEdgeAssociation:
  {
    strValue = OD_T("kMeshEdgeAssociation");
  } break;

  case OdDgAssocPointRoot::kBSplineSurfaceAssociation:
  {
    strValue = OD_T("kBSplineSurfaceAssociation");
  } break;

  default:
  {
    strValue = OD_T("kUnknownAssociation");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgArcAssociation::OdDgArcAssociationKeyPoint value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgArcAssociation::kCenterPoint:
  {
    strValue = OD_T("kCenterPoint");
  } break;

  case OdDgArcAssociation::kStartPoint:
  {
    strValue = OD_T("kStartPoint");
  } break;

  case OdDgArcAssociation::kEndPoint:
  {
    strValue = OD_T("kEndPoint");
  } break;

  default:
  {
    strValue = OD_T("kAnglePoint");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgOriginAssociation::OdDgOriginAssocOption value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgOriginAssociation::kInsertionPoint:
  {
    strValue = OD_T("kInsertionPoint");
  } break;

  default:
  {
    strValue = OD_T("kUpperLeftPoint");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLineStyleModificationLinkage::OdDgLsMultilineDataType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgLineStyleModificationLinkage::kLsMultilineTypeLine:
  {
    strValue = OD_T("kProfileLine");
  } break;

  case OdDgLineStyleModificationLinkage::kLsMultilineTypeStartCap:
  {
    strValue = OD_T("kStartCap");
  } break;

  case OdDgLineStyleModificationLinkage::kLsMultilineTypeEndCap:
  {
    strValue = OD_T("kEndCap");
  } break;

  default:
  {
    strValue = OD_T("kJoints");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgRasterFrame::OdDgGeoPriority value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgRasterFrame::kAttachment:
  {
    strValue = OD_T("kAttachment");
  } break;

  case OdDgRasterFrame::kRasterHeader:
  {
    strValue = OD_T("kRasterHeader");
  } break;

  case OdDgRasterFrame::kSisterFile:
  {
    strValue = OD_T("kSisterFile");
  } break;

  default:
  {
    strValue = OD_T("kFromPreferences");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgRasterFrame::OdDgRasterDrawingPlane value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgRasterFrame::kBackgroundPlane:
  {
    strValue = OD_T("kBackgroundPlane");
  } break;

  case OdDgRasterFrame::kForegroundPlane:
  {
    strValue = OD_T("kForegroundPlane");
  } break;

  case OdDgRasterFrame::kDesignPlane:
  {
    strValue = OD_T("kDesignPlane");
  } break;

  default:
  {
    strValue = OD_T("kUnknownPlane");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgRasterFrame::OdDgRasterColorMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgRasterFrame::k2ColorsMode:
  {
    strValue = OD_T("k2ColorsMode");
  } break;

  case OdDgRasterFrame::kMonochromeMode:
  {
    strValue = OD_T("kMonochromeMode");
  } break;

  case OdDgRasterFrame::k16ColorsMode:
  {
    strValue = OD_T("k16ColorsMode");
  } break;

  case OdDgRasterFrame::k256ColorsMode:
  {
    strValue = OD_T("k256ColorsMode");
  } break;

  case OdDgRasterFrame::kGrayscaleMode:
  {
    strValue = OD_T("kGrayscaleMode");
  } break;

  case OdDgRasterFrame::kRGBMode:
  {
    strValue = OD_T("kRGBMode");
  } break;

  case OdDgRasterFrame::kRGBAMode:
  {
    strValue = OD_T("kRGBAMode");
  } break;

  default:
  {
    strValue = OD_T("kUnknownMode");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgOle2Frame::OdDgDrawAspect value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgOle2Frame::kContent:
  {
    strValue = OD_T("kContent");
  } break;

  case OdDgOle2Frame::kThumbnail:
  {
    strValue = OD_T("kThumbnail");
  } break;

  case OdDgOle2Frame::kIcon:
  {
    strValue = OD_T("kIcon");
  } break;

  default:
  {
    strValue = OD_T("kDocPrint");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgOle2Frame::OdDgOleObjectType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgOle2Frame::kLinked:
  {
    strValue = OD_T("kLinked");
  } break;

  case OdDgOle2Frame::kEmbedded:
  {
    strValue = OD_T("kEmbedded");
  } break;

  case OdDgOle2Frame::kPicture:
  {
    strValue = OD_T("kPicture");
  } break;

  default:
  {
    strValue = OD_T("kUnknown");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgOle2Frame::OdDgOleViewRotationMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgOle2Frame::kViewIndependent:
  {
    strValue = OD_T("kViewIndependent");
  } break;

  case OdDgOle2Frame::kViewProjection:
  {
    strValue = OD_T("kViewProjection");
  } break;

  default:
  {
    strValue = OD_T("kViewDependent");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgNamedGroupItem::OdDgNamedGroupPropagateType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgNamedGroupItem::kApplyNever:
  {
    strValue = OD_T("kApplyNever");
  } break;

  case OdDgNamedGroupItem::kApplyAlways:
  {
    strValue = OD_T("kApplyAlways");
  } break;

  default:
  {
    strValue = OD_T("kApplyIfGroupLockOn");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgRasterAttachmentHeader::OdDgRasterAttachmentPlane value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgRasterAttachmentHeader::kBackground:
  {
    strValue = OD_T("kBackground");
  } break;

  case OdDgRasterAttachmentHeader::kDesignPlane:
  {
    strValue = OD_T("kDesignPlane");
  } break;

  case OdDgRasterAttachmentHeader::kForeground:
  {
    strValue = OD_T("kForeground");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgTemplateValueVariant value)
{
  OdString strValue;

  switch (value.getDataType())
  {
  case OdDgTemplateValueVariant::kBoolean:
  {
    if (value.getBoolValue())
    {
      strValue = L"Bool: true";
    }
    else
    {
      strValue = L"Bool: false";
    }
  }
  break;

  case OdDgTemplateValueVariant::kByte:
  {
    strValue.format(L"Byte: %d", value.getByteValue());
  }
  break;

  case OdDgTemplateValueVariant::kShort:
  {
    strValue.format(L"Short: %d", value.getShortValue());
  }
  break;

  case OdDgTemplateValueVariant::kDouble:
  {
    strValue.format(L"Double: %f", value.getDoubleValue());
  }
  break;

  case OdDgTemplateValueVariant::kPoint3d:
  {
    strValue.format(L"Point3d: %f, %f, %f", value.getPoint3dValue().x, value.getPoint3dValue().y, value.getPoint3dValue().z);
  }
  break;

  case OdDgTemplateValueVariant::kString:
  {
    if (value.getStringValue().isEmpty())
    {
      strValue = L"String: \"(none)\"";
    }
    else
    {
      strValue = L"String: \"" + value.getStringValue() + "\"";
    }
  }
  break;

  case OdDgTemplateValueVariant::kColor:
  {
    OdDgTemplateColorValue clr = value.getColorValue();

    switch (clr.getColorType())
    {
    case OdDgTemplateColorValue::kColorByLevel:
    {
      strValue = L"Color: kColorByLevel";
    } break;

    case OdDgTemplateColorValue::kColorByCell:
    {
      strValue = L"Color: kColorByCell";
    } break;

    case OdDgTemplateColorValue::kColorBook:
    {
      strValue.format(L"( %d, %d, %d )", ODGETRED(clr.getColorRGB()), ODGETGREEN(clr.getColorRGB()), ODGETBLUE(clr.getColorRGB()));

      strValue = L"Color From Book: " + clr.getBookAndColorName() + L" " + strValue;
    } break;

    case OdDgTemplateColorValue::kColorRGB:
    {
      strValue.format(L"Color RGB: ( %d, %d, %d )", ODGETRED(clr.getColorRGB()), ODGETGREEN(clr.getColorRGB()), ODGETBLUE(clr.getColorRGB()));
    } break;

    case OdDgTemplateColorValue::kColorIndex:
    {
      strValue.format(L"Color Index: %d", clr.getColorIndex());
    } break;
    }
  }
  break;

  default:
  {
    strValue = L"Type is not defined.";
  }
  break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::OdDgGridOrientationType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgModel::kACS:
  {
    strValue = OD_T("kACS");
  } break;

  case OdDgModel::kTop:
  {
    strValue = OD_T("kTop");
  } break;

  case OdDgModel::kFront:
  {
    strValue = OD_T("kFront");
  } break;

  case OdDgModel::kRight:
  {
    strValue = OD_T("kRight");
  } break;

  default:
  {
    strValue = OD_T("kView");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::AcsType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgModel::kCylindrical:
  {
    strValue = OD_T("kCylindrical");
  } break;

  case OdDgModel::kSpherical:
  {
    strValue = OD_T("kSpherical");
  } break;

  case OdDgModel::kRectangular:
  {
    strValue = OD_T("kRectangular");
  } break;

  case OdDgModel::kGeographic:
  {
    strValue = OD_T("kGeographic");
  } break;

  case OdDgModel::kMilitaryGrid:
  {
    strValue = OD_T("kMilitaryGrid");
  } break;

  case OdDgModel::kMilitaryGridWGS84:
  {
    strValue = OD_T("kMilitaryGridWGS84");
  } break;

  default:
  {
    strValue = OD_T("kUnknownAcsType");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDg::OdDgMaterialType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDg::kLevelOverride:
  {
    strValue = OD_T("kLevelOverride");
  } break;

  case OdDg::kByLevelAssigned:
  {
    strValue = OD_T("kByLevelAssigned");
  } break;

  default:
  {
    strValue = OD_T("kElementAssugned");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLinkNode::OdDgLinkNodeType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgLinkNode::kFolderLink:
  {
    strValue = OD_T("kFolderLink");
  } break;

  case OdDgLinkNode::kFileLink:
  {
    strValue = OD_T("kFileLink");
  } break;

  case OdDgLinkNode::kModelLink:
  {
    strValue = OD_T("kModelLink");
  } break;

  case OdDgLinkNode::kRegionLink:
  {
    strValue = OD_T("kRegionLink");
  } break;

  case OdDgLinkNode::kPDFRegionLink:
  {
    strValue = OD_T("kPdfRegionLink");
  } break;

  case OdDgLinkNode::kExcelSheetLink:
  {
    strValue = OD_T("kExcelSheetLink");
  } break;

  case OdDgLinkNode::kWordHeadingLink:
  {
    strValue = OD_T("kWordHeadingLink");
  } break;

  case OdDgLinkNode::kWordRegionLink:
  {
    strValue = OD_T("kWordRegionLink");
  } break;

  case OdDgLinkNode::kURLLink:
  {
    strValue = OD_T("kUrlLink");
  } break;

  case OdDgLinkNode::kLinkSetLink:
  {
    strValue = OD_T("kLinkSetLink");
  } break;

  case OdDgLinkNode::kLinkToFolder:
  {
    strValue = OD_T("kLinkToFolder");
  } break;

  case OdDgLinkNode::kDrawingRegionLink:
  {
    strValue = OD_T("kDrawingRegionLink");
  } break;

  case OdDgLinkNode::kConfigurationVariableLink:
  {
    strValue = OD_T("kConfigurationVariableLink");
  } break;

  default:
  {
    strValue = OD_T("kUnknownLink");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLinkNodePtr value)
{
  switch (value->getType())
  {
  case OdDgLinkNode::kFolderLink:
  {
    OdString strOffset;

    for (OdInt32 i = 0; i < name.getLength(); i++)
    {
      strOffset += L" ";
    }

    if (name.getLength() > 0 && name[0] == L'+')
    {
      dumpFieldName(L"---------------------");
    }

    writeFieldValue(strOffset + L"Name ", value->getName());
    writeFieldValue(strOffset + L"Type ", value->getType());

    if (name.getLength() > 0 && name[0] == L'+')
    {
      dumpFieldName(L"---------------------");
    }

    OdDgFolderLinkNode* pLink = dynamic_cast<OdDgFolderLinkNode*>(value.get());

    if( !pLink->getSheetIndexSuffix().isEmpty() )
      writeFieldValue(strOffset + L"SheetIndexPrefix ", pLink->getSheetIndexPrefix());

    if (!pLink->getSheetIndexPrefix().isEmpty())
      writeFieldValue(strOffset + L"SheetIndexSuffix ", pLink->getSheetIndexSuffix());

    if (!pLink->getSheetIndexPrefix().isEmpty())
      writeFieldValue(strOffset + L"LinkTreeDescription ", pLink->getLinkTreeDescription());

    writeFieldValue(strOffset + L"SheetStartNumber ", pLink->getSheetStartNumber());
    writeFieldValue(strOffset + L"SheetIncrement ", pLink->getSheetIncrement());
    writeFieldValue(strOffset + L"SheetNumOfDigit ", pLink->getSheetNumOfDigit());
    writeFieldValue(strOffset + L"SheetAutomaticNamingFlag ", pLink->getSheetAutomaticNamingFlag());
    writeFieldValue(strOffset + L"SheetLeadingZeroFlag ", pLink->getSheetLeadingZeroFlag());
    writeFieldValue(strOffset + L"SheetNamingRuleOfParentFlag ", pLink->getSheetNamingRuleOfParentFlag());
    writeFieldValue(strOffset + L"LastModifiedTime ", pLink->getLastModifiedTime());

    for (OdUInt32 i = 0; i < pLink->getChildCount(); i++)
    {
      writeFieldValue(name + L"  ", pLink->getChild(i));
    }
  } break;

  case OdDgLinkNode::kFileLink:
  {
    OdDgFileLinkNode* pLink = dynamic_cast<OdDgFileLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kModelLink:
  {
    OdDgModelLinkNode* pLink = dynamic_cast<OdDgModelLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kRegionLink:
  {
    OdDgRegionLinkNode* pLink = dynamic_cast<OdDgRegionLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kDrawingRegionLink:
  {
    OdDgDrawingLinkNode* pLink = dynamic_cast<OdDgDrawingLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kLinkToFolder:
  {
    OdDgLinkToFolderNode* pLink = dynamic_cast<OdDgLinkToFolderNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kLinkSetLink:
  {
    OdDgLinkSetLinkNode* pLink = dynamic_cast<OdDgLinkSetLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kConfigurationVariableLink:
  {
    OdDgConfigurationVariableLinkNode* pLink = dynamic_cast<OdDgConfigurationVariableLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kPDFRegionLink:
  {
    OdDgPdfRegionLinkNode* pLink = dynamic_cast<OdDgPdfRegionLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kExcelSheetLink:
  {
    OdDgExcelSheetLinkNode* pLink = dynamic_cast<OdDgExcelSheetLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kWordHeadingLink:
  {
    OdDgWordHeadingLinkNode* pLink = dynamic_cast<OdDgWordHeadingLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kWordRegionLink:
  {
    OdDgWordRegionLinkNode* pLink = dynamic_cast<OdDgWordRegionLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kURLLink:
  {
    OdDgURLLinkNode* pLink = dynamic_cast<OdDgURLLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;

  case OdDgLinkNode::kUnknownLink:
  {
    OdDgUnknownLinkNode* pLink = dynamic_cast<OdDgUnknownLinkNode*>(value.get());

    if (pLink)
    {
      writeFieldValue(name, pLink);
    }
  } break;
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFileLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"FileName", value->getFileName());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLinkToFolderNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"RelativePath", value->getRelativePath());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());

  if( !value->getFilter().isEmpty() )
    writeFieldValue(strOffset + L"Filter", value->getFilter());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLinkSetLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"FileName", value->getFileName());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());

  if (!value->getLinkSetName().isEmpty())
    writeFieldValue(strOffset + L"LinkSetName", value->getLinkSetName());

  if (!value->getLinkFilePath().isEmpty())
    writeFieldValue(strOffset + L"LinkFilePath", value->getLinkFilePath());

  if (value->getLinkTreeKey() != 0)
    writeFieldValue(strOffset + L"LinkTreeKey", value->getLinkTreeKey());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgConfigurationVariableLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());

  if (!value->getVariableName().isEmpty())
    writeFieldValue(strOffset + L"VariableName", value->getVariableName());

  if (!value->getVariableFilterString().isEmpty())
    writeFieldValue(strOffset + L"VariableFilterString", value->getVariableFilterString());

  if (!value->getVariableFileFilter().isEmpty())
    writeFieldValue(strOffset + L"VariableFileFilter", value->getVariableFileFilter());

  if (value->getVariableExpressionFlag() != 0)
    writeFieldValueHex(strOffset + L"VariableExpressionFlag", value->getVariableExpressionFlag());

  if (value->getVariableProcessSubDirectories() != 0)
    writeFieldValue(strOffset + L"VariableProcessSubDirectoriesFlag", value->getVariableProcessSubDirectories());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModelLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"FileName", value->getFileName());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());
  writeFieldValue(strOffset + L"ModelName", value->getModelName());
  writeFieldValue(strOffset + L"ModelTypeName", value->getModelTypeName());
  writeFieldValue(strOffset + L"ModelType", value->getModelType());

  if( !value->getExtendedModelTypeName().isEmpty() )
    writeFieldValue(strOffset + L"ModelExtendedType", value->getExtendedModelTypeName());

  if (!value->getExtendedModelMarkUpTypeName().isEmpty())
    writeFieldValue(strOffset + L"ModelExtendedMarkUpType", value->getExtendedModelMarkUpTypeName());

  if (!value->getSheetName().isEmpty())
    writeFieldValue(strOffset + L"SheetName", value->getSheetName());

  writeFieldValue(strOffset + L"ExcludeFromIndexFlag", value->getExcludeFromIndexFlag());
  writeFieldValue(strOffset + L"ExcludeFromSqnNumberFlag", value->getExcludeFromSqnNumberFlag());
  writeFieldValue(strOffset + L"ModelLinkModelDimension", value->getModelLinkModelDimension());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgRegionLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"FileName", value->getFileName());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());
  writeFieldValue(strOffset + L"ModelName", value->getModelName());

  if( !value->getModelTypeName().isEmpty() )
    writeFieldValue(strOffset + L"ModelTypeName", value->getModelTypeName());

  if (!value->getExtendedModelTypeName().isEmpty())
    writeFieldValue(strOffset + L"ModelExtendedType", value->getExtendedModelTypeName());

  if (!value->getExtendedModelMarkUpTypeName().isEmpty())
    writeFieldValue(strOffset + L"ModelExtendedMarkUpType", value->getExtendedModelMarkUpTypeName());

  writeFieldValue(strOffset + L"RegionName", value->getRegionName());

  if (!value->getRegionTypeName().isEmpty())
  {
    writeFieldValue(strOffset + L"RegionTypeName", value->getRegionTypeName());
    writeFieldValue(strOffset + L"RegionType", value->getRegionType());
  }

  if (!value->getRegionSubType().isEmpty())
    writeFieldValue(strOffset + L"RegionSubType", value->getRegionSubType());

  if (!value->getRegionImage().isEmpty())
    writeFieldValue(strOffset + L"RegionImage", value->getRegionImage());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDrawingLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"FileName", value->getFileName());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());
  writeFieldValue(strOffset + L"ModelName", value->getModelName());

  if (!value->getModelTypeName().isEmpty())
    writeFieldValue(strOffset + L"ModelTypeName", value->getModelTypeName());

  if (!value->getExtendedModelTypeName().isEmpty())
    writeFieldValue(strOffset + L"ModelExtendedType", value->getExtendedModelTypeName());

  if (!value->getExtendedModelMarkUpTypeName().isEmpty())
    writeFieldValue(strOffset + L"ModelExtendedMarkUpType", value->getExtendedModelMarkUpTypeName());

  writeFieldValue(strOffset + L"RegionName", value->getRegionName());

  if (!value->getRegionTypeName().isEmpty())
  {
    writeFieldValue(strOffset + L"RegionTypeName", value->getRegionTypeName());
    writeFieldValue(strOffset + L"RegionType", value->getRegionType());
  }

  if (!value->getRegionSubType().isEmpty())
    writeFieldValue(strOffset + L"RegionSubType", value->getRegionSubType());

  if (!value->getRegionImage().isEmpty())
    writeFieldValue(strOffset + L"RegionImage", value->getRegionImage());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPdfRegionLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"FileName", value->getFileName());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());

  for (OdUInt32 i = 0; i < value->getPdfInfoItemCount(); i++)
  {
    OdDgPdfRegionInfoItem rgnItem = value->getPdfInfoItem(i);

    writeFieldValue(strOffset + L"Region Number", i);
    writeFieldValue(strOffset + L"  RegionName", rgnItem.getRegionName());
    writeFieldValue(strOffset + L"  RegionTypeName", rgnItem.getRegionTypeName());
    writeFieldValue(strOffset + L"  RegionType", rgnItem.getRegionType());
    writeFieldValue(strOffset + L"  SequenceNumber", rgnItem.getSequenceNumber());
  }

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgExcelSheetLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"FileName", value->getFileName());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());
  writeFieldValue(strOffset + L"ExcelSheetName", value->getSheetName());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgWordHeadingLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"FileName", value->getFileName());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());

  for (OdUInt32 i = 0; i < value->getInfoItemCount(); i++)
  {
    OdDgWordHeadingInfoItem wordItem = value->getInfoItem(i);

    writeFieldValue(strOffset + L"Heading Number", i);
    writeFieldValue(strOffset + L"  Name", wordItem.getName());
    writeFieldValue(strOffset + L"  TypeName", wordItem.getTypeName());
    writeFieldValue(strOffset + L"  Type", wordItem.getType());
    writeFieldValue(strOffset + L"  SequenceNumber", wordItem.getSequenceNumber());
    writeFieldValue(strOffset + L"  Style", wordItem.getWordHeadingStyle());
  }

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgWordRegionLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"FileName", value->getFileName());
  writeFieldValue(strOffset + L"isRelative ", value->getRelativeFileLinkFlag());
  writeFieldValue(strOffset + L"FullPath", value->getFullPath());
  writeFieldValue(strOffset + L"RegionName", value->getRegionName());
  writeFieldValue(strOffset + L"RegionTypeName", value->getRegionTypeName());
  writeFieldValue(strOffset + L"RegionType", value->getRegionType());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgURLLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"URL", value->getURL());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgUnknownLinkNode* value)
{
  OdString strOffset;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    strOffset += L" ";
  }

  writeFieldValue(strOffset + L"Name ", value->getName());
  writeFieldValue(strOffset + L"Type", value->getType());
  writeFieldValue(strOffset + L"ValidFlag", value->getValidFlag());
  writeFieldValue(strOffset + L"HandlerName", value->getHandlerName());
  writeFieldValue(strOffset + L"HandlerData", value->getHandler());

  if (name.getLength() > 0 && name[0] == L'+')
  {
    dumpFieldName(L" ");
  }
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModelLinkNode::OdDgModelLinkNodeType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgModelLinkNode::kDesignModel:
  {
    strValue = OD_T("kDesignModel");
  } break;

  case OdDgModelLinkNode::kSheetModel:
  {
    strValue = OD_T("kSheetModel");
  } break;

  default:
  {
    strValue = OD_T("kUnknownModel");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgRegionLinkNode::OdDgRegionLinkNodeType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgRegionLinkNode::kReference:
  {
    strValue = OD_T("kReference");
  } break;

  case OdDgRegionLinkNode::kSavedView:
  {
    strValue = OD_T("kSavedView");
  } break;

  case OdDgRegionLinkNode::kDrawing:
  {
    strValue = OD_T("kDrawing");
  } break;

  default:
  {
    strValue = OD_T("kUnknownRegion");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPdfRegionInfoItem::OdDgPdfRegionType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPdfRegionInfoItem::kBookmark:
  {
    strValue = OD_T("kBookmark");
  } break;

  case OdDgPdfRegionInfoItem::kHeading:
  {
    strValue = OD_T("kHeading");
  } break;

  default:
  {
    strValue = OD_T("kUnknownRegion");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgWordHeadingInfoItem::OdDgWordHeadingItemType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgWordHeadingInfoItem::kBookmark:
  {
    strValue = OD_T("kBookmark");
  } break;

  case OdDgWordHeadingInfoItem::kHeading:
  {
    strValue = OD_T("kHeading");
  } break;

  default:
  {
    strValue = OD_T("kUnknown");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgTextExtendedProperties::OdDgSpecialSymbol value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTextExtendedProperties::kParagraph:
  {
    strValue = OD_T("kParagraphBreak");
  } break;

  case OdDgTextExtendedProperties::kNewLine:
  {
    strValue = OD_T("kNewLineBreak");
  } break;

  default:
  {
    strValue = OD_T("kTab");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgEnvMapBackground::OdDgEnvMapBackgroungMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgEnvMapBackground::kColor:
  {
    strValue = OD_T("kColor");
  } break;

  case OdDgEnvMapBackground::kImage:
  {
    strValue = OD_T("kImage");
  } break;

  default:
  {
    strValue = OD_T("kBlank");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgEnvMapFog::OdDgEnvMapFogMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgEnvMapFog::kLinear:
  {
    strValue = OD_T("kLinear");
  } break;

  default:
  {
    strValue = OD_T("kExponential");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgEnvMapImage::OdDgEnvMapProjectionType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgEnvMapImage::kPlanar:
  {
    strValue = OD_T("kPlanar");
  } break;

  case OdDgEnvMapImage::kCylindrical:
  {
    strValue = OD_T("kCylindrical");
  } break;

  case OdDgEnvMapImage::kSpherical:
  {
    strValue = OD_T("kSpherical");
  } break;

  case OdDgEnvMapImage::kCubic:
  {
    strValue = OD_T("kCubic");
  } break;

  case OdDgEnvMapImage::kFront:
  {
    strValue = OD_T("kFront");
  } break;

  default:
  {
    strValue = OD_T("kLightProbe");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgEnvMapImage::OdDgEnvMapFilterType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgEnvMapImage::kBicubic:
  {
    strValue = OD_T("kBicubic");
  } break;

  case OdDgEnvMapImage::kBilinear:
  {
    strValue = OD_T("kBilinear");
  } break;

  default:
  {
    strValue = OD_T("kNearest");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgEnvMapGradient::OdDgEnvMapGradientMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgEnvMapGradient::k2Colors:
  {
    strValue = OD_T("k2Colors");
  } break;

  default:
  {
    strValue = OD_T("k4Colors");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgEnvMapLayer::OdDgEnvMapLayerType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgEnvMapLayer::kSkyLight:
  {
    strValue = OD_T("kSkyLight");
  } break;

  case OdDgEnvMapLayer::kLightProbe:
  {
    strValue = OD_T("kLightProbe");
  } break;

  case OdDgEnvMapLayer::kImage:
  {
    strValue = OD_T("kImage");
  } break;

  case OdDgEnvMapLayer::kImageCube:
  {
    strValue = OD_T("kImageCube");
  } break;

  default:
  {
    strValue = OD_T("kGradient");
  } break;
  }

  writeFieldValue(name, strValue);
}

inline void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgView::OdDgDisplayMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgView::kWireMesh:
  {
    strValue = OD_T("kWireMesh");
  } break;

  case OdDgView::kHiddenLine:
  {
    strValue = OD_T("kHiddenLine");
  } break;

  case OdDgView::kFilledHiddenLine:
  {
    strValue = OD_T("kFilledHiddenLine");
  } break;

  case OdDgView::kConstantShade:
  {
    strValue = OD_T("kConstantShade");
  } break;

  case OdDgView::kSmoothShade:
  {
    strValue = OD_T("kSmoothShade");
  } break;

  case OdDgView::kPhongShade:
  {
    strValue = OD_T("kPhongShade");
  } break;

  default:
  {
    strValue = OD_T("kWireFrame");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdGiMaterialColor& value)
{
  OdString strValue;

  strValue.format(L"Clr = %08X, factor = %f, ", ODRGB(value.color().red(), value.color().green(), value.color().blue()), value.factor());

  if (value.method() == OdGiMaterialColor::kInherit)
  {
    strValue += L"kInherit";
  }
  else
  {
    strValue += L"kOverride";
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgMaterialParam& value)
{
  if (value.getIsComplexParam())
  {
    dumpFieldName(name + L" :");

    int nSpaces = 0;

    while ((nSpaces < name.getLength()) && (name[nSpaces] == L' '))
    {
      nSpaces++;
    }

    nSpaces += 2;

    OdString strSpaces;

    for (OdUInt32 j = 0; j < (OdUInt32)nSpaces; j++)
    {
      strSpaces += L" ";
    }

    for (OdUInt32 i = 0; i < value.getChildCount(); i++)
    {
      OdString strChildName = strSpaces;

      OdDgMaterialParam childParam = value.getChild(i);

      strChildName += childParam.getParamName();

      writeFieldValue(strChildName, childParam);
    }
  }
  else
  {
    writeFieldValue(name, value.getParamValue());
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdGeScale2d& value)
{
  OdString strValue;
  strValue.format(L"%f, %f", value.sx, value.sy);

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdGeScale3d& value)
{
  OdString strValue;
  strValue.format(L"%f, %f, %f", value.sx, value.sy, value.sz);

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDoubleColor& value)
{
  OdString strValue;
  strValue.format(L"r = %f, g = %f, b = %f", value.dRed, value.dGreen, value.dBlue);

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgMaterialPattern::OdDgMaterialPatternType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgMaterialPattern::kUnknownPattern:
  {
    strValue = OD_T("kUnknownPattern");
  } break;

  case OdDgMaterialPattern::kDiffusePattern:
  {
    strValue = OD_T("kDiffusePattern");
  } break;

  case OdDgMaterialPattern::kBumpMapPattern:
  {
    strValue = OD_T("kBumpMapPattern");
  } break;

  case OdDgMaterialPattern::kSpecularPattern:
  {
    strValue = OD_T("kSpecularPattern");
  } break;

  case OdDgMaterialPattern::kReflectPattern:
  {
    strValue = OD_T("kReflectPattern");
  } break;

  case OdDgMaterialPattern::kOpacityPattern:
  {
    strValue = OD_T("kOpacityPattern");
  } break;

  case OdDgMaterialPattern::kDiffuseMapPattern:
  {
    strValue = OD_T("kDiffuseMapPattern");
  } break;

  case OdDgMaterialPattern::kFinishPattern:
  {
    strValue = OD_T("kFinishPattern");
  } break;

  case OdDgMaterialPattern::kTranslucencyPattern:
  {
    strValue = OD_T("kTranslucencyPattern");
  } break;

  case OdDgMaterialPattern::kGlowPattern:
  {
    strValue = OD_T("kGlowPattern");
  } break;

  case OdDgMaterialPattern::kClearcoatPattern:
  {
    strValue = OD_T("kClearcoatPattern");
  } break;

  case OdDgMaterialPattern::kAnisotropyPattern:
  {
    strValue = OD_T("kAnisotropyPattern");
  } break;

  case OdDgMaterialPattern::kSpecularColorPattern:
  {
    strValue = OD_T("kSpecularColorPattern");
  } break;

  case OdDgMaterialPattern::kTransparentColorPattern:
  {
    strValue = OD_T("kTransparentColorPattern");
  } break;

  case OdDgMaterialPattern::kSubSurfaceColorPattern:
  {
    strValue = OD_T("kSubSurfaceColorPattern");
  } break;

  case OdDgMaterialPattern::kDisplacementPattern:
  {
    strValue = OD_T("kDisplacementPattern");
  } break;

  case OdDgMaterialPattern::kNormalPattern:
  {
    strValue = OD_T("kNormalPattern");
  } break;

  case OdDgMaterialPattern::kFurLengthPattern:
  {
    strValue = OD_T("kFurLengthPattern");
  } break;

  case OdDgMaterialPattern::kFurDensityPattern:
  {
    strValue = OD_T("kFurDensityPattern");
  } break;

  case OdDgMaterialPattern::kFurJitterPattern:
  {
    strValue = OD_T("kFurJitterPattern");
  } break;

  case OdDgMaterialPattern::kFurFlexPattern:
  {
    strValue = OD_T("kFurFlexPattern");
  } break;

  case OdDgMaterialPattern::kFurClimpsPattern:
  {
    strValue = OD_T("kFurClimpsPattern");
  } break;

  case OdDgMaterialPattern::kGlowColorPattern:
  {
    strValue = OD_T("kGlowColorPattern");
  } break;

  case OdDgMaterialPattern::kReflectColorPattern:
  {
    strValue = OD_T("kReflectColorPattern");
  } break;

  case OdDgMaterialPattern::kRefractionRoughnessPattern:
  {
    strValue = OD_T("kRefractionRoughnessPattern");
  } break;

  case OdDgMaterialPattern::kFrenselPattern:
  {
    strValue = OD_T("kFrenselPattern");
  } break;

  case OdDgMaterialPattern::kGeometryPattern:
  {
    strValue = OD_T("kGeometryPattern");
  } break;

  default:
  {
    strValue.format(OD_T("kUndefinedType_%d"), (OdUInt32)(value));
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgMaterialMap::MappingType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgMaterialMap::kElevationDrape:
  {
    strValue = OD_T("kElevationDrape");
  } break;

  case OdDgMaterialMap::kPlanar:
  {
    strValue = OD_T("kPlanar");
  } break;

  case OdDgMaterialMap::kDirectionalDrape:
  {
    strValue = OD_T("kDirectionalDrape");
  } break;

  case OdDgMaterialMap::kCubic:
  {
    strValue = OD_T("kCubic");
  } break;

  case OdDgMaterialMap::kSpherical:
  {
    strValue = OD_T("kSpherical");
  } break;

  case OdDgMaterialMap::kCylindrical:
  {
    strValue = OD_T("kCylindrical");
  } break;

  default:
  {
    strValue.format(OD_T("kParametric"));
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgMaterialMap::ScaleMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgMaterialMap::kMasterUnitMode:
  {
    strValue = OD_T("kMasterUnitMode");
  } break;

  case OdDgMaterialMap::kSubUnitMode:
  {
    strValue = OD_T("kSubUnitMode");
  } break;

  case OdDgMaterialMap::kMetersMode:
  {
    strValue = OD_T("kMetersMode");
  } break;

  case OdDgMaterialMap::kMillimetrersMode:
  {
    strValue = OD_T("kMillimetrersMode");
  } break;

  case OdDgMaterialMap::kFeetMode:
  {
    strValue = OD_T("kFeetMode");
  } break;

  case OdDgMaterialMap::kInchesMode:
  {
    strValue = OD_T("kInchesMode");
  } break;

  default:
  {
    strValue.format(OD_T("kSurfaceMode"));
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgMaterialLayerPattern::OdDgMaterialLayerPatternType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgMaterialLayerPattern::kLayerNormal:
  {
    strValue = OD_T("kLayerNormal");
  } break;

  case OdDgMaterialLayerPattern::kLayerAdd:
  {
    strValue = OD_T("kLayerAdd");
  } break;

  case OdDgMaterialLayerPattern::kLayerSubtract:
  {
    strValue = OD_T("kLayerSubtract");
  } break;

  case OdDgMaterialLayerPattern::kLayerAlpha:
  {
    strValue = OD_T("kLayerAlpha");
  } break;

  case OdDgMaterialLayerPattern::kLayerGradient:
  {
    strValue = OD_T("kLayerGradient");
  } break;

  case OdDgMaterialLayerPattern::kLayerImage:
  {
    strValue = OD_T("kLayerImage");
  } break;

  case OdDgMaterialLayerPattern::kLayerProcedure:
  {
    strValue = OD_T("kLayerProcedure");
  } break;

  case OdDgMaterialLayerPattern::kLayerGamma:
  {
    strValue = OD_T("kLayerGamma");
  } break;

  case OdDgMaterialLayerPattern::kLayerTint:
  {
    strValue = OD_T("kLayerTint");
  } break;

  case OdDgMaterialLayerPattern::kLayerGroupStart:
  {
    strValue = OD_T("kLayerGroupStart");
  } break;

  case OdDgMaterialLayerPattern::kLayerGroupEnd:
  {
    strValue = OD_T("kLayerGroupEnd");
  } break;

  case OdDgMaterialLayerPattern::kLayerAlphaBgStart:
  {
    strValue = OD_T("kLayerAlphaBgStart");
  } break;

  case OdDgMaterialLayerPattern::kLayerAlphaBgEnd:
  {
    strValue = OD_T("kLayerAlphaBgEnd");
  } break;

  default:
  {
    strValue.format(OD_T("kLayerUnknown"));
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::Type value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgModel::kDesignModel:
  {
    strValue = OD_T("kDesignModel");
  } break;

  case OdDgModel::kSheetModel:
  {
    strValue = OD_T("kSheetModel");
  } break;

  case OdDgModel::kExtractionModel:
  {
    strValue = OD_T("kExtractionModel");
  } break;

  case OdDgModel::kDrawingModel:
  {
    strValue = OD_T("kDrawingModel");
  } break;

  default:
  {
    strValue.format(L"kModelType_%d", value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::CellType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgModel::kNormalGraphics:
  {
    strValue = OD_T("kGraphics");
  } break;

  case OdDgModel::kPoint:
  {
    strValue = OD_T("kPoint");
  } break;

  case OdDgModel::kMenu:
  {
    strValue = OD_T("kMenu");
  } break;

  case OdDgModel::kParametric:
  {
    strValue = OD_T("kParametric");
  } break;

  default:
  {
    strValue.format(L"kCellType_%d", value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgDimTextFormat::AngleValueDisplayMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDimTextFormat::kAngle_DM:
  {
    strValue = OD_T("kAngle_DM");
  } break;

  case OdDgDimTextFormat::kAngle_DMS:
  {
    strValue = OD_T("kAngle_DMS");
  } break;

  case OdDgDimTextFormat::kAngle_C:
  {
    strValue = OD_T("kAngle_C");
  } break;

  case OdDgDimTextFormat::kAngle_Radian:
  {
    strValue = OD_T("kAngle_Radian");
  } break;

  default:
  {
    strValue.format(L"kAngle_D");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDg::OdDgDecimalAccuracy value)
{
  OdString strValue;

  switch (value)
  {
  case OdDg::kDecimalAccuracy0:
  {
    strValue = OD_T("kDecimalAccuracy0");
  } break;

  case OdDg::kDecimalAccuracy1:
  {
    strValue = OD_T("kDecimalAccuracy1");
  } break;

  case OdDg::kDecimalAccuracy2:
  {
    strValue = OD_T("kDecimalAccuracy2");
  } break;

  case OdDg::kDecimalAccuracy3:
  {
    strValue = OD_T("kDecimalAccuracy3");
  } break;

  case OdDg::kDecimalAccuracy4:
  {
    strValue = OD_T("kDecimalAccuracy4");
  } break;

  case OdDg::kDecimalAccuracy5:
  {
    strValue = OD_T("kDecimalAccuracy5");
  } break;

  case OdDg::kDecimalAccuracy6:
  {
    strValue = OD_T("kDecimalAccuracy6");
  } break;

  case OdDg::kDecimalAccuracy7:
  {
    strValue = OD_T("kDecimalAccuracy7");
  } break;

  default:
  {
    strValue.format(L"kDecimalAccuracy8");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDg::OdDgAngleReadoutDirectionMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDg::kAzimut:
  {
    strValue = OD_T("kAzimut");
  } break;

  default:
  {
    strValue.format(L"kBearing");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgXMLNode& value)
{
  OdUInt32 nSpaces = 0;

  for (OdInt32 n = 0; n < name.getLength(); n++)
  {
    if (name.getAt(n) != L' ')
    {
      break;
    }

    nSpaces++;
  }

  dumpFieldName(name);

  if (value.hasText())
  {
    OdString strPropName = L"Xml Text";

    for (OdUInt32 j = 0; j < nSpaces + 2; j++)
      strPropName = L" " + strPropName;

    writeFieldValue(strPropName, value.getText());
  }

  for (OdUInt32 i = 0; i < value.getPropertiesCount(); i++)
  {
    const OdDgXMLProperty& xmlProp = value.getProperty(i);

    if (xmlProp.isXMLNode())
    {
      OdString strNodeName = xmlProp.getName() + L":";

      for (OdUInt32 j = 0; j < nSpaces + 2; j++)
      {
        strNodeName = L" " + strNodeName;
      }

      writeFieldValue(strNodeName, xmlProp.asXMLNode());
    }
    else
    {
      OdString strPropName = xmlProp.getName();

      for (OdUInt32 j = 0; j < nSpaces + 2; j++)
      {
        strPropName = L" " + strPropName;
      }

      writeFieldValue(strPropName, xmlProp.asString());
    }
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleTableRecord::OdDgDisplayStyleDisplayHeader& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleTableRecord::kNoHeader:
  {
    strValue = OD_T("kNoHeader");
  } break;

  case OdDgDisplayStyleTableRecord::kHeight:
  {
    strValue = OD_T("kHeight");
  } break;

  case OdDgDisplayStyleTableRecord::kSlope:
  {
    strValue = OD_T("kSlope");
  } break;

  case OdDgDisplayStyleTableRecord::kAspectAngle:
  {
    strValue = OD_T("kAspectAngle");
  } break;

  case OdDgDisplayStyleTableRecord::kElementRange:
  {
    strValue = OD_T("kElementRange");
  } break;

  case OdDgDisplayStyleTableRecord::kHillShade:
  {
    strValue = OD_T("kHillShade");
  } break;

  default:
  {
    strValue.format(L"kUnknownHeader 0x%08x", value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleTableRecord::OdDgDisplayMode& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleTableRecord::kWireframe:
  {
    strValue = OD_T("kWireframe");
  } break;

  case OdDgDisplayStyleTableRecord::kVisibleEdges:
  {
    strValue = OD_T("kVisibleEdges");
  } break;

  case OdDgDisplayStyleTableRecord::kFilledVisibleEdges:
  {
    strValue = OD_T("kFilledVisibleEdges");
  } break;

  case OdDgDisplayStyleTableRecord::kShaded:
  {
    strValue = OD_T("kShaded");
  } break;

  default:
  {
    strValue.format(L"kUnknownMode %d", value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleTableRecord::OdDgEnvironmentTypeDisplayed& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleTableRecord::kBackgroundColor:
  {
    strValue = OD_T("kBackgroundColor");
  } break;

  case OdDgDisplayStyleTableRecord::kEnvironment:
  {
    strValue = OD_T("kEnvironment");
  } break;

  default:
  {
    strValue.format(L"kUnknownType %d", value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleLegendXAttribute::OdDgLegendCoordinateAxis& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleLegendXAttribute::kYAxis:
  {
    strValue = OD_T("kYAxis");
  } break;

  case OdDgDisplayStyleLegendXAttribute::kXAxis:
  {
    strValue = OD_T("kXAxis");
  } break;

  default:
  {
    strValue = OD_T("kZAxis");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleLegendXAttribute::OdDgSlopeDisplayMode& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleLegendXAttribute::kPercent:
  {
    strValue = OD_T("kPercent");
  } break;

  default:
  {
    strValue = OD_T("kAngle");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleLegendXAttribute::OdDgLegendColorScheme& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleLegendXAttribute::kRedBlue:
  {
    strValue = OD_T("kRedBlue");
  } break;

  case OdDgDisplayStyleLegendXAttribute::kBlueRed:
  {
    strValue = OD_T("kBlueRed");
  } break;

  case OdDgDisplayStyleLegendXAttribute::kMonochrome:
  {
    strValue = OD_T("kMonochrome");
  } break;

  case OdDgDisplayStyleLegendXAttribute::kTopographic:
  {
    strValue = OD_T("kTopographic");
  } break;

  case OdDgDisplayStyleLegendXAttribute::kSeaMountain:
  {
    strValue = OD_T("kSeaMountain");
  } break;

  default:
  {
    strValue = OD_T("kCustom");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleLegendXAttribute::OdDgLegendEdgeOverride& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleLegendXAttribute::kAllVisible:
  {
    strValue = OD_T("kAllVisible");
  } break;

  case OdDgDisplayStyleLegendXAttribute::kAllInvisible:
  {
    strValue = OD_T("kAllInvisible");
  } break;

  default:
  {
    strValue = OD_T("kNone");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleLegendXAttribute::OdDgLegendValuesCalcMethod& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleLegendXAttribute::kStep:
  {
    strValue = OD_T("kStep");
  } break;

  default:
  {
    strValue = OD_T("kCount");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleLegendXAttribute::OdDgSteppedDisplayMethod& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleLegendXAttribute::kAccurate:
  {
    strValue = OD_T("kAccurate");
  } break;

  case OdDgDisplayStyleLegendXAttribute::kIsolines:
  {
    strValue = OD_T("kIsolines");
  } break;

  case OdDgDisplayStyleLegendXAttribute::kFast:
  {
    strValue = OD_T("kFast");
  } break;

  case OdDgDisplayStyleLegendXAttribute::kFastIsolines:
  {
    strValue = OD_T("kFastIsolines");
  } break;

  default:
  {
    strValue = OD_T("kOff");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleLegendXAttribute::OdDgLegendItem& value)
{
  OdString strValue;
  strValue.format(L"%0.6f, 0x%08X, %d", value.m_dItemPosition, value.m_uItemColor, value.m_bVisibleItem ? 1 : 0);
  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleTypeFilterXAttribute::OdDgFilterApplyToType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleTypeFilterXAttribute::kSelectedElementTypes:
  {
    strValue = OD_T("kSelectedElementTypes");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kAllExceptSelectedElementTypes:
  {
    strValue = OD_T("kAllExceptSelectedElementTypes");
  } break;

  default:
  {
    strValue = OD_T("kAllElementTypes");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDisplayStyleTypeFilterXAttribute::OdDgFilterElementType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgDisplayStyleTypeFilterXAttribute::kBSplineSurface:
  {
    strValue = OD_T("kBSplineSurface");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kBSplineCurve:
  {
    strValue = OD_T("kBSplineCurve");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kCellHeader:
  {
    strValue = OD_T("kCellHeader");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSpiralCurve:
  {
    strValue = OD_T("kSpiralCurve");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kAssociativeRegion:
  {
    strValue = OD_T("kAssociativeRegion");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kDimension:
  {
    strValue = OD_T("kDimension");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSmartSolidAndSurface:
  {
    strValue = OD_T("kSmartSolidAndSurface");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSharedCell:
  {
    strValue = OD_T("kSharedCell");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kNote:
  {
    strValue = OD_T("kNote");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kMultiline:
  {
    strValue = OD_T("kMultiline");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kGroupedHole:
  {
    strValue = OD_T("kGroupedHole");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kTag:
  {
    strValue = OD_T("kTag");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kLineString:
  {
    strValue = OD_T("kLineString");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kRasterImage:
  {
    strValue = OD_T("kRasterImage");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kTextNode:
  {
    strValue = OD_T("kTextNode");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kRasterAttachment:
  {
    strValue = OD_T("kRasterAttachment");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kComplexString:
  {
    strValue = OD_T("kComplexString");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kMesh:
  {
    strValue = OD_T("kMesh");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kEllipse:
  {
    strValue = OD_T("kEllipse");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kExtendedElement:
  {
    strValue = OD_T("kExtendedElement");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kText:
  {
    strValue = OD_T("kText");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSavedView:
  {
    strValue = OD_T("kSavedView");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSolid:
  {
    strValue = OD_T("kSolid");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSectionClip:
  {
    strValue = OD_T("kSectionClip");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kCone:
  {
    strValue = OD_T("kCone");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSectionCallout:
  {
    strValue = OD_T("kSectionCallout");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kFeatureSolid:
  {
    strValue = OD_T("kFeatureSolid");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kDetailCallout2dView:
  {
    strValue = OD_T("kDetailCallout2dView");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kDigitalSignature:
  {
    strValue = OD_T("kDigitalSignature");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kElevationCallout:
  {
    strValue = OD_T("kElevationCallout");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kLine:
  {
    strValue = OD_T("kLine");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kTitleText:
  {
    strValue = OD_T("kTitleText");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kCurve:
  {
    strValue = OD_T("kCurve");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSurface:
  {
    strValue = OD_T("kSurface");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kPointString:
  {
    strValue = OD_T("kPointString");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kMarkupContentAreaHeader:
  {
    strValue = OD_T("kMarkupContentAreaHeader");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kOleObject:
  {
    strValue = OD_T("kOleObject");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kAnnotationCell:
  {
    strValue = OD_T("kAnnotationCell");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kShape:
  {
    strValue = OD_T("kShape");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kComplexShape:
  {
    strValue = OD_T("kComplexShape");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kDrawingTitle:
  {
    strValue = OD_T("kDrawingTitle");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kDrawingTitleUnderlined:
  {
    strValue = OD_T("kDrawingTitleUnderlined");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSheetAnnotationClip:
  {
    strValue = OD_T("kSheetAnnotationClip");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kPlanCallout:
  {
    strValue = OD_T("kPlanCallout");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kSectionCalloutOrthogonal:
  {
    strValue = OD_T("kSectionCalloutOrthogonal");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kInteriorElevationCallout:
  {
    strValue = OD_T("kInteriorElevationCallout");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kDetailCallout:
  {
    strValue = OD_T("kDetailCallout");
  } break;

  case OdDgDisplayStyleTypeFilterXAttribute::kArc:
  {
    strValue = OD_T("kArc");
  } break;

  default:
  {
    strValue = OD_T("kUnkownType");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTerrainFeature::OdDgTerrainFeatureType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTerrainFeature::kDataPoints:
  {
    strValue = OD_T("kDataPoints");
  } break;

  case OdDgTerrainFeature::kHole:
  {
    strValue = OD_T("kHole");
  } break;

  case OdDgTerrainFeature::kBreakLine:
  {
    strValue = OD_T("kBreakLine");
  } break;

  case OdDgTerrainFeature::kContour:
  {
    strValue = OD_T("kContour");
  } break;

  case OdDgTerrainFeature::kVoid:
  {
    strValue = OD_T("kVoid");
  } break;

  case OdDgTerrainFeature::kIsland:
  {
    strValue = OD_T("kIsland");
  } break;

  case OdDgTerrainFeature::kOuterBoundary:
  {
    strValue = OD_T("kOuterBoundary");
  } break;

  default:
  {
    strValue = OD_T("kUnknown");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTerrainControlElement::OdDgTerrainEdgeMethod& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTerrainControlElement::kNone:
  {
    strValue = OD_T("kNone");
  } break;

  case OdDgTerrainControlElement::kSlivers:
  {
    strValue = OD_T("kSlivers");
  } break;

  case OdDgTerrainControlElement::kMaxTriangleLength:
  {
    strValue = OD_T("kMaxTriangleLength");
  } break;

  default:
  {
    strValue = OD_T("kUnknown");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgExtendedElementTypeXAttribute::OdDgExtendedElementType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgExtendedElementTypeXAttribute::kSectionClipElement:
  {
    strValue = OD_T("kSectionClipElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kXRefViewsElement:
  {
    strValue = OD_T("kXRefViewsElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kDisplayStyleElement:
  {
    strValue = OD_T("kDisplayStyleElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kKMLPlacemarkElement:
  {
    strValue = OD_T("kKMLPlacemarkElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kDetailingSymbolElement:
  {
    strValue = OD_T("kDetailingSymbolElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kLuxSetupElement:
  {
    strValue = OD_T("kLuxSetupElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kEnvironmentMapTableElement:
  {
    strValue = OD_T("kEnvironmentMapTableElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kTerrainCtrlElement:
  {
    strValue = OD_T("kTerrainCtrlElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kTerrainGraphElement:
  {
    strValue = OD_T("kTerrainGraphElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kTerrainGraphElementCE:
  {
    strValue = OD_T("kTerrainGraphElementCE");
  } break;

  case OdDgExtendedElementTypeXAttribute::kItemLibrary:
  {
    strValue = OD_T("kItemLibrary");
  } break;

  case OdDgExtendedElementTypeXAttribute::kTableElement:
  {
    strValue = OD_T("kTableElement");
  } break;

  case OdDgExtendedElementTypeXAttribute::kTablePrototype:
  {
    strValue = OD_T("kTablePrototype");
  } break;

  case OdDgExtendedElementTypeXAttribute::kVariables:
  {
    strValue = OD_T("kVariables");
  } break;

  case OdDgExtendedElementTypeXAttribute::kConstraints2d:
  {
    strValue = OD_T("kConstraints2d");
  } break;

  case OdDgExtendedElementTypeXAttribute::kExtendedElementWithGrCache:
  {
    strValue = OD_T("kExtendedElementWithGrCache");
  } break;

  default:
  {
    strValue.format(OD_T("UnregisterdType_0x%08X"), value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTerrainGraphicsSettingsXAttribute::OdDgTerrainGraphicsType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTerrainGraphicsSettingsXAttribute::kNoSettings:
  {
    strValue = OD_T("kNoSettings");
  } break;

  case OdDgTerrainGraphicsSettingsXAttribute::kSourceFeatureSettings:
  {
    strValue = OD_T("kSourceFeatureSettings");
  } break;

  case OdDgTerrainGraphicsSettingsXAttribute::kVertexSettings:
  {
    strValue = OD_T("kVertexSettings");
  } break;

  case OdDgTerrainGraphicsSettingsXAttribute::kTriangleSettings:
  {
    strValue = OD_T("kTriangleSettings");
  } break;

  case OdDgTerrainGraphicsSettingsXAttribute::kContourSettings:
  {
    strValue = OD_T("kContourSettings");
  } break;

  default:
  {
    strValue = OD_T("kUnknownSettingsValue");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTerrainSourceFeatureSettings::OdDgSourceFeatureType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTerrainSourceFeatureSettings::kBreakLineFeature:
  {
    strValue = OD_T("kBreakLineFeature");
  } break;

  case OdDgTerrainSourceFeatureSettings::kHoleFeature:
  {
    strValue = OD_T("kHoleFeature");
  } break;

  case OdDgTerrainSourceFeatureSettings::kIslandFeature:
  {
    strValue = OD_T("kIslandFeature");
  } break;

  case OdDgTerrainSourceFeatureSettings::kVoidFeature:
  {
    strValue = OD_T("kVoidFeature");
  } break;

  case OdDgTerrainSourceFeatureSettings::kBoundaryFeature:
  {
    strValue = OD_T("kBoundaryFeature");
  } break;

  case OdDgTerrainSourceFeatureSettings::kContourFeature:
  {
    strValue = OD_T("kContourFeature");
  } break;

  default:
  {
    strValue = OD_T("kUnknownFeatureValue");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTerrainVertexFeatureSettings::OdDgTerrainVertexFeatureType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTerrainVertexFeatureSettings::kSourceVertex:
  {
    strValue = OD_T("kSourceVertex");
  } break;

  case OdDgTerrainVertexFeatureSettings::kTriangleVertex:
  {
    strValue = OD_T("kTriangleVertex");
  } break;

  case OdDgTerrainVertexFeatureSettings::kLowPoints:
  {
    strValue = OD_T("kLowPoints");
  } break;

  case OdDgTerrainVertexFeatureSettings::kHighPoints:
  {
    strValue = OD_T("kHighPoints");
  } break;

  case OdDgTerrainVertexFeatureSettings::kFlowArrows:
  {
    strValue = OD_T("kFlowArrows");
  } break;

  default:
  {
    strValue = OD_T("kUnknownSettingsValue");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTerrainOptions::OdDgTerrainPointDisplayType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTerrainOptions::kElement:
  {
    strValue = OD_T("kElement");
  } break;

  case OdDgTerrainOptions::kSymbol:
  {
    strValue = OD_T("kSymbol");
  } break;

  case OdDgTerrainOptions::kCell:
  {
    strValue = OD_T("kCell");
  } break;

  default:
  {
    strValue = OD_T("kUnknownValue");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTerrainOptions::OdDgTerrainContourSmoothingType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTerrainOptions::kNoneSmoothing:
  {
    strValue = OD_T("kNoneSmoothing");
  } break;

  case OdDgTerrainOptions::kVertexSmoothing:
  {
    strValue = OD_T("kVertexSmoothing");
  } break;

  case OdDgTerrainOptions::kSplineSmoothing:
  {
    strValue = OD_T("kSplineSmoothing");
  } break;

  case OdDgTerrainOptions::kSplineWithoutOverlapDetectionSmoothing:
  {
    strValue = OD_T("kSplineWithoutOverlapDetectionSmoothing");
  } break;

  default:
  {
    strValue = OD_T("kUnknownValue");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTerrainContourFeatureSettings::OdDgTerrainContourFeatureType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTerrainContourFeatureSettings::kMajorContour:
  {
    strValue = OD_T("kMajorContour");
  } break;

  case OdDgTerrainContourFeatureSettings::kMinorContour:
  {
    strValue = OD_T("kMinorContour");
  } break;

  default:
  {
    strValue = OD_T("kUnknownValue");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgItemType::OdDgItemTypeCategory& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgItemType::kItemType:
  {
    strValue = OD_T("kItemType");
  } break;

  case OdDgItemType::kPropertyType:
  {
    strValue = OD_T("kPropertyType");
  } break;

  case OdDgItemType::kCustomAttribute:
  {
    strValue = OD_T("kCustomAttribute");
  } break;

  default:
  {
    strValue = OD_T("kUnknownValue");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePrintArea value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kVeiw:
  {
    strValue = OD_T("kView");
  } break;

  case OdDgPrintStyleTableRecord::kSheet:
  {
    strValue = OD_T("kSheet");
  } break;

  case OdDgPrintStyleTableRecord::kFence:
  {
    strValue = OD_T("kFence");
  } break;

  default:
  {
    strValue = OD_T("kUndefinedArea");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyle3StateBoolean value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kFalse:
  {
    strValue = OD_T("kFalse");
  } break;

  case OdDgPrintStyleTableRecord::kTrue:
  {
    strValue = OD_T("kTrue");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleColorMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kMonochrome:
  {
    strValue = OD_T("kMonochrome");
  } break;

  case OdDgPrintStyleTableRecord::kGrayscale:
  {
    strValue = OD_T("kGrayscale");
  } break;

  case OdDgPrintStyleTableRecord::kTrueColor:
  {
    strValue = OD_T("kTrueColor");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePropertyPubMethod value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kNone:
  {
    strValue = OD_T("kNone");
  } break;

  case OdDgPrintStyleTableRecord::kAll:
  {
    strValue = OD_T("kAll");
  } break;

  case OdDgPrintStyleTableRecord::kFilterByFile:
  {
    strValue = OD_T("kFilterByFile");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePdfPaperSizeMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kPaperNotSet:
  {
    strValue = OD_T("kPaperNotSet");
  } break;

  case OdDgPrintStyleTableRecord::kAutoPaperSize:
  {
    strValue = OD_T("kAutoPaperSize");
  } break;

  case OdDgPrintStyleTableRecord::kDefinedPaperSize:
  {
    strValue = OD_T("kDefinedPaperSize");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleRasterRotation value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kRot0:
  {
    strValue = OD_T("kRot0");
  } break;

  case OdDgPrintStyleTableRecord::kRot90:
  {
    strValue = OD_T("kRot90");
  } break;

  case OdDgPrintStyleTableRecord::kRot180:
  {
    strValue = OD_T("kRot180");
  } break;

  case OdDgPrintStyleTableRecord::kRot270:
  {
    strValue = OD_T("kRot270");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgConstraintsDataXAttr::OdDgConstraintsXAttributeType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgConstraintsDataXAttr::k2dConstraints:
  {
    strValue = OD_T("k2dConstraints");
  } break;

  case OdDgConstraintsDataXAttr::kDimConstraints:
  {
    strValue = OD_T("kDimConstraints");
  } break;

  case OdDgConstraintsDataXAttr::kVersionConstraints:
  {
    strValue = OD_T("kVersionConstraints");
  } break;

  case OdDgConstraintsDataXAttr::kIdMapConstraints:
  {
    strValue = OD_T("kIdMapConstraints");
  } break;

  default:
  {
    strValue = OD_T("kFlagsConstraints");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDimensionalConstraintRepresentation::OdDgDimensionalConstraintRepAngleQuadrant& uQuad)
{
  OdString strValue;

  switch (uQuad)
  {
  case OdDgDimensionalConstraintRepresentation::kQuadrant1:
  {
    strValue = OD_T("kQuadrant1");
  } break;

  case OdDgDimensionalConstraintRepresentation::kQuadrant2:
  {
    strValue = OD_T("kQuadrant2");
  } break;

  case OdDgDimensionalConstraintRepresentation::kQuadrant3:
  {
    strValue = OD_T("kQuadrant3");
  } break;

  default:
  {
    strValue = OD_T("kQuadrant0");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgDimensionalConstraintRepresentation::OdDgDimensionalConstraintYOffsetAlignment& uAlign)
{
  OdString strValue;

  switch (uAlign)
  {
  case OdDgDimensionalConstraintRepresentation::kPositiveY:
  {
    strValue = OD_T("kPositiveY");
  } break;

  case OdDgDimensionalConstraintRepresentation::kPositiveX:
  {
    strValue = OD_T("kPositiveX");
  } break;

  case OdDgDimensionalConstraintRepresentation::kNegativeY:
  {
    strValue = OD_T("kNegativeY");
  } break;

  case OdDgDimensionalConstraintRepresentation::kNegativeX:
  {
    strValue = OD_T("kNegativeX");
  } break;

  default:
  {
    strValue = OD_T("kTrue");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDg2dConstraintRepresentation::OdDgConstraintType type)
{
  OdString strValue;

  switch (type)
  {
  case OdDg2dConstraintRepresentation::kDistanceConstraint:
  {
    strValue = OD_T("kDistanceConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kAngleConstraint:
  {
    strValue = OD_T("kAngleConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kRadiusConstraint:
  {
    strValue = OD_T("kRadiusConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kEllipArcPrimaryAxisConstraint:
  {
    strValue = OD_T("kEllipArcPrimaryAxisConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kEllipArcSecondaryAxisConstraint:
  {
    strValue = OD_T("kEllipArcSecondaryAxisConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kEqualDistanceConstraint:
  {
    strValue = OD_T("kEqualDistanceConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kAreaConstraint:
  {
    strValue = OD_T("kAreaConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kPerimeterConstraint:
  {
    strValue = OD_T("kPerimeterConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kFix2dConstraint:
  {
    strValue = OD_T("kFix2dConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kConcentricConstraint:
  {
    strValue = OD_T("kConcentricConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kParallelConstraint:
  {
    strValue = OD_T("kParallelConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kPerpendicularConstraint:
  {
    strValue = OD_T("kPerpendicularConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kCoincidentConstraint:
  {
    strValue = OD_T("kCoincidentConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kTangentConstraint:
  {
    strValue = OD_T("kTangentConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kEqualConstraint:
  {
    strValue = OD_T("kEqualConstraint");
  } break;

  case OdDg2dConstraintRepresentation::kDimensionPlaneConstraint:
  {
    strValue = OD_T("kDimensionPlaneConstraint");
  } break;

  default:
  {
    strValue.format(L"Constraint type 0x%02X", type);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgConstraintRepPoint& ptConstraint)
{
  OdString strValue;
  strValue.format(L"%d", ptConstraint.getEelementIdMapIndex());

  OdString strTopoType;

  if (ptConstraint.getTopologyFlags() != 0)
    strTopoType.format(L"(%d, %04X) : ", ptConstraint.getTopologyId(), ptConstraint.getTopologyFlags());
  else
    strTopoType.format(L"(%d) : ", ptConstraint.getTopologyId());

  OdString strPath;
  strPath.format(L"0x%02X = ", ptConstraint.getType());

  for (OdUInt32 i = 0; i < ptConstraint.getItemsCount(); i++)
  {
    OdString strPathItem;

    if (i == (ptConstraint.getItemsCount() - 1))
      strPathItem.format(L"%d", ptConstraint.getItem(i));
    else
      strPathItem.format(L"%d, ", ptConstraint.getItem(i));

    strPath += strPathItem;
  }

  strPath += L" : ";

  OdString strFlags;

  if (ptConstraint.getSkipTopLevelComplexElementFlag())
    strFlags.format(L"Cplx %d of %d => %d", ptConstraint.getSegmentIndex(), ptConstraint.getNumberOfSegments(), ptConstraint.getSnapType());
  else
    strFlags.format(L"%d of %d => %d", ptConstraint.getSegmentIndex(), ptConstraint.getNumberOfSegments(), ptConstraint.getSnapType());

  strValue += strTopoType + strPath + strFlags;

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePrintDefCreationMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kFromPaperSheetModels:
  {
    strValue = OD_T("kFromPaperSheetModels");
  } break;

  case OdDgPrintStyleTableRecord::kFromAllModels:
  {
    strValue = OD_T("kFromAllModels");
  } break;

  case OdDgPrintStyleTableRecord::kFromAllSheetModels:
  {
    strValue = OD_T("kFromAllSheetModels");
  } break;

  case OdDgPrintStyleTableRecord::kFromAllDesignModels:
  {
    strValue = OD_T("kFromAllDesignModels");
  } break;

  case OdDgPrintStyleTableRecord::kFromListedModels:
  {
    strValue = OD_T("kFromListedModels");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleFenceCreationData::OdDgPrintStyleFenceCreationMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleFenceCreationData::kFromShape:
  {
    strValue = OD_T("kFromShape");
  } break;

  case OdDgPrintStyleFenceCreationData::kFromAllShapes:
  {
    strValue = OD_T("kFromAllShapes");
  } break;

  case OdDgPrintStyleFenceCreationData::kFromCell:
  {
    strValue = OD_T("kFromCell");
  } break;

  case OdDgPrintStyleFenceCreationData::kFromAllCells:
  {
    strValue = OD_T("kFromAllCells");
  } break;

  case OdDgPrintStyleFenceCreationData::kFitToMasterModel:
  {
    strValue = OD_T("kFitToMasterModel");
  } break;

  case OdDgPrintStyleFenceCreationData::kFitToMasterModelAndXRefs:
  {
    strValue = OD_T("kFitToMasterModelAndXRefs");
  } break;

  case OdDgPrintStyleFenceCreationData::kFitToElementRange:
  {
    strValue = OD_T("kFitToElementRange");
  } break;

  case OdDgPrintStyleFenceCreationData::kFromPoints:
  {
    strValue = OD_T("kFromPoints");
  } break;

  default:
  {
    strValue = OD_T("kNone");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStylePaperOrientation value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kLandscape:
  {
    strValue = OD_T("kLandscape");
  } break;

  case OdDgPrintStyleTableRecord::kPortrait:
  {
    strValue = OD_T("kPortrait");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutUnits value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kFeet:
  {
    strValue = OD_T("kFeet");
  } break;

  case OdDgPrintStyleTableRecord::kInches:
  {
    strValue = OD_T("kInches");
  } break;

  case OdDgPrintStyleTableRecord::kMeters:
  {
    strValue = OD_T("kMeters");
  } break;

  case OdDgPrintStyleTableRecord::kDecimeters:
  {
    strValue = OD_T("kDecimeters");
  } break;

  case OdDgPrintStyleTableRecord::kCentimeters:
  {
    strValue = OD_T("kCentimeters");
  } break;

  case OdDgPrintStyleTableRecord::kMillimeters:
  {
    strValue = OD_T("kMillimeters");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutSizeScaleMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kMaximize:
  {
    strValue = OD_T("kMaximize");
  } break;

  case OdDgPrintStyleTableRecord::kSizeX:
  {
    strValue = OD_T("kSizeX");
  } break;

  case OdDgPrintStyleTableRecord::kSizeY:
  {
    strValue = OD_T("kSizeY");
  } break;

  case OdDgPrintStyleTableRecord::kScale:
  {
    strValue = OD_T("kScale");
  } break;

  case OdDgPrintStyleTableRecord::kRescaleFactor:
  {
    strValue = OD_T("kRescaleFactor");
  } break;

  case OdDgPrintStyleTableRecord::kRescaleSize:
  {
    strValue = OD_T("kRescaleSize");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutOriginMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kAutoCenter:
  {
    strValue = OD_T("kAutoCenter");
  } break;

  case OdDgPrintStyleTableRecord::kUserDefinedOrigin:
  {
    strValue = OD_T("kUserDefinedOrigin");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutMirrorMode value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kMirrorNone:
  {
    strValue = OD_T("kMirrorNone");
  } break;

  case OdDgPrintStyleTableRecord::kMirrorAboutX:
  {
    strValue = OD_T("kMirrorAboutX");
  } break;

  case OdDgPrintStyleTableRecord::kMirrorAboutY:
  {
    strValue = OD_T("kMirrorAboutY");
  } break;

  case OdDgPrintStyleTableRecord::kMirrorAboutBoth:
  {
    strValue = OD_T("kMirrorAboutX");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgPrintStyleTableRecord::OdDgPrintStyleLayoutFenceAlign value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgPrintStyleTableRecord::kXAxisAlign:
  {
    strValue = OD_T("kXAxisAlign");
  } break;

  case OdDgPrintStyleTableRecord::kYAxisAlign:
  {
    strValue = OD_T("kXAxisAlign");
  } break;

  case OdDgPrintStyleTableRecord::kNoneAlign:
  {
    strValue = OD_T("kNoneAlign");
  } break;

  default:
  {
    strValue = OD_T("kUndefined");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTerrainOptions::OdDgTerrainOptionsType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTerrainOptions::kTriangles:
  {
    strValue = OD_T("kTriangles");
  } break;

  case OdDgTerrainOptions::kMajorContour:
  {
    strValue = OD_T("kMajorContour");
  } break;

  case OdDgTerrainOptions::kMinorContour:
  {
    strValue = OD_T("kMinorContour");
  } break;

  case OdDgTerrainOptions::kSourceVertex:
  {
    strValue = OD_T("kSourceVertex");
  } break;

  case OdDgTerrainOptions::kTriangleVertices:
  {
    strValue = OD_T("kTriangleVertices");
  } break;

  case OdDgTerrainOptions::kLowPoints:
  {
    strValue = OD_T("kLowPoints");
  } break;

  case OdDgTerrainOptions::kHighPoints:
  {
    strValue = OD_T("kHighPoints");
  } break;

  case OdDgTerrainOptions::kFlowArrows:
  {
    strValue = OD_T("kFlowArrows");
  } break;

  case OdDgTerrainOptions::kSourceBreakLine:
  {
    strValue = OD_T("kSourceBreakLine");
  } break;

  case OdDgTerrainOptions::kSourceHole:
  {
    strValue = OD_T("kSourceHole");
  } break;

  case OdDgTerrainOptions::kSourceIsland:
  {
    strValue = OD_T("kSourceIsland");
  } break;

  case OdDgTerrainOptions::kSourceVoid:
  {
    strValue = OD_T("kSourceVoid");
  } break;

  case OdDgTerrainOptions::kSourceBoundary:
  {
    strValue = OD_T("kSourceBoundary");
  } break;

  case OdDgTerrainOptions::kSourceContour:
  {
    strValue = OD_T("kSourceContour");
  } break;

  default:
  {
    strValue = OD_T("kUnknownSettingsValue");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgItemTypePropertyValue& value)
{
  switch (value.getPropertyType())
  {
  case OdDgItemTypeProperty::kString:
    writeFieldValue(name, value.getStringValue()); break;
  case OdDgItemTypeProperty::kDouble:
    writeFieldValue(name, value.getDoubleValue()); break;
  case OdDgItemTypeProperty::kInteger:
    writeFieldValue(name, value.getIntegerValue()); break;
  case OdDgItemTypeProperty::kBoolean:
    writeFieldValue(name, value.getBooleanValue()); break;
  case OdDgItemTypeProperty::kPoint3d:
    writeFieldValue(name, value.getPointValue()); break;
  case OdDgItemTypeProperty::kDateTime:
    writeFieldValue(name, value.getDateTimeValue()); break;
  default:
    writeFieldValue(name, OdString(L"Unknown data type")); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdTimeStamp& value)
{
  OdString strValue;
  value.strftime(L"%d.%m.%Y %H:%M:%S", strValue);
  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgItemTypePropertyUnits& value)
{
  OdString strValue = value.getUnitsName();
  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<bool>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      if (value[i])
        strData += L"true";
      else
        strData += L"false";
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdBoolArray& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      if (value[i])
        strData += L"true";
      else
        strData += L"false";
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdInt8>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%d", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdInt8Array& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%d", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdInt16>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%d", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdInt16Array& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%d", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdInt32>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%d", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdInt32Array& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%d", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdInt64>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%i64", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdInt64Array& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%i64", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}


void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<double>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%f", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDoubleArray& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"%f", value[i]);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdString>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      strData += L"\"" + value[i] + L"\"";
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdAnsiString>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      strData += L"\"" + OdString(value[i]) + L"\"";
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdGePoint3d>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strNumber;
      strNumber.format(L"(%f,%f,%f)", value[i].x, value[i].y, value[i].z);

      strData += strNumber;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdTimeStamp>& value)
{
  OdString strData;

  if (value.isEmpty())
  {
    strData = L"<empty>";
  }
  else
  {
    strData = L"{ ";

    for (OdUInt32 i = 0; i < value.size(); i++)
    {
      if (i != 0)
        strData += L", ";

      OdString strValue;
      value[i].strftime(L"(%d.%m.%Y %H:%M:%S)", strValue);

      strData += strValue;
    }

    strData += L" }";
  }

  writeFieldValue(name, strData);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgEdgeRunTableElementSchema::OdDgEdgeRunSide& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgEdgeRunTableElementSchema::kTopEdge:
  {
    strValue = OD_T("kTopEdge");
  } break;

  case OdDgEdgeRunTableElementSchema::kBottomEdge:
  {
    strValue = OD_T("kBottomEdge");
  } break;

  case OdDgEdgeRunTableElementSchema::kLeftEdge:
  {
    strValue = OD_T("kLeftEdge");
  } break;

  case OdDgEdgeRunTableElementSchema::kRightEdge:
  {
    strValue = OD_T("kRightEdge");
  } break;

  default:
  {
    strValue.format(OD_T("UnknownValue_%d"), value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgAssocRegion::OdDgAssocRegionType value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgAssocRegion::kFromElements:
  {
    strValue = OD_T("kFromElements");
  } break;

  case OdDgAssocRegion::kUnion:
  {
    strValue = OD_T("kUnion");
  } break;

  case OdDgAssocRegion::kIntersect:
  {
    strValue = OD_T("kIntersect");
  } break;

  case OdDgAssocRegion::kDifference:
  {
    strValue = OD_T("kDifference");
  } break;

  default:
  {
    strValue = OD_T("kHatchFill");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgAssocRegion::OdDgAssocRegionFillModeInteriorShapes value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgAssocRegion::kIgnore:
  {
    strValue = OD_T("kIgnore");
  } break;

  case OdDgAssocRegion::kIdentifyAlternating:
  {
    strValue = OD_T("kIdentifyAlternating");
  } break;

  default:
  {
    strValue = OD_T("kLocate");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTableCellElement::OdDgTableCellElementTextAlignment& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTableCellElement::kLeftTop:
  {
    strValue = OD_T("kLeftTop");
  } break;

  case OdDgTableCellElement::kLeftMiddle:
  {
    strValue = OD_T("kLeftMiddle");
  } break;

  case OdDgTableCellElement::kLeftBottom:
  {
    strValue = OD_T("kLeftBottom");
  } break;

  case OdDgTableCellElement::kCenterTop:
  {
    strValue = OD_T("kCenterTop");
  } break;

  case OdDgTableCellElement::kCenterMiddle:
  {
    strValue = OD_T("kCentertMiddle");
  } break;

  case OdDgTableCellElement::kCenterBottom:
  {
    strValue = OD_T("kCenterBottom");
  } break;

  case OdDgTableCellElement::kRightTop:
  {
    strValue = OD_T("kRightTop");
  } break;

  case OdDgTableCellElement::kRightMiddle:
  {
    strValue = OD_T("kRightMiddle");
  } break;

  case OdDgTableCellElement::kRightBottom:
  {
    strValue = OD_T("kRightBottom");
  } break;

  default:
  {
    strValue.format(OD_T("UnknownValue_%d"), value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTableCellElement::OdDgTableCellElementTextOrientation& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTableCellElement::kHorizontal:
  {
    strValue = OD_T("kHorizontal");
  } break;

  case OdDgTableCellElement::kRotateRight:
  {
    strValue = OD_T("kRotateRight");
  } break;

  case OdDgTableCellElement::kRotateLeft:
  {
    strValue = OD_T("kRotateLeft");
  } break;

  case OdDgTableCellElement::kVertical:
  {
    strValue = OD_T("kVertical");
  } break;

  default:
  {
    strValue.format(OD_T("UnknownValue_%d"), value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTableElement::OdDgTableElementBreakType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTableElement::kHorizontalBreak:
  {
    strValue = OD_T("kHorizontalBreak");
  } break;

  case OdDgTableElement::kNoBreak:
  {
    strValue = OD_T("kNoBreak");
  } break;

  default:
  {
    strValue.format(OD_T("UnknownValue_%d"), value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgLevelTableRecord::ElementAccess type)
{
  OdString strValue;

  switch (type)
  {
  case OdDgLevelTableRecord::kAccessAll:
  {
    strValue = OD_T("kAccessAll");
  } break;

  case OdDgLevelTableRecord::kAccessLocked:
  {
    strValue = OD_T("kAccessLocked");
  } break;

  case OdDgLevelTableRecord::kAccessReadOnly:
  {
    strValue = OD_T("kAccessReadOnly");
  } break;

  default:
  {
    strValue = OD_T("kAccessViewOnly");
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTableElement::OdDgTableElementSubTablePosition& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTableElement::kRight:
  {
    strValue = OD_T("kRight");
  } break;

  case OdDgTableElement::kLeft:
  {
    strValue = OD_T("kLeft");
  } break;

  case OdDgTableElement::kAbove:
  {
    strValue = OD_T("kAbove");
  } break;

  case OdDgTableElement::kBelow:
  {
    strValue = OD_T("kBelow");
  } break;

  case OdDgTableElement::kManual:
  {
    strValue = OD_T("kManual");
  } break;

  default:
  {
    strValue.format(OD_T("UnknownValue_%d"), value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgTableSchemaDescriptionItem::OdDgTableSchemaDescriptionItemType& value)
{
  OdString strValue;

  switch (value)
  {
  case OdDgTableSchemaDescriptionItem::kGroup:
  {
    strValue = OD_T("kGroup");
  } break;

  case OdDgTableSchemaDescriptionItem::kBoolean:
  {
    strValue = OD_T("kBoolean");
  } break;

  case OdDgTableSchemaDescriptionItem::kDouble:
  {
    strValue = OD_T("kDouble");
  } break;

  case OdDgTableSchemaDescriptionItem::kUInt32:
  {
    strValue = OD_T("kUInt32");
  } break;

  case OdDgTableSchemaDescriptionItem::kPoint3d:
  {
    strValue = OD_T("kPoint3d");
  } break;

  case OdDgTableSchemaDescriptionItem::kString:
  {
    strValue = OD_T("kString");
  } break;

  case OdDgTableSchemaDescriptionItem::kDateTime:
  {
    strValue = OD_T("kDateTime");
  } break;

  case OdDgTableSchemaDescriptionItem::kExpressionDesc:
  {
    strValue = OD_T("kExpressionDesc");
  } break;

  default:
  {
    strValue.format(OD_T("UnknownValue_%d"), value);
  } break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgVariable::OdDgVariableType type)
{
  OdString strValue = L"kProxy";

  switch (type)
  {
  case OdDgVariable::kDistance: strValue = L"kDistance"; break;
  case OdDgVariable::kAngle: strValue = L"kAngle"; break;
  case OdDgVariable::kNumber: strValue = L"kNumber"; break;
  case OdDgVariable::kInteger: strValue = L"kInteger"; break;
  case OdDgVariable::kBoolean: strValue = L"kBoolean"; break;
  case OdDgVariable::kArea: strValue = L"kArea"; break;
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgVariable::OdDgVariableScope type)
{
  if (type == OdDgVariable::kDefinition)
    writeFieldValue(name, OdString(L"kDefinition"));
  else
    writeFieldValue(name, OdString(L"kInstance"));
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgVariableValueVariant type)
{
  switch (type.getType())
  {
  case OdDgVariable::kInteger:
    writeFieldValue(name, type.getIntegerValue()); break;
  case OdDgVariable::kBoolean:
    writeFieldValue(name, type.getBooleanValue()); break;
  case OdDgVariable::kProxy:
    writeFieldValue(name, OdString(L"<Error!>")); break;
  default:
    writeFieldValue(name, type.getDoubleValue()); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgItemTypeBasedVariable::OdDgItemTypeBasedVariableUnits type)
{
  switch (type)
  {
  case OdDgItemTypeBasedVariable::kAcre:
    writeFieldValue(name, OdString(OD_T("kAcre"))); break;
  case OdDgItemTypeBasedVariable::kCentimetreSquared:
    writeFieldValue(name, OdString(OD_T("kCentimetreSquared"))); break;
  case OdDgItemTypeBasedVariable::kFootFoot:
    writeFieldValue(name, OdString(OD_T("kFootFoot"))); break;
  case OdDgItemTypeBasedVariable::kFootMile:
    writeFieldValue(name, OdString(OD_T("kFootMile"))); break;
  case OdDgItemTypeBasedVariable::kFootSquared:
    writeFieldValue(name, OdString(OD_T("kFootSquared"))); break;
  case OdDgItemTypeBasedVariable::kHectare:
    writeFieldValue(name, OdString(OD_T("kHectare"))); break;
  case OdDgItemTypeBasedVariable::kInchFoot:
    writeFieldValue(name, OdString(OD_T("kInchFoot"))); break;
  case OdDgItemTypeBasedVariable::kInchMetre:
    writeFieldValue(name, OdString(OD_T("kInchMetre"))); break;
  case OdDgItemTypeBasedVariable::kInchMile:
    writeFieldValue(name, OdString(OD_T("kInchMile"))); break;
  case OdDgItemTypeBasedVariable::kInchSquared:
    writeFieldValue(name, OdString(OD_T("kInchSquared"))); break;
  case OdDgItemTypeBasedVariable::kKilometreSquared:
    writeFieldValue(name, OdString(OD_T("kKilometreSquared"))); break;
  case OdDgItemTypeBasedVariable::kMeterKilometre:
    writeFieldValue(name, OdString(OD_T("kMeterKilometre"))); break;
  case OdDgItemTypeBasedVariable::kMetreMetre:
    writeFieldValue(name, OdString(OD_T("kMetreMetre"))); break;
  case OdDgItemTypeBasedVariable::kMetreSquared:
    writeFieldValue(name, OdString(OD_T("kMetreSquared"))); break;
  case OdDgItemTypeBasedVariable::kMileSquared:
    writeFieldValue(name, OdString(OD_T("kMileSquared"))); break;
  case OdDgItemTypeBasedVariable::kMillimetreKilometre:
    writeFieldValue(name, OdString(OD_T("kMillimetreKilometre"))); break;
  case OdDgItemTypeBasedVariable::kMillimetreMetre:
    writeFieldValue(name, OdString(OD_T("kMillimetreMetre"))); break;
  case OdDgItemTypeBasedVariable::kMillimetreMile:
    writeFieldValue(name, OdString(OD_T("kMillimetreMile"))); break;
  case OdDgItemTypeBasedVariable::kMillimetreSquared:
    writeFieldValue(name, OdString(OD_T("kMillimetreSquared"))); break;
  case OdDgItemTypeBasedVariable::kYardSquared:
    writeFieldValue(name, OdString(OD_T("kYardSquared"))); break;
  case OdDgItemTypeBasedVariable::kDegree:
    writeFieldValue(name, OdString(OD_T("kDegree"))); break;
  case OdDgItemTypeBasedVariable::kRadian:
    writeFieldValue(name, OdString(OD_T("kRadian"))); break;
  case OdDgItemTypeBasedVariable::kAngleMinute:
    writeFieldValue(name, OdString(OD_T("kAngleMinute"))); break;
  case OdDgItemTypeBasedVariable::kAngleQuadrant:
    writeFieldValue(name, OdString(OD_T("kAngleQuadrant"))); break;
  case OdDgItemTypeBasedVariable::kAngleSecond:
    writeFieldValue(name, OdString(OD_T("kAngleSecond"))); break;
  case OdDgItemTypeBasedVariable::kRevolution:
    writeFieldValue(name, OdString(OD_T("kRevolution"))); break;
  case OdDgItemTypeBasedVariable::kGradian:
    writeFieldValue(name, OdString(OD_T("kGradian"))); break;
  case OdDgItemTypeBasedVariable::kMetre:
    writeFieldValue(name, OdString(OD_T("kMetre"))); break;
  case OdDgItemTypeBasedVariable::kMicroInch:
    writeFieldValue(name, OdString(OD_T("kMicroInch"))); break;
  case OdDgItemTypeBasedVariable::kMicroMetre:
    writeFieldValue(name, OdString(OD_T("kMicroMetre"))); break;
  case OdDgItemTypeBasedVariable::kCentimetre:
    writeFieldValue(name, OdString(OD_T("kCentimetre"))); break;
  case OdDgItemTypeBasedVariable::kDecimetre:
    writeFieldValue(name, OdString(OD_T("kDecimetre"))); break;
  case OdDgItemTypeBasedVariable::kFoot:
    writeFieldValue(name, OdString(OD_T("kFoot"))); break;
  case OdDgItemTypeBasedVariable::kInch:
    writeFieldValue(name, OdString(OD_T("kInch"))); break;
  case OdDgItemTypeBasedVariable::kKilometre:
    writeFieldValue(name, OdString(OD_T("kKilometre"))); break;
  case OdDgItemTypeBasedVariable::kMilliFoot:
    writeFieldValue(name, OdString(OD_T("kMilliFoot"))); break;
  case OdDgItemTypeBasedVariable::kMile:
    writeFieldValue(name, OdString(OD_T("kMile"))); break;
  case OdDgItemTypeBasedVariable::kMilliInch:
    writeFieldValue(name, OdString(OD_T("kMilliInch"))); break;
  case OdDgItemTypeBasedVariable::kMilliMetre:
    writeFieldValue(name, OdString(OD_T("kMilliMetre"))); break;
  case OdDgItemTypeBasedVariable::kYard:
    writeFieldValue(name, OdString(OD_T("kYard"))); break;
  default:
    writeFieldValue(name, OdString(OD_T("kMasterUnits"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdBinaryData& value)
{
  OdString strFieldValue;

  for( OdUInt32 i = 0; i < value.size(); i++ )
  {
    OdString strItem;

    if (i == value.size() - 1)
      strItem.format(L"0x%02X", (OdUInt32)(value[i]));
    else
      strItem.format(L"0x%02X,", (OdUInt32)(value[i]));

    strFieldValue += strItem;
  }

  writeFieldValue(name, strFieldValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdBinaryData>& value)
{
  OdString strFieldTotal = L"{";

  for (OdUInt32 i = 0; i < value.size(); i++)
  {
    OdString strFieldValue;

    for (OdUInt32 j = 0; j < value[i].size(); j++)
    {
      OdString strItem;

      if (j == value[i].size() - 1)
        strItem.format(L"0x%02X", (OdUInt32)(value[i][j]));
      else
        strItem.format(L"0x%02X,", (OdUInt32)(value[i][j]));

      strFieldValue += strItem;
    }

    strFieldValue = L"(" + strFieldValue + L"),";

    strFieldTotal += strFieldValue;
  }

  strFieldTotal = strFieldTotal.left(strFieldTotal.getLength() - 1) + L"}";

  writeFieldValue(name, strFieldTotal);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgBinXMLNode* pValue)
{
  OdString strSpaces;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    if (name.getAt(i) == L' ')
      strSpaces += L' ';
    else
      break;
  }

  dumpFieldName(strSpaces + L"+ " + pValue->getName());

  strSpaces += L"  ";

  for (OdUInt32 j = 0; j < pValue->getChildCount(); j++)
  {
    OdDgBinXMLItemPtr pItem = pValue->getChildItem(j);

    if (pItem->isXmlNode())
    {
      OdDgBinXMLNode* pNode = (OdDgBinXMLNode*)(pItem.get());
      writeFieldValue(strSpaces, pNode);
    }
    else
    {
      OdDgBinXMLValue* pValueItem = (OdDgBinXMLValue*)(pItem.get());
      writeFieldValue(strSpaces, pValueItem);
    }
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgBinXMLValue* pValue)
{
  OdString strSpaces;

  for (OdInt32 i = 0; i < name.getLength(); i++)
  {
    if (name.getAt(i) == L' ')
      strSpaces += L' ';
    else
      break;
  }

  OdString strName = strSpaces + L"- " + pValue->getName();

  OdDgBECXMLVariant var = pValue->getValue();

  if (var.m_uFlags & OdDgBECXMLVariant::kBool)
    writeFieldValue(strName, var.m_varBool);
  else if (var.m_uFlags & OdDgBECXMLVariant::kBoolArray)
    writeFieldValue(strName, var.m_varBoolArray);
  else if (var.m_uFlags & OdDgBECXMLVariant::kByte)
    writeFieldValue(strName, var.m_varByte);
  else if (var.m_uFlags & OdDgBECXMLVariant::kByteOrBool)
    writeFieldValue(strName, var.m_varByte);
  else if (var.m_uFlags & OdDgBECXMLVariant::kByteArray)
    writeFieldValue(strName, var.m_varByteArray);
  else if (var.m_uFlags & OdDgBECXMLVariant::kShort)
    writeFieldValue(strName, var.m_varShort);
  else if (var.m_uFlags & OdDgBECXMLVariant::kShortArray)
    writeFieldValue(strName, var.m_varShortArray);
  else if (var.m_uFlags & OdDgBECXMLVariant::kInt32)
    writeFieldValue(strName, var.m_varInt32);
  else if (var.m_uFlags & OdDgBECXMLVariant::kInt32Array)
    writeFieldValue(strName, var.m_varInt32Array);
  else if (var.m_uFlags & OdDgBECXMLVariant::kInt64)
    writeFieldValue(strName, var.m_varInt64);
  else if (var.m_uFlags & OdDgBECXMLVariant::kInt64Array)
    writeFieldValue(strName, var.m_varInt64Array);
  else if (var.m_uFlags & OdDgBECXMLVariant::kDouble)
    writeFieldValue(strName, var.m_varDouble);
  else if (var.m_uFlags & OdDgBECXMLVariant::kDoubleArray)
    writeFieldValue(strName, var.m_varDoubleArray);
  else if (var.m_uFlags & OdDgBECXMLVariant::kString)
    writeFieldValue(strName, var.m_varString);
  else if (var.m_uFlags & OdDgBECXMLVariant::kStringArray)
    writeFieldValue(strName, var.m_varStringArray);
  else if (var.m_uFlags & OdDgBECXMLVariant::kPoint3d)
    writeFieldValue(strName, var.m_varPoint3d);
  else if (var.m_uFlags & OdDgBECXMLVariant::kPoint3dArray)
    writeFieldValue(strName, var.m_varPoint3dArray);
  else if (var.m_uFlags & OdDgBECXMLVariant::kDateAndTime)
    writeFieldValue(strName, var.m_varDateTime);
  else if (var.m_uFlags & OdDgBECXMLVariant::kDateTimeArray)
    writeFieldValue(strName, var.m_varDateTimeArray);
  else if (var.m_uFlags & OdDgBECXMLVariant::kBinary)
    writeFieldValue(strName, var.m_varBinaryData);
  else if (var.m_uFlags & OdDgBECXMLVariant::kBinaryDataArray)
    writeFieldValue(strName, var.m_varBinaryDataArray);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgSchemaItemVariant& value)
{
  switch (value.getType())
  {
  case OdDgSchemaItemVariant::kEmptyVar:
    writeFieldValue(name, OdString(OD_T("<Empty>"))); break;
  case OdDgSchemaItemVariant::kStringVar:
    writeFieldValue(name, value.getStringValue()); break;
  case OdDgSchemaItemVariant::kDoubleVar:
    writeFieldValue(name, value.getDoubleValue()); break;
  case OdDgSchemaItemVariant::kInt32Var:
    writeFieldValue(name, value.getInt32Value()); break;
  case OdDgSchemaItemVariant::kBoolVar:
    writeFieldValue(name, value.getBoolValue()); break;
  case OdDgSchemaItemVariant::kPoint3dVar:
    writeFieldValue(name, value.getPoint3dValue()); break;
  case OdDgSchemaItemVariant::kDateTimeVar:
    writeFieldValue(name, value.getDateTimeValue()); break;
  case OdDgSchemaItemVariant::kItemGroupVar:
  {
    OdDgItemGroupVariable varData = value.getItemGroupValue();
    OdString strVal;

    OdUInt32Array arrIndexes = varData.getGroupItemIdArray();

    for (OdUInt32 i = 0; i < arrIndexes.size(); i++)
    {
      OdString strIndex;

      if (i < arrIndexes.size() - 1)
        strIndex.format(L"%d,", arrIndexes[i]);
      else
        strIndex.format(L"%d", arrIndexes[i]);

      strVal += strIndex;
    }

    if (arrIndexes.isEmpty())
      writeFieldValue(name, OdString(L"<Empty>"));
    else
      writeFieldValue(name, strVal);
  } break;

  case OdDgSchemaItemVariant::kStringArrayVar:
  {
    OdArray<OdString> varData = value.getStringArrayValue();
    OdString strVal = L"( ";

    for (OdUInt32 i = 0; i < varData.size(); i++)
      strVal += L"\"" + varData[i] + L"\",";

    if (varData.isEmpty())
      writeFieldValue(name, OdString(L"<Empty>"));
    else
    {
      strVal = strVal.left(strVal.getLength() - 1) + L" )";
      writeFieldValue(name, strVal);
    }
  } break;

  case OdDgSchemaItemVariant::kDoubleArrayVar:
  {
    OdArray<double> varData = value.getDoubleArrayValue();
    OdString strVal = L"( ";

    for (OdUInt32 i = 0; i < varData.size(); i++)
    {
      OdString strItem;
      strItem.format(L"%f,", varData[i]);
      strVal += strItem;
    }

    if (varData.isEmpty())
      writeFieldValue(name, OdString(L"<Empty>"));
    else
    {
      strVal = strVal.left(strVal.getLength() - 1) + L" )";
      writeFieldValue(name, strVal);
    }
  } break;

  case OdDgSchemaItemVariant::kInt32ArrayVar:
  {
    OdArray<OdInt32> varData = value.getInt32ArrayValue();
    OdString strVal = L"( ";

    for (OdUInt32 i = 0; i < varData.size(); i++)
    {
      OdString strItem;
      strItem.format(L"%d,", varData[i]);
      strVal += strItem;
    }

    if (varData.isEmpty())
      writeFieldValue(name, OdString(L"<Empty>"));
    else
    {
      strVal = strVal.left(strVal.getLength() - 1) + L" )";
      writeFieldValue(name, strVal);
    }
  } break;

  case OdDgSchemaItemVariant::kBoolArrayVar:
  {
    OdArray<bool> varData = value.getBoolArrayValue();
    OdString strVal = L"( ";

    for (OdUInt32 i = 0; i < varData.size(); i++)
      varData[i] ? strVal += L"true," : strVal += L"false,";

    if (varData.isEmpty())
      writeFieldValue(name, OdString(L"<Empty>"));
    else
    {
      strVal = strVal.left(strVal.getLength() - 1) + L" )";
      writeFieldValue(name, strVal);
    }
  } break;

  case OdDgSchemaItemVariant::kPoint3dArrayVar:
  {
    OdArray<OdGePoint3d> varData = value.getPoint3dArrayValue();
    OdString strVal = L"( ";

    for (OdUInt32 i = 0; i < varData.size(); i++)
    {
      OdString strItem;
      strItem.format(L"<%f,%f,%f>,", varData[i].x, varData[i].y, varData[i].z);
      strVal += strItem;
    }

    if (varData.isEmpty())
      writeFieldValue(name, OdString(L"<Empty>"));
    else
    {
      strVal = strVal.left(strVal.getLength() - 1) + L" )";
      writeFieldValue(name, strVal);
    }
  } break;

  case OdDgSchemaItemVariant::kDateTimeArrayVar:
  {
    OdArray<OdTimeStamp> varData = value.getDateTimeArrayValue();
    OdString strVal = L"( ";

    for (OdUInt32 i = 0; i < varData.size(); i++)
    {
      OdString strItem;
      varData[i].strftime(L"<%d.%m.%Y %H:%M:%S>,", strItem);
      strVal += strItem;
    }

    if (varData.isEmpty())
      writeFieldValue(name, OdString(L"<Empty>"));
    else
    {
      strVal = strVal.left(strVal.getLength() - 1) + L" )";
      writeFieldValue(name, strVal);
    }
  } break;

  case OdDgSchemaItemVariant::kExpressionGroupVar:
  {
    OdDgExpressionGroupVariable varData = value.getExpressionGroupValue();

    if (varData.getExpressionCount() == 0)
      writeFieldValue(name, OdString(L"<Empty>"));
    else
    {
      OdString strPrefix = L" ";

      for (OdInt32 k = 0; k < name.getLength(); k++)
      {
        if (name.getAt(k) == L' ')
          strPrefix = L" " + strPrefix;
        else
          break;
      }

      for (OdUInt32 i = 0; i < varData.getExpressionCount(); i++)
      {
        // Convert to string form. But now we dump them as binary data.
        OdDgExpressionVariablePtr pExpression = varData.getExpression(i);

        OdString strExpression;
        strExpression.format(L"Expression %d:", i);
        writeFieldValue(strPrefix + L" = " + strExpression, pExpression->getResultVariableName() + L" = " + pExpression->getExpressionString());
      }
    }
  } break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdGiDgLinetypeModifiers& lsModifiers)
{
  dumpFieldName(name);

  if (lsModifiers.getDashScaleFlag())
    writeFieldValue(" - Line Style Dash Scale", lsModifiers.getDashScale());
  else
    writeFieldValue(" - Line Style Dash Scale", 1.0);

  if (lsModifiers.getGapScaleFlag())
    writeFieldValue(" - Line Style Gap Scale", lsModifiers.getGapScale());
  else
    writeFieldValue(" - Line Style Gap Scale", 1.0);

  if (lsModifiers.getWidthFlag())
  {
    switch (lsModifiers.getWidthMode())
    {
    case OdGiDgLinetypeModifiers::kLsNoWidth:
    {
      writeFieldValue(" - Width Mode", OdString(L"kLsNoWidth"));
    } break;

    case OdGiDgLinetypeModifiers::kLsWidthConstant:
    {
      writeFieldValue(" - Width Mode", OdString(L"kLsWidthConstant"));
      writeFieldValue(" - Width", lsModifiers.getWidth());
      writeFieldValue(" - True Width Flag", lsModifiers.getTrueWidthFlag());
    } break;

    case OdGiDgLinetypeModifiers::kLsWidthTapered:
    {
      writeFieldValue(" - Width Mode", OdString(L"kLsWidthTapered"));
      writeFieldValue(" - Width", lsModifiers.getWidth());
      writeFieldValue(" - End Width", lsModifiers.getEndWidth());
      writeFieldValue(" - True Width Flag", lsModifiers.getTrueWidthFlag());
    } break;
    }
  }
  else
    writeFieldValue(" - Width Mode", OdString(L"kLsNoWidth"));

  if (lsModifiers.getShiftFlag())
  {
    switch (lsModifiers.getShiftMode())
    {
    case OdGiDgLinetypeModifiers::kLsNoShift:
    {
      writeFieldValue(" - Shift Mode", OdString(L"kLsNoShift"));
    } break;

    case OdGiDgLinetypeModifiers::kLsShiftDistance:
    {
      writeFieldValue(" - Shift Mode", OdString(L"kLsShiftDistance"));
      writeFieldValue(" - Shift Distance", lsModifiers.getPhase());
    } break;

    case OdGiDgLinetypeModifiers::kLsShiftFraction:
    {
      writeFieldValue(" - Shift Mode", OdString(L"kLsShiftFraction"));
      writeFieldValue(" - Fraction Phase", lsModifiers.getPhase());
    } break;
    }
  }
  else
    writeFieldValue(" - Shift Mode", OdString(L"kLsNoShift"));

  switch (lsModifiers.getCornersMode())
  {
  case OdGiDgLinetypeModifiers::kLsCornersFromLS:
    writeFieldValue(" - Corners Mode", OdString(L"kLsCornersFromLS")); break;

  case OdGiDgLinetypeModifiers::kLsRunThroughCorners:
    writeFieldValue(" - Corners Mode", OdString(L"kLsRunThroughCorners")); break;

  case OdGiDgLinetypeModifiers::kLsBreakAtCorners:
    writeFieldValue(" - Corners Mode", OdString(L"kLsBreakAtCorners")); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeometryCacheActionPtr& pValue, OdDgDatabase* pDb)
{
  OdString strName;
  OdString strValue;

  switch (pValue->getType())
  {
  case OdDgGeometryCacheAction::kBrepData:
  {
    strName = L"kBrepData";

    OdDgBrepGeometryCacheActionPtr pBrepCache = pValue;
    strValue.format(L"Parasolid stream size = %d", pBrepCache->getBrepData().size());
  } break;

  case OdDgGeometryCacheAction::kBSplineSurface:
  {
    strName = L"kBSplineSurface";
    strValue = L"<empty>";
  } break;

  case OdDgGeometryCacheAction::kCone:
  {
    strName = L"kCylinder";
    OdDgConeGeometryCacheActionPtr pCylinderCache = pValue;
    OdGeVector3d vrRef = pCylinderCache->getRefVector();
    OdGeVector3d vrDir = pCylinderCache->getYDirectionVector();
    OdGePoint3d  ptOrigin1 = pCylinderCache->getStartOrigin();
    OdGePoint3d  ptOrigin2 = pCylinderCache->getEndOrigin();
    strValue.format(L"Ref Vector (%f, %f, %f), Dir Vector (%f, %f, %f), Start Origin (%f, %f, %f), End Origin (%f, %f, %f), Start radius = %f, End radius = %f",
      vrRef.x, vrRef.y, vrRef.z, vrDir.x, vrDir.y, vrDir.z,
      ptOrigin1.x, ptOrigin1.y, ptOrigin1.z, ptOrigin2.x, ptOrigin2.y, ptOrigin2.z,
      pCylinderCache->getStartRadius(), pCylinderCache->getEndRadius()
    );
  } break;

  case OdDgGeometryCacheAction::kMesh:
  {
    strName = L"kMesh";

    OdDgMeshGeometryCacheActionPtr pMeshCache = pValue;
    strValue.format(L"%d faces, %d vertices", pMeshCache->getFaceCount(), pMeshCache->getVertexCount());
  } break;

  case OdDgGeometryCacheAction::kArc3d:
  {
    strName = L"kArc3d";

    OdDgArc3dGeometryCacheActionPtr pArcCache = pValue;
    OdGePoint3d ptOrigin = pArcCache->getOrigin();
    strValue.format(L"origin = (%f,%f,%f), radius = %d", ptOrigin.x, ptOrigin.y, ptOrigin.z, pArcCache->getPrimaryRadius());
  } break;

  case OdDgGeometryCacheAction::kArc2d:
  {
    strName = L"kArc2d";

    OdDgArc2dGeometryCacheActionPtr pArcCache = pValue;
    OdGePoint2d ptOrigin = pArcCache->getOrigin();
    strValue.format(L"origin = (%f,%f), radius = %d", ptOrigin.x, ptOrigin.y, pArcCache->getPrimaryRadius());
  } break;

  case OdDgGeometryCacheAction::kEllipse3d:
  {
    strName = L"kEllipse3d";

    OdDgEllipse3dGeometryCacheActionPtr pEllipseCache = pValue;
    OdGePoint3d ptOrigin = pEllipseCache->getOrigin();
    strValue.format(L"origin = (%f,%f,%f), radius1 = %d, radius2 = %d", ptOrigin.x, ptOrigin.y, ptOrigin.z, pEllipseCache->getPrimaryRadius(), pEllipseCache->getSecondaryRadius());
  } break;

  case OdDgGeometryCacheAction::kTorus:
  {
    strName = L"kTorus";

    OdDgTorusGeometryCacheActionPtr pTorusCache = pValue;
    OdGePoint3d ptOrigin = pTorusCache->getOrigin();
    strValue.format(L"origin = (%f,%f,%f), radius1 = %d, radius2 = %d", ptOrigin.x, ptOrigin.y, ptOrigin.z, pTorusCache->getPrimaryRadius(), pTorusCache->getSecondaryRadius());
  } break;

  case OdDgGeometryCacheAction::kSphere:
  {
    strName = L"kSphere";

    OdDgSphereGeometryCacheActionPtr pSphereCache = pValue;
    OdGePoint3d ptOrigin = pSphereCache->getOrigin();
    strValue.format(L"origin = (%f,%f,%f), radius1 = %d, radius2 = %d", ptOrigin.x, ptOrigin.y, ptOrigin.z, pSphereCache->getPrimaryRadius(), pSphereCache->getSecondaryRadius());
  } break;

  case OdDgGeometryCacheAction::kHatchPattern:
  {
    strName = L"kHatchPattern";

    OdDgHatchPatternGeometryCacheActionPtr pHatchCache = pValue;
    strValue.format(L"number of cache items = %d", pHatchCache->getGeometryItemsCount());
  } break;

  case OdDgGeometryCacheAction::kSlabSolid:
  {
    strName = L"kSlabSolid";

    OdDgSlabSolidGeometryCacheActionPtr pBoxCache = pValue;
    OdGePoint3d ptOrigin1 = pBoxCache->getStartOrigin();
    OdGePoint3d ptOrigin2 = pBoxCache->getEndOrigin();
    strValue.format(L"origin1 = (%f,%f,%f), origin2 = (%f,%f,%f)", ptOrigin1.x, ptOrigin1.y, ptOrigin1.z, ptOrigin2.x, ptOrigin2.y, ptOrigin2.z);
  } break;

  case OdDgGeometryCacheAction::kEllipse2d:
  {
    strName = L"kEllipse2d";

    OdDgEllipse2dGeometryCacheActionPtr pEllipseCache = pValue;
    OdGePoint2d ptOrigin = pEllipseCache->getOrigin();
    strValue.format(L"origin = (%f,%f), radius1 = %d, radius2 = %d", ptOrigin.x, ptOrigin.y, pEllipseCache->getPrimaryRadius(), pEllipseCache->getSecondaryRadius());
  } break;

  case OdDgGeometryCacheAction::kBSplineCurve3d:
  {
    strName = L"kBSplineCurve3d";

    OdDgBSplineCurve3dGeometryCacheActionPtr pCurveCache = pValue;
    strValue.format(L"Order %d, %d poles, %d knots", pCurveCache->getOrder(), pCurveCache->getControlPoints().size(),
      pCurveCache->getKnots().length());
  } break;

  case OdDgGeometryCacheAction::kPolyline3d:
  {
    strName = L"kPolyline3d";

    OdDgPolyline3dGeometryCacheActionPtr pPolylineCache = pValue;

    for (OdUInt32 i = 0; i < pPolylineCache->getVertexCount(); i++)
    {
      OdString strToAdd;
      OdGePoint3d ptVertex = pPolylineCache->getVertex(i);
      strToAdd.format(L"(%f,%f,%f) -> ", ptVertex.x, ptVertex.y, ptVertex.y);
      strValue += strToAdd;
    }

    if (strValue.getLength() > 4)
    {
      strValue = strValue.left(strValue.getLength() - 4);
    }
  } break;

  case OdDgGeometryCacheAction::kPolyline2d:
  {
    strName = L"kPolyline2d";

    OdDgPolyline2dGeometryCacheActionPtr pPolylineCache = pValue;

    for (OdUInt32 i = 0; i < pPolylineCache->getVertexCount(); i++)
    {
      OdString strToAdd;
      OdGePoint2d ptVertex = pPolylineCache->getVertex(i);
      strToAdd.format(L"(%f,%f) -> ", ptVertex.x, ptVertex.y);
      strValue += strToAdd;
    }

    if (strValue.getLength() > 4)
    {
      strValue = strValue.left(strValue.getLength() - 4);
    }
  } break;

  case OdDgGeometryCacheAction::kPolygon3d:
  {
    strName = L"kPolygon3d";

    OdDgPolygon3dGeometryCacheActionPtr pPolylineCache = pValue;

    for (OdUInt32 i = 0; i < pPolylineCache->getVertexCount(); i++)
    {
      OdString strToAdd;
      OdGePoint3d ptVertex = pPolylineCache->getVertex(i);
      strToAdd.format(L"(%f,%f,%f) -> ", ptVertex.x, ptVertex.y, ptVertex.y);
      strValue += strToAdd;
    }

    if (strValue.getLength() > 4)
    {
      strValue = strValue.left(strValue.getLength() - 4);
    }
  } break;

  case OdDgGeometryCacheAction::kPolygon2d:
  {
    strName = L"kPolygon2d";

    OdDgPolygon2dGeometryCacheActionPtr pPolylineCache = pValue;

    for (OdUInt32 i = 0; i < pPolylineCache->getVertexCount(); i++)
    {
      OdString strToAdd;
      OdGePoint2d ptVertex = pPolylineCache->getVertex(i);
      strToAdd.format(L"(%f,%f) -> ", ptVertex.x, ptVertex.y);
      strValue += strToAdd;
    }

    if (strValue.getLength() > 4)
    {
      strValue = strValue.left(strValue.getLength() - 4);
    }
  } break;

  case OdDgGeometryCacheAction::kPushTransform:
  {
    strName = L"kPushTransform";

    OdDgPushTransformGeometryCacheActionPtr pCache = pValue;

    OdGeMatrix3d mat = pCache->getTransformMatrix();

    strValue.format(L"((%f,%f,%f,%f),(%f,%f,%f,%f),(%f,%f,%f,%f),(%f,%f,%f,%f))",
      mat[0][0], mat[0][1], mat[0][2], mat[0][3],
      mat[1][0], mat[1][1], mat[1][2], mat[1][3],
      mat[2][0], mat[2][1], mat[2][2], mat[2][3],
      mat[3][0], mat[3][1], mat[3][2], mat[3][3]
    );
  } break;

  case OdDgGeometryCacheAction::kPopTransform:
  {
    strName = L"kPopTransform";
    strValue = L"<empty>";
  } break;

  case OdDgGeometryCacheAction::kBeginSolid:
  {
    strName = L"kBeginSolid";
    OdDgBeginSolidGeometryCacheActionPtr pCache = pValue;
    strValue.format(L"isSolid = %d", pCache->isSolid());
  } break;

  case OdDgGeometryCacheAction::kBeginExtrusionSolid:
  {
    strName = L"kBeginExtrusionSolid";
    OdDgBeginExtrusionSolidGeometryCacheActionPtr pCache = pValue;
    OdGeVector3d vrExtrusion = pCache->getExtrusionVector();
    strValue.format(L"isSolid = %d, vrExtrusion = (%f,%f,%f)", pCache->isSolid(), vrExtrusion.x, vrExtrusion.y, vrExtrusion.z);
  } break;

  case OdDgGeometryCacheAction::kBeginRevolutionSolid:
  {
    strName = L"kBeginRevolutionSolid";
    OdDgBeginRevolutionSolidGeometryCacheActionPtr pCache = pValue;
    strValue.format(L"isSolid = %d", pCache->getSolidFlag());
  } break;

  case OdDgGeometryCacheAction::kEndSolid:
  {
    strName = L"kEndSolid";
    strValue = L"<empty>";
  } break;

  case OdDgGeometryCacheAction::kModifiedProfileBegin:
  {
    strName = L"kModifiedProfileBegin";
    strValue = L"<empty>";
  } break;

  case OdDgGeometryCacheAction::kModifiedProfileEnd:
  {
    strName = L"kModifiedProfileEnd";
    strValue = L"<empty>";
  } break;

  case OdDgGeometryCacheAction::kBeginComplexShapeOrGrHole:
  {
    strName = L"kBeginComplex";
    OdDgBeginComplexGeometryCacheActionPtr pCache = pValue;
    strValue.format(L"subType = %d", pCache->getActionSubtype());
  } break;

  case OdDgGeometryCacheAction::kBeginComplexString:
  {
    strName = L"kBeginComplexString";
    strValue = L"<empty>";
  } break;

  case OdDgGeometryCacheAction::kEndComplex:
  {
    strName = L"kEndComplex";
    strValue = L"<empty>";
  } break;

  case OdDgGeometryCacheAction::kMarkHole:
  {
    strName = L"kMarkHole";
    strValue = L"<empty>";
  } break;

  case OdDgGeometryCacheAction::kSetTrainsData:
  {
    strName = L"kSetTraitsData";

    OdDgSetTraitsDataGeometryCacheActionPtr pCache = pValue;

    strValue = L"(";

    if (pCache->getColorFlag())
    {
      OdString strToAdd;
      strToAdd.format(L"Color = %d, ", pCache->getColorIndex());
      strValue += strToAdd;
    }

    if (pCache->getFillColorFlag())
    {
      OdString strToAdd;
      strToAdd.format(L"FillColor = %d, ", pCache->getFillColorIndex());
      strValue += strToAdd;
    }

    if (pCache->getLineWeightFlag())
    {
      OdString strToAdd;
      strToAdd.format(L"LineWeight = %d, ", pCache->getLineWeight());
      strValue += strToAdd;
    }

    if (pCache->getLineTypeFlag())
    {
      OdString strToAdd;
      strToAdd.format(L"LineType = %d, ", pCache->getLineType());
      strValue += strToAdd;
    }

    if (pCache->getFillModeFlag())
    {
      OdString strToAdd;
      strToAdd.format(L"FillMode = %d, ", pCache->getFillMode());
      strValue += strToAdd;
    }

    if (pCache->getTransparencyFlag())
    {
      OdString strToAdd;
      strToAdd.format(L"Transparency = %f, ", pCache->getTransparency());
      strValue += strToAdd;
    }

    if (pCache->getSubitemIndexFlag())
    {
      OdString strSubitems;
      strSubitems.format(L"subItemIndex = %d, ", pCache->getSubitemIndex());
      strValue += strSubitems;
    }

    if (pCache->getMaterialIdFlag())
    {
      OdString strToAdd;

      bool bAddId = true;

      if( pDb && (pCache->getMateralId() != (OdUInt64)(-1)) )
      {
        OdDgElementId idElm = pDb->getElementId(OdDbHandle(pCache->getMateralId()));

        if( !idElm.isNull() )
        {
          OdDgElementPtr pElm = idElm.openObject(OdDg::kForRead);

          if (!pElm.isNull() && pElm->isKindOf(OdDgMaterialTableRecord::desc()))
          {
            OdDgMaterialTableRecordPtr pMat = pElm;
            strToAdd = L"Material = \"" + pMat->getName() + L"\", ";
            bAddId = false;
          }
        }
      }
      
      if( bAddId )
        strToAdd.format(L"MaterialId = 0x%08X, ", pCache->getMateralId());

      strValue += strToAdd;
    }

    if (pCache->getLineStyleModFlag())
    {
      double dScale = pCache->getLineStyleScale();
      OdString strToAdd;
      strToAdd.format(L"LineStyleScale = %f, ", dScale);
      strValue += strToAdd;
    }

    if (pCache->getAlternativeRGBColor())
    {
      OdString strToAdd;
      strToAdd.format(L"AlternativeRGBColor = (%d,%d,%d), ", ODGETRED(pCache->getAlternativeRGBColor()),
        ODGETGREEN(pCache->getAlternativeRGBColor()), ODGETBLUE(pCache->getAlternativeRGBColor()));
      strValue += strToAdd;
    }

    if (strValue.getLength() > 2)
      strValue = strValue.left(strValue.getLength() - 2);
    else
      strValue += "Reset All";

    strValue += L")";

  } break;

  case OdDgGeometryCacheAction::kOriginAndRotation:
  {
    strName = L"kOriginAndRotation";

    OdDgOriginAndRotationGeometryCacheActionPtr pCache = pValue;

    OdGePoint3d    ptOrigin = pCache->getOrigin();
    OdGeQuaternion quatRotation = pCache->getRotation();

    if (pCache->getRotationFlag())
      strValue.format(L"Pt:(%f,%f,%f), Dir:(%f,%f,%f,%f)", ptOrigin.x, ptOrigin.y, ptOrigin.z, quatRotation.w, quatRotation.x, quatRotation.y, quatRotation.z);
    else
      strValue.format(L"Pt:(%f,%f,%f)", ptOrigin.x, ptOrigin.y, ptOrigin.z);
  } break;

  case OdDgGeometryCacheAction::kExtraDataSectionBegin:
  {
    OdDgExtraDataSectionBeginGeometryCacheActionPtr pCache = pValue;

    if (pCache->isLevelIndexData())
    {
      strName = L"kSetLevelIndex";
      strValue.format(L"Level Index = %d", pCache->getLevelIndex());
    }
    else
    {
      strName = L"kExtraDataSectionBegin";
      strValue.format(L"Type = %d, Data Size = %d", pCache->getExtraProxyDataType(), pCache->getExtraProxyData().size());
    }
  } break;

  case OdDgGeometryCacheAction::kExtraDataSectionEnd:
  {
    strName = L"kExtraDataSectionEnd";
    strValue = L"<empty>";
  } break;

  case OdDgGeometryCacheAction::kByLevelOrGradientData:
  {
    strName = L"kByLevelOrGradientData";

    OdDgByLevelOrGradientDataGeometryCacheActionPtr pCache = pValue;

    strValue = L"(";

    if (pCache->getUseByLevelDataFlag())
    {
      if (pCache->getColorByLevelFlag())
        strValue += L"Color, ";

      if (pCache->getFillColorByLevelFlag())
        strValue += L"FillColor, ";

      if (pCache->getLineWeightByLevelFlag())
        strValue += L"LineWeight, ";

      if (pCache->getLineTypeByLevelFlag())
        strValue += L"LineType, ";
    }

    if (pCache->getUseGradientDataFlag())
    {
      if (pCache->getEndOfUseGradientDataFlag())
        strValue += L"X-Gradient-X, ";
      else
        strValue += L"Gradient, ";
    }

    if (strValue.getLength() > 2)
      strValue = strValue.left(strValue.getLength() - 2);
    else
      strValue += "Reset All";

    strValue += L")";
  } break;

  case OdDgGeometryCacheAction::kText:
  {
    strName = L"kText";

    OdDgTextGeometryCacheActionPtr pCache = pValue;
    strValue = L"\"" + pCache->getText() + L"\"";
  } break;

  default:
  {
    strName.format(L"kAction_0x%02x", (OdUInt16)(pValue->getType()));
    OdBinaryData binData = pValue->getProxyData();
    //strValue.format(L"-= Proxy Data Size = %d =-", binData.size() );

    for (OdUInt32 l = 0; l < binData.size(); l++)
    {
      OdString strV;
      strV.format(L"%02x,", binData[l]);
      strValue += strV;
    };

    strValue = strValue.left(strValue.getLength() - 1);
  } break;
  }

  if (pValue->isCorrupted())
  {
    strValue = L"!!! Data Corrupted";
  }

  strName = name + strName;

  writeFieldValue(strName, strValue);
}

void OdExDgnDumper::writeFieldColorValue(const OdString& name, OdUInt32 value)
{
  if (value == OdDg::kColorByLevel)
  {
    writeFieldValue(name, OdString(L"kColorByLevel"));
  }
  else if (value == OdDg::kColorByCell)
  {
    writeFieldValue(name, OdString(L"kColorByCell"));
  }
  else
  {
    writeFieldValue(name, value);
  }
}

void OdExDgnDumper::writeFieldLineStyleValue(const OdString& name, OdUInt32 value)
{
  if (value == OdDg::kLineStyleByLevel)
  {
    writeFieldValue(name, OdString(L"kLineStyleByLevel"));
  }
  else if (value == OdDg::kLineStyleByCell)
  {
    writeFieldValue(name, OdString(L"kLineStyleByCell"));
  }
  else
  {
    writeFieldValueHex(name, value);
  }
}

void OdExDgnDumper::writeFieldLineWeightValue(const OdString& name, OdUInt32 value)
{
  if (value == OdDg::kLineWeightByLevel)
  {
    writeFieldValue(name, OdString(L"kLineWeightByLevel"));
  }
  else if (value == OdDg::kLineWeightByCell)
  {
    writeFieldValue(name, OdString(L"kLineWeightByCell"));
  }
  else
  {
    writeFieldValue(name, value);
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdString>& arrData, bool bHideIfEmpty)
{
  if (bHideIfEmpty && arrData.isEmpty())
    return;

  OdString strValue;

  for (OdUInt32 i = 0; i < arrData.size(); i++)
    strValue += arrData[i] + L", ";

  if (!strValue.isEmpty())
  {
    strValue = strValue.left(strValue.getLength() - 2);
    strValue = L"( " + strValue + L" )";
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdUInt64>& arrData, bool bHideIfEmpty)
{
  if (bHideIfEmpty && arrData.isEmpty())
    return;

  OdString strValue;

  for (OdUInt32 i = 0; i < arrData.size(); i++)
  {
    OdString strItem;
    strItem.format(L"%I64u", arrData[i]);
    strValue += strItem + L", ";
  }

  if (!strValue.isEmpty())
  {
    strValue = strValue.left(strValue.getLength() - 2);
    strValue = L"( " + strValue + L" )";
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdUInt32>& arrData, bool bHideIfEmpty)
{
  if (bHideIfEmpty && arrData.isEmpty())
    return;

  OdString strValue;

  for (OdUInt32 i = 0; i < arrData.size(); i++)
  {
    OdString strItem;
    strItem.format(L"%u", arrData[i]);
    strValue += strItem + L", ";
  }

  if (!strValue.isEmpty())
  {
    strValue = strValue.left(strValue.getLength() - 2);
    strValue = L"( " + strValue + L" )";
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<OdInt32>& arrData, bool bHideIfEmpty)
{
  if (bHideIfEmpty && arrData.isEmpty())
    return;

  OdString strValue;

  for (OdUInt32 i = 0; i < arrData.size(); i++)
  {
    OdString strItem;
    strItem.format(L"%d", arrData[i]);
    strValue += strItem + L", ";
  }

  if (!strValue.isEmpty())
  {
    strValue = strValue.left(strValue.getLength() - 2);
    strValue = L"( " + strValue + L" )";
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<double>& arrData, bool bHideIfEmpty)
{
  if (bHideIfEmpty && arrData.isEmpty())
    return;

  OdString strValue;

  for (OdUInt32 i = 0; i < arrData.size(); i++)
  {
    OdString strItem;
    strItem.format(L"%f", arrData[i]);
    strValue += strItem + L", ";
  }

  if (!strValue.isEmpty())
  {
    strValue = strValue.left(strValue.getLength() - 2);
    strValue = L"( " + strValue + L" )";
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdArray<bool>& arrData, bool bHideIfEmpty)
{
  if (bHideIfEmpty && arrData.isEmpty())
    return;

  OdString strValue;

  for (OdUInt32 i = 0; i < arrData.size(); i++)
  {
    if (arrData[i])
      strValue += "true, ";
    else
      strValue += "false, ";
  }

  if (!strValue.isEmpty())
  {
    strValue = strValue.left(strValue.getLength() - 2);
    strValue = L"( " + strValue + L" )";
  }

  writeFieldValue(name, strValue);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgECClass::OdDgECClassType type)
{
  switch (type)
  {
  case OdDgECClass::kCustomAttribute:
    writeFieldValue(name, OdString(OD_T("kCustomAttribute"))); break;
  case OdDgECClass::kClassDomain:
    writeFieldValue(name, OdString(OD_T("kClassDomain"))); break;
  case OdDgECClass::kClassStructDomain:
    writeFieldValue(name, OdString(OD_T("kClassStructDomain"))); break;
  case OdDgECClass::kClassStructValue:
    writeFieldValue(name, OdString(OD_T("kClassStructValue"))); break;
  default:
    writeFieldValue(name, OdString(OD_T("kClassValue"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgECRelationshipClass::OdDgECRelationshipStrength type)
{
  switch (type)
  {
    case OdDgECRelationshipClass::kEmbedding:
      writeFieldValue(name, OdString(OD_T("kEmbedding"))); break;
    case OdDgECRelationshipClass::kHolding:
      writeFieldValue(name, OdString(OD_T("kHolding"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kReferencing"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgECRelationshipClass::OdDgECRelationshipDirection type)
{
  if(type == OdDgECRelationshipClass::kBackward)
    writeFieldValue(name, OdString(OD_T("kBackward")));
  else
    writeFieldValue(name, OdString(OD_T("kForward")));
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::OdDgAngleAccuracy type)
{
  switch (type)
  {
    case OdDgModel::kAngleAccuracy0:
      writeFieldValue(name, OdString(OD_T("kAngleAccuracy0"))); break;
    case OdDgModel::kAngleAccuracy1:
      writeFieldValue(name, OdString(OD_T("kAngleAccuracy1"))); break;
    case OdDgModel::kAngleAccuracy2:
      writeFieldValue(name, OdString(OD_T("kAngleAccuracy2"))); break;
    case OdDgModel::kAngleAccuracy3:
      writeFieldValue(name, OdString(OD_T("kAngleAccuracy3"))); break;
    case OdDgModel::kAngleAccuracy4:
      writeFieldValue(name, OdString(OD_T("kAngleAccuracy4"))); break;
    case OdDgModel::kAngleAccuracy5:
      writeFieldValue(name, OdString(OD_T("kAngleAccuracy5"))); break;
    case OdDgModel::kAngleAccuracy6:
      writeFieldValue(name, OdString(OD_T("kAngleAccuracy6"))); break;
    case OdDgModel::kAngleAccuracy7:
      writeFieldValue(name, OdString(OD_T("kAngleAccuracy7"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kAngleAccuracy8"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::OdDgAngleDirectionMode type)
{
  switch (type)
  {
    case OdDgModel::kAzimut:
      writeFieldValue(name, OdString(OD_T("kAzimut"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kBearing"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::OdDgAngleFormat type)
{
  switch (type)
  {
    case OdDgModel::kAngle_D:
      writeFieldValue(name, OdString(OD_T("kAngle_D"))); break;
    case OdDgModel::kAngle_DM:
      writeFieldValue(name, OdString(OD_T("kAngle_DM"))); break;
    case OdDgModel::kAngle_DMS:
      writeFieldValue(name, OdString(OD_T("kAngle_DMS"))); break;
    case OdDgModel::kAngle_Gradian:
      writeFieldValue(name, OdString(OD_T("kAngle_Gradian"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kAngle_Radian"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::OdDgUnitsFormat type)
{
  switch (type)
  {
    case OdDgModel::kMu_Su:
      writeFieldValue(name, OdString(OD_T("Mu:Su"))); break;
    case OdDgModel::kMu:
      writeFieldValue(name, OdString(OD_T("Mu"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("Mu:Su:Pu"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidHelixNode::OdDgFetureSolidHelixThreadType type)
{
  switch (type)
  {
    case OdDgFeatureSolidHelixNode::kLeft:
      writeFieldValue(name, OdString(OD_T("kLeft"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kRight"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidHelixNode::OdDgFetureSolidHelixPitchType type)
{
  switch (type)
  {
    case OdDgFeatureSolidHelixNode::kVarying:
      writeFieldValue(name, OdString(OD_T("kVarying"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kConstant"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidThicknessNode::OdDgFeatureSolidThicknessApplyToType type)
{
  switch (type)
  {
    case OdDgFeatureSolidThicknessNode::kSideOne:
      writeFieldValue(name, OdString(OD_T("kSideOne"))); break;
    case OdDgFeatureSolidThicknessNode::kSideTwo:
      writeFieldValue(name, OdString(OD_T("kSideTwo"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kBothSides"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidChamferNode::OdDgFeatureSolidChamferMode type)
{
  switch (type)
  {
  case OdDgFeatureSolidChamferNode::kChamferLength:
      writeFieldValue(name, OdString(OD_T("kChamferLength"))); break;
    case OdDgFeatureSolidChamferNode::kDistances:
      writeFieldValue(name, OdString(OD_T("kDistances"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kDistanceAngle"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidHoleNode::OdDgFeatureSolidHoleType type)
{
  switch (type)
  {
  case OdDgFeatureSolidHoleNode::kSimple:
    writeFieldValue(name, OdString(OD_T("kSimple"))); break;
  case OdDgFeatureSolidHoleNode::kCounterbore:
    writeFieldValue(name, OdString(OD_T("kCounterbore"))); break;
  default:
    writeFieldValue(name, OdString(OD_T("kCountersink"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidHoleNode::OdDgFeatureSolidHoleDrillType type)
{
  switch (type)
  {
  case OdDgFeatureSolidHoleNode::kThrough:
    writeFieldValue(name, OdString(OD_T("kThrough"))); break;
  case OdDgFeatureSolidHoleNode::kBlind:
    writeFieldValue(name, OdString(OD_T("kBlind"))); break;
  default:
    writeFieldValue(name, OdString(OD_T("kNextFace"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidHoleNode::OdDgFeatureSolidHoleCounterType type)
{
  switch (type)
  {
  case OdDgFeatureSolidHoleNode::kFirstFace:
    writeFieldValue(name, OdString(OD_T("kFirstFace"))); break;
  case OdDgFeatureSolidHoleNode::kLastFace:
    writeFieldValue(name, OdString(OD_T("kLastFace"))); break;
  default:
    writeFieldValue(name, OdString(OD_T("kBothFaces"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidCutNode::OdDgFeatureSolidCutMethod type)
{
  switch (type)
  {
    case OdDgFeatureSolidCutNode::kOutsideProfile:
      writeFieldValue(name, OdString(OD_T("kOutsideProfile"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kInsideProfile"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidCutNode::OdDgFeatureSolidCutThroughType type)
{
  switch (type)
  {
    case OdDgFeatureSolidCutNode::kBlind:
      writeFieldValue(name, OdString(OD_T("kBlind"))); break;
    case OdDgFeatureSolidCutNode::kUpToBody:
      writeFieldValue(name, OdString(OD_T("kUpToBody"))); break;
    case OdDgFeatureSolidCutNode::kAllFaces:
      writeFieldValue(name, OdString(OD_T("kAllFaces"))); break;
    case OdDgFeatureSolidCutNode::kNextFace:
      writeFieldValue(name, OdString(OD_T("kNextFace"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kSelectedFaces"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidCutNode::OdDgFeatureSolidCutOffsetType type)
{
  switch (type)
  {
  case OdDgFeatureSolidCutNode::kOffsetBy:
    writeFieldValue(name, OdString(OD_T("kOffsetBy"))); break;
  default:
    writeFieldValue(name, OdString(OD_T("kMoveBy"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidProtrusionNode::OdDgFeatureSolidProtrusionMethod type)
{
  switch (type)
  {
  case OdDgFeatureSolidProtrusionNode::kOutsideProfile:
    writeFieldValue(name, OdString(OD_T("kOutsideProfile"))); break;
  default:
    writeFieldValue(name, OdString(OD_T("kInsideProfile"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidProtrusionNode::OdDgFeatureSolidProtrusionThroughType type)
{
  switch (type)
  {
  case OdDgFeatureSolidProtrusionNode::kBlind:
    writeFieldValue(name, OdString(OD_T("kBlind"))); break;
  case OdDgFeatureSolidProtrusionNode::kUpToBody:
    writeFieldValue(name, OdString(OD_T("kUpToBody"))); break;
  case OdDgFeatureSolidProtrusionNode::kAllFaces:
    writeFieldValue(name, OdString(OD_T("kAllFaces"))); break;
  case OdDgFeatureSolidProtrusionNode::kNextFace:
    writeFieldValue(name, OdString(OD_T("kNextFace"))); break;
  default:
    writeFieldValue(name, OdString(OD_T("kSelectedFaces"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidProtrusionNode::OdDgFeatureSolidProtrusionOffsetType type)
{
  switch (type)
  {
  case OdDgFeatureSolidProtrusionNode::kOffsetBy:
    writeFieldValue(name, OdString(OD_T("kOffsetBy"))); break;
  default:
    writeFieldValue(name, OdString(OD_T("kMoveBy"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidSweepEdgeNode::OdDgFeatureSolidSweepEdgeMode type)
{
  switch (type)
  {
    case OdDgFeatureSolidSweepEdgeNode::kCut:
      writeFieldValue(name, OdString(OD_T("kCut"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kProtrude"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidSweepEdgeNode::OdDgFeatureSolidSweepEdgeMethod type)
{
  switch (type)
  {
    case OdDgFeatureSolidSweepEdgeNode::kCircularEdge:
      writeFieldValue(name, OdString(OD_T("kCircularEdge"))); break;
    case OdDgFeatureSolidSweepEdgeNode::kSelectedEdge:
      writeFieldValue(name, OdString(OD_T("kSelectedEdge"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kPoint"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureSolidArrayNode::OdDgFeatureSolidArrayType type)
{
  switch (type)
  {
    case OdDgFeatureSolidArrayNode::kRectangular:
      writeFieldValue(name, OdString(OD_T("kRectangular"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kPolar"))); break;
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgVolumeClipSettings& value)
{
  OdString strVolumeClip;

  if (value.getDisplayStyleEntryId() == value.getDisplayStyleFromView())
    strVolumeClip = L"Display Style = kFromView";
  else
    strVolumeClip.format(L"Display Style = %d", value.getDisplayStyleEntryId());

  if (value.getLocateFlag())
    strVolumeClip = L"Lacale = true, " + strVolumeClip;
  else
    strVolumeClip = L"Lacale = false, " + strVolumeClip;

  if (value.getSnapFlag())
    strVolumeClip = L"Snap = true, " + strVolumeClip;
  else
    strVolumeClip = L"Snap = false, " + strVolumeClip;

  if (value.getDisplayFlag())
    strVolumeClip = L"Display = true, " + strVolumeClip;
  else
    strVolumeClip = L"Display = false, " + strVolumeClip;

  writeFieldValue(name, strVolumeClip);
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgFeatureLinkage::OdDgFeatureElementType type)
{
  switch (type)
  {
    case OdDgFeatureLinkage::kFeatureCell:
      writeFieldValue(name, OdString(OD_T("kFeatureCell"))); break;
    case OdDgFeatureLinkage::kFeatureNode:
      writeFieldValue(name, OdString(OD_T("kFeatureNode"))); break;    
    case OdDgFeatureLinkage::kFeatureNodeSheetWire:
      writeFieldValue(name, OdString(OD_T("kFeatureNodeSheetWire"))); break;
    default:
    {
      OdString strValue;
      strValue.format(L"kUnknownValue_%d", (OdUInt16)(type));
      writeFieldValue(name, strValue); break;
    }
  }
}

void OdExDgnDumper::writeFieldValue(const OdString& name, OdDgModel::OdDgUnitsAccuracy type)
{
  switch (type)
  {
    case OdDgModel::kAccuracyDecimal1:
      writeFieldValue(name, OdString(OD_T("kAccuracyDecimal1"))); break;
    case OdDgModel::kAccuracyDecimal2:
      writeFieldValue(name, OdString(OD_T("kAccuracyDecimal2"))); break;
    case OdDgModel::kAccuracyDecimal3:
      writeFieldValue(name, OdString(OD_T("kAccuracyDecimal3"))); break;
    case OdDgModel::kAccuracyDecimal4:
      writeFieldValue(name, OdString(OD_T("kAccuracyDecimal4"))); break;
    case OdDgModel::kAccuracyDecimal5:
      writeFieldValue(name, OdString(OD_T("kAccuracyDecimal5"))); break;
    case OdDgModel::kAccuracyDecimal6:
      writeFieldValue(name, OdString(OD_T("kAccuracyDecimal6"))); break;
    case OdDgModel::kAccuracyDecimal7:
      writeFieldValue(name, OdString(OD_T("kAccuracyDecimal7"))); break;
    case OdDgModel::kAccuracyDecimal8:
      writeFieldValue(name, OdString(OD_T("kAccuracyDecimal8"))); break;
    case OdDgModel::kAccuracyExponential1:
      writeFieldValue(name, OdString(OD_T("kAccuracyExponential1"))); break;
    case OdDgModel::kAccuracyExponential2:
      writeFieldValue(name, OdString(OD_T("kAccuracyExponential2"))); break;
    case OdDgModel::kAccuracyExponential3:
      writeFieldValue(name, OdString(OD_T("kAccuracyExponential3"))); break;
    case OdDgModel::kAccuracyExponential4:
      writeFieldValue(name, OdString(OD_T("kAccuracyExponential4"))); break;
    case OdDgModel::kAccuracyExponential5:
      writeFieldValue(name, OdString(OD_T("kAccuracyExponential5"))); break;
    case OdDgModel::kAccuracyExponential6:
      writeFieldValue(name, OdString(OD_T("kAccuracyExponential6"))); break;
    case OdDgModel::kAccuracyExponential7:
      writeFieldValue(name, OdString(OD_T("kAccuracyExponential7"))); break;
    case OdDgModel::kAccuracyExponential8:
      writeFieldValue(name, OdString(OD_T("kAccuracyExponential8"))); break;
    case OdDgModel::kAccuracyFractional2:
      writeFieldValue(name, OdString(OD_T("kAccuracyFractional2"))); break;
    case OdDgModel::kAccuracyFractional4:
      writeFieldValue(name, OdString(OD_T("kAccuracyFractional4"))); break;
    case OdDgModel::kAccuracyFractional8:
      writeFieldValue(name, OdString(OD_T("kAccuracyFractional8"))); break;
    case OdDgModel::kAccuracyFractional16:
      writeFieldValue(name, OdString(OD_T("kAccuracyFractional16"))); break;
    case OdDgModel::kAccuracyFractional32:
      writeFieldValue(name, OdString(OD_T("kAccuracyFractional32"))); break;
    case OdDgModel::kAccuracyFractional64:
      writeFieldValue(name, OdString(OD_T("kAccuracyFractional64"))); break;
    case OdDgModel::kAccuracyFractional128:
      writeFieldValue(name, OdString(OD_T("kAccuracyFractional128"))); break;
    case OdDgModel::kAccuracyFractional256:
      writeFieldValue(name, OdString(OD_T("kAccuracyFractional256"))); break;
    default:
      writeFieldValue(name, OdString(OD_T("kAccuracyNone"))); break;
  }
}

#endif // _EX_DGNDUMPER_H_