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_