fs_paragraphediting.h

#ifndef FS_PARAGRAPHEDITING_H_
#define FS_PARAGRAPHEDITING_H_

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

namespace foxit {
namespace addon {
namespace pageeditor {
// forward declaration
class ParagraphEditing;
class ParagraphEditingUndoItem;

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

  virtual Matrix GetRenderMatrix(const pdf::PDFDoc& document, int page_index) = 0;

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

  virtual RectF GetClientRect(const pdf::PDFDoc& document) = 0;

  virtual float GetScale(const pdf::PDFDoc& document, int page_index) = 0;

  virtual bool GotoPageView(const pdf::PDFDoc& document, int page_index, float left, float top) = 0;

  virtual Int32Array GetVisiblePageIndexArray(const pdf::PDFDoc& document) = 0;

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

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

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

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

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

  virtual void AddUndoItem(const ParagraphEditingUndoItem& undo_item) = 0;

  virtual void SetDocChangeMark(const pdf::PDFDoc& document) = 0;

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

 protected:
  virtual ~ParagraphEditingProviderCallback() {}
};

class ParagraphEditingUndoItem FS_FINAL : public Base {
 public:
  ParagraphEditingUndoItem(const ParagraphEditingUndoItem& other);

  ~ParagraphEditingUndoItem();

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit ParagraphEditingUndoItem(FS_HANDLE handle);

  ParagraphEditingUndoItem& operator=(const ParagraphEditingUndoItem& other);

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

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

  bool IsEmpty() const;

  void Undo();

  void Redo();
};

class ParagraphEditing FS_FINAL : public Base {
 public:
  typedef enum _BulletType {
    e_BulletTypeNone = 0,
    e_BulletTypeSolidCircle = 1,
    e_BulletTypeSolidRectangle = 2,
    e_BulletTypeSolidDiamond = 3,
    e_BulletTypeCheck = 4,
    e_BulletTypeRightArrow = 5,
    e_BulletTypeInverseTangentCircle = 6,
    e_BulletTypeDiagonalUpRightArrow = 7,
    e_BulletTypeBlackDiamondMinusWhite = 8
  } BulletType;
  
  typedef enum _NumberingType {
    e_NumberingTypeNone = 0,
    e_NumberingTypeDecimalDot = 1,
    e_NumberingTypeDecimalRParen = 2,
    e_NumberingTypeUpperLatinDot = 3,
    e_NumberingTypeLowerLatinRParen = 4,
    e_NumberingTypeLowerLatinDot = 5
  } NumberingType;
  

  ~ParagraphEditing();

  ParagraphEditing(const ParagraphEditing& other);

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit ParagraphEditing(FS_HANDLE handle);

  ParagraphEditing& operator=(const ParagraphEditing& other);

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

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

  bool IsEmpty() const;

  bool Activate();

  bool Deactivate();

  void StartEditing(int page_index, const PointF& start_point, const PointF& end_point);

  void ExitEditing(bool is_end_directly = false);

  bool InsertText(const WString& text);

  bool Render(const Int32Array page_index_array, const common::Renderer& renderer);

  bool OnChar(uint32 char_code);

  bool OnKeyDown(uint32 key_code);

  bool OnKeyUp(uint32 key_code);

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

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

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

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

  bool OnMouseWheel(int page_index, const PointF& point, int32 delta);

  bool CanSelectAll();

  bool SelectAll();

  bool CanDelete();

  bool DeleteSelected();

  bool CanCopy();

  bool CopySelected();

  bool CanCut();

  bool CutSelected();

  bool CanPaste();

  bool PasteSelected();

  bool CanDeselectAll();

  bool DeselectAll();

  void SetFontName(const WString& font_name);

  void SetFontSize(float font_size);

  void SetTextColor(RGB text_color);

  void SetBold(bool is_bold);

  void SetItalic(bool is_italic);

  void SetAlignment(foxit::common::Alignment alignment);

  void SetCharSpace(float char_space);

  void SetCharHorizontalScale(int scale);

  void SetLineSpace(float line_space);

  void SetUnderline(bool is_underline);

  void SetStrikethrough(bool is_striketrough);

  void SetSuperscript(bool is_superscript);

  void SetSubscript(bool is_subscript);

  void SetParagraphSpacing(float paragraph_space);

  void Indent();

  void Dedent();

  void SetBulletedList(BulletType bullet_type);

  void SetNumberedList(NumberingType numbering_type);
};

class JoinSplit FS_FINAL : public Base {
 public:
  typedef enum _JoinSplitOperationType {
    e_JoinSplitOperationTypeJoin = 0,
    e_JoinSplitOperationTypeSpilt = 1,
    e_JoinSplitOperationTypeLink = 2,
    e_JoinSplitOperationTypeUnlink = 3,
    e_JoinSplitOperationTypeSelectNone = 4,
    e_JoinSplitOperationTypeClose = 5
  } JoinSplitOperationType;
  

  ~JoinSplit();

  JoinSplit(const JoinSplit& other);

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit JoinSplit(FS_HANDLE handle);

  JoinSplit& operator=(const JoinSplit& other);

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

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

  bool IsEmpty() const;

  bool Activate();

  bool Deactivate();

  void ExitJoinEditing();

  bool Render(Int32Array page_index_array, const common::Renderer& renderer);

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

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

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

  bool GetEnableStatus(JoinSplit::JoinSplitOperationType type);

  void JoinBoxes();

  void SplitBoxes();

  void LinkBoxes();

  void UnlinkBoxes();

  void SelectNone();
};

class ParagraphEditingMgr FS_FINAL : public Base{
 public:
   explicit ParagraphEditingMgr(ParagraphEditingProviderCallback* callback, const pdf::PDFDoc& document);

   ~ParagraphEditingMgr();

   ParagraphEditingMgr(const ParagraphEditingMgr& other);

   // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
   explicit ParagraphEditingMgr(FS_HANDLE handle = NULL);

   ParagraphEditingMgr& operator=(const ParagraphEditingMgr& other);

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

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

   bool IsEmpty() const;

   ParagraphEditing GetParagraphEditing();

   JoinSplit GetJoinSplit();

   void SetSystemDPI(float horizontal_dpi, float vertical_dpi);
};
}  // namespace pageeditor
}  // namespace addon
}  // namespace foxit
#endif  // FS_PARAGRAPHEDIT_H_