/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#include "OdaCommon.h"
#include "ExDgnDumper.h"

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgECClassInstancePtr& pClass)
{
  // Dump default class instances.
  OdDgECClassReference classRef = pClass->getECClassReference();

  OdString strClassName = convertECSchemaItemNameToString(classRef.getClassName());
  OdString strSchemaName = convertECSchemaItemNameToString(classRef.getSchemaName());
  OdString strSchemaPrefix = convertECSchemaItemNameToString(classRef.getSchemaPrefix());

  writeFieldValue(name + strClassName, strSchemaName + L"." + classRef.getSchemaVersion() + L" ( " + strSchemaPrefix + L" )");

  OdString strPropPrefix;

  for (OdInt32 k = 0; k < name.getLength(); k++)
    strPropPrefix += L" ";

  strPropPrefix += L" = ";

  for( OdUInt32 i = 0; i < pClass->getPropertyInstanceCount(); i++ )
  {
    OdDgECPropertyInstance propInstance = pClass->getPropertyInstance(i);

    OdString strTypeName;
    OdDgECClassReference typeRef;

    switch (propInstance.getType())
    {
      case OdDgECPropertyInstance::kUndefined:
      {
        strTypeName = " <unknownType>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, OdString(L"--No data--"));
      } break;

      case OdDgECPropertyInstance::kBool:
      {
        strTypeName = " <bool>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getBoolValue());
      } break;

      case OdDgECPropertyInstance::kBoolArray:
      {
        strTypeName = " <boolArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getBoolArrayValue());
      } break;

      case OdDgECPropertyInstance::kByte:
      {
        strTypeName = " <byte>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getUByteValue());
      } break;

      case OdDgECPropertyInstance::kByteArray:
      {
        strTypeName = " <byteArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getByteArrayValue());
      } break;

      case OdDgECPropertyInstance::kShort:
      {
        strTypeName = " <short>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getShortValue());
      } break;

      case OdDgECPropertyInstance::kShortArray:
      {
        strTypeName = " <shortArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getShortArrayValue());
      } break;

      case OdDgECPropertyInstance::kInt32:
      {
        strTypeName = " <int>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getIntValue());
      } break;

      case OdDgECPropertyInstance::kInt32Array:
      {
        strTypeName = " <intArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getIntArrayValue());
      } break;

      case OdDgECPropertyInstance::kInt64:
      {
        strTypeName = " <long>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getInt64Value());
      } break;

      case OdDgECPropertyInstance::kInt64Array:
      {
        strTypeName = " <longArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getInt64ArrayValue());
      } break;

      case OdDgECPropertyInstance::kDouble:
      {
        strTypeName = " <double>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getDoubleValue());
      } break;

      case OdDgECPropertyInstance::kDoubleArray:
      {
        strTypeName = " <doubleArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getDoubleArrayValue());
      } break;

      case OdDgECPropertyInstance::kBinary:
      {
        strTypeName = " <binary>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getBinaryValue());
      } break;

      case OdDgECPropertyInstance::kBinaryArray:
      {
        strTypeName = " <binaryArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getBinaryArrayValue());
      } break;

      case OdDgECPropertyInstance::kString:
      {
        strTypeName = " <string>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, convertECSchemaItemNameToString(propInstance.getStringValue()));
      } break;

      case OdDgECPropertyInstance::kStringArray:
      {
        strTypeName = " <stringArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getStringArrayValue());
      } break;

      case OdDgECPropertyInstance::kPoint3d:
      {
        strTypeName = " <point3d>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getPoint3dValue());
      } break;

      case OdDgECPropertyInstance::kPoint3dArray:
      {
        strTypeName = " <point3dArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getPoint3dArrayValue());
      } break;

      case OdDgECPropertyInstance::kDateAndTime:
      {
        strTypeName = " <dateTime>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getDateTimeValue());
      } break;

      case OdDgECPropertyInstance::kDateTimeArray:
      {
        strTypeName = " <dateTimeArray>";
        writeFieldValue(strPropPrefix + propInstance.getName() + strTypeName, propInstance.getDateTimeArrayValue());
      } break;

      case OdDgECPropertyInstance::kECClassInstance:
      {
        OdDgECClassInstancePtr pClassInst = propInstance.getClassInstanceValue();
        OdDgECClassReference classRef = pClassInst->getECClassReference();
        OdString strClassName  = convertECSchemaItemNameToString(classRef.getClassName());
        OdString strSchemaPrefix = convertECSchemaItemNameToString(classRef.getSchemaPrefix());
        writeFieldValue(strPropPrefix + convertECSchemaItemNameToString(propInstance.getName()), strSchemaPrefix + L":" + strClassName);

        OdString strClassInstPrefix;

        for (OdInt32 l = 0; l < strPropPrefix.getLength(); l++)
          strClassInstPrefix += L" ";

        strClassInstPrefix += L" + ";

        writeFieldValue(strClassInstPrefix, pClassInst);
      } break;
      case OdDgECPropertyInstance::kECClassInstanceArray:
      {
        OdArray<OdDgECClassInstancePtr> pClassInstArr = propInstance.getClassInstanceArrayValue();

        if (pClassInstArr.isEmpty())
        {
          writeFieldValue(strPropPrefix + propInstance.getName(), OdString(L"<--Empty Class Instance Array-->"));
        }
        else
        {
          OdDgECClassReference classRef = pClassInstArr[0]->getECClassReference();
          OdString strClassName = convertECSchemaItemNameToString(classRef.getClassName());
          OdString strSchemaPrefix = convertECSchemaItemNameToString(classRef.getSchemaPrefix());
          writeFieldValue(strPropPrefix + convertECSchemaItemNameToString(propInstance.getName()), L"Array of < " + strSchemaPrefix + L":" + strClassName + L" >");

          OdString strClassInstPrefix;

          for (OdInt32 l = 0; l < strPropPrefix.getLength(); l++)
            strClassInstPrefix += L" ";

          strClassInstPrefix += L" + ";

          for( OdUInt32 n = 0; n < pClassInstArr.size(); n++ )
            writeFieldValue(strClassInstPrefix, pClassInstArr[n]);
        }
      } break;
    }
  }
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgECRelationshipInstancePtr& pRelationship)
{
  // Dump default class instances.
  OdDgECClassReference classRef = pRelationship->getECClassReference();

  OdString strClassName = convertECSchemaItemNameToString(classRef.getClassName());
  OdString strSchemaName = convertECSchemaItemNameToString(classRef.getSchemaName());
  OdString strSchemaPrefix = convertECSchemaItemNameToString(classRef.getSchemaPrefix());

  if( strSchemaPrefix.isEmpty() )
    writeFieldValue(name + strClassName, strSchemaName + L"." + classRef.getSchemaVersion());
  else
    writeFieldValue(name + strClassName, strSchemaName + L"." + classRef.getSchemaVersion() + L" ( " + strSchemaPrefix + L" )");

  OdString strPropPrefix;

  for (OdInt32 k = 0; k < name.getLength(); k++)
    strPropPrefix += L" ";

  strPropPrefix += L" = ";

  writeFieldValue(strPropPrefix + L"Local Index", pRelationship->getLocalIndex());
  writeFieldValue(strPropPrefix + L"Mode", pRelationship->getRelationshipMode() == OdDgECRelationshipInstance::kSource ? OdString(L"kSource") : OdString(L"kTarget"));
  writeFieldValue(strPropPrefix + L"Handler", pRelationship->getHandlerName());

  if( pRelationship->getHeaderLocalIndex() != 0 )
    writeFieldValue(strPropPrefix + L"Header Relationship Local Index", pRelationship->getHeaderLocalIndex());

  writeFieldValueHex(strPropPrefix + L"Flags", pRelationship->getFlags());
  writeFieldValue(strPropPrefix + L"Use Unknown Node Count Format Flag", pRelationship->getUnknownNodeCountFormatFlag());
  writeFieldValue(strPropPrefix + L"Use Handler Flag", pRelationship->getUseHandlerFlag());
  writeFieldValue(strPropPrefix + L"Use Extended Value Flag", pRelationship->getUseExtendedValueFlag());
  writeFieldValue(strPropPrefix + L"Use Data String Flag", pRelationship->getUseDataStringFlag());

  for (OdUInt32 i = 0; i < pRelationship->getRelationshipNodeCount(); i++)
  {
    OdDgECRelationshipInstanceNodePtr pCurNode = pRelationship->getRelationshipNode(i);

    OdString strRecordNum;
    OdString strRecordData;
    strRecordNum.format(L"Relationship Node %d :", i);
    strRecordNum = strPropPrefix + strRecordNum;
    writeFieldValue(strRecordNum, pCurNode);
  }
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgECClassPtr& pClass)
{
  if( !pClass.isNull() && pClass->isKindOf(OdDgECRelationshipClass::desc()) )
  {
    OdDgECRelationshipClassPtr pRelClass = pClass;
    dumpFieldName(L" ");
    writeFieldValue(name.left(name.getLength() - 3) + OdString(L"  Relationship Class : " + convertECSchemaItemNameToString(pRelClass->getName())), OdString(L" "));
    writeFieldValue(name + L"Name", convertECSchemaItemNameToString(pRelClass->getName()));
    writeFieldValue(name + L"DisplayName", pRelClass->getDisplayName());
    writeFieldValue(name + L"Description", pRelClass->getDescription());
    writeFieldValue(name + L"Type", pRelClass->getType());
    writeFieldValue(name + L"strength", pRelClass->getStrength());
    writeFieldValue(name + L"direction", pRelClass->getStrengthDirection());

    OdString strPrefix;

    for (OdInt32 l = 0; l < name.getLength(); l++)
      strPrefix += L" ";

    if (pClass->getBaseClassCount() > 0)
    {
      dumpFieldName(name + L"------ Parent classes ------------");

      for (OdUInt32 i = 0; i < pRelClass->getBaseClassCount(); i++)
      {
        OdDgECClassReference classRef = pRelClass->getBaseClass(i);
        OdString strClassName = convertECSchemaItemNameToString(classRef.getClassName());
        OdString strSchemaName = convertECSchemaItemNameToString(classRef.getSchemaName());
        OdString strSchemaPrefix = convertECSchemaItemNameToString(classRef.getSchemaPrefix());

        writeFieldValue(strPrefix + L" - " + strClassName,
          strSchemaName + L"." + classRef.getSchemaVersion() + L" ( " + strSchemaPrefix + L" )");
      }
    }

    if (pRelClass->getCustomAttributeCount() > 0)
    {
      dumpFieldName(name + L"----- Relationship Class Custom Attributes ------");

      for (OdUInt32 j = 0; j < pRelClass->getCustomAttributeCount(); j++)
        writeFieldValue(strPrefix + L" - ", pRelClass->getCustomAttribute(j));
    }

    if (pRelClass->getPropertyCount() > 0)
    {
      dumpFieldName(name + L"------ Properties ------------------------");

      for (OdUInt32 k = 0; k < pRelClass->getPropertyCount(); k++)
        writeFieldValue(strPrefix + L" - ", pRelClass->getProperty(k));
    }

    writeFieldValue(strPrefix + L" - ", pRelClass->getSource(), true);
    writeFieldValue(strPrefix + L" - ", pRelClass->getTarget(), false);
  }
  else   if (!pClass.isNull() && pClass->isKindOf(OdDgECClass::desc()))
  {
    dumpFieldName(L" ");
    writeFieldValue(name.left(name.getLength() - 3) + OdString(L"Class : " + convertECSchemaItemNameToString(pClass->getName())), OdString(L" "));
    writeFieldValue(name + L"Name", convertECSchemaItemNameToString(pClass->getName()));
    writeFieldValue(name + L"DisplayName", pClass->getDisplayName());
    writeFieldValue(name + L"Description", pClass->getDescription());
    writeFieldValue(name + L"Type", pClass->getType());

    OdString strPrefix;

    for (OdInt32 l = 0; l < name.getLength(); l++)
      strPrefix += L" ";

    if (pClass->getCustomAttributeCount() > 0)
    {
      dumpFieldName(name + L"----- Class Custom Attributes -------------");

      for (OdUInt32 j = 0; j < pClass->getCustomAttributeCount(); j++)
        writeFieldValue(strPrefix + L" - ", pClass->getCustomAttribute(j));
    }

    if (pClass->getPropertyCount() > 0)
    {
      dumpFieldName(name + L"------ Properties ------------------------");

      for (OdUInt32 k = 0; k < pClass->getPropertyCount(); k++)
        writeFieldValue(strPrefix + L" - ", pClass->getProperty(k));
    }
  }
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgECRelationshipInstanceNodePtr& pNode)
{
  OdString strValue;

  if( pNode->isKindOf(OdDgECRelationshipInstanceElementIdNode::desc()) )
  {
    OdDgECRelationshipInstanceElementIdNodePtr pIdNode = pNode;

    strValue.format(L"Id = 0x%X", pIdNode->getElementId());

    if( pIdNode->getUseHandlerNameFlag() )
    {
      strValue += L", HandlerName = \"" + pIdNode->getHandlerName() + "\"";

      if (pIdNode->getExtendedValue())
      {
        OdString strFormat;
        strFormat.format(L", ExtendedValue = %d", pIdNode->getExtendedValue());
        strValue += strFormat;
      }

      if (pIdNode->getUseDataStringFlag() && !pIdNode->getDataString().isEmpty())
        strValue += L", DataString = " + pIdNode->getDataString();
    }
    else
    {
      OdString strExt;
      strExt.format(L", ExtFlags = 0x%X, LocalIndex= %d", pIdNode->getLocalIndexExtValue(), pIdNode->getLocalIndexValue());
      strValue += strExt;

      if (pIdNode->getExtendedValue())
      {
        OdString strFormat;
        strFormat.format(L", ExtendedValue = %d", pIdNode->getExtendedValue());
        strValue += strFormat;
      }

      if (pIdNode->getUseDataStringFlag() && !pIdNode->getDataString().isEmpty() )
        strValue += L", DataString = " + pIdNode->getDataString();
    }
  }
  else if (pNode->isKindOf(OdDgECRelationshipInstanceElementIdExtNode::desc()))
  {
    OdDgECRelationshipInstanceElementIdExtNodePtr pIdNode = pNode;

    strValue.format(L"Index = %d, Id = 0x%X", pIdNode->getIndex(), pIdNode->getElementId());

    if (pIdNode->getUseHandlerNameFlag())
    {
      strValue += L", HandlerName = \"" + pIdNode->getHandlerName() + "\"";

      if (pIdNode->getExtendedValue())
      {
        OdString strFormat;
        strFormat.format(L", ExtendedValue = %d", pIdNode->getExtendedValue());
        strValue += strFormat;
      }

      if (pIdNode->getUseDataStringFlag() && !pIdNode->getDataString().isEmpty() )
        strValue += L", DataString = " + pIdNode->getDataString();
    }
    else
    {
      OdString strExt;
      strExt.format(L", ExtFlags = 0x%X, LocalIndex= %d", pIdNode->getLocalIndexExtValue(), pIdNode->getLocalIndexValue());
      strValue += strExt;

      if (pIdNode->getExtendedValue())
      {
        OdString strFormat;
        strFormat.format(L", ExtendedValue = %d", pIdNode->getExtendedValue());
        strValue += strFormat;
      }

      if (pIdNode->getUseDataStringFlag() && !pIdNode->getDataString().isEmpty() )
        strValue += L", DataString = " + pIdNode->getDataString();
    }
  }
  else if (pNode->isKindOf(OdDgECRelationshipInstanceFarElementIdNode::desc()))
  {
    OdDgECRelationshipInstanceFarElementIdNodePtr pIdNode = pNode;

    strValue.format(L"XRefId = 0x%X, Index = %d, Id = 0x%X", pIdNode->getXRefId(), pIdNode->getIndex(), pIdNode->getElementId());

    if (pIdNode->getUseHandlerNameFlag())
    {
      strValue += L", HandlerName = \"" + pIdNode->getHandlerName() + "\"";

      if (pIdNode->getExtendedValue())
      {
        OdString strFormat;
        strFormat.format(L", ExtendedValue = %d", pIdNode->getExtendedValue());
        strValue += strFormat;
      }

      if (pIdNode->getUseDataStringFlag() && !pIdNode->getDataString().isEmpty() )
        strValue += L", DataString = " + pIdNode->getDataString();
    }
    else
    {
      OdString strExt;
      strExt.format(L", ExtFlags = 0x%X, LocalIndex= %d", pIdNode->getLocalIndexExtValue(), pIdNode->getLocalIndexValue());
      strValue += strExt;

      if (pIdNode->getExtendedValue())
      {
        OdString strFormat;
        strFormat.format(L", ExtendedValue = %d", pIdNode->getExtendedValue());
        strValue += strFormat;
      }

      if (pIdNode->getUseDataStringFlag() && !pIdNode->getDataString().isEmpty())
        strValue += L", DataString = " + pIdNode->getDataString();
    }
  }
  else if (pNode->isKindOf(OdDgECRelationshipInstanceFarElementIdExtNode::desc()))
  {
    OdDgECRelationshipInstanceFarElementIdExtNodePtr pIdNode = pNode;

    strValue.format(L"XRefIndex = %d, XRefId = 0x%X, Index = %d, Id = 0x%X", pIdNode->getXRefIndex(), pIdNode->getXRefId(), pIdNode->getIndex(), pIdNode->getElementId());

    if (pIdNode->getUseHandlerNameFlag())
    {
      strValue += L", HandlerName = \"" + pIdNode->getHandlerName() + "\"";

      if (pIdNode->getExtendedValue())
      {
        OdString strFormat;
        strFormat.format(L", ExtendedValue = %d", pIdNode->getExtendedValue());
        strValue += strFormat;
      }

      if (pIdNode->getUseDataStringFlag() && !pIdNode->getDataString().isEmpty())
        strValue += L", DataString = " + pIdNode->getDataString();
    }
    else
    {
      OdString strExt;
      strExt.format(L", ExtFlags = 0x%X, LocalIndex= %d", pIdNode->getLocalIndexExtValue(), pIdNode->getLocalIndexValue());
      strValue += strExt;

      if (pIdNode->getExtendedValue())
      {
        OdString strFormat;
        strFormat.format(L", ExtendedValue = %d", pIdNode->getExtendedValue());
        strValue += strFormat;
      }

      if (pIdNode->getUseDataStringFlag() && !pIdNode->getDataString().isEmpty())
        strValue += L", DataString = " + pIdNode->getDataString();
    }
  }
  else
  {
    OdDgECRelationshipInstanceProxyNodePtr pProxyNode = pNode;
    strValue.format(L"NumItems = %d", pProxyNode->getSubNodeCount());
    OdBinaryData binData = pProxyNode->getProxyData();

    OdString strBinData;

    for(OdUInt32 j = 0; j < binData.size(); j++)
    {
      OdString strItem;

      if (j < binData.size() - 1)
        strItem.format(L"%02X,", binData[j]);
      else
        strItem.format(L"%02X", binData[j]);
        
      strBinData += strItem;
    }

    strValue += L",BinData = {" + strBinData + L"}";
  }

  writeFieldValue(name, strValue);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name,
                                      OdDgECProperty::OdDgECPropertyType uType,
                                        const OdDgECClassReference& typeRef)
{
  switch (uType)
  {
  case OdDgECProperty::kECClassReference:
  {
    OdString strClassName    = convertECSchemaItemNameToString(typeRef.getClassName());
    OdString strSchemaPrefix = convertECSchemaItemNameToString(typeRef.getSchemaPrefix());
    writeFieldValue(name, strSchemaPrefix + L":" + strClassName);
  }break;
  case OdDgECProperty::kString:
    writeFieldValue(name, OdString(L"kString")); break;
  case OdDgECProperty::kDouble:
    writeFieldValue(name, OdString(L"kDouble")); break;
  case OdDgECProperty::kInteger:
    writeFieldValue(name, OdString(L"kInteger")); break;
  case OdDgECProperty::kLong:
    writeFieldValue(name, OdString(L"kLong")); break;
  case OdDgECProperty::kBoolean:
    writeFieldValue(name, OdString(L"kBoolean")); break;
  case OdDgECProperty::kDateTime:
    writeFieldValue(name, OdString(L"kDateTime")); break;
  case OdDgECProperty::kPoint3d:
    writeFieldValue(name, OdString(L"kPoint3d")); break;
  case OdDgECProperty::kBinary:
    writeFieldValue(name, OdString(L"kBinary")); break;
  }
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgECPropertyPtr& pProperty)
{
  OdDgECClassReference typeRef;
  OdDgECProperty::OdDgECPropertyType uType = pProperty->getPropertyType(typeRef);
  writeFieldValue(name.left(name.getLength() - 3) + OdString(L"Property : " + convertECSchemaItemNameToString(pProperty->getName())), OdString(L" "));
  writeFieldValue(name + L"Name", convertECSchemaItemNameToString(pProperty->getName()));
  writeFieldValue(name + L"DisplayName", pProperty->getDisplayName());
  writeFieldValue(name + L"Description", pProperty->getDescription());
  writeFieldValue(name + L"Type", uType, typeRef);
  writeFieldValue(name + L"ReadOnly", pProperty->getReadOnlyFlag());
  writeFieldValue(name + L"IsArray", pProperty->isArrayProperty());
  writeFieldValue(name + L"IsStruct", pProperty->isArrayProperty());

  if( pProperty->isKindOf(OdDgECArrayProperty::desc()))
  {
    const OdDgECArrayPropertyPtr pArrayProperty = pProperty;
    writeFieldValue(name + L"MinOccurs", pArrayProperty->getMinOccurs());
    writeFieldValue(name + L"MaxOccurs", pArrayProperty->getMaxOccurs());
  }

  OdString strPrefix;

  for (OdInt32 l = 0; l < name.getLength(); l++)
    strPrefix += L" ";

  if (pProperty->getCustomAttributeCount() > 0)
  {
    dumpFieldName(name + L"+++++ Property Custom Attributes +++++++++++++");

    for (OdUInt32 j = 0; j < pProperty->getCustomAttributeCount(); j++)
      writeFieldValue(strPrefix + L" + ", pProperty->getCustomAttribute(j));
  }
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgECRelationshipPtr& pRelationship, bool bSource)
{
  if (pRelationship.isNull())
    return;

  dumpFieldName(L" ");

  if( bSource )
    writeFieldValue(name.left(name.getLength() - 3) + OdString(L"  Source Relationship: "), OdString(L" "));
  else
    writeFieldValue(name.left(name.getLength() - 3) + OdString(L"  Target Relationship: "), OdString(L" "));

  dumpFieldName(L" ");

  writeFieldValue(name + L"Role Label", pRelationship->getRoleLabel());
  writeFieldValue(name + L"Cardinality", pRelationship->getCardinality());
  writeFieldValue(name + L"Polymorphic", pRelationship->getPolymorphicFlag());

  OdString strPrefix;

  for (OdInt32 l = 0; l < name.getLength(); l++)
    strPrefix += L" ";

  if (pRelationship->getClassCount() > 0)
  {
    dumpFieldName(name + L"------ Classes ------------");

    for (OdUInt32 i = 0; i < pRelationship->getClassCount(); i++)
    {
      OdDgECClassReference classRef = pRelationship->getClass(i);

      OdString strClassName  = convertECSchemaItemNameToString(classRef.getClassName());
      OdString strSchemaName = convertECSchemaItemNameToString(classRef.getSchemaName());
      OdString strSchemaPrefix = convertECSchemaItemNameToString(classRef.getSchemaPrefix());

      writeFieldValue(strPrefix + L" - " + strClassName,
        strSchemaName + L"." + classRef.getSchemaVersion() + L" ( " + strSchemaPrefix + L" )");
    }
  }

  if( pRelationship->getCustomAttributeCount() > 0 )
  {
    dumpFieldName(name + L"----- Class Custom Attributes -------------");

    for (OdUInt32 j = 0; j < pRelationship->getCustomAttributeCount(); j++)
      writeFieldValue(strPrefix + L" - ", pRelationship->getCustomAttribute(j));
  }
}

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

OdString getAngleStr(double dAngle, const OdString& strPlus, const OdString& strMinus)
{
  OdUInt32 nDegree  = (OdUInt32)(fabs(dAngle) * 180 / OdaPI);
  OdUInt32 nMinutes = (OdUInt32)((fabs(dAngle) * 180 / OdaPI - nDegree)*60.0);
  double   dSeconds = ((fabs(dAngle) * 180 / OdaPI - nDegree)*60.0 - nMinutes) * 60;
  OdString strRet;
  strRet.format(L"%02d^%02d\'%6.4f\" ", nDegree, nMinutes, dSeconds);

  if (dAngle > 0)
    strRet += strPlus;
  else
    strRet += strMinus;

  return strRet;
}

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

OdString getSignedAngleStr(double dAngle)
{
  OdUInt32 nDegree = (OdUInt32)(fabs(dAngle) * 180 / OdaPI);
  OdUInt32 nMinutes = (OdUInt32)((fabs(dAngle) * 180 / OdaPI - nDegree)*60.0);
  double   dSeconds = ((fabs(dAngle) * 180 / OdaPI - nDegree)*60.0 - nMinutes) * 60;
  OdString strRet;
  strRet.format(L"%02d^%02d\'%6.4f\" ", nDegree, nMinutes, dSeconds);

  if (dAngle < 0)
    strRet = L"-" + strRet;

  return strRet;
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystemPtr& pNode)
{
  if (pNode.isNull())
    return;

  writeFieldValue(L" - Name", pNode->getName());
  writeFieldValue(L" - Description", pNode->getDescription());
  writeFieldValue(L" - Projection", pNode->getProjectionType());
  writeFieldValue(L" - Source", pNode->getSource());
  writeFieldValue(L" - Units", pNode->getUnits());

  switch( pNode->getProjectionType() )
  {
    case OdDgGeoDataCoordinateSystem::kGeographic:
    {
      OdDgGeographicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Min Useful Longitude", getAngleStr(pData->getMinUsefulLongitude(), L"E", L"W"));
      writeFieldValue(L" - Max Useful Longitude", getAngleStr(pData->getMaxUsefulLongitude(), L"E", L"W"));
    } break;

    case OdDgGeoDataCoordinateSystem::kTransverseMercator:
    {
      OdDgTransverseMercatorCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kAlbersEqualAreaConic:
    {
      OdDgAlbersEqualAreaConicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Second Standard Parallel", getAngleStr(pData->getSecondStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kMercator:
    {
      OdDgMercatorCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kLambertAzimuthalEquidistant:
    {
      OdDgLambertAzimuthalEquidistantCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Y-Axis Azimuth", getSignedAngleStr(pData->getYAxisAzimuth()));
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kLambertTangential:
    {
      OdDgLambertTangentialCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kPolyconic:
    {
      OdDgPolyconicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kPolyconicMod:
    {
      OdDgPolyconicModCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Eastern Meredian", getAngleStr(pData->getEasternMeredian(), L"E", L"W"));
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Second Standard Parallel", getAngleStr(pData->getSecondStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kAzimuthalEqualArea:
    {
      OdDgAzimuthalEqualAreaCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Y-Axis Azimuth", getSignedAngleStr(pData->getYAxisAzimuth()));
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kEquidistantConic:
    {
      OdDgEquidistantConicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Second Standard Parallel", getAngleStr(pData->getSecondStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kMiller:
    {
      OdDgMillerCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kStereographicMod:
    {
      OdDgStereographicModCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Coefficients", pData->getCoefficients());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kNewZealand:
    {
      OdDgNewZealandCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kSinusoidal:
    {
      OdDgSinusoidalCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Coefficients", pData->getCoefficients());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kOrthographic:
    {
      OdDgOrthographicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kGnomonic:
    {
      OdDgGnomonicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kEquidistantCylindrical:
    {
      OdDgEquidistantCylindricalCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - Reference Parallel", getAngleStr(pData->getReferenceParallel(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kVanDerGrinten:
    {
      OdDgVanDerGrintenCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kCassini:
    {
      OdDgCassiniCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kRobinson:
    {
      OdDgRobinsonCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kBonne:
    {
      OdDgBonneCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kEckert4:
    {
      OdDgEckert4CoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kEckert6:
    {
      OdDgEckert6CoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kMollweide:
    {
      OdDgMollweideCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Coefficients", pData->getCoefficients());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kGoodeHomolosine:
    {
      OdDgGoodeHomolosineCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Coefficients", pData->getCoefficients());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kEqualAreaCylindricalNA:
    {
      OdDgEqualAreaCylindricalNACoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kEqualAreaCylindricalTA:
    {
      OdDgEqualAreaCylindricalTACoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kBipolarObliqueConformalConic:
    {
      OdDgBipolarObliqueConformalConicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Pole Longitude", getAngleStr(pData->getFirstPoleLongitude(), L"E", L"W"));
      writeFieldValue(L" - Second Pole Longitude", getAngleStr(pData->getSecondPoleLongitude(), L"E", L"W"));
      writeFieldValue(L" - First Pole Latitude", getAngleStr(pData->getFirstPoleLatitude(), L"N", L"S"));
      writeFieldValue(L" - Second Pole Latitude", getAngleStr(pData->getSecondPoleLatitude(), L"N", L"S"));
      writeFieldValue(L" - Distance Between Poles", pData->getDistanceBetweenPoles());
      writeFieldValue(L" - Angular Distance To First Std Parallel", pData->getAngularDistanceToFirstStdParallel());
      writeFieldValue(L" - Angular Distance To Second Std Parallel", pData->getAngularDistanceToSecondStdParallel());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kSwissObliqueCylindrical:
    {
      OdDgSwissObliqueCylindricalCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kPolarStereographic:
    {
      OdDgPolarStereographicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kObliqueStereographic:
    {
      OdDgObliqueStereographicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kSnyderObliqueStereographic:
    {
      OdDgSnyderObliqueStereographicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - Y-Axis Azimuth", getSignedAngleStr(pData->getYAxisAzimuth()));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kLambertConformalConic1StdLat:
    {
      OdDgLambertConformalConic1StdLatCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kLambertConformalConic:
    {
      OdDgLambertConformalConicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Second Standard Parallel", getAngleStr(pData->getSecondStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kLambertConformalConicMichigan:
    {
      OdDgLambertConformalConicMichiganCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Second Standard Parallel", getAngleStr(pData->getSecondStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kLambertConformalConicBelgian:
    {
      OdDgLambertConformalConicBelgianCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Second Standard Parallel", getAngleStr(pData->getSecondStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kLambertConformalConicWCCS:
    {
      OdDgLambertConformalConicWCCSCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Second Standard Parallel", getAngleStr(pData->getSecondStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - Average Separation", pData->getAverageSeparation());
      writeFieldValue(L" - Average Elevation", pData->getAverageElevation());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kTransverseMercatorWCCS:
    {
      OdDgTransverseMercatorWCCSCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - Average Separation", pData->getAverageSeparation());
      writeFieldValue(L" - Average Elevation", pData->getAverageElevation());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kLambertConformalConicM:
    {
      OdDgLambertConformalConicMCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Second Standard Parallel", getAngleStr(pData->getSecondStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - Average Height", pData->getAverageHeight());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kTransverseMercatorM:
    {
      OdDgTransverseMercatorMCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - Average Height", pData->getAverageHeight());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kTransverseMercatorRSA:
    {
      OdDgTransverseMercatorRSACoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kUniversalTransverseMercator:
    {
      OdDgUniversalTransverseMercatorCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - UTM Zone", pData->getUTMZone());
      writeFieldValue(L" - Hemisphere", pData->getHemisphere());
    } break;

    case OdDgGeoDataCoordinateSystem::kTransverseMercatorSnyder:
    {
      OdDgTransverseMercatorSnyderCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kGaussKruger:
    {
      OdDgGaussKrugerCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kKrovak:
    {
      OdDgKrovakCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Pole Longitude", getAngleStr(pData->getPoleLongitude(), L"E", L"W"));
      writeFieldValue(L" - Pole Latitude", getAngleStr(pData->getPoleLatitude(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kMercatorSR:
    {
      OdDgMercatorSRCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kObliqueConformalConic:
    {
      OdDgObliqueConformalConicCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Pole Longitude", getAngleStr(pData->getPoleLongitude(), L"E", L"W"));
      writeFieldValue(L" - Pole Latitude", getAngleStr(pData->getPoleLatitude(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kKrovak95:
    {
      OdDgKrovak95CoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Pole Longitude", getAngleStr(pData->getPoleLongitude(), L"E", L"W"));
      writeFieldValue(L" - Pole Latitude", getAngleStr(pData->getPoleLatitude(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kPolarStereographicSL:
    {
      OdDgPolarStereographicSLCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Standard Circle Latitude", getAngleStr(pData->getStandardCircleLatitude(), L"N", L"S"));
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kTransverseMercatorAffine:
    {
      OdDgTransverseMercatorAffineCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - A0 Coefficient", pData->getA0Coefficient());
      writeFieldValue(L" - B0 Coefficient", pData->getB0Coefficient());
      writeFieldValue(L" - A1 Coefficient", pData->getA1Coefficient());
      writeFieldValue(L" - A2 Coefficient", pData->getA2Coefficient());
      writeFieldValue(L" - B1 Coefficient", pData->getB1Coefficient());
      writeFieldValue(L" - B2 Coefficient", pData->getB2Coefficient());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kNonEarth:
    {
      OdDgNonEarthCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kObliqueCylindrical:
    {
      OdDgObliqueCylindricalCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - Gaussian Parallel Point Latitude", getAngleStr(pData->getGaussianParallelPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kDanishSystemKMS2001:
    {
      OdDgDanishSystemKMS2001CoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Region Number", pData->getRegionNumber());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kTransverseMercatorOSTN02:
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorOSTN97:
    {
    } break;

    case OdDgGeoDataCoordinateSystem::kAzimuthalEquidistant:
    {
      OdDgAzimuthalEquidistantCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Y-Axis Azimuth", getSignedAngleStr(pData->getYAxisAzimuth()));
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kDanishSystemNoKMS:
    {
      OdDgDanishSystemNoKMSCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Region Number", pData->getRegionNumber());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kTransverseMercatorKF:
    {
      OdDgTransverseMercatorKFCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kWinkelTripel:
    {
      OdDgWinkelTripelCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Reference Parallel", getAngleStr(pData->getReferenceParallel(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kNerthSR:
    {
      OdDgNerthSRCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Rotation", pData->getRotation() * 180 / OdaPI);
      writeFieldValue(L" - Scale", pData->getScale());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kLambertConformalConicAffine:
    {
      OdDgLambertConformalConicAffineCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - First Standard Parallel", getAngleStr(pData->getFirstStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Second Standard Parallel", getAngleStr(pData->getSecondStandardParallel(), L"N", L"S"));
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - A0 Coefficient", pData->getA0Coefficient());
      writeFieldValue(L" - B0 Coefficient", pData->getB0Coefficient());
      writeFieldValue(L" - A1 Coefficient", pData->getA1Coefficient());
      writeFieldValue(L" - A2 Coefficient", pData->getA2Coefficient());
      writeFieldValue(L" - B1 Coefficient", pData->getB1Coefficient());
      writeFieldValue(L" - B2 Coefficient", pData->getB2Coefficient());
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kDanishSystemKMS1999:
    {
      OdDgDanishSystemKMS1999CoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Region Number", pData->getRegionNumber());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kEquidistantCylindricalE:
    {
      OdDgEquidistantCylindricalECoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - Reference Parallel", getAngleStr(pData->getReferenceParallel(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kPlateCarree:
    {
      OdDgPlateCarreeCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Longitude", getAngleStr(pData->getOriginLongitude(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - Reference Parallel", getAngleStr(pData->getReferenceParallel(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kPseudoMercator:
    {
      OdDgPseudoMercatorCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kUniversalTransverseMercatorBF:
    {
      OdDgUniversalTransverseMercatorBFCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - UTM Zone", pData->getUTMZone());
      writeFieldValue(L" - Hemisphere", pData->getHemisphere());
    } break;

    case OdDgGeoDataCoordinateSystem::kTransverseMercatorBF:
    {
      OdDgTransverseMercatorBFCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Meredian", getAngleStr(pData->getCentralMeredian(), L"E", L"W"));
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kObliqueMercator1PtUV:
    {
      OdDgObliqueMercator1PtUVCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Point Longitude", getAngleStr(pData->getCentralPointLongitude(), L"E", L"W"));
      writeFieldValue(L" - Central Point Latitude", getAngleStr(pData->getCentralPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Azimuth", getSignedAngleStr(pData->getAzimuth()));
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kObliqueMercator1PtXY:
    {
      OdDgObliqueMercator1PtXYCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Point Longitude", getAngleStr(pData->getCentralPointLongitude(), L"E", L"W"));
      writeFieldValue(L" - Central Point Latitude", getAngleStr(pData->getCentralPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Azimuth", getSignedAngleStr(pData->getAzimuth()));
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kObliqueMercator2PtUV:
    {
      OdDgObliqueMercator2PtUVCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - First Point Longitude", getAngleStr(pData->getFirstPointLongitude(), L"E", L"W"));
      writeFieldValue(L" - First Point Latitude", getAngleStr(pData->getFirstPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - Second Point Longitude", getAngleStr(pData->getSecondPointLongitude(), L"E", L"W"));
      writeFieldValue(L" - Second Point Latitude", getAngleStr(pData->getSecondPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kObliqueMercator2PtXY:
    {
      OdDgObliqueMercator2PtXYCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Origin Latitude", getAngleStr(pData->getOriginLatitude(), L"N", L"S"));
      writeFieldValue(L" - First Point Longitude", getAngleStr(pData->getFirstPointLongitude(), L"E", L"W"));
      writeFieldValue(L" - First Point Latitude", getAngleStr(pData->getFirstPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - Second Point Longitude", getAngleStr(pData->getSecondPointLongitude(), L"E", L"W"));
      writeFieldValue(L" - Second Point Latitude", getAngleStr(pData->getSecondPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kRectifiedSkewOrthoAO:
    {
      OdDgRectifiedSkewOrthoAOCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Point Longitude", getAngleStr(pData->getCentralPointLongitude(), L"E", L"W"));
      writeFieldValue(L" - Central Point Latitude", getAngleStr(pData->getCentralPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Azimuth", getSignedAngleStr(pData->getAzimuth()));
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kRectifiedSkewOrthoC:
    {
      OdDgRectifiedSkewOrthoCCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Point Longitude", getAngleStr(pData->getCentralPointLongitude(), L"E", L"W"));
      writeFieldValue(L" - Central Point Latitude", getAngleStr(pData->getCentralPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Azimuth", getSignedAngleStr(pData->getAzimuth()));
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;

    case OdDgGeoDataCoordinateSystem::kRectifiedSkewOrthoIsect:
    {
      OdDgRectifiedSkewOrthoIsectCoordinateSystemPtr pData = pNode;
      writeFieldValue(L" - Central Point Longitude", getAngleStr(pData->getCentralPointLongitude(), L"E", L"W"));
      writeFieldValue(L" - Central Point Latitude", getAngleStr(pData->getCentralPointLatitude(), L"N", L"S"));
      writeFieldValue(L" - False Easting", pData->getFalseEasting());
      writeFieldValue(L" - False Northing", pData->getFalseNorthing());
      writeFieldValue(L" - Azimuth", getSignedAngleStr(pData->getAzimuth()));
      writeFieldValue(L" - Scale Reduction", pData->getScaleReduction());
      writeFieldValue(L" - Quadrant", pData->getQuadrant());
    } break;
  }

  OdGeExtents2d extData = pNode->getGeodeticExtents();

  writeFieldValue(L" - Minimum Longitude", getAngleStr(extData.minPoint().x,L"E", L"W"));
  writeFieldValue(L" - Maximum Longitude", getAngleStr(extData.maxPoint().x, L"E", L"W"));
  writeFieldValue(L" - Minimum Latitude", getAngleStr(extData.minPoint().y, L"N", L"S"));
  writeFieldValue(L" - Maximum Latitude", getAngleStr(extData.maxPoint().y, L"N", L"S"));
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataInfo::OdDgGeoDataVerticalDataType& uType)
{
  OdString strRet = OdString::kEmpty;

  switch (uType)
  {
    case OdDgGeoDataInfo::kMatchDatum:                          strRet = L"kMatchDatum";  break;
    case OdDgGeoDataInfo::kGeoid:                               strRet = L"kGeoid";  break;
    default:                                                    strRet.format(L"%d", uType);  break;
  }

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataInfo::OdDgGeoDataLocalTransformType& uType)
{
  OdString strRet = OdString::kEmpty;

  switch (uType)
  {
    case OdDgGeoDataInfo::kNoTransform:                          strRet = L"kNoTransform";  break;
    case OdDgGeoDataInfo::kHelmertTransform:                     strRet = L"kHelmertTransform";  break;
    default:                                                     strRet.format(L"%d", uType);  break;
  }

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataDatum& uDatum)
{
  dumpFieldName("Datum:");
  writeFieldValue(" - Name", uDatum.getName());
  writeFieldValue(" - Description", uDatum.getDescription());
  writeFieldValue(" - Source", uDatum.getSource());
  writeFieldValue(" - Conversion Method", uDatum.getDatumConversionMethod());
  writeFieldValue(" - Offset", uDatum.getOffset());
  writeFieldValue(" - X-Rotation", uDatum.getXRotation());
  writeFieldValue(" - Y-Rotation", uDatum.getYRotation());
  writeFieldValue(" - Z-Rotation", uDatum.getZRotation());
  writeFieldValue(" - Scale", uDatum.getScale());
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataEllipsoid& uEllipsoid)
{
  dumpFieldName("Ellipsoid:");
  writeFieldValue(" - Name", uEllipsoid.getName());
  writeFieldValue(" - Description", uEllipsoid.getDescription());
  writeFieldValue(" - Source", uEllipsoid.getSource());
  writeFieldValue(" - Polar Radius", uEllipsoid.getPolarRadius());
  writeFieldValue(" - Equatorial Radius", uEllipsoid.getEquatorialRadius());
  writeFieldValue(" - Eccentricity", uEllipsoid.getEccentricity());
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystemParam& uParam)
{
  OdString strName;
  OdString strValue;

  switch( uParam.getType() )
  {
    case OdDgGeoDataCoordinateSystemParam::kParamNotUsed                : strName = L"  - kParamNotUsed";             strValue = OdString::kEmpty; break;
    case OdDgGeoDataCoordinateSystemParam::kParamCentralMeredian        : strName = L"  - kParamCentralMeredian";     strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamNorthernStdParallel    : strName = L"  - kParamNorthernStdParallel"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamSouthernStdParallel    : strName = L"  - kParamSouthernStdParallel"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamStandardParallel       : strName = L"  - kParamStandardParallel"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamFirstPointLongitude    : strName = L"  - kParamFirstPointLongitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamFirstPointLatitude     : strName = L"  - kParamFirstPointLatitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamSecondPointLongitude   : strName = L"  - kParamSecondPointLongitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamSecondPointLatitude    : strName = L"  - kParamSecondPointLatitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamPointLongitude         : strName = L"  - kParamPointLongitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamPointLatitude          : strName = L"  - kParamPointLatitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamAzimuth                : strName = L"  - kParamAzimuth"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamYAxisAzimuth           : strName = L"  - kParamYAxisAzimuth"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamEasternStandardMeridian: strName = L"  - kParamEasternStandardMeridian"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamNorthernParallel       : strName = L"  - kParamNorthernParallel"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamSouthernParallel       : strName = L"  - kParamSouthernParallel"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamFirstPoleLongitude     : strName = L"  - kParamFirstPoleLongitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamFirstPoleLatitude      : strName = L"  - kParamFirstPoleLatitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamSecondPoleLongitude    : strName = L"  - kParamSecondPoleLongitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamSecondPoleLatitude     : strName = L"  - kParamSecondPoleLatitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamDistanceBetweenPoles   : strName = L"  - kParamDistanceBetweenPoles"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamDistanceToFirstStdParallel   : strName = L"  - kParamDistanceToFirstStdParallel"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamDistanceToSecondStdParallel  : strName = L"  - kParamDistanceToSecondStdParallel"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamCplxParamA : 
    {
      strName = L"  - kParamCplxParamA";

      OdString strPart;

      strValue = L"{";

      for( OdUInt32 i = 0; i < 24; i++ )
      {
        strPart.format(L"%f,");
        strValue += strPart;
      }

      strValue = strValue.left(strValue.getLength() - 1);
      strValue += L"}";
    } break;
    case OdDgGeoDataCoordinateSystemParam::kParamCplxParamB:
    {
      strName = L"  - kParamCplxParamB";

      OdString strPart;

      strValue = L"{";

      for (OdUInt32 i = 0; i < 24; i++)
      {
        strPart.format(L"%f,");
        strValue += strPart;
      }

      strValue = strValue.left(strValue.getLength() - 1);
      strValue += L"}";
    } break;
    case OdDgGeoDataCoordinateSystemParam::kParamWesternEndOfLongitudeRange: strName = L"  - kParamWesternEndOfLongitudeRange"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamEasternEndOfLongitudeRange: strName = L"  - kParamEasternEndOfLongitudeRange"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamUTMZoneNumber: strName = L"  - kParamUTMZoneNumber"; strValue.format(L"%d", uParam.getIntegerValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamNorthSouthHemisphere: strName = L"  - kParamNorthSouthHemisphere"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamAverageGeoidHeight: strName = L"  - kParamAverageGeoidHeight"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamAverageElevation: strName = L"  - kParamAverageElevation"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamObliquePoleLongitude: strName = L"  - kParamObliquePoleLongitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamObliquePoleLatitude: strName = L"  - kParamObliquePoleLatitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamObliqueConeStandardParallel: strName = L"  - kParamObliqueConeStandardParallel"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamStandardCircleLatitude: strName = L"  - kParamStandardCircleLatitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamAffineTransformA0: strName = L"  - kParamAffineTransformA0"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamAffineTransformB0: strName = L"  - kParamAffineTransformB0"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamAffineTransformA1: strName = L"  - kParamAffineTransformA1"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamAffineTransformA2: strName = L"  - kParamAffineTransformA2"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamAffineTransformB1: strName = L"  - kParamAffineTransformB1"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamAffineTransformB2: strName = L"  - kParamAffineTransformB2"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamNormalParallel: strName = L"  - kParamNormalParallel"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamDanishSystem24Region: strName = L"  - kParamDanishSystem24Region"; strValue.format(L"%d", uParam.getIntegerValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamRectifiedSkewOrthomorphic: strName = L"  - kParamRectifiedSkewOrthomorphic"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamXCoordOrigin: strName = L"  - kParamXCoordOrigin"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamYCoordOrigin: strName = L"  - kParamYCoordOrigin"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamScaleFactor: strName = L"  - kParamScaleFactor"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamRotationAngle: strName = L"  - kParamRotationAngle"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamEllipsoidScale: strName = L"  - kParamEllipsoidScale"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamFalseEasting: strName = L"  - kParamFalseEasting"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamFalseNorthing: strName = L"  - kParamFalseNorthing"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamOriginLongitude: strName = L"  - kParamOriginLongitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamOriginLatitude: strName = L"  - kParamOriginLatitude"; strValue.format(L"%f", uParam.getDoubleValue()); break;
    case OdDgGeoDataCoordinateSystemParam::kParamScaleReduction: strName = L"  - kParamScaleReduction"; strValue.format(L"%f", uParam.getDoubleValue()); break;
  }

  writeFieldValue(strName, strValue);
}

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


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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystem::OdDgGeoDataCoordSystemUnitType& uType)
{
  OdString strRet = OdString::kEmpty;

  switch (uType)
  {
    case OdDgGeoDataCoordinateSystem::kUnitUnknown: strRet = "kUnitUnknown"; break;
    case OdDgGeoDataCoordinateSystem::kUnitMeter: strRet = "kUnitMeter"; break;
    case OdDgGeoDataCoordinateSystem::kUnitFoot: strRet = "kUnitFoot"; break;
    case OdDgGeoDataCoordinateSystem::kUnitInch: strRet = "kUnitInch"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIFoot: strRet = "kUnitIFoot"; break;
    case OdDgGeoDataCoordinateSystem::kUnitClarkeFoot: strRet = "kUnitClarkeFoot"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIInch: strRet = "kUnitIInch"; break;
    case OdDgGeoDataCoordinateSystem::kUnitCentimeter: strRet = "kUnitCentimeter"; break;
    case OdDgGeoDataCoordinateSystem::kUnitKilometer: strRet = "kUnitKilometer"; break;
    case OdDgGeoDataCoordinateSystem::kUnitYard: strRet = "kUnitYard"; break;
    case OdDgGeoDataCoordinateSystem::kUnitSearsYard: strRet = "kUnitSearsYard"; break;
    case OdDgGeoDataCoordinateSystem::kUnitMile: strRet = "kUnitMile"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIYard: strRet = "kUnitIYard"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIMile: strRet = "kUnitIMile"; break;
    case OdDgGeoDataCoordinateSystem::kUnitKnot: strRet = "kUnitKnot"; break;
    case OdDgGeoDataCoordinateSystem::kUnitNautM: strRet = "kUnitNautM"; break;
    case OdDgGeoDataCoordinateSystem::kUnitLat66: strRet = "kUnitLat66"; break;
    case OdDgGeoDataCoordinateSystem::kUnitLat83: strRet = "kUnitLat83"; break;
    case OdDgGeoDataCoordinateSystem::kUnitDecimeter: strRet = "kUnitDecimeter"; break;
    case OdDgGeoDataCoordinateSystem::kUnitMillimeter: strRet = "kUnitMillimeter"; break;
    case OdDgGeoDataCoordinateSystem::kUnitDekameter: strRet = "kUnitDekameter"; break;
    case OdDgGeoDataCoordinateSystem::kUnitHectometer: strRet = "kUnitHectometer"; break;
    case OdDgGeoDataCoordinateSystem::kUnitGermanMeter: strRet = "kUnitGermanMeter"; break;
    case OdDgGeoDataCoordinateSystem::kUnitCaGrid: strRet = "kUnitCaGrid"; break;
    case OdDgGeoDataCoordinateSystem::kUnitClarkeChain: strRet = "kUnitClarkeChain"; break;
    case OdDgGeoDataCoordinateSystem::kUnitGunterChain: strRet = "kUnitGunterChain"; break;
    case OdDgGeoDataCoordinateSystem::kUnitBenoitChain: strRet = "kUnitBenoitChain"; break;
    case OdDgGeoDataCoordinateSystem::kUnitSearsChain: strRet = "kUnitSearsChain"; break;
    case OdDgGeoDataCoordinateSystem::kUnitClarkeLink: strRet = "kUnitClarkeLink"; break;
    case OdDgGeoDataCoordinateSystem::kUnitGunterLink: strRet = "kUnitGunterLink"; break;
    case OdDgGeoDataCoordinateSystem::kUnitBenoitLink: strRet = "kUnitBenoitLink"; break;
    case OdDgGeoDataCoordinateSystem::kUnitSearsLink: strRet = "kUnitSearsLink"; break;
    case OdDgGeoDataCoordinateSystem::kUnitRod: strRet = "kUnitRod"; break;
    case OdDgGeoDataCoordinateSystem::kUnitPerch: strRet = "kUnitPerch"; break;
    case OdDgGeoDataCoordinateSystem::kUnitPole: strRet = "kUnitPole"; break;
    case OdDgGeoDataCoordinateSystem::kUnitFurlong: strRet = "kUnitFurlong"; break;
    case OdDgGeoDataCoordinateSystem::kUnitRood: strRet = "kUnitRood"; break;
    case OdDgGeoDataCoordinateSystem::kUnitCapeFoot: strRet = "kUnitCapeFoot"; break;
    case OdDgGeoDataCoordinateSystem::kUnitBrealey: strRet = "kUnitBrealey"; break;
    case OdDgGeoDataCoordinateSystem::kUnitSearsFoot: strRet = "kUnitSearsFoot"; break;
    case OdDgGeoDataCoordinateSystem::kUnitGoldCoastFoot: strRet = "kUnitGoldCoastFoot"; break;
    case OdDgGeoDataCoordinateSystem::kUnitMicroInch: strRet = "kUnitMicroInch"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIndianYard: strRet = "kUnitIndianYard"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIndianFoot: strRet = "kUnitIndianFoot"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIndianFt37: strRet = "kUnitIndianFt37"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIndianFt62: strRet = "kUnitIndianFt62"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIndianFt75: strRet = "kUnitIndianFt75"; break;
    case OdDgGeoDataCoordinateSystem::kUnitIndianYd37: strRet = "kUnitIndianYd37"; break;
    case OdDgGeoDataCoordinateSystem::kUnitDecameter: strRet = "kUnitDecameter"; break;
    case OdDgGeoDataCoordinateSystem::kUnitInternationalChain: strRet = "kUnitInternationalChain"; break;
    case OdDgGeoDataCoordinateSystem::kUnitInternationalLink: strRet = "kUnitInternationalLink"; break;
    case OdDgGeoDataCoordinateSystem::kUnitBrFootTrunc: strRet = "kUnitBrFootTrunc"; break;
    case OdDgGeoDataCoordinateSystem::kUnitBrChainTrunc: strRet = "kUnitBrChainTrunc"; break;
    case OdDgGeoDataCoordinateSystem::kUnitBrLinkTrunc: strRet = "kUnitBrLinkTrunc"; break;
    case OdDgGeoDataCoordinateSystem::kUnitDegree: strRet = "kUnitDegree"; break;
    case OdDgGeoDataCoordinateSystem::kUnitGrad: strRet = "kUnitGrad"; break;
    case OdDgGeoDataCoordinateSystem::kUnitGrade: strRet = "kUnitGrade"; break;
    case OdDgGeoDataCoordinateSystem::kUnitMapInfo: strRet = "kUnitMapInfo"; break;
    case OdDgGeoDataCoordinateSystem::kUnitMil: strRet = "kUnitMil"; break;
    case OdDgGeoDataCoordinateSystem::kUnitMinute: strRet = "kUnitMinute"; break;
    case OdDgGeoDataCoordinateSystem::kUnitRadian: strRet = "kUnitRadian"; break;
    case OdDgGeoDataCoordinateSystem::kUnitSecond: strRet = "kUnitSecond"; break;
    case OdDgGeoDataCoordinateSystem::kUnitDecisec: strRet = "kUnitDecisec"; break;
    case OdDgGeoDataCoordinateSystem::kUnitCentisec: strRet = "kUnitCentisec"; break;
    case OdDgGeoDataCoordinateSystem::kUnitMillisec: strRet = "kUnitMillisec"; break;
  }

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystemParam::OdDgGeoDataCoordSystemQuadrantValue& uType)
{
  OdString strRet = OdString::kEmpty;

  switch (uType)
  {
    case OdDgGeoDataCoordinateSystemParam::kPositiveXYInv:                         strRet = L"kPositiveXYInv";  break;
    case OdDgGeoDataCoordinateSystemParam::kNegativeXPositiveYInv:                 strRet = L"kNegativeXPositiveYInv";  break;
    case OdDgGeoDataCoordinateSystemParam::kNegativeXYInv:                         strRet = L"kNegativeXYInv";  break;
    case OdDgGeoDataCoordinateSystemParam::kPositiveXNegativeYInv:                 strRet = L"kPositiveXNegativeYInv";  break;
    case OdDgGeoDataCoordinateSystemParam::kPositiveXY:                            strRet = L"kPositiveXY";  break;
    case OdDgGeoDataCoordinateSystemParam::kNegativeXPositiveY:                    strRet = L"kNegativeXPositiveY";  break;
    case OdDgGeoDataCoordinateSystemParam::kNegativeXY:                            strRet = L"kNegativeXY";  break;
    case OdDgGeoDataCoordinateSystemParam::kPositiveXNegativeY:                    strRet = L"kPositiveXNegativeY";  break;
    default:                                                                       strRet.format(L"%d", uType);  break;
  }

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystemParam::OdDgGeoDataCoordSystemHemisphereValue& uType)
{
  OdString strRet = OdString::kEmpty;

  switch (uType)
  {
    case OdDgGeoDataCoordinateSystemParam::kSouthen: strRet = L"kSouthen";  break;
    default:                                         strRet = L"kNorthen";  break;
  }
  
  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataDatum::OdDgGeoDataConversionMethod& uType)
{
  OdString strRet = OdString::kEmpty;

  switch (uType)
  {
    case OdDgGeoDataDatum::kMolodensky:         strRet = L"Dma Molodensky Transformation";  break;
    case OdDgGeoDataDatum::kMultipleRegression: strRet = L"Dma Multiple Regression";  break;
    case OdDgGeoDataDatum::kBursaWolf:          strRet = L"Bursa/Wolf Transformation";  break;
    case OdDgGeoDataDatum::kNAD27:              strRet = L"NAD27<->NAD83 via NADCON/Nt.v2";  break;
    case OdDgGeoDataDatum::kNAD83:              strRet = L"NAD83 noShiftRequered";  break;
    case OdDgGeoDataDatum::kWGS84:              strRet = L"WGS84";  break;
    case OdDgGeoDataDatum::kWGS72:              strRet = L"WGS72";  break;
    case OdDgGeoDataDatum::kHARN:               strRet = L"HARN<->NAD83 via NADCON";  break;
    case OdDgGeoDataDatum::k7Params:            strRet = L"Seven Params Transform";  break;
    case OdDgGeoDataDatum::kAGD66:              strRet = L"AGD66";  break;
    case OdDgGeoDataDatum::k3Params:            strRet = L"Three ParamsTransform ";  break;
    case OdDgGeoDataDatum::k4Params:            strRet = L"Four ParamsTransform ";  break;
    case OdDgGeoDataDatum::k6Params:            strRet = L"Six ParamsTransform ";  break;
    case OdDgGeoDataDatum::kAGD84:              strRet = L"AGD84";  break;
    case OdDgGeoDataDatum::kNZGD4:              strRet = L"XX-NZGD4-XX";  break;
    case OdDgGeoDataDatum::kATS77:              strRet = L"ATS77";  break;
    case OdDgGeoDataDatum::kGDA94:              strRet = L"GDA94 noShiftRequered";  break;
    case OdDgGeoDataDatum::kNZGD2k:             strRet = L"XX-NZGD2000-XX";  break;
    case OdDgGeoDataDatum::kCSRS:               strRet = L"CSRS<->NAD83 via Grid File";  break;
    case OdDgGeoDataDatum::kTOKYO:              strRet = L"TOKYO<->JGD2000 via Grid File";  break;
    case OdDgGeoDataDatum::kRGF93:              strRet = L"NTF<->RGF93 via Grid File";  break;
    case OdDgGeoDataDatum::kED50:               strRet = L"ED50<->ETRF89 via Grid File";  break;
    case OdDgGeoDataDatum::kDHDN:               strRet = L"DHDN<->ETRF89 via Grid File";  break;
    case OdDgGeoDataDatum::kETRF89:             strRet = L"ETRF89";  break;
    case OdDgGeoDataDatum::kGeocentric:         strRet = L"Geocentric Transform";  break;
    case OdDgGeoDataDatum::kCHENxy:             strRet = L"CH1903<->WG84 via CHENxy.gsb";  break;
    case OdDgGeoDataDatum::kPLYNM:              strRet = L"Grid Shift Files";  break;
    case OdDgGeoDataDatum::kNone:               strRet = L"None";  break;
    default:                                    strRet.format(L"%d", uType);  break;
  }

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgGeoDataCoordinateSystem::OdDgGeoDataCoordSystemProjectionType& uType)
{
  OdString strRet = OdString::kEmpty;

  switch (uType)
  {
    case OdDgGeoDataCoordinateSystem::kUndefined: strRet = L"No projection type."; break;
    case OdDgGeoDataCoordinateSystem::kGeographic: strRet = L"Geographic (Latitude/Longitude)."; break;
    case OdDgGeoDataCoordinateSystem::kTransverseMercator: strRet = L"Transverse Mercator."; break;
    case OdDgGeoDataCoordinateSystem::kAlbersEqualAreaConic: strRet = L"Albers' Equal Area Conic."; break;                      
    case OdDgGeoDataCoordinateSystem::kMercator: strRet = L"Mercator."; break;
    case OdDgGeoDataCoordinateSystem::kLambertAzimuthalEquidistant: strRet = L"Lambert Azimuthal Equidistant."; break;
    case OdDgGeoDataCoordinateSystem::kLambertTangential: strRet = L"Lambert Tangential."; break;
    case OdDgGeoDataCoordinateSystem::kPolyconic: strRet = L"Polyconic."; break;
    case OdDgGeoDataCoordinateSystem::kPolyconicMod: strRet = L"Lallemand IMW Modified Polyconic."; break;
    case OdDgGeoDataCoordinateSystem::kAzimuthalEqualArea: strRet = L"Azimuthal Equal Area."; break;      
    case OdDgGeoDataCoordinateSystem::kEquidistantConic: strRet = L"Equidistant Conic."; break;
    case OdDgGeoDataCoordinateSystem::kMiller: strRet = L"Miller."; break;
    case OdDgGeoDataCoordinateSystem::kStereographicMod: strRet = L"Modified Stereographic."; break;
    case OdDgGeoDataCoordinateSystem::kNewZealand: strRet = L"New Zealand."; break;
    case OdDgGeoDataCoordinateSystem::kSinusoidal: strRet = L"Sinusoidal."; break;
    case OdDgGeoDataCoordinateSystem::kOrthographic: strRet = L"Orthographic projection."; break;                   
    case OdDgGeoDataCoordinateSystem::kGnomonic: strRet = L"Gnomonic."; break;                                  
    case OdDgGeoDataCoordinateSystem::kEquidistantCylindrical: strRet = L"Equidistant Cylindrical. (Spherical only)."; break;
    case OdDgGeoDataCoordinateSystem::kVanDerGrinten: strRet = L"Van Der Grinten."; break;
    case OdDgGeoDataCoordinateSystem::kCassini: strRet = L"Cassini."; break;      
    case OdDgGeoDataCoordinateSystem::kRobinson: strRet = L"Robinson."; break;      
    case OdDgGeoDataCoordinateSystem::kBonne: strRet = L"Bonne."; break;
    case OdDgGeoDataCoordinateSystem::kEckert4: strRet = L"Eckert 4."; break;
    case OdDgGeoDataCoordinateSystem::kEckert6: strRet = L"Eckert 6."; break;
    case OdDgGeoDataCoordinateSystem::kMollweide: strRet = L"Mollweide."; break;
    case OdDgGeoDataCoordinateSystem::kGoodeHomolosine: strRet = L"Goode Homolosine."; break;
    case OdDgGeoDataCoordinateSystem::kEqualAreaCylindricalNA: strRet = L"Equal-area Cylindrical. Normal Aspect."; break;    
    case OdDgGeoDataCoordinateSystem::kEqualAreaCylindricalTA: strRet = L"Equal Area Cylindrical. Transverse Aspect."; break; 
    case OdDgGeoDataCoordinateSystem::kBipolarObliqueConformalConic: strRet = L"Bipolar Oblique Conformal Conic."; break;           
    case OdDgGeoDataCoordinateSystem::kSwissObliqueCylindrical: strRet = L"Swiss Oblique Cylindrical."; break;
    case OdDgGeoDataCoordinateSystem::kPolarStereographic: strRet = L"Polar Stereographic."; break;
    case OdDgGeoDataCoordinateSystem::kObliqueStereographic: strRet = L"Oblique Stereographic."; break;
    case OdDgGeoDataCoordinateSystem::kSnyderObliqueStereographic: strRet = L"Snyder's Oblique Stereographic."; break;           
    case OdDgGeoDataCoordinateSystem::kLambertConformalConic1StdLat: strRet = L"Lambert Conformal Conic 1 Standard Latitude."; break;
    case OdDgGeoDataCoordinateSystem::kLambertConformalConic: strRet = L"Lambert Conformal Conic."; break;
    case OdDgGeoDataCoordinateSystem::kLambertConformalConicBelgian: strRet = L"Belgian Variation of the Lambert Conformal Conic."; break;
    case OdDgGeoDataCoordinateSystem::kLambertConformalConicWCCS: strRet = L"Lambert Conformal Conic. Wisconsin County Coordinate System Variation."; break;
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorWCCS: strRet = L"Transverse Mercator. Wisconsin County Coordinate System Variation."; break;
    case OdDgGeoDataCoordinateSystem::kLambertConformalConicM: strRet = L"Lambert Conformal Conic. Minnesota DOT Variation."; break;
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorM: strRet = L"Transverse Mercator. Minnesota DOT Variation."; break;
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorRSA: strRet = L"South Orientated Transverse Mercator (RSA)."; break;
    case OdDgGeoDataCoordinateSystem::kUniversalTransverseMercator: strRet = L"Universe Transverce Mercator."; break;
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorSnyder: strRet = L"Transverse Mercator per J. P. Snyder."; break;
    case OdDgGeoDataCoordinateSystem::kGaussKruger: strRet = L"Gauss-Kruger."; break;
    case OdDgGeoDataCoordinateSystem::kKrovak: strRet = L"Krovak (precise origin)."; break;
    case OdDgGeoDataCoordinateSystem::kMercatorSR: strRet = L"Mercator with scale reduction."; break;
    case OdDgGeoDataCoordinateSystem::kObliqueConformalConic: strRet = L"Oblique conformal conic."; break;
    case OdDgGeoDataCoordinateSystem::kKrovak95: strRet = L"Krovak includes 1995 adjustment."; break;
    case OdDgGeoDataCoordinateSystem::kPolarStereographicSL: strRet = L"Polar Stereographic with standard latitude."; break;
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorAffine: strRet = L"Transverse Mercator projection with affine post-processor."; break;
    case OdDgGeoDataCoordinateSystem::kNonEarth: strRet = L"Non-Earth."; break;
    case OdDgGeoDataCoordinateSystem::kObliqueCylindrical: strRet = L"Oblique Cylindrical."; break;
    case OdDgGeoDataCoordinateSystem::kDanishSystemKMS2001: strRet = L"Danish System 1934/1945 (KMS 2001 Polynomials)."; break;
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorOSTN97: strRet = L"Transverse Mercator with the OSTN97 grid shift tacked on."; break;
    case OdDgGeoDataCoordinateSystem::kAzimuthalEquidistant: strRet = L"Azimuthal equidistant (elevated ellipsoid)."; break;     
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorOSTN02: strRet = L"Transverse Mercator projection with the OSTN02 grid shift tacked on."; break;
    case OdDgGeoDataCoordinateSystem::kDanishSystemNoKMS: strRet = L"Danish System 1934/1945 (Non-KMS)."; break;
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorKF: strRet = L"Transverse Mercator Kruger Formulation."; break;      
    case OdDgGeoDataCoordinateSystem::kWinkelTripel: strRet = L"Winkel-Tripel."; break;
    case OdDgGeoDataCoordinateSystem::kNerthSR: strRet = L"Non-Earth with Scale and Rotation."; break;
    case OdDgGeoDataCoordinateSystem::kLambertConformalConicAffine: strRet = L"Lambert Conformal Conic with Affine post-processor."; break;
    case OdDgGeoDataCoordinateSystem::kDanishSystemKMS1999: strRet = L"Danish System 1934/1945 (KMS 1999 Polynomials)."; break;
    case OdDgGeoDataCoordinateSystem::kEquidistantCylindricalE: strRet = L"Equidistant Cylindrical, Ellipsoidal or Spherical."; break;
    case OdDgGeoDataCoordinateSystem::kPlateCarree: strRet = L"Plate Carree."; break;
    case OdDgGeoDataCoordinateSystem::kPseudoMercator: strRet = L"Popular Visualisation Pseudo Mercator (Google Earth)."; break;
    case OdDgGeoDataCoordinateSystem::kLambertConformalConicMichigan: strRet = L"Lambert Conformal Conic Michigan variation."; break;
    case OdDgGeoDataCoordinateSystem::kUniversalTransverseMercatorBF: strRet = L"Universal Transverse Mercator using BF Calculation."; break;
    case OdDgGeoDataCoordinateSystem::kTransverseMercatorBF: strRet = L"Transverse Mercator using BF Calculation."; break;
    case OdDgGeoDataCoordinateSystem::kObliqueMercator1PtUV: strRet = L"Unrectified Hotine Oblique Mercator. Single point form."; break; 
    case OdDgGeoDataCoordinateSystem::kObliqueMercator1PtXY: strRet = L"Rectified Hotine Oblique Mercator. Single point form."; break;
    case OdDgGeoDataCoordinateSystem::kObliqueMercator2PtUV: strRet = L"Unrectified Hotine Oblique Mercator. Two point form."; break;
    case OdDgGeoDataCoordinateSystem::kObliqueMercator2PtXY: strRet = L"Rectified Hotine Oblique Mercator. Two point form."; break;
    case OdDgGeoDataCoordinateSystem::kRectifiedSkewOrthoAO: strRet = L"Rectified Skew Orthomorphic (Azimuth at Origin)."; break;
    case OdDgGeoDataCoordinateSystem::kRectifiedSkewOrthoC: strRet = L"Rectified Skew Orthomorphic (Center)."; break;
    case OdDgGeoDataCoordinateSystem::kRectifiedSkewOrthoIsect: strRet = L"Rectified Skew Orthomorphic (Intersect)."; break;       
  }

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgFeatureSolidVariablePtr& pVar)
{
  if (pVar.isNull())
    return;

  OdString strRet;
  strRet.format(L"%f", pVar->getValue());

  if (!pVar->getExpression().isEmpty())
    strRet += L" (" + pVar->getExpression() + L")";

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgFeatureSolidVertexMarkerPtr& pVar)
{
  if (pVar.isNull())
    return;

  OdString strRet;

  strRet.format(L"Vertex : (N = %d, F = %d), (N = %d, F = %d), (N = %d, F = %d), Source = %d", 
    pVar->getNode1(), pVar->getFace1(), pVar->getNode2(), pVar->getFace2(), pVar->getNode3(), pVar->getFace3(), pVar->getSourceIndex());

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgFeatureSolidEdgeMarkerPtr& pVar)
{
  if (pVar.isNull())
    return;

  OdString strRet;

  strRet.format(L"Edge : (N = %d, F = %d), (N = %d, F = %d), Param  = %f, Source = %d",
    pVar->getNode1(), pVar->getFace1(), pVar->getNode2(), pVar->getFace2(), pVar->getParam(), pVar->getSourceIndex());

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgFeatureSolidFaceMarkerPtr& pVar)
{
  if (pVar.isNull())
    return;

  OdString strRet;

  strRet.format(L"Face : (N = %d, F = %d), Param  = (%f, %f), Source = %d",
    pVar->getNode(), pVar->getFace(), pVar->getUParam(), pVar->getVParam(), pVar->getSourceIndex());

  writeFieldValue(name, strRet);
}

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

void OdExDgnDumper::writeFieldValue(const OdString& name, const OdDgFeatureSolidBodyMarkerPtr& pVar)
{
  if (pVar.isNull())
    return;

  OdString strRet;

  strRet.format(L"Body : (Node = %d)", pVar->getNode());

  writeFieldValue(name, strRet);
}

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