fs_annot.h

Go to the documentation of this file.

#ifndef FS_ANNOT_H_
#define FS_ANNOT_H_

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

namespace foxit {
namespace pdf {
// forward declaration
class PDFPage;
class FileSpec;
class LayerNode;
class GraphicsObjects;
class PagingSealSignature;
namespace actions {
class Action;
class JavaScriptAction;
}  // namespace actions
namespace annots {
class Note;
class Popup;
}  // namespace annots
namespace interform {
class Field;
class Control;
}  // namespace interform

class DefaultAppearance FS_FINAL : public Object {
 public:
  typedef enum _DefAPFlags {
    e_FlagFont = 0x0001,
    e_FlagTextColor = 0x0002,
    e_FlagFontSize = 0x0004
  } DefAPFlags;
  

  DefaultAppearance(uint32 flags, const common::Font& font, float text_size, RGB text_color)
    : flags(flags)
    , font(font)
    , text_size(text_size)
    , text_color(text_color) {}

  DefaultAppearance()
    : flags(0)
    , text_size(0)
    , text_color(0x000000) {}

  DefaultAppearance(const DefaultAppearance& default_appearance)
    : flags(default_appearance.flags)
    , font(default_appearance.font)
    , text_size(default_appearance.text_size)
    , text_color(default_appearance.text_color) {}

  DefaultAppearance& operator = (const DefaultAppearance& default_appearance) {
    flags = default_appearance.flags;
    font = default_appearance.font;
    text_size = default_appearance.text_size;
    text_color = default_appearance.text_color;
    return *this;
  }

  bool operator == (const DefaultAppearance& default_appearance) const {
    return (flags == default_appearance.flags && font == default_appearance.font &&
            fabs(text_size-default_appearance.text_size) <= FLT_EPSILON &&
            text_color == default_appearance.text_color);
  }

  bool operator != (const DefaultAppearance& default_appearance) const  {
    return (flags != default_appearance.flags || font != default_appearance.font ||
            fabs(text_size - default_appearance.text_size) > FLT_EPSILON ||
            text_color != default_appearance.text_color);
  }

  void Set(uint32 flags, const common::Font& font, float text_size, RGB text_color) {
    this->flags = flags;
    this->font = font;
    this->text_size = text_size;
    this->text_color = text_color;
  }

  uint32 flags;

  common::Font font;

  float text_size;

  RGB text_color;
};

class RichTextStyle FS_FINAL : public Object{
 public:
  typedef enum _CornerMarkStyle {
    e_CornerMarkNone = 1,
    e_CornerMarkSuperscript = 2,
    e_CornerMarkSubscript = 3
  } CornerMarkStyle;
  

  RichTextStyle(const common::Font& font, float text_size, common::Alignment text_alignment, RGB text_color,
                bool is_bold, bool is_italic, bool is_underline, bool is_strikethrough, CornerMarkStyle mark_style, float char_space, float word_space)
      : font(font)
      , text_size(text_size)
      , text_alignment(text_alignment)
      , text_color(text_color)
      , is_bold(is_bold)
      , is_italic(is_italic)
      , is_underline(is_underline)
      , is_strikethrough(is_strikethrough)
      , mark_style(mark_style)
      , char_space(char_space)
      , word_space(word_space) {}

  RichTextStyle()
      : text_size(0)
      , text_alignment(common::e_AlignmentLeft)
      , text_color(0x000000)
      , is_bold(false)
      , is_italic(false)
      , is_underline(false)
      , is_strikethrough(false)
      , mark_style(RichTextStyle::e_CornerMarkNone) 
      , char_space(0.0f)
      , word_space(0.0f) {}

  RichTextStyle(const RichTextStyle& style)
    : font(style.font)
    , text_size(style.text_size)
    , text_alignment(style.text_alignment)
    , text_color(style.text_color)
    , is_bold(style.is_bold)
    , is_italic(style.is_italic)
    , is_underline(style.is_underline)
    , is_strikethrough(style.is_strikethrough)
    , mark_style(style.mark_style)
    , char_space(style.char_space)
    , word_space(style.word_space) {}

  RichTextStyle& operator = (const RichTextStyle& style) {
    font = style.font;
    text_size = style.text_size;
    text_alignment = style.text_alignment;
    text_color = style.text_color;
    is_bold = style.is_bold;
    is_italic = style.is_italic;
    is_underline = style.is_underline;
    is_strikethrough = style.is_strikethrough;
    mark_style = style.mark_style;
    char_space = style.char_space;
    word_space = style.word_space;
    return *this;
  }

  bool operator == (const RichTextStyle& style) const {
    return (font == style.font &&
            fabs(text_size- style.text_size) <= FLT_EPSILON &&
            text_alignment == style.text_alignment &&
            text_color == style.text_color &&
            is_bold == style.is_bold &&
            is_italic == style.is_italic &&
            is_underline == style.is_underline &&
            is_strikethrough == style.is_strikethrough &&
            mark_style == style.mark_style &&
            char_space == style.char_space &&
            word_space == style.word_space);
  }

  bool operator != (const RichTextStyle& style) const  {
    return !((*this) == style);
  }

  void Set(const common::Font& font, float text_size, common::Alignment text_alignment, RGB text_color,
           bool is_bold, bool is_italic, bool is_underline, bool is_strikethrough, CornerMarkStyle mark_style, float char_space, float word_space) {
    this->font = font;
    this->text_size = text_size;
    this->text_alignment = text_alignment;
    this->text_color = text_color;
    this->is_bold = is_bold;
    this->is_italic = is_italic;
    this->is_underline = is_underline;
    this->is_strikethrough = is_strikethrough;
    this->mark_style = mark_style;
    this->char_space = char_space;
    this->word_space = word_space;
  }

  common::Font font;

  float text_size;

  common::Alignment text_alignment;

  RGB text_color;

  bool is_bold;

  bool is_italic;

  bool is_underline;

  bool is_strikethrough;

  CornerMarkStyle mark_style;

  float char_space;

  float word_space;
};

namespace annots {
class BorderInfo FS_FINAL : public Object {
 public:
  typedef enum _Style {
    e_Solid      = 0,
    e_Dashed     = 1,
    e_UnderLine  = 2,
    e_Beveled    = 3,
    e_Inset      = 4,
    e_Cloudy     = 5
  } Style;
  

  BorderInfo(float width, Style style, float intensity, float dash_phase, const FloatArray& dashes) {
    this->width = width;
    this->style = style;
    this->cloud_intensity = intensity;
    this->dash_phase = dash_phase;
    this->dashes = dashes;
  }

  BorderInfo()
      : width(1.0f)
      , style(BorderInfo::e_Solid)
      , cloud_intensity(0)
      , dash_phase(0) {}

  ~BorderInfo() {}

  BorderInfo(const BorderInfo& border_info) {
    this->width = border_info.width;
    this->style = border_info.style;
    this->cloud_intensity = border_info.cloud_intensity;
    this->dash_phase = border_info.dash_phase;
    this->dashes = border_info.dashes;
  }

  BorderInfo& operator = (const BorderInfo& border_info) {
    this->width = border_info.width;
    this->style = border_info.style;
    this->cloud_intensity = border_info.cloud_intensity;
    this->dash_phase = border_info.dash_phase;
    this->dashes = border_info.dashes;
    return *this;
  }

  bool operator == (const BorderInfo& border_info) const {
    if (fabs(width - border_info.width) > FLT_EPSILON || style != border_info.style ||
        fabs(cloud_intensity - border_info.cloud_intensity) > FLT_EPSILON ||
        fabs(dash_phase - border_info.dash_phase) > FLT_EPSILON ||
        dashes.GetSize() != border_info.dashes.GetSize())
      return false;
    for (int i=0; i<dashes.GetSize(); i++) {
      if (fabs(dashes[i]-border_info.dashes[i])>FLT_EPSILON)
        return false;
    }
    return true;
  }

  bool operator != (const BorderInfo& border_info) const{
    if (fabs(width - border_info.width) > FLT_EPSILON || style != border_info.style ||
      fabs(cloud_intensity - border_info.cloud_intensity) > FLT_EPSILON ||
      fabs(dash_phase - border_info.dash_phase) > FLT_EPSILON ||
      dashes.GetSize() != border_info.dashes.GetSize())
      return true;
    for (int i=0; i<dashes.GetSize(); i++) {
      if (fabs(dashes[i]-border_info.dashes[i])>FLT_EPSILON)
        return true;
    }
    return false;
  }

  void Set(float width, Style style, float intensity, float dash_phase, const FloatArray& dashes) {
    this->width = width;
    this->style = style;
    this->cloud_intensity = intensity;
    this->dash_phase = dash_phase;
    this->dashes = dashes;
  }

  float width;

  Style style;

  float cloud_intensity;

  float dash_phase;

  FloatArray dashes;
};

class QuadPoints FS_FINAL : public Object {
 public:
  QuadPoints(const PointF& first, const PointF& second, const PointF& third, const PointF& fourth) {
    this->first = first;
    this->second = second;
    this->third = third;
    this->fourth = fourth;
  }

  QuadPoints() {}

  QuadPoints(const QuadPoints& quad_points) {
    first = quad_points.first;
    second = quad_points.second;
    third = quad_points.third;
    fourth = quad_points.fourth;
  }

  QuadPoints& operator = (const QuadPoints& quad_points) {
    first = quad_points.first;
    second = quad_points.second;
    third = quad_points.third;
    fourth = quad_points.fourth;
    return *this;
  }

  bool operator == (const QuadPoints& quad_points) const {
    return (first == quad_points.first && second == quad_points.second &&
            third == quad_points.third && fourth == quad_points.fourth);
  }

  bool operator != (const QuadPoints& quad_points) const {
    return (first != quad_points.first || second != quad_points.second ||
            third != quad_points.third || fourth != quad_points.fourth);
  }

  void Set(const PointF& first, const PointF& second, const PointF& third, const PointF& fourth) {
    this->first = first;
    this->second = second;
    this->third = third;
    this->fourth = fourth;
  }

  PointF  first;
  PointF  second;
  PointF  third;
  PointF  fourth;
};

FSDK_DEFINE_ARRAY(QuadPointsArray, QuadPoints)


class IconFit FS_FINAL : public Object {
 public:
  typedef enum _ScaleWayType {
    e_ScaleWayNone = 0,
    e_ScaleWayAlways = 1,
    e_ScaleWayBigger = 2,
    e_ScaleWaySmaller = 3,
    e_ScaleWayNever = 4
  } ScaleWayType;
  

  IconFit()
      : scale_way_type(e_ScaleWayNone)
      , is_proportional_scaling(false)
      , horizontal_fraction(0)
      , vertical_fraction(0)
      , fit_bounds(false) {}

  IconFit(ScaleWayType type, bool is_proportional_scaling, float horizontal_fraction,
            float vertical_fraction, bool fit_bounds)
      : scale_way_type(type)
      , is_proportional_scaling(is_proportional_scaling)
      , horizontal_fraction(horizontal_fraction)
      , vertical_fraction(vertical_fraction)
      , fit_bounds(fit_bounds) {}

  IconFit(const IconFit& icon_fit)
      : scale_way_type(icon_fit.scale_way_type)
      , is_proportional_scaling(icon_fit.is_proportional_scaling)
      , horizontal_fraction(icon_fit.horizontal_fraction)
      , vertical_fraction(icon_fit.vertical_fraction)
      , fit_bounds(icon_fit.fit_bounds) {}

  IconFit& operator = (const IconFit& icon_fit) {
    scale_way_type = icon_fit.scale_way_type;
    is_proportional_scaling = icon_fit.is_proportional_scaling;
    horizontal_fraction = icon_fit.horizontal_fraction;
    vertical_fraction = icon_fit.vertical_fraction;
    fit_bounds = icon_fit.fit_bounds;
    return *this;
  }

  bool operator == (const IconFit& icon_fit) const {
    return (scale_way_type == icon_fit.scale_way_type &&
            is_proportional_scaling == icon_fit.is_proportional_scaling &&
            fabs(horizontal_fraction - icon_fit.horizontal_fraction) <= FLT_EPSILON &&
            fabs(vertical_fraction - icon_fit.vertical_fraction) <= FLT_EPSILON &&
            fit_bounds == icon_fit.fit_bounds);
  }

  bool operator != (const IconFit& icon_fit) const {
    return (scale_way_type != icon_fit.scale_way_type ||
            is_proportional_scaling != icon_fit.is_proportional_scaling ||
            fabs(horizontal_fraction - icon_fit.horizontal_fraction) > FLT_EPSILON ||
            fabs(vertical_fraction - icon_fit.vertical_fraction) > FLT_EPSILON ||
            fit_bounds != icon_fit.fit_bounds);
  }

  void Set(ScaleWayType type, bool is_proportional_scaling, float horizontal_fraction,
           float vertical_fraction, bool fit_bounds) {
      this->scale_way_type = type;
      this->is_proportional_scaling = is_proportional_scaling;
      this->horizontal_fraction = horizontal_fraction;
      this->vertical_fraction = vertical_fraction;
      this->fit_bounds = fit_bounds;
  }

  ScaleWayType scale_way_type;
  bool is_proportional_scaling;
  float horizontal_fraction;
  float vertical_fraction;
  bool fit_bounds;
};

class Annot : public Base {
 public:
  typedef enum _Type {
    e_UnknownType    = 0,
    e_Note           = 1,
    e_Link           = 2,
    e_FreeText       = 3,
    e_Line           = 4,
    e_Square         = 5,
    e_Circle         = 6,
    e_Polygon        = 7,
    e_PolyLine       = 8,
    e_Highlight      = 9,
    e_Underline      = 10,
    e_Squiggly       = 11,
    e_StrikeOut      = 12,
    e_Stamp          = 13,
    e_Caret          = 14,
    e_Ink            = 15,
    e_PSInk          = 16,
    e_FileAttachment = 17,
    e_Sound          = 18,
    e_Movie          = 19,
    e_Widget         = 20,
    e_Screen         = 21,
    e_PrinterMark    = 22,
    e_TrapNet        = 23,
    e_Watermark      = 24,
    e_3D             = 25,
    e_Popup          = 26,
    e_Redact         = 27,
    e_RichMedia      = 28,
    e_PagingSeal = 29
  } Type;
  
  typedef enum _Flags {
    e_FlagInvisible      = 0x0001,
    e_FlagHidden         = 0x0002,
    e_FlagPrint          = 0x0004,
    e_FlagNoZoom         = 0x0008,
    e_FlagNoRotate       = 0x0010,
    e_FlagNoView         = 0x0020,
    e_FlagReadOnly       = 0x0040,
    e_FlagLocked         = 0x0080,
    e_FlagToggleNoView   = 0x0100,
    e_FlagLockedContents = 0x0200
  } Flags;
  
  typedef enum _HighlightingMode {
    e_HighlightingNone    = 0,
    e_HighlightingInvert  = 1,
    e_HighlightingOutline = 2,
    e_HighlightingPush    = 3,
    e_HighlightingToggle  = 4
  } HighlightingMode;
  
  typedef enum _Property {
    e_PropertyModifiedDate = 0,
    e_PropertyCreationDate = 1,
    e_PropertyBorderColor  = 2,
    e_PropertyFillColor    = 3
  } Property;
  
  typedef enum _MKEntry {
    e_MKEntryRotation = 0,
    e_MKEntryBorderColor = 1,
    e_MKEntryBackgroundColor = 2,
    e_MKEntryNormalCaption = 3,
    e_MKEntryRolloverCaption = 4,
    e_MKEntryDownCaption = 5,
    e_MKEntryNormalIcon = 6,
    e_MKEntryRolloverIcon = 7,
    e_MKEntryDownIcon = 8,
    e_MKEntryIconFit = 9,
    e_MKEntryIconCaptionRelation = 10
  } MKEntry;
  
  typedef enum _MKIconCaptionRelation {
    e_MKRelationNoIcon = 0,
    e_MKRelationNoCaption = 1,
    e_MKRelationCaptionBelowIcon = 2,
    e_MKRelationCaptionAboveIcon = 3,
    e_MKRelationCaptionRight = 4,
    e_MKRelationCaptionLeft = 5,
    e_MKRelationCaptionOvrlayOnIcon = 6
  } MKIconCaptionRelation;
  
  typedef enum _AppearanceType {
    e_AppearanceTypeNormal = 0,
    e_AppearanceTypeRollover = 1,
    e_AppearanceTypeDown = 2
  } AppearanceType;
  

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Annot(FS_HANDLE handle);
  Annot(const PDFPage& page, objects::PDFDictionary* annot_dict);
#ifndef __EMSCRIPTEN_RENDER__

  Annot(const Annot& annot);
#endif

  Annot() {}
#ifndef __EMSCRIPTEN_RENDER__

  Annot& operator = (const Annot& annot);
#endif

  bool operator ==(const Annot& other) const;
  bool operator != (const Annot& other) const;
#ifndef __EMSCRIPTEN_RENDER__

  virtual ~Annot();
#endif

  bool IsEmpty() const;

  PDFPage GetPage() const;
  bool IsMarkup() const;
  Type GetType() const;
  int GetIndex() const;
  WString GetContent() const;
  void SetContent(const WString& content);
  DateTime GetModifiedDateTime() const;
  void SetModifiedDateTime(const DateTime& date_time);
  uint32 GetFlags() const;
  void SetFlags(uint32 flags);
  WString GetUniqueID() const;
  void SetUniqueID(const WString& unique_id);
  RectF GetRect() const;

  Matrix GetDisplayMatrix(const Matrix& page_display_matrix);

  bool Move(const RectF& rect);

  bool Move(const RectF& rect, bool is_reset_appearance);

  BorderInfo GetBorderInfo() const;

  void SetBorderInfo(const BorderInfo& border);
  RGB GetBorderColor() const;
  void SetBorderColor(RGB color);
  bool ResetAppearanceStream();

  bool ResetAppearanceStream(bool is_generate_new_appearance_obj);

  RectI GetDeviceRect(const Matrix& matrix);

  objects::PDFDictionary* GetDict() const;

  bool HasProperty(Property property) const;

  bool RemoveProperty(Property property);

  objects::PDFDictionary* GetOptionalContent() const;

  objects::PDFStream* GetAppearanceStream(AppearanceType type, const char* appearance_state = "") const;
};

FSDK_DEFINE_ARRAY(AnnotArray, Annot)


class ShadingColor FS_FINAL : public Object {
 public:
  ShadingColor(ARGB firstcolor, ARGB secondcolor)
      : first_color(firstcolor)
      , second_color(secondcolor) {}

  ShadingColor()
      : first_color(0xFFFFFFFF)
      , second_color(0xFFFFFFFF) {}

  ShadingColor(const ShadingColor& shading_color)
      : first_color(shading_color.first_color)
      , second_color(shading_color.second_color) {}

  ShadingColor& operator = (const ShadingColor& shading_color) {
    this->first_color = shading_color.first_color;
    this->second_color = shading_color.second_color;
    return *this;
  }

  bool operator == (const ShadingColor& shading_color) const {
    return (first_color == shading_color.first_color && second_color == shading_color.second_color);
  }

  bool operator != (const ShadingColor& shading_color) const {
    return (first_color != shading_color.first_color || second_color != shading_color.second_color);
  }

  void Set(ARGB firstcolor, ARGB secondcolor) {
    this->first_color = firstcolor;
    this->second_color = secondcolor;
  }

  ARGB first_color;
  ARGB second_color;
};

class IconProviderCallback {
 public:
  virtual void Release() = 0;
  virtual String GetProviderID() {
    return String();
  }
  virtual String GetProviderVersion() {
    return String();
  }
  virtual bool HasIcon(Annot::Type annot_type, const char* icon_name) {
    return false;
  }
  virtual bool CanChangeColor(Annot::Type annot_type, const char* icon_name) {
    return false;
  }
#ifndef __EMSCRIPTEN_RENDER__

  virtual PDFPage GetIcon(Annot::Type annot_type, const char* icon_name, ARGB color,
                          foxit::pdf::objects::PDFDictionary* annot_dict);
#endif

  virtual bool GetShadingColor(Annot::Type annot_type, const char* icon_name,
                               RGB referenced_color, int shading_index, ShadingColor& out_shading_color) {
    return false;
  }
  virtual float GetDisplayWidth(Annot::Type annot_type, const char* icon_name) {
    return 0.0f;
  }
  virtual float GetDisplayHeight(Annot::Type annot_type, const char* icon_name) {
    return 0.0f;
  }

 protected:
  ~IconProviderCallback() {}
};

class Markup;
FSDK_DEFINE_ARRAY(MarkupArray, Markup)

class Note;
FSDK_DEFINE_ARRAY(NoteArray, Note)


class Markup : public Annot {
 public:
  typedef enum _StateModel {
    e_StateModelMarked = 1,
    e_StateModelReview = 2
  } StateModel;
  
  typedef enum _State {
    e_StateNone = 0,
    e_StateMarked    = 1,
    e_StateUnmarked  = 2,
    e_StateAccepted  = 3,
    e_StateRejected  = 4,
    e_StateCancelled = 5,
    e_StateCompleted = 6,
    e_StateDeferred = 7,
    e_StateFuture = 8
  } State;
  
  typedef enum _EndingStyle {
    e_EndingStyleNone = 0,
    e_EndingStyleSquare = 1,
    e_EndingStyleCircle = 2,
    e_EndingStyleDiamond = 3,
    e_EndingStyleOpenArrow = 4,
    e_EndingStyleClosedArrow = 5,
    e_EndingStyleButt = 6,
    e_EndingStyleROpenArrow = 7,
    e_EndingStyleRClosedArrow = 8,
    e_EndingStyleSlash = 9
  } EndingStyle;
  
  typedef enum _MeasureType {
    e_MeasureTypeX = 0,
    e_MeasureTypeY = 1,
    e_MeasureTypeD = 2,
    e_MeasureTypeA = 3,
    e_MeasureTypeT = 4,
    e_MeasureTypeS = 5
  } MeasureType;
  

  explicit Markup(const Annot& annot);
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Markup(FS_HANDLE handle);
  Markup() {}

   ~Markup() {}

   Popup GetPopup();
   void SetPopup(const Popup& popup);

   bool RemovePopup();

   WString GetTitle() const;

   void SetTitle(const WString& title);

   WString GetSubject() const;

   void SetSubject(const WString& subject);

   float GetOpacity() const;

   void SetOpacity(float opacity);

   String GetIntent() const;

   void SetIntent(const String& intent);

   DateTime GetCreationDateTime() const;

   void SetCreationDateTime(const DateTime& date_time);

   int GetReplyCount();

   Note GetReply(int index) const;

   Note AddReply();

   bool RemoveReply(int index);

   bool RemoveAllReplies();

   bool IsGrouped();

   Markup GetGroupHeader();

   MarkupArray GetGroupElements();

   bool Ungroup();

   NoteArray GetStateAnnots(StateModel model);

   Note AddStateAnnot(const WString& title, StateModel model, State state);

   bool RemoveAllStateAnnots();
   int32 GetRichTextCount();

   WString GetRichTextContent(int32 index);

   void SetRichTextContent(int32 index, const WString& content);

   RichTextStyle GetRichTextStyle(int32 index);

   void SetRichTextStyle(int32 index, const RichTextStyle& style);

   void AddRichText(const WString& content, const RichTextStyle& style);

   void InsertRichText(int32 index, const WString& content, const RichTextStyle& style);

   void RemoveRichText(int index);

   void SetBorderOpacity(float opacity);

   float GetBorderOpacity() const;

   void SetFillOpacity(float opacity);

   float GetFillOpacity() const;
};

class Note FS_FINAL : public Markup {
 public:
  Note() {}
  explicit Note(const Annot& annot);
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Note(FS_HANDLE handle);
  ~Note() {}

  bool GetOpenStatus() const;
  void SetOpenStatus(bool status);
  String GetIconName() const;
  void SetIconName(const char* icon_name);
  Markup GetReplyTo();
  bool IsStateAnnot();

  StateModel GetStateModel();

  State GetState();

  void SetState(State state);

};

class TextMarkup: public Markup {
 public:
  TextMarkup() {}
  explicit TextMarkup(const Annot& annot);
  ~TextMarkup() {}

   QuadPointsArray GetQuadPoints() const;
   void SetQuadPoints(const QuadPointsArray& quad_points_array);
};

class Highlight FS_FINAL : public TextMarkup {
 public:
  Highlight() {}
  explicit Highlight(const Annot& annot);
  ~Highlight() {}
};

class Underline FS_FINAL : public TextMarkup {
 public:
  Underline() {}
  explicit Underline(const Annot& annot);
  ~Underline() {}
};

class StrikeOut FS_FINAL : public TextMarkup {
 public:
  StrikeOut() {}
  explicit StrikeOut(const Annot& annot);
  ~StrikeOut() {}
};

class Squiggly FS_FINAL : public TextMarkup {
 public:
  Squiggly() {}
  explicit Squiggly(const Annot& annot);
  ~Squiggly() {}
};

class Link FS_FINAL : public Annot {
 public:
  Link() {}
  explicit Link(const Annot& annot);
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Link(FS_HANDLE handle);
   ~Link() {}

  QuadPointsArray GetQuadPoints() const;
  void SetQuadPoints(const QuadPointsArray& quad_points_array);

  HighlightingMode GetHighlightingMode();

  void SetHighlightingMode(HighlightingMode mode);

  actions::Action GetAction();

  void SetAction(const actions::Action& action);

  bool RemoveAction();

  bool ExecuteJavaScriptAction(const actions::JavaScriptAction& javascript_action = actions::JavaScriptAction((FS_HANDLE)NULL));
};

class Square FS_FINAL : public Markup {
 public:
  Square() {}
  explicit Square(const Annot& annot);
  ~Square() {}

  RGB GetFillColor() const;

  void SetFillColor(RGB fill_color);

  RectF GetInnerRect() const;
  void SetInnerRect(const RectF& inner_rect);

  void SetMeasureRatio(const char* ratio);

  String GetMeasureRatio();

  WString GetMeasureRatioW();

  void SetMeasureUnit(MeasureType measure_type, const char* unit);

  String GetMeasureUnit(MeasureType measure_type);

  WString GetMeasureUnitW(MeasureType measure_type);

  void SetMeasureConversionFactor(MeasureType measure_type, float factor);

  float GetMeasureConversionFactor(MeasureType measure_type);
};

class Circle FS_FINAL : public Markup {
 public:
  Circle() {}
  explicit Circle(const Annot& annot);
  ~Circle() {}

  RGB GetFillColor() const;

  void SetFillColor(RGB fill_color);

  RectF GetInnerRect() const;

  void SetInnerRect(const RectF& inner_rect);

  void SetMeasureRatio(const char* ratio);

  String GetMeasureRatio();

  WString GetMeasureRatioW();

  void SetMeasureUnit(MeasureType measure_type, const char* unit);

  String GetMeasureUnit(MeasureType measure_type);

  WString GetMeasureUnitW(MeasureType measure_type);

  void SetMeasureConversionFactor(MeasureType measure_type, float factor);

  float GetMeasureConversionFactor(MeasureType measure_type);
};

class FreeText FS_FINAL : public Markup {
 public:
  FreeText() {}
  explicit FreeText(const Annot& annot);

  ~FreeText() {}

  RGB GetFillColor() const;

  void SetFillColor(RGB fill_color);

  common::Alignment GetAlignment() const;

  void SetAlignment(common::Alignment alignment);

  RectF GetInnerRect() const;

  void SetInnerRect(const RectF& inner_rect);

  DefaultAppearance GetDefaultAppearance();

  bool SetDefaultAppearance(const DefaultAppearance& default_ap);

  EndingStyle GetCalloutLineEndingStyle() const;

  void SetCalloutLineEndingStyle(EndingStyle ending_style);

  PointFArray GetCalloutLinePoints() const;

  void SetCalloutLinePoints(const PointFArray& point_array);

  void SetTextMatrix(const Matrix& text_matrix);

  Matrix GetTextMatrix() const;

  common::Rotation GetRotation();

  void SetRotation(common::Rotation rotation);

  void Rotate(common::Rotation rotation);

  void AllowTextOverflow(bool is_text_overflow);
};

class Line FS_FINAL : public Markup {
 public:
  typedef enum _CapPos {
    e_CapPosInline = 0,
    e_CapPosTop = 1
  } CapPos;
  

  Line() {}
  explicit Line(const Annot& annot);
  ~Line() {}

   EndingStyle GetLineStartStyle() const;
  void SetLineStartStyle(EndingStyle ending_style);
  EndingStyle GetLineEndStyle() const;
  void SetLineEndStyle(EndingStyle ending_style);

  RGB GetStyleFillColor() const;

  void SetStyleFillColor(RGB color);

  PointF GetStartPoint() const;
  void SetStartPoint(const PointF& point);

  PointF GetEndPoint() const;
  void SetEndPoint(const PointF& point);

  bool HasCaption() const;
  void EnableCaption(bool cap);

  CapPos GetCaptionPositionType() const;
  void SetCaptionPositionType(CapPos cap_position);
  Offset GetCaptionOffset() const;
  void SetCaptionOffset(const Offset& offset);

  float GetLeaderLineLength() const;
  void SetLeaderLineLength(float length);
  float GetLeaderLineExtensionLength() const;
  void SetLeaderLineExtensionLength(float extension_length);

  float GetLeaderLineOffset() const;
  void SetLeaderLineOffset(float offset);

  void SetMeasureRatio(const String& ratio);

  String GetMeasureRatio();

  WString GetMeasureRatioW();

  void SetMeasureUnit(MeasureType measure_type, const String& unit);

  String GetMeasureUnit(MeasureType measure_type);

  WString GetMeasureUnitW(MeasureType measure_type);

  void SetMeasureConversionFactor(MeasureType measure_type, float factor);

  float GetMeasureConversionFactor(MeasureType measure_type);
};

class Ink FS_FINAL : public Markup {
 public:
  Ink() {}
  explicit Ink(const Annot& annot);
  ~Ink() {}
  common::Path GetInkList();

  void SetInkList(const common::Path& ink_list);

  void EnableUseBezier(bool use_bezier);

};

class Stamp FS_FINAL : public Markup {
 public:
  Stamp() {}
  explicit Stamp(const Annot& annot);
#ifndef __EMSCRIPTEN_RENDER__

  ~Stamp();
#endif

   String GetIconName() const;
  void SetIconName(const char* icon_name);
  void SetBitmap(const common::Bitmap& bitmap);

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

   void SetRotation(int angle);

  int GetRotation();

  void Rotate(int angle);
};

class Screen FS_FINAL : public Annot {
 public:
  Screen() {}
  explicit Screen(const Annot& annot);
  virtual ~Screen() {}

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

  common::Bitmap GetBitmap();

  pdf::objects::PDFDictionary* GetMKDict() const;

  void SetMKDict(pdf::objects::PDFDictionary* dict);

  void SetRotation(common::Rotation rotate);

  common::Rotation GetRotation();

  float GetOpacity() const;
  void SetOpacity(float opacity);

  WString GetTitle() const;
  void SetTitle(const WString& title);

  actions::Action GetAction();
  void SetAction(const actions::Action& action);
  void RemoveAction();
};

class Polygon FS_FINAL : public Markup {
 public:
  Polygon() {}
  explicit Polygon(const Annot& annot);
  ~Polygon() {}
  RGB GetFillColor() const;

  void SetFillColor(RGB fill_color);

  PointFArray GetVertexes();

  void SetVertexes(const PointFArray& vertexes);

  void SetMeasureRatio(const String& ratio);

  String GetMeasureRatio();

  WString GetMeasureRatioW();

  void SetMeasureUnit(MeasureType measure_type, const String& unit);

  String GetMeasureUnit(MeasureType measure_type);

  WString GetMeasureUnitW(MeasureType measure_type);

  void SetMeasureConversionFactor(MeasureType measure_type, float factor);

  float GetMeasureConversionFactor(MeasureType measure_type);
};

class PolyLine FS_FINAL : public Markup {
 public:
  PolyLine() {}
  explicit PolyLine(const Annot& annot);
  ~PolyLine() {}
  RGB GetStyleFillColor() const;
  void SetStyleFillColor(RGB fill_color);

  PointFArray GetVertexes();

  void SetVertexes(const PointFArray& vertexes);
  EndingStyle GetLineStartStyle() const;
  void SetLineStartStyle(EndingStyle starting_style);
  EndingStyle GetLineEndStyle() const;
  void SetLineEndStyle(EndingStyle ending_style);

  void SetMeasureRatio(const String& ratio);

  String GetMeasureRatio();

  WString GetMeasureRatioW();

  void SetMeasureUnit(MeasureType measure_type, const String& unit);

  String GetMeasureUnit(MeasureType measure_type);

  WString GetMeasureUnitW(MeasureType measure_type);

  void SetMeasureConversionFactor(MeasureType measure_type, float factor);

  float GetMeasureConversionFactor(MeasureType measure_type);
};

class Caret FS_FINAL : public Markup {
 public:
  Caret() {}
  explicit Caret(const Annot& annot);
  ~Caret() {}

  RectF GetInnerRect() const;
  void SetInnerRect(const RectF& inner_rect);
};

class FileAttachment FS_FINAL : public Markup {
 public:
  FileAttachment() {}
  explicit FileAttachment(const Annot& annot);
  ~FileAttachment() {}

  bool SetFileSpec(const FileSpec& file_spec);

  FileSpec GetFileSpec();

  String GetIconName() const;

  void SetIconName(const char* icon_name);
};

class Popup FS_FINAL : public Annot {
 public:
  Popup() {}
  explicit Popup(const Annot& annot);
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Popup(FS_HANDLE handle);
  ~Popup() {}

  bool GetOpenStatus() const;
  void SetOpenStatus(bool status);

  Markup GetParent();
};
#ifndef __FSDK_NO_PSINK__ 

class PSInk FS_FINAL : public Annot {
 public:
  PSInk() {}
  explicit PSInk(const Annot& annot);
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit PSInk(FS_HANDLE handle);
  ~PSInk() {}

};
#endif

class Widget FS_FINAL : public Annot {
 public:
  typedef enum _LineSpacingStyle {
    e_LineSpacingSingle = 0,
    e_LineSpacingOneAndHalf = 1,
    e_LineSpacingDouble = 2,
    e_LineSpacingExactValue = 3,
    e_LineSpacingAuto = 4
  } LineSpacingStyle;
  

  Widget() {}
  explicit Widget(const Annot& annot);
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Widget(FS_HANDLE handle);
#ifndef __EMSCRIPTEN_RENDER__

   ~Widget();
#endif

  interform::Field GetField();

  interform::Control GetControl();

  HighlightingMode GetHighlightingMode();

  void SetHighlightingMode(HighlightingMode mode);

  actions::Action GetAction();

  void SetAction(const actions::Action& action);

  void RemoveAction();

  bool HasMKEntry(MKEntry mk_entry);

  void RemoveMKEntry(MKEntry mk_entry);

  common::Rotation GetMKRotation() const;

  void SetMKRotation(common::Rotation rotation);

  RGB GetMKBorderColor() const;

  void SetMKBorderColor(RGB color);

  RGB GetMKBackgroundColor() const;

  void SetMKBackgroundColor(RGB color);

  WString GetMKNormalCaption() const;

  void SetMKNormalCaption(const wchar_t* caption);

  WString GetMKRolloverCaption() const;

  void SetMKRolloverCaption(const wchar_t* caption);

  WString GetMKDownCaption() const;

  void SetMKDownCaption(const wchar_t* caption);

  common::Bitmap GetMKNormalIconBitmap();

  void SetMKNormalIconBitmap(const common::Bitmap& bitmap);

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

  common::Bitmap GetMKRolloverIconBitmap();

  void SetMKRolloverIconBitmap(const common::Bitmap& bitmap);

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

  common::Bitmap GetMKDownIconBitmap();

  void SetMKDownIconBitmap(const common::Bitmap& bitmap);

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

  IconFit GetMKIconFit() const;

  void SetMKIconFit(const IconFit& icon_fit);

  MKIconCaptionRelation GetMKIconCaptionRelation() const;

  void SetMKIconCaptionRelation(MKIconCaptionRelation relation);

  void SetAppearanceState(const String& appearance_state);

  String GetAppearanceState() const;

  String GetAppearanceOnStateName() const;

  LineSpacingStyle GetLineSpacing(float& line_spacing_value);

  void SetLineSpacing(LineSpacingStyle line_spacing_style, float line_spacing_value);

#ifdef _SUPPORTWEBSDK_
  //Set push button icon form icon stream. stream is from doc::createIcon.
  //face: 0: normal, 1: down, 2: roller
  void  SetButtonIcon(objects::PDFStream* icon, int face);
#endif
};

class Redact FS_FINAL : public Markup {
 public:
  Redact() {}
  explicit Redact(const Annot& annot);
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Redact(FS_HANDLE handle);
#ifndef __EMSCRIPTEN_RENDER__

   ~Redact();
#endif  

  QuadPointsArray GetQuadPoints() const;

  void SetQuadPoints(const QuadPointsArray& quad_points_array);

  RGB GetFillColor() const;
  void SetFillColor(RGB fill_color);

  RGB GetApplyFillColor() const;

  void SetApplyFillColor(RGB fill_color);

  WString GetOverlayText() const;

  void SetOverlayText(const WString& overlay_text);

  bool IsOverlayTextRepeated();

  void EnableRepeatOverlayText(bool is_to_repeat_overlay_text);

  common::Alignment GetOverlayTextAlignment() const;

  void SetOverlayTextAlignment(common::Alignment alignment);

  void EnableAutoFontSize();

  DefaultAppearance GetDefaultAppearance();

  bool SetDefaultAppearance(const DefaultAppearance& default_ap);
        
  bool Apply();

};

class Sound FS_FINAL : public Markup{
 public:
  typedef enum _SampleEncodingFormat {
    e_SampleEncodingFormatRaw = 0,
    e_SampleEncodingFormatSigned = 1,
    e_SampleEncodingFormatMuLaw = 2,
    e_SampleEncodingFormatALaw = 3
  } SampleEncodingFormat;
  

  Sound() {}

  explicit Sound(const Annot& annot);

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Sound(FS_HANDLE handle);

#ifndef __EMSCRIPTEN_RENDER__

  ~Sound();
#endif

  objects::PDFStream* GetSoundStream() const;

  float GetSamplingRate() const;

  int GetChannelCount() const;

  int GetBits() const;

  SampleEncodingFormat GetSampleEncodingFormat() const;

  String GetCompressionFormat() const;

  FileSpec GetFileSpec() const;
};

class PagingSeal FS_FINAL : public Annot {
 public:
  PagingSeal(const Annot& annot);

  ~PagingSeal();

  PagingSealSignature GetPagingSealSignature();

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit PagingSeal(FS_HANDLE handle);
};

}  // namespace annots
}  // namespace pdf
}  // namespace foxit

#endif  // FS_ANNOT_H_