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
  } DWG2PDFColorPolicy;
  
 
  DWG2PDFSettingData()
      : export_flags(1)
      , export_hatches_type(e_DWG2PDFExportHatchesTypeBitmap)
      , 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){}
 
  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;
    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;
};
 
#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)
 
#if (defined(_WIN32) || defined(_WIN64)) || defined(__linux__) 
 
class OFDConvertParam FS_FINAL : public Object{
 public:
   OFDConvertParam()
   :is_embed_font(false) {}
 
   OFDConvertParam(bool is_embed_font) {
     this->is_embed_font = is_embed_font;
   }
 
   void Set(bool is_embed_font) {
     this->is_embed_font = is_embed_font;
   }
 
   bool is_embed_font;
};
#endif
 
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__) 
 
   static bool FromOFD(const wchar_t* src_ofd_path, const wchar_t* password, const wchar_t* saved_pdf_file_path, OFDConvertParam convert_param);
 
   static bool ToOFD(const wchar_t* src_pdf_path, const wchar_t* password, const wchar_t* saved_ofd_file_path, OFDConvertParam convert_param);
#endif // #if (defined(_WIN32) || defined(_WIN64)) || defined(__linux__)
 
};
}
}
}
#endif