fs_convert.h

浏览该文件的文档.

#ifndef FS_CONVERT_H_
#define FS_CONVERT_H_

#include "common/fs_common.h"
#include "pdf/fs_pdfdoc.h"
#include "pdf/fs_pdfpage.h"

namespace foxit {
namespace addon {
namespace conversion {
class HTML2PDFSettingData  FS_FINAL : public Object{
 public:
  typedef enum _HTML2PDFPageMode {
    e_PageModeSinglePage  = 0,
    e_PageModeMultiplePage = 1
  } HTML2PDFPageMode;
  
  typedef enum _HTML2PDFScalingMode {
    e_ScalingModeNone  = 0,
    e_ScalingModeScale = 1,
    e_ScalingModeEnlarge = 2
  } HTML2PDFScalingMode;
  
  typedef enum _HTML2PDFEncodingFormat {
    e_EncodingFormatDefault  = 0,
    e_EncodingFormatASCII = 1,
    e_EncodingFormatLatin2 = 2,
    e_EncodingFormatLatin3  = 3,
    e_EncodingFormatLatin4 = 4,
    e_EncodingFormatLatin5  = 5,
    e_EncodingFormatLatin6 = 6,
    e_EncodingFormatISO_8859_5 = 7,
    e_EncodingFormatArabic = 8,
    e_EncodingFormatGreek = 9,
    e_EncodingFormatHebrew = 10,
    e_EncodingFormatEUC_JP = 11,
    e_EncodingFormatSJS  = 12,
    e_EncodingFormatJIS = 13,
    e_EncodingFormatBIG5 = 14,
    e_EncodingFormatGB  = 15,
    e_EncodingFormatEUC_CN = 16,
    e_EncodingFormatKSC = 17,
    e_EncodingFormatUnicode  = 18,
    e_EncodingFormatEUC = 19,
    e_EncodingFormatCNS = 20,
    e_EncodingFormatBIG5_CP950  = 21,
    e_EncodingFormatASCII_7_bit = 22,
    e_EncodingFormatKOI8R = 23,
    e_EncodingFormatCP852 = 24,
    e_EncodingFormatCP866 = 25,
    e_EncodingFormatCP874 = 26,
    e_EncodingFormatCP932 = 27,
    e_EncodingFormatCP1250  = 28,
    e_EncodingFormatCP1251  = 29,
    e_EncodingFormatCP1252 = 30,
    e_EncodingFormatCP1253  = 31,
    e_EncodingFormatCP1254 = 32,
    e_EncodingFormatCP1255 = 33,
    e_EncodingFormatCP1256  = 34,
    e_EncodingFormatCP1257  = 35,
    e_EncodingFormatKOI8U = 36,
    e_EncodingFormatISO_8859_15 = 37,
    e_EncodingFormatISO_8859_11 = 38,
    e_EncodingFormatISO_8859_8_I = 39,
    e_EncodingFormatVISUAL  = 40,
    e_EncodingFormatCSN_369103 = 41,
    e_EncodingFormatISO_8859_13 = 42,
    e_EncodingFormatISO_2022_KR  = 43,
    e_EncodingFormatGBK = 44,
    e_EncodingFormatGB18030 = 45,
    e_EncodingFormatBIG5_HKSCS  = 46,
    e_EncodingFormatISO_2022_CN = 47,
    e_EncodingFormatTSCII = 48,
    e_EncodingFormatTAM  = 49,
    e_EncodingFormatTAB = 50,
    e_EncodingFormatJAGRAN = 51,
    e_EncodingFormatMACINTOSH  = 52,
    e_EncodingFormatUTF7 = 53,
    e_EncodingFormatBHASKAR = 54,
    e_EncodingFormatHTCHANAKYA  = 55,
    e_EncodingFormatUTF_16BE = 56,
    e_EncodingFormatUTF_16LE = 57,
    e_EncodingFormatUTF_32BE  = 58,
    e_EncodingFormatUTF_32LE = 59,
    e_EncodingFormatX_BINARYENC = 60,
    e_EncodingFormatHZ_GB_2312  = 61,
    e_EncodingFormatX_UTF8UTF8 = 62,
    e_EncodingFormatX_TAM_ELANGO = 63,
    e_EncodingFormatX_TAM_LTTMBARANI = 64,
    e_EncodingFormatX_TAM_SHREE = 65,
    e_EncodingFormatX_TAM_TBOOMIS = 66,
    e_EncodingFormatX_TAM_TMNEWS = 67,
    e_EncodingFormatX_TAM_WEBTAMIL  = 68,
    e_EncodingFormatX_KDDI_Shift_JIS = 69,
    e_EncodingFormatX_DoCoMo_Shift_JIS = 70,
    e_EncodingFormatX_SoftBank_Shift_JIS  = 71,
    e_EncodingFormatX_KDDI_ISO_2022_JP = 72,
    e_EncodingFormatX_SoftBank_ISO_2022_JP = 73
  } HTML2PDFEncodingFormat;
  
  typedef enum _HTML2PDFMediaStyle {
    e_MediaStyleScreen  = 0,
    e_MediaStylePrint  = 1
  } HTML2PDFMediaStyle;
  

  HTML2PDFSettingData()
    : page_width(0)
    , page_height(0)
    , is_to_page_scale(false)
    , page_margin(0.0f, 0.0f, 0.0f, 0.0f)
    , rotate_degrees(common::e_Rotation0)
    , is_convert_link(false)
    , is_generate_tag(false)
    , page_mode(e_PageModeSinglePage)
    , to_generate_bookmarks(false)
    , scaling_mode(e_ScalingModeScale)
    , encoding_format(e_EncodingFormatDefault)
    , to_render_images(true) 
    , to_remove_underline_for_link(false)
    , to_set_headerfooter(false)
    , headerfooter_title(L"")
    , headerfooter_url(L"")
    , bookmark_root_name(L"")
    , to_resize_objects(false) 
    , to_print_background(true)
    , to_optimize_tag_tree(false)
    , media_style(e_MediaStyleScreen)
    , to_load_active_content(false)
    , to_disable_sandbox(true)
    , to_use_blacklist(false)
    , to_hide_header(false)
    , to_hide_footer(false)
    , to_deny_local_file_access(false) {}

  HTML2PDFSettingData(float page_width, float page_height, bool is_to_page_scale, RectF page_margin,
      bool is_convert_link, common::Rotation rotate_degrees, bool is_generate_tag, HTML2PDFPageMode page_mode, bool to_generate_bookmarks, HTML2PDFScalingMode scaling_mode,
      HTML2PDFEncodingFormat encoding_format, bool to_render_images, bool to_remove_underline_for_link, bool to_set_headerfooter, const wchar_t* headerfooter_title, 
      const wchar_t* headerfooter_url, const wchar_t* bookmark_root_name, bool to_resize_objects, bool to_print_background, bool to_optimize_tag_tree,
      HTML2PDFMediaStyle media_style, bool to_load_active_content, bool to_disable_sandbox, bool to_use_blacklist,
      bool to_hide_header, bool to_hide_footer, bool to_deny_local_file_access) {
    this->page_width = page_width;
    this->page_height = page_height;
    this->is_to_page_scale = is_to_page_scale;
    this->page_margin = page_margin;
    this->is_convert_link = is_convert_link;
    this->rotate_degrees = rotate_degrees;
    this->is_generate_tag = is_generate_tag;
    this->page_mode = page_mode;
    this->to_generate_bookmarks = to_generate_bookmarks;
    this->scaling_mode = scaling_mode;
    this->encoding_format = encoding_format;
    this->to_render_images = to_render_images;
    this->to_remove_underline_for_link = to_remove_underline_for_link;
    this->to_set_headerfooter = to_set_headerfooter;
    this->headerfooter_title = headerfooter_title;
    this->headerfooter_url = headerfooter_url;
    this->bookmark_root_name = bookmark_root_name;
    this->to_resize_objects = to_resize_objects;
    this->to_print_background = to_print_background;
    this->to_optimize_tag_tree = to_optimize_tag_tree;
    this->media_style = media_style;
    this->to_load_active_content = to_load_active_content;
    this->to_disable_sandbox = to_disable_sandbox;
    this->to_use_blacklist = to_use_blacklist;
    this->to_hide_header = to_hide_header;
    this->to_hide_footer = to_hide_footer;
    this->to_deny_local_file_access = to_deny_local_file_access;
  }

  HTML2PDFSettingData &operator = (const HTML2PDFSettingData& data) {
    page_width = data.page_width;
    page_height = data.page_height;
    is_to_page_scale = data.is_to_page_scale;
    page_margin = data.page_margin;
    is_convert_link = data.is_convert_link;
    rotate_degrees = data.rotate_degrees;
    is_generate_tag = data.is_generate_tag;
    page_mode = data.page_mode;
    to_generate_bookmarks = data.to_generate_bookmarks;
    scaling_mode = data.scaling_mode;
    encoding_format = data.encoding_format;
    to_render_images = data.to_render_images;
    to_remove_underline_for_link = data.to_remove_underline_for_link;
    to_set_headerfooter = data.to_set_headerfooter;
    headerfooter_title = data.headerfooter_title;
    headerfooter_url = data.headerfooter_url;
    bookmark_root_name = data.bookmark_root_name;
    to_resize_objects = data.to_resize_objects;
    to_print_background = data.to_print_background;
    to_optimize_tag_tree = data.to_optimize_tag_tree;
    media_style = data.media_style;
    to_load_active_content = data.to_load_active_content;
    to_disable_sandbox = data.to_disable_sandbox;
    to_use_blacklist = data.to_use_blacklist;
    to_hide_header = data.to_hide_header;
    to_hide_footer = data.to_hide_footer;
    to_deny_local_file_access = data.to_deny_local_file_access;
    return (*this);
  }

  void Set(float page_width, float page_height, bool is_to_page_scale, RectF page_margin,
      bool is_convert_link, common::Rotation rotate_degrees, bool is_generate_tag, HTML2PDFPageMode page_mode, bool to_generate_bookmarks, HTML2PDFScalingMode scaling_mode,
      HTML2PDFEncodingFormat encoding_format, bool to_render_images, bool to_remove_underline_for_link, bool to_set_headerfooter, 
      const wchar_t* headerfooter_title, const wchar_t* headerfooter_url, const wchar_t* bookmark_root_name, bool to_resize_objects, bool to_print_background, bool to_optimize_tag_tree,
      HTML2PDFMediaStyle media_style, bool to_load_active_content, bool to_disable_sandbox, bool to_use_blacklist,
      bool to_hide_header, bool to_hide_footer, bool to_deny_local_file_access) {
    this->page_width = page_width;
    this->page_height = page_height;
    this->is_to_page_scale = is_to_page_scale;
    this->page_margin = page_margin;
    this->is_convert_link = is_convert_link;
    this->rotate_degrees = rotate_degrees;
    this->is_generate_tag = is_generate_tag;
    this->page_mode = page_mode;
    this->to_generate_bookmarks = to_generate_bookmarks;
    this->scaling_mode = scaling_mode;
    this->encoding_format = encoding_format;
    this->to_render_images = to_render_images;
    this->to_remove_underline_for_link = to_remove_underline_for_link;
    this->to_set_headerfooter = to_set_headerfooter;
    this->headerfooter_title = headerfooter_title;
    this->headerfooter_url = headerfooter_url;
    this->bookmark_root_name = bookmark_root_name;
    this->to_resize_objects = to_resize_objects;
    this->to_print_background = to_print_background;
    this->to_optimize_tag_tree = to_optimize_tag_tree;
    this->media_style = media_style;
    this->to_load_active_content = to_load_active_content;
    this->to_disable_sandbox = to_disable_sandbox;
    this->to_use_blacklist = to_use_blacklist;
    this->to_hide_header = to_hide_header;
    this->to_hide_footer = to_hide_footer;
    this->to_deny_local_file_access = to_deny_local_file_access;
  }

  float page_width;

  float page_height;

  bool is_to_page_scale;

  RectF page_margin;

  common::Rotation rotate_degrees;

  bool is_convert_link;

  bool is_generate_tag;

  HTML2PDFPageMode page_mode;

  bool to_generate_bookmarks;

  HTML2PDFScalingMode scaling_mode;

  HTML2PDFEncodingFormat encoding_format;

  bool to_render_images;

  bool to_remove_underline_for_link;

  bool to_set_headerfooter;

  foxit::WString headerfooter_title;

  foxit::WString headerfooter_url;

  foxit::WString bookmark_root_name;

  bool to_resize_objects;

  bool to_print_background;

  bool to_optimize_tag_tree;

  HTML2PDFMediaStyle media_style;

  bool to_load_active_content;

  bool to_disable_sandbox;

  bool to_use_blacklist;

  bool to_hide_header;

  bool to_hide_footer;

  bool to_deny_local_file_access;
};

class TXT2PDFSettingData FS_FINAL : public Object {
 public:
  TXT2PDFSettingData()
    : page_width(0)
    , page_height(0)
    , text_size(0)
    , text_color(0xFF000000)
    , linespace(0)
    , is_break_page(false) {
  }

  TXT2PDFSettingData(float page_width, float page_height, RectF page_margin, const common::Font& font, float text_size,
                     ARGB text_color, float linespace, bool is_break_page) {
    this->page_width = page_width;
    this->page_height = page_height;
    this->page_margin = page_margin;
    this->font = font;
    this->text_size = text_size;
    this->text_color = text_color;
    this->linespace = linespace;
    this->is_break_page = is_break_page;
  }

  TXT2PDFSettingData& operator=(const TXT2PDFSettingData& data) {
    page_width = data.page_width;
    page_height = data.page_height;
    page_margin = data.page_margin;
    font = data.font;
    text_size = data.text_size;
    text_color = data.text_color;
    linespace = data.linespace;
    is_break_page = data.is_break_page;
    return (*this);
  }

  void Set(float page_width, float page_height, RectF page_margin, const common::Font& font, float text_size,
           ARGB text_color, float linespace, bool is_break_page) {
    this->page_width = page_width;
    this->page_height = page_height;
    this->page_margin = page_margin;
    this->font = font;
    this->text_size = text_size;
    this->text_color = text_color;
    this->linespace = linespace;
    this->is_break_page = is_break_page;
  }

  float page_width;

  float page_height;

  RectF page_margin;

  common::Font font;

  float text_size;

  ARGB text_color;

  float linespace;

  bool is_break_page;
};

class DWG2PDFProgressCallback {
 public:
  virtual void Release() = 0;
  virtual void OnProgress(const wchar_t* message, float progress) = 0;
 };

class DWG2PDFSettingData FS_FINAL : public Object {
 public:
  typedef enum _DWG2PDFExportFlags {
    e_FlagEmbededTTF = 0x0001,
    e_FlagTTFTextAsGeometry = 0x0002,
    e_FlagSHXTextAsGeometry = 0x0004,
    e_FlagSimpleGeomOptimization = 0x0008,
    e_FlagEnableLayers = 0x0010,
    e_FlagIncludeOffLayers = 0x0020,
    e_FlagEmbededOptimizedTTF = 0x0040,
    e_FlagUseHLR = 0x0080,
    e_FlagFlateCompression = 0x0100,
    e_FlagASCIIHexEncoding = 0x0200,
    e_FlagExportHyperlinks = 0x0400,
    e_FlagZoomToExtentsMode = 0x0800,
    e_FlagLinearized = 0x1000,
    e_FlagMeasuring = 0x4000
  } DWG2PDFExportFlags;
  
  typedef enum _DWG2PDFExportHatchesType {
    e_DWG2PDFExportHatchesTypeBitmap  = 0,
    e_DWG2PDFExportHatchesTypeDrawing  = 1,
    e_DWG2PDFExportHatchesTypePdfPaths  = 2,
    e_DWG2PDFExportHatchesTypePolygons  = 3
  } DWG2PDFExportHatchesType;
  
  typedef enum _DWG2PDFSearchableTextType {
    e_DWG2PDFSearchableTextTypeNoSearch  = 0,
    e_DWG2PDFSearchableTextTypeSHX  = 1,
    e_DWG2PDFSearchableTextTypeTTF  = 2
  } DWG2PDFSearchableTextType;
  
  typedef enum _DWG2PDFColorPolicy {
    e_DWG2PDFColorPolicyNoPolicy = 0,
    e_DWG2PDFColorPolicyMono = 1,
    e_DWG2PDFColorPolicyGrayscale = 2,
    e_DWG2PDFColorPolicyIndexToBlack = 3
  } DWG2PDFColorPolicy;
  
  typedef enum _DWG2PDFLayoutScope {
    e_DWG2PDFLayoutScopeModelSpaceOnly = 0,
    e_DWG2PDFLayoutScopeCurrentLayout = 1,
    e_DWG2PDFLayoutScopeAllLayouts = 2,
    e_DWG2PDFLayoutScopeModelSpaceAndLayouts = 3,
    e_DWG2PDFLayoutScopeFrameBlocks = 4,
    e_DWG2PDFLayoutScopeDrawingLimits = 5,
    e_DWG2PDFLayoutScopeAutoByLayoutOverflow = 6,
    e_DWG2PDFLayoutScopeAutoRects = 7,
    e_DWG2PDFLayoutScopeLayoutByIndex = 8,
    e_DWG2PDFLayoutScopeAutoRectsAndAllLayouts = 9
  } DWG2PDFLayoutScope;
  
  typedef enum _DWG2PDFLineweightStyleMode {
    e_DWG2PDFLineweightStyleModeNoStyleNoLineweight = 0,
    e_DWG2PDFLineweightStyleModeStyleAndLineweight = 1,
    e_DWG2PDFLineweightStyleModeStyleNoLineweight = 2
  } DWG2PDFLineweightStyleMode;
  

  DWG2PDFSettingData()
      : export_flags(1)
      , export_hatches_type(e_DWG2PDFExportHatchesTypePolygons)
      , other_export_hatches_type(e_DWG2PDFExportHatchesTypeBitmap)
      , gradient_export_hatches_type(e_DWG2PDFExportHatchesTypeBitmap)
      , searchable_text_type(e_DWG2PDFSearchableTextTypeNoSearch)
      , is_active_layout(false)
      , paper_width(0.0f)
      , paper_height(0.0f)
      , color_policy(e_DWG2PDFColorPolicyNoPolicy)
      , is_output_progress(true)
      , progress_callback(NULL)
      , geometry_output_dpi(400)
      , color_image_output_dpi(400)
      , monochrome_image_output_dpi(400)
      , background_color_index(7)
      , layout_scope(e_DWG2PDFLayoutScopeCurrentLayout)
      , layout_index(1)
      , lineweight_style_mode(e_DWG2PDFLineweightStyleModeNoStyleNoLineweight)
      , plot_scale_factor(0.99)
      , page_margin(0)
      , lineweight_scale_factor(1.0)
      , maximum_drawing_area(0.0)
      , minimum_export_rect_side_length(0.0)
      , treat_inches_as_millimeters(false)
      , enable_diagnostic_log_output(false) {}

  DWG2PDFSettingData& operator=(const DWG2PDFSettingData& data) {
    export_flags = data.export_flags;
    export_hatches_type = data.export_hatches_type;
    other_export_hatches_type = data.other_export_hatches_type;
    gradient_export_hatches_type = data.gradient_export_hatches_type;
    searchable_text_type = data.searchable_text_type;
    is_active_layout = data.is_active_layout;
    output_title = data.output_title;
    output_author = data.output_author;
    output_subject = data.output_subject;
    output_keywords = data.output_keywords;
    output_creator = data.output_creator;
    output_producer = data.output_producer;
    paper_width = data.paper_width;
    paper_height = data.paper_height;
    color_policy = data.color_policy;
    is_output_progress = data.is_output_progress;
    progress_callback = data.progress_callback;
    geometry_output_dpi = data.geometry_output_dpi;
    color_image_output_dpi = data.color_image_output_dpi;
    monochrome_image_output_dpi = data.monochrome_image_output_dpi;
    background_color_index = data.background_color_index;
    layout_scope = data.layout_scope;
    layout_index = data.layout_index;
    lineweight_style_mode = data.lineweight_style_mode;
    plot_scale_factor = data.plot_scale_factor;
    page_margin = data.page_margin;
    lineweight_scale_factor = data.lineweight_scale_factor;
    drawing_size_block_reference_name = data.drawing_size_block_reference_name;
    maximum_drawing_area = data.maximum_drawing_area;
    minimum_export_rect_side_length = data.minimum_export_rect_side_length;
    frame_block_configuration_path = data.frame_block_configuration_path;
    treat_inches_as_millimeters = data.treat_inches_as_millimeters;
    enable_diagnostic_log_output = data.enable_diagnostic_log_output;
    return (*this);
  }

  uint32 export_flags;

  DWG2PDFExportHatchesType export_hatches_type;

  DWG2PDFExportHatchesType other_export_hatches_type;

  DWG2PDFExportHatchesType gradient_export_hatches_type;

  DWG2PDFSearchableTextType searchable_text_type;

  bool is_active_layout;

  foxit::WString output_title;

  foxit::WString output_author;

  foxit::WString output_subject;

  foxit::WString output_keywords;

  foxit::WString output_creator;

  foxit::WString output_producer;

  float paper_width;

  float paper_height;

  DWG2PDFColorPolicy color_policy;

  bool is_output_progress;

  void* progress_callback;

  int32 geometry_output_dpi;

  int32 color_image_output_dpi;

  int32 monochrome_image_output_dpi;

  int32 background_color_index;

  DWG2PDFLayoutScope layout_scope;

  int32 layout_index;

  DWG2PDFLineweightStyleMode lineweight_style_mode;

  double plot_scale_factor;

  int32 page_margin;

  double lineweight_scale_factor;

  foxit::WString drawing_size_block_reference_name;

  double maximum_drawing_area;

  double minimum_export_rect_side_length;

  foxit::WString frame_block_configuration_path;

  bool treat_inches_as_millimeters;

  bool enable_diagnostic_log_output;
};

#if defined(_WIN32) || defined(_WIN64) || defined(__linux__)

class Word2PDFSettingData FS_FINAL : public Object{
 public:
  typedef enum _ConvertOptimizeOption {
    e_ConvertOptimizeOptionForPrint  = 0,
    e_ConvertOptimizeOptionForOnScreen = 1
  } ConvertOptimizeOption;
  
  typedef enum _ConvertContentOption {
    e_ConvertContentOptionOnlyContent  = 0,
    e_ConvertContentOptionWithMarkup = 1
  } ConvertContentOption;
  
  typedef enum _ConvertBookmarkOption {
    e_ConvertBookmarkOptionNone  = 0,
    e_ConvertBookmarkOptionUseHeadings = 1,
    e_ConvertBookmarkOptionUseWordBookmark = 2
  } ConvertBookmarkOption;
  

  Word2PDFSettingData()
      : include_doc_props(false)
      , optimize_option(Word2PDFSettingData::e_ConvertOptimizeOptionForPrint)
      , content_option(Word2PDFSettingData::e_ConvertContentOptionOnlyContent)
      , bookmark_option(Word2PDFSettingData::e_ConvertBookmarkOptionNone)
      , convert_to_pdfa(false)
      , disable_vba_code(false)
  {}

  Word2PDFSettingData(bool include_doc_props, ConvertOptimizeOption optimize_option,
                      ConvertContentOption content_option, ConvertBookmarkOption bookmark_option,
                      bool convert_to_pdfa, bool disable_vba_code) {
    this->include_doc_props = include_doc_props;
    this->optimize_option = optimize_option;
    this->content_option = content_option;
    this->bookmark_option = bookmark_option;
    this->convert_to_pdfa = convert_to_pdfa;
    this->disable_vba_code = disable_vba_code;
  }

  Word2PDFSettingData &operator = (const Word2PDFSettingData& data) {
    include_doc_props = data.include_doc_props;
    optimize_option = data.optimize_option;
    content_option = data.content_option;
    bookmark_option = data.bookmark_option;
    convert_to_pdfa = data.convert_to_pdfa;
    disable_vba_code = data.disable_vba_code;
    return (*this);
  }

  void Set(bool include_doc_props, ConvertOptimizeOption optimize_option,
           ConvertContentOption content_option, ConvertBookmarkOption bookmark_option,
           bool convert_to_pdfa, bool disable_vba_code) {
    this->include_doc_props = include_doc_props;
    this->optimize_option = optimize_option;
    this->content_option = content_option;
    this->bookmark_option = bookmark_option;
    this->convert_to_pdfa = convert_to_pdfa;
    this->disable_vba_code = disable_vba_code;
  }

  bool include_doc_props;

  ConvertOptimizeOption optimize_option;

  ConvertContentOption content_option;

  ConvertBookmarkOption bookmark_option;

  bool convert_to_pdfa;

  bool disable_vba_code;
};

class Excel2PDFSettingData FS_FINAL : public Object{
 public:
  typedef enum _ConvertQuality {
    e_ConvertQualityStandard  = 0,
    e_ConvertQualityMinimum = 1
  } ConvertQuality;
  
  typedef enum _ScaleType {
    e_ScaleTypeNone  = 0,
    e_ScaleTypeFitAllColumns = 1,
    e_ScaleTypeFitAllRows = 2,
    e_ScaleTypeFitSheet = 3
  } ScaleType;
  

  Excel2PDFSettingData()
      : include_doc_props(false)
      , quality(Excel2PDFSettingData::e_ConvertQualityStandard)
      , ignore_print_area(true)
      , scale_type(Excel2PDFSettingData::e_ScaleTypeNone)
      , convert_to_pdfa(false)
      , disable_vba_code(false)
  {}

  Excel2PDFSettingData(bool include_doc_props, ConvertQuality quality, bool ignore_print_area,
                       ScaleType scale_type, bool convert_to_pdfa, bool disable_vba_code) {
    this->include_doc_props = include_doc_props;
    this->quality = quality;
    this->ignore_print_area = ignore_print_area;
    this->scale_type = scale_type;
    this->convert_to_pdfa = convert_to_pdfa;
    this->disable_vba_code = disable_vba_code;
  }

  Excel2PDFSettingData &operator = (const Excel2PDFSettingData& data) {
    include_doc_props = data.include_doc_props;
    quality = data.quality;
    ignore_print_area = data.ignore_print_area;
    scale_type = data.scale_type;
    convert_to_pdfa = data.convert_to_pdfa;
    disable_vba_code = data.disable_vba_code;
    return (*this);
  }

  void Set(bool include_doc_props, ConvertQuality quality, bool ignore_print_area,
           ScaleType scale_type, bool convert_to_pdfa) {
    this->include_doc_props = include_doc_props;
    this->quality = quality;
    this->ignore_print_area = ignore_print_area;
    this->scale_type = scale_type;
    this->convert_to_pdfa = convert_to_pdfa;
    this->disable_vba_code = disable_vba_code;
  }

  bool include_doc_props;

  ConvertQuality quality;

  bool ignore_print_area;

  ScaleType scale_type;

  bool convert_to_pdfa;

  bool disable_vba_code;
};

class PowerPoint2PDFSettingData FS_FINAL : public Object{
 public:
  typedef enum _ConvertIntent {
    e_ConvertIntentPrint  = 0,
    e_ConvertIntentScreen = 1
  } ConvertIntent;
  
  typedef enum _HandoutOrder {
    e_HandoutOrderHorizontalFirst  = 0,
    e_HandoutOrderVerticalFirst = 1
  } HandoutOrder;
  
  typedef enum _OutputType {
    e_OutputSlides = 1,
    e_OutputNotesPages = 2,
    e_OutputOutline = 3,
    e_OutputOneSlideHandouts = 4,
    e_OutputTwoSlideHandouts = 5,
    e_OutputThreeSlideHandouts = 6,
    e_OutputFourSlideHandouts = 7,
    e_OutputSixSlideHandouts = 8,
    e_OutputNineSlideHandouts = 9
  } OutputType;
  

  PowerPoint2PDFSettingData()
    : intent(PowerPoint2PDFSettingData::e_ConvertIntentPrint)
    , frame_output_slides(false)
    , output_type(PowerPoint2PDFSettingData::e_OutputSlides)
    , handout_order(PowerPoint2PDFSettingData::e_HandoutOrderVerticalFirst)
    , output_hidden_slides(false)
    , include_doc_props(false)
    , disable_vba_code(false)
  {}

  PowerPoint2PDFSettingData(ConvertIntent intent, bool frame_output_slides, OutputType output_type, HandoutOrder handout_order,
                            bool output_hidden_slides, bool include_doc_props, bool disable_vba_code) {
    this->intent = intent;
    this->frame_output_slides = frame_output_slides;
    this->handout_order = handout_order;
    this->output_hidden_slides = output_hidden_slides;
    this->output_type = output_type;
    this->include_doc_props = include_doc_props;
    this->disable_vba_code = disable_vba_code;
  }

  PowerPoint2PDFSettingData &operator = (const PowerPoint2PDFSettingData& data) {
    intent = data.intent;
    frame_output_slides = data.frame_output_slides;
    output_type = data.output_type;
    handout_order = data.handout_order;
    output_hidden_slides = data.output_hidden_slides;
    include_doc_props = data.include_doc_props;
    disable_vba_code = data.disable_vba_code;
    return (*this);
  }

  void Set(ConvertIntent intent, bool frame_output_slides, OutputType output_type, HandoutOrder handout_order,
           bool output_hidden_slides, bool include_doc_props, bool disable_vba_code) {
    this->intent = intent;
    this->frame_output_slides = frame_output_slides;
    this->output_type = output_type;
    this->handout_order = handout_order;
    this->output_hidden_slides = output_hidden_slides;
    this->include_doc_props = include_doc_props;
    this->disable_vba_code = disable_vba_code;
  }

  ConvertIntent intent;

  bool frame_output_slides;

  OutputType output_type;

  HandoutOrder handout_order;

  bool output_hidden_slides;

  bool include_doc_props;

  bool disable_vba_code;
};
#endif  // #if (defined(_WIN32) || defined(_WIN64))

class HTML2PDFRelatedResource FS_FINAL : public Object{
 public:
  HTML2PDFRelatedResource() 
    : related_resource_file(NULL)
    , resource_file_relative_path(L"") {
  }

  HTML2PDFRelatedResource(foxit::common::file::ReaderCallback* related_resource_file, foxit::WString resource_file_relative_path) {
    this->related_resource_file = related_resource_file;
    this->resource_file_relative_path = resource_file_relative_path;
  }

  HTML2PDFRelatedResource &operator = (const HTML2PDFRelatedResource& data) {
    related_resource_file = data.related_resource_file;
    resource_file_relative_path = data.resource_file_relative_path;
    return (*this);
  }

  foxit::common::file::ReaderCallback* related_resource_file;

  foxit::WString resource_file_relative_path;
};

FSDK_DEFINE_ARRAY(HTML2PDFRelatedResourceArray, HTML2PDFRelatedResource)


class Convert FS_FINAL : public Base {
 public:
    typedef enum _Office2PdfEngine {
      e_Office2PdfEngineMicrosoft = 0,
      e_Office2PdfEngineWps = 1
    } Office2PdfEngine;
    

   static void FromHTML(const wchar_t* src_html, const wchar_t* engine_path, const wchar_t* cookies_path, const HTML2PDFSettingData& setting_data, const wchar_t* saved_pdf_path, int32 timeout);

   static void FromHTML(const wchar_t* src_html, const wchar_t* engine_path, foxit::common::file::ReaderCallback* cookies_reader, const HTML2PDFSettingData& setting_data, const wchar_t* saved_pdf_path, int32 timeout);

   static void FromHTML(const wchar_t* src_html, const wchar_t* engine_path, foxit::common::file::ReaderCallback* cookies_reader, const HTML2PDFSettingData& setting_data, foxit::common::file::WriterCallback* saved_pdf_filestream, int32 timeout);

   static void FromHTML(foxit::common::file::ReaderCallback* src_html, const HTML2PDFRelatedResourceArray& html2pdf_related_resource_array, const wchar_t* engine_path, foxit::common::file::ReaderCallback* cookies_reader, const HTML2PDFSettingData& setting_data, foxit::common::file::WriterCallback* saved_pdf_filestream, int32 timeout);

   static void FromTXT(const wchar_t* src_txt, const wchar_t* saved_pdf_path, const TXT2PDFSettingData& setting_data);

   static void FromImage(const wchar_t* src_img, const wchar_t* saved_pdf_path);

   static void FromImage(foxit::common::file::ReaderCallback* file_reader, foxit::common::file::WriterCallback* saved_pdf_filestream);

   static bool FromDWG(const wchar_t* engine_path, const wchar_t* src_dwg_path, const wchar_t* saved_pdf_path,
                       const DWG2PDFSettingData& settings);

#if (defined(_WIN32) || defined(_WIN64))

   static void FromWord(const wchar_t* src_word_file_path, const wchar_t* src_file_password, const wchar_t* saved_pdf_path, const Word2PDFSettingData& setting_data, Office2PdfEngine engine= e_Office2PdfEngineMicrosoft);

   static void FromExcel(const wchar_t* src_excel_file_path, const wchar_t* src_file_password, const wchar_t* saved_pdf_path, const Excel2PDFSettingData& setting_data, Office2PdfEngine engine= e_Office2PdfEngineMicrosoft);

   static void FromPowerPoint(const wchar_t* src_ppt_file_path, const wchar_t* src_file_password, const wchar_t* saved_pdf_path, const PowerPoint2PDFSettingData& setting_data, Office2PdfEngine engine= e_Office2PdfEngineMicrosoft);

#elif defined(__linux__) && !(defined(__ANDROID__) || defined(_FS_IOS_) || defined(_SWIG_ANDROID_) || defined(_SWIG_IOS_))

   static void FromWord(const wchar_t* src_word_file_path, const wchar_t* src_file_password, const wchar_t* saved_pdf_path, const wchar_t* engine_path, const Word2PDFSettingData& setting_data, const wchar_t* fx_engine_path = L"", const wchar_t* specified_user_profile_path = L"");

   static void FromExcel(const wchar_t* src_excel_file_path, const wchar_t* src_file_password, const wchar_t* saved_pdf_path, const wchar_t* engine_path, const Excel2PDFSettingData& setting_data, const wchar_t* fx_engine_path = L"", const wchar_t* specified_user_profile_path = L"");

   static void FromPowerPoint(const wchar_t* src_ppt_file_path, const wchar_t* src_file_password, const wchar_t* saved_pdf_path, const wchar_t* engine_path, const PowerPoint2PDFSettingData& setting_data, const wchar_t* fx_engine_path = L"", const wchar_t* specified_user_profile_path = L"");
#endif

   static bool ToXML(const wchar_t* src_pdf_path, const wchar_t* src_file_password, const wchar_t* saved_xml_path, const wchar_t* saved_image_folder_path, bool is_force_to_tagged_pdf);

};

#if (defined(_WIN32) || defined(_WIN64)) || defined(__linux__) && defined(_BUILD_OFDSDK_)

class OFDConvertParam FS_FINAL : public Object{
 public:
   OFDConvertParam() : document_index(0)
                     , is_embed_font(false)
                     , ofd2pdf_sign_pic_red2black(false)
                     , dpi(96)
                     , dib_format(foxit::common::Bitmap::e_DIBArgb)
                     , jpg_quality(75)
                     , img_width(0.0)
                     , img_height(0.0)
                     , page_split_x_count(1)
                     , page_split_y_count(1)
                     , password("") {
   }

   OFDConvertParam(int document_index, bool is_embed_font, bool ofd2pdf_sign_pic_red2black, int dpi,
                   common::Bitmap::DIBFormat dib_format, int jpg_quality, float img_width, float img_height,
                   int page_split_x_count, int page_split_y_count, String password) {
     this->document_index = document_index;
     this->is_embed_font = is_embed_font;
     this->ofd2pdf_sign_pic_red2black = ofd2pdf_sign_pic_red2black;
     this->dpi = dpi;
     this->dib_format = dib_format;
     this->jpg_quality = jpg_quality;
     this->img_width = img_width;
     this->img_height = img_height;
     this->password = password;
   }

   void Set(int document_index, bool is_embed_font, bool ofd2pdf_sign_pic_red2black, int dpi,
            common::Bitmap::DIBFormat dib_format, int jpg_quality, float img_width, float img_height,
            int page_split_x_count, int page_split_y_count, String password) {
     this->document_index = document_index;
     this->is_embed_font = is_embed_font;
     this->ofd2pdf_sign_pic_red2black = ofd2pdf_sign_pic_red2black;
     this->dpi = dpi;
     this->dib_format = dib_format;
     this->jpg_quality = jpg_quality;
     this->img_width = img_width;
     this->img_height = img_height;
     this->password = password;
   }

   int                                  document_index;
   bool                                 is_embed_font;
   bool                                 ofd2pdf_sign_pic_red2black;

   int                                  dpi;
   common::Bitmap::DIBFormat            dib_format;
   int                                  jpg_quality;
   float                                img_width;
   float                                img_height;

   int                                  page_split_x_count;
   int                                  page_split_y_count;

   String                               password;
};

class OfdConvert FS_FINAL : public Base {
 public:
    static bool ToPdf(const wchar_t* src_ofd_path, const char* password, const wchar_t* saved_pdf_file_path, OFDConvertParam convert_param);

    static bool FromPdf(const wchar_t* src_pdf_path, const char* password, const wchar_t* saved_ofd_file_path, OFDConvertParam convert_param);

    static bool ToImage(const wchar_t* src_ofd_path, const char* password, const wchar_t* saved_img_file_path, OFDConvertParam convert_param, int page_index = 0);
};
#endif  // (defined(_WIN32) || defined(_WIN64)) || defined(__linux__) && defined(_BUILD_OFDSDK_)

}
}
}
#endif