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

// ODA Platform
#include "OdaCommon.h"
#include "RxDynamicModule.h"
#include "RxVariantValue.h"

// Visualize SDK
#include "TvFactory.h"
#include "TvImportUserData.h"

//PDF export
#include "Visualize2Pdf.h"
#include "DynamicLinker.h"
#include "TvError.h"
#include "PdfExport.h"

// publish
#include "ExStringIO.h"
#include "Ed/EdCommandStack.h"
#include "TvExDbCommandContext.h"
#include "PrcModuleNames.h"

using namespace TD_PDF_2D_EXPORT;

//***************************************************************************//
// 'OdTvVisualize2PdfFilerProperties' methods implementation
//***************************************************************************//

OdTvVisualize2PdfExportProperties::OdTvVisualize2PdfExportProperties()
  : m_iFlags(kDefault)
{
  m_backgroundColor = ODRGB(255, 255, 255);
  m_iTemplate = (OdUInt8)kDefault;
}

OdTvVisualize2PdfExportProperties::~OdTvVisualize2PdfExportProperties()
{
}

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

void OdTvVisualize2PdfExportProperties::set3DPdf(bool bIs3DPdf)
{
  SETBIT(m_iFlags, k3dPdf, bIs3DPdf);
}

bool OdTvVisualize2PdfExportProperties::is3DPdf() const
{
  return GETBIT(m_iFlags, k3dPdf);
}

void OdTvVisualize2PdfExportProperties::setBackgroundColor(OdIntPtr backgroundColor)
{
  ODCOLORREF* pColor = (ODCOLORREF*)(backgroundColor);
  if (!pColor)
  {
    ODA_ASSERT(false);
  }
  m_backgroundColor = *pColor;
}

OdIntPtr OdTvVisualize2PdfExportProperties::getBackgroundColor() const
{
  return (OdIntPtr)(&m_backgroundColor);
}

void OdTvVisualize2PdfExportProperties::setDevices(const OdStringArray& devices)
{
  m_devices = devices;
}

const OdStringArray& OdTvVisualize2PdfExportProperties::getDevices() const
{
  return m_devices;
}

void OdTvVisualize2PdfExportProperties::setPaperSizes(OdDoubleArray paperSizes)
{
  m_paperSizes = paperSizes;
}

const OdDoubleArray OdTvVisualize2PdfExportProperties::getPaperSizes() const
{
  return m_paperSizes;
}

void OdTvVisualize2PdfExportProperties::setZoomToExtents(bool bVal)
{
  SETBIT(m_iFlags, kZoomExtents, bVal);
}

bool OdTvVisualize2PdfExportProperties::getZoomToExtents() const
{
  return GETBIT(m_iFlags, kZoomExtents);
}

void OdTvVisualize2PdfExportProperties::setPublishTemplate(OdUInt8 publishTemplate)
{
  m_iTemplate = (int)publishTemplate;
}

OdUInt8 OdTvVisualize2PdfExportProperties::getPublishTemplate() const
{
  return m_iTemplate;
}

void OdTvVisualize2PdfExportProperties::setEmbeddedTTF(bool bVal)
{
  SETBIT(m_iFlags, kEmbeddedTTF, bVal);
}

bool OdTvVisualize2PdfExportProperties::getEmbeddedTTF() const
{
  return GETBIT(m_iFlags, kEmbeddedTTF);
}

void OdTvVisualize2PdfExportProperties::setEmbeddedTTFOptimization(bool bVal)
{
  SETBIT(m_iFlags, kEmbeddedTTFOptimized, bVal);
}

bool OdTvVisualize2PdfExportProperties::getEmbeddedTTFOptimization() const
{
  return GETBIT(m_iFlags, kEmbeddedTTFOptimized);
}

void OdTvVisualize2PdfExportProperties::setTTFAsGeometry(bool bVal)
{
  SETBIT(m_iFlags, kTTFAsGeometry, bVal);
}

bool OdTvVisualize2PdfExportProperties::getTTFAsGeometry() const
{
  return GETBIT(m_iFlags, kTTFAsGeometry);
}

void OdTvVisualize2PdfExportProperties::setSHXAsGeometry(bool bVal)
{
  SETBIT(m_iFlags, kSHXAsGeometry, bVal);
}

bool OdTvVisualize2PdfExportProperties::getSHXAsGeometry() const
{
  return GETBIT(m_iFlags, kSHXAsGeometry);
}

void OdTvVisualize2PdfExportProperties::setTextSearchable(bool bVal)
{
  SETBIT(m_iFlags, kTextSearchable, bVal);
}

bool OdTvVisualize2PdfExportProperties::getTextSearchable() const
{
  return GETBIT(m_iFlags, kTextSearchable);
}

void OdTvVisualize2PdfExportProperties::setSimpleGeomOptimization(bool bVal)
{
  SETBIT(m_iFlags, kSimpleGeomOptimization, bVal);
}

bool OdTvVisualize2PdfExportProperties::getSimpleGeomOptimization() const
{
  return GETBIT(m_iFlags, kSimpleGeomOptimization);
}

void OdTvVisualize2PdfExportProperties::setHiddenLineRemovalAlgorithm(bool bVal)
{
  SETBIT(m_iFlags, kHiddenLineRemovalAlg, bVal);
}

bool OdTvVisualize2PdfExportProperties::getHiddenLineRemovalAlgorithm() const
{
  return GETBIT(m_iFlags, kHiddenLineRemovalAlg);
}

void OdTvVisualize2PdfExportProperties::setExportHyperLinks(bool bVal)
{
  SETBIT(m_iFlags, kExportHyperlinks, bVal);
}

bool OdTvVisualize2PdfExportProperties::getExportHyperLinks() const
{
  return GETBIT(m_iFlags, kExportHyperlinks);
}

void OdTvVisualize2PdfExportProperties::setLinearizePDF(bool bVal)
{
  SETBIT(m_iFlags, kLinearizePDF, bVal);
}

bool OdTvVisualize2PdfExportProperties::getLinearizePDF() const
{
  return GETBIT(m_iFlags, kLinearizePDF);
}

void OdTvVisualize2PdfExportProperties::setIgnoreVisibleVpBorders(bool bVal)
{
  SETBIT(m_iFlags, kIgnoreVisibleVpBorders, bVal);
}

bool OdTvVisualize2PdfExportProperties::getIgnoreVisibleVpBorders() const
{
  return GETBIT(m_iFlags, kIgnoreVisibleVpBorders);
}

void OdTvVisualize2PdfExportProperties::setTransparentShadedVpBg(bool bVal)
{
  SETBIT(m_iFlags, kTransparentShadedVpBg, bVal);
}

bool OdTvVisualize2PdfExportProperties::getTransparentShadedVpBg() const
{
  return GETBIT(m_iFlags, kTransparentShadedVpBg);
}

void OdTvVisualize2PdfExportProperties::setFlateCompression(bool bVal)
{
  SETBIT(m_iFlags, kFlateCompression, bVal);
}

bool OdTvVisualize2PdfExportProperties::getFlateCompression() const
{
  return GETBIT(m_iFlags, kFlateCompression);
}

void OdTvVisualize2PdfExportProperties::setASCIIHexEncoding(bool bVal)
{
  SETBIT(m_iFlags, kASCIIHexEncoding, bVal);
}

bool OdTvVisualize2PdfExportProperties::getASCIIHexEncoding() const
{
  return GETBIT(m_iFlags, kASCIIHexEncoding);
}

ODRX_DECLARE_PROPERTY(is3D)
ODRX_DECLARE_PROPERTY(BackgroundColor)
ODRX_DECLARE_PROPERTY(Devices)
ODRX_DECLARE_PROPERTY(PaperSizes)
ODRX_DECLARE_PROPERTY(ZoomToExtents)
ODRX_DECLARE_PROPERTY(PublishTemplate)
ODRX_DECLARE_PROPERTY(EmbeddedTTF)
ODRX_DECLARE_PROPERTY(EmbeddedTTFOptimized)
ODRX_DECLARE_PROPERTY(TTFAsGeometry)
ODRX_DECLARE_PROPERTY(SHXAsGeometry)
ODRX_DECLARE_PROPERTY(TextSearchable)
ODRX_DECLARE_PROPERTY(SimpleGeomOptimization)
ODRX_DECLARE_PROPERTY(HiddenLineRemovalAlgorithm)
ODRX_DECLARE_PROPERTY(ExportHyperLinks)
ODRX_DECLARE_PROPERTY(LinearizePDF)
ODRX_DECLARE_PROPERTY(IgnoreVisibleVpBorders)
ODRX_DECLARE_PROPERTY(TransparentShadedVpBg)
ODRX_DECLARE_PROPERTY(FlateCompression)
ODRX_DECLARE_PROPERTY(ASCIIHexEncoding)

ODRX_BEGIN_DYNAMIC_PROPERTY_MAP(OdTvVisualize2PdfExportProperties);
ODRX_GENERATE_PROPERTY(is3D)
ODRX_GENERATE_PROPERTY(BackgroundColor)
ODRX_GENERATE_PROPERTY(Devices)
ODRX_GENERATE_PROPERTY(PaperSizes)
ODRX_GENERATE_PROPERTY(ZoomToExtents)
ODRX_GENERATE_PROPERTY(PublishTemplate)
ODRX_GENERATE_PROPERTY(EmbeddedTTF)
ODRX_GENERATE_PROPERTY(EmbeddedTTFOptimized)
ODRX_GENERATE_PROPERTY(TTFAsGeometry)
ODRX_GENERATE_PROPERTY(SHXAsGeometry)
ODRX_GENERATE_PROPERTY(TextSearchable)
ODRX_GENERATE_PROPERTY(SimpleGeomOptimization)
ODRX_GENERATE_PROPERTY(HiddenLineRemovalAlgorithm)
ODRX_GENERATE_PROPERTY(ExportHyperLinks)
ODRX_GENERATE_PROPERTY(LinearizePDF)
ODRX_GENERATE_PROPERTY(IgnoreVisibleVpBorders)
ODRX_GENERATE_PROPERTY(TransparentShadedVpBg)
ODRX_GENERATE_PROPERTY(FlateCompression)
ODRX_GENERATE_PROPERTY(ASCIIHexEncoding)
ODRX_END_DYNAMIC_PROPERTY_MAP(OdTvVisualize2PdfExportProperties);

ODRX_DEFINE_PROPERTY_METHODS(is3D, OdTvVisualize2PdfExportProperties, is3DPdf, set3DPdf, getBool);
ODRX_DEFINE_PROPERTY_METHODS(BackgroundColor, OdTvVisualize2PdfExportProperties, getBackgroundColor, setBackgroundColor, getIntPtr);
ODRX_DEFINE_PROPERTY_METHODS(Devices, OdTvVisualize2PdfExportProperties, getDevices, setDevices, getStringArray);
ODRX_DEFINE_PROPERTY_METHODS(PaperSizes, OdTvVisualize2PdfExportProperties, getPaperSizes, setPaperSizes, getDoubleArray);
ODRX_DEFINE_PROPERTY_METHODS(ZoomToExtents, OdTvVisualize2PdfExportProperties, getZoomToExtents, setZoomToExtents, getBool);
ODRX_DEFINE_PROPERTY_METHODS(PublishTemplate, OdTvVisualize2PdfExportProperties, getPublishTemplate, setPublishTemplate, getUInt8);
ODRX_DEFINE_PROPERTY_METHODS(EmbeddedTTF, OdTvVisualize2PdfExportProperties, getEmbeddedTTF, setEmbeddedTTF, getBool);
ODRX_DEFINE_PROPERTY_METHODS(EmbeddedTTFOptimized, OdTvVisualize2PdfExportProperties, getEmbeddedTTFOptimization, setEmbeddedTTFOptimization, getBool);
ODRX_DEFINE_PROPERTY_METHODS(TTFAsGeometry, OdTvVisualize2PdfExportProperties, getTTFAsGeometry, setTTFAsGeometry, getBool);
ODRX_DEFINE_PROPERTY_METHODS(SHXAsGeometry, OdTvVisualize2PdfExportProperties, getSHXAsGeometry, setSHXAsGeometry, getBool);
ODRX_DEFINE_PROPERTY_METHODS(TextSearchable, OdTvVisualize2PdfExportProperties, getTextSearchable, setTextSearchable, getBool);
ODRX_DEFINE_PROPERTY_METHODS(SimpleGeomOptimization, OdTvVisualize2PdfExportProperties, getSimpleGeomOptimization, setSimpleGeomOptimization, getBool);
ODRX_DEFINE_PROPERTY_METHODS(HiddenLineRemovalAlgorithm, OdTvVisualize2PdfExportProperties, getHiddenLineRemovalAlgorithm, setHiddenLineRemovalAlgorithm, getBool);
ODRX_DEFINE_PROPERTY_METHODS(ExportHyperLinks, OdTvVisualize2PdfExportProperties, getExportHyperLinks, setExportHyperLinks, getBool);
ODRX_DEFINE_PROPERTY_METHODS(LinearizePDF, OdTvVisualize2PdfExportProperties, getLinearizePDF, setLinearizePDF, getBool);
ODRX_DEFINE_PROPERTY_METHODS(IgnoreVisibleVpBorders, OdTvVisualize2PdfExportProperties, getIgnoreVisibleVpBorders, setIgnoreVisibleVpBorders, getBool);
ODRX_DEFINE_PROPERTY_METHODS(TransparentShadedVpBg, OdTvVisualize2PdfExportProperties, getTransparentShadedVpBg, setTransparentShadedVpBg, getBool);
ODRX_DEFINE_PROPERTY_METHODS(FlateCompression, OdTvVisualize2PdfExportProperties, getFlateCompression, setFlateCompression, getBool);
ODRX_DEFINE_PROPERTY_METHODS(ASCIIHexEncoding, OdTvVisualize2PdfExportProperties, getASCIIHexEncoding, setASCIIHexEncoding, getBool);


//***************************************************************************//
// 'OdTvVisualize2PdfFiler' methods implementation
//***************************************************************************//

OdTvVisualize2PdfExport::OdTvVisualize2PdfExport()
{
  m_properties = OdTvVisualize2PdfExportProperties::createObject();
}

OdTvResult OdTvVisualize2PdfExport::exportTo(const OdTvDatabaseId& tvDbId, const OdString& fileName) const
{
  OdTvDatabasePtr pTvDb = tvDbId.openObject();
  if (pTvDb.isNull())
    return tvInvalidInput;

  //call method for write the file
  try
  {
    OdDbBaseDatabase* pDb = static_cast<OdDbBaseDatabase*>(pTvDb->getInternalDatabase());
    int errorCode;
    if (!m_properties->is3DPdf())
      errorCode = exportTo2dPdf(tvDbId, pDb, fileName);
    else
      errorCode = exportTo3dPdf(tvDbId, pDb, fileName);

    if (errorCode != 0)
      return tvErrorDuringExport;
  }
  catch (OdTvError& /*e*/)
  {
    return tvInternal;
  }

  return tvOk;
}

OdTvResult OdTvVisualize2PdfExport::exportTo(const OdTvDatabaseId& tvDbId, OdStreamBuf* pStreamBuf) const
{
  return tvNotImplementedYet;
}

OdInt32 OdTvVisualize2PdfExport::exportTo2dPdf(const OdTvDatabaseId& tvDbId, OdDbBaseDatabase* pDb, const OdString& fileName) const
{
  // try to load pdf export module
  OdPdfExportPtr exporter;
  {
    OdPdfExportModulePtr pModule = odrxDynamicLinker()->loadApp(OdPdfExportModuleName, false);

    if (pModule.isNull())
      return tvMissingExportModule;
    exporter = pModule->create();
  }

  if (exporter.isNull())
    return tvMissingExportModule;

  //get visualize export properties
  bool                bZoomToExtents = m_properties->getZoomToExtents();
  ODCOLORREF          backgroundColor = *((ODCOLORREF*)m_properties->getBackgroundColor());
  const OdStringArray devices = m_properties->getDevices();
  OdDoubleArray       paperSizes = m_properties->getPaperSizes();

  //check the possibility of not the zoom to extents
  if (!bZoomToExtents && devices.isEmpty())
  {
    bZoomToExtents = true;
  }

  //prepare and fill pdf export structure
  PDFExportParams params;
  params.setDatabase(pDb);
  params.setOutput(odrxSystemServices()->createFile(fileName, Oda::kFileWrite, Oda::kShareDenyNo, Oda::kCreateAlways));
  params.setExportFlags(PDFExportParams::PDFExportFlags(
    (m_properties->getFlateCompression() ? PDFExportParams::kFlateCompression : 0) |
    (m_properties->getASCIIHexEncoding() ? PDFExportParams::kASCIIHexEncoding : 0) |
    (m_properties->getEmbeddedTTFOptimization() ? PDFExportParams::kEmbededOptimizedTTF : 0) |
    (m_properties->getEmbeddedTTF() ? PDFExportParams::kEmbededTTF : 0) |
    (m_properties->getTTFAsGeometry() ? PDFExportParams::kTTFTextAsGeometry : 0) |
    (m_properties->getSHXAsGeometry() ? PDFExportParams::kSHXTextAsGeometry : 0) |
    (m_properties->getSimpleGeomOptimization() ? PDFExportParams::kSimpleGeomOptimization : 0) |
    (m_properties->getHiddenLineRemovalAlgorithm() ? PDFExportParams::kUseHLR : 0) |
    (m_properties->getExportHyperLinks() ? PDFExportParams::kExportHyperlinks : 0) |
    (m_properties->getLinearizePDF() ? PDFExportParams::kLinearized : 0) |
    (bZoomToExtents ? PDFExportParams::kZoomToExtentsMode : 0)));

  params.setUseViewExtents(m_properties->getIgnoreVisibleVpBorders());
  params.setImageCropping(true);
  params.setDCTCompression(true);
  params.setDCTQuality(50);
  params.setArchived((PDFExportParams::PDF_A_mode)0);

  PDFExportParams::SearchableTextType STType = (m_properties->getTextSearchable() && m_properties->getTTFAsGeometry()) ? PDFExportParams::kTTF : PDFExportParams::kNoSearch;
  params.setSearchableTextType(STType);

  params.setForceDisableGsDevice(false);
  params.setTransparentShadedVpBg(m_properties->getTransparentShadedVpBg());

  params.setSearchableTextType(PDFExportParams::kNoSearch);
  params.setSolidHatchesExportType(PDFExportParams::kPdfPaths);
  params.setGradientHatchesExportType(PDFExportParams::kBitmap);
  
  params.setGeomDPI(600);
  params.setBWImagesDPI(400);
  params.setColorImagesDPI(400);
  params.setHatchDPI(72);

  //fill parameters from incoming properties
  params.setLayouts(devices);
  params.setBackground(backgroundColor);
  params.pageParams().resize(devices.length());
  for (OdUInt32 i = 0; i < devices.length(); i++)
    params.pageParams()[i].set(paperSizes.at(2 * i), paperSizes.at(2 * i + 1));

  //perform export
  OdUInt32 errorCode = exporter->exportPdf(params);
  
  //release export module
  exporter.release();

  ::odrxDynamicLinker()->unloadModule(OdPdfExportModuleName);
  odrxDynamicLinker()->unloadUnreferenced();

  return errorCode;
}

OdInt32 OdTvVisualize2PdfExport::exportTo3dPdf(const OdTvDatabaseId& tvDbId, OdDbBaseDatabase* pDb, const OdString& fileName) const
{
  {
    OdPdfExportModulePtr pModule = odrxDynamicLinker()->loadApp(OdTvExPdfPublishCmdsModuleName, false);
    if (pModule.isNull())
      return tvMissingExportModule;
  }

  OdString sOutTemplate1(fileName);
  OdSmartPtr<ExStringIO> pStringIO = ExStringIO::create(L"Yes\nTess\n" + sOutTemplate1 + L"\n");

  if(m_properties->getPublishTemplate() == (OdUInt8)OdTvPdfExportParams::kDefault)
  {
    ODA_VERIFY(!::odedRegCmds()->lookupCmd("PUBLISH3DCASE1").isNull());
    TvExDbCommandContextBasePtr ctx = TvExDbCommandContext::createObject(pStringIO, pDb);
    ::odedRegCmds()->executeCommand("PUBLISH3DCASE1", ctx);
  }
  else if(m_properties->getPublishTemplate() == (OdUInt8)OdTvPdfExportParams::kOpenIfcViewer)
  {
    OdEdCommandPtr pCmd = ::odedRegCmds()->lookupCmd("OpenIfcViewerTemplate");
    ODA_VERIFY(!pCmd.isNull());

    _OpenIfcViewerTemplate_cmd* pTvCmd = dynamic_cast<_OpenIfcViewerTemplate_cmd*>(pCmd.get());
    if (pTvCmd)
    {
      pTvCmd->setTvDatabase(tvDbId);
    }

    TvExDbCommandContextBasePtr ctx = TvExDbCommandContext::createObject(pStringIO, pDb);
    ::odedRegCmds()->executeCommand("OpenIfcViewerTemplate", ctx);
  }
  else if (m_properties->getPublishTemplate() == (OdUInt8)OdTvPdfExportParams::kOpenStepViewer)
  {
    OdEdCommandPtr pCmd = ::odedRegCmds()->lookupCmd("OpenStepViewerTemplate");
    ODA_VERIFY(!pCmd.isNull());
  
    _OpenStepViewerTemplate_cmd* pTvCmd = dynamic_cast<_OpenStepViewerTemplate_cmd*>(pCmd.get());
    if (pTvCmd)
    {
      pTvCmd->setTvDatabase(tvDbId);
    }
  
    TvExDbCommandContextBasePtr ctx = TvExDbCommandContext::createObject(pStringIO, pDb);
    ::odedRegCmds()->executeCommand("OpenStepViewerTemplate", ctx);
  }

  ::odrxDynamicLinker()->unloadModule(OdTvExPdfPublishCmdsModuleName);
  odrxDynamicLinker()->unloadUnreferenced();

  return 0;
}

//***************************************************************************//
// 'OdTvVisualize2PdfFilerModule' methods implementation
//***************************************************************************//

#define CMD_DEF_CLASS(CmdName, GroupName) \
  extern void _##CmdName##_func(OdEdCommandContext* pCmdCtx, const OdTvDatabaseId& tvDbId);\
  const OdString _##CmdName##_cmd::globalName() const { return OD_T(#CmdName); }\
  const OdString _##CmdName##_cmd::groupName() const { return GroupName; }

#define CMD_DEF(CmdName, GroupName) \
  extern void _##CmdName##_func(OdEdCommandContext* pCmdCtx, const OdTvDatabaseId& tvDbId);\
  const OdString _##CmdName##_cmd::globalName() const { return OD_T(#CmdName); }\
  const OdString _##CmdName##_cmd::groupName() const { return GroupName; }\
  void _##CmdName##_cmd::execute(OdEdCommandContext* pCmdCtx) { _##CmdName##_func(pCmdCtx, m_dbId); }

#include "Visualize2PdfCommands.h"

#undef CMD_DEF_CLASS
#undef CMD_DEF

ODRX_DEFINE_DYNAMIC_MODULE(OdTvVisualize2PdfFilerModule);

OdTvVisualizeExportPtr OdTvVisualize2PdfFilerModule::getVisualizeExporter() const
{
  OdTvVisualizeExportPtr pPdfExporter = new OdTvVisualize2PdfExport();
  return pPdfExporter;
}

void OdTvVisualize2PdfFilerModule::initApp()
{
  // initialize the Visualize SDK
  odTvInitialize();

  TvExDbCommandContextBase::rxInit();
  TvExDbUserIO::rxInit();

  OdEdCommandStackPtr pCommands = odedRegCmds();
#define CMD_DEF(CmdName, GroupName) \
  pCommands->addCommand(&m_##CmdName##_cmd);
#include "Visualize2PdfCommands.h"
#undef CMD_DEF
}

void OdTvVisualize2PdfFilerModule::uninitApp()
{
  TvExDbUserIO::rxUninit();
  TvExDbCommandContextBase::rxUninit();

  // Uninitialize the Visualize SDK
  odTvUninitialize();

  OdEdCommandStackPtr pCommands = odedRegCmds();
#define CMD_DEF(CmdName, GroupName) \
  pCommands->removeCmd(GroupName, OD_T(#CmdName));
#include "Visualize2PdfCommands.h"
#undef CMD_DEF
}