#if !defined(Magick_Drawable_header)
#define Magick_Drawable_header
#include "Magick++/Include.h"
#include <functional>
#include <string>
#include <list>
#include <utility>
#include "Magick++/Color.h"
#include "Magick++/Geometry.h"
#if defined(MagickDLLExplicitTemplate)
# if defined(MAGICK_PLUSPLUS_IMPLEMENTATION)
# define MagickDrawableExtern
# else
# pragma warning( disable: 4231 )
# define MagickDrawableExtern extern
# endif
#else
# define MagickDrawableExtern
#endif
namespace Magick
{
class MagickPPExport Coordinate
{
public:
Coordinate ( void )
: _x(0),
_y(0)
{ }
Coordinate ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
virtual ~Coordinate ()
{ }
void x ( double x_ )
{
_x = x_;
}
double x ( void ) const
{
return _x;
}
void y ( double y_ )
{
_y = y_;
}
double y ( void ) const
{
return _y;
}
private:
double _x;
double _y;
};
typedef std::list<Magick::Coordinate> CoordinateList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::Coordinate>;
#endif
MagickPPExport int operator == ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator != ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator > ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator < ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator >= ( const Coordinate& left_,
const Coordinate& right_ );
MagickPPExport int operator <= ( const Coordinate& left_,
const Coordinate& right_ );
class MagickPPExport DrawableBase:
public std::unary_function<MagickCore::DrawingWand,void>
{
public:
DrawableBase ( void )
{ }
virtual ~DrawableBase ( void );
virtual void operator()( MagickCore::DrawingWand *) const = 0;
virtual DrawableBase* copy() const = 0;
private:
};
#undef Drawable
class MagickPPExport Drawable
{
public:
Drawable ( void );
Drawable ( const DrawableBase& original_ );
~Drawable ( void );
Drawable ( const Drawable& original_ );
Drawable& operator= (const Drawable& original_ );
void operator()( MagickCore::DrawingWand *context_ ) const;
private:
DrawableBase* dp;
};
MagickPPExport int operator == ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator != ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator > ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator < ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator >= ( const Drawable& left_,
const Drawable& right_ );
MagickPPExport int operator <= ( const Drawable& left_,
const Drawable& right_ );
typedef std::list<Magick::Drawable> DrawableList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::Drawable>;
#endif
class MagickPPExport VPathBase
{
public:
VPathBase ( void )
{ }
virtual ~VPathBase ( void );
virtual void operator()( MagickCore::DrawingWand *context_ ) const = 0;
virtual VPathBase* copy() const = 0;
};
class MagickPPExport VPath
{
public:
VPath ( void );
VPath ( const VPathBase& original_ );
virtual ~VPath ( void );
VPath ( const VPath& original_ );
VPath& operator= (const VPath& original_ );
void operator()( MagickCore::DrawingWand *context_ ) const;
private:
VPathBase* dp;
};
MagickPPExport int operator == ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator != ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator > ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator < ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator >= ( const VPath& left_,
const VPath& right_ );
MagickPPExport int operator <= ( const VPath& left_,
const VPath& right_ );
typedef std::list<Magick::VPath> VPathList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::VPath>;
#endif
class MagickPPExport DrawableAffine : public DrawableBase
{
public:
DrawableAffine ( double sx_, double sy_,
double rx_, double ry_,
double tx_, double ty_ );
DrawableAffine ( void );
~DrawableAffine( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void sx( const double sx_ )
{
_affine.sx = sx_;
}
double sx( void ) const
{
return _affine.sx;
}
void sy( const double sy_ )
{
_affine.sy = sy_;
}
double sy( void ) const
{
return _affine.sy;
}
void rx( const double rx_ )
{
_affine.rx = rx_;
}
double rx( void ) const
{
return _affine.rx;
}
void ry( const double ry_ )
{
_affine.ry = ry_;
}
double ry( void ) const
{
return _affine.ry;
}
void tx( const double tx_ )
{
_affine.tx = tx_;
}
double tx( void ) const
{
return _affine.tx;
}
void ty( const double ty_ )
{
_affine.ty = ty_;
}
double ty( void ) const
{
return _affine.ty;
}
private:
MagickCore::AffineMatrix _affine;
};
class MagickPPExport DrawableArc : public DrawableBase
{
public:
DrawableArc ( double startX_, double startY_,
double endX_, double endY_,
double startDegrees_, double endDegrees_ )
: _startX(startX_),
_startY(startY_),
_endX(endX_),
_endY(endY_),
_startDegrees(startDegrees_),
_endDegrees(endDegrees_)
{ }
~DrawableArc( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void startX( double startX_ )
{
_startX = startX_;
}
double startX( void ) const
{
return _startX;
}
void startY( double startY_ )
{
_startY = startY_;
}
double startY( void ) const
{
return _startY;
}
void endX( double endX_ )
{
_endX = endX_;
}
double endX( void ) const
{
return _endX;
}
void endY( double endY_ )
{
_endY = endY_;
}
double endY( void ) const
{
return _endY;
}
void startDegrees( double startDegrees_ )
{
_startDegrees = startDegrees_;
}
double startDegrees( void ) const
{
return _startDegrees;
}
void endDegrees( double endDegrees_ )
{
_endDegrees = endDegrees_;
}
double endDegrees( void ) const
{
return _endDegrees;
}
private:
double _startX;
double _startY;
double _endX;
double _endY;
double _startDegrees;
double _endDegrees;
};
class MagickPPExport DrawableBezier : public DrawableBase
{
public:
DrawableBezier ( const CoordinateList &coordinates_ );
DrawableBezier ( const DrawableBezier& original_ );
~DrawableBezier ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport DrawablePopClipPath : public DrawableBase
{
public:
DrawablePopClipPath ( void )
: _dummy(0)
{
}
~DrawablePopClipPath ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
class MagickPPExport DrawablePushClipPath : public DrawableBase
{
public:
DrawablePushClipPath ( const std::string &id_);
DrawablePushClipPath ( const DrawablePushClipPath& original_ );
~DrawablePushClipPath ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
std::string _id;
};
class MagickPPExport DrawableClipPath : public DrawableBase
{
public:
DrawableClipPath ( const std::string &id_ );
DrawableClipPath ( const DrawableClipPath& original_ );
~DrawableClipPath ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void clip_path( const std::string &id_ )
{
_id = id_.c_str();
}
std::string clip_path( void ) const
{
return _id;
}
private:
std::string _id;
};
class MagickPPExport DrawableCircle : public DrawableBase
{
public:
DrawableCircle ( double originX_, double originY_,
double perimX_, double perimY_ )
: _originX(originX_),
_originY(originY_),
_perimX(perimX_),
_perimY(perimY_)
{
}
~DrawableCircle ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void originX( double originX_ )
{
_originX = originX_;
}
double originX( void ) const
{
return _originX;
}
void originY( double originY_ )
{
_originY = originY_;
}
double originY( void ) const
{
return _originY;
}
void perimX( double perimX_ )
{
_perimX = perimX_;
}
double perimX( void ) const
{
return _perimX;
}
void perimY( double perimY_ )
{
_perimY = perimY_;
}
double perimY( void ) const
{
return _perimY;
}
private:
double _originX;
double _originY;
double _perimX;
double _perimY;
};
class MagickPPExport DrawableColor : public DrawableBase
{
public:
DrawableColor ( double x_, double y_,
PaintMethod paintMethod_ )
: _x(x_),
_y(y_),
_paintMethod(paintMethod_)
{ }
~DrawableColor ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
void paintMethod( PaintMethod paintMethod_ )
{
_paintMethod = paintMethod_;
}
PaintMethod paintMethod( void ) const
{
return _paintMethod;
}
private:
double _x;
double _y;
PaintMethod _paintMethod;
};
class MagickPPExport Image;
class MagickPPExport DrawableCompositeImage : public DrawableBase
{
public:
DrawableCompositeImage ( double x_, double y_,
const std::string &filename_ );
DrawableCompositeImage ( double x_, double y_,
const Image &image_ );
DrawableCompositeImage ( double x_, double y_,
double width_, double height_,
const std::string &filename_ );
DrawableCompositeImage ( double x_, double y_,
double width_, double height_,
const Image &image_ );
DrawableCompositeImage ( double x_, double y_,
double width_, double height_,
const std::string &filename_,
CompositeOperator composition_ );
DrawableCompositeImage ( double x_, double y_,
double width_, double height_,
const Image &image_,
CompositeOperator composition_ );
DrawableCompositeImage ( const DrawableCompositeImage& original_ );
~DrawableCompositeImage( void );
DrawableCompositeImage& operator=
(const DrawableCompositeImage& original_ );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void composition( CompositeOperator composition_ )
{
_composition = composition_;
}
CompositeOperator composition( void ) const
{
return _composition;
}
void filename( const std::string &image_ );
std::string filename( void ) const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
void width( double width_ )
{
_width = width_;
}
double width( void ) const
{
return _width;
}
void height( double height_ )
{
_height = height_;
}
double height( void ) const
{
return _height;
}
void image( const Image &image_ );
Magick::Image image( void ) const;
void magick( std::string magick_ );
std::string magick( void );
private:
CompositeOperator _composition;
double _x;
double _y;
double _width;
double _height;
Image* _image;
};
class MagickPPExport DrawableDensity : public DrawableBase
{
public:
DrawableDensity(const std::string &density_);
~DrawableDensity(void);
void operator()(MagickCore::DrawingWand *context_) const;
DrawableBase* copy() const;
private:
std::string _density;
};
class MagickPPExport DrawableEllipse : public DrawableBase
{
public:
DrawableEllipse ( double originX_, double originY_,
double radiusX_, double radiusY_,
double arcStart_, double arcEnd_ )
: _originX(originX_),
_originY(originY_),
_radiusX(radiusX_),
_radiusY(radiusY_),
_arcStart(arcStart_),
_arcEnd(arcEnd_)
{ }
~DrawableEllipse( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void originX( double originX_ )
{
_originX = originX_;
}
double originX( void ) const
{
return _originX;
}
void originY( double originY_ )
{
_originY = originY_;
}
double originY( void ) const
{
return _originY;
}
void radiusX( double radiusX_ )
{
_radiusX = radiusX_;
}
double radiusX( void ) const
{
return _radiusX;
}
void radiusY( double radiusY_ )
{
_radiusY = radiusY_;
}
double radiusY( void ) const
{
return _radiusY;
}
void arcStart( double arcStart_ )
{
_arcStart = arcStart_;
}
double arcStart( void ) const
{
return _arcStart;
}
void arcEnd( double arcEnd_ )
{
_arcEnd = arcEnd_;
}
double arcEnd( void ) const
{
return _arcEnd;
}
private:
double _originX;
double _originY;
double _radiusX;
double _radiusY;
double _arcStart;
double _arcEnd;
};
class MagickPPExport DrawableFillColor : public DrawableBase
{
public:
DrawableFillColor ( const Color &color_ );
DrawableFillColor ( const DrawableFillColor& original_ );
~DrawableFillColor( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void color( const Color &color_ )
{
_color = color_;
}
Color color( void ) const
{
return _color;
}
private:
Color _color;
};
class MagickPPExport DrawableFillRule : public DrawableBase
{
public:
DrawableFillRule ( const FillRule fillRule_ )
: _fillRule(fillRule_)
{
}
~DrawableFillRule ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void fillRule( const FillRule fillRule_ )
{
_fillRule = fillRule_;
}
FillRule fillRule( void ) const
{
return _fillRule;
}
private:
FillRule _fillRule;
};
class MagickPPExport DrawableFillOpacity : public DrawableBase
{
public:
DrawableFillOpacity ( double opacity_ )
: _opacity(opacity_)
{
}
~DrawableFillOpacity ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void opacity( double opacity_ )
{
_opacity = opacity_;
}
double opacity( void ) const
{
return _opacity;
}
private:
double _opacity;
};
class MagickPPExport DrawableFont : public DrawableBase
{
public:
DrawableFont ( const std::string &font_ );
DrawableFont ( const std::string &family_,
StyleType style_,
const unsigned int weight_,
StretchType stretch_ );
DrawableFont ( const DrawableFont& original_ );
~DrawableFont ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void font( const std::string &font_ )
{
_font = font_;
}
std::string font( void ) const
{
return _font;
}
private:
std::string _font;
std::string _family;
StyleType _style;
unsigned int _weight;
StretchType _stretch;
};
class MagickPPExport DrawableGravity : public DrawableBase
{
public:
DrawableGravity ( GravityType gravity_ )
: _gravity(gravity_)
{
}
~DrawableGravity ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void gravity( GravityType gravity_ )
{
_gravity = gravity_;
}
GravityType gravity( void ) const
{
return _gravity;
}
private:
GravityType _gravity;
};
class MagickPPExport DrawableLine : public DrawableBase
{
public:
DrawableLine ( double startX_, double startY_,
double endX_, double endY_ )
: _startX(startX_),
_startY(startY_),
_endX(endX_),
_endY(endY_)
{ }
~DrawableLine ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void startX( double startX_ )
{
_startX = startX_;
}
double startX( void ) const
{
return _startX;
}
void startY( double startY_ )
{
_startY = startY_;
}
double startY( void ) const
{
return _startY;
}
void endX( double endX_ )
{
_endX = endX_;
}
double endX( void ) const
{
return _endX;
}
void endY( double endY_ )
{
_endY = endY_;
}
double endY( void ) const
{
return _endY;
}
private:
double _startX;
double _startY;
double _endX;
double _endY;
};
class MagickPPExport DrawableMatte : public DrawableBase
{
public:
DrawableMatte ( double x_, double y_,
PaintMethod paintMethod_ )
: _x(x_),
_y(y_),
_paintMethod(paintMethod_)
{ }
~DrawableMatte ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
void paintMethod( PaintMethod paintMethod_ )
{
_paintMethod = paintMethod_;
}
PaintMethod paintMethod( void ) const
{
return _paintMethod;
}
private:
double _x;
double _y;
PaintMethod _paintMethod;
};
class MagickPPExport DrawablePath : public DrawableBase
{
public:
DrawablePath ( const VPathList &path_ );
DrawablePath ( const DrawablePath& original_ );
~DrawablePath ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
VPathList _path;
};
class MagickPPExport DrawablePoint : public DrawableBase
{
public:
DrawablePoint ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
~DrawablePoint ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x;
double _y;
};
class MagickPPExport DrawablePointSize : public DrawableBase
{
public:
DrawablePointSize ( double pointSize_ )
: _pointSize(pointSize_)
{ }
~DrawablePointSize ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void pointSize( double pointSize_ )
{
_pointSize = pointSize_;
}
double pointSize( void ) const
{
return _pointSize;
}
private:
double _pointSize;
};
class MagickPPExport DrawablePolygon : public DrawableBase
{
public:
DrawablePolygon ( const CoordinateList &coordinates_ );
DrawablePolygon ( const DrawablePolygon& original_ );
~DrawablePolygon ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport DrawablePolyline : public DrawableBase
{
public:
DrawablePolyline ( const CoordinateList &coordinates_ );
DrawablePolyline ( const DrawablePolyline& original_ );
~DrawablePolyline ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport DrawablePopGraphicContext : public DrawableBase
{
public:
DrawablePopGraphicContext ( void )
: _dummy(0)
{
}
~DrawablePopGraphicContext ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
class MagickPPExport DrawablePushGraphicContext : public DrawableBase
{
public:
DrawablePushGraphicContext ( void )
: _dummy(0)
{
}
~DrawablePushGraphicContext ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
class MagickPPExport DrawablePopPattern : public DrawableBase
{
public:
DrawablePopPattern ( void )
: _dummy(0)
{
}
~DrawablePopPattern ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
class MagickPPExport DrawablePushPattern : public DrawableBase
{
public:
DrawablePushPattern ( const std::string &id_, ::ssize_t x_, ::ssize_t y_,
size_t width_, size_t height_ );
DrawablePushPattern ( const DrawablePushPattern& original_ );
~DrawablePushPattern ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
private:
std::string _id;
::ssize_t _x;
::ssize_t _y;
size_t _width;
size_t _height;
};
class MagickPPExport DrawableRectangle : public DrawableBase
{
public:
DrawableRectangle ( double upperLeftX_, double upperLeftY_,
double lowerRightX_, double lowerRightY_ )
: _upperLeftX(upperLeftX_),
_upperLeftY(upperLeftY_),
_lowerRightX(lowerRightX_),
_lowerRightY(lowerRightY_)
{ }
~DrawableRectangle ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void upperLeftX( double upperLeftX_ )
{
_upperLeftX = upperLeftX_;
}
double upperLeftX( void ) const
{
return _upperLeftX;
}
void upperLeftY( double upperLeftY_ )
{
_upperLeftY = upperLeftY_;
}
double upperLeftY( void ) const
{
return _upperLeftY;
}
void lowerRightX( double lowerRightX_ )
{
_lowerRightX = lowerRightX_;
}
double lowerRightX( void ) const
{
return _lowerRightX;
}
void lowerRightY( double lowerRightY_ )
{
_lowerRightY = lowerRightY_;
}
double lowerRightY( void ) const
{
return _lowerRightY;
}
private:
double _upperLeftX;
double _upperLeftY;
double _lowerRightX;
double _lowerRightY;
};
class MagickPPExport DrawableRotation : public DrawableBase
{
public:
DrawableRotation ( double angle_ )
: _angle( angle_ )
{ }
~DrawableRotation ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void angle( double angle_ )
{
_angle = angle_;
}
double angle( void ) const
{
return _angle;
}
private:
double _angle;
};
class MagickPPExport DrawableRoundRectangle : public DrawableBase
{
public:
DrawableRoundRectangle ( double centerX_, double centerY_,
double width_, double hight_,
double cornerWidth_, double cornerHeight_ )
: _centerX(centerX_),
_centerY(centerY_),
_width(width_),
_hight(hight_),
_cornerWidth(cornerWidth_),
_cornerHeight(cornerHeight_)
{ }
~DrawableRoundRectangle ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void centerX( double centerX_ )
{
_centerX = centerX_;
}
double centerX( void ) const
{
return _centerX;
}
void centerY( double centerY_ )
{
_centerY = centerY_;
}
double centerY( void ) const
{
return _centerY;
}
void width( double width_ )
{
_width = width_;
}
double width( void ) const
{
return _width;
}
void hight( double hight_ )
{
_hight = hight_;
}
double hight( void ) const
{
return _hight;
}
void cornerWidth( double cornerWidth_ )
{
_cornerWidth = cornerWidth_;
}
double cornerWidth( void ) const
{
return _cornerWidth;
}
void cornerHeight( double cornerHeight_ )
{
_cornerHeight = cornerHeight_;
}
double cornerHeight( void ) const
{
return _cornerHeight;
}
private:
double _centerX;
double _centerY;
double _width;
double _hight;
double _cornerWidth;
double _cornerHeight;
};
class MagickPPExport DrawableScaling : public DrawableBase
{
public:
DrawableScaling ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
~DrawableScaling ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x;
double _y;
};
class MagickPPExport DrawableSkewX : public DrawableBase
{
public:
DrawableSkewX ( double angle_ )
: _angle(angle_)
{ }
~DrawableSkewX ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void angle( double angle_ )
{
_angle = angle_;
}
double angle( void ) const
{
return _angle;
}
private:
double _angle;
};
class MagickPPExport DrawableSkewY : public DrawableBase
{
public:
DrawableSkewY ( double angle_ )
: _angle(angle_)
{ }
~DrawableSkewY ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void angle( double angle_ )
{
_angle = angle_;
}
double angle( void ) const
{
return _angle;
}
private:
double _angle;
};
class MagickPPExport DrawableDashArray : public DrawableBase
{
public:
DrawableDashArray( const double* dasharray_ );
DrawableDashArray( const size_t* dasharray_ );
DrawableDashArray( const Magick::DrawableDashArray &original_ );
~DrawableDashArray( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void dasharray( const double* dasharray_ );
void dasharray( const size_t* dasharray_ );
const double* dasharray( void ) const
{
return _dasharray;
}
DrawableDashArray& operator=(const Magick::DrawableDashArray &original_);
private:
size_t _size;
double *_dasharray;
};
class MagickPPExport DrawableDashOffset : public DrawableBase
{
public:
DrawableDashOffset ( const double offset_ )
: _offset(offset_)
{ }
~DrawableDashOffset ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void offset( const double offset_ )
{
_offset = offset_;
}
double offset( void ) const
{
return _offset;
}
private:
double _offset;
};
class MagickPPExport DrawableStrokeLineCap : public DrawableBase
{
public:
DrawableStrokeLineCap ( LineCap linecap_ )
: _linecap(linecap_)
{ }
~DrawableStrokeLineCap ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void linecap( LineCap linecap_ )
{
_linecap = linecap_;
}
LineCap linecap( void ) const
{
return _linecap;
}
private:
LineCap _linecap;
};
class MagickPPExport DrawableStrokeLineJoin : public DrawableBase
{
public:
DrawableStrokeLineJoin ( LineJoin linejoin_ )
: _linejoin(linejoin_)
{ }
~DrawableStrokeLineJoin ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void linejoin( LineJoin linejoin_ )
{
_linejoin = linejoin_;
}
LineJoin linejoin( void ) const
{
return _linejoin;
}
private:
LineJoin _linejoin;
};
class MagickPPExport DrawableMiterLimit : public DrawableBase
{
public:
DrawableMiterLimit ( size_t miterlimit_ )
: _miterlimit(miterlimit_)
{ }
~DrawableMiterLimit ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void miterlimit( size_t miterlimit_ )
{
_miterlimit = miterlimit_;
}
size_t miterlimit( void ) const
{
return _miterlimit;
}
private:
size_t _miterlimit;
};
class MagickPPExport DrawableStrokeAntialias : public DrawableBase
{
public:
DrawableStrokeAntialias ( bool flag_ )
: _flag(flag_)
{ }
~DrawableStrokeAntialias ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void flag( bool flag_ )
{
_flag = flag_;
}
bool flag( void ) const
{
return _flag;
}
private:
bool _flag;
};
class MagickPPExport DrawableStrokeColor : public DrawableBase
{
public:
DrawableStrokeColor ( const Color &color_ );
DrawableStrokeColor ( const DrawableStrokeColor& original_ );
~DrawableStrokeColor ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void color( const Color& color_ )
{
_color = color_;
}
Color color( void ) const
{
return _color;
}
private:
Color _color;
};
class MagickPPExport DrawableStrokeOpacity : public DrawableBase
{
public:
DrawableStrokeOpacity ( double opacity_ )
: _opacity(opacity_)
{
}
~DrawableStrokeOpacity ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void opacity( double opacity_ )
{
_opacity = opacity_;
}
double opacity( void ) const
{
return _opacity;
}
private:
double _opacity;
};
class MagickPPExport DrawableStrokeWidth : public DrawableBase
{
public:
DrawableStrokeWidth ( double width_ )
: _width(width_)
{ }
~DrawableStrokeWidth ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void width( double width_ )
{
_width = width_;
}
double width( void ) const
{
return _width;
}
private:
double _width;
};
class MagickPPExport DrawableText : public DrawableBase
{
public:
DrawableText ( const double x_, const double y_,
const std::string &text_ );
DrawableText ( const double x_, const double y_,
const std::string &text_, const std::string &encoding_);
DrawableText ( const DrawableText& original_ );
~DrawableText ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void encoding(const std::string &encoding_)
{
_encoding = encoding_;
}
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
void text( const std::string &text_ )
{
_text = text_;
}
std::string text( void ) const
{
return _text;
}
private:
double _x;
double _y;
std::string _text;
std::string _encoding;
};
class MagickPPExport DrawableTextAntialias : public DrawableBase
{
public:
DrawableTextAntialias ( bool flag_ );
DrawableTextAntialias( const DrawableTextAntialias &original_ );
~DrawableTextAntialias ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void flag( bool flag_ )
{
_flag = flag_;
}
bool flag( void ) const
{
return _flag;
}
private:
bool _flag;
};
class MagickPPExport DrawableTextDecoration : public DrawableBase
{
public:
DrawableTextDecoration ( DecorationType decoration_ );
DrawableTextDecoration ( const DrawableTextDecoration& original_ );
~DrawableTextDecoration( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void decoration( DecorationType decoration_ )
{
_decoration = decoration_;
}
DecorationType decoration( void ) const
{
return _decoration;
}
private:
DecorationType _decoration;
};
class MagickPPExport DrawableTextDirection : public DrawableBase
{
public:
DrawableTextDirection(DirectionType direction_);
~DrawableTextDirection(void);
void operator()(MagickCore::DrawingWand *context_) const;
void direction(DirectionType direction_);
DirectionType direction(void) const;
DrawableBase* copy() const;
private:
DirectionType _direction;
};
class MagickPPExport DrawableTextInterlineSpacing : public DrawableBase
{
public:
DrawableTextInterlineSpacing(double spacing_);
~DrawableTextInterlineSpacing(void);
void operator()(MagickCore::DrawingWand *context_) const;
void spacing(double spacing_);
double spacing(void) const;
DrawableBase* copy() const;
private:
double _spacing;
};
class MagickPPExport DrawableTextInterwordSpacing : public DrawableBase
{
public:
DrawableTextInterwordSpacing(double spacing_);
~DrawableTextInterwordSpacing(void);
void operator()(MagickCore::DrawingWand *context_) const;
void spacing(double spacing_);
double spacing(void) const;
DrawableBase *copy() const;
private:
double _spacing;
};
class MagickPPExport DrawableTextKerning : public DrawableBase
{
public:
DrawableTextKerning(double kerning_);
~DrawableTextKerning(void);
void operator()(MagickCore::DrawingWand *context_) const;
void kerning(double kerning_);
double kerning(void) const;
DrawableBase *copy() const;
private:
double _kerning;
};
class MagickPPExport DrawableTextUnderColor : public DrawableBase
{
public:
DrawableTextUnderColor ( const Color &color_ );
DrawableTextUnderColor ( const DrawableTextUnderColor& original_ );
~DrawableTextUnderColor ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void color( const Color& color_ )
{
_color = color_;
}
Color color( void ) const
{
return _color;
}
private:
Color _color;
};
class MagickPPExport DrawableTranslation : public DrawableBase
{
public:
DrawableTranslation ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
~DrawableTranslation ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x;
double _y;
};
class MagickPPExport DrawableViewbox : public DrawableBase
{
public:
DrawableViewbox(::ssize_t x1_, ::ssize_t y1_,
::ssize_t x2_, ::ssize_t y2_)
: _x1(x1_),
_y1(y1_),
_x2(x2_),
_y2(y2_) { }
~DrawableViewbox ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
DrawableBase* copy() const;
void x1( ::ssize_t x1_ )
{
_x1 = x1_;
}
::ssize_t x1( void ) const
{
return _x1;
}
void y1( ::ssize_t y1_ )
{
_y1 = y1_;
}
::ssize_t y1( void ) const
{
return _y1;
}
void x2( ::ssize_t x2_ )
{
_x2 = x2_;
}
::ssize_t x2( void ) const
{
return _x2;
}
void y2( ::ssize_t y2_ )
{
_y2 = y2_;
}
::ssize_t y2( void ) const
{
return _y2;
}
private:
::ssize_t _x1;
::ssize_t _y1;
::ssize_t _x2;
::ssize_t _y2;
};
class MagickPPExport PathArcArgs
{
public:
PathArcArgs( void );
PathArcArgs( double radiusX_, double radiusY_,
double xAxisRotation_, bool largeArcFlag_,
bool sweepFlag_, double x_, double y_ );
PathArcArgs( const PathArcArgs &original_ );
~PathArcArgs ( void );
void radiusX( double radiusX_ )
{
_radiusX = radiusX_;
}
double radiusX( void ) const
{
return _radiusX;
}
void radiusY( double radiusY_ )
{
_radiusY = radiusY_;
}
double radiusY( void ) const
{
return _radiusY;
}
void xAxisRotation( double xAxisRotation_ )
{
_xAxisRotation = xAxisRotation_;
}
double xAxisRotation( void ) const
{
return _xAxisRotation;
}
void largeArcFlag( bool largeArcFlag_ )
{
_largeArcFlag = largeArcFlag_;
}
bool largeArcFlag( void ) const
{
return _largeArcFlag;
}
void sweepFlag( bool sweepFlag_ )
{
_sweepFlag = sweepFlag_;
}
bool sweepFlag( void ) const
{
return _sweepFlag;
}
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _radiusX;
double _radiusY;
double _xAxisRotation;
bool _largeArcFlag;
bool _sweepFlag;
double _x;
double _y;
};
MagickPPExport int operator == ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator != ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator > ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator < ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator >= ( const PathArcArgs& left_,
const PathArcArgs& right_ );
MagickPPExport int operator <= ( const PathArcArgs& left_,
const PathArcArgs& right_ );
typedef std::list<Magick::PathArcArgs> PathArcArgsList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::PathArcArgs>;
#endif
class MagickPPExport PathArcAbs : public VPathBase
{
public:
PathArcAbs ( const PathArcArgs &coordinates_ );
PathArcAbs ( const PathArcArgsList &coordinates_ );
PathArcAbs ( const PathArcAbs& original_ );
~PathArcAbs ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
PathArcArgsList _coordinates;
};
class MagickPPExport PathArcRel : public VPathBase
{
public:
PathArcRel ( const PathArcArgs &coordinates_ );
PathArcRel ( const PathArcArgsList &coordinates_ );
PathArcRel ( const PathArcRel& original_ );
~PathArcRel ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
PathArcArgsList _coordinates;
};
class MagickPPExport PathClosePath : public VPathBase
{
public:
PathClosePath ( void )
: _dummy(0)
{
}
~PathClosePath ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
::ssize_t _dummy;
};
class MagickPPExport PathCurvetoArgs
{
public:
PathCurvetoArgs( void );
PathCurvetoArgs( double x1_, double y1_,
double x2_, double y2_,
double x_, double y_ );
PathCurvetoArgs( const PathCurvetoArgs &original_ );
~PathCurvetoArgs ( void );
void x1( double x1_ )
{
_x1 = x1_;
}
double x1( void ) const
{
return _x1;
}
void y1( double y1_ )
{
_y1 = y1_;
}
double y1( void ) const
{
return _y1;
}
void x2( double x2_ )
{
_x2 = x2_;
}
double x2( void ) const
{
return _x2;
}
void y2( double y2_ )
{
_y2 = y2_;
}
double y2( void ) const
{
return _y2;
}
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x1;
double _y1;
double _x2;
double _y2;
double _x;
double _y;
};
MagickPPExport int operator == ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator != ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator > ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator < ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator >= ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
MagickPPExport int operator <= ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
typedef std::list<Magick::PathCurvetoArgs> PathCurveToArgsList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::PathCurvetoArgs>;
#endif
class MagickPPExport PathCurvetoAbs : public VPathBase
{
public:
PathCurvetoAbs ( const PathCurvetoArgs &args_ );
PathCurvetoAbs ( const PathCurveToArgsList &args_ );
PathCurvetoAbs ( const PathCurvetoAbs& original_ );
~PathCurvetoAbs ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
PathCurveToArgsList _args;
};
class MagickPPExport PathCurvetoRel : public VPathBase
{
public:
PathCurvetoRel ( const PathCurvetoArgs &args_ );
PathCurvetoRel ( const PathCurveToArgsList &args_ );
PathCurvetoRel ( const PathCurvetoRel& original_ );
~PathCurvetoRel ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
PathCurveToArgsList _args;
};
class MagickPPExport PathSmoothCurvetoAbs : public VPathBase
{
public:
PathSmoothCurvetoAbs ( const Magick::Coordinate &coordinates_ );
PathSmoothCurvetoAbs ( const CoordinateList &coordinates_ );
PathSmoothCurvetoAbs ( const PathSmoothCurvetoAbs& original_ );
~PathSmoothCurvetoAbs ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathSmoothCurvetoRel : public VPathBase
{
public:
PathSmoothCurvetoRel ( const Coordinate &coordinates_ );
PathSmoothCurvetoRel ( const CoordinateList &coordinates_ );
PathSmoothCurvetoRel ( const PathSmoothCurvetoRel& original_ );
~PathSmoothCurvetoRel ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathQuadraticCurvetoArgs
{
public:
PathQuadraticCurvetoArgs( void );
PathQuadraticCurvetoArgs( double x1_, double y1_,
double x_, double y_ );
PathQuadraticCurvetoArgs( const PathQuadraticCurvetoArgs &original_ );
~PathQuadraticCurvetoArgs ( void );
void x1( double x1_ )
{
_x1 = x1_;
}
double x1( void ) const
{
return _x1;
}
void y1( double y1_ )
{
_y1 = y1_;
}
double y1( void ) const
{
return _y1;
}
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _x1;
double _y1;
double _x;
double _y;
};
MagickPPExport int operator == ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_ );
MagickPPExport int operator != ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_);
MagickPPExport int operator > ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_);
MagickPPExport int operator < ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_);
MagickPPExport int operator >= ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_ );
MagickPPExport int operator <= ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_ );
typedef std::list<Magick::PathQuadraticCurvetoArgs> PathQuadraticCurvetoArgsList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::PathQuadraticCurvetoArgs>;
#endif
class MagickPPExport PathQuadraticCurvetoAbs : public VPathBase
{
public:
PathQuadraticCurvetoAbs ( const Magick::PathQuadraticCurvetoArgs &args_ );
PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoArgsList &args_ );
PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoAbs& original_ );
~PathQuadraticCurvetoAbs ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
PathQuadraticCurvetoArgsList _args;
};
class MagickPPExport PathQuadraticCurvetoRel : public VPathBase
{
public:
PathQuadraticCurvetoRel ( const Magick::PathQuadraticCurvetoArgs &args_ );
PathQuadraticCurvetoRel ( const PathQuadraticCurvetoArgsList &args_ );
PathQuadraticCurvetoRel ( const PathQuadraticCurvetoRel& original_ );
~PathQuadraticCurvetoRel ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
PathQuadraticCurvetoArgsList _args;
};
class MagickPPExport PathSmoothQuadraticCurvetoAbs : public VPathBase
{
public:
PathSmoothQuadraticCurvetoAbs ( const Magick::Coordinate &coordinate_ );
PathSmoothQuadraticCurvetoAbs ( const CoordinateList &coordinates_ );
PathSmoothQuadraticCurvetoAbs ( const PathSmoothQuadraticCurvetoAbs& original_ );
~PathSmoothQuadraticCurvetoAbs ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathSmoothQuadraticCurvetoRel : public VPathBase
{
public:
PathSmoothQuadraticCurvetoRel ( const Magick::Coordinate &coordinate_ );
PathSmoothQuadraticCurvetoRel ( const CoordinateList &coordinates_ );
PathSmoothQuadraticCurvetoRel ( const PathSmoothQuadraticCurvetoRel& original_ );
~PathSmoothQuadraticCurvetoRel ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathLinetoAbs : public VPathBase
{
public:
PathLinetoAbs ( const Magick::Coordinate& coordinate_ );
PathLinetoAbs ( const CoordinateList &coordinates_ );
PathLinetoAbs ( const PathLinetoAbs& original_ );
~PathLinetoAbs ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathLinetoRel : public VPathBase
{
public:
PathLinetoRel ( const Magick::Coordinate& coordinate_ );
PathLinetoRel ( const CoordinateList &coordinates_ );
PathLinetoRel ( const PathLinetoRel& original_ );
~PathLinetoRel ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathLinetoHorizontalAbs : public VPathBase
{
public:
PathLinetoHorizontalAbs ( double x_ )
: _x(x_)
{
}
~PathLinetoHorizontalAbs ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
private:
double _x;
};
class MagickPPExport PathLinetoHorizontalRel : public VPathBase
{
public:
PathLinetoHorizontalRel ( double x_ )
: _x(x_)
{
}
~PathLinetoHorizontalRel ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
private:
double _x;
};
class MagickPPExport PathLinetoVerticalAbs : public VPathBase
{
public:
PathLinetoVerticalAbs ( double y_ )
: _y(y_)
{
}
~PathLinetoVerticalAbs ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _y;
};
class MagickPPExport PathLinetoVerticalRel : public VPathBase
{
public:
PathLinetoVerticalRel ( double y_ )
: _y(y_)
{
}
~PathLinetoVerticalRel ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _y;
};
class MagickPPExport PathMovetoAbs : public VPathBase
{
public:
PathMovetoAbs ( const Magick::Coordinate &coordinate_ );
PathMovetoAbs ( const CoordinateList &coordinates_ );
PathMovetoAbs ( const PathMovetoAbs& original_ );
~PathMovetoAbs ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathMovetoRel : public VPathBase
{
public:
PathMovetoRel ( const Magick::Coordinate &coordinate_ );
PathMovetoRel ( const CoordinateList &coordinates_ );
PathMovetoRel ( const PathMovetoRel& original_ );
~PathMovetoRel ( void );
void operator()( MagickCore::DrawingWand *context_ ) const;
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
}
#endif