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_