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_