Convert.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2025 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------
#ifndef PDFTRON_H_CPPPDFConvert
#define PDFTRON_H_CPPPDFConvert

#include <PDF/PDFDoc.h>
#include <PDF/Page.h>
#include <PDF/PDFRasterizer.h>
#include <PDF/DocumentConversion.h>
#include <PDF/TemplateDocument.h>
#include <PDF/WordToPDFOptions.h>
#include <PDF/CADConvertOptions.h>
#include <PDF/AdvancedImagingConvertOptions.h>
#include <PDF/SVGConvertOptions.h>
#include <PDF/Reflow.h>
#include <C/PDF/TRN_Convert.h>
#include <SDF/Obj.h>
#include <SDF/ObjSet.h>

namespace pdftron{ 
    namespace PDF {

// Experimental - Developer use only
class ConversionMonitor
{
public:
    bool Next();
    bool Ready();
    UInt32 Progress();
    Filters::Filter Filter();
    ConversionMonitor();
    void Destroy();
    ~ConversionMonitor();
    ConversionMonitor(const ConversionMonitor& copy);
    ConversionMonitor& operator=(const ConversionMonitor& other);

    operator bool () { return mp_impl!=0;}
#ifndef SWIGHIDDEN
    TRN_ConversionMonitor mp_impl;
    ConversionMonitor(TRN_ConversionMonitor impl, bool is_owner);
    bool m_owner;
#endif
};

class XPSOutputOptions;
class XODOutputOptions;
class HTMLOutputOptions;
class WordOutputOptions;
class ExcelOutputOptions;
class PowerPointOutputOptions;
class EPUBOutputOptions;
class SVGOutputOptions;
class TiffOutputOptions;
class Printer;
class Convert
{
public:
    typedef pdftron::PDF::XPSOutputOptions XPSOutputOptions;
    typedef pdftron::PDF::XODOutputOptions XODOutputOptions;
    typedef pdftron::PDF::HTMLOutputOptions HTMLOutputOptions;
    typedef pdftron::PDF::WordOutputOptions WordOutputOptions;
    typedef pdftron::PDF::ExcelOutputOptions ExcelOutputOptions;
    typedef pdftron::PDF::PowerPointOutputOptions PowerPointOutputOptions;
    typedef pdftron::PDF::EPUBOutputOptions EPUBOutputOptions;
    typedef pdftron::PDF::SVGOutputOptions SVGOutputOptions;
    typedef pdftron::PDF::TiffOutputOptions TiffOutputOptions;
    typedef pdftron::PDF::Printer Printer;

    enum FlattenThresholdFlag {
        e_very_strict, 
        e_strict,
        e_default,
        e_keep_most,
        e_keep_all
    };

    enum FlattenFlag {
        e_off,
        e_simple,
        e_fast,

        e_high_quality
    };

    static void FromXps(PDFDoc & in_pdfdoc, const UString & in_filename);

    static void FromXps(PDFDoc & in_pdfdoc, const char* buf, size_t buf_sz);

    static void FromEmf(PDFDoc & in_pdfdoc, const UString & in_filename);

    static void FromText(PDFDoc & in_pdfdoc, const UString& in_filename, const SDF::Obj& in_options = SDF::Obj());

    static void ToEmf(PDFDoc & in_pdfdoc, const UString & in_filename);

    static void ToEmf(Page & in_page, const UString & in_filename);

    
    static void ToSvg(PDFDoc & in_pdfdoc, const UString & in_filename, const SVGOutputOptions& in_options);

    static void ToSvg(PDFDoc & in_pdfdoc, const UString & in_filename);

    static void ToSvg(Page & in_page, const UString & in_filename, const SVGOutputOptions& in_options);
    
    static void ToSvg(Page & in_page, const UString & in_filename);
          
    static void ToXps(PDFDoc & in_pdfdoc, const UString & in_filename, const XPSOutputOptions& options);

    static void ToXps(PDFDoc & in_pdfdoc, const UString & in_filename);

    static void ToXps(const UString & in_inputFilename, const UString & in_outputFilename, const XPSOutputOptions& options);

    static void ToXps(const UString & in_inputFilename, const UString & in_outputFilename);

    static void ToXod(const UString & in_filename, const UString & out_filename, const XODOutputOptions& options);

    static void ToXod(const UString & in_filename, const UString & out_filename);

    static void ToXod(PDFDoc & in_pdfdoc, const UString & out_filename, const XODOutputOptions& options);

    static void ToXod(PDFDoc & in_pdfdoc, const UString & out_filename);

    static void ToHtml(const UString & in_filename, const UString & out_path, const HTMLOutputOptions& options);

    static void ToHtml(const UString & in_filename, const UString & out_path);


    static UString PageToHtml(const Page & page);

    static UString PageToHtmlZoned(const Page & page, const UString & json_zones);

    static void ToHtml(PDFDoc & in_pdfdoc, const UString & out_path, const HTMLOutputOptions& options);

    static void ToHtml(PDFDoc & in_pdfdoc, const UString & out_path);

    static void ToWord(const UString & in_filename, const UString & out_path, const WordOutputOptions& options);

    static void ToWord(const UString & in_filename, const UString & out_path);

    static void ToWord(PDFDoc& in_pdfdoc, Filters::Filter& out_filter);

    static void ToWord(PDFDoc& in_pdfdoc, Filters::Filter& out_filter, const WordOutputOptions& options);

    static void ToWord(PDFDoc & in_pdfdoc, const UString & out_path, const WordOutputOptions& options);

    static void ToWord(PDFDoc & in_pdfdoc, const UString & out_path);

    static void ToExcel(const UString& in_filename, const UString& out_path, const ExcelOutputOptions& options);

    static void ToExcel(const UString& in_filename, const UString& out_path);

    static void ToExcel(PDFDoc& in_pdfdoc, const UString& out_path, const ExcelOutputOptions& options);

    static void ToExcel(PDFDoc& in_pdfdoc, const UString& out_path);

    static void ToExcel(PDFDoc& in_pdfdoc, Filters::Filter& out_filter);

    static void ToExcel(PDFDoc& in_pdfdoc, Filters::Filter& out_filter, const ExcelOutputOptions& options);

    static void ToPowerPoint(const UString& in_filename, const UString& out_path, const PowerPointOutputOptions& options);

    static void ToPowerPoint(const UString& in_filename, const UString& out_path);

    static void ToPowerPoint(PDFDoc& in_pdfdoc, const UString& out_path, const PowerPointOutputOptions& options);

    static void ToPowerPoint(PDFDoc& in_pdfdoc, const UString& out_path);

    static void ToPowerPoint(PDFDoc& in_pdfdoc, Filters::Filter& out_filter);

    static void ToPowerPoint(PDFDoc& in_pdfdoc, Filters::Filter& out_filter, const PowerPointOutputOptions& options);

    static void ToEpub(const UString & in_filename, const UString & out_path, const HTMLOutputOptions& html_options, const EPUBOutputOptions& epub_options);

    static void ToEpub(const UString & in_filename, const UString & out_path, const HTMLOutputOptions& html_options);

    static void ToEpub(const UString & in_filename, const UString & out_path);

    static void ToEpub(PDFDoc & in_pdfdoc, const UString & out_path, const HTMLOutputOptions& html_options, const EPUBOutputOptions& epub_options);

    static void ToEpub(PDFDoc & in_pdfdoc, const UString & out_path, const HTMLOutputOptions& html_options);

    static void ToEpub(PDFDoc & in_pdfdoc, const UString & out_path);

    static void ToTiff(const UString & in_filename, const UString & out_path, const TiffOutputOptions& options);

    static void ToTiff(const UString & in_filename, const UString & out_path);

    static void ToTiff(PDFDoc & in_pdfdoc, const UString & out_path, const TiffOutputOptions& options);

    static void ToTiff(PDFDoc & in_pdfdoc, const UString & out_path);

    static void ToTiff(const UString & in_filename, Filters::Filter& out_filter, const TiffOutputOptions& options);

    static void ToTiff(const UString & in_filename, Filters::Filter& out_filter);

    static void ToTiff(PDFDoc & in_pdfdoc, Filters::Filter& out_filter, const TiffOutputOptions& options);

    static void ToTiff(PDFDoc & in_pdfdoc, Filters::Filter& out_filter);

    static Filters::Filter ToXod(const UString & in_filename, const XODOutputOptions& options);

    static Filters::Filter ToXod(const UString & in_filename);

    static Filters::Filter ToXod(PDFDoc & in_pdfdoc, const XODOutputOptions& options);

    static Filters::Filter ToXod(PDFDoc & in_pdfdoc);
    // Experimental - Developer use only
    static ConversionMonitor ToXodWithMonitor(PDFDoc & in_pdfdoc, const XODOutputOptions& options);
    static ConversionMonitor ToXodWithMonitor(PDFDoc & in_pdfdoc);


    static void WordToPDF( PDFDoc & in_pdfdoc, const UString & in_filename, WordToPDFOptions* options);

    static DocumentConversion WordToPDFConversion( PDFDoc & in_pdfdoc, const UString & in_filename, WordToPDFOptions* options);

    static void WordToPDF( PDFDoc & in_pdfdoc, Filters::Filter in_stream, WordToPDFOptions* options);

    static DocumentConversion WordToPDFConversion( PDFDoc & in_pdfdoc, Filters::Filter in_stream, WordToPDFOptions* options);
    
    static void OfficeToPDF( PDFDoc & in_pdfdoc, const UString & in_filename, ConversionOptions* options);

    static DocumentConversion StreamingPDFConversion( PDFDoc & in_pdfdoc, const UString & in_filename, ConversionOptions* options);
    
    static DocumentConversion StreamingPDFConversion(const UString & in_filename, ConversionOptions* options);

    static Reflow CreateReflow(Page & in_page, const UString & json_zones);

    static void OfficeToPDF( PDFDoc & in_pdfdoc, Filters::Filter in_stream, ConversionOptions* options);

    static DocumentConversion StreamingPDFConversion( PDFDoc & in_pdfdoc, Filters::Filter in_stream, ConversionOptions* options);
    
    static DocumentConversion StreamingPDFConversion(Filters::Filter in_stream, ConversionOptions* options);

    static void ToPdf(PDFDoc & in_pdfdoc, const UString & in_filename);

    static void FromCAD(PDFDoc& in_pdfdoc, const UString& in_filename, CADConvertOptions* opts = 0);
    
    static void FromDICOM(PDFDoc& in_pdfdoc, const UString& in_filename, AdvancedImagingConvertOptions* opts = 0);

    
    static void FromSVG(PDFDoc& in_pdfdoc, const UString& in_filename, SVGConvertOptions* opts = 0);

    static void FromTiff(PDFDoc& in_pdfdoc, Filters::Filter in_data);

    static TemplateDocument CreateOfficeTemplate(const UString& in_filename, ConversionOptions* options);

    static TemplateDocument CreateOfficeTemplate(Filters::Filter in_stream, ConversionOptions* options);

    static bool RequiresPrinter(const UString & in_filename);

    
private:
    Convert ();
    ~Convert ();
};

class XPSOutputCommonOptions
{
public:
    XPSOutputCommonOptions();
    void SetPrintMode(bool print_mode);

    void SetDPI(UInt32 dpi);

    void SetRenderPages(bool render);

    void SetThickenLines(bool thicken);

    void GenerateURLLinks(bool generate);

    enum OverprintPreviewMode
    {
        e_op_off = 0,
        e_op_on,
        e_op_pdfx_on
    };

    void SetOverprint(enum OverprintPreviewMode mode);

    TRN_Obj m_obj;
protected:
    friend class Convert;
    SDF::ObjSet m_objset;
};

class XPSOutputOptions : public XPSOutputCommonOptions
{
public:
    void SetOpenXps(bool openxps);
};

class XODOutputOptions : public XPSOutputCommonOptions
{
public:

    enum AnnotationOutputFlag {
        e_internal_xfdf,                // include the annotation file in the XOD output. This is the default option
        e_external_xfdf,                // output the annotation file externally to the same output path with extension .xfdf. 
                                        // This is not available when using streaming conversion
        e_flatten                       // flatten all annotations that are not link annotations
    };

    void SetExtractUsingZorder(bool use_zorder);

    void SetOutputThumbnails(bool include_thumbs);

    void SetThumbnailSize(UInt32 size);

    void SetThumbnailSize(UInt32 regular_size, UInt32 large_size);

    void SetElementLimit(UInt32 element_limit);

    void SetOpacityMaskWorkaround(bool opacity_render);

    void SetMaximumImagePixels(UInt32 max_pixels);

    void SetFlattenContent(enum Convert::FlattenFlag flatten);

    void SetFlattenThreshold(enum Convert::FlattenThresholdFlag threshold);

    void SetPreferJPG(bool prefer_jpg);

    void SetJPGQuality(UInt32 quality);

    void SetSilverlightTextWorkaround(bool workaround);

    void SetAnnotationOutput(enum AnnotationOutputFlag annot_output);

    void SetExternalParts(bool generate);

    void SetEncryptPassword(const char* pass);

    void UseSilverlightFlashCompatible(bool compatible);
};

class OutputOptionsOCR
{
public:
    enum LanguageChoice
    {
        e_lang_auto = 0, /* Indicates automatic OCR language detection. */
        e_lang_catalan, /* Indicates the Catalan language for OCR. */
        e_lang_danish, /* Indicates the Danish language for OCR. */
        e_lang_german, /* Indicates the German language for OCR. */
        e_lang_english, /* Indicates the English language for OCR. */
        e_lang_spanish, /* Indicates the Spanish language for OCR. */
        e_lang_finnish, /* Indicates the Finnish language for OCR. */
        e_lang_french, /* Indicates the French language for OCR. */
        e_lang_italian, /* Indicates the Italian language for OCR. */
        e_lang_dutch, /* Indicates the Dutch language for OCR. */
        e_lang_norwegian, /* Indicates the Norwegian language for OCR. */
        e_lang_portuguese, /* Indicates the Portuguese language for OCR. */
        e_lang_polish, /* Indicates the Polish language for OCR. */
        e_lang_romanian, /* Indicates the Romanian language for OCR. */
        e_lang_russian, /* Indicates the Russian language for OCR. */
        e_lang_slovenian, /* Indicates the Slovenian language for OCR. */
        e_lang_swedish, /* Indicates the Swedish language for OCR. */
        e_lang_turkish /* Indicates the Turkish language for OCR. */
    };

    enum PreferredOCREngine
    {
        e_engine_default = 0,
        e_engine_tesseract
    };

    static UString LanguageChoiceToString(LanguageChoice language);
    
    static UString PreferredOCRChoiceToString(PreferredOCREngine engine);
};

class StructuredOutputOptions
{
public:
    enum SectionConversionSetting
    {
        e_Recover = 0,     /* Recover as headers, footers, and/or footnotes. */
        e_DoNotDetect,     /* Place in the body of the document. */
        e_DetectAndRemove  /* Remove detected headers, footers, and/or footnotes. */
    };

    static StructuredOutputOptions::SectionConversionSetting SectionConversionSettingFromOption(TRN_Obj& obj);
};

class HTMLOutputOptions
{
public:
    HTMLOutputOptions();

    void SetPreferJPG(bool prefer_jpg);

    void SetJPGQuality(UInt32 quality);

    void SetDPI(UInt32 dpi);

    void SetMaximumImagePixels(UInt32 max_pixels);

    enum ContentReflowSetting
    {
        e_fixed_position = 0, /* Content uses fixed positioning (default). */
        e_reflow_paragraphs, /* Deprecated. Text flows within paragraphs. */
        e_reflow_full /* Text flows freely edge-to-edge in a single column. */
    };

    void SetContentReflowSetting(ContentReflowSetting reflow);

    void SetScale(double scale);

    void SetExternalLinks(bool enable);

    void SetInternalLinks(bool enable);

    void SetSimplifyText(bool enable);

    void SetReportFile(const UString& path);

    void SetTitle(const UString& title);

    void SetImageDPI(UInt32 dpi);

    void SetEmbedImages(bool embed);

    void SetFileConversionTimeoutSeconds(int seconds);

    void SetPages(int page_from, int page_to);

    void SetPDFPassword(const UString& password);

    enum SearchableImageSetting
    {
        e_ocr_image_text = 0, /* Convert both images and pre-existing hidden text from previous OCR. Only applies to e_reflow_paragraphs. */
        e_ocr_image, /* Convert images only, ignoring pre-existing text from previous OCR, and do not perform any new OCR. */
        e_ocr_text, /* Convert pre-existing text from previous OCR only (e_reflow_paragraphs mode). Perform new OCR on scanned pages (e_reflow_full mode). */
        e_ocr_off, /* Convert images only, ignoring pre-existing text from previous OCR, and do not perform any new OCR. */
        e_ocr_always /* Perform new OCR on all pages. (e_reflow_full mode). */
    };

    void SetSearchableImageSetting(SearchableImageSetting setting);

    void SetSimpleLists(bool enable);

    void SetConnectHyphens(bool connect);

    void SetDisableVerticalSplit(bool disable);

    void SetNoPageWidth(bool enable);

    void SetLanguage(OutputOptionsOCR::LanguageChoice language);

    void SetPreferredOCREngine(OutputOptionsOCR::PreferredOCREngine engine);

    void SetHeadersAndFootersSetting(StructuredOutputOptions::SectionConversionSetting option);

    void SetFootnotesSetting(StructuredOutputOptions::SectionConversionSetting option);

    StructuredOutputOptions::SectionConversionSetting GetHeadersAndFootersSetting();

    StructuredOutputOptions::SectionConversionSetting GetFootnotesSetting();

    void SetTextRecoveryNSE(bool use_ocr);
    
protected:
    TRN_Obj m_obj;
    friend class Convert;
    SDF::ObjSet m_objset;
};

class WordOutputOptions
{
public:
    WordOutputOptions();

    enum WordOutputFormat
    {
        e_wof_docx = 0,
        e_wof_doc,
        e_wof_rtf,
        e_wof_txt
    };

    void SetWordOutputFormat(WordOutputFormat format);

    void SetPages(int page_from, int page_to);

    void SetPDFPassword(const UString& password);

    enum SearchableImageSetting
    {
        e_ocr_image_text = 0, /* Deprecated. OCR will be performed. */
        e_ocr_image, /* Deprecated. OCR will not be performed. */
        e_ocr_text, /* Indicates that OCR will be performed on scanned pages, and the recognized text replaces the image pixels underneath (default). */
        e_ocr_off, /* Indicates that OCR will not be performed. */
        e_ocr_always /* Indicates that OCR will always be performed on all pages, and the recognized text replaces the image pixels underneath. */
    };

    void SetSearchableImageSetting(SearchableImageSetting setting);

    void SetTextRecoveryNSE(bool use_ocr);
    
    void SetDetectTOC(bool detect_toc);
    
    void SetConnectHyphens(bool connect);

    void SetLanguage(OutputOptionsOCR::LanguageChoice language);

    void SetPreferredOCREngine(OutputOptionsOCR::PreferredOCREngine engine);

    void SetCustomOCRLanguage(const UString& ocrlang);

    void SetPrioritizeVisualAppearance(bool replica);

    void SetHeadersAndFootersSetting(StructuredOutputOptions::SectionConversionSetting option);

    void SetFootnotesSetting(StructuredOutputOptions::SectionConversionSetting option);

    StructuredOutputOptions::SectionConversionSetting GetHeadersAndFootersSetting();

    StructuredOutputOptions::SectionConversionSetting GetFootnotesSetting();

protected:
    TRN_Obj m_obj;
    friend class Convert;
    SDF::ObjSet m_objset;
};

class ExcelOutputOptions
{
public:
    ExcelOutputOptions();

    void SetPages(int page_from, int page_to);

    void SetPDFPassword(const UString& password);

    void SetLanguage(OutputOptionsOCR::LanguageChoice language);

    void SetPreferredOCREngine(OutputOptionsOCR::PreferredOCREngine engine);

    void SetCustomOCRLanguage(const UString& ocrlang);

    enum SearchableImageSetting
    {
        e_ocr_text = 2, /* Indicates that OCR will be performed on scanned pages, and the recognized text replaces the image pixels underneath (default). */
        e_ocr_off, /* Indicates that OCR will not be performed. */
        e_ocr_always /* Indicates that OCR will always be performed on all pages, and the recognized text replaces the image pixels underneath. */
    };

    void SetSearchableImageSetting(SearchableImageSetting setting);

    void SetTextRecoveryNSE(bool use_ocr);
    
    void SetNonTableContent(bool non_tables);

    void SetSingleSheet(bool single_sheet);

    void SetPageSingleSheet(bool page_single);
    
    void SetHeadersAndFootersSetting(StructuredOutputOptions::SectionConversionSetting option);

    void SetFootnotesSetting(StructuredOutputOptions::SectionConversionSetting option);

    StructuredOutputOptions::SectionConversionSetting GetHeadersAndFootersSetting();

    StructuredOutputOptions::SectionConversionSetting GetFootnotesSetting();

protected:
    TRN_Obj m_obj;
    friend class Convert;
    SDF::ObjSet m_objset;
};

class PowerPointOutputOptions
{
public:
    PowerPointOutputOptions();

    void SetPages(int page_from, int page_to);

    void SetPDFPassword(const UString& password);

    void SetLanguage(OutputOptionsOCR::LanguageChoice language);

    void SetPreferredOCREngine(OutputOptionsOCR::PreferredOCREngine engine);

    void SetCustomOCRLanguage(const UString& ocrlang);

    enum SearchableImageSetting
    {
        e_ocr_text = 2, /* Indicates that OCR will be performed on scanned pages, and the recognized text replaces the image pixels underneath (default). */
        e_ocr_off, /* Indicates that OCR will not be performed. */
        e_ocr_always /* Indicates that OCR will always be performed on all pages, and the recognized text replaces the image pixels underneath. */
    };

    void SetSearchableImageSetting(SearchableImageSetting setting);

    void SetTextRecoveryNSE(bool use_ocr);
    
    void SetHeadersAndFootersSetting(StructuredOutputOptions::SectionConversionSetting option);

    void SetFootnotesSetting(StructuredOutputOptions::SectionConversionSetting option);

    StructuredOutputOptions::SectionConversionSetting GetHeadersAndFootersSetting();

    StructuredOutputOptions::SectionConversionSetting GetFootnotesSetting();

protected:
    TRN_Obj m_obj;
    friend class Convert;
    SDF::ObjSet m_objset;
};

class EPUBOutputOptions
{
public:
    EPUBOutputOptions();

    void SetExpanded(bool expanded);

    void SetReuseCover(bool reuse);
protected:
    TRN_Obj m_obj;
    friend class Convert;
    SDF::ObjSet m_objset;
};

class SVGOutputOptions
{
public:

    SVGOutputOptions();

    void SetEmbedImages(bool embed_images);

    void SetNoFonts(bool no_fonts);

    void SetSvgFonts(bool svg_fonts);

    void SetEmbedFonts(bool embed_fonts);

    void SetNoUnicode(bool no_unicode);

    void SetIndividualCharPlacement(bool individual_char_placement);

    void SetRemoveCharPlacement(bool remove_char_placement);

    void SetFlattenContent(enum Convert::FlattenFlag flatten);

    void SetFlattenThreshold(enum Convert::FlattenThresholdFlag threshold);

    void SetFlattenDPI(UInt32 dpi);

    void SetFlattenMaximumImagePixels(UInt32 max_pixels);

    void SetCompress(bool svgz);

    void SetOutputThumbnails(bool include_thumbs);

    void SetThumbnailSize(UInt32 size);

    void SetCreateXmlWrapper(bool xml);

    void SetDtd(bool dtd);

    void SetAnnots(bool annots);

    void SetOverprint(PDFRasterizer::OverprintPreviewMode mode);
protected:
    TRN_Obj m_obj;
    friend class Convert;
    SDF::ObjSet m_objset;
};

class TiffOutputOptions
{
public:
    TiffOutputOptions();

    void SetBox(enum Page::Box type);

    void SetRotate(enum Page::Rotate rotation);

    void SetClip(double x1, double y1, double x2, double y2);

    void SetPages(const char* page_desc);

    void SetOverprint(enum PDFRasterizer::OverprintPreviewMode mode);

    void SetCMYK(bool enable);

    void SetDither(bool enable);

    void SetGray(bool enable);

    void SetMono(bool enable);

    void SetAnnots(bool enable);

    void SetSmooth(bool enable);

    void SetPrintmode(bool enable);

    void SetTransparentPage(bool enable);


    void SetPalettized(bool enable);

    void SetDPI(double dpi);

    void SetGamma(double gamma);

    void SetHRes(int hres);

    void SetVRes(int vres);


protected:
    TRN_Obj m_obj;
    friend class Convert;
    SDF::ObjSet m_objset;
};

class Printer
{
public:
    static void Install(const UString & in_printerName = "PDFTron PDFNet");

    static void Uninstall();

    static const UString GetPrinterName();

    static void SetPrinterName(const UString & in_printerName = "PDFTron PDFNet");

    static bool IsInstalled(const UString & in_printerName = "PDFTron PDFNet");

    enum Mode {
        e_auto,
        e_interop_only,
        e_printer_only,
        e_prefer_builtin_converter
    };

    static void SetMode(Mode mode);

    static Mode GetMode();


};

#include <Impl/Convert.inl>

    }; // namespace PDF
}; // namespace pdftron

#endif // PDFTRON_H_CPPPDFConvert