fs_watermark.h

浏览该文件的文档.

 
#ifndef FS_WATERMARK_H_
#define FS_WATERMARK_H_
 
#include "common/fs_common.h"
#include "common/fs_image.h"
#include "pdf/fs_pdfdoc.h"
 
namespace foxit {
namespace pdf {
// forward declaration
class WatermarkSettings;
class WatermarkTextProperties;
 
class Watermark FS_FINAL : public Base {
 public:
  explicit Watermark(const PDFDoc& document, const wchar_t* text, const WatermarkTextProperties& properties,
                     const WatermarkSettings& settings);
 
  explicit Watermark(const foxit::pdf::PDFDoc& document, const foxit::common::Bitmap& bitmap, const foxit::pdf::WatermarkSettings& settings);
 
  explicit Watermark(const foxit::pdf::PDFDoc& document, const foxit::common::Image& image, int frame_index,
                     const foxit::pdf::WatermarkSettings& settings);
 
  explicit Watermark(const foxit::pdf::PDFDoc& document, const foxit::pdf::PDFPage& page, const foxit::pdf::WatermarkSettings& settings);
 
  Watermark(const Watermark& other);
 
  Watermark& operator = (const Watermark& other);
 
  bool operator == (const Watermark& other) const;
  bool operator != (const Watermark& other) const;
 
  ~Watermark();
 
  bool IsEmpty() const;
 
  float GetWidth() const;
 
  float GetHeight() const;
 
  bool InsertToPage(PDFPage page);
 
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Watermark(FS_HANDLE handle =  NULL);
};
 
class WatermarkSettings FS_FINAL : public Object {
 public:
  typedef enum _Flags {
    e_FlagASPageContents = 0x0000,
    e_FlagASAnnot = 0x0001,
    e_FlagOnTop = 0x0002,
    e_FlagNoPrint = 0x0004,
    e_FlagInvisible = 0x0008,
    e_FlagShareImageStream = 0x0010,
    e_FlagShareTextStream = 0x0020,
    e_FlagSharePageStream = 0x0040
  } Flags;
  
 
  explicit WatermarkSettings(const common::Position position, float offset_x, float offset_y, uint32 flags,
                      float scale_x, float scale_y, float rotation, int opacity)
      : position(position)
      , offset_x(offset_x)
      , offset_y(offset_y)
      , flags(flags)
      , scale_x(scale_x)
      , scale_y(scale_y)
      , rotation(rotation)
      , opacity(opacity) {}
 
  WatermarkSettings()
      : position(CommonDefines::e_PosTopLeft)
      , offset_x(0)
      , offset_y(0)
      , flags(0)
      , scale_x(1.0)
      , scale_y(1.0)
      , rotation(0)
      , opacity(100) {}
 
  WatermarkSettings(const WatermarkSettings& settings)
      : position(settings.position)
      , offset_x(settings.offset_x)
      , offset_y(settings.offset_y)
      , flags(settings.flags)
      , scale_x(settings.scale_x)
      , scale_y(settings.scale_y)
      , rotation(settings.rotation)
      , opacity(settings.opacity) {}
 
  WatermarkSettings& operator = (const WatermarkSettings& settings) {
    position = settings.position;
    offset_x = settings.offset_x;
    offset_y = settings.offset_y;
    flags = settings.flags;
    scale_x = settings.scale_x;
    scale_y = settings.scale_y;
    rotation = settings.rotation;
    opacity = settings.opacity;
    return *this;
  }
 
  void Set(const common::Position position, float offset_x, float offset_y, uint32 flags, float scale_x, float scale_y,
           float rotation, int opacity) {
    this->position = position;
    this->offset_x = offset_x;
    this->offset_y = offset_y;
    this->flags = flags;
    this->scale_x = scale_x;
    this->scale_y = scale_y;
    this->rotation = rotation;
    this->opacity = opacity;
  }
 
  common::Position position;
  float offset_x;
  float offset_y;
  uint32 flags;
  float scale_x;
  float scale_y;
  float rotation;
  int opacity;
};
 
class WatermarkTextProperties FS_FINAL : public Object {
 public:
  typedef enum _FontStyle {
    e_FontStyleNormal = 0,
    e_FontStyleUnderline = 1
  } FontStyle;
  
 
  WatermarkTextProperties(const common::Font& font, float font_size, RGB color, FontStyle style, float line_space,
                          CommonDefines::Alignment alignment)
      : font(font)
      , font_size(font_size)
      , color(color)
      , font_style(style)
      , line_space(line_space)
      , alignment(alignment) {}
 
  WatermarkTextProperties()
      : font_size(24.0)
      , color(0x000000)
      , font_style(e_FontStyleNormal)
      , line_space(1.0)
      , alignment(CommonDefines::e_AlignmentLeft) {}
 
  WatermarkTextProperties(const WatermarkTextProperties& properties)
      : font(properties.font)
      , font_size(properties.font_size)
      , color(properties.color)
      , font_style(properties.font_style)
      , line_space(properties.line_space)
      , alignment(properties.alignment) {}
 
  WatermarkTextProperties& operator = (const WatermarkTextProperties& properties) {
    font = properties.font;
    font_size = properties.font_size;
    color = properties.color;
    font_style = properties.font_style;
    line_space = properties.line_space;
    alignment = properties.alignment;
    return *this;
  }
 
  void Set(const common::Font& font, float font_size, RGB color, FontStyle style, float line_space,
           CommonDefines::Alignment alignment) {
    this->font = font;
    this->font_size = font_size;
    this->color = color;
    this->font_style = style;
    this->line_space = line_space;
    this->alignment = alignment;
  }
 
  common::Font font;
  float font_size;
  RGB color;
  FontStyle font_style;
  float line_space;
  CommonDefines::Alignment alignment;
};
}  // namespace pdf
}  // namespace foxit
#endif  // FS_WATERMARK_H_