// pdftohtmlEX.cc

//

// Copyright (C) 2012,2013 Lu Wang <coolwanglu@gmail.com>

#include <cstdio>

#include <cstdlib>

#include <cstddef>

#include <cstring>

#include <ctime>

#include <string>

#include <limits>

#include <iostream>

#include <getopt.h>

#include <poppler-config.h>

#include <goo/GooString.h>

#include <Object.h>

#include <PDFDoc.h>

#include <PDFDocFactory.h>

#include <GlobalParams.h>

#include "Param.h"

#include "pdf2htmlEX-config.h"

#include "HTMLRenderer_mp.h"

#include "util/ArgParser.h"

#include "util/path.h"

#include "util/ffw.h"

using namespace std;

using namespace pdf2htmlEX;

Param param;

ArgParser argparser;

void show_usage_and_exit(const char * dummy = nullptr)

{

cerr << "Usage: pdf2htmlEX [options] <input.pdf> [<output.html>]" << endl;

argparser.show_usage(cerr);

exit(EXIT_FAILURE);

}

void show_version_and_exit(const char * dummy = nullptr)

{

cerr << "pdftohtmlEX version " << PDF2HTMLEX_VERSION << endl;

cerr << "Copyright 2012,2013 Lu Wang <coolwanglu@gmail.com>" << endl;

cerr << "Libraries: ";

cerr << "poppler " << POPPLER_VERSION << ", ";

cerr << "libfontforge " << ffw_get_version() << endl;

cerr << "Default data-dir: " << PDF2HTMLEX_DATA_PATH << endl;

exit(EXIT_SUCCESS);

}

void parse_options (int argc, char **argv)

{

string deprecated_string;

argparser

// pages

.add("first-page,f", &param.first_page, 1, "first page to convert")

.add("last-page,l", &param.last_page, numeric_limits<int>::max(), "last page to convert")

// dimensions

.add("zoom", &param.zoom, 0, "zoom ratio", nullptr, true)

.add("fit-width", &param.fit_width, 0, "fit width to <fp> pixels", nullptr, true)

.add("fit-height", &param.fit_height, 0, "fit height to <fp> pixels", nullptr, true)

.add("use-cropbox", &param.use_cropbox, 0, "use CropBox instead of MediaBox")

.add("hdpi", &param.h_dpi, 144.0, "horizontal resolution for graphics in DPI")

.add("vdpi", &param.v_dpi, 144.0, "vertical resolution for graphics in DPI")

// output files

.add("single-html", &param.single_html, 1, "generate a single HTML file")

.add("split-pages", &param.split_pages, 0, "split pages into separate files")

.add("dest-dir", &param.dest_dir, ".", "specify destination directory")

.add("css-filename", &param.css_filename, "", "filename of the generated css file")

.add("outline-filename", &param.outline_filename, "", "filename of the generated outline file")

// fonts

.add("embed-base-font", &param.embed_base_font, 0, "embed local match for standard 14 fonts")

.add("embed-external-font", &param.embed_external_font, 0, "embed local match for external fonts")

.add("font-suffix", &param.font_suffix, ".ttf", "suffix for embedded font files (.ttf,.otf,.woff,.svg)")

.add("decompose-ligature", &param.decompose_ligature, 0, "decompose ligatures, such as \uFB01 -> fi")

.add("remove-unused-glyph", &param.remove_unused_glyph, 1, "remove unused glyphs in embedded fonts")

.add("auto-hint", &param.auto_hint, 0, "use fontforge autohint on fonts without hints")

.add("external-hint-tool", &param.external_hint_tool, "", "external tool for hinting fonts (overrides --auto-hint)")

.add("stretch-narrow-glyph", &param.stretch_narrow_glyph, 0, "stretch narrow glyphs instead of padding them")

.add("squeeze-wide-glyph", &param.squeeze_wide_glyph, 1, "shrink wide glyphs instead of truncating them")

// text

.add("heps", &param.h_eps, 1.0, "horizontal threshold for merging text, in pixels")

.add("veps", &param.v_eps, 1.0, "vertical threshold for merging text, in pixels")

.add("space-threshold", &param.space_threshold, (1.0/8), "word break threshold (threshold * em)")

.add("font-size-multiplier", &param.font_size_multiplier, 4.0, "a value greater than 1 increases the rendering accuracy")

.add("space-as-offset", &param.space_as_offset, 0, "treat space characters as offsets")

.add("tounicode", &param.tounicode, 0, "how to handle ToUnicode CMaps (0=auto, 1=force, -1=ignore)")

// encryption

.add("owner-password,o", &param.owner_password, "", "owner password (for encrypted files)", nullptr, true)

.add("user-password,u", &param.user_password, "", "user password (for encrypted files)", nullptr, true)

.add("no-drm", &param.no_drm, 0, "override document DRM settings")

// misc.

.add("clean-tmp", &param.clean_tmp, 1, "remove temporary files after conversion")

.add("process-nontext", &param.process_nontext, 1, "render graphics in addition to text")

.add("data-dir", &param.data_dir, PDF2HTMLEX_DATA_PATH, "specify data directory")

.add("css-draw", &param.css_draw, 0, "[experimental and unsupported] CSS drawing")

.add("debug", &param.debug, 0, "print debugging information")

// meta

.add("version,v", "print copyright and version info", &show_version_and_exit)

.add("help,h", "print usage information", &show_usage_and_exit)

// multipages

.add("dump-mediabox", &param.dump_mediabox, 0, "dump mediaboxes of each page")

.add("set-mediabox", &param.set_mediabox, "", "specify new mediabox for each page, format \"x1 y1 x2 y2\"")

.add("group-by-outline", &param.group_by_outline, 0, "group pages according to the outline")

.add("", &param.input_filename, "", "")

.add("", &param.output_filename, "", "")

// deprecated

.add("font-format", &deprecated_string, "", "", [] (const char*) {

cerr << "warning: --font-format is deprecated, @font-face format is inferred from --font-suffix" << endl;

})

;

try

{

argparser.parse(argc, argv);

}

catch(const char * s)

{

// if s == "", getopt_long would have printed the error message

if(s && s[0])

{

cerr << "Error when parsing the arguments:" << endl;

cerr << s << endl;

}

exit(EXIT_FAILURE);

}

catch(const std::string & s)

{

// if s == "", getopt_long would have printed the error message

if(s != "")

{

cerr << "Error when parsing the arguments:" << endl;

cerr << s << endl;

}

exit(EXIT_FAILURE);

}

}

int main(int argc, char **argv)

{

parse_options(argc, argv);

if (param.input_filename == "")

{

show_usage_and_exit();

}

//prepare the directories

{

char buf[] = "/tmp/pdf2htmlEX-XXXXXX";

auto p = mkdtemp(buf);

if(p == nullptr)

{

cerr << "Cannot create temp directory" << endl;

exit(EXIT_FAILURE);

}

param.tmp_dir = buf;

}

if(param.debug)

cerr << "temporary dir: " << (param.tmp_dir) << endl;

try

{

create_directories(param.dest_dir);

}

catch (const string & s)

{

cerr << s << endl;

exit(EXIT_FAILURE);

}

bool finished = false;

// read config file

globalParams = new GlobalParams();

// open PDF file

PDFDoc *doc = nullptr;

try

{

{

GooString * ownerPW = (param.owner_password == "") ? (nullptr) : (new GooString(param.owner_password.c_str()));

GooString * userPW = (param.user_password == "") ? (nullptr) : (new GooString(param.user_password.c_str()));

GooString fileName(param.input_filename.c_str());

doc = PDFDocFactory().createPDFDoc(fileName, ownerPW, userPW);

delete userPW;

delete ownerPW;

}

if (!doc->isOk()) {

throw "Cannot read the file";

}

// check for copy permission

if (!doc->okToCopy()) {

if (param.no_drm == 0) {

throw "Copying of text from this document is not allowed.";

}

cerr << "Document has copy-protection bit set." << endl;

}

param.first_page = min<int>(max<int>(param.first_page, 1), doc->getNumPages());

param.last_page = min<int>(max<int>(param.last_page, param.first_page), doc->getNumPages());

if(param.output_filename.empty())

{

const string s = get_filename(param.input_filename);

if(get_suffix(param.input_filename) == ".pdf")

{

if(param.split_pages)

param.output_filename = s.substr(0, s.size() - 4);

else

param.output_filename = s.substr(0, s.size() - 4) + ".html";

}

else

{

if(param.split_pages)

param.output_filename = s;

else

param.output_filename = s + ".html";

}

}

if(param.css_filename.empty())

{

const string s = get_filename(param.input_filename);

if(get_suffix(param.input_filename) == ".pdf")

{

param.css_filename = s.substr(0, s.size() - 4) + ".css";

}

else

{

if(!param.split_pages)

param.css_filename = s + ".css";

}

}

if(param.outline_filename.empty())

{

const string s = get_filename(param.input_filename);

if(get_suffix(param.input_filename) == ".pdf")

{

param.outline_filename = s.substr(0, s.size() - 4) + ".outline";

}

else

{

if(!param.split_pages)

param.outline_filename = s + ".outline";

}

}

HTMLRenderer_mp * htmlOut = new HTMLRenderer_mp(&param);

htmlOut->process(doc);

delete htmlOut;

finished = true;

}

catch (const char * s)

{

cerr << "Error: " << s << endl;

}

catch (const string & s)

{

cerr << "Error: " << s << endl;

}

// clean up

if(doc) delete doc;

if(globalParams) delete globalParams;

// check for memory leaks

Object::memCheck(stderr);

gMemReport(stderr);

exit(finished ? (EXIT_SUCCESS) : (EXIT_FAILURE));

return 0;

}