fs_readingorder.h

浏览该文件的文档.

#ifndef FS_READINGORDER_H_
#define FS_READINGORDER_H_

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

namespace foxit {
namespace addon {
namespace accessibility {
typedef enum _ContentType {
  e_ContentTypeUnknown = 0,
  e_ContentTypeDoc = 1,
  e_ContentTypePage = 2,
  e_ContentTypeEmptyObject = 3,
  e_ContentTypeTextGroup = 4,
  e_ContentTypeTextObject = 5,
  e_ContentTypePathObject = 6,
  e_ContentTypeShadingObject = 7,
  e_ContentTypeImageObject = 8,
  e_ContentTypeAnnotGroup = 9,
  e_ContentTypeAnnot = 10,
  e_ContentTypeContainer = 11,
  e_ContentTypeFormXObject = 12
} ContentType;


class TableCellAttribute FS_FINAL : public Object {
 public:
   typedef enum _TableCellType {
     e_TableCellTypeHeader = 0,
     e_TableCellTypeData = 1
   } TableCellType;
   
  TableCellAttribute()
    : row_span(1)
    , column_span(1)
    , type(e_TableCellTypeHeader) {}

  TableCellAttribute(const TableCellAttribute& other) {
    row_span = other.row_span;
    column_span = other.column_span;
    type = other.type;
    scope = other.scope;
    cell_id = other.cell_id;
    associated_array = other.associated_array;
  }

  TableCellAttribute& operator=(const TableCellAttribute& other) {
    row_span = other.row_span;
    column_span = other.column_span;
    type = other.type;
    scope = other.scope;
    cell_id = other.cell_id;
    associated_array = other.associated_array;
    return *this;
  }

  void Set(int row_span, int column_span, TableCellType type, String scope,
           WString cell_id, WStringArray associated_array) {
    this->row_span = row_span;
    this->column_span = column_span;
    this->type = type;
    this->scope = scope;
    this->cell_id = cell_id;
    this->associated_array = associated_array;
  }

  int row_span;
  int column_span;
  TableCellType type;
  String scope;
  WString cell_id;
  WStringArray associated_array;
};

FSDK_DEFINE_ARRAY(TableCellAttributeArray, TableCellAttribute)


class SelectItemInfo FS_FINAL : public Object {
 public:
  SelectItemInfo()
    : page_index(-1)
    , order_index(-1) {}

  SelectItemInfo(int page_index, int order_index, const foxit::RectF& rect)
    : page_index(page_index)
    , order_index(order_index)
    , rect(rect) {}

  SelectItemInfo(const SelectItemInfo& other) {
    this->page_index = other.page_index;
    this->order_index = other.order_index;
    this->rect = other.rect;
  }

  SelectItemInfo& operator=(const SelectItemInfo& other) {
    this->page_index = other.page_index;
    this->order_index = other.order_index;
    this->rect = other.rect;
    return (*this);
  }

  void Set(int page_index, int order_index, const foxit::RectF& rect) {
    this->page_index = page_index;
    this->order_index = order_index;
    this->rect = rect;
  }

  int page_index;
  int order_index;
  foxit::RectF rect;
};

FSDK_DEFINE_ARRAY(SelectItemInfoArray, SelectItemInfo)


class TreeItemInfo FS_FINAL : public Object {
 public:
  TreeItemInfo()
    : type(e_ContentTypeUnknown)
    , order_index(-1)
    , page_index(-1) {}

  TreeItemInfo(ContentType type, int order_index, int page_index,
               const wchar_t* text, foxit::RectF rect)
    : type(type)
    , order_index(order_index)
    , page_index(page_index)
    , text(text)
    , rect(rect) {}

  TreeItemInfo(const TreeItemInfo& other) {
    this->type = other.type;
    this->order_index = other.order_index;
    this->page_index = other.page_index;
    this->text = other.text;
    this->rect = other.rect;
  }

  TreeItemInfo& operator=(const TreeItemInfo& other) {
    this->type = other.type;
    this->order_index = other.order_index;
    this->page_index = other.page_index;
    this->text = other.text;
    this->rect = other.rect;
    return (*this);
  }

  void Set(ContentType type, int order_index, int page_index,
           const wchar_t* text, foxit::RectF rect) {
    this->type = type;
    this->order_index = order_index;
    this->page_index = page_index;
    this->text = text;
    this->rect = rect;
  }

  ContentType type;
  int order_index;
  int page_index;
  WString text;
  foxit::RectF rect;
};

FSDK_DEFINE_ARRAY(TreeItemInfoArray, TreeItemInfo)


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

  TreeItem(TreeItemInfo item_info, TreeItemInfoArray children_items_info)
    : item_info(item_info)
    , children_items_info(children_items_info) {}

  TreeItem(const TreeItem& other) {
    this->item_info = other.item_info;
    this->children_items_info = other.children_items_info;
  }

  TreeItem& operator=(const TreeItem& other) {
    this->item_info = other.item_info;
    this->children_items_info = other.children_items_info;
    return (*this);
  }

  void Set(TreeItemInfo item_info, TreeItemInfoArray children_items_info) {
    this->item_info = item_info;
    this->children_items_info = children_items_info;
  }

  TreeItemInfo item_info;
  TreeItemInfoArray children_items_info;
};

FSDK_DEFINE_ARRAY(TreeItemArray, TreeItem)


class ReadingOrderOptions FS_FINAL : public Object {
 public:
  typedef enum _ReadingOrderShowType {
    e_ReadingOrderShowTypeOrder = 0,
    e_ReadingOrderShowTypeStruct = 1,
    e_ReadingOrderShowTypeNone = 2
  } ReadingOrderShowType;
  
  
  ReadingOrderOptions()
    : reading_order_show_type(e_ReadingOrderShowTypeStruct)
    , is_show_table_figure(true)
    , is_display_like_element(false)
    , is_show_table_cells(true) {}

  ReadingOrderOptions(ReadingOrderShowType reading_order_show_type, bool is_show_table_figure,
                      bool is_display_like_element, bool is_show_table_cells)
    : reading_order_show_type(reading_order_show_type)
    , is_show_table_figure(is_show_table_figure)
    , is_display_like_element(is_display_like_element)
    , is_show_table_cells(is_show_table_cells) {}

  ReadingOrderOptions(const ReadingOrderOptions& other) {
    this->reading_order_show_type = other.reading_order_show_type;
    this->is_show_table_figure = other.is_show_table_figure;
    this->is_display_like_element = other.is_display_like_element;
    this->is_show_table_cells = other.is_show_table_cells;
  }

  ReadingOrderOptions& operator=(const ReadingOrderOptions& other) {
    this->reading_order_show_type = other.reading_order_show_type;
    this->is_show_table_figure = other.is_show_table_figure;
    this->is_display_like_element = other.is_display_like_element;
    this->is_show_table_cells = other.is_show_table_cells;
    return (*this);
  }

  void Set(ReadingOrderShowType reading_order_show_type, bool is_show_table_figure,
           bool is_display_like_element, bool is_show_table_cells) {
    this->reading_order_show_type = reading_order_show_type;
    this->is_show_table_figure = is_show_table_figure;
    this->is_display_like_element = is_display_like_element;
    this->is_show_table_cells = is_show_table_cells;
  }

  ReadingOrderShowType reading_order_show_type;
  bool is_show_table_figure;
  bool is_display_like_element;
  bool is_show_table_cells;
};

class ContentTreeItemData FS_FINAL : public Object {
 public:
  ContentTreeItemData()
    : page_index(-1)
    , type(e_ContentTypeUnknown) {}

  ContentTreeItemData(WString name, String id, RectFArray rect_array,
                      int page_index, ContentType type)
    : name(name)
    , id(id)
    , rect_array(rect_array)
    , page_index(page_index)
    , type(type) {}

  ContentTreeItemData(const ContentTreeItemData& other) {
    this->name = other.name;
    this->id = other.id;
    this->rect_array = other.rect_array;
    this->page_index = other.page_index;
    this->type = other.type;
  }

  ContentTreeItemData& operator=(const ContentTreeItemData& other) {
    this->name = other.name;
    this->id = other.id;
    this->rect_array = other.rect_array;
    this->page_index = other.page_index;
    this->type = other.type;
    return *this;
  }

  void Set(WString name, String id, RectFArray rect_array, int page_index, ContentType type) {
    this->name = name;
    this->id = id;
    this->rect_array = rect_array;
    this->page_index = page_index;
    this->type = type;
  }

  WString name;
  String id;
  RectFArray rect_array;
  int page_index;
  ContentType type;
};

FSDK_DEFINE_ARRAY(ContentTreeItemDataArray, ContentTreeItemData)


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

  ContentTreeItem(const ContentTreeItemData& item_data,
                  const ContentTreeItemDataArray& children_items_data)
      : item_data(item_data)
      , children_items_data(children_items_data) {}

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

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

  void Set(const ContentTreeItemData& item_data, const ContentTreeItemDataArray& children_items_data) {
    this->item_data = item_data;
    this->children_items_data = children_items_data;
  }

  ContentTreeItemData item_data;
  ContentTreeItemDataArray children_items_data;
};

FSDK_DEFINE_ARRAY(ContentTreeItemArray, ContentTreeItem)


class ReadingOrder FS_FINAL : public Base {
 public:
  typedef enum _TableSelectResult {
    e_TableSelectResultNone = 0,
    e_TableSelectResultNotStarted = 1,
    e_TableSelectResultNotSamePage = 2,
    e_TableSelectResultNoTableExist = 3,
    e_TableSelectResultNotInTable = 4
  } TableSelectResult;
  
  typedef enum _StructureType {
    e_StructureTypeText = 0,
    e_StructureTypeFigure = 1,
    e_StructureTypeFormfield = 2,
    e_StructureTypeFigureOrCaption = 3,
    e_StructureTypeCaption = 4,
    e_StructureTypeH1 = 5,
    e_StructureTypeH2 = 6,
    e_StructureTypeH3 = 7,
    e_StructureTypeH4 = 8,
    e_StructureTypeH5 = 9,
    e_StructureTypeH6 = 10,
    e_StructureTypeTable = 11,
    e_StructureTypeCell = 12,
    e_StructureTypeFormula = 13,
    e_StructureTypeReference = 14,
    e_StructureTypeNote = 15,
    e_StructureTypeBackgroundOrArtifact = 16
  } StructureType;
  

  ReadingOrder(const foxit::pdf::PDFDoc& pdf_doc);

  explicit ReadingOrder(FS_HANDLE handle);

  ~ReadingOrder();

  ReadingOrder(const ReadingOrder& other);

  ReadingOrder& operator=(const ReadingOrder& other);

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

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

  bool IsEmpty() const;

  void SetReadingOrderOptions(const ReadingOrderOptions& options);

  TreeItemArray GetReadingOrderTreeItems();

  bool DrawReadingOrderItems(int page_index);

  bool SetOrderTypeForSelectedTreeItems(StructureType structure_type, const TreeItemInfoArray& select_info_array);

  bool SetOrderTypeForSelectedContent(StructureType structure_type);

  RectFArray AddOrderDataForRect(int page_index, foxit::RectF rect);

  RectFArray RemoveOrderDataForRect(int page_index, foxit::RectF rect);

  bool CanMoveDataOrder(int page_index, const TreeItemInfoArray& select_info_array,
                        const TreeItemInfo& dest_move_item);

  int MoveOrderData(int page_index, Int32Array src_order_index_array, int dest_order_index);

  int DeleteOrderDataStructInfo(foxit::pdf::PDFPage page, Int32Array src_order_index_array, bool is_loaded);

  void ClearPageStructInfo(foxit::pdf::PDFPage page);

  bool ApplyReadingOrder(int page_index, const RectFArray& selected_rect);

  bool SelectTableAtPoint(int page_index, const PointF& point);

  bool StartEditTable(foxit::pdf::PDFPage page);

  bool StartEditTableAtPoint(foxit::pdf::PDFPage page, foxit::PointF point);

  bool EndEditTable();

  bool IsEditingTable();

  WStringArray GetCurrentTableHeaderIDs();

  bool HasMissingHeaderIDs();

  bool GenerateTableHeaderIDs();

  bool HasHeaderID(WString header_id);

  TableCellAttributeArray GetSelectedTableCellAttributes();

  bool SetSelectedTableCellAttributes(TableCellAttribute cell_attribute, bool change_id_enabled,
                                      bool need_change_ids);

  ReadingOrder::TableSelectResult CanSelectTableCellAtPoint(foxit::pdf::PDFPage page, foxit::PointF point);

  ReadingOrder::TableSelectResult SelectTableCellAtPoint(foxit::pdf::PDFPage page, foxit::PointF point,
                                                    foxit::RectFArray& region_selected, bool appended);

  ReadingOrder::TableSelectResult SelectTableCellAtRect(foxit::pdf::PDFPage page, foxit::RectF rect,
                                                   foxit::RectFArray& region_selected, bool appended);

  WString GetTableSummary(foxit::pdf::PDFPage page);

  bool SetTableSummary(foxit::pdf::PDFPage page, const wchar_t* table_summary);

  void SynchronizeTable();

  ContentTreeItemArray GetContentTree();

  StringArray GetAllLeafChildrenByContentItemID(const ContentTreeItemArray& content_tree,
                                                  const String& content_item_id);
};

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