fs_pdfpage.h

浏览该文件的文档.

#ifndef FS_PDFPAGE_H_
#define FS_PDFPAGE_H_

#include "common/fs_common.h"
#include "common/fs_image.h"
#ifndef __EMSCRIPTEN_RENDER__
#include "pdf/annots/fs_annot.h"
#endif
#include "pdf/graphics/fs_pdfgraphicsobject.h"
#include "pdf/objects/fs_pdfobject.h"
#ifndef __EMSCRIPTEN_RENDER__
#include "pdf/fs_signature.h"
#endif

namespace foxit {
namespace pdf {
// forward declaration
namespace interform {
class Control;
}  // namespace interform
class PDFDoc;
//class Signature;

class GraphicsObjects : public Base {
 public:
  typedef enum _TextMergeOption {
    e_TextMergeNone  = 0,
    e_TextMergeTJY = 1,
    e_TextMergeBTET = 2
  } TextMergeOption;
  
   // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit GraphicsObjects(FS_HANDLE handle = NULL);
  virtual ~GraphicsObjects();

  GraphicsObjects(const GraphicsObjects& other);

  GraphicsObjects& operator=(const GraphicsObjects& other);

  bool IsEmpty() const;

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

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

  POSITION GetFirstGraphicsObjectPosition(graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll) const;

  POSITION GetNextGraphicsObjectPosition(POSITION position, graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll) const;

  POSITION GetLastGraphicsObjectPosition(graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll) const;

  POSITION GetPrevGraphicsObjectPosition(POSITION position, graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll) const;

  graphics::GraphicsObject* GetGraphicsObject(POSITION position) const;

  POSITION InsertGraphicsObject(POSITION position_insert_after, graphics::GraphicsObject* graphics_object);

  bool RemoveGraphicsObject(graphics::GraphicsObject* graphics_object);

  bool RemoveGraphicsObjectByPosition(POSITION position);

  POSITION MoveGraphicsObjectByPosition(POSITION current_position, POSITION position_move_after);

  POSITION GetGraphicsObjectPosition(graphics::GraphicsObject* graphics_object);

  int GetGraphicsObjectCount() const;

  int GetGraphicsObjectIndex(graphics::GraphicsObject* graphics_object) const;

  graphics::GraphicsObject* GetGraphicsObject(int index) const;

  bool GenerateContent();

  bool GenerateContent(TextMergeOption text_merge_option);
};

class PDFPage FS_FINAL : public GraphicsObjects {
 public:
  typedef enum _ParseFlags {
    e_ParsePageNormal = 0x0000,
    e_ParsePageTextOnly = 0x0001
  } ParseFlags;
  
  typedef enum _CalcMarginMode {
    e_CalcContentsBox  = 0,
    e_CalcDetection = 1
  } CalcMarginMode;
  
  typedef enum _FlattenOptions {
    e_FlattenAll        = 0,
    e_FlattenNoAnnot      = 0x0001,
    e_FlattenNoFormControl  = 0x0002
  } FlattenOptions;
  
  typedef enum _BoxType {
    e_MediaBox = 0,
    e_CropBox = 1,
    e_TrimBox = 2,
    e_ArtBox = 3,
    e_BleedBox = 4
  } BoxType;
  
  typedef enum _Size {
    e_SizeLetter = 1,
    e_SizeLegal = 2,
    e_SizeA2 = 3,
    e_SizeA3 = 4,
    e_SizeA4 = 5,
    e_SizeA5 = 6,
    e_SizeA6 = 7,
    e_SizeB2 = 8,
    e_SizeB3 = 9,
    e_SizeB4 = 10,
    e_SizeB5 = 11,
    e_SizeB6 = 12
  } Size;
  

  PDFPage(const PDFDoc& document, objects::PDFDictionary* page_dict);

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

  explicit PDFPage(const foxit::pdf::GraphicsObjects& other);

  ~PDFPage();

  PDFDoc GetDocument() const;

  objects::PDFDictionary* GetDict() const;

  bool IsParsed() const;

  common::Progressive StartParse(uint32 flags = PDFPage::e_ParsePageNormal, common::PauseCallback* pause = NULL,
                                 bool is_reparse = false);

  int GetIndex() const;

  float GetHeight() const;

  float GetWidth() const;

  common::Rotation GetRotation() const;

  common::Bitmap LoadThumbnail();

  Matrix GetDisplayMatrix(int left, int top, int width, int height, common::Rotation rotate);

  RectF CalcContentBBox(CalcMarginMode mode);

#ifndef __EMSCRIPTEN_RENDER__

  int GetAnnotCount();

  annots::Annot GetAnnot(int index);

  annots::Annot GetAnnotAtPoint(const PointF& position, float tolerance);

  annots::Annot GetAnnotAtDevicePoint(const PointF& position, float tolerance, const Matrix* matrix = NULL);

  annots::AnnotArray GetAnnotsAtPoint(const PointF& position, float tolerance);

  annots::AnnotArray GetAnnotsAtDevicePoint(const PointF& position, float tolerance, const Matrix* matrix = NULL);

  annots::Annot AddAnnot(annots::Annot::Type type, const RectF& rect);

  annots::Annot AddAnnot(objects::PDFDictionary* annot_dict);

  bool RemoveAnnot(const annots::Annot& annot);

  void MoveAnnotToFirst(const annots::Annot& annot);

  void MoveAnnotToLast(const annots::Annot& annot);

  void MoveAnnotToPrev(const annots::Annot& annot);

  void MoveAnnotToNext(const annots::Annot& annot);

  void UpdateAnnotList();
#endif

  bool HasTransparency();

  bool IsScanned();

  bool Flatten(bool for_display, uint32 options = PDFPage::e_FlattenAll);

#ifndef __EMSCRIPTEN_RENDER__

  bool FlattenAnnot(annots::Annot annot);

  bool SetAnnotGroup(const annots::MarkupArray& annot_array, int header_index);

  foxit::pdf::Signature AddSignature(const foxit::RectF& rect);

  foxit::pdf::Signature AddSignature(const foxit::RectF& rect, const foxit::WString& field_name);

  foxit::pdf::Signature AddSignature(const foxit::RectF& rect, const foxit::WString& field_name, foxit::pdf::Signature::SignatureType signature_type, bool to_check_permission = true);

  foxit::pdf::Signature AddSignatureWithExistedVDict(const foxit::RectF& rect, const foxit::WString& field_name, foxit::pdf::Signature::SignatureType signature_type, bool to_check_permission, const foxit::pdf::Signature& existed_signature);
#endif
  
  bool HasWatermark();

  bool RemoveAllWatermarks();

  void SetRotation(common::Rotation rotate);

  void SetSize(float width, float height);
  void SetSize(foxit::pdf::PDFPage::Size size);

  void SetBox(BoxType box_type, const RectF& box);

  RectF GetBox(BoxType box_type);

  float GetUserUnitSize() const;

  void SetUserUnitSize(float user_unit);

  bool Transform(const Matrix& matrix, bool need_transform_clip_path, bool need_transform_annotations = false);

  bool Normalize();

  void SetClipRect(const RectF& clip_rect);

  void SetThumbnail(const common::Bitmap& thumbnail);

  graphics::GraphicsObject* GetGraphicsObjectAtPoint(const PointF& point, float tolerance,
                                                     graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll) const;

  graphics::GraphicsObjectArray GetGraphicsObjectsAtPoint(const PointF& point, float tolerance,
                                                          graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll);

  graphics::GraphicsObject* GetGraphicsObjectAtDevicePoint(const PointF& point, float tolerance,const Matrix* matrix ,
                                                     graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll) const;

  graphics::GraphicsObjectArray GetGraphicsObjectsAtDevicePoint(const PointF& point, float tolerance,const Matrix* matrix,
                                                          graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll);

  graphics::GraphicsObject* GetGraphicsObjectAtRectangle(const RectF& rect, graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll) const;

  graphics::GraphicsObjectArray GetGraphicsObjectsAtRectangle(const RectF& rect, graphics::GraphicsObject::Type filter = graphics::GraphicsObject::e_TypeAll);

  bool AddImage(const common::Image& image, int frame_index, const PointF& position, float width, float height,
                bool auto_generate_content = true);

  bool AddImageFromFilePath(const char* file_path, const PointF& position, float width, float height,
                            bool auto_generate_content = true);

  bool AddImageFromFilePath(const wchar_t* file_path, const PointF& position, float width, float height,
                            bool auto_generate_content = true);

  objects::PDFArray* GetAnnots() const;

  objects::PDFDictionary* GetResources() const;

  objects::PDFObject* GetContents() const;

  objects::PDFStream* GetThumb() const;

  objects::PDFObject* GetInheritedAttribute(const char* attruibute_name) const;

  void ClearRenderCache();

  RectF GetSuggestedRect(const common::Bitmap& render_result, const Matrix& render_matrix, const PointF& point) const;

  bool AddText(const wchar_t* text, const foxit::RectF& rect, const foxit::pdf::RichTextStyle& style, const Matrix& matrix = Matrix(), bool is_each_text = false,bool disable_embed_font = false);

  RectF AddText(const wchar_t* text, const foxit::RectF& rect, const foxit::pdf::RichTextStyle& style, int rotation, common::RotationPointOptions  rotate_point = common::e_RotationPointCenter, bool disable_embed_font = false);

  RectF CalculateNewRectForText(const wchar_t* text, const foxit::RectF& rect, const foxit::pdf::RichTextStyle& style, int rotation, common::RotationPointOptions  rotate_point = common::e_RotationPointCenter, bool disable_embed_font = false);

  graphics::TextObjectArray SplitTextsInRectangle(RectF rect, int split_step);

};
}  // namespace pdf
}  // namespace foxit
#endif  // FS_PDFPAGE_H_