fs_ofdwatermark.h

#ifndef FS_OFD_WATERMARK_H_
#define FS_OFD_WATERMARK_H_

#include "common/fs_common.h"

namespace foxit {
namespace ofd {
class OFDPage;

class TextProperties FS_FINAL : public Object {
 public:
  explicit TextProperties(const String& text, const String& font_name, float font_size, float char_space, foxit::RGB text_color) :
    text(text),
    font_name(font_name),
    font_size(font_size),
    char_space(char_space),
    text_color(text_color) {}

  TextProperties(const TextProperties& settings) {
    this->text = settings.text;
    this->font_name = settings.font_name;
    this->font_size = settings.font_size;
    this->char_space = settings.char_space;
    this->text_color = settings.text_color;
  }

  TextProperties& operator = (const TextProperties& settings) {
    this->text = settings.text;
    this->font_name = settings.font_name;
    this->font_size = settings.font_size;
    this->char_space = settings.char_space;
    this->text_color = settings.text_color;
    return *this;
  }

  void Set(const String& text, const String& font_name, float font_size, float char_space, foxit::RGB text_color) {
    this->text = text;
    this->font_name = font_name;
    this->font_size = font_size;
    this->char_space = char_space;
    this->text_color = text_color;
  }

  bool IsValid() const {
    return !text.IsEmpty() && !font_name.IsEmpty() && font_size > 0;
  }

  String text;

  String font_name;

  float font_size;

  float char_space;

  foxit::RGB text_color;
};

class ImageProperties FS_FINAL : public Object {
 public:
  explicit ImageProperties(foxit::uint32 image_id)
    : image_id(image_id) {}

  ImageProperties(const ImageProperties& settings) {
    this->image_id = settings.image_id;
  }

  ImageProperties& operator = (const ImageProperties& settings) {
    this->image_id = settings.image_id;
    return *this;
  }

  void Set(foxit::uint32 image_id) {
    this->image_id = image_id;
  }

  bool IsValid() const {
    return image_id != 0;
  }

  foxit::uint32 image_id;
};

class BaseWatermarkSettings : public Object {
 public:
  explicit BaseWatermarkSettings(float width, float height, float rotation, foxit::uint8 opacity, bool visible = true, bool printable = true) :
    width(width),
    height(height),
    rotation(rotation),
    opacity(opacity),
    visible(visible),
    printable(printable) {}

  BaseWatermarkSettings(const BaseWatermarkSettings& settings) {
    this->width = settings.width;
    this->height = settings.height;
    this->rotation = settings.rotation;
    this->opacity = settings.opacity;
    this->visible = settings.visible;
    this->printable = settings.printable;
  }

  BaseWatermarkSettings& operator = (const BaseWatermarkSettings& settings) {
    this->width = settings.width;
    this->height = settings.height;
    this->rotation = settings.rotation;
    this->opacity = settings.opacity;
    this->visible = settings.visible;
    this->printable = settings.printable;
    return *this;
  }

  void Set(float width, float height, float rotation, foxit::uint8 opacity, bool visible = true, bool printable = true) {
    this->width = width;
    this->height = height;
    this->rotation = rotation;
    this->opacity = opacity;
    this->visible = visible;
    this->printable = printable;
  }

  virtual bool IsValid() const {
    return width > 0.0f && height > 0.0f && opacity >= 0 && opacity <= 255 && rotation >= 0.0f && rotation < 360.0f;
  }

  float width;

  float height;

  float rotation;

  foxit::uint8 opacity;

  bool visible;

  bool printable;
};

class WatermarkSettings : public BaseWatermarkSettings {
 public:
  explicit WatermarkSettings(float x_pos, float y_pos, float width, float height, float rotation, foxit::uint8 opacity, bool visible = true, bool printable = true) :
    x_pos(x_pos),
    y_pos(y_pos),
    BaseWatermarkSettings(width, height, rotation, opacity, visible, printable) {}

  WatermarkSettings(const WatermarkSettings& settings) :
    BaseWatermarkSettings(settings) {
    this->x_pos = settings.x_pos;
    this->y_pos = settings.y_pos;
  }

  WatermarkSettings& operator = (const WatermarkSettings& settings) {
    this->x_pos = settings.x_pos;
    this->y_pos = settings.y_pos;
    this->width = settings.width;
    this->height = settings.height;
    this->rotation = settings.rotation;
    this->opacity = settings.opacity;
    this->visible = settings.visible;
    this->printable = settings.printable;
    return *this;
  }

  void Set(float x_pos, float y_pos, float width, float height, float rotation, foxit::uint8 opacity, bool visible = true, bool printable = true) {
    this->x_pos = x_pos;
    this->y_pos = y_pos;
    this->width = width;
    this->height = height;
    this->rotation = rotation;
    this->opacity = opacity;
    this->visible = visible;
    this->printable = printable;
  }

  virtual bool IsValid() const {
    return BaseWatermarkSettings::IsValid();
  }

  float x_pos;

  float y_pos;
};

class AlignmentWatermarkSettings FS_FINAL : public BaseWatermarkSettings {
 public:
  typedef enum _WatermarkHAlign {
    e_WatermarkHAlignLeft   =  0,
    e_WatermarkHAlignCenter  =  1,
    e_WatermarkHAlignRight   =  2
  } WatermarkHAlign;
  
  typedef enum _WatermarkVAlign {
    e_WatermarkVAlignTop     =  0,
    e_WatermarkVAlignMiddle  =  1,
    e_WatermarkVAlignBottom  =  2
  } WatermarkVAlign;
  

  explicit AlignmentWatermarkSettings(WatermarkHAlign h_align, WatermarkVAlign v_align, float width, float height, float rotation, foxit::uint8 opacity,
    bool visible = true, bool printable = true) :
    h_align(h_align),
    v_align(v_align),
    BaseWatermarkSettings(width, height, rotation, opacity, visible, printable) {}

  AlignmentWatermarkSettings(const AlignmentWatermarkSettings& settings) :
    BaseWatermarkSettings(settings) {
    this->h_align = settings.h_align;
    this->v_align = settings.v_align;
  }

  AlignmentWatermarkSettings& operator = (const AlignmentWatermarkSettings& settings) {
    this->h_align = settings.h_align;
    this->v_align = settings.v_align;
    this->width = settings.width;
    this->height = settings.height;
    this->rotation = settings.rotation;
    this->opacity = settings.opacity;
    this->visible = settings.visible;
    this->printable = settings.printable;
    return *this;
  }

  void Set(WatermarkHAlign h_align, WatermarkVAlign v_align, float width, float height, float rotation, foxit::uint8 opacity,
    bool visible = true, bool printable = true) {
    this->h_align = h_align;
    this->v_align = v_align;
    this->width = width;
    this->height = height;
    this->rotation = rotation;
    this->opacity = opacity;
    this->visible = visible;
    this->printable = printable;
  }

  virtual bool IsValid() const {
    return BaseWatermarkSettings::IsValid();
  }

  WatermarkHAlign h_align;

  WatermarkVAlign v_align;
};

class TiledWatermarkSettings FS_FINAL : public WatermarkSettings {
 public:
  explicit TiledWatermarkSettings(float x_pos, float y_pos, float width, float height, float rotation, foxit::uint8 opacity,
    float x_step, float y_step, bool visible = true, bool printable = true) :
    x_step(x_step),
    y_step(y_step),
    WatermarkSettings(x_pos, y_pos, width, height, rotation, opacity, visible, printable) {}

  TiledWatermarkSettings(const TiledWatermarkSettings& settings) :
    WatermarkSettings(settings) {
    this->x_step = settings.x_step;
    this->y_step = settings.y_step;
  }

  TiledWatermarkSettings& operator = (const TiledWatermarkSettings& settings) {
    this->x_step = settings.x_step;
    this->y_step = settings.y_step;
    this->x_pos = settings.x_pos;
    this->y_pos = settings.y_pos;
    this->width = settings.width;
    this->height = settings.height;
    this->rotation = settings.rotation;
    this->opacity = settings.opacity;
    this->visible = settings.visible;
    this->printable = settings.printable;
    return *this;
  }

  void Set(float x_pos, float y_pos, float width, float height, float rotation, foxit::uint8 opacity,
    float x_step, float y_step, bool visible = true, bool printable = true) {
    this->x_pos = x_pos;
    this->y_pos = y_pos;
    this->width = width;
    this->height = height;
    this->rotation = rotation;
    this->opacity = opacity;
    this->visible = visible;
    this->printable = printable;
    this->x_step = x_step;
    this->y_step = y_step;
  }

  virtual bool IsValid() const {
    return WatermarkSettings::IsValid() && x_step > 0 && y_step > 0;
  }

  float x_step;

  float y_step;
};

class Watermark FS_FINAL : public Base {
 public:
  explicit Watermark(OFDPage page);

  ~Watermark();

  Watermark(const Watermark& other);

  Watermark& operator = (const Watermark& other);

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

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

  bool AddTextWatermark(const TextProperties& properties, const WatermarkSettings& settings);

  bool AddAlignTextWatermark(const TextProperties& properties, const AlignmentWatermarkSettings& settings);

  bool AddTiledTextWatermark(const TextProperties& properties, const TiledWatermarkSettings& settings);

  bool AddImageWatermark(const ImageProperties& properties, const WatermarkSettings& settings);

  bool AddAlignImageWatermark(const ImageProperties& properties, const AlignmentWatermarkSettings& settings);

  bool AddTiledImageWatermark(const ImageProperties& properties, const TiledWatermarkSettings& settings);

  bool AddRegionTextWatermark(foxit::RectF region, const TextProperties& properties, const TiledWatermarkSettings& settings);

  bool AddRegionImageWatermark(foxit::RectF region, const ImageProperties& properties, const TiledWatermarkSettings& settings);

  bool AddMultiAreaTextWatermark(int h_layout_num, int v_layout_num, const TextProperties& properties, const WatermarkSettings& settings);

  bool AddMultiAreaImageWatermark(int h_layout_num, int v_layout_num, const ImageProperties& properties, const WatermarkSettings& settings);

  explicit Watermark(FS_HANDLE handle);
};

}  // namespace ofd
}  // namespace foxit

#endif  // FS_OFD_WATERMARK_H_