fs_ofdaction.h

#ifndef FS_OFD_ACTION_H_
#define FS_OFD_ACTION_H_

#include "common/fs_common.h"

namespace foxit {
namespace ofd {
class ActionDestinationInfo FS_FINAL : public Object {
 public:
  typedef enum _GotoDestType {
    e_GotoDestTypeUnknown   =  0,
    e_GotoDestTypeXYZ  =  1,
    e_GotoDestTypeFit  =  2,
    e_GotoDestTypeFitH  =  3,
    e_GotoDestTypeFitV  =  4,
    e_GotoDestTypeFitR  =  5
  } GotoDestType;
  

  explicit ActionDestinationInfo(foxit::uint32 page_id, GotoDestType type, float left, float right, float top, float bottom, float zoom) :
    page_id(page_id),
    type(type),
    left(left),
    right(right),
    top(top),
    bottom(bottom),
    zoom(zoom) {}

  ActionDestinationInfo(const ActionDestinationInfo& other) {
    this->page_id = other.page_id;
    this->type = other.type;
    this->left = other.left;
    this->right = other.right;
    this->top = other.top;
    this->bottom = other.bottom;
    this->zoom = other.zoom;
  }

  ActionDestinationInfo& operator = (const ActionDestinationInfo& other) {
    this->page_id = other.page_id;
    this->type = other.type;
    this->left = other.left;
    this->right = other.right;
    this->top = other.top;
    this->bottom = other.bottom;
    this->zoom = other.zoom;
    return *this;
  }

  void Set(foxit::uint32 page_id, GotoDestType type, float left, float right, float top, float bottom, float zoom) {
    this->page_id = page_id;
    this->type = type;
    this->left = left;
    this->right = right;
    this->top = top;
    this->bottom = bottom;
    this->zoom = zoom;
  }

  foxit::uint32 page_id;

  GotoDestType type;

  float left;

  float right;

  float top;

  float bottom;

  float zoom;
};

class Action : public Base {
 public:
  typedef enum _ActionType {
    e_ActionTypeUnknown   =  0,
    e_ActionTypeGoto  =  1,
    e_ActionTypeUri  =  2,
    e_ActionTypeSound  =  3,
    e_ActionTypeMovie  =  4,
    e_ActionTypeGotoA  =  5
  } ActionType;
  
  typedef enum _ActionEventTriggerType {
    e_ActionEventTriggerTypeDocumentOpen   =  0,
    e_ActionEventTriggerTypePageOpen  =  1,
    e_ActionEventTriggerTypeClick  =  2
  } ActionEventTriggerType;
  

  ~Action();

  Action(const Action& other);

  Action& operator = (const Action& other);

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

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

  bool IsEmpty() const;

  foxit::ofd::Action::ActionType GetType();

  ActionEventTriggerType GetEventTrigger();

  void SetEventTrigger(ActionEventTriggerType event_trigger);

  explicit Action(FS_HANDLE handle);
};

class GoToAction FS_FINAL : public Action {
 public:
  GoToAction();

  explicit GoToAction(Action object);

  ~GoToAction();

  GoToAction(const GoToAction& other);

  GoToAction& operator = (const GoToAction& other);

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

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

  bool IsEmpty() const;

  foxit::ofd::ActionDestinationInfo GetDestination();

  void SetDestination(float x, float y, foxit::uint32 page_id);

  explicit GoToAction(FS_HANDLE handle);
};

class URIAction FS_FINAL : public Action {
 public:
  URIAction();

  explicit URIAction(Action object);

  ~URIAction();

  URIAction(const URIAction& other);

  URIAction& operator = (const URIAction& other);

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

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

  bool IsEmpty() const;

  String GetURI();

  void SetURI(const String& uri);

  explicit URIAction(FS_HANDLE handle);
};

class SoundAction FS_FINAL : public Action {
 public:
  SoundAction();

  explicit SoundAction(Action object);

  ~SoundAction();

  SoundAction(const SoundAction& other);

  SoundAction& operator = (const SoundAction& other);

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

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

  bool IsEmpty() const;

  foxit::uint32 GetResourceID();

  int GetVolume();

  bool IsRepeat();

  bool IsSynchronous();

  void SetResourceID(foxit::uint32 resource_id);

  void SetVolume(int volume);

  void EnableRepeat(bool repeat);

  void EnableSynchronous(bool synchronous);

  explicit SoundAction(FS_HANDLE handle);
};

class MovieAction FS_FINAL : public Action {
 public:
  typedef enum _MovieOperatorType {
    e_MovieOperatorTypePlay   =  0,
    e_MovieOperatorTypeStop  =  1,
    e_MovieOperatorTypePause  =  2,
    e_MovieOperatorTypeResume  =  3
  } MovieOperatorType;
  

  MovieAction();

  explicit MovieAction(Action object);

  ~MovieAction();

  MovieAction(const MovieAction& other);

  MovieAction& operator = (const MovieAction& other);

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

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

  bool IsEmpty() const;

  foxit::uint32 GetResourceID();

  MovieOperatorType GetOperator();

  void SetResourceID(foxit::uint32 resource_id);

  void SetOperator(MovieOperatorType op);

  explicit MovieAction(FS_HANDLE handle);
};

class Actions FS_FINAL : public Base {
 public:
  ~Actions();

  Actions(const Actions& other);

  Actions& operator = (const Actions& other);

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

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

  bool IsEmpty() const;

  int GetActionCount();

  Action GetAction(int index);

  Action AddAction(Action::ActionType type);

  bool RemoveAction(int index);

  explicit Actions(FS_HANDLE handle);
};

}  // namespace ofd
}  // namespace foxit

#endif  // FS_OFD_ACTION_H_