fs_action.h

浏览该文件的文档.

#ifndef FS_ACTION_H_
#define FS_ACTION_H_

#include "common/fs_common.h"
#include "pdf/objects/fs_pdfobject.h"
#include "common/file/fs_file.h"
#include "pdf/fs_rendition.h"

namespace foxit {
namespace pdf {
// forward declaration
class FileSpec;
class PDFDoc;
class PDFPage;
namespace objects {
    class PDFDictionary;
} // namespace objects
namespace annots {
class Annot;
class Screen;
}  // namespace annots
namespace interform {
  class Field;
}  // namespace interform

class Destination FS_FINAL : public Base {
 public:
   typedef enum _ZoomMode {
     e_ZoomXYZ = 1,
     e_ZoomFitPage = 2,
     e_ZoomFitHorz = 3,
     e_ZoomFitVert = 4,
     e_ZoomFitRect = 5,
     e_ZoomFitBBox = 6,
     e_ZoomFitBHorz = 7,
     e_ZoomFitBVert = 8
   } ZoomMode;
   

  static Destination CreateXYZ(const PDFDoc& document, int page_index, float left, float top, float zoom_factor);

  static Destination CreateFitPage(const PDFDoc& document, int page_index) ;

  static Destination CreateFitHorz(const PDFDoc& document, int page_index, float top);

  static Destination CreateFitVert(const PDFDoc& document, int page_index, float left);

  static Destination CreateFitRect(const PDFDoc& document, int page_index,
                                   float left, float bottom, float right, float top);

  static Destination CreateFitBBox(const PDFDoc& document, int page_index);

  static Destination CreateFitBHorz(const PDFDoc& document, int page_index, float top);

  static Destination CreateFitBVert(const PDFDoc& document, int page_index, float left);

  static Destination CreateFromPDFArray(const PDFDoc& document, objects::PDFArray* pdf_array);

  explicit Destination(objects::PDFArray* dest_array);
  ~Destination();
  Destination(const Destination& other);
  Destination& operator = (const Destination& other);

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

  bool IsEmpty() const;

  int GetPageIndex(const PDFDoc& document) const;

  Destination::ZoomMode GetZoomMode() const;

  float GetLeft() const;

  bool IsLeftNull() const;

  float GetTop() const;

  bool IsTopNull() const;

  float GetRight() const;

  float GetBottom() const;

  float GetZoomFactor() const;

  objects::PDFArray* GetDestArray() const;

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

namespace actions{
class Action : public Base {
 public:
  typedef enum _Type {
    e_TypeUnknown = 0,
    e_TypeGoto = 1,
    e_TypeGoToR = 2,
    e_TypeGoToE = 3,
    e_TypeLaunch = 4,
    e_TypeThread = 5,
    e_TypeURI = 6,
    e_TypeSound = 7,
    e_TypeMovie = 8,
    e_TypeHide = 9,
    e_TypeNamed = 10,
    e_TypeSubmitForm = 11,
    e_TypeResetForm = 12,
    e_TypeImportData = 13,
    e_TypeJavaScript = 14,
    e_TypeSetOCGState = 15,
    e_TypeRendition = 16,
    e_TypeTrans = 17,
    e_TypeGoTo3DView = 18
  } Type;
  
  typedef enum _NewWindowFlag {
    e_NewWindowFlagFalse = 0,
    e_NewWindowFlagTrue = 1,
    e_NewWindowFlagNone = 2
  } NewWindowFlag;
  

  static Action Create(const foxit::pdf::PDFDoc& document, Type action_type);

  explicit Action(const PDFDoc& document, objects::PDFDictionary* action_dict);
  Action(const Action& action);
  ~Action();

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

  bool IsEmpty() const;

  Type GetType();

  PDFDoc GetDocument();

  objects::PDFDictionary* GetDict() const;

  int GetSubActionCount();

  Action GetSubAction(int index);

  void SetSubAction(int index, const Action& sub_action);

  void InsertSubAction(int index, const Action& sub_action);

  void RemoveSubAction(int index);

  void RemoveAllSubActions();
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Action(FS_HANDLE handle =  NULL);
};

class GotoAction FS_FINAL : public Action {
 public:
  explicit GotoAction(const Action& action);

  Destination GetDestination();

  void SetDestination(const Destination& dest);
};

class URIAction FS_FINAL : public Action {
 public:
  explicit URIAction(const Action& action);

  String GetURI();

  void SetURI(const String& uri);

  bool IsTrackPosition();

  void SetTrackPositionFlag(bool is_track_position);

};

class JavaScriptAction FS_FINAL : public Action {
 public:
  explicit JavaScriptAction(const Action& action);

  WString GetScript();

  void SetScript(const WString& script);

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

class NamedAction FS_FINAL : public Action {
 public:
  explicit NamedAction(const Action& action);

  String GetName();

  void SetName(const String& name);
};

class RemoteGotoAction FS_FINAL : public Action {
 public:
  explicit RemoteGotoAction(const Action& action);

  Destination GetDestination();

  void SetDestination(const Destination& destination);

  String GetDestinationName();

  void SetDestinationName(const String& dest_name);

  FileSpec GetFileSpec();

  void SetFileSpec(const FileSpec& file_specification);

  NewWindowFlag GetNewWindowFlag();

  void SetNewWindowFlag(NewWindowFlag flag);
};

class EmbeddedGotoTarget FS_FINAL : public Base {
 public:
  explicit EmbeddedGotoTarget(const PDFDoc& document);
  EmbeddedGotoTarget(const foxit::pdf::PDFDoc& document, foxit::pdf::objects::PDFDictionary* target_object);
  ~EmbeddedGotoTarget();

  EmbeddedGotoTarget(const EmbeddedGotoTarget& action);

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

  objects::PDFDictionary* GetDict() const;

  bool IsEmpty() const;

  String GetRelationship();

  void SetRelationship(const String& relationship);

  WString GetAttachedFileName();

  void SetAttachedFileName(const WString& embed_file_name);

  int GetPageIndex();

  void SetPageIndex(int page_index);

  int GetFileAttachmentAnnotIndex();

  void SetFileAttachmentAnnotIndex(int annot_index);

  EmbeddedGotoTarget GetTarget();

  void SetTarget(const EmbeddedGotoTarget& target);

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

class EmbeddedGotoAction FS_FINAL : public Action {
 public:
  explicit EmbeddedGotoAction(const Action& action);

  Destination GetDestination();

  void SetDestination(const Destination& destination);

  String GetDestinationName();

  void SetDestinationName(const String& dest_name);

  FileSpec GetRootFile();

  void SetRootFile(const FileSpec& file_specification);

  NewWindowFlag GetNewWindowFlag();

  void SetNewWindowFlag(NewWindowFlag flag);

  EmbeddedGotoTarget GetTarget();

  void SetTarget(const EmbeddedGotoTarget& target);
};

class SubmitFormAction FS_FINAL : public Action {
 public:
  typedef enum _Flags {
    e_FlagExclude = 0x0001,
    e_FlagIncludeNoValueFields = 0x0002,
    e_FlagExportFormat = 0x0004,
    e_FlagGetMethod = 0x0008,
    e_FlagWithCoordinates = 0x0010,
    e_FlagAsXFDF = 0x0020,
    e_FlagIncludeAppendSaves = 0x0040,
    e_FlagIncludeAnnotations = 0x0080,
    e_FlagSubmitAsPDF = 0x0100,
    e_FlagCanonicalFormat = 0x0200,
    e_FlagExclNonUserAnnots = 0x0400,
    e_FlagExclFKey = 0x0800,
    e_FlagEmbedForm = 0x2000
  } Flags;
  
  explicit SubmitFormAction(const Action& action);

  String GetURL();

  void SetURL(const String& url);

  WStringArray GetFieldNames();

  void SetFieldNames(const WStringArray& field_names);

  uint32 GetFlags();

  void SetFlags(uint32 flags);
};

class ResetFormAction FS_FINAL : public Action {
 public:
  explicit ResetFormAction(const Action& action);

  WStringArray GetFieldNames();

  void SetFieldNames(const WStringArray& field_names);

  uint32 GetFlags();

  void SetFlags(uint32 flags);
};

class ImportDataAction FS_FINAL : public Action {
 public:
  explicit ImportDataAction(const Action& action);

  FileSpec GetFDFFileSpec();

  void SetFDFFileSpec(const FileSpec& file_specification);
};

class HideAction FS_FINAL : public Action {
 public:
  explicit HideAction(const Action& action);

  WStringArray GetFieldNames();

  void SetFieldNames(const WStringArray& field_names);

  bool GetHideState();

  void SetHideState(bool is_hide);
};

class LaunchAction FS_FINAL : public Action {
 public:
  explicit LaunchAction(const Action& action);

  FileSpec GetFileSpec();

  void SetFileSpec(const FileSpec& file_specification);

  NewWindowFlag GetNewWindowFlag();

  void SetNewWindowFlag(NewWindowFlag flag);

  String GetWinFileName();

  String GetWinDefaultDirectory();

  String GetWinAppOperation();

  String GetWinAppParameter();

  void SetWinLaunchParameter(const String& file_name, const String& default_directory,
    const String& operation, const String& app_parameter);

};

class RenditionAction FS_FINAL : public Action {
 public:
  typedef enum _OperationType {
    e_OpTypeNone = -1,
    e_OpTypeAssociate = 0,
    e_OpTypeStop = 1,
    e_OpTypePause = 2,
    e_OpTypeResume = 3,
    e_OpTypePlay = 4
  } OperationType;
  
  explicit RenditionAction(const Action& action);

  OperationType GetOperationType();
  void SetOperationType(OperationType op_type);

  int GetRenditionCount() const;
  Rendition GetRendition(int index);
  void InsertRendition(const Rendition& rendition, int index = -1);
  void RemoveRendition(const Rendition& rendition);

  annots::Screen GetScreenAnnot();
  void SetScreenAnnot(const annots::Screen& screen_annot);

  WString GetJavaScript();
  void SetJavaScript(const WString& script);
};

class SetOCGStateAction FS_FINAL : public Action {
 public:
  typedef enum _OCGState {
    e_OCGStateOn = 0,
    e_OCGStateOff = 1,
    e_OCGStateToggle = 2
  } OCGState;
  

  explicit SetOCGStateAction(const Action& action);

  int GetOCGStateCount() const;

  OCGState GetOCGState(int index) const;

  objects::PDFDictionaryArray GetOCGStateArray(int index) const;

  int InsertOCGStates(const PDFDoc& document, int index, OCGState state, const objects::PDFDictionaryArray& ocg_dict_array);

  bool ReplaceOCGStates(const PDFDoc& document, int index, const objects::PDFDictionaryArray& ocg_dict_array);

  void RemoveOCGStates(int index);

  bool IsRadioButtonStatePreserved() const;

  void SetRadioButtonStatePreserved(bool is_preserved);
};

class AdditionalAction FS_FINAL : public Base {
 public:
  typedef enum _TriggerEvent {
    e_TriggerPageOpened = 0,
    e_TriggerPageClosed = 1,
    e_TriggerDocWillClose = 2,
    e_TriggerDocWillSave = 3,
    e_TriggerDocSaved = 4,
    e_TriggerDocWillPrint = 5,
    e_TriggerDocPrinted = 6,
    e_TriggerFieldKeyStroke = 7,
    e_TriggerFieldWillFormat = 8,
    e_TriggerFieldValueChanged = 9,
    e_TriggerFieldRecalculateValue = 10,
    e_TriggerAnnotCursorEnter = 11,
    e_TriggerAnnotCursorEnter = 11,
    e_TriggerAnnotCursorExit = 12,
    e_TriggerAnnotMouseButtonPressed = 13,
    e_TriggerAnnotMouseButtonReleased = 14,
    e_TriggerAnnotReceiveInputFocus = 15,
    e_TriggerAnnotLoseInputFocus = 16,
    e_TriggerAnnotPageOpened = 17,
    e_TriggerAnnotPageClosed = 18,
    e_TriggerAnnotPageVisible = 19,
    e_TriggerAnnotPageInvisible = 20
  } TriggerEvent;
  
   explicit AdditionalAction(const PDFDoc& doc, objects::PDFDictionary* pdf_dict = NULL);

  explicit AdditionalAction(const foxit::pdf::PDFPage& page);

  explicit AdditionalAction(const foxit::pdf::interform::Field& field);

  explicit AdditionalAction(const foxit::pdf::annots::Annot& annot);

  ~AdditionalAction();

  AdditionalAction(const AdditionalAction& other);
  AdditionalAction& operator = (const AdditionalAction& other);
  bool operator == (const AdditionalAction& other) const;
  bool operator != (const AdditionalAction& other) const;
  bool IsEmpty() const;

  Action GetAction(TriggerEvent trigger);

  void SetAction(TriggerEvent trigger,const Action& action);

  bool RemoveAction(TriggerEvent trigger);

  bool RemoveAllActions();
  
  bool DoJSAction(TriggerEvent trigger);

  objects::PDFDictionary* GetDict() const;

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

}  // namespace actions
}  // namespace pdf
}  // namespace foxit

#endif  // FS_ACTION_H_