fs_ofdpathobject.h

#ifndef FS_OFD_PATHOBJECT_H_
#define FS_OFD_PATHOBJECT_H_

#include "common/fs_common.h"
#include "fs_ofdgraphicsobject.h"

namespace foxit {
namespace ofd {
namespace graphics {
class OFDPathData;

class PathPoint FS_FINAL : public Object {
 public:
  typedef enum _PathPointType {
    e_PathPointTypeNormal = 0,
    e_PathPointTypeStart = 1,
    e_PathPointTypeMoveTo = 2,
    e_PathPointTypeLineTo = 3,
    e_PathPointTypeQuadraticBezierTo = 4,
    e_PathPointTypeCubicBezierTo = 5,
    e_PathPointTypeArcTo = 6,
    e_PathPointTypeClose = 7
  } PathPointType;
  
  PathPoint()
      : x(0)
      , y(0)
      , type(e_PathPointTypeNormal) {
  }

  PathPoint(float x, float y, PathPointType type) :
    x(x),
    y(x),
    type(type) {
  }

  PathPoint& operator=(const PathPoint& other) {
    this->x = other.x;
    this->y = other.y;
    this->type = other.type;

    return *this;
  }

  void Set(float x, float y, PathPointType type) {
    this->x = x;
    this->y = y;
    this->type = type;
  }

  float           x;

  float           y;

  PathPointType   type;
};

class EllipseInfo FS_FINAL : public Object {
 public:
  EllipseInfo(float x_radius, float y_radius, float rotation_angle, bool large_arc, bool sweep_direction)
   : x_radius(x_radius),
     y_radius(y_radius),
     rotation_angle(rotation_angle),
     large_arc(large_arc),
     sweep_direction(sweep_direction) {
  }

  EllipseInfo& operator=(const EllipseInfo& other) {
    this->x_radius = other.x_radius;
    this->y_radius = other.y_radius;
    this->rotation_angle = other.rotation_angle;
    this->large_arc = other.large_arc;
    this->sweep_direction = other.sweep_direction;

    return *this;
  }

  void Set(float x_radius, float y_radius, float rotation_angle, bool large_arc, bool sweep_direction) {
    this->x_radius = x_radius;
    this->y_radius = y_radius;
    this->rotation_angle = rotation_angle;
    this->large_arc = large_arc;
    this->sweep_direction = sweep_direction;
  }

  float     x_radius;

  float     y_radius;

  float     rotation_angle;

  bool      large_arc;

  bool      sweep_direction;
};

FSDK_DEFINE_ARRAY(PathPointArray, PathPoint)


class OFDPathObject FS_FINAL : public OFDGraphicsObject {
 public:
  typedef enum _PathFillMode {
    e_PathFillNonZero = 0,
    e_PathFillEvenOdd = 1
  } PathFillMode;
  

  explicit OFDPathObject(OFDGraphicsObject object);

  ~OFDPathObject();

  OFDPathObject(const OFDPathObject& other);

  OFDPathObject& operator = (const OFDPathObject& other);

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

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

  bool IsEmpty() const;

  bool IsFill();

  bool IsStroke();

  OFDPathData GetPathData();

  String GetAbbreviatedData();

  PathFillMode GetFillMode();

  void SetFill(bool fill);

  void SetFillMode(PathFillMode fill_mode = e_PathFillNonZero);

  void SetStroke(bool stroke);

  void SetAbbreviatedData(const String& abbreviated_data);

  void SetPathData(const OFDPathData& path);

  explicit OFDPathObject(FS_HANDLE handle);
};

class OFDPathData FS_FINAL : public Base {
 public:
  OFDPathData();

  ~OFDPathData();

  OFDPathData(const OFDPathData& other);

  OFDPathData& operator = (const OFDPathData& other);

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

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

  bool IsEmpty() const;

  void StartFigure(float x, float y);

  void MoveTo(float x, float y);

  void LineTo(float x, float y);

  void QuadraticBezierTo(float x1, float y1, float x2, float y2);

  void CubicBezierTo(float x1, float y1, float x2, float y2, float x3, float y3);

  void ArcTo(EllipseInfo arc_info, float x, float y);

  void AddPoints(PathPointArray& points);

  void CloseFigure();

  void ClearPath();

  void AppendPath(const OFDPathData& path_append);

  void CopyPath(const OFDPathData& path);

  int GetPointCount();

  PathPoint GetPoint(int index);

  explicit OFDPathData(FS_HANDLE handle);
};

}  // namespace graphics
}  // namespace ofd
}  // namespace foxit

#endif  // FS_OFD_PATHOBJECT_H_