Drawable.h
Go to the documentation of this file.
// This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002
//
// Copyright @ 2014 ImageMagick Studio LLC, a non-profit organization
// dedicated to making software imaging solutions freely available.
//
// Definition of Drawable (Graphic objects)
//
// The technique used for instantiating classes which derive from STL
// templates is described in Microsoft MSDN Article ID: Q168958
// "HOWTO: Exporting STL Components Inside & Outside of a Class".
// "http://support.microsoft.com/kb/168958"
//
// Note that version 3.0 of this article says that that only STL
// container template which supports DLL export is <vector> and we are
// not using <vector> as part of the Drawable implementation.
//
#if !defined(Magick_Drawable_header)
#define Magick_Drawable_header
#include "Magick++/Include.h"
#include <functional>
#include <string>
#include <vector>
#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 ) // Disable warning regarding using extern
# define MagickDrawableExtern extern
# endif // MAGICK_PLUSPLUS_IMPLEMENTATION
#else
# define MagickDrawableExtern
#endif // MagickDLLExplicitTemplate
namespace Magick
{
//
// Representation of an x,y coordinate
//
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::vector<Magick::Coordinate> CoordinateList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::Coordinate>;
#endif // MagickDLLExplicitTemplate
// Compare two Coordinate objects regardless of LHS/RHS
extern MagickPPExport int operator ==
(const Coordinate& left_,const Coordinate& right_);
extern MagickPPExport int operator !=
(const Coordinate& left_, const Coordinate& right_);
extern MagickPPExport int operator >
(const Coordinate& left_, const Coordinate& right_);
extern MagickPPExport int operator <
(const Coordinate& left_, const Coordinate& right_);
extern MagickPPExport int operator >=
(const Coordinate& left_, const Coordinate& right_);
extern MagickPPExport int operator <=
(const Coordinate& left_, const Coordinate& right_);
//
// Base class for all drawable objects
//
class MagickPPExport DrawableBase
{
public:
// Default constructor
DrawableBase(void);
// Destructor
virtual ~DrawableBase(void);
// Operator to invoke equivalent draw API call
virtual void operator()(MagickCore::DrawingWand *) const;
// Return polymorphic copy of object
virtual DrawableBase* copy() const;
};
//
// Representation of a drawable surrogate object to manage drawable objects
//
#undef Drawable // Conflict with <X11/Xproto.h>
class MagickPPExport Drawable
{
public:
// Default constructor
Drawable(void);
// Construct from DrawableBase
Drawable(const DrawableBase& original_);
// Destructor
~Drawable(void);
// Copy constructor
Drawable(const Drawable& original_);
// Assignment operator
Drawable& operator=(const Drawable& original_);
// Operator to invoke contained object
void operator()(MagickCore::DrawingWand *) const;
private:
DrawableBase* dp;
};
typedef std::vector<Magick::Drawable> DrawableList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::Drawable>;
#endif // MagickDLLExplicitTemplate
//
// Base class for all drawable path elements for use with
// DrawablePath
//
class MagickPPExport VPathBase
{
public:
// Constructor
VPathBase ( void )
{ }
// Destructor
virtual ~VPathBase ( void );
// Assignment operator
// const VPathBase& operator= (const VPathBase& original_ );
// Operator to invoke equivalent draw API call
virtual void operator()( MagickCore::DrawingWand *context_ ) const = 0;
// Return polymorphic copy of object
virtual VPathBase* copy() const = 0;
};
//
// Representation of a drawable path element surrogate object to
// manage drawable path elements so they may be passed as a list to
// DrawablePath.
//
class MagickPPExport VPath
{
public:
// Constructor
VPath ( void );
// Construct from VPathBase
VPath ( const VPathBase& original_ );
// Destructor
virtual ~VPath ( void );
// Copy constructor
VPath ( const VPath& original_ );
// Assignment operator
VPath& operator= (const VPath& original_ );
// Operator to invoke contained object
void operator()( MagickCore::DrawingWand *context_ ) const;
private:
VPathBase* dp;
};
typedef std::vector<Magick::VPath> VPathList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::VPath>;
// MagickDrawableExtern template class MagickPPExport
// std::vector<Magick::VPath, std::allocator<Magick::VPath> >;
#endif // MagickDLLExplicitTemplate
//
// Drawable Objects
//
// Affine (scaling, rotation, and translation)
class MagickPPExport DrawableAffine : public DrawableBase
{
public:
DrawableAffine ( double sx_, double sy_,
double rx_, double ry_,
double tx_, double ty_ );
DrawableAffine ( void );
/*virtual*/ ~DrawableAffine( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/
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;
};
// Change pixel alpha value to transparent using PaintMethod
class MagickPPExport DrawableAlpha : public DrawableBase
{
public:
DrawableAlpha(double x_, double y_,PaintMethod paintMethod_)
: _x(x_),
_y(y_),
_paintMethod(paintMethod_)
{
}
~DrawableAlpha(void);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
// Return polymorphic copy of object
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;
};
// Arc
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_)
{ }
/*virtual*/ ~DrawableArc( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Bezier curve (Coordinate list must contain at least three members)
class MagickPPExport DrawableBezier : public DrawableBase
{
public:
// Construct from coordinates
DrawableBezier ( const CoordinateList &coordinates_ );
// Copy constructor
DrawableBezier ( const DrawableBezier& original_ );
// Destructor
/*virtual*/ ~DrawableBezier ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
CoordinateList _coordinates;
};
// Sets the border color to be used for drawing bordered objects.
class MagickPPExport DrawableBorderColor : public DrawableBase
{
public:
DrawableBorderColor(const Color &color_);
DrawableBorderColor(const DrawableBorderColor &original_);
~DrawableBorderColor(void);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
void color(const Color &color_);
Color color(void) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
private:
Color _color;
};
// Sets the polygon fill rule to be used by the clipping path.
class MagickPPExport DrawableClipRule : public DrawableBase
{
public:
DrawableClipRule(const FillRule fillRule_);
~DrawableClipRule(void);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
void fillRule(const FillRule fillRule_);
FillRule fillRule(void) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
private:
FillRule _fillRule;
};
// Sets the interpretation of clip path units.
class MagickPPExport DrawableClipUnits : public DrawableBase
{
public:
DrawableClipUnits(const ClipPathUnits units_);
~DrawableClipUnits(void);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
void units(const ClipPathUnits units_);
ClipPathUnits units(void) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
private:
ClipPathUnits _units;
};
// Pop (terminate) clip path definition
class MagickPPExport DrawablePopClipPath : public DrawableBase
{
public:
DrawablePopClipPath ( void )
: _dummy(0)
{
}
/*virtual*/ ~DrawablePopClipPath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
// Push (create) Clip path definition
class MagickPPExport DrawablePushClipPath : public DrawableBase
{
public:
DrawablePushClipPath ( const std::string &id_);
DrawablePushClipPath ( const DrawablePushClipPath& original_ );
/*virtual*/ ~DrawablePushClipPath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
std::string _id;
};
// Named Clip Path
class MagickPPExport DrawableClipPath : public DrawableBase
{
public:
DrawableClipPath ( const std::string &id_ );
DrawableClipPath ( const DrawableClipPath& original_ );
/*virtual*/ ~DrawableClipPath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void clip_path( const std::string &id_ )
{
_id = id_.c_str(); //multithread safe
}
std::string clip_path( void ) const
{
return _id;
}
private:
std::string _id;
};
// Circle
class MagickPPExport DrawableCircle : public DrawableBase
{
public:
DrawableCircle ( double originX_, double originY_,
double perimX_, double perimY_ )
: _originX(originX_),
_originY(originY_),
_perimX(perimX_),
_perimY(perimY_)
{
}
/*virtual*/ ~DrawableCircle ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Colorize at point using PaintMethod
class MagickPPExport DrawableColor : public DrawableBase
{
public:
DrawableColor ( double x_, double y_,
PaintMethod paintMethod_ )
: _x(x_),
_y(y_),
_paintMethod(paintMethod_)
{ }
/*virtual*/ ~DrawableColor ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Draw image at point, scaled to size specified by width and height
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_ );
// Copy constructor
DrawableCompositeImage ( const DrawableCompositeImage& original_ );
// Destructor
/*virtual*/ ~DrawableCompositeImage( void );
// Assignment operator
DrawableCompositeImage& operator=
(const DrawableCompositeImage& original_ );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
// Specify image format used to output Base64 inlined image data.
void magick( std::string magick_ );
std::string magick( void );
private:
CompositeOperator _composition;
double _x;
double _y;
double _width;
double _height;
Image* _image;
};
// Density
class MagickPPExport DrawableDensity : public DrawableBase
{
public:
DrawableDensity(const Point &density_);
DrawableDensity(const std::string &density_);
~DrawableDensity(void);
void operator()(MagickCore::DrawingWand *context_) const;
DrawableBase* copy() const;
private:
std::string _density;
};
// Ellipse
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_)
{ }
/*virtual*/ ~DrawableEllipse( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Specify drawing fill color
class MagickPPExport DrawableFillColor : public DrawableBase
{
public:
DrawableFillColor ( const Color &color_ );
DrawableFillColor ( const DrawableFillColor& original_ );
/*virtual*/ ~DrawableFillColor( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void color( const Color &color_ )
{
_color = color_;
}
Color color( void ) const
{
return _color;
}
private:
Color _color;
};
// Sets the URL to use as a fill pattern for filling objects. Only local
// URLs("#identifier") are supported at this time. These local URLs are
// normally created by defining a named fill pattern with
// DrawablePushPattern/DrawablePopPattern.
class MagickPPExport DrawableFillPatternUrl : public DrawableBase
{
public:
DrawableFillPatternUrl(const std::string &url_);
~DrawableFillPatternUrl(void);
DrawableFillPatternUrl(const DrawableFillPatternUrl& original_);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
void url(const std::string &url_);
std::string url(void) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
private:
std::string _url;
};
// Specify fill rule (fill-rule)
class MagickPPExport DrawableFillRule : public DrawableBase
{
public:
DrawableFillRule ( const FillRule fillRule_ )
: _fillRule(fillRule_)
{
}
/*virtual*/ ~DrawableFillRule ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void fillRule( const FillRule fillRule_ )
{
_fillRule = fillRule_;
}
FillRule fillRule( void ) const
{
return _fillRule;
}
private:
FillRule _fillRule;
};
// Specify drawing fill alpha
class MagickPPExport DrawableFillOpacity : public DrawableBase
{
public:
DrawableFillOpacity(double opacity_)
: _opacity(opacity_)
{
}
~DrawableFillOpacity ( void );
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
void opacity(double opacity_)
{
_opacity=opacity_;
}
double opacity(void) const
{
return(_opacity);
}
private:
double _opacity;
};
// Specify text font
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_ );
/*virtual*/ ~DrawableFont ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Specify text positioning gravity
class MagickPPExport DrawableGravity : public DrawableBase
{
public:
DrawableGravity ( GravityType gravity_ )
: _gravity(gravity_)
{
}
/*virtual*/ ~DrawableGravity ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void gravity( GravityType gravity_ )
{
_gravity = gravity_;
}
GravityType gravity( void ) const
{
return _gravity;
}
private:
GravityType _gravity;
};
// Line
class MagickPPExport DrawableLine : public DrawableBase
{
public:
DrawableLine ( double startX_, double startY_,
double endX_, double endY_ )
: _startX(startX_),
_startY(startY_),
_endX(endX_),
_endY(endY_)
{ }
/*virtual*/ ~DrawableLine ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Drawable Path
class MagickPPExport DrawablePath : public DrawableBase
{
public:
DrawablePath ( const VPathList &path_ );
DrawablePath ( const DrawablePath& original_ );
/*virtual*/ ~DrawablePath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
VPathList _path;
};
// Point
class MagickPPExport DrawablePoint : public DrawableBase
{
public:
DrawablePoint ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
/*virtual*/ ~DrawablePoint ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Text pointsize
class MagickPPExport DrawablePointSize : public DrawableBase
{
public:
DrawablePointSize ( double pointSize_ )
: _pointSize(pointSize_)
{ }
/*virtual*/ ~DrawablePointSize ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void pointSize( double pointSize_ )
{
_pointSize = pointSize_;
}
double pointSize( void ) const
{
return _pointSize;
}
private:
double _pointSize;
};
// Polygon (Coordinate list must contain at least three members)
class MagickPPExport DrawablePolygon : public DrawableBase
{
public:
DrawablePolygon ( const CoordinateList &coordinates_ );
DrawablePolygon ( const DrawablePolygon& original_ );
/*virtual*/ ~DrawablePolygon ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
CoordinateList _coordinates;
};
// Polyline (Coordinate list must contain at least three members)
class MagickPPExport DrawablePolyline : public DrawableBase
{
public:
DrawablePolyline ( const CoordinateList &coordinates_ );
DrawablePolyline ( const DrawablePolyline& original_ );
/*virtual*/ ~DrawablePolyline ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
CoordinateList _coordinates;
};
// Pop Graphic Context
class MagickPPExport DrawablePopGraphicContext : public DrawableBase
{
public:
DrawablePopGraphicContext ( void )
: _dummy(0)
{
}
/*virtual*/ ~DrawablePopGraphicContext ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
// Push Graphic Context
class MagickPPExport DrawablePushGraphicContext : public DrawableBase
{
public:
DrawablePushGraphicContext ( void )
: _dummy(0)
{
}
/*virtual*/ ~DrawablePushGraphicContext ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
// Pop (terminate) Pattern definition
class MagickPPExport DrawablePopPattern : public DrawableBase
{
public:
DrawablePopPattern ( void )
: _dummy(0)
{
}
/*virtual*/ ~DrawablePopPattern ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
::ssize_t _dummy;
};
// Push (create) Pattern definition
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_ );
/*virtual*/ ~DrawablePushPattern ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
private:
std::string _id;
::ssize_t _x;
::ssize_t _y;
size_t _width;
size_t _height;
};
// Rectangle
class MagickPPExport DrawableRectangle : public DrawableBase
{
public:
DrawableRectangle ( double upperLeftX_, double upperLeftY_,
double lowerRightX_, double lowerRightY_ )
: _upperLeftX(upperLeftX_),
_upperLeftY(upperLeftY_),
_lowerRightX(lowerRightX_),
_lowerRightY(lowerRightY_)
{ }
/*virtual*/ ~DrawableRectangle ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Apply Rotation
class MagickPPExport DrawableRotation : public DrawableBase
{
public:
DrawableRotation ( double angle_ )
: _angle( angle_ )
{ }
/*virtual*/ ~DrawableRotation ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void angle( double angle_ )
{
_angle = angle_;
}
double angle( void ) const
{
return _angle;
}
private:
double _angle;
};
// Round Rectangle
class MagickPPExport DrawableRoundRectangle : public DrawableBase
{
public:
DrawableRoundRectangle ( double upperLeftX_, double upperLeftY_,
double lowerRightX_, double lowerRightY_,
double cornerWidth_, double cornerHeight_ )
: _upperLeftX(upperLeftX_),
_upperLeftY(upperLeftY_),
_lowerRightX(lowerRightX_),
_lowerRightY(lowerRightY_),
_cornerWidth(cornerWidth_),
_cornerHeight(cornerHeight_)
{ }
/*virtual*/ ~DrawableRoundRectangle ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
#if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)
void centerX( double centerX_ )
{
_upperLeftX = centerX_;
}
double centerX( void ) const
{
return _upperLeftX;
}
void centerY( double centerY_ )
{
_upperLeftY = centerY_;
}
double centerY( void ) const
{
return _upperLeftY;
}
void width( double width_ )
{
_lowerRightX = width_;
}
double width( void ) const
{
return _lowerRightX;
}
void hight( double hight_ )
{
_lowerRightY = hight_;
}
double hight( void ) const
{
return _lowerRightY;
}
#endif
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;
}
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 _upperLeftX;
double _upperLeftY;
double _lowerRightX;
double _lowerRightY;
double _cornerWidth;
double _cornerHeight;
};
// Apply Scaling
class MagickPPExport DrawableScaling : public DrawableBase
{
public:
DrawableScaling ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
/*virtual*/ ~DrawableScaling ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Apply Skew in X direction
class MagickPPExport DrawableSkewX : public DrawableBase
{
public:
DrawableSkewX ( double angle_ )
: _angle(angle_)
{ }
/*virtual*/ ~DrawableSkewX ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void angle( double angle_ )
{
_angle = angle_;
}
double angle( void ) const
{
return _angle;
}
private:
double _angle;
};
// Apply Skew in Y direction
class MagickPPExport DrawableSkewY : public DrawableBase
{
public:
DrawableSkewY ( double angle_ )
: _angle(angle_)
{ }
/*virtual*/ ~DrawableSkewY ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void angle( double angle_ )
{
_angle = angle_;
}
double angle( void ) const
{
return _angle;
}
private:
double _angle;
};
// Stroke dasharray
//
// dasharray_ is an allocated array terminated by value 0.0 or 0.
// The array is copied so the original does not need to be preserved.
// Pass a null pointer to clear an existing dash array setting.
class MagickPPExport DrawableStrokeDashArray : public DrawableBase
{
public:
DrawableStrokeDashArray(const double* dasharray_);
DrawableStrokeDashArray(const Magick::DrawableStrokeDashArray &original_);
~DrawableStrokeDashArray(void);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
void dasharray(const double* dasharray_);
const double* dasharray(void) const;
DrawableStrokeDashArray& operator=(
const Magick::DrawableStrokeDashArray &original_);
private:
size_t _size;
double *_dasharray;
};
// Stroke dashoffset
class MagickPPExport DrawableStrokeDashOffset : public DrawableBase
{
public:
DrawableStrokeDashOffset(const double offset_)
: _offset(offset_)
{ }
~DrawableStrokeDashOffset(void);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
void offset(const double offset_);
double offset(void) const;
private:
double _offset;
};
// Stroke linecap
class MagickPPExport DrawableStrokeLineCap : public DrawableBase
{
public:
DrawableStrokeLineCap ( LineCap linecap_ )
: _linecap(linecap_)
{ }
/*virtual*/ ~DrawableStrokeLineCap ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void linecap( LineCap linecap_ )
{
_linecap = linecap_;
}
LineCap linecap( void ) const
{
return _linecap;
}
private:
LineCap _linecap;
};
// Stroke linejoin
class MagickPPExport DrawableStrokeLineJoin : public DrawableBase
{
public:
DrawableStrokeLineJoin ( LineJoin linejoin_ )
: _linejoin(linejoin_)
{ }
/*virtual*/ ~DrawableStrokeLineJoin ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void linejoin( LineJoin linejoin_ )
{
_linejoin = linejoin_;
}
LineJoin linejoin( void ) const
{
return _linejoin;
}
private:
LineJoin _linejoin;
};
// Stroke miterlimit
class MagickPPExport DrawableMiterLimit : public DrawableBase
{
public:
DrawableMiterLimit ( size_t miterlimit_ )
: _miterlimit(miterlimit_)
{ }
/*virtual*/ ~DrawableMiterLimit ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void miterlimit( size_t miterlimit_ )
{
_miterlimit = miterlimit_;
}
size_t miterlimit( void ) const
{
return _miterlimit;
}
private:
size_t _miterlimit;
};
// Sets the pattern used for stroking object outlines.
class MagickPPExport DrawableStrokePatternUrl : public DrawableBase
{
public:
DrawableStrokePatternUrl(const std::string &url_);
~DrawableStrokePatternUrl(void);
DrawableStrokePatternUrl(const DrawableStrokePatternUrl& original_);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
void url(const std::string &url_);
std::string url(void) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
private:
std::string _url;
};
// Stroke antialias
class MagickPPExport DrawableStrokeAntialias : public DrawableBase
{
public:
DrawableStrokeAntialias ( bool flag_ )
: _flag(flag_)
{ }
/*virtual*/ ~DrawableStrokeAntialias ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void flag( bool flag_ )
{
_flag = flag_;
}
bool flag( void ) const
{
return _flag;
}
private:
bool _flag;
};
// Stroke color
class MagickPPExport DrawableStrokeColor : public DrawableBase
{
public:
DrawableStrokeColor ( const Color &color_ );
DrawableStrokeColor ( const DrawableStrokeColor& original_ );
/*virtual*/ ~DrawableStrokeColor ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void color( const Color& color_ )
{
_color = color_;
}
Color color( void ) const
{
return _color;
}
private:
Color _color;
};
// Stroke opacity
class MagickPPExport DrawableStrokeOpacity : public DrawableBase
{
public:
DrawableStrokeOpacity(double opacity_)
: _opacity(opacity_)
{
}
~DrawableStrokeOpacity(void);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
void opacity(double opacity_)
{
_opacity=opacity_;
}
double opacity(void) const
{
return(_opacity);
}
private:
double _opacity;
};
// Stroke width
class MagickPPExport DrawableStrokeWidth : public DrawableBase
{
public:
DrawableStrokeWidth ( double width_ )
: _width(width_)
{ }
/*virtual*/ ~DrawableStrokeWidth ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void width( double width_ )
{
_width = width_;
}
double width( void ) const
{
return _width;
}
private:
double _width;
};
// Draw text at point
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_ );
/*virtual*/ ~DrawableText ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Text alignment
class MagickPPExport DrawableTextAlignment : public DrawableBase
{
public:
DrawableTextAlignment(AlignType alignment_);
DrawableTextAlignment(const DrawableTextAlignment& original_);
~DrawableTextAlignment(void);
// Operator to invoke equivalent draw API call
void operator()(MagickCore::DrawingWand *context_) const;
void alignment(AlignType alignment_);
AlignType alignment(void) const;
// Return polymorphic copy of object
DrawableBase* copy() const;
private:
AlignType _alignment;
};
// Text antialias
class MagickPPExport DrawableTextAntialias : public DrawableBase
{
public:
DrawableTextAntialias ( bool flag_ );
DrawableTextAntialias( const DrawableTextAntialias &original_ );
/*virtual*/ ~DrawableTextAntialias ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void flag( bool flag_ )
{
_flag = flag_;
}
bool flag( void ) const
{
return _flag;
}
private:
bool _flag;
};
// Decoration (text decoration)
class MagickPPExport DrawableTextDecoration : public DrawableBase
{
public:
DrawableTextDecoration ( DecorationType decoration_ );
DrawableTextDecoration ( const DrawableTextDecoration& original_ );
/*virtual*/ ~DrawableTextDecoration( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void decoration( DecorationType decoration_ )
{
_decoration = decoration_;
}
DecorationType decoration( void ) const
{
return _decoration;
}
private:
DecorationType _decoration;
};
// Render text right-to-left or left-to-right.
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;
};
// Specify text inter-line spacing
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;
};
// Specify text inter-word 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;
};
// Specify text kerning
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;
};
// Text undercolor box
class MagickPPExport DrawableTextUnderColor : public DrawableBase
{
public:
DrawableTextUnderColor ( const Color &color_ );
DrawableTextUnderColor ( const DrawableTextUnderColor& original_ );
/*virtual*/ ~DrawableTextUnderColor ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ DrawableBase* copy() const;
void color( const Color& color_ )
{
_color = color_;
}
Color color( void ) const
{
return _color;
}
private:
Color _color;
};
// Apply Translation
class MagickPPExport DrawableTranslation : public DrawableBase
{
public:
DrawableTranslation ( double x_, double y_ )
: _x(x_),
_y(y_)
{ }
/*virtual*/ ~DrawableTranslation ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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;
};
// Set the size of the viewbox
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_) { }
/*virtual*/ ~DrawableViewbox ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/
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;
};
//
// Path Element Classes To Support DrawablePath
//
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; // X radius
double _radiusY; // Y radius
double _xAxisRotation; // Rotation relative to X axis
bool _largeArcFlag; // Draw longer of the two matching arcs
bool _sweepFlag; // Draw arc matching clock-wise rotation
double _x; // End-point X
double _y; // End-point Y
};
// Compare two PathArcArgs objects regardless of LHS/RHS
extern MagickPPExport int operator == ( const PathArcArgs& left_,
const PathArcArgs& right_ );
extern MagickPPExport int operator != ( const PathArcArgs& left_,
const PathArcArgs& right_ );
extern MagickPPExport int operator > ( const PathArcArgs& left_,
const PathArcArgs& right_ );
extern MagickPPExport int operator < ( const PathArcArgs& left_,
const PathArcArgs& right_ );
extern MagickPPExport int operator >= ( const PathArcArgs& left_,
const PathArcArgs& right_ );
extern MagickPPExport int operator <= ( const PathArcArgs& left_,
const PathArcArgs& right_ );
typedef std::vector<Magick::PathArcArgs> PathArcArgsList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::PathArcArgs>;
// MagickDrawableExtern template class MagickPPExport
// std::vector<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> >;
#endif // MagickDLLExplicitTemplate
// Path Arc (Elliptical Arc)
class MagickPPExport PathArcAbs : public VPathBase
{
public:
// Draw a single arc segment
PathArcAbs ( const PathArcArgs &coordinates_ );
// Draw multiple arc segments
PathArcAbs ( const PathArcArgsList &coordinates_ );
// Copy constructor
PathArcAbs ( const PathArcAbs& original_ );
// Destructor
/*virtual*/ ~PathArcAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathArcArgsList _coordinates;
};
class MagickPPExport PathArcRel : public VPathBase
{
public:
// Draw a single arc segment
PathArcRel ( const PathArcArgs &coordinates_ );
// Draw multiple arc segments
PathArcRel ( const PathArcArgsList &coordinates_ );
PathArcRel ( const PathArcRel& original_ );
/*virtual*/ ~PathArcRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathArcArgsList _coordinates;
};
// Path Closepath
class MagickPPExport PathClosePath : public VPathBase
{
public:
PathClosePath ( void )
: _dummy(0)
{
}
/*virtual*/ ~PathClosePath ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
::ssize_t _dummy;
};
//
// Curveto (Cubic Bezier)
//
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;
};
// Compare two PathCurvetoArgs objects regardless of LHS/RHS
extern MagickPPExport int operator == ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
extern MagickPPExport int operator != ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
extern MagickPPExport int operator > ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
extern MagickPPExport int operator < ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
extern MagickPPExport int operator >= ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
extern MagickPPExport int operator <= ( const PathCurvetoArgs& left_,
const PathCurvetoArgs& right_ );
typedef std::vector<Magick::PathCurvetoArgs> PathCurveToArgsList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::PathCurvetoArgs>;
// MagickDrawableExtern template class MagickPPExport
// std::vector<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> >;
#endif // MagickDLLExplicitTemplate
class MagickPPExport PathCurvetoAbs : public VPathBase
{
public:
// Draw a single curve
PathCurvetoAbs ( const PathCurvetoArgs &args_ );
// Draw multiple curves
PathCurvetoAbs ( const PathCurveToArgsList &args_ );
// Copy constructor
PathCurvetoAbs ( const PathCurvetoAbs& original_ );
// Destructor
/*virtual*/ ~PathCurvetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathCurveToArgsList _args;
};
class MagickPPExport PathCurvetoRel : public VPathBase
{
public:
// Draw a single curve
PathCurvetoRel ( const PathCurvetoArgs &args_ );
// Draw multiple curves
PathCurvetoRel ( const PathCurveToArgsList &args_ );
// Copy constructor
PathCurvetoRel ( const PathCurvetoRel& original_ );
/*virtual*/ ~PathCurvetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathCurveToArgsList _args;
};
class MagickPPExport PathSmoothCurvetoAbs : public VPathBase
{
public:
// Draw a single curve
PathSmoothCurvetoAbs ( const Magick::Coordinate &coordinates_ );
// Draw multiple curves
PathSmoothCurvetoAbs ( const CoordinateList &coordinates_ );
// Copy constructor
PathSmoothCurvetoAbs ( const PathSmoothCurvetoAbs& original_ );
/*virtual*/ ~PathSmoothCurvetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathSmoothCurvetoRel : public VPathBase
{
public:
// Draw a single curve
PathSmoothCurvetoRel ( const Coordinate &coordinates_ );
// Draw multiple curves
PathSmoothCurvetoRel ( const CoordinateList &coordinates_ );
// Copy constructor
PathSmoothCurvetoRel ( const PathSmoothCurvetoRel& original_ );
// Destructor
/*virtual*/ ~PathSmoothCurvetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/
VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
//
// Quadratic Curveto (Quadratic Bezier)
//
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;
};
// Compare two PathQuadraticCurvetoArgs objects regardless of LHS/RHS
extern MagickPPExport int operator == ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_ );
extern MagickPPExport int operator != ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_);
extern MagickPPExport int operator > ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_);
extern MagickPPExport int operator < ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_);
extern MagickPPExport int operator >= ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_ );
extern MagickPPExport int operator <= ( const PathQuadraticCurvetoArgs& left_,
const PathQuadraticCurvetoArgs& right_ );
typedef std::vector<Magick::PathQuadraticCurvetoArgs> PathQuadraticCurvetoArgsList;
#if defined(MagickDLLExplicitTemplate)
MagickDrawableExtern template class MagickPPExport
std::allocator<Magick::PathQuadraticCurvetoArgs>;
// MagickDrawableExtern template class MagickPPExport
// std::vector<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> >;
#endif // MagickDLLExplicitTemplate
class MagickPPExport PathQuadraticCurvetoAbs : public VPathBase
{
public:
// Draw a single curve
PathQuadraticCurvetoAbs ( const Magick::PathQuadraticCurvetoArgs &args_ );
// Draw multiple curves
PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoArgsList &args_ );
// Copy constructor
PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoAbs& original_ );
// Destructor
/*virtual*/ ~PathQuadraticCurvetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathQuadraticCurvetoArgsList _args;
};
class MagickPPExport PathQuadraticCurvetoRel : public VPathBase
{
public:
// Draw a single curve
PathQuadraticCurvetoRel ( const Magick::PathQuadraticCurvetoArgs &args_ );
// Draw multiple curves
PathQuadraticCurvetoRel ( const PathQuadraticCurvetoArgsList &args_ );
// Copy constructor
PathQuadraticCurvetoRel ( const PathQuadraticCurvetoRel& original_ );
// Destructor
/*virtual*/ ~PathQuadraticCurvetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
PathQuadraticCurvetoArgsList _args;
};
class MagickPPExport PathSmoothQuadraticCurvetoAbs : public VPathBase
{
public:
// Draw a single curve
PathSmoothQuadraticCurvetoAbs ( const Magick::Coordinate &coordinate_ );
// Draw multiple curves
PathSmoothQuadraticCurvetoAbs ( const CoordinateList &coordinates_ );
// Copy constructor
PathSmoothQuadraticCurvetoAbs ( const PathSmoothQuadraticCurvetoAbs& original_ );
// Destructor
/*virtual*/ ~PathSmoothQuadraticCurvetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathSmoothQuadraticCurvetoRel : public VPathBase
{
public:
// Draw a single curve
PathSmoothQuadraticCurvetoRel ( const Magick::Coordinate &coordinate_ );
// Draw multiple curves
PathSmoothQuadraticCurvetoRel ( const CoordinateList &coordinates_ );
// Copy constructor
PathSmoothQuadraticCurvetoRel ( const PathSmoothQuadraticCurvetoRel& original_ );
// Destructor
/*virtual*/ ~PathSmoothQuadraticCurvetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
//
// Path Lineto
//
class MagickPPExport PathLinetoAbs : public VPathBase
{
public:
// Draw to a single point
PathLinetoAbs ( const Magick::Coordinate& coordinate_ );
// Draw to multiple points
PathLinetoAbs ( const CoordinateList &coordinates_ );
// Copy constructor
PathLinetoAbs ( const PathLinetoAbs& original_ );
// Destructor
/*virtual*/ ~PathLinetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathLinetoRel : public VPathBase
{
public:
// Draw to a single point
PathLinetoRel ( const Magick::Coordinate& coordinate_ );
// Draw to multiple points
PathLinetoRel ( const CoordinateList &coordinates_ );
// Copy constructor
PathLinetoRel ( const PathLinetoRel& original_ );
// Destructor
/*virtual*/ ~PathLinetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
// Path Horizontal Lineto
class MagickPPExport PathLinetoHorizontalAbs : public VPathBase
{
public:
PathLinetoHorizontalAbs ( double x_ )
: _x(x_)
{
}
/*virtual*/ ~PathLinetoHorizontalAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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_)
{
}
/*virtual*/ ~PathLinetoHorizontalRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
void x( double x_ )
{
_x = x_;
}
double x( void ) const
{
return _x;
}
private:
double _x;
};
// Path Vertical Lineto
class MagickPPExport PathLinetoVerticalAbs : public VPathBase
{
public:
PathLinetoVerticalAbs ( double y_ )
: _y(y_)
{
}
/*virtual*/ ~PathLinetoVerticalAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ 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_)
{
}
/*virtual*/ ~PathLinetoVerticalRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
void y( double y_ )
{
_y = y_;
}
double y( void ) const
{
return _y;
}
private:
double _y;
};
// Path Moveto
class MagickPPExport PathMovetoAbs : public VPathBase
{
public:
// Simple moveto
PathMovetoAbs ( const Magick::Coordinate &coordinate_ );
// Moveto followed by implicit linetos
PathMovetoAbs ( const CoordinateList &coordinates_ );
// Copy constructor
PathMovetoAbs ( const PathMovetoAbs& original_ );
// Destructor
/*virtual*/ ~PathMovetoAbs ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
class MagickPPExport PathMovetoRel : public VPathBase
{
public:
// Simple moveto
PathMovetoRel ( const Magick::Coordinate &coordinate_ );
// Moveto followed by implicit linetos
PathMovetoRel ( const CoordinateList &coordinates_ );
// Copy constructor
PathMovetoRel ( const PathMovetoRel& original_ );
// Destructor
/*virtual*/ ~PathMovetoRel ( void );
// Operator to invoke equivalent draw API call
/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;
// Return polymorphic copy of object
/*virtual*/ VPathBase* copy() const;
private:
CoordinateList _coordinates;
};
} // namespace Magick
#endif // Magick_Drawable_header
Magick::DrawableRectangle
Definition: Drawable.h:1401
Magick::DrawableRectangle::upperLeftY
void upperLeftY(double upperLeftY_)
Definition: Drawable.h:1429
Magick::DrawableDensity
Definition: Drawable.h:831
Magick::DrawableGravity::gravity
GravityType gravity(void) const
Definition: Drawable.h:1111
Magick::PathLinetoVerticalAbs::y
void y(double y_)
Definition: Drawable.h:3047
Magick::DrawableAlpha::paintMethod
PaintMethod paintMethod(void) const
Definition: Drawable.h:347
Magick::DrawableMiterLimit::miterlimit
size_t miterlimit(void) const
Definition: Drawable.h:1849
Magick::PathCurvetoAbs
Definition: Drawable.h:2642
Magick::operator!=
MagickPPExport int operator!=(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:38
Magick::DrawableTextInterlineSpacing
Definition: Drawable.h:2162
Magick::DrawableCompositeImage::composition
void composition(CompositeOperator composition_)
Definition: Drawable.h:766
Magick::DrawableLine::startX
double startX(void) const
Definition: Drawable.h:1144
Magick::DrawableCircle::originY
double originY(void) const
Definition: Drawable.h:639
Magick::PathLinetoVerticalRel::PathLinetoVerticalRel
PathLinetoVerticalRel(double y_)
Definition: Drawable.h:3062
Magick::PathArcArgs::xAxisRotation
double xAxisRotation(void) const
Definition: Drawable.h:2391
Magick::DrawableRoundRectangle::upperLeftY
void upperLeftY(double upperLeftY_)
Definition: Drawable.h:1564
Magick::DrawableAffine::sy
double sy(void) const
Definition: Drawable.h:257
Magick::DrawableCompositeImage::x
double x(void) const
Definition: Drawable.h:782
Magick::DrawableStrokeDashOffset::DrawableStrokeDashOffset
DrawableStrokeDashOffset(const double offset_)
Definition: Drawable.h:1752
Magick::DrawableAffine::ty
void ty(const double ty_)
Definition: Drawable.h:289
Magick::DrawableAffine::rx
double rx(void) const
Definition: Drawable.h:266
Magick::DrawableArc::endY
double endY(void) const
Definition: Drawable.h:413
Magick::DrawableText::x
void x(double x_)
Definition: Drawable.h:2025
Magick::DrawableRoundRectangle::centerX
void centerX(double centerX_)
Definition: Drawable.h:1517
Magick::DrawablePolyline
Definition: Drawable.h:1293
Magick::DrawableStrokeAntialias::DrawableStrokeAntialias
DrawableStrokeAntialias(bool flag_)
Definition: Drawable.h:1886
Magick::Coordinate::y
void y(double y_)
Definition: Drawable.h:65
Magick::DrawableRectangle::DrawableRectangle
DrawableRectangle(double upperLeftX_, double upperLeftY_, double lowerRightX_, double lowerRightY_)
Definition: Drawable.h:1404
Magick::PathCurvetoArgs::x2
void x2(double x2_)
Definition: Drawable.h:2571
Magick::PathCurveToArgsList
std::vector< Magick::PathCurvetoArgs > PathCurveToArgsList
Definition: Drawable.h:2630
Magick::PathQuadraticCurvetoArgs::y1
double y1(void) const
Definition: Drawable.h:2767
Magick::DrawableFillOpacity::opacity
double opacity(void) const
Definition: Drawable.h:1044
Magick::PathCurvetoArgs
Definition: Drawable.h:2540
Magick::DrawableRoundRectangle::lowerRightY
double lowerRightY(void) const
Definition: Drawable.h:1586
Magick::DrawableFont::font
void font(const std::string &font_)
Definition: Drawable.h:1073
Magick::PathLinetoHorizontalRel::PathLinetoHorizontalRel
PathLinetoHorizontalRel(double x_)
Definition: Drawable.h:3004
Magick::DrawablePoint::DrawablePoint
DrawablePoint(double x_, double y_)
Definition: Drawable.h:1207
Magick::DrawableClipUnits
Definition: Drawable.h:515
Magick::DrawablePoint::y
void y(double y_)
Definition: Drawable.h:1229
Magick::DrawableAlpha::paintMethod
void paintMethod(PaintMethod paintMethod_)
Definition: Drawable.h:342
Magick::DrawableRoundRectangle::DrawableRoundRectangle
DrawableRoundRectangle(double upperLeftX_, double upperLeftY_, double lowerRightX_, double lowerRightY_, double cornerWidth_, double cornerHeight_)
Definition: Drawable.h:1496
Magick::DrawableArc::startX
double startX(void) const
Definition: Drawable.h:386
Magick::DrawableEllipse::DrawableEllipse
DrawableEllipse(double originX_, double originY_, double radiusX_, double radiusY_, double arcStart_, double arcEnd_)
Definition: Drawable.h:853
Magick::DrawablePopGraphicContext::DrawablePopGraphicContext
DrawablePopGraphicContext(void)
Definition: Drawable.h:1316
Magick::DrawableAlpha::x
double x(void) const
Definition: Drawable.h:327
Magick::PathArcAbs
Definition: Drawable.h:2469
Magick::DrawableLine::endX
void endX(double endX_)
Definition: Drawable.h:1158
Magick::DrawablePoint::x
double x(void) const
Definition: Drawable.h:1224
Magick::DrawableCompositeImage::width
void width(double width_)
Definition: Drawable.h:796
Magick::Coordinate::Coordinate
Coordinate(double x_, double y_)
Definition: Drawable.h:56
Magick::DrawableText::x
double x(void) const
Definition: Drawable.h:2029
Magick::DrawableTranslation
Definition: Drawable.h:2251
Magick::PathQuadraticCurvetoArgs::x1
void x1(double x1_)
Definition: Drawable.h:2754
Magick::DrawableRectangle::upperLeftY
double upperLeftY(void) const
Definition: Drawable.h:1433
Magick::DrawableTextDecoration
Definition: Drawable.h:2113
Magick::Point
Definition: Geometry.h:208
Magick::DrawableRoundRectangle::upperLeftX
double upperLeftX(void) const
Definition: Drawable.h:1559
Magick::PathArcArgs::x
double x(void) const
Definition: Drawable.h:2418
Magick::DrawableStrokeLineJoin::linejoin
LineJoin linejoin(void) const
Definition: Drawable.h:1820
Magick::DrawableSkewY::angle
void angle(double angle_)
Definition: Drawable.h:1703
Magick::DrawableEllipse
Definition: Drawable.h:850
Magick::DrawableClipPath::clip_path
std::string clip_path(void) const
Definition: Drawable.h:596
Magick::DrawableFillRule::fillRule
FillRule fillRule(void) const
Definition: Drawable.h:1012
Magick::DrawableArc::startY
double startY(void) const
Definition: Drawable.h:395
Magick::DrawableScaling::y
double y(void) const
Definition: Drawable.h:1648
Magick::DrawablePointSize::pointSize
double pointSize(void) const
Definition: Drawable.h:1263
Magick::DrawableArc::DrawableArc
DrawableArc(double startX_, double startY_, double endX_, double endY_, double startDegrees_, double endDegrees_)
Definition: Drawable.h:363
Magick::PathQuadraticCurvetoArgsList
std::vector< Magick::PathQuadraticCurvetoArgs > PathQuadraticCurvetoArgsList
Definition: Drawable.h:2811
Magick::DrawableFillColor::color
void color(const Color &color_)
Definition: Drawable.h:951
Magick::DrawableStrokeOpacity
Definition: Drawable.h:1941
Magick::DrawablePointSize
Definition: Drawable.h:1244
Magick::PathLinetoHorizontalRel::x
double x(void) const
Definition: Drawable.h:3021
Magick::DrawableGravity
Definition: Drawable.h:1091
Magick::DrawableTranslation::y
double y(void) const
Definition: Drawable.h:2280
Magick::DrawableAffine::tx
void tx(const double tx_)
Definition: Drawable.h:280
Magick::Coordinate::y
double y(void) const
Definition: Drawable.h:66
Magick::PathClosePath::PathClosePath
PathClosePath(void)
Definition: Drawable.h:2520
Magick::DrawableTextUnderColor
Definition: Drawable.h:2222
Magick::DrawableStrokeLineJoin
Definition: Drawable.h:1801
Magick::DrawableSkewY
Definition: Drawable.h:1688
Magick::DrawableViewbox::DrawableViewbox
DrawableViewbox(::ssize_t x1_, ::ssize_t y1_, ::ssize_t x2_, ::ssize_t y2_)
Definition: Drawable.h:2294
Magick::DrawableFont
Definition: Drawable.h:1054
Magick::PathArcArgs::radiusY
double radiusY(void) const
Definition: Drawable.h:2382
Magick::DrawableTextUnderColor::color
Color color(void) const
Definition: Drawable.h:2241
Magick::DrawableViewbox::y2
void y2(::ssize_t y2_)
Definition: Drawable.h:2337
Magick::DrawableCircle::perimY
double perimY(void) const
Definition: Drawable.h:657
Magick::PathQuadraticCurvetoArgs::y
void y(double y_)
Definition: Drawable.h:2781
Magick::DrawableViewbox::y1
::ssize_t y1(void) const
Definition: Drawable.h:2323
Magick::DrawableStrokeDashArray
Definition: Drawable.h:1721
Magick::DrawableViewbox::x2
void x2(::ssize_t x2_)
Definition: Drawable.h:2328
Magick::PathQuadraticCurvetoArgs::x1
double x1(void) const
Definition: Drawable.h:2758
Magick::DrawableRoundRectangle::upperLeftX
void upperLeftX(double upperLeftX_)
Definition: Drawable.h:1555
Magick::DrawableEllipse::originY
double originY(void) const
Definition: Drawable.h:885
Magick::PathSmoothCurvetoRel
Definition: Drawable.h:2713
Magick::PathArcArgs::largeArcFlag
void largeArcFlag(bool largeArcFlag_)
Definition: Drawable.h:2396
Magick::PathSmoothCurvetoAbs
Definition: Drawable.h:2689
Magick::DrawableStrokeLineJoin::linejoin
void linejoin(LineJoin linejoin_)
Definition: Drawable.h:1816
Magick::PathLinetoHorizontalAbs::PathLinetoHorizontalAbs
PathLinetoHorizontalAbs(double x_)
Definition: Drawable.h:2976
Magick::operator<
MagickPPExport int operator<(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:50
Magick::PathClosePath
Definition: Drawable.h:2517
Magick::DrawableFillRule
Definition: Drawable.h:992
Magick::PathLinetoVerticalRel::y
double y(void) const
Definition: Drawable.h:3079
Magick::DrawableTextDecoration::decoration
DecorationType decoration(void) const
Definition: Drawable.h:2132
Magick::Coordinate::Coordinate
Coordinate(void)
Definition: Drawable.h:52
Magick::PathSmoothQuadraticCurvetoRel
Definition: Drawable.h:2895
Magick::DrawableRoundRectangle::lowerRightX
double lowerRightX(void) const
Definition: Drawable.h:1577
Magick::DrawableLine
Definition: Drawable.h:1121
Magick::DrawableArc::startDegrees
void startDegrees(double startDegrees_)
Definition: Drawable.h:418
Magick::DrawableViewbox::y2
::ssize_t y2(void) const
Definition: Drawable.h:2341
Magick::DrawableCompositeImage::x
void x(double x_)
Definition: Drawable.h:778
Magick::DrawableLine::endY
void endY(double endY_)
Definition: Drawable.h:1167
Magick::PathLinetoHorizontalAbs::x
double x(void) const
Definition: Drawable.h:2993
Magick::DrawableStrokeOpacity::opacity
double opacity(void) const
Definition: Drawable.h:1963
Magick::Coordinate
Definition: Drawable.h:48
Magick::PathMovetoRel
Definition: Drawable.h:3113
Magick::DrawablePushGraphicContext::DrawablePushGraphicContext
DrawablePushGraphicContext(void)
Definition: Drawable.h:1337
Magick::PathSmoothQuadraticCurvetoAbs
Definition: Drawable.h:2871
Magick::DrawableEllipse::radiusX
double radiusX(void) const
Definition: Drawable.h:894
Magick::DrawableFillRule::fillRule
void fillRule(const FillRule fillRule_)
Definition: Drawable.h:1008
Magick::PathArcArgs::sweepFlag
void sweepFlag(bool sweepFlag_)
Definition: Drawable.h:2405
Magick::DrawableArc::endX
void endX(double endX_)
Definition: Drawable.h:400
Magick::PathQuadraticCurvetoRel
Definition: Drawable.h:2847
Magick::DrawableStrokeLineJoin::DrawableStrokeLineJoin
DrawableStrokeLineJoin(LineJoin linejoin_)
Definition: Drawable.h:1804
Magick::DrawableRoundRectangle::upperLeftY
double upperLeftY(void) const
Definition: Drawable.h:1568
Magick::DrawableTextUnderColor::color
void color(const Color &color_)
Definition: Drawable.h:2237
Magick::DrawableCompositeImage::y
void y(double y_)
Definition: Drawable.h:787
Magick::DrawableFillOpacity::opacity
void opacity(double opacity_)
Definition: Drawable.h:1039
Magick::DrawableEllipse::arcEnd
double arcEnd(void) const
Definition: Drawable.h:921
Magick::DrawableColor::x
double x(void) const
Definition: Drawable.h:692
Magick::PathCurvetoArgs::y1
void y1(double y1_)
Definition: Drawable.h:2562
Magick::DrawableCircle::perimY
void perimY(double perimY_)
Definition: Drawable.h:653
Magick::DrawableLine::startX
void startX(double startX_)
Definition: Drawable.h:1140
Magick::DrawablePoint::x
void x(double x_)
Definition: Drawable.h:1220
Magick::DrawableTextKerning
Definition: Drawable.h:2202
Magick::operator<=
MagickPPExport int operator<=(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:72
Magick::PathQuadraticCurvetoArgs::x
double x(void) const
Definition: Drawable.h:2776
Magick::PathArcArgs::xAxisRotation
void xAxisRotation(double xAxisRotation_)
Definition: Drawable.h:2387
Magick::operator>=
MagickPPExport int operator>=(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:66
Magick::DrawableTextDecoration::decoration
void decoration(DecorationType decoration_)
Definition: Drawable.h:2128
Magick::DrawableEllipse::radiusX
void radiusX(double radiusX_)
Definition: Drawable.h:890
Magick::DrawableColor::paintMethod
void paintMethod(PaintMethod paintMethod_)
Definition: Drawable.h:706
Magick::DrawableScaling::x
double x(void) const
Definition: Drawable.h:1639
Magick::PathLinetoHorizontalAbs::x
void x(double x_)
Definition: Drawable.h:2989
Magick::PathCurvetoArgs::x1
void x1(double x1_)
Definition: Drawable.h:2553
Magick::DrawableTranslation::DrawableTranslation
DrawableTranslation(double x_, double y_)
Definition: Drawable.h:2254
Magick::DrawableRectangle::lowerRightY
void lowerRightY(double lowerRightY_)
Definition: Drawable.h:1447
Magick::DrawableText::encoding
void encoding(const std::string &encoding_)
Definition: Drawable.h:2020
Magick::DrawableLine::startY
void startY(double startY_)
Definition: Drawable.h:1149
Magick::PathArcArgs::sweepFlag
bool sweepFlag(void) const
Definition: Drawable.h:2409
Magick::VPath
Definition: Drawable.h:184
Magick::DrawableScaling::x
void x(double x_)
Definition: Drawable.h:1635
Magick::DrawableGravity::gravity
void gravity(GravityType gravity_)
Definition: Drawable.h:1107
Magick::DrawableGravity::DrawableGravity
DrawableGravity(GravityType gravity_)
Definition: Drawable.h:1094
Magick::PathArcArgs
Definition: Drawable.h:2356
Magick::DrawableStrokeOpacity::DrawableStrokeOpacity
DrawableStrokeOpacity(double opacity_)
Definition: Drawable.h:1945
Magick::DrawableScaling::DrawableScaling
DrawableScaling(double x_, double y_)
Definition: Drawable.h:1622
Magick::DrawableFillOpacity
Definition: Drawable.h:1022
Magick::VPathBase::VPathBase
VPathBase(void)
Definition: Drawable.h:163
Magick::DrawableStrokeLineCap::linecap
LineCap linecap(void) const
Definition: Drawable.h:1791
Magick::DrawableCircle::perimX
double perimX(void) const
Definition: Drawable.h:648
Magick::Coordinate::~Coordinate
virtual ~Coordinate()
Definition: Drawable.h:60
Magick::PathLinetoVerticalAbs::PathLinetoVerticalAbs
PathLinetoVerticalAbs(double y_)
Definition: Drawable.h:3034
MagickPPExport
#define MagickPPExport
Definition: Include.h:297
Magick::VPathBase
Definition: Drawable.h:159
Magick::DrawableFillPatternUrl
Definition: Drawable.h:968
Magick::DrawableRectangle::lowerRightY
double lowerRightY(void) const
Definition: Drawable.h:1451
Magick::DrawableViewbox::x1
void x1(::ssize_t x1_)
Definition: Drawable.h:2310
Magick::DrawableSkewX::DrawableSkewX
DrawableSkewX(double angle_)
Definition: Drawable.h:1662
Magick::DrawableScaling
Definition: Drawable.h:1619
Magick::DrawableList
std::vector< Magick::Drawable > DrawableList
Definition: Drawable.h:146
Magick::Coordinate::x
double x(void) const
Definition: Drawable.h:63
Magick::DrawableStrokeDashOffset
Definition: Drawable.h:1749
Magick::DrawableRectangle::lowerRightX
double lowerRightX(void) const
Definition: Drawable.h:1442
Magick::DrawableEllipse::arcEnd
void arcEnd(double arcEnd_)
Definition: Drawable.h:917
Magick::DrawableTextAlignment
Definition: Drawable.h:2060
Magick::DrawableCircle::DrawableCircle
DrawableCircle(double originX_, double originY_, double perimX_, double perimY_)
Definition: Drawable.h:609
Magick::PathQuadraticCurvetoArgs
Definition: Drawable.h:2742
Magick::PathLinetoHorizontalRel::x
void x(double x_)
Definition: Drawable.h:3017
Magick::DrawableCircle::originX
void originX(double originX_)
Definition: Drawable.h:626
Magick::PathArcArgs::x
void x(double x_)
Definition: Drawable.h:2414
Magick::DrawableArc::endDegrees
double endDegrees(void) const
Definition: Drawable.h:431
Magick::DrawableColor::x
void x(double x_)
Definition: Drawable.h:688
Magick::DrawableMiterLimit::miterlimit
void miterlimit(size_t miterlimit_)
Definition: Drawable.h:1845
Magick::PathLinetoVerticalAbs
Definition: Drawable.h:3031
Magick::DrawableText::y
void y(double y_)
Definition: Drawable.h:2034
Magick::DrawableStrokeLineCap::DrawableStrokeLineCap
DrawableStrokeLineCap(LineCap linecap_)
Definition: Drawable.h:1775
Magick::PathQuadraticCurvetoArgs::x
void x(double x_)
Definition: Drawable.h:2772
Magick::DrawableClipRule
Definition: Drawable.h:493
Magick::DrawableAffine::sy
void sy(const double sy_)
Definition: Drawable.h:253
Magick::VPathList
std::vector< Magick::VPath > VPathList
Definition: Drawable.h:209
Magick::DrawableText
Definition: Drawable.h:2002
Magick::PathLinetoAbs
Definition: Drawable.h:2923
Magick::DrawableFont::font
std::string font(void) const
Definition: Drawable.h:1077
Magick::DrawableRoundRectangle::width
void width(double width_)
Definition: Drawable.h:1535
Magick::DrawableEllipse::originX
double originX(void) const
Definition: Drawable.h:876
Magick::DrawableStrokePatternUrl
Definition: Drawable.h:1859
Magick::PathQuadraticCurvetoArgs::y1
void y1(double y1_)
Definition: Drawable.h:2763
Magick::DrawableTranslation::x
void x(double x_)
Definition: Drawable.h:2267
Magick::Color
Definition: Color.h:36
Magick::DrawableAffine::sx
void sx(const double sx_)
Definition: Drawable.h:244
Magick::PathCurvetoArgs::y
double y(void) const
Definition: Drawable.h:2602
Magick::DrawableCompositeImage::height
double height(void) const
Definition: Drawable.h:809
Magick::DrawableArc::startX
void startX(double startX_)
Definition: Drawable.h:382
Magick::DrawablePopPattern
Definition: Drawable.h:1355
Magick::PathArcArgs::y
void y(double y_)
Definition: Drawable.h:2423
Magick::DrawableAffine
Definition: Drawable.h:226
Magick::PathCurvetoArgs::y1
double y1(void) const
Definition: Drawable.h:2566
Magick::DrawableLine::endY
double endY(void) const
Definition: Drawable.h:1171
Magick::DrawableEllipse::radiusY
void radiusY(double radiusY_)
Definition: Drawable.h:899
Magick::DrawableSkewY::DrawableSkewY
DrawableSkewY(double angle_)
Definition: Drawable.h:1691
Magick::DrawableColor
Definition: Drawable.h:670
Magick::PathLinetoHorizontalRel
Definition: Drawable.h:3001
Magick::DrawableTextAntialias::flag
bool flag(void) const
Definition: Drawable.h:2103
Magick::DrawableMiterLimit
Definition: Drawable.h:1830
Magick::DrawableArc::endY
void endY(double endY_)
Definition: Drawable.h:409
Magick::DrawableRoundRectangle::centerY
void centerY(double centerY_)
Definition: Drawable.h:1526
Magick::DrawableEllipse::originY
void originY(double originY_)
Definition: Drawable.h:881
Magick::DrawableCompositeImage::composition
CompositeOperator composition(void) const
Definition: Drawable.h:770
Magick::DrawableFillColor
Definition: Drawable.h:936
MagickDrawableExtern
#define MagickDrawableExtern
Definition: Drawable.h:40
Magick::DrawableAlpha::DrawableAlpha
DrawableAlpha(double x_, double y_, PaintMethod paintMethod_)
Definition: Drawable.h:307
Magick::DrawableRoundRectangle::hight
double hight(void) const
Definition: Drawable.h:1548
Magick::DrawableRotation
Definition: Drawable.h:1464
Magick::DrawableStrokeColor::color
void color(const Color &color_)
Definition: Drawable.h:1927
Magick::DrawableCircle
Definition: Drawable.h:606
Magick::DrawableTextAntialias
Definition: Drawable.h:2084
Magick::DrawableRoundRectangle::lowerRightY
void lowerRightY(double lowerRightY_)
Definition: Drawable.h:1582
Magick::DrawablePath
Definition: Drawable.h:1184
Magick::PathCurvetoArgs::x2
double x2(void) const
Definition: Drawable.h:2575
Magick::DrawableLine::DrawableLine
DrawableLine(double startX_, double startY_, double endX_, double endY_)
Definition: Drawable.h:1124
Magick::DrawableBezier
Definition: Drawable.h:446
Magick::DrawableStrokeLineCap
Definition: Drawable.h:1772
Magick::DrawableStrokeWidth::DrawableStrokeWidth
DrawableStrokeWidth(double width_)
Definition: Drawable.h:1976
Magick::DrawableStrokeLineCap::linecap
void linecap(LineCap linecap_)
Definition: Drawable.h:1787
Magick::DrawablePopClipPath
Definition: Drawable.h:537
Magick::DrawableRoundRectangle::cornerHeight
double cornerHeight(void) const
Definition: Drawable.h:1604
Magick::DrawableAffine::ty
double ty(void) const
Definition: Drawable.h:293
Magick::DrawableCompositeImage::height
void height(double height_)
Definition: Drawable.h:805
Magick::DrawableAffine::rx
void rx(const double rx_)
Definition: Drawable.h:262
Magick::DrawableAlpha::y
double y(void) const
Definition: Drawable.h:337
Magick::PathQuadraticCurvetoAbs
Definition: Drawable.h:2823
Magick::DrawableTextInterwordSpacing
Definition: Drawable.h:2182
Color.h
Magick::PathMovetoAbs
Definition: Drawable.h:3089
Magick::DrawableClipPath
Definition: Drawable.h:578
Magick::DrawableText::text
void text(const std::string &text_)
Definition: Drawable.h:2043
Magick::DrawableRotation::DrawableRotation
DrawableRotation(double angle_)
Definition: Drawable.h:1467
Magick::DrawableLine::endX
double endX(void) const
Definition: Drawable.h:1162
Magick::DrawableStrokeAntialias
Definition: Drawable.h:1883
Magick::PathCurvetoArgs::x
double x(void) const
Definition: Drawable.h:2593
Magick::PathLinetoRel
Definition: Drawable.h:2947
Magick::DrawableCompositeImage
Definition: Drawable.h:723
Include.h
Magick::DrawableStrokeAntialias::flag
bool flag(void) const
Definition: Drawable.h:1902
Magick::DrawableColor::y
double y(void) const
Definition: Drawable.h:701
Magick::PathArcArgsList
std::vector< Magick::PathArcArgs > PathArcArgsList
Definition: Drawable.h:2456
Magick::DrawableArc::endDegrees
void endDegrees(double endDegrees_)
Definition: Drawable.h:427
Magick::DrawableStrokeWidth::width
void width(double width_)
Definition: Drawable.h:1988
Magick::DrawableMiterLimit::DrawableMiterLimit
DrawableMiterLimit(size_t miterlimit_)
Definition: Drawable.h:1833
Magick::DrawableRectangle::upperLeftX
double upperLeftX(void) const
Definition: Drawable.h:1424
Magick::PathArcArgs::radiusX
void radiusX(double radiusX_)
Definition: Drawable.h:2369
Magick::DrawableRoundRectangle
Definition: Drawable.h:1493
Magick::DrawablePoint
Definition: Drawable.h:1204
Magick::DrawableSkewX::angle
void angle(double angle_)
Definition: Drawable.h:1674
Magick::DrawablePopClipPath::DrawablePopClipPath
DrawablePopClipPath(void)
Definition: Drawable.h:540
Magick::DrawableRoundRectangle::cornerWidth
double cornerWidth(void) const
Definition: Drawable.h:1595
Magick::DrawableRoundRectangle::width
double width(void) const
Definition: Drawable.h:1539
Magick::DrawableArc::startY
void startY(double startY_)
Definition: Drawable.h:391
Magick::DrawableTextDirection
Definition: Drawable.h:2142
Magick::DrawableRotation::angle
double angle(void) const
Definition: Drawable.h:1483
Magick::DrawableCompositeImage::width
double width(void) const
Definition: Drawable.h:800
Magick::DrawableScaling::y
void y(double y_)
Definition: Drawable.h:1644
Magick::DrawableLine::startY
double startY(void) const
Definition: Drawable.h:1153
Magick::DrawableCircle::originX
double originX(void) const
Definition: Drawable.h:630
Magick::DrawableAffine::tx
double tx(void) const
Definition: Drawable.h:284
Magick::DrawableViewbox::x1
::ssize_t x1(void) const
Definition: Drawable.h:2314
Magick::DrawableColor::y
void y(double y_)
Definition: Drawable.h:697
Magick::DrawableStrokeWidth::width
double width(void) const
Definition: Drawable.h:1992
Magick::PathLinetoVerticalRel::y
void y(double y_)
Definition: Drawable.h:3075
Magick::DrawableAffine::ry
double ry(void) const
Definition: Drawable.h:275
Magick::DrawableRoundRectangle::cornerHeight
void cornerHeight(double cornerHeight_)
Definition: Drawable.h:1600
Magick::DrawablePointSize::DrawablePointSize
DrawablePointSize(double pointSize_)
Definition: Drawable.h:1247
Magick::Drawable
Definition: Drawable.h:120
Magick::DrawableCircle::perimX
void perimX(double perimX_)
Definition: Drawable.h:644
Magick::DrawableStrokeWidth
Definition: Drawable.h:1973
Magick::DrawableRoundRectangle::cornerWidth
void cornerWidth(double cornerWidth_)
Definition: Drawable.h:1591
Magick::DrawableAffine::ry
void ry(const double ry_)
Definition: Drawable.h:271
Magick::DrawableArc::endX
double endX(void) const
Definition: Drawable.h:404
Magick::Coordinate::x
void x(double x_)
Definition: Drawable.h:62
Magick::DrawableViewbox::x2
::ssize_t x2(void) const
Definition: Drawable.h:2332
Magick::DrawablePushGraphicContext
Definition: Drawable.h:1334
Magick::operator>
MagickPPExport int operator>(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:44
Magick::PathQuadraticCurvetoArgs::y
double y(void) const
Definition: Drawable.h:2785
Magick::DrawableSkewX::angle
double angle(void) const
Definition: Drawable.h:1678
Magick::DrawableClipPath::clip_path
void clip_path(const std::string &id_)
Definition: Drawable.h:592
Magick::operator==
MagickPPExport int operator==(const Magick::Color &left_, const Magick::Color &right_)
Definition: Color.cpp:22
Magick::Image
class MagickPPExport Image
Definition: Drawable.h:722
Magick::DrawablePointSize::pointSize
void pointSize(double pointSize_)
Definition: Drawable.h:1259
Magick::DrawableEllipse::arcStart
double arcStart(void) const
Definition: Drawable.h:912
Magick::DrawableText::y
double y(void) const
Definition: Drawable.h:2038
Magick::PathCurvetoRel
Definition: Drawable.h:2666
Magick::DrawableRoundRectangle::lowerRightX
void lowerRightX(double lowerRightX_)
Definition: Drawable.h:1573
Magick::PathCurvetoArgs::y2
double y2(void) const
Definition: Drawable.h:2584
Magick::DrawableBase
Definition: Drawable.h:99
Magick::DrawableColor::paintMethod
PaintMethod paintMethod(void) const
Definition: Drawable.h:710
Magick::DrawableEllipse::originX
void originX(double originX_)
Definition: Drawable.h:872
Magick
Definition: Blob.h:17
Magick::DrawableRoundRectangle::centerY
double centerY(void) const
Definition: Drawable.h:1530
Magick::PathLinetoVerticalAbs::y
double y(void) const
Definition: Drawable.h:3051
Magick::DrawablePushPattern
Definition: Drawable.h:1376
Magick::DrawablePopPattern::DrawablePopPattern
DrawablePopPattern(void)
Definition: Drawable.h:1358
Magick::DrawableSkewX
Definition: Drawable.h:1659
Magick::DrawableArc
Definition: Drawable.h:360
Magick::DrawableViewbox::y1
void y1(::ssize_t y1_)
Definition: Drawable.h:2319
Magick::DrawableFillOpacity::DrawableFillOpacity
DrawableFillOpacity(double opacity_)
Definition: Drawable.h:1026
Magick::DrawablePopGraphicContext
Definition: Drawable.h:1313
Magick::DrawableStrokeColor
Definition: Drawable.h:1912
Magick::PathArcArgs::y
double y(void) const
Definition: Drawable.h:2427
Magick::DrawableTranslation::y
void y(double y_)
Definition: Drawable.h:2276
Magick::PathLinetoVerticalRel
Definition: Drawable.h:3059
Magick::DrawableAffine::sx
double sx(void) const
Definition: Drawable.h:248
Magick::DrawableEllipse::arcStart
void arcStart(double arcStart_)
Definition: Drawable.h:908
Magick::CoordinateList
std::vector< Magick::Coordinate > CoordinateList
Definition: Drawable.h:73
Magick::PathCurvetoArgs::x1
double x1(void) const
Definition: Drawable.h:2557
Magick::DrawableRotation::angle
void angle(double angle_)
Definition: Drawable.h:1479
Magick::DrawableAlpha::y
void y(double y_)
Definition: Drawable.h:332
Magick::DrawableTextAntialias::flag
void flag(bool flag_)
Definition: Drawable.h:2099
Magick::DrawableTranslation::x
double x(void) const
Definition: Drawable.h:2271
Magick::PathArcArgs::radiusX
double radiusX(void) const
Definition: Drawable.h:2373
Magick::DrawableRoundRectangle::hight
void hight(double hight_)
Definition: Drawable.h:1544
Magick::DrawableCompositeImage::y
double y(void) const
Definition: Drawable.h:791
Magick::PathArcRel
Definition: Drawable.h:2493
Magick::DrawableRectangle::lowerRightX
void lowerRightX(double lowerRightX_)
Definition: Drawable.h:1438
Magick::DrawablePolygon
Definition: Drawable.h:1273
Magick::DrawableStrokeColor::color
Color color(void) const
Definition: Drawable.h:1931
Magick::DrawableArc::startDegrees
double startDegrees(void) const
Definition: Drawable.h:422
Magick::Image
Definition: Image.h:55
Magick::DrawablePushClipPath
Definition: Drawable.h:558
Magick::DrawableStrokeOpacity::opacity
void opacity(double opacity_)
Definition: Drawable.h:1958
Magick::PathCurvetoArgs::x
void x(double x_)
Definition: Drawable.h:2589
Magick::DrawableFillRule::DrawableFillRule
DrawableFillRule(const FillRule fillRule_)
Definition: Drawable.h:995
Magick::PathArcArgs::largeArcFlag
bool largeArcFlag(void) const
Definition: Drawable.h:2400
Magick::PathCurvetoArgs::y
void y(double y_)
Definition: Drawable.h:2598
Magick::DrawableRoundRectangle::centerX
double centerX(void) const
Definition: Drawable.h:1521
Magick::DrawableBorderColor
Definition: Drawable.h:469
Magick::DrawableColor::DrawableColor
DrawableColor(double x_, double y_, PaintMethod paintMethod_)
Definition: Drawable.h:673
Magick::DrawableViewbox
Definition: Drawable.h:2291
Geometry.h
Magick::DrawableStrokeAntialias::flag
void flag(bool flag_)
Definition: Drawable.h:1898
Magick::DrawableText::text
std::string text(void) const
Definition: Drawable.h:2047
Magick::DrawableSkewY::angle
double angle(void) const
Definition: Drawable.h:1707
Magick::PathCurvetoArgs::y2
void y2(double y2_)
Definition: Drawable.h:2580
Magick::DrawablePoint::y
double y(void) const
Definition: Drawable.h:1233
Magick::PathArcArgs::radiusY
void radiusY(double radiusY_)
Definition: Drawable.h:2378
Magick::DrawableCircle::originY
void originY(double originY_)
Definition: Drawable.h:635
Magick::DrawableRectangle::upperLeftX
void upperLeftX(double upperLeftX_)
Definition: Drawable.h:1420
Magick::DrawableAlpha::x
void x(double x_)
Definition: Drawable.h:322
Magick::DrawableFillColor::color
Color color(void) const
Definition: Drawable.h:955
Magick::DrawableEllipse::radiusY
double radiusY(void) const
Definition: Drawable.h:903
Magick::PathLinetoHorizontalAbs
Definition: Drawable.h:2973
Magick::DrawableAlpha
Definition: Drawable.h:303