fs_tablegenerator.h

#ifndef FS_TABLEGENERATOR_H_
#define FS_TABLEGENERATOR_H_

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

namespace foxit {
namespace addon {
namespace tablegenerator {
class TableBorderInfo FS_FINAL : public Object{
 public:
  typedef enum _TableBorderStyle {
    e_TableBorderStyleSolid      = 0,
    e_TableBorderStyleDashed = 1
  } TableBorderStyle;
  

  TableBorderInfo()
      : table_border_style(e_TableBorderStyleSolid)
      , line_width(0.0f)
      , color(0xff000000)
      , dash_phase(0.0f)
      , dashes(FloatArray()) {}

  TableBorderInfo(const TableBorderStyle& table_border_style, float line_width, ARGB color, float dash_phase, FloatArray dashes)
    :table_border_style(table_border_style)
    ,line_width(line_width) 
    ,color(color)
    ,dash_phase(dash_phase)
    ,dashes(dashes) {}

  TableBorderInfo(const TableBorderInfo& table_border_info)
    : table_border_style(table_border_info.table_border_style)
    , line_width(table_border_info.line_width)
    , color(table_border_info.color)
    , dash_phase(table_border_info.dash_phase)
    , dashes(table_border_info.dashes) {}

  TableBorderInfo &operator = (const TableBorderInfo& data) {
    table_border_style = data.table_border_style;
    line_width = data.line_width;
    color = data.color;
    dash_phase = data.dash_phase;
    dashes = data.dashes;
    return *this;
  }

  bool operator == (const TableBorderInfo& table_border_info) const {
    if (dashes.GetSize() != table_border_info.dashes.GetSize()) return false;
    for (int i = 0; i < dashes.GetSize(); i++)
      if (dashes.GetAt(i) != table_border_info.dashes.GetAt(i)) return false;

    return (table_border_style == table_border_info.table_border_style &&
            fabs(line_width- table_border_info.line_width) <= FLT_EPSILON &&
            color == table_border_info.color &&
            dash_phase == table_border_info.dash_phase);
  }

  bool operator != (const TableBorderInfo& data) const  {
    return !((*this) == data);
  }

  void Set(const TableBorderStyle& table_border_style, float line_width, ARGB color, float dash_phase, FloatArray dashes) {
    this->table_border_style = table_border_style;
    this->line_width = line_width;
    this->color = color;
    this->dash_phase = dash_phase;
    this->dashes = dashes;
  }

  TableBorderStyle table_border_style;

  float line_width;

  ARGB color;

  float dash_phase;

  FloatArray dashes;
};

class TableCellData;
FSDK_DEFINE_ARRAY(TableCellDataColArray, TableCellData)
FSDK_DEFINE_ARRAY(TableCellDataArray, TableCellDataColArray)

class TableCellData  FS_FINAL : public Object{
 public:
  TableCellData()
    : cell_text_style(foxit::pdf::RichTextStyle())
    , cell_fill_color(0xFFFFFFFF)
    , cell_text(L"")
    , cell_margin(RectF()) {}

  TableCellData(const foxit::pdf::RichTextStyle& cell_text_style, const ARGB cell_fill_color, const WString& cell_text, const foxit::common::Image& cell_image, const RectF& cell_margin)
    :cell_text_style(cell_text_style)
    ,cell_fill_color(cell_fill_color)
    ,cell_text(cell_text)
    ,cell_image(cell_image)
    ,cell_margin(cell_margin) {}

  TableCellData(const TableCellData& data)
    : cell_text_style(data.cell_text_style)
    , cell_fill_color(data.cell_fill_color)
    , cell_text(data.cell_text)
    , cell_image(data.cell_image)
    , cell_margin(data.cell_margin) {}

  TableCellData &operator = (const TableCellData& data) {
    cell_text_style = data.cell_text_style;
    cell_fill_color = data.cell_fill_color;
    cell_text = data.cell_text;
    cell_image = data.cell_image;
    cell_margin = data.cell_margin;
    return *this;
  }

  bool operator == (const TableCellData& data) const {
    return (cell_text_style == data.cell_text_style &&
            cell_fill_color == data.cell_fill_color &&
            cell_text == data.cell_text &&
            cell_image == data.cell_image &&
            cell_margin == data.cell_margin);
  }

  bool operator != (const TableCellData& data) const  {
    return !((*this) == data);
  }

  void Set(const foxit::pdf::RichTextStyle& cell_text_style, const ARGB cell_fill_color, const WString& cell_text, const foxit::common::Image& cell_image, const RectF& cell_margin) {
    this->cell_text_style = cell_text_style;
    this->cell_fill_color = cell_fill_color;
    this->cell_text = cell_text;
    this->cell_image = cell_image;
    this->cell_margin = cell_margin;
  }

  foxit::pdf::RichTextStyle cell_text_style;

  ARGB cell_fill_color;

  WString cell_text;

  foxit::common::Image cell_image;

  RectF cell_margin;
};

typedef CFX_Point TableCellIndex;

FSDK_DEFINE_ARRAY(TableCellIndexArray, TableCellIndex)


class TableData  FS_FINAL : public Object {
 public:
  TableData() : rect(RectF())
    ,row_count(0)
    ,col_count(0)
    ,outside_border_left(TableBorderInfo())
    ,outside_border_right(TableBorderInfo())
    ,outside_border_top(TableBorderInfo())
    ,outside_border_bottom(TableBorderInfo())
    ,inside_border_row(TableBorderInfo())
    ,inside_border_col(TableBorderInfo()) {
  }

  TableData(RectF rect, int row_count, int col_count, TableBorderInfo outside_border_left,
    TableBorderInfo outside_border_right, TableBorderInfo outside_border_top, TableBorderInfo outside_border_bottom,
    TableBorderInfo inside_border_row, TableBorderInfo inside_border_col, TableCellIndexArray merge_cells, FloatArray row_height_array, FloatArray col_width_array)
    :rect(rect)
    ,row_count(row_count)
    ,col_count(col_count)
    ,outside_border_left(outside_border_left)
    ,outside_border_right(outside_border_right)
    ,outside_border_top(outside_border_top)
    ,outside_border_bottom(outside_border_bottom)
    ,inside_border_row(inside_border_row)
    ,inside_border_col(inside_border_col)
    ,merge_cells(merge_cells)
    ,row_height_array(row_height_array)
    ,col_width_array(col_width_array) {
  }

  TableData(const TableData& data)
    :rect(data.rect)
    ,row_count(data.row_count)
    ,col_count(data.col_count)
    ,outside_border_left(data.outside_border_left)
    ,outside_border_right(data.outside_border_right)
    ,outside_border_top(data.outside_border_top)
    ,outside_border_bottom(data.outside_border_bottom)
    ,inside_border_row(data.inside_border_row)
    ,inside_border_col(data.inside_border_col)
    ,merge_cells(data.merge_cells)
    ,row_height_array(data.row_height_array)
    ,col_width_array(data.col_width_array) {
  }

  bool operator == (const TableData& data) const {
    if (merge_cells.GetSize() != data.merge_cells.GetSize()) return false;
    for (size_t i = 0; i < merge_cells.GetSize(); i++)
      if (merge_cells.GetAt(i) != data.merge_cells.GetAt(i)) return false;
    if (row_height_array.GetSize() != data.row_height_array.GetSize()) return false;
    for (int i = 0; i < row_height_array.GetSize(); i++)
      if (fabs(row_height_array.GetAt(i) - data.row_height_array.GetAt(i)) > FLT_EPSILON)  return false;
    if (col_width_array.GetSize() != data.col_width_array.GetSize()) return false;
    for (int i = 0; i < col_width_array.GetSize(); i++)
      if (fabs(col_width_array.GetAt(i) - data.col_width_array.GetAt(i)) > FLT_EPSILON)  return false;
    return (rect == data.rect &&
            row_count == data.row_count &&
            col_count == data.col_count &&
            outside_border_left == data.outside_border_left && 
            outside_border_right == data.outside_border_right &&
            outside_border_top == data.outside_border_top &&
            outside_border_bottom == data.outside_border_bottom &&
            inside_border_row == data.inside_border_row &&
            inside_border_col == data.inside_border_col);
  }

  bool operator != (const TableData& data) const  {
    return !((*this) == data);
  }

  TableData &operator = (const TableData& data) {
    rect = data.rect;
    row_count = data.row_count;
    col_count = data.col_count;
    outside_border_left = data.outside_border_left;
    outside_border_right = data.outside_border_right;
    outside_border_top = data.outside_border_top;
    outside_border_bottom = data.outside_border_bottom;
    inside_border_row = data.inside_border_row;
    inside_border_col = data.inside_border_col;
    merge_cells = data.merge_cells;
    row_height_array = data.row_height_array;
    col_width_array = data.col_width_array;
    return *this;
  }

  void Set(RectF rect, int row_count, int col_count, TableBorderInfo outside_border_left,
    TableBorderInfo outside_border_right, TableBorderInfo outside_border_top, TableBorderInfo outside_border_bottom,
    TableBorderInfo inside_border_row, TableBorderInfo inside_border_col, TableCellIndexArray merge_cells, FloatArray row_height_array, FloatArray col_width_array) {
    this->rect = rect;
    this->row_count = row_count;
    this->col_count = col_count;
    this->outside_border_left = outside_border_left;
    this->outside_border_right = outside_border_right;
    this->outside_border_top = outside_border_top;
    this->outside_border_bottom = outside_border_bottom;
    this->inside_border_row = inside_border_row;
    this->inside_border_col = inside_border_col;
    this->merge_cells = merge_cells;
    this->row_height_array = row_height_array;
    this->col_width_array = col_width_array;
  }

  RectF rect;

  int row_count;

  int col_count;

  TableBorderInfo outside_border_left;

  TableBorderInfo outside_border_right;

  TableBorderInfo outside_border_top;

  TableBorderInfo outside_border_bottom;

  TableBorderInfo inside_border_row;

  TableBorderInfo inside_border_col;

  TableCellIndexArray merge_cells;

  FloatArray row_height_array;

  FloatArray col_width_array;
};

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

  virtual float GetTableTopMarginToPage(int page_index) = 0;

  virtual foxit::pdf::PageBasicInfo GetNewPageBasicInfo(int page_index, float rest_table_height, float table_width) = 0;
};

class TableGenerator FS_FINAL : public Base{
 public:
  static bool AddTableToPage(const foxit::pdf::PDFPage& page, const TableData& data, const TableCellDataArray& cell_array);

  static bool InsertTablePagesToDocument(const foxit::pdf::PDFDoc& doc, int dest_page_index, float page_width, float page_height, const TableData& data, const TableCellDataArray& cell_array, bool allow_to_cross_page, TableGeneratorCallback* tablegenerator_callback = NULL);
};
}
}
}
#endif