fs_accessibility.h

浏览该文件的文档.

#ifndef FS_ACCESSIBILITY_H_
#define FS_ACCESSIBILITY_H_

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

namespace foxit {
namespace addon {
namespace accessibility {
typedef enum _RuleType {
  e_RuleTypeDocPermission = 0,
  e_RuleTypeDocImageOnly = 1,
  e_RuleTypeDocTagged = 2,
  e_RuleTypeDocStructreeOrder = 3,
  e_RuleTypeDocLang = 4,
  e_RuleTypeDocTitle = 5,
  e_RuleTypeDocBookmark = 6,
  e_RuleTypeDocColorcontrast = 7,
  e_RuleTypePageContentTagged = 8,
  e_RuleTypePageAnnotTagged = 9,
  e_RuleTypePageTabOrder = 10,
  e_RuleTypePageFontEncoding = 11,
  e_RuleTypePageMultiMediaTagged = 12,
  e_RuleTypePageFlickering = 13,
  e_RuleTypePageScript = 14,
  e_RuleTypePageResponses = 15,
  e_RuleTypePageLink = 16,
  e_RuleTypeFormFieldTagged = 17,
  e_RuleTypeFormFieldAltText = 18,
  e_RuleTypeTableRows = 19,
  e_RuleTypeTableThAndTd = 20,
  e_RuleTypeTableHeaders = 21,
  e_RuleTypeTableRegularity = 22,
  e_RuleTypeTableSummary = 23,
  e_RuleTypeListItems = 24,
  e_RuleTypeListLblAndLbody = 25,
  e_RuleTypeAlternateTextFigures = 26,
  e_RuleTypeAlternateTextNested = 27,
  e_RuleTypeAlternateTextContent = 28,
  e_RuleTypeAlternateTextAnnot = 29,
  e_RuleTypeAlternateTextOther = 30,
  e_RuleTypeHeading = 31
} RuleType;

typedef enum _CheckState {
  e_CheckStateNone = 0,
  e_CheckStatePassed = 1,
  e_CheckStateFailed = 2,
  e_CheckStateHumanCheck = 3,
  e_CheckStateSkipped = 4,
  e_CheckStateHumanPassed = 5,
  e_CheckStateHumanFailed = 6,
  e_CheckStateLast = 7
} CheckState;


class AccessibilityRectInfo FS_FINAL : public Object {
 public:
  AccessibilityRectInfo()
   : data_index(-1) {}

  AccessibilityRectInfo(const AccessibilityRectInfo& other) {
    rect = other.rect;
    data_index = other.data_index;
  }

  AccessibilityRectInfo& operator=(const AccessibilityRectInfo& other) {
    rect = other.rect;
    data_index = other.data_index;
    return *this;
  }

  void Set(const RectF& rect, int data_index) {
    this->rect = rect;
    this->data_index = data_index;
  }

  foxit::RectF rect;

  int data_index;
};

FSDK_DEFINE_ARRAY(AccessibilityRectInfoArray, AccessibilityRectInfo)


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

  AccessibilityLineInfo(const PointF& start_point, const PointF& end_point) {
    this->start_point = start_point;
    this->end_point = end_point;
  }

  AccessibilityLineInfo(const AccessibilityLineInfo& other) {
    start_point = other.start_point;
    end_point = other.end_point;
  }

  AccessibilityLineInfo& operator=(const AccessibilityLineInfo& other) {
    start_point = other.start_point;
    end_point = other.end_point;
    return *this;
  }

  void Set(const PointF& start_point, const PointF& end_point) {
    this->start_point = start_point;
    this->end_point = end_point;
  }

  PointF start_point;

  PointF end_point;
};

FSDK_DEFINE_ARRAY(AccessibilityLineInfoArray, AccessibilityLineInfo)


class AccessibilityTextInfo FS_FINAL : public Object {
 public:
  AccessibilityTextInfo()
    : data_index(-1) {}

  AccessibilityTextInfo(const AccessibilityTextInfo& other) {
    text = other.text;
    rect = other.rect;
    data_index = other.data_index;
    text_color = other.text_color;
    background_color = other.background_color;
    border_color = other.border_color;
  }

  AccessibilityTextInfo& operator=(const AccessibilityTextInfo& other) {
    text = other.text;
    rect = other.rect;
    data_index = other.data_index;
    text_color = other.text_color;
    background_color = other.background_color;
    border_color = other.border_color;
    return *this;
  }

  void Set(WString text, const RectF& rect, int data_index,
           foxit::RGB text_color, foxit::RGB background_color, foxit::RGB border_color) {
    this->text = text;
    this->rect = rect;
    this->data_index = data_index;
    this->text_color = text_color;
    this->background_color = background_color;
    this->border_color = border_color;
  }

  WString text;
  foxit::RectF rect;
  int data_index;
  foxit::RGB text_color;
  foxit::RGB background_color;
  foxit::RGB border_color;
};

FSDK_DEFINE_ARRAY(AccessibilityTextInfoArray, AccessibilityTextInfo)


class AccessibilityCheckOptions FS_FINAL : public Object {
 public:
  typedef enum _CheckValidateRuleType {
    e_CheckValidateRuleTypeDocPermission = 0x0101,
    e_CheckValidateRuleTypeDocPureImage = 0x0102,
    e_CheckValidateRuleTypeDocTagged = 0x0103,
    e_CheckValidateRuleTypeDocStructTreeOrder = 0x0104,
    e_CheckValidateRuleTypeDocLanguageSpecified = 0x0105,
    e_CheckValidateRuleTypeDocTitle = 0x0106,
    e_CheckValidateRuleTypeDocOutlineForLarge = 0x0107,
    e_CheckValidateRuleTypeDocColorContrast = 0x0108,
    e_CheckValidateRuleTypePageContentTagged = 0x0109,
    e_CheckValidateRuleTypePageAnnotTagged = 0x010A,
    e_CheckValidateRuleTypePageTabOrder = 0x010B,
    e_CheckValidateRuleTypePageFontEncoding = 0x010C,
    e_CheckValidateRuleTypePageMultimediaObjectTagged = 0x010D,
    e_CheckValidateRuleTypePageNoFlickering = 0x010E,
    e_CheckValidateRuleTypePageNoInaccessibleScript = 0x010F,
    e_CheckValidateRuleTypePageNoTimedResponse = 0x0110,
    e_CheckValidateRuleTypePageNavigationLinkRepeat = 0x0111,
    e_CheckValidateRuleTypeFormFieldTagged = 0x0112,
    e_CheckValidateRuleTypeFormFieldAltText = 0x0113,
    e_CheckValidateRuleTypeTableRowsUsed = 0x0114,
    e_CheckValidateRuleTypeTableThTdUsed = 0x0115,
    e_CheckValidateRuleTypeTableHeadersExist = 0x0116,
    e_CheckValidateRuleTypeTableSpanCorrect = 0x0117,
    e_CheckValidateRuleTypeTableSummary = 0x0118,
    e_CheckValidateRuleTypeListItemsUsed = 0x0119,
    e_CheckValidateRuleTypeListLblLbodyUsed = 0x011A,
    e_CheckValidateRuleTypeFigureAltText = 0x011B,
    e_CheckValidateRuleTypeNoNestedAltText = 0x011C,
    e_CheckValidateRuleTypeAltTextHasContent = 0x011D,
    e_CheckValidateRuleTypeAltTextHideAnnot = 0x011E,
    e_CheckValidateRuleTypeElementAltText = 0x011F,
    e_CheckValidateRuleTypeHeadingProperNest = 0x0120
  } CheckValidateRuleType;
  

  AccessibilityCheckOptions() {}

  AccessibilityCheckOptions(const AccessibilityCheckOptions& other) {
    check_rule_array = other.check_rule_array;
    page_range = other.page_range;
  }

  AccessibilityCheckOptions& operator=(const AccessibilityCheckOptions& other) {
    check_rule_array = other.check_rule_array;
    page_range = other.page_range;
    return *this;
  }

  void Set(UInt32Array check_rule_array, foxit::common::Range page_range) {
    this->check_rule_array = check_rule_array;
    this->page_range = page_range;
  }

  UInt32Array check_rule_array;
  foxit::common::Range page_range;
};

class AccessibilityCheckResultDetailData FS_FINAL : public Object {
 public:
  AccessibilityCheckResultDetailData()
    : page_index(-1)
    , can_show_in_tags(false) {}

  AccessibilityCheckResultDetailData(const wchar_t* item_name, const char* item_id, const wchar_t* explain_url,
                                        int page_index, const RectF& item_rect, bool can_show_in_tags)
    : item_name(item_name)
    , item_id(item_id)
    , explain_url(explain_url)
    , page_index(page_index)
    , item_rect(item_rect)
    , can_show_in_tags(can_show_in_tags) {}

  AccessibilityCheckResultDetailData(const AccessibilityCheckResultDetailData& other) {
    this->item_name = other.item_name;
    this->item_id = other.item_id;
    this->explain_url = other.explain_url;
    this->page_index = other.page_index;
    this->item_rect = other.item_rect;
    this->can_show_in_tags = other.can_show_in_tags;
  }

  AccessibilityCheckResultDetailData& operator=(const AccessibilityCheckResultDetailData& other) {
    this->item_name = other.item_name;
    this->item_id = other.item_id;
    this->explain_url = other.explain_url;
    this->page_index = other.page_index;
    this->item_rect = other.item_rect;
    this->can_show_in_tags = other.can_show_in_tags;
    return *this;
  }

  void Set(const wchar_t* item_name, const char* item_id, const wchar_t* explain_url,
           int page_index, const RectF& item_rect, bool can_show_in_tags) {
    this->item_name = item_name;
    this->item_id = item_id;
    this->explain_url = explain_url;
    this->page_index = page_index;
    this->item_rect = item_rect;
    this->can_show_in_tags = can_show_in_tags;
  }

  WString item_name;
  String item_id;
  WString explain_url;
  int page_index;
  foxit::RectF item_rect;
  bool can_show_in_tags;
};

FSDK_DEFINE_ARRAY(AccessibilityCheckResultDetailDataArray, AccessibilityCheckResultDetailData)


class AccessibilityCheckResultSubItemData FS_FINAL : public Object {
 public:
  AccessibilityCheckResultSubItemData()
    : item_rule(e_RuleTypeDocPermission)
    , item_state(e_CheckStateNone) {}

  AccessibilityCheckResultSubItemData(const wchar_t* item_name, const wchar_t* item_full_name, const wchar_t* explain_url,
                                       RuleType item_rule, CheckState item_state,
                                       AccessibilityCheckResultDetailDataArray detail_data_array)
    : item_name(item_name)
    , item_full_name(item_full_name)
    , explain_url(explain_url)
    , item_rule(item_rule)
    , item_state(item_state)
    , detail_data_array(detail_data_array) {}

  AccessibilityCheckResultSubItemData(const AccessibilityCheckResultSubItemData& other) {
    this->item_name = other.item_name;
    this->item_full_name = other.item_full_name;
    this->explain_url = other.explain_url;
    this->item_rule = other.item_rule;
    this->item_state = other.item_state;
    this->detail_data_array = other.detail_data_array;
  }

  AccessibilityCheckResultSubItemData& operator=(const AccessibilityCheckResultSubItemData& other) {
    this->item_name = other.item_name;
    this->item_full_name = other.item_full_name;
    this->explain_url = other.explain_url;
    this->item_rule = other.item_rule;
    this->item_state = other.item_state;
    this->detail_data_array = other.detail_data_array;
    return *this;
  }

  void Set(const wchar_t* item_name, const wchar_t* item_full_name, const wchar_t* explain_url,
           RuleType item_rule, CheckState item_state,
           AccessibilityCheckResultDetailDataArray detail_data_array) {
    this->item_name = item_name;
    this->item_full_name = item_full_name;
    this->explain_url = explain_url;
    this->item_rule = item_rule;
    this->item_state = item_state;
    this->detail_data_array = detail_data_array;
  }

  WString item_name;
  WString item_full_name;
  WString explain_url;
  RuleType item_rule;
  CheckState item_state;
  AccessibilityCheckResultDetailDataArray detail_data_array;
};

FSDK_DEFINE_ARRAY(AccessibilityCheckResultSubItemDataArray, AccessibilityCheckResultSubItemData)


class AccessibilityCheckResultItemData FS_FINAL : public Object {
 public:
  AccessibilityCheckResultItemData()
   : issues_num(0) {}

  AccessibilityCheckResultItemData(const wchar_t* item_name, const wchar_t* item_full_name, const wchar_t* explain_url,
                                    int issues_num, AccessibilityCheckResultSubItemDataArray subitem_array)
    : item_name(item_name)
    , item_full_name(item_full_name)
    , explain_url(explain_url)
    , issues_num(issues_num)
    , subitem_array(subitem_array) {}

  AccessibilityCheckResultItemData(const AccessibilityCheckResultItemData& other) {
    this->issues_num = other.issues_num;
    this->item_name = other.item_name;
    this->item_full_name = other.item_full_name;
    this->explain_url = other.explain_url;
    this->subitem_array = other.subitem_array;
  }

  AccessibilityCheckResultItemData& operator=(const AccessibilityCheckResultItemData& other) {
    this->issues_num = other.issues_num;
    this->item_name = other.item_name;
    this->item_full_name = other.item_full_name;
    this->explain_url = other.explain_url;
    this->subitem_array = other.subitem_array;
    return *this;
  }

  void Set(const wchar_t* item_name, const wchar_t* item_full_name, const wchar_t* explain_url,
           int issues_num, AccessibilityCheckResultSubItemDataArray subitem_array) {
    this->issues_num = issues_num;
    this->item_full_name = item_full_name;
    this->item_name = item_name;
    this->explain_url = explain_url;
    this->subitem_array = subitem_array;
  }

  WString item_name;
  WString item_full_name;
  WString explain_url;
  int issues_num;
  AccessibilityCheckResultSubItemDataArray subitem_array;
};

FSDK_DEFINE_ARRAY(AccessibilityCheckResultItemDataArray, AccessibilityCheckResultItemData)


class AccessibilityFindResult FS_FINAL : public Object {
 public:
  AccessibilityFindResult()
    : page_index(-1) {}

  AccessibilityFindResult(const foxit::RectFArray& rects, const wchar_t* result_type, int page_index)
    : rects(rects)
    , result_type(result_type)
    , page_index(page_index) {}

  AccessibilityFindResult(const AccessibilityFindResult& other) {
    rects = other.rects;
    result_type = other.result_type;
    page_index = other.page_index;
  }

  AccessibilityFindResult& operator=(const AccessibilityFindResult& other) {
    rects = other.rects;
    result_type = other.result_type;
    page_index = other.page_index;
    return *this;
  }

  void Set(const foxit::RectFArray& rects, const wchar_t* result_type, int page_index) {
    this->rects = rects;
    this->result_type = result_type;
    this->page_index = page_index;
  }

  foxit::RectFArray rects;
  WString result_type;
  int page_index;
};

class AccessibilityDictionaryTreeItemData FS_FINAL : public Object {
 public:
   typedef enum _DictionaryValueType {
     e_DictionaryValueTypeArray = 0,
     e_DictionaryValueTypeBoolean = 1,
     e_DictionaryValueTypeDictionary = 2,
     e_DictionaryValueTypeFixedPoint = 3,
     e_DictionaryValueTypeInt = 4,
     e_DictionaryValueTypeName = 5,
     e_DictionaryValueTypeString = 6,
     e_DictionaryValueTypeDocClass = 7,
     e_DictionaryValueTypeAttributeObject = 8,
     e_DictionaryValueTypeAttributeClassesRoot = 9,
     e_DictionaryValueTypeDocumentClassesRoot = 10,
     e_DictionaryValueTypeAttributeObjectsRoot = 11
   } DictionaryValueType;
   
   typedef enum _TreeItemStatus {
     e_TreeItemStatusNormal = 0,
     e_TreeItemStatusAdd = 1,
     e_TreeItemStatusDelete = 2,
     e_TreeItemStatusChange = 3
   } TreeItemStatus;
   

  AccessibilityDictionaryTreeItemData()
    : value_type(e_DictionaryValueTypeArray)
    , status(e_TreeItemStatusNormal) {}

  AccessibilityDictionaryTreeItemData(const wchar_t* item_name, const char* item_id, const wchar_t* key,
                                       const wchar_t* value, DictionaryValueType value_type, TreeItemStatus status)
    : item_name(item_name)
    , item_id(item_id)
    , key(key)
    , value(value)
    , value_type(value_type)
    , status(status) {}

  AccessibilityDictionaryTreeItemData(const AccessibilityDictionaryTreeItemData& other) {
    this->item_name = other.item_name;
    this->item_id = other.item_id;
    this->key = other.key;
    this->value = other.value;
    this->value_type = other.value_type;
    this->status = other.status;
  }

  AccessibilityDictionaryTreeItemData& operator=(const AccessibilityDictionaryTreeItemData& other) {
    this->item_name = other.item_name;
    this->item_id = other.item_id;
    this->key = other.key;
    this->value = other.value;
    this->value_type = other.value_type;
    this->status = other.status;
    return *this;
  }

  void Set(const wchar_t* item_name, const char* item_id, const wchar_t* key,
           const wchar_t* value, DictionaryValueType value_type, TreeItemStatus status) {
    this->item_name = item_name;
    this->item_id = item_id;
    this->key = key;
    this->value = value;
    this->value_type = value_type;
    this->status = status;
  }

  WString item_name;
  String item_id;
  WString key;
  WString value;
  DictionaryValueType value_type;
  TreeItemStatus status;
};

FSDK_DEFINE_ARRAY(AccessibilityDictionaryTreeItemDataArray, AccessibilityDictionaryTreeItemData)


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

  AccessibilityDictionaryTreeItem(const AccessibilityDictionaryTreeItemData& item_data,
                                   const AccessibilityDictionaryTreeItemDataArray& children_items_data,
                                   const char* parent_item_id)
    : item_data(item_data)
    , children_items_data(children_items_data)
    , parent_item_id(parent_item_id) {}

  AccessibilityDictionaryTreeItem(const AccessibilityDictionaryTreeItem& other) {
    this->item_data = other.item_data;
    this->children_items_data = other.children_items_data;
    this->parent_item_id = other.parent_item_id;
  }

  AccessibilityDictionaryTreeItem& operator=(const AccessibilityDictionaryTreeItem& other) {
    this->item_data = other.item_data;
    this->children_items_data = other.children_items_data;
    this->parent_item_id = other.parent_item_id;
    return (*this);
  }

  void Set(const AccessibilityDictionaryTreeItemData& item_data,
           const AccessibilityDictionaryTreeItemDataArray& children_items_data,
           const char* parent_item_id) {
    this->item_data = item_data;
    this->children_items_data = children_items_data;
    this->parent_item_id = parent_item_id;
  }

  AccessibilityDictionaryTreeItemData item_data;
  AccessibilityDictionaryTreeItemDataArray children_items_data;
  String parent_item_id;
};

FSDK_DEFINE_ARRAY(AccessibilityDictionaryTreeItemArray, AccessibilityDictionaryTreeItem)


class AccessibilityProviderCallback {
 public:
  virtual void Release() = 0;

  typedef enum _DrawRectType {
    e_DrawRectTypeContent = 0,
    e_DrawRectTypeTableCell = 1,
    e_DrawRectTypeTableFigure = 2,
    e_DrawRectTypeOrderRect = 3,
    e_DrawRectTypeText = 4,
    e_DrawRectTypeTableLabel = 5,
    e_DrawRectTypeLine = 6,
    e_DrawRectTypeLabel = 7,
    e_DrawRectTypeTableCellsType = 8,
    e_DrawRectTypeTableCellsBorder = 9,
    e_DrawRectTypeTableCellsSelectedBorder = 10,
    e_DrawRectTypeTableCellsHeaderBackground = 11,
    e_DrawRectTypeTableCellsDataBackground = 12,
    e_DrawRectTypeTableCellsHeaderBackgroundMultispan = 13,
    e_DrawRectTypeTableCellsDataBackgroundMultispan = 14,
    e_DrawRectTypeTableCellsHeaderBackgroundMissingHeader = 15,
    e_DrawRectTypeTableCellsDataBackgroundMissingHeader = 16
  } DrawRectType;
  

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

  virtual void OnContentChanged(const foxit::pdf::PDFDoc& pdf_doc, int page_index, bool is_notify_self) = 0;

  virtual WString GetDocumentFileName(const foxit::pdf::PDFDoc& pdf_doc) = 0;

  virtual WString GetTextStringByStringID(const WString& string_id) = 0;

  virtual void DrawRect(const foxit::pdf::PDFDoc& pdf_doc, int page_index, DrawRectType type, const AccessibilityRectInfoArray& rect_info_array) = 0;

  virtual void DrawLine(const foxit::pdf::PDFDoc& pdf_doc, int page_index, DrawRectType type, const AccessibilityLineInfoArray& line_info_array) = 0;

  virtual void DrawText(const foxit::pdf::PDFDoc& pdf_doc, int page_index, DrawRectType type, const AccessibilityTextInfoArray& text_info_array) = 0;

 protected:
  ~AccessibilityProviderCallback() {}
};

class AccessibilityCheckResultsCallback {
 public:
  virtual WString GetIdentityName() = 0;

  virtual WString GetIdentityOrganization() = 0;

  virtual WString GetURL(const WString& linkInfo) = 0;

  virtual WString GetTextName(const WString& stringID) = 0;

  virtual void ReportCheckResult(const AccessibilityCheckResultItemDataArray& item_array) = 0;

 protected:
  ~AccessibilityCheckResultsCallback() {}
};

class AccessibilityNavigator FS_FINAL : public Base {
 public:
  typedef enum _FinderType {
    e_FinderTypeInvalid = 0,
    e_FinderTypeArtifacts = 1,
    e_FinderTypeUnmarkedComments = 2,
    e_FinderTypeUnmarkedLinks = 3,
    e_FinderTypeUnmarkedAnnots = 4,
    e_FinderTypeUnmarkedContent = 5,
    e_FinderTypeOcrSuspects = 6
  } FinderType;
  

  explicit AccessibilityNavigator(const foxit::pdf::PDFDoc& pdf_doc);

  explicit AccessibilityNavigator(FS_HANDLE handle);

  ~AccessibilityNavigator();

  AccessibilityNavigator(const AccessibilityNavigator& other);

  AccessibilityNavigator& operator=(const AccessibilityNavigator& other);

  bool operator==(const AccessibilityNavigator& other) const;

  bool operator!=(const AccessibilityNavigator& other) const;

  bool IsEmpty() const;

  void StartFindNextElement();

  AccessibilityFindResult FindNextElement(int page_index, FinderType find_type, bool is_search_page);

  void StopFindNextElement();
};

class AccessibilityChecker FS_FINAL : public Base {
 public:
  explicit AccessibilityChecker(const foxit::pdf::PDFDoc& pdf_doc);

  explicit AccessibilityChecker(FS_HANDLE handle);

  ~AccessibilityChecker();

  AccessibilityChecker(const AccessibilityChecker& other);

  AccessibilityChecker& operator=(const AccessibilityChecker& other);

  bool operator==(const AccessibilityChecker& other) const;

  bool operator!=(const AccessibilityChecker& other) const;

  bool IsEmpty() const;

  bool CanCheck();

  common::Progressive StartCheck(AccessibilityCheckOptions check_options,
                              foxit::common::file::StreamCallback* report_callback,
                              AccessibilityCheckResultsCallback* provider,
                              common::PauseCallback* pause);

  AccessibilityCheckResultItemData RecheckResult(AccessibilityCheckOptions check_options,
                                            const AccessibilityCheckResultItemData& root_data);

  AccessibilityCheckResultItemData RecheckResult(AccessibilityCheckOptions check_options,
                                            const AccessibilityCheckResultItemData& root_data,
                                            const AccessibilityCheckResultSubItemData& sub_item_data);

  AccessibilityCheckResultItemData ChangeCheckStateInResultTree(const AccessibilityCheckResultItemData& root_data,
                                                          const AccessibilityCheckResultSubItemData& sub_item_data,
                                                          const CheckState& new_check_state);

  AccessibilityCheckResultItemData RemoveSkippedStateInResultTree(AccessibilityCheckOptions check_options,
                                                            const AccessibilityCheckResultItemData& root_data,
                                                            const AccessibilityCheckResultSubItemData& sub_item_data);

  String GetTagTreeNodeIDByCheckResultItemID(int page_index, const char* item_id);

  bool UpdateCheckResultReport();

  bool UpdateCheckState(const RuleType& rule_type, const CheckState& check_state);
};

class AccessibilityFixer FS_FINAL : public Base {
 public:
  explicit AccessibilityFixer(const foxit::pdf::PDFDoc& pdf_doc);

  explicit AccessibilityFixer(FS_HANDLE handle);

  ~AccessibilityFixer();

  AccessibilityFixer(const AccessibilityFixer& other);

  AccessibilityFixer& operator=(const AccessibilityFixer& other);

  bool operator==(const AccessibilityFixer& other) const;

  bool operator!=(const AccessibilityFixer& other) const;

  bool IsEmpty() const;

  bool CanFixRules(const RuleType& check_rule, const CheckState& check_state);

  bool CanFixPermissionRules(const RuleType& check_rule, bool is_ocr_enabled);

  bool FixDocumentLanguage(const wchar_t* lang);

  WString FixDocumentTitleWithExistingTitle();

  bool FixDocumentTitle(const wchar_t* title, const wchar_t* subject, const wchar_t* author, const wchar_t* keywords);

  bool FixDocumentBookmark(const WStringArray& roles_array);

  bool FixDocumentPermission();

  bool FixDocumentTag();

  bool FixPageTabOrder();

  bool FixFigureAltText(const AccessibilityCheckResultDetailDataArray& detail_data_array);

  bool FixFormFieldTagged();

  bool FixFormFieldDescriptions();
};

}  // namespace accessibility
}  // namespace addon
}  // namespace foxit
#endif  // FS_ACCESSIBILITY_H_