fs_actioncallback.h

浏览该文件的文档.

#ifndef FS_ACTIONCALLBACK_H_
#define FS_ACTIONCALLBACK_H_

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

namespace foxit {
class MenuList;
class MenuItemEx;
FSDK_DEFINE_ARRAY(MenuListArray, MenuList)
FSDK_DEFINE_ARRAY(MenuItemExArray, MenuItemEx)


class MenuList FS_FINAL : public Object {
 public:
  MenuList() : level(0) {}

  MenuList(int level, const wchar_t* name, MenuListArray sub_menu_list_array) {
    this->level = level;
    if (name)
      this->name = name;
    this->sub_menu_list_array = sub_menu_list_array;
  }

  MenuList(const MenuList& menu_list) {
    level = menu_list.level;
    name = menu_list.name;
    sub_menu_list_array = menu_list.sub_menu_list_array;
  }

  MenuList& operator = (const MenuList& menu_list) {
    this->level = menu_list.level;
    this->name = menu_list.name;
    this->sub_menu_list_array = menu_list.sub_menu_list_array;
    return *this;
  }

  void Set(int level, const wchar_t* name, MenuListArray sub_menu_list_array) {
    this->level = level;
    if (name)
      this->name = name;
    this->sub_menu_list_array = sub_menu_list_array;
  }

  int level;
  WString name;
  MenuListArray sub_menu_list_array;
};

class MenuItemEx FS_FINAL : public Object {
 public:
  MenuItemEx() {}

  MenuItemEx(const wchar_t* item_name, const wchar_t* return_name, bool is_checked, bool is_enabled, MenuItemExArray sub_menu_item_array) {
    if (item_name)
      this->item_name = item_name;
    if (return_name)
      this->return_name = return_name;
    this->is_checked = is_checked;
    this->is_enabled = is_enabled;
    this->sub_menu_item_array = sub_menu_item_array;
  }

  MenuItemEx(const MenuItemEx& menu_item) {
    item_name = menu_item.item_name;
    return_name = menu_item.return_name;
    is_checked = menu_item.is_checked;
    is_enabled = menu_item.is_enabled;
    sub_menu_item_array = menu_item.sub_menu_item_array;
  }

  MenuItemEx& operator = (const MenuItemEx& menu_item) {
    this->item_name = menu_item.item_name;
    this->return_name = menu_item.return_name;
    this->is_checked = menu_item.is_checked;
    this->is_enabled = menu_item.is_enabled;
    this->sub_menu_item_array = menu_item.sub_menu_item_array;
    return *this;
  }

  void Set(const wchar_t* item_name, const wchar_t* return_name, bool is_checked, bool is_enabled, MenuItemExArray sub_menu_item_array) {
    if (item_name)
      this->item_name = item_name;
    if (return_name)
      this->return_name = return_name;
    this->is_checked = is_checked;
    this->is_enabled = is_enabled;
    this->sub_menu_item_array = sub_menu_item_array;
  }

  WString item_name;

  WString return_name;

  bool is_checked;

  bool is_enabled;

  MenuItemExArray sub_menu_item_array;
};

class IdentityProperties FS_FINAL : public Object {
 public:
  IdentityProperties() {}

  IdentityProperties(const wchar_t* corporation, const wchar_t* email, const wchar_t* login_name, const wchar_t* name, const wchar_t* first_name,
                     const wchar_t* last_name, const wchar_t* title, const wchar_t* department)
      : corporation(corporation)
      , email(email)
      , login_name(login_name)
      , name(name)
      , first_name(first_name)
      , last_name(last_name)
      , title(title)
      , department(department){}

  IdentityProperties(const IdentityProperties& id_properities)
      : corporation(id_properities.corporation)
      , email(id_properities.email)
      , login_name(id_properities.login_name)
      , name(id_properities.name)
      , first_name(id_properities.first_name)
      , last_name(id_properities.last_name)
      , title(id_properities.title)
      , department(id_properities.department) {}

  void Set(const wchar_t* corporation, const wchar_t* email, const wchar_t* login_name, const wchar_t* name, const wchar_t* first_name,
    const wchar_t* last_name, const wchar_t* title, const wchar_t* department) {
    this->corporation = corporation;
    this->email = email;
    this->login_name = login_name;
    this->name = name;
    this->first_name = first_name;
    this->last_name = last_name;
    this->title = title;
    this->department = department;
  }

  WString corporation;
  WString email;
  WString login_name;
  WString name;
  WString first_name;
  WString last_name;
  WString title;
  WString department;
};

class ButtonItem FS_FINAL : public Object{
 public:
  ButtonItem() {}

  ButtonItem(const wchar_t* name, int pos,const wchar_t* exec, const wchar_t* enable,
    const wchar_t* marked,  const wchar_t* tooltip,  const wchar_t* label, const common::Bitmap& bitmap)
    : name(name)
    , pos(pos)
    , exec(exec)
    , enable(enable)
    , marked(marked)
    , tooltip(tooltip)
    , label(label)
    , bitmap(bitmap){}

  ButtonItem(const ButtonItem& button_item)
    : name(button_item.name)
    , pos(button_item.pos)
    , exec(button_item.exec)
    , enable(button_item.enable)
    , marked(button_item.marked)
    , tooltip(button_item.tooltip)
    , label(button_item.label)
    , bitmap(button_item.bitmap){}

  void Set(const wchar_t* name, int pos, const wchar_t* exec, const wchar_t* enable,
    const wchar_t* marked,  const wchar_t* tooltip,  const wchar_t* label, const common::Bitmap& bitmap) {
    this->name = name;
    this->pos = pos;
    this->exec = exec;
    this->enable = enable;
    this->marked = marked;
    this->tooltip = tooltip;
    this->label = label;
    this->bitmap = bitmap;
  }

  WString name;
  int pos;
  WString exec;
  WString enable;
  WString marked;
  WString tooltip;
  WString label;
  common::Bitmap bitmap;
};

class MenuItemConfig FS_FINAL : public Object{
 public:
  MenuItemConfig() {}

  MenuItemConfig(const wchar_t* name, const wchar_t* user, const wchar_t* parent, int pos, const char* pos_str,
    const wchar_t* exec, const wchar_t* enable, const wchar_t* marked)
    : name(name)
    , user(user)
    , parent(parent)
    , pos(pos)
    , pos_str(pos_str)
    , exec(exec)
    , enable(enable)
    , marked(marked) {}

  MenuItemConfig(const MenuItemConfig& menu_item_config)
    : name(menu_item_config.name)
    , user(menu_item_config.user)
    , parent(menu_item_config.parent)
    , pos(menu_item_config.pos)
    , pos_str(menu_item_config.pos_str)
    , exec(menu_item_config.exec)
    , enable(menu_item_config.enable)
    , marked(menu_item_config.marked) {}

  void Set(const wchar_t* name, const wchar_t* user, const wchar_t* parent, int pos, const char* pos_str,
    const wchar_t* exec, const wchar_t* enable, const wchar_t* marked) {
    this->name = name;
    this->user = user;
    this->parent = parent;
    this->pos = pos;
    this->pos_str = pos_str;
    this->exec = exec;
    this->enable = enable;
    this->marked = marked;
  }
  WString name;
  WString user;
  WString parent;
  int pos;
  String pos_str;
  WString exec;
  WString enable;
  WString marked;
};

class DialogDescriptionElement;
FSDK_DEFINE_ARRAY(DialogDescriptionElementArray, DialogDescriptionElement)


class DialogDescriptionElement FS_FINAL : public Object{
 public:
  DialogDescriptionElement() {}

  DialogDescriptionElement(const char* name, const char* item_id, const char* type, const char* next_tab, int width, int height, int char_width, int char_height,
     const char* font, bool bold, bool italic, const char* alignment, const char* align_children,  DialogDescriptionElementArray element_array)
    : name(name)
    , item_id(item_id)
    , type(type)
    , next_tab(next_tab)
    , width(width)
    , height(height)
    , char_width(char_width)
    , char_height(char_height)
    , font(font)
    , bold(bold)
    , italic(italic)
    , alignment(alignment)
    , align_children(align_children)
    , element_array(element_array) {}

  DialogDescriptionElement(const DialogDescriptionElement& dlg_des_element)
    : name(dlg_des_element.name)
    , item_id(dlg_des_element.item_id)
    , type(dlg_des_element.type)
    , next_tab(dlg_des_element.next_tab)
    , width(dlg_des_element.width)
    , height(dlg_des_element.height)
    , char_width(dlg_des_element.char_width)
    , char_height(dlg_des_element.char_height)
    , font(dlg_des_element.font)
    , bold(dlg_des_element.bold)
    , italic(dlg_des_element.italic)
    , alignment(dlg_des_element.alignment)
    , align_children(dlg_des_element.align_children)
    , element_array(dlg_des_element.element_array) {}

  DialogDescriptionElement& operator = (const DialogDescriptionElement& dlg_des_element) {
    this->name = dlg_des_element.name;
    this->item_id = dlg_des_element.item_id;
    this->type = dlg_des_element.type;
    this->next_tab = dlg_des_element.next_tab;
    this->width = dlg_des_element.width;
    this->height = dlg_des_element.height;
    this->char_width = dlg_des_element.char_width;
    this->char_height = dlg_des_element.char_height;
    this->font = dlg_des_element.font;
    this->bold = dlg_des_element.bold;
    this->italic = dlg_des_element.italic;
    this->alignment = dlg_des_element.alignment;
    this->align_children = dlg_des_element.align_children;
    this->element_array = dlg_des_element.element_array;
    return *this;
  }

  void Set(const char* name, const char* item_id, const char* type, const char* next_tab, int width, int height, int char_width, int char_height,
     const char* font, bool bold, bool italic, const char* alignment, const char* align_children,  DialogDescriptionElementArray element_array) {
    this->name = name;
    this->item_id = item_id;
    this->type = type;
    this->next_tab = next_tab;
    this->width = width;
    this->height = height;
    this->char_width = char_width;
    this->char_height = char_height;
    this->font = font;
    this->bold = bold;
    this->italic = italic;
    this->alignment = alignment;
    this->align_children = align_children;
    this->element_array = element_array;
  }

  String name;
  String item_id;
  String type;
  String next_tab;
  int width;

  int height;
  int char_width;
  int char_height;
  String font;
  bool bold;
  bool italic;
  String alignment;
  String align_children;
  DialogDescriptionElementArray element_array;
};

class DialogDescriptionConfig FS_FINAL : public Object{
 public:
  DialogDescriptionConfig() {}

  DialogDescriptionConfig(const char* name, const char* first_tab, int width, int height,
    int char_width, int char_height, const char* align_children,  DialogDescriptionElementArray element_array)
    : name(name)
    , first_tab(first_tab)
    , width(width)
    , height(height)
    , char_width(char_width)
    , char_height(char_height)
    , align_children(align_children)
    , element_array(element_array) {}

  DialogDescriptionConfig(const DialogDescriptionConfig& dlg_des_config)
    : name(dlg_des_config.name)
    , first_tab(dlg_des_config.first_tab)
    , width(dlg_des_config.width)
    , height(dlg_des_config.height)
    , char_width(dlg_des_config.char_width)
    , char_height(dlg_des_config.char_height)
    , align_children(dlg_des_config.align_children)
    , element_array(dlg_des_config.element_array) {}

  DialogDescriptionConfig& operator = (const DialogDescriptionConfig& dlg_des_config) {
    this->name = dlg_des_config.name;
    this->first_tab = dlg_des_config.first_tab;
    this->width = dlg_des_config.width;
    this->height = dlg_des_config.height;
    this->char_width = dlg_des_config.char_width;
    this->char_height = dlg_des_config.char_height;
    this->align_children = dlg_des_config.align_children;
    this->element_array = dlg_des_config.element_array;
    return *this;
  }

  void Set(const char* name, const char* first_tab, int width, int height, int char_width, int char_height,
    const char* align_children,  DialogDescriptionElementArray element_array) {
    this->name = name;
    this->first_tab = first_tab;
    this->width = width;
    this->height = height;
    this->char_width = char_width;
    this->char_height = char_height;
    this->align_children = align_children;
    this->element_array = element_array;
  }

  String name;

  String first_tab;

  int width;

  int height;

  int char_width;

  int char_height;

  String align_children;

  DialogDescriptionElementArray element_array;
};

class SOAPAuthenticateInfo FS_FINAL : public Object {
 public:
  SOAPAuthenticateInfo() {}

  SOAPAuthenticateInfo(const wchar_t* username, const wchar_t* password, bool is_use_platform_auth)
      : username(username)
      , password(password)
      , is_use_platform_auth(is_use_platform_auth){}

  SOAPAuthenticateInfo(const SOAPAuthenticateInfo& soap_authenticate)
      : username(soap_authenticate.username)
      , password(soap_authenticate.password)
      , is_use_platform_auth(soap_authenticate.is_use_platform_auth) {}

  void Set(const wchar_t* username, const wchar_t* password, bool is_use_platform_auth) {
    this->username = username;
    this->password = password;
    this->is_use_platform_auth = is_use_platform_auth;
  }

  WString username;
  WString password;
  bool is_use_platform_auth;
};

class SOAPRequestProperties FS_FINAL : public Object {
 public:
  SOAPRequestProperties() {}

  SOAPRequestProperties(const wchar_t* request_url, const char* request_content, const wchar_t* soap_action,
                        const wchar_t* soap_namespace, const wchar_t* soap_version, const wchar_t* content_type, bool is_encode,
                        bool is_wiredump, const char* request_header, const SOAPAuthenticateInfo& authenticate)
      : request_url(request_url)
      , request_content(request_content)
      , soap_action(soap_action)
      , soap_namespace(soap_namespace)
      , soap_version(soap_version)
      , content_type(content_type)
      , is_encode(is_encode)
      , is_wiredump(is_wiredump)
      , request_header(request_header) 
      , authenticate(authenticate) {}

  SOAPRequestProperties(const SOAPRequestProperties& request_properties)
      : request_url(request_properties.request_url)
      , request_content(request_properties.request_content)
      , soap_action(request_properties.soap_action)
      , soap_namespace(request_properties.soap_namespace)
      , soap_version(request_properties.soap_version)
      , content_type(request_properties.content_type)
      , is_encode(request_properties.is_encode)
      , is_wiredump(request_properties.is_wiredump) 
      , request_header(request_properties.request_header) 
      , authenticate(request_properties.authenticate) {}

  void Set(const wchar_t* request_url, const char* request_content, const wchar_t* soap_action, const wchar_t* soap_namespace,
           const wchar_t* soap_version, const wchar_t* content_type, bool is_encode, bool is_wiredump, const char* request_header,
           const SOAPAuthenticateInfo& authenticate) {
    this->request_url = request_url;
    this->request_content = request_content;
    this->soap_action = soap_action;
    this->soap_namespace = soap_namespace;
    this->soap_version = soap_version;
    this->content_type = content_type;
    this->is_encode = is_encode;
    this->is_wiredump = is_wiredump;
    this->request_header = request_header;
    this->authenticate = authenticate;
  }

  WString request_url;
  String request_content;
  WString soap_action;
  WString soap_namespace;
  WString soap_version;
  WString content_type;
  bool is_encode;
  bool is_wiredump;
  String request_header;
  SOAPAuthenticateInfo authenticate;
};

class SOAPResponseInfo FS_FINAL : public Object {
 public:
  SOAPResponseInfo() {}

  SOAPResponseInfo(const wchar_t* response_header, const wchar_t* response_body, const wchar_t* network_error, uint32 status_code)
      : response_header(response_header)
      , response_body(response_body)
      , network_error(network_error) 
      , status_code(status_code) {}

  SOAPResponseInfo(const SOAPResponseInfo& soap_response)
      : response_header(soap_response.response_header)
      , response_body(soap_response.response_body)
      , network_error(soap_response.network_error) 
      , status_code(soap_response.status_code) {}

  void Set(const wchar_t* response_header, const wchar_t* response_body, const wchar_t* network_error, uint32 status_code) {
    this->response_header = response_header;
    this->response_body = response_body;
    this->network_error = network_error;
    this->status_code = status_code;
  }

  WString response_header;
  WString response_body;
  WString network_error;
  uint32 status_code;
};

class PrintParams FS_FINAL: public Object{
 public:
  typedef enum _PrintContent {
    e_PrintContentDocument = 0,
    e_PrintContentDocAndAnnots = 1,
    e_PrintContentFormFieldsOnly = 2
  } PrintContent;
  
  typedef enum _DuplexType {
    e_DuplexTypeSimplex = 0,
    e_DuplexTypeDuplexFlipLongEdge = 1,
    e_DuplexTypeDuplexFlipShortEdge = 2
  } DuplexType;
  
  typedef enum _BookletDuplexMode {
    e_BookletDuplexModeBothSides = 0,
    e_BookletDuplexModeFrontSideOnly = 1,
    e_BookletDuplexModeBackSideOnly = 2
  } BookletDuplexMode;
  
  typedef enum _BookletBinding {
    e_BookletBindingRight = 0,
    e_BookletBindingLeft = 1,
    e_BookletBindingLeftTall = 2,
    e_BookletBindingRightTall = 3
  } BookletBinding;
  
  typedef enum _PageOrder {
    e_PageOrderHorizontal = 0,
    e_PageOrderHorizontalReversed = 1,
    e_PageOrderVertical = 2
  } PageOrder;
  
  typedef enum _PrintHandling {
    e_PrintHandlingNone = 0,
    e_PrintHandlingFitPaper = 1,
    e_PrintHandlingReducePaper = 2,
    e_PrintHandlingMultiplePages = 3,
    e_PrintHandlingTileLargePages = 4,
    e_PrintHandlingBooklet = 5
  } PrintHandling;
  

  PrintParams()
  : is_show_ui(false)
  , is_reverse(false)
  , is_print_as_image(false)
  , is_print_auto_center(false)
  , is_print_auto_rotate(false)
  , is_simulate_overprinting(false)
  , is_print_page_border(false)
  , page_range(common::Range()) 
  , print_content(PrintParams::e_PrintContentDocument)
  , printer_name(L"")
  , output_file_name(L"")
  , num_copies(0)
  , duplex_type(PrintParams::e_DuplexTypeSimplex)
  , is_tile_label(false)
  , tile_mark(false)
  , tile_overlap(0)
  , tile_scale(0)
  , handling(PrintParams::e_PrintHandlingNone)
  , binding(PrintParams::e_BookletBindingRight)
  , booklet_duplex_mode(PrintParams::e_BookletDuplexModeBothSides)
  , num_pages_h(0)
  , num_pages_v(0)
  , page_order(PrintParams::e_PageOrderHorizontal)
  {}

  PrintParams(const PrintParams& print_params)
    : is_show_ui(print_params.is_show_ui)
    , is_reverse(print_params.is_reverse)
    , is_print_as_image(print_params.is_print_as_image)
    , is_print_auto_center(print_params.is_print_auto_center)
    , is_print_auto_rotate(print_params.is_print_auto_rotate)
    , is_simulate_overprinting(print_params.is_simulate_overprinting)
    , is_print_page_border(print_params.is_print_page_border)
    , page_range(print_params.page_range)
    , print_content(print_params.print_content)
    , printer_name(print_params.printer_name)
    , output_file_name(print_params.output_file_name)
    , num_copies(print_params.num_copies)
    , duplex_type(print_params.duplex_type)
    , is_tile_label(print_params.is_tile_label)
    , tile_mark(print_params.tile_mark)
    , tile_overlap(print_params.tile_overlap)
    , tile_scale(print_params.tile_scale)
    , handling(print_params.handling)
    , binding(print_params.binding)
    , booklet_duplex_mode(print_params.booklet_duplex_mode)
    , num_pages_h(print_params.num_pages_h)
    , num_pages_v(print_params.num_pages_v)
    , page_order(print_params.page_order) {}

  PrintParams& operator=(const PrintParams& print_params) {
    this->is_show_ui = print_params.is_show_ui;
    this->is_reverse = print_params.is_reverse;
    this->is_print_as_image = print_params.is_print_as_image;
    this->is_print_auto_center = print_params.is_print_auto_center;
    this->is_print_auto_rotate = print_params.is_print_auto_rotate;
    this->is_simulate_overprinting = print_params.is_simulate_overprinting;
    this->is_print_page_border = print_params.is_print_page_border;
    this->page_range = print_params.page_range;
    this->print_content = print_params.print_content;
    this->printer_name = print_params.printer_name;
    this->output_file_name = print_params.output_file_name;
    this->num_copies = print_params.num_copies;
    this->duplex_type = print_params.duplex_type;
    this->is_tile_label = print_params.is_tile_label;
    this->tile_mark = print_params.tile_mark;
    this->tile_overlap = print_params.tile_overlap;
    this->tile_scale = print_params.tile_scale;
    this->handling = print_params.handling;
    this->binding = print_params.binding;
    this->booklet_duplex_mode = print_params.booklet_duplex_mode;
    this->num_pages_h = print_params.num_pages_h;
    this->num_pages_v = print_params.num_pages_v;
    this->page_order = print_params.page_order;
    return *this;
  }

  bool is_show_ui;
  bool is_reverse;
  bool is_print_as_image;
  bool is_print_auto_center;
  bool is_print_auto_rotate;
  bool is_simulate_overprinting;
  bool is_print_page_border;
  common::Range page_range;
  PrintContent print_content;
  WString printer_name;
  WString output_file_name;
  int num_copies;
  DuplexType duplex_type;
  bool is_tile_label;
  bool tile_mark;
  float tile_overlap;
  float tile_scale;
  PrintHandling handling;
  BookletBinding binding;
  BookletDuplexMode booklet_duplex_mode;
  int num_pages_h;
  int num_pages_v;
  PageOrder page_order;
};

class FloatingInfo FS_FINAL : public Object{
 public:
  typedef enum _WindowPosition {
    e_WindowPositionTopLeft = 0,
    e_WindowPositionTopCenter = 1,
    e_WindowPositionTopRight = 2,
    e_WindowPositionCenterLeft = 3,
    e_WindowPositionCenter = 4,
    e_WindowPositionCenterRight = 5,
    e_WindowPositionBottomLeft = 6,
    e_WindowPositionBottomCenter = 7,
    e_WindowPositionBottomRight = 8
  } WindowPosition;
  
  typedef enum _RelativeTarget {
    e_RelativeTargetPageWindow = 0,
    e_RelativeTargetAppWindow = 1,
    e_RelativeTargetDesktop = 2,
    e_RelativeTargetMonitor = 3
  } RelativeTarget;
  
  typedef enum _ResizeType {
    e_ResizeTypeNo = 0,
    e_ResizeTypeKeepRatio = 1,
    e_ResizeTypeYes = 2
  } ResizeType;
  
  typedef enum _OffScreenAction {
    e_OffScreenAllow = 0,
    e_OffScreenForceOnScreen = 1,
    e_OffScreenCancel = 2
  } OffScreenAction;
  

  FloatingInfo() {}

  FloatingInfo(WindowPosition window_pos, RelativeTarget relative_target, ResizeType resize_type,
    bool has_close, bool has_title, const wchar_t* title, OffScreenAction off_screen, const RectF& rect)
    : window_pos(window_pos)
    , relative_target(relative_target)
    , resize_type(resize_type)
    , has_close(has_close)
    , has_title(has_title)
    , title(title)
    , off_screen(off_screen)
    , rect(rect) {}

  FloatingInfo(const FloatingInfo& floating_info)
    : window_pos(floating_info.window_pos)
    , relative_target(floating_info.relative_target)
    , resize_type(floating_info.resize_type)
    , has_close(floating_info.has_close)
    , has_title(floating_info.has_title)
    , title(floating_info.title)
    , off_screen(floating_info.off_screen)
    , rect(floating_info.rect) {}

  FloatingInfo& operator = (const FloatingInfo& floating_info) {
    this->window_pos = floating_info.window_pos;
    this->relative_target = floating_info.relative_target;
    this->resize_type = floating_info.resize_type;
    this->has_close = floating_info.has_close;
    this->has_title = floating_info.has_title;
    this->title = floating_info.title;
    this->off_screen = floating_info.off_screen;
    this->rect = floating_info.rect;
    return *this;
  }

  void Set(WindowPosition window_pos, RelativeTarget relative_target, ResizeType resize_type,
    bool has_close, bool has_title, const wchar_t* title, OffScreenAction off_screen, const RectF& rect) {
    this->window_pos = window_pos;
    this->relative_target = relative_target;
    this->resize_type = resize_type;
    this->has_close = has_close;
    this->has_title = has_title;
    this->title = title;
    this->off_screen = off_screen;
    this->rect = rect;
  }
  
  WindowPosition window_pos;

  RelativeTarget relative_target;

  ResizeType resize_type;

  bool has_close;

  bool has_title;

  WString title;

  OffScreenAction off_screen;

  RectF rect;
};

class MediaSettings FS_FINAL : public Object{
 public:
  typedef enum _PlayerWindowType {
    e_PlayerWindowTypeDockedPage = 1,
    e_PlayerWindowTypeFloating = 2,
    e_PlayerWindowTypeFullScreen = 4
  } PlayerWindowType;
  

  MediaSettings(){}

  MediaSettings(bool auto_play, const wchar_t* base_url, foxit::RGB bg_color, float bg_opacity,
    int duration, int page, int repeat, bool show_ui, bool is_visible, int volume,
    PlayerWindowType window_type,const FloatingInfo& floating_wnd_info)
    : auto_play(auto_play)
    , base_url(base_url)
    , bg_color(bg_color)
    , bg_opacity(bg_opacity)
    , duration(duration)
    , page(page)
    , repeat(repeat)
    , show_ui(show_ui)
    , is_visible(is_visible)
    , volume(volume)
    , window_type(window_type)
    , floating_wnd_info(floating_wnd_info) {}

  MediaSettings(const MediaSettings& media_settings)
    : auto_play(media_settings.auto_play)
    , base_url(media_settings.base_url)
    , bg_color(media_settings.bg_color)
    , bg_opacity(media_settings.bg_opacity)
    , duration(media_settings.duration)
    , page(media_settings.page)
    , repeat(media_settings.repeat)
    , show_ui(media_settings.show_ui)
    , is_visible(media_settings.is_visible)
    , volume(media_settings.volume)
    , window_type(media_settings.window_type)
    , floating_wnd_info(media_settings.floating_wnd_info) {}

  MediaSettings& operator = (const MediaSettings& media_settings) {
    this->auto_play = media_settings.auto_play;
    this->base_url = media_settings.base_url;
    this->bg_color = media_settings.bg_color;
    this->bg_opacity = media_settings.bg_opacity;
    this->duration = media_settings.duration;
    this->page = media_settings.page;
    this->repeat = media_settings.repeat;
    this->show_ui = media_settings.show_ui;
    this->is_visible = media_settings.is_visible;
    this->volume = media_settings.volume;
    this->window_type = media_settings.window_type;
    this->floating_wnd_info = media_settings.floating_wnd_info;
    return *this;
  }

  void Set(bool auto_play, const wchar_t* base_url, foxit::RGB bg_color, float bg_opacity,
    int duration, int page, int repeat, bool show_ui, bool is_visible, int volume,
    PlayerWindowType window_type, const FloatingInfo& floating_wnd_info) {
    this->auto_play = auto_play;
    this->base_url = base_url;
    this->bg_color = bg_color;
    this->bg_opacity = bg_opacity;
    this->duration = duration;
    this->page = page;
    this->repeat = repeat;
    this->show_ui = show_ui;
    this->is_visible = is_visible;
    this->volume = volume;
    this->window_type = window_type;
    this->floating_wnd_info = floating_wnd_info;
  }

  bool auto_play;

  WString base_url;

  foxit::RGB bg_color;

  float bg_opacity;

  int duration;

  int page;

  int repeat;

  bool show_ui;

  bool is_visible;

  int volume;

  PlayerWindowType window_type;

  FloatingInfo floating_wnd_info;

};

class PlayerArgs FS_FINAL : public Object{
 public:
  PlayerArgs() {}

  PlayerArgs(const pdf::PDFDoc& doc, const pdf::annots::Screen& screen_annot, const pdf::Rendition& rendition, const wchar_t* URL,
    const wchar_t* audio_format, const MediaSettings& player_settings)
    : doc(doc)
    , screen_annot(screen_annot)
    , rendition(rendition)
    , URL(URL)
    , audio_format(audio_format)
    , player_settings(player_settings) {}

  PlayerArgs(const PlayerArgs& player_args)
    : doc(player_args.doc)
    , screen_annot(player_args.screen_annot)
    , rendition(player_args.rendition)
    , URL(player_args.URL)
    , audio_format(player_args.audio_format)
    , player_settings(player_args.player_settings) {}

  PlayerArgs& operator = (const PlayerArgs& player_args) {
    this->doc = player_args.doc;
    this->screen_annot = player_args.screen_annot;
    this->rendition = player_args.rendition;
    this->URL = player_args.URL;
    this->audio_format = player_args.audio_format;
    this->player_settings = player_args.player_settings;
    return *this;
  }

  void Set(const pdf::PDFDoc& doc, const pdf::annots::Screen& screen_annot, const pdf::Rendition& rendition, const wchar_t* URL,
    const wchar_t* audio_format, const MediaSettings& player_settings) {
    this->doc = doc;
    this->screen_annot = screen_annot;
    this->rendition = rendition;
    this->URL = URL;
    this->audio_format = audio_format;
    this->player_settings = player_settings;
  }

  pdf::PDFDoc doc;

  pdf::annots::Screen screen_annot;

  pdf::Rendition rendition;

  WString URL;

  WString audio_format;

  MediaSettings player_settings;
};

class SearchOption FS_FINAL : public Object{
 public:
  typedef enum _WordMatching {
    e_WordMatchingMatchPhrase = 0,
    e_WordMatchingMatchAllWords = 1,
    e_WordMatchingMatchAnyWord = 2
  } WordMatching;
  

  SearchOption() {}

  SearchOption(bool is_whole_word, bool is_case_sensitive, bool is_search_bookmarks, bool is_search_in_marup,
    bool is_search_in_attachments, bool is_ignore_accents, bool is_proximity, bool is_stemming, bool is_ignore_full_width,
    int max_docs, WordMatching word_matching, bool is_search_doc_text)
    : is_whole_word(is_whole_word)
    , is_case_sensitive(is_case_sensitive)
    , is_search_bookmarks(is_search_bookmarks)
    , is_search_in_markup(is_search_in_marup)
    , is_search_in_attachments(is_search_in_attachments)
    , is_ignore_accents(is_ignore_accents)
    , is_proximity(is_proximity)
    , is_stemming(is_stemming)
    , is_ignore_full_width(is_ignore_full_width)
    , max_docs(max_docs)
    , word_matching(word_matching)
    , is_search_doc_text(is_search_doc_text) {}

  SearchOption(const SearchOption& search_option)
    : is_whole_word(search_option.is_whole_word)
    , is_case_sensitive(search_option.is_case_sensitive)
    , is_search_bookmarks(search_option.is_search_bookmarks)
    , is_search_in_markup(search_option.is_search_in_markup)
    , is_search_in_attachments(search_option.is_search_in_attachments)
    , is_ignore_accents(search_option.is_ignore_accents)
    , is_proximity(search_option.is_proximity)
    , is_stemming(search_option.is_stemming)
    , is_ignore_full_width(search_option.is_ignore_full_width)
    , max_docs(search_option.max_docs)
    , word_matching(search_option.word_matching)
    , is_search_doc_text(search_option.is_search_doc_text) {}

  SearchOption& operator = (const SearchOption& search_option) {
    this->is_whole_word = search_option.is_whole_word;
    this->is_case_sensitive = search_option.is_case_sensitive;
    this->is_search_bookmarks = search_option.is_search_bookmarks;
    this->is_search_in_markup = search_option.is_search_in_markup;
    this->is_search_in_attachments = search_option.is_search_in_attachments;
    this->is_ignore_accents = search_option.is_ignore_accents;
    this->is_proximity = search_option.is_proximity;
    this->is_stemming = search_option.is_stemming;
    this->is_ignore_full_width = search_option.is_ignore_full_width;
    this->max_docs = search_option.max_docs;
    this->word_matching = search_option.word_matching;
    this->is_search_doc_text = search_option.is_search_doc_text;
    return *this;
  }

  void Set(bool is_whole_word, bool is_case_sensitive, bool is_search_bookmarks, bool is_search_in_marup,
    bool is_search_in_attachments, bool is_ignore_accents, bool is_proximity, bool is_stemming, bool is_ignore_full_width,
    int max_docs, WordMatching word_matching, bool is_search_doc_text) {
    this->is_whole_word = is_whole_word;
    this->is_case_sensitive = is_case_sensitive;
    this->is_search_bookmarks = is_search_bookmarks;
    this->is_search_in_markup = is_search_in_marup;
    this->is_search_in_attachments = is_search_in_attachments;
    this->is_ignore_accents = is_ignore_accents;
    this->is_proximity = is_proximity;
    this->is_stemming = is_stemming;
    this->is_ignore_full_width = is_ignore_full_width;
    this->max_docs = max_docs;
    this->word_matching = word_matching;
    this->is_search_doc_text = is_search_doc_text;
  }

  bool is_whole_word;
  bool is_case_sensitive;
  bool is_search_bookmarks;
  bool is_search_in_markup;
  bool is_search_in_attachments;
  bool is_ignore_accents;
  bool is_proximity;
  bool is_stemming;
  bool is_ignore_full_width;
  int max_docs;
  WordMatching word_matching;
  bool is_search_doc_text;
};

class SearchIndexConfig FS_FINAL : public Object{
 public:
  SearchIndexConfig() {}

  SearchIndexConfig(WString name, bool is_available, WString path, bool is_selected)
    : name(name)
    , is_available(is_available)
    , path(path)
    , is_selected(is_selected) {}

  SearchIndexConfig(const SearchIndexConfig& search_index_config)
    : name(search_index_config.name)
    , is_available(search_index_config.is_available)
    , path(search_index_config.path)
    , is_selected(search_index_config.is_selected) {}

  SearchIndexConfig& operator = (const SearchIndexConfig& search_index_config) {
    this->name = search_index_config.name;
    this->is_available = search_index_config.is_available;
    this->path = search_index_config.path;
    this->is_selected = search_index_config.is_selected;
    return *this;
  }

  void Set(WString name, bool is_available, WString path, bool is_selected) {
    this->name = name;
    this->is_available = is_available;
    this->path = path;
    this->is_selected = is_selected;
  }
  WString name;

  bool is_available;

  WString path;

  bool is_selected;
};

class MediaPlayerCallback {
 public:
  typedef enum _JSMediaPlayerState {
    e_JSMediaPlayerStateOpen = 0,
    e_JSMediaPlayerStateClose = 1,
    e_JSMediaPlayerStatePlaying = 2,
    e_JSMediaPlayerStateStop = 3,
    e_JSMediaPlayerStateSuspend = 4
  } JSMediaPlayerState;
  

  virtual void Release() = 0;

  virtual bool Play() = 0;

  virtual void Close() = 0;

  virtual bool Stop() = 0;

  virtual bool Seek(int current_pos) = 0;

  virtual JSMediaPlayerState GetState() = 0;

  virtual MediaSettings GetPlayerSettings() = 0;

 protected:
  ~MediaPlayerCallback() {}
};

class JavascriptModifyItemInfo FS_FINAL : public Object {
 public:
  typedef enum _JavascriptEventType {
    e_JavascriptEventTypeUnknown = 0,
    e_JavascriptEventTypeAppInit = 1,
    e_JavascriptEventTypeHtmlCallback = 2,
    e_JavascriptEventTypeDocOpen = 3,
    e_JavascriptEventTypeDocWillPrint = 4,
    e_JavascriptEventTypeDocDidprint = 5,
    e_JavascriptEventTypeDocWillSave = 6,
    e_JavascriptEventTypeDocDidSave = 7,
    e_JavascriptEventTypeDocWillClose = 8,
    e_JavascriptEventTypePageOpen = 9,
    e_JavascriptEventTypePageClose = 10,
    e_JavascriptEventTypePageInView = 11,
    e_JavascriptEventTypePageOutView = 12,
    e_JavascriptEventTypeFieldMouseDown = 13,
    e_JavascriptEventTypeFieldMouseUp = 14,
    e_JavascriptEventTypeFieldMouseEnter = 15,
    e_JavascriptEventTypeFieldMouseExit = 16,
    e_JavascriptEventTypeFieldFocus = 17,
    e_JavascriptEventTypeFieldBlur= 18,
    e_JavascriptEventTypeFieldKeyStroke= 19,
    e_JavascriptEventTypeFieldValidate= 21,
    e_JavascriptEventTypeFieldCalculate= 22,
    e_JavascriptEventTypeFieldFormat= 23,
    e_JavascriptEventTypeScreenFocus = 24,
    e_JavascriptEventTypeScreenBlur = 25,
    e_JavascriptEventTypeScreenOpen = 26,
    e_JavascriptEventTypeScreenClose = 27,
    e_JavascriptEventTypeScreenMouseDown = 28,
    e_JavascriptEventTypeScreenMouseUp = 29,
    e_JavascriptEventTypeScreenMouseEnter = 30,
    e_JavascriptEventTypeScreenMouseExit = 31,
    e_JavascriptEventTypeScreenInview = 32,
    e_JavascriptEventTypeScreenOutview = 33,
    e_JavascriptEventTypeBatchExec = 34,
    e_JavascriptEventTypeMenuExec = 35,
    e_JavascriptEventTypeConsoleExec = 36,
    e_JavascriptEventTypeExternalExec = 37,
    e_JavascriptEventTypeBookmarkMouseUp = 38,
    e_JavascriptEventTypeLinkMouseUp = 39,
    e_JavascriptEventTypeMediaBlur = 40,
    e_JavascriptEventTypeMediaClose = 41,
    e_JavascriptEventTypeMediaDone = 42,
    e_JavascriptEventTypeMediaPlay = 43,
    e_JavascriptEventTypeMediaReady = 44,
    e_JavascriptEventTypeMediaSeek = 45,
    e_JavascriptEventTypeMediaStop = 46
  } JavascriptEventType;
  
  typedef enum _JavascriptModifyItemType {
    e_JavascriptModifyItemTypeNone = 0,
    e_JavascriptModifyItemTypeField = 1,
    e_JavascriptModifyItemTypeAnnot = 2,
    e_JavascriptModifyItemTypePage = 3,
    e_JavascriptModifyItemTypeDoc= 4
  } JavascriptModifyItemType;
  
  typedef enum _JavascriptModifyPropertyType {
    e_JavascriptModifyPropertyTypeNone = 0,
    e_JavascriptModifyPropertyTypeBorderColor = 1,
    e_JavascriptModifyPropertyTypeFillColor = 2,
    e_JavascriptModifyPropertyTypeTextColor = 3,
    e_JavascriptModifyPropertyTypeValue = 4,
    e_JavascriptModifyPropertyTypeCharLimit = 5,
    e_JavascriptModifyPropertyTypeButtonPosition = 6,
    e_JavascriptModifyPropertyTypeSelectChange = 7,
    e_JavascriptModifyPropertyTypeAlignment = 8,
    e_JavascriptModifyPropertyTypeBorderStyle = 9,
    e_JavascriptModifyPropertyTypeButtonAlignX = 10,
    e_JavascriptModifyPropertyTypeButtonAlignY = 11,
    e_JavascriptModifyPropertyTypeButtonFitBounds = 12,
    e_JavascriptModifyPropertyTypeButtonScaleHow = 13,
    e_JavascriptModifyPropertyTypeButtonScaleWhen = 14,
    e_JavascriptModifyPropertyTypeComb = 15,
    e_JavascriptModifyPropertyTypeDefaultStyle = 16,
    e_JavascriptModifyPropertyTypeDefaultValue = 17,
    e_JavascriptModifyPropertyTypeDoNotScroll = 18,
    e_JavascriptModifyPropertyTypeDelay= 19,
    e_JavascriptModifyPropertyTypeDisplay = 20,
    e_JavascriptModifyPropertyTypeEditable = 21,
    e_JavascriptModifyPropertyTypeNotSpellCheck = 22,
    e_JavascriptModifyPropertyTypeHidden = 23,
    e_JavascriptModifyPropertyTypeHighlight= 24,
    e_JavascriptModifyPropertyTypeLineWidth = 25,
    e_JavascriptModifyPropertyTypeMultiline = 26,
    e_JavascriptModifyPropertyTypePassword = 27,
    e_JavascriptModifyPropertyTypeRect = 28,
    e_JavascriptModifyPropertyTypeRequired = 29,
    e_JavascriptModifyPropertyTypeRichText = 30,
    e_JavascriptModifyPropertyTypeRichValue = 31,
    e_JavascriptModifyPropertyTypeRotation = 32,
    e_JavascriptModifyPropertyTypeNormalCaption = 33,
    e_JavascriptModifyPropertyTypeDownCaption = 34,
    e_JavascriptModifyPropertyTypeRolloverCaption = 35,
    e_JavascriptModifyPropertyTypeTextFont = 36,
    e_JavascriptModifyPropertyTypeUserName = 37,
    e_JavascriptModifyPropertyTypeButtonSetIcon = 38,
    e_JavascriptModifyPropertyTypeCheckThisBox = 39,
    e_JavascriptModifyPropertyTypeClearItems = 40,
    e_JavascriptModifyPropertyTypeDefaultIsChecked = 41,
    e_JavascriptModifyPropertyTypeDeleteItemAt = 42,
    e_JavascriptModifyPropertyTypeInsertItemAt = 43,
    e_JavascriptModifyPropertyTypeSetItems = 44,
    e_JavascriptModifyPropertyTypeActivated = 45,
    e_JavascriptModifyPropertyTypeArrowBegin = 46,
    e_JavascriptModifyPropertyTypeArrowEnd = 47,
    e_JavascriptModifyPropertyTypeAttachIcon = 48,
    e_JavascriptModifyPropertyTypeBorderEffectIntensity = 49,
    e_JavascriptModifyPropertyTypeBorderEffectStyle = 50,
    e_JavascriptModifyPropertyTypeCallout = 51,
    e_JavascriptModifyPropertyTypeCaretSymbol = 52,
    e_JavascriptModifyPropertyTypeContents = 53,
    e_JavascriptModifyPropertyTypeDash = 54,
    e_JavascriptModifyPropertyTypeDoCaption = 55,
    e_JavascriptModifyPropertyTypeGestures = 56,
    e_JavascriptModifyPropertyTypeIntent = 57,
    e_JavascriptModifyPropertyTypeLeaderExtend = 58,
    e_JavascriptModifyPropertyTypeLeaderLength = 59,
    e_JavascriptModifyPropertyTypeLineEnding = 60,
    e_JavascriptModifyPropertyTypeNoteIcon = 61,
    e_JavascriptModifyPropertyTypeToggleNoView = 62,
    e_JavascriptModifyPropertyTypeOpacity = 63,
    e_JavascriptModifyPropertyTypePoints = 64,
    e_JavascriptModifyPropertyTypeQuads = 65,
    e_JavascriptModifyPropertyTypeTextSize = 66,
    e_JavascriptModifyPropertyTypeRichContents = 67,
    e_JavascriptModifyPropertyTypeRichDefaults = 68,
    e_JavascriptModifyPropertyTypeSoundIcon = 69,
    e_JavascriptModifyPropertyTypeSubject = 70,
    e_JavascriptModifyPropertyTypeVertices = 71,
    e_JavascriptModifyPropertyTypeImport = 72,
    e_JavascriptModifyPropertyTypeRemoveDataObject = 73,
    e_JavascriptModifyPropertyTypeImportDataObject = 74,
    e_JavascriptModifyPropertyTypeRemoveTemplate = 75,
    e_JavascriptModifyPropertyTypeAddPageTemplate = 76,
    e_JavascriptModifyPropertyTypeRsetForms = 77,
    e_JavascriptModifyPropertyTypeRsetAllForms = 78,
    e_JavascriptModifyPropertyTypeTitle = 79,
    e_JavascriptModifyPropertyTypeResizePage = 80,
    e_JavascriptModifyPropertyTypeSpawnPageFromTemplate = 81,
    e_JavascriptModifyPropertyTypeAddWeblinks = 82,
    e_JavascriptModifyPropertyTypeRemoveWeblinks = 83,
    e_JavascriptModifyPropertyTypeRemoveLinks = 84,
    e_JavascriptModifyPropertyTypePageRotations = 85,
    e_JavascriptModifyPropertyTypeNewPage = 86,
    e_JavascriptModifyPropertyTypeMovePage = 87,
    e_JavascriptModifyPropertyTypeInsertPages = 88,
    e_JavascriptModifyPropertyTypeReplacePages = 89,
    e_JavascriptModifyPropertyTypeImportAnnotFromXFDF = 90,
    e_JavascriptModifyPropertyTypeDeleteAnnot = 91,
    e_JavascriptModifyPropertyTypeAddWatermark = 92,
    e_JavascriptModifyPropertyTypeFlatDocument = 93,
    e_JavascriptModifyPropertyTypeAddFileAttachment = 94,
    e_JavascriptModifyPropertyTypeRuntimeHighlight = 95,
    e_JavascriptModifyPropertyTypeRuntimeHighlightColor = 96,
    e_JavascriptModifyPropertyTypeInsertFromTemplates = 97,
    e_JavascriptModifyPropertyTypeAddLink = 98,
    e_JavascriptModifyPropertyTypeMultipleSelection = 99,
    e_JavascriptModifyPropertyTypeSetPageTemplateVisible = 100
  } JavascriptModifyPropertyType;
  
  typedef enum _JavascriptModifyType {
    e_JavascriptModifyTypeNone = 0,
    e_JavascriptModifyTypeAdd = 1,
    e_JavascriptModifyTypeModify = 2,
    e_JavascriptModifyTypeDelete = 3
  } JavascriptModifyType;
  

  JavascriptModifyItemInfo()
    : event_type(JavascriptModifyItemInfo::e_JavascriptEventTypeUnknown)
    , page_index(-1)
    , field_control_index(-1)
    , modify_item_type(JavascriptModifyItemInfo::e_JavascriptModifyItemTypeNone)
    , modify_type(JavascriptModifyItemInfo::e_JavascriptModifyTypeNone)
    , modify_property_type(JavascriptModifyItemInfo::e_JavascriptModifyPropertyTypeNone)
    , field_or_annot_name(L"")
    , new_value(L"")
    , old_value(L"") {}

  JavascriptModifyItemInfo(JavascriptEventType event_type, 
      int page_index, int field_control_index, JavascriptModifyItemType modify_item_type,
      JavascriptModifyType modify_type, JavascriptModifyPropertyType modify_property_type, 
      WString field_or_annot_name, WString new_value, WString old_value)
      : event_type(JavascriptModifyItemInfo::e_JavascriptEventTypeUnknown)
      , page_index(page_index)
      , field_control_index(field_control_index)
      , modify_item_type(modify_item_type)
      , modify_type(modify_type)
      , modify_property_type(modify_property_type)
      , field_or_annot_name(field_or_annot_name)
      , new_value(new_value)
      , old_value(old_value) { }

  JavascriptModifyItemInfo (const JavascriptModifyItemInfo& other)
    : event_type(other.event_type)
    , page_index(other.page_index)
    , field_control_index(other.field_control_index)
    , modify_item_type(other.modify_item_type)
    , modify_type(other.modify_type)
    , modify_property_type(other.modify_property_type)
    , field_or_annot_name(other.field_or_annot_name)
    , new_value(other.new_value)
   , old_value(other.old_value) {
  }

  JavascriptModifyItemInfo& operator = (const JavascriptModifyItemInfo& other) {
    if (this != &other) {
      event_type = other.event_type;
      page_index = other.page_index;
      field_control_index = other.field_control_index;
      modify_item_type = other.modify_item_type;
      modify_type = other.modify_type;
      modify_property_type = other.modify_property_type;
      field_or_annot_name = other.field_or_annot_name;
      new_value = other.new_value;
      old_value = other.old_value;
    }
    return *this;
  }

  JavascriptEventType event_type;

  int page_index;

  int field_control_index;
  
  JavascriptModifyItemType modify_item_type;

  JavascriptModifyType modify_type;

  JavascriptModifyPropertyType modify_property_type;

  WString field_or_annot_name;

  WString new_value;

  WString old_value;
};

class ActionCallback {
 public:
  typedef enum _Language {
    e_LanguageUnknown = 0,
    e_LanguageCHS = 1,
    e_LanguageCHT = 2,
    e_LanguageDAN = 3,
    e_LanguageDEU = 4,
    e_LanguageENU = 5,
    e_LanguageESP = 6,
    e_LanguageFRA = 7,
    e_LanguageITA = 8,
    e_LanguageKOR = 9,
    e_LanguageJPN = 10,
    e_LanguageNLD = 11,
    e_LanguageNOR = 12,
    e_LanguagePTB = 13,
    e_LanguageSUO = 14,
    e_LanguageSVE = 15
  } Language;
  
  typedef enum _AppInfoType {
    e_AppInfoTypeFormsVersion = 0x0,
    e_AppInfoTypeViewerType = 0x01,
    e_AppInfoTypeViewerVariation = 0x02,
    e_AppInfoTypeViewerVersion = 0x03,
    e_AppInfoTypeAppVersion = 0x04
  } AppInfoType;
  
  typedef enum _MailType {
    e_MailTypeDoc = 0,
    e_MailTypeForm = 1,
    e_MailTypeMsg = 2
  } MailType;
  
  typedef enum _JSFieldValueChangeType {
    e_JSFieldValueChangedByFormat = 0,
    e_JSFieldValueChangedByCalculation = 1,
    e_JSFieldValueChangedBySetValue = 2,
    e_JSFieldValueChangedBySetReadOnly = 3,
    e_JSFieldValueChangedByFillColor = 4
  } JSFieldValueChangeType;
  
  typedef enum _JSMediaPlayerState {
    e_JSMediaPlayerStateOpen = 0,
    e_JSMediaPlayerStateClose = 1,
    e_JSMediaPlayerStatePlaying = 2,
    e_JSMediaPlayerStateStop = 3,
    e_JSMediaPlayerStateSuspend = 4
  } JSMediaPlayerState;
  
  typedef enum _LayoutMode {
    e_LayoutModeSinglePage = 0,
    e_LayoutModeContinuous = 1,
    e_LayoutModeFacing = 2,
    e_LayoutModeContinuousFacing = 3
  } LayoutMode;
  
  typedef enum _JsMailResult {
    e_JSMailResultFailed = 0,
    e_JSMailResultSuccess = 1,
    e_JSMailResultUserAbort = 2
  } JsMailResult;
  
  typedef enum _SearchScope {
    e_SearchScopeActiveDoc = 0,
    e_SearchScopeFolder = 1,
    e_SearchScopeIndex = 2,
    e_SearchScopeActiveIndexes = 3
  } SearchScope;
  

  virtual void Release() = 0;

  virtual bool InvalidateRect(const pdf::PDFDoc& document, int page_index, const RectF& pdf_rect) = 0;

  virtual int GetCurrentPage(const pdf::PDFDoc& document) = 0;

  virtual void SetCurrentPage(const pdf::PDFDoc& document, int page_index) = 0;

  virtual void SetCurrentPage(const pdf::PDFDoc& document, const foxit::pdf::Destination& destination) = 0;

  virtual common::Rotation GetPageRotation(const pdf::PDFDoc& document, int page_index) = 0;

  virtual bool SetPageRotation(const pdf::PDFDoc& document, int page_index, common::Rotation rotation) = 0;

  virtual bool ExecuteNamedAction(const pdf::PDFDoc& document, const char* named_action) = 0;

  virtual bool SetDocChangeMark(const pdf::PDFDoc& document, bool change_mark) = 0;

  virtual bool GetDocChangeMark(const pdf::PDFDoc& document) = 0;

  virtual int GetOpenedDocCount() = 0;

  virtual pdf::PDFDoc GetOpenedDoc(int index) = 0;

  virtual pdf::PDFDoc GetCurrentDoc() = 0;

  virtual pdf::PDFDoc CreateBlankDoc() = 0;
  
  virtual void CloseDoc(const pdf::PDFDoc& document, bool is_prompt_to_save) = 0;
  
  virtual pdf::PDFDoc OpenDoc(const WString& file_path, const WString& password) = 0;

  virtual bool Beep(int type) = 0;

  virtual WString Response(const wchar_t* question, const wchar_t* title, const wchar_t* default_value,
                                const wchar_t* label, bool is_password) = 0;

  virtual WString GetFilePath(const pdf::PDFDoc& document) = 0;

  virtual bool IsLocalFile(const pdf::PDFDoc& document) = 0;

  virtual WString GetAttachmentsFilePath(const pdf::PDFDoc& pdf_doc, const wchar_t* name) = 0;

  virtual WString GetExtractedEmbeddedFilePath(const pdf::PDFDoc& pdf_doc, const wchar_t* name) = 0;

  virtual bool Print(const pdf::PDFDoc& document, bool is_ui,
                     const common::Range& page_range, bool is_silent ,
                     bool is_shrunk_to_fit, bool is_printed_as_image,
                     bool is_reversed, bool is_to_print_annots) = 0;

  virtual bool Print(const pdf::PDFDoc& document, const PrintParams& print_params) = 0;

  virtual bool SubmitForm(const pdf::PDFDoc& document, void* form_data, uint32 length, const char* url, common::FileFormatType file_format_type) = 0;

  virtual bool LaunchURL(const char* url) = 0;

  virtual WString BrowseFile() = 0;

  virtual WString BrowseFile(bool is_open_dialog, const wchar_t* file_format, const wchar_t* file_filter) = 0;

  virtual Language GetLanguage() = 0;

  virtual int Alert(const wchar_t* msg, const wchar_t* title, int type, int icon) = 0;

  virtual IdentityProperties GetIdentityProperties() = 0;

  virtual bool SetIdentityProperties(const IdentityProperties& identity_properties) = 0;

  virtual WString PopupMenu(const MenuListArray& menus, bool& is_selected_item) = 0;

  virtual MenuItemEx PopupMenuEx(const MenuItemExArray& menus, bool& is_selected_item) = 0;

  virtual WString GetAppInfo(AppInfoType type) = 0;

  virtual bool MailData(void* data, MailType data_type, bool is_ui, const wchar_t* to,
                        const wchar_t* subject, const wchar_t* cc, const wchar_t* bcc, const wchar_t* message) = 0;

  virtual uint32 VerifySignature(const pdf::PDFDoc& document, const pdf::Signature& pdf_signature) = 0;
  
  virtual WString GetUntitledBookmarkName() = 0;

  virtual WStringArray GetPrinterNameList() = 0;

  virtual bool AddToolButton(const ButtonItem& button_item) = 0;

  virtual bool RemoveToolButtom(const wchar_t* button_name) = 0;

  virtual MenuListArray GetMenuItemNameList() = 0;

  virtual bool AddMenuItem(const MenuItemConfig& menu_item_config, bool is_prepend) = 0;

  virtual bool AddSubMenu(const MenuItemConfig& menu_item_config) = 0;

  virtual bool ShowDialog(const DialogDescriptionConfig& dlg_config) = 0;

  virtual bool GetFullScreen() = 0;

  virtual void SetFullScreen(bool is_full_screen) = 0;

  virtual void OnFieldValueChanged(const wchar_t* field_name, JSFieldValueChangeType type, const WStringArray &value_before_changed, const WStringArray &value_after_changed) = 0;

  virtual void UpdateLogicalLabel() = 0;

  virtual JsMailResult MailDoc(const pdf::PDFDoc& document,
    const wchar_t* to_address, const wchar_t* cc_address, const wchar_t* bcc_address,
    const wchar_t* subject, const wchar_t* message, bool is_ui) = 0;

  virtual WString GetTemporaryFileName(const pdf::PDFDoc& document, const wchar_t* file_suffix_name)  = 0;

  virtual MediaPlayerCallback* OpenMediaPlayer(const PlayerArgs& player_args) = 0;
 
  virtual WString GetTemporaryDirectory() = 0;

  virtual void Scroll(const PointF& point) = 0;

  virtual void SelectPageNthWord(int page_index, int start_offset, int end_offset, bool is_show_selection) = 0;

  virtual PointF GetMousePosition() = 0;

  virtual RectF GetPageWindowRect(const foxit::pdf::PDFDoc& pdf_doc, int page_index) = 0;

  virtual LayoutMode GetLayoutMode() = 0;

  virtual void SetLayoutMode(LayoutMode layout_mode, bool is_cover_mode) = 0;

  virtual float GetPageScale() = 0;

  virtual void SetPageScale(foxit::pdf::Destination::ZoomMode zoom_mode, const foxit::pdf::Destination& dest) = 0;

  virtual foxit::pdf::Destination::ZoomMode GetPageZoomMode() = 0;

  virtual void Query(const wchar_t* keywords, SearchScope search_scope, const SearchOption& search_option, const wchar_t* di_path) = 0;

  virtual SearchIndexConfig AddSearchIndex(const wchar_t* di_path, bool is_selected) = 0;

  virtual bool RemoveSearchIndex(const SearchIndexConfig& search_index_config) = 0;

  virtual WStringArray GetSignatureAPStyleNameList() = 0;

  virtual SOAPResponseInfo SoapRequest(const SOAPRequestProperties& request_params) = 0;

  virtual void EnablePageLoop(bool is_loop) = 0;

  virtual bool IsPageLoop() = 0;

  virtual void SetDefaultPageTransitionMode(const wchar_t* trans_type, const wchar_t* trans_di) = 0;

  virtual bool IsCurrentDocOpenedInBrowser() = 0;

  virtual void PostMessageToHtml(WStringArray message) = 0;

  virtual void NotifyBeginDoJob(const pdf::PDFDoc& document, JavascriptModifyItemInfo::JavascriptEventType event_type) = 0;

  virtual void NotifyAfterDataChange(const pdf::PDFDoc& document, JavascriptModifyItemInfo modify_item_info) = 0;

  virtual void NotifyEndDoJob(const pdf::PDFDoc& document, JavascriptModifyItemInfo::JavascriptEventType event_type) = 0;

  virtual bool InitModifyItem(const pdf::PDFDoc &document, ModifyItemType item_type, int page_index, const WString &dict_name) = 0;

  virtual void ResetModifyItem(const pdf::PDFDoc &document) = 0;
  
  virtual int GetVisiblePageCount(const pdf::PDFDoc& document) = 0;

  virtual int GetVisiblePage(const pdf::PDFDoc& document, int index) = 0;
 protected:
  virtual ~ActionCallback() {}
};
}  // namespace foxit

#endif  // FS_ACTIONCALLBACK_H_