fs_pdfgraphicsobject.h

浏览该文件的文档.

#ifndef FS_PDFGRAPHICSOBJECT_H_
#define FS_PDFGRAPHICSOBJECT_H_

#include "common/fs_common.h"
#include "common/file/fs_file.h"
#include "common/fs_image.h"
#include "pdf/objects/fs_pdfobject.h"

namespace foxit {
namespace pdf {
namespace graphics {
class TextObject;
class FormXObject;
class ImageObject;
class PathObject;
class ShadingObject;
}  // namespace graphics
class PDFPage;
class GraphicsObjects;
class LayerNodeArray;
class LayerTree;
}  // namespace pdf

namespace pdf {
namespace graphics {
class ColorState FS_FINAL : public Base {
 public:
  // 强烈建议用户不要使用此方法；否则可能出现未知情况。
  explicit ColorState(FS_HANDLE handle);

  ~ColorState();

  ColorState(const ColorState& other);

  ColorState& operator=(const ColorState& other);

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

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

  bool IsEmpty() const;

  common::Color GetFillColor();

  void SetFillColor(const common::Color& color);

  common::Color GetStrokeColor();
  
  void SetStrokeColor(const common::Color& color);
};

class MarkedContent FS_FINAL : public Object {
 public:
  ~MarkedContent() {}

  bool HasTag(const char* tag_name);
  int GetItemCount() const;
  String GetItemTagName(int index) const;
  int GetItemMCID(int index) const;
  objects::PDFDictionary* GetItemPropertyDict(int index) const;
  int AddItem(const char* tag_name, objects::PDFDictionary* property_dict = NULL);
  bool RemoveItem(const char* tag_name);

 private:
  MarkedContent(const MarkedContent& markedcontent);
  MarkedContent &operator = (const MarkedContent& markedcontent);
};

class GraphicsObject : public Object {
 public:
  typedef enum _BlendMode {
    e_BlendNormal  = 0,
    e_BlendMultiply = 1,
    e_BlendScreen = 2,
    e_BlendOverlay = 3,
    e_BlendDarken = 4,
    e_BlendLighten = 5,
    e_BlendColorDodge = 6,
    e_BlendColorBurn = 7,
    e_BlendHardlight = 8,
    e_BlendSoftlight = 9,
    e_BlendDifference = 10,
    e_BlendExclusion = 11,
    e_BlendHue = 21,
    e_BlendSaturation = 22,
    e_BlendColor = 23,
    e_BlendLuminosity = 24
  } BlendMode;
  
  typedef enum _Type {
    e_TypeAll  = 0,
    e_TypeText = 1,
    e_TypePath = 2,
    e_TypeImage = 3,
    e_TypeShading = 4,
    e_TypeFormXObject = 5,
    e_TypeInlines = 6,
    e_TypeEmptyMarkedContent = 7
  } Type;
  

#if !defined(_SWIG_IOS_) && !defined(_SWIG_MACOC_)

  void Release();
#endif

  Type GetType() const;

  RectF GetRect() const;

  bool HasTransparency();

  ARGB GetStrokeColor() const;

  ARGB GetFillColor() const;

  void SetStrokeColor(ARGB color);

  void SetFillColor(ARGB color);

  ColorState GetColorState() const;

  void SetColorState(const ColorState& color_state);

  void SetFillOpacity(float opacity);

  void SetStrokeOpacity(float opacity);

  float GetFillOpacity() const;
  
  float GetStrokeOpacity()const;

  Matrix GetMatrix() const;

  void SetMatrix(const Matrix& matrix);

  bool Transform(const Matrix& matrix, bool need_transform_clippath);

  GraphicsObject* Clone();

  GraphicsObject* Clone(foxit::pdf::GraphicsObjects src_graphicsobjects, foxit::pdf::GraphicsObjects dest_graphicsobjects);

  common::GraphState GetGraphState() const;

  void SetGraphState(const common::GraphState& graph_state);

  BlendMode GetBlendMode() const;

  void SetBlendMode(BlendMode blend_mode);

  int GetClipPathCount() const;

  common::Path GetClipPath(int index) const;

  common::FillMode GetClipPathFillMode(int index) const;

  bool AddClipPath(const common::Path& path, common::FillMode fill_mode);

  bool RemoveClipPath(int index);

  int GetClipTextObjectCount() const;

  TextObject* GetClipTextObject(int index) const;

  bool AddClipTextObject(TextObject* textobject);

  bool RemoveClipTextObject(int index);

  RectF GetClipRect() const;

  void SetClipRect(const RectF& clip_rect);

  bool ClearClips();

  MarkedContent* GetMarkedContent() const;

  LayerNodeArray GetLayers(const LayerTree& layer_tree);

  TextObject* GetTextObject() const;

  FormXObject* GetFormXObject() const;

  ImageObject* GetImageObject() const;

  PathObject* GetPathObject() const;

  ShadingObject* GetShadingObject() const;

  void Rotate(int angle);
 protected:
  ~GraphicsObject() {}

 private:
  GraphicsObject(const GraphicsObject& graphicsobject);
  GraphicsObject &operator = (const GraphicsObject& graphicsobject);
};

typedef CFX_ArrayTemplate<GraphicsObject*> GraphicsObjectArray;

class TextState FS_FINAL : public Object {
 public:
  typedef enum _Mode {
    e_ModeFill  = 0,
    e_ModeStroke = 1,
    e_ModeFillStroke = 2,
    e_ModeInvisible = 3,
    e_ModeFillClip = 4,
    e_ModeStrokeClip = 5,
    e_ModeFillStrokeClip = 6,
    e_ModeClip = 7
  } Mode;
  

  TextState(uint32 version, const common::Font& font, float font_size, float charspace, float wordspace, Mode textmode,
            const PointF& origin_position, float textmatrix[4]) {
    this->version = version;
    this->font = font;
    this->font_size = font_size;
    this->font_vertical_size = font_size;
    this->font_horizontal_size = font_size;
    this->charspace = charspace;
    this->wordspace = wordspace;
    this->textmode = textmode;
    this->origin_position = origin_position;
    for (int i=0; i < 4; i++)
      this->textmatrix[i] = textmatrix[i];
  }

  TextState()
      :version(1)
      , font_size(0.0f)
      , font_vertical_size(0.0f)
      , font_horizontal_size(0.0f)
      , charspace(0.0f)
      , wordspace(0.0f)
      , textmode(TextState::e_ModeFill) {
    origin_position = PointF();
    this->textmatrix[0] = 1;
    this->textmatrix[1] = 0;
    this->textmatrix[2] = 0;
    this->textmatrix[3] = 1;
  }

  TextState(const TextState& state) {
    version = state.version;
    font = state.font;
    font_size = state.font_size;
    font_vertical_size = state.font_vertical_size;
    font_horizontal_size = state.font_horizontal_size;
    charspace = state.charspace;
    wordspace = state.wordspace;
    textmode = state.textmode;
    origin_position = state.origin_position;
    for (int i=0; i < 4; i++)
      textmatrix[i] = state.textmatrix[i];
  }

  TextState &operator = (const TextState& state) {
    version = state.version;
    font = state.font;
    font_size = state.font_size;
    font_vertical_size = state.font_vertical_size;
    font_horizontal_size = state.font_horizontal_size;
    charspace = state.charspace;
    wordspace = state.wordspace;
    textmode = state.textmode;
    origin_position = state.origin_position;
    for (int i=0; i < 4; i++)
      textmatrix[i] = state.textmatrix[i];
    return (*this);
  }

  void Set(uint32 version, const common::Font& font, float font_size, float charspace, float wordspace,
           Mode textmode, const PointF& origin_position, float textmatrix[4]) {
    this->version = version;
    this->font = font;
    this->font_size = font_size;
    this->font_vertical_size = font_size;
    this->font_horizontal_size = font_size;
    this->charspace = charspace;
    this->wordspace = wordspace;
    this->textmode = textmode;
    this->origin_position = origin_position;
    for (int i=0; i < 4; i++)
      this->textmatrix[i] = textmatrix[i];
  }

  uint32 version;

  common::Font font;

  float font_size;

  float font_vertical_size;

  float font_horizontal_size;

  float charspace;

  float wordspace;

  Mode textmode;

  PointF origin_position;

  float textmatrix[4];
};

class ImageObject FS_FINAL : public GraphicsObject {
 public:
  static ImageObject* Create(const PDFDoc& document);

  void SetBitmap(const common::Bitmap& bitmap, const common::Bitmap& mask = common::Bitmap());

  void SetImage(const common::Image& image, int frame_index);

  common::Bitmap CloneBitmap(const GraphicsObjects& graphics_objects);

  common::Bitmap CloneBitmap(const PDFPage& page, const GraphicsObjects& graphics_objects);

  static ImageObject* CreateFromType3TextObject(const PDFPage& page, TextObject* text_obj);

  common::ColorSpaceType GetColorSpace() const;

  objects::PDFStream* GetStream() const;

  bool IsImageMask() const;

  objects::PDFObject* GetMask() const;

 private:
  ~ImageObject() {}

 private:
  ImageObject(const ImageObject& imageobject);
  ImageObject &operator = (const ImageObject& imageobject);
};

class TextObject FS_FINAL : public GraphicsObject {
 public:
  static TextObject* Create();

  WString GetText() const;

  void SetText(const wchar_t* text);

  void SetText(const WString& text);

  TextState GetTextState(const PDFPage& page) const;

  void SetTextState(const PDFPage& page, const TextState& text_state, bool is_italic, int weight);

  int GetCharCount() const;

  PointF GetCharPos(int index) const;

  float GetCharWidthByIndex(int index) const;

  float GetCharHeightByIndex(int index) const;

 private:
  ~TextObject() {}

 private:
  TextObject(const TextObject& textobject);
  TextObject &operator = (const TextObject& textobject);
};

typedef CFX_ArrayTemplate<TextObject*> TextObjectArray;

class PathObject FS_FINAL : public GraphicsObject {
 public:
  static PathObject* Create();

  static PathObject* CreateFromTextObject(const PDFPage& page, TextObject* text_obj);

  common::FillMode GetFillMode() const;
  void SetFillMode(common::FillMode fill_mode);
  bool GetStrokeState() const;
  void SetStrokeState(bool is_stroke);
  common::Path GetPathData() const;

  void SetPathData(const common::Path& path_data);

 private:
  ~PathObject() {}

 private:
  PathObject(const PathObject& pathobject);
  PathObject &operator = (const PathObject& pathobject);
};

class FormXObject FS_FINAL : public GraphicsObject {
 public:
  static FormXObject* Create(const PDFDoc& document);

  objects::PDFStream* GetStream() const;

  GraphicsObjects GetGraphicsObjects() const;

  bool ImportPageContent(const PDFPage& source_page, bool is_annots_included);

 private:
  ~FormXObject() {}

 private:
  FormXObject(const FormXObject& formxobject);
  FormXObject &operator = (const FormXObject& formxobject);
};

class ShadingObject FS_FINAL : public GraphicsObject {
 public:
  objects::PDFObject* GetPDFObject() const;

 private:
  ~ShadingObject() {}

 private:
  ShadingObject(const ShadingObject& shadingobject);
  ShadingObject &operator = (const ShadingObject& shadingobject);
};
}  // namespace graphics
}  // namespace pdf
}  // namespace foxit
#endif  // FS_PDFGRAPHICSOBJECT_H_