fs_annot.h

浏览该文件的文档.

 
#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 PagingSealSignature;
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(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);
  // 强烈建议用户不要使用此方法；否则可能出现未知情况。
  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);
  // 强烈建议用户不要使用此方法；否则可能出现未知情况。
  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);
  // 强烈建议用户不要使用此方法；否则可能出现未知情况。
  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);
  // 强烈建议用户不要使用此方法；否则可能出现未知情况。
  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);
  // 强烈建议用户不要使用此方法；否则可能出现未知情况。
  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);
  // 强烈建议用户不要使用此方法；否则可能出现未知情况。
  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);
 
  // 强烈建议用户不要使用此方法；否则可能出现未知情况。
  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();
 
  // 强烈建议用户不要使用此方法；否则可能出现未知情况。
  explicit PagingSeal(FS_HANDLE handle);
};
 
}  // namespace annots
}  // namespace pdf
}  // namespace foxit
 
#endif  // FS_ANNOT_H_