convert.h

Go to the documentation of this file.

#pragma once

 
#include <filesystem>
 
#include <pdfsdk/cxx/core.h>
 
#include <pdfsdk/convert/pdf2docx.h>
#include <pdfsdk/convert/pdf2html.h>
#include <pdfsdk/convert/pdf2pptx.h>
#include <pdfsdk/convert/pdf2xlsx.h>
#include <pdfsdk/convert/pdf2rtf.h>
#include <pdfsdk/convert/pdf2text.h>
#include <pdfsdk/convert/pdf2json.h>
 
namespace PDF {

enum class ConvertPdfToExcelType {
    TablePerSheet,     
    PagePerSheet,      
    DocumentPerSheet,  
};

inline void ConvertPdfToWord(const PDF::Document& input,
                             bool ignoreHeadersAndFooters,
                             const std::filesystem::path& outputFile,
                             const std::vector<size_t>& pageIndexes = {},
                             PDF::ProgressMonitor* progress = nullptr) {
    PDFConvertToDocxParams params = {};
    auto outputFileStr = outputFile.wstring();
    params.outputFile = outputFileStr.c_str();
    params.ignoreHeadersAndFooters = ignoreHeadersAndFooters;
    PDPageRange pages = {pageIndexes.data(), pageIndexes.size()};
    const PDPageRange* pagesPtr = pageIndexes.empty() ? nullptr : &pages;
    const PDProgressMonitor* progressMonitor = progress ? progress->monitor() : nullptr;
    void* progressData = progress ? progress->userdata() : nullptr;
    PDF_CHECK_SUCCESS_X(PDFConvertToDocx(input.get(), pagesPtr, progressMonitor, progressData, &params));
}

inline void ConvertPdfToExcel(const PDF::Document& input,
                              ConvertPdfToExcelType convertType,
                              bool keepTablesOnly,
                              const std::filesystem::path& outputFile,
                              const std::vector<size_t>& pageIndexes = {},
                              PDF::ProgressMonitor* progress = nullptr) {
    PDFConvertToXlsxParams params = {};
    auto outputFileStr = outputFile.wstring();
    params.outputFile = outputFileStr.c_str();
    params.convertType = static_cast<PDFConvertToXlsxType>(convertType);
    params.keepTablesOnly = keepTablesOnly;
    PDPageRange pages = {pageIndexes.data(), pageIndexes.size()};
    const PDPageRange* pagesPtr = pageIndexes.empty() ? nullptr : &pages;
    const PDProgressMonitor* progressMonitor = progress ? progress->monitor() : nullptr;
    void* progressData = progress ? progress->userdata() : nullptr;
    PDF_CHECK_SUCCESS_X(PDFConvertToXlsx(input.get(), pagesPtr, progressMonitor, progressData, &params));
}

inline void ConvertPdfToPowerPoint(const PDF::Document& input,
                                   const std::filesystem::path& outputFile,
                                   const std::vector<size_t>& pageIndexes = {},
                                   PDF::ProgressMonitor* progress = nullptr) {
    PDFConvertToPptxParams params = {};
    auto outputFileStr = outputFile.wstring();
    params.outputFile = outputFileStr.c_str();
    PDPageRange pages = {pageIndexes.data(), pageIndexes.size()};
    const PDPageRange* pagesPtr = pageIndexes.empty() ? nullptr : &pages;
    const PDProgressMonitor* progressMonitor = progress ? progress->monitor() : nullptr;
    void* progressData = progress ? progress->userdata() : nullptr;
    PDF_CHECK_SUCCESS_X(PDFConvertToPptx(input.get(), pagesPtr, progressMonitor, progressData, &params));
}

inline void ConvertPdfToHtml(const PDF::Document& input,
                             const std::filesystem::path& outputFolder,
                             const std::vector<size_t>& pageIndexes = {},
                             PDF::ProgressMonitor* progress = nullptr) {
#ifdef _WIN32
    PDFConvertToHtmlParams params = {};
    auto outputFolderStr = outputFolder.wstring();
    params.outputFolder = outputFolderStr.c_str();
    params.useHTMExtension = true;
    PDPageRange pages = {pageIndexes.data(), pageIndexes.size()};
    const PDPageRange* pagesPtr = pageIndexes.empty() ? nullptr : &pages;
    const PDProgressMonitor* progressMonitor = progress ? progress->monitor() : nullptr;
    void* progressData = progress ? progress->userdata() : nullptr;
    PDF_CHECK_SUCCESS_X(PDFConvertToHtml(input.get(), pagesPtr, progressMonitor, progressData, &params));
#else
    (void)input;
    (void)outputFolder;
    (void)pageIndexes;
    (void)progress;
    PDF_THROW(kPDErrInternalError, "PDF to HTML converter is temporary unavailable on this platform");
#endif
}

inline void ConvertPdfToRtf(const PDF::Document& input,
                            const std::filesystem::path& outputFile,
                            const std::vector<size_t>& pageIndexes = {},
                            PDF::ProgressMonitor* progress = nullptr) {
#ifdef _WIN32
    PDFConvertToRtfParams params = {};
    auto outputFileStr = outputFile.wstring();
    params.outputFile = outputFileStr.c_str();
    params.tableRecognize = true;
    PDPageRange pages = {pageIndexes.data(), pageIndexes.size()};
    const PDPageRange* pagesPtr = pageIndexes.empty() ? nullptr : &pages;
    const PDProgressMonitor* progressMonitor = progress ? progress->monitor() : nullptr;
    void* progressData = progress ? progress->userdata() : nullptr;
    PDF_CHECK_SUCCESS_X(PDFConvertToRtf(input.get(), pagesPtr, progressMonitor, progressData, &params));
#else
    (void)input;
    (void)outputFile;
    (void)pageIndexes;
    (void)progress;
    PDF_THROW(kPDErrInternalError, "PDF to RTF converters is temporary unavailable on this platform");
#endif
}

inline void ConvertPdfToText(const PDF::Document& input,
                             const std::wstring& pageDivider,
                             bool convertCroppedText,
                             const std::filesystem::path& outputFile,
                             const std::vector<size_t>& pageIndexes = {},
                             PDF::ProgressMonitor* progress = nullptr) {
    PDFConvertToTextParams params = {};
    auto outputFileStr = outputFile.wstring();
    params.outputFile = outputFileStr.c_str();
    params.convertCroppedText = convertCroppedText;
    params.dividerString = pageDivider.c_str();
    PDPageRange pages = {pageIndexes.data(), pageIndexes.size()};
    const PDPageRange* pagesPtr = pageIndexes.empty() ? nullptr : &pages;
    const PDProgressMonitor* progressMonitor = progress ? progress->monitor() : nullptr;
    void* progressData = progress ? progress->userdata() : nullptr;
    PDF_CHECK_SUCCESS_X(PDFConvertToText(input.get(), pagesPtr, progressMonitor, progressData, &params));
}

inline void ConvertPdfToJson(const PDF::Document& input,
                             const std::filesystem::path& outputFile,
                             const std::vector<size_t>& pageIndexes = {},
                             PDF::ProgressMonitor* progress = nullptr) {
    PDFConvertToJsonParams params = {};
    auto outputFileStr = outputFile.wstring();
    params.outputFile = outputFileStr.c_str();
    PDPageRange pages = {pageIndexes.data(), pageIndexes.size()};
    const PDPageRange* pagesPtr = pageIndexes.empty() ? nullptr : &pages;
    const PDProgressMonitor* progressMonitor = progress ? progress->monitor() : nullptr;
    void* progressData = progress ? progress->userdata() : nullptr;
    PDF_CHECK_SUCCESS_X(PDFConvertToJson(input.get(), pagesPtr, progressMonitor, progressData, &params));
}
 
}