Convert.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2018 by PDFTron Systems 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/WordToPDFOptions.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 Convert
{
public:
    enum FlattenThresholdFlag {
        e_very_strict, 
        e_strict,
        e_default,
        e_keep_most,
        e_keep_all
    };

    enum FlattenFlag {
        e_off,
        e_simple,
        e_fast
    };

    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);

    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 FlattenFlag flatten);

        void SetFlattenThreshold(enum 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;
    };

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

    static void ToSvg(Page & in_page, const UString & in_filename, const SVGOutputOptions& in_options = SVGOutputOptions());

    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 Getm_obj();

        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 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 FlattenFlag flatten);

        void SetFlattenThreshold(enum 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 HTMLOutputOptions
    {
    public:
        HTMLOutputOptions();

        void SetPreferJPG(bool prefer_jpg);

        void SetJPGQuality(UInt32 quality);

        void SetDPI(UInt32 dpi);

        void SetMaximumImagePixels(UInt32 max_pixels);

        void SetReflow(bool reflow);

        void SetScale(double scale);

        void SetExternalLinks(bool enable);

        void SetInternalLinks(bool enable);

        void SetSimplifyText(bool enable);

        void SetReportFile(const UString& path);

    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 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;
    };

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

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

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

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

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

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

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

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

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

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

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

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


    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 ToPdf(PDFDoc & in_pdfdoc, const UString & in_filename);

    static bool RequiresPrinter(const UString & in_filename);

    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();


    };

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


#include <Impl/Convert.inl>

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

#endif // PDFTRON_H_CPPPDFConvert