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, bool is_offset_centered)
      : position(position)
      , offset_x(offset_x)
      , offset_y(offset_y)
      , flags(flags)
      , scale_x(scale_x)
      , scale_y(scale_y)
      , rotation(rotation)
      , opacity(opacity)
      , is_offset_centered(is_offset_centered) {}

  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)
      , is_offset_centered(false) {}

  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)
      , is_offset_centered(settings.is_offset_centered) {}

  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;
    is_offset_centered = settings.is_offset_centered;
    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, bool is_offset_centered) {
    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;
    this->is_offset_centered = is_offset_centered;
  }

  common::Position position;
  float offset_x;
  float offset_y;
  uint32 flags;
  float scale_x;
  float scale_y;
  float rotation;
  int opacity;
  bool is_offset_centered;
};

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_