1// This may look like C code, but it is really -*- C++ -*-
2//
3// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
4// Copyright Dirk Lemstra 2014-2015
5//
6// Implementation of Drawable (Graphic objects)
7//
8
9#define MAGICKCORE_IMPLEMENTATION  1
10#define MAGICK_PLUSPLUS_IMPLEMENTATION 1
11#define MAGICK_DRAWABLE_IMPLEMENTATION
12
13#include "Magick++/Include.h"
14#include <math.h>
15#include <string>
16
17#include "Magick++/Drawable.h"
18#include "Magick++/Image.h"
19
20using namespace std;
21
22MagickPPExport int Magick::operator == (const Magick::Coordinate& left_,
23  const Magick::Coordinate& right_)
24{
25  return((left_.x() == right_.x()) && (left_.y() == right_.y()));
26}
27
28MagickPPExport int Magick::operator != (const Magick::Coordinate& left_,
29  const Magick::Coordinate& right_)
30{
31  return(!(left_ == right_));
32}
33
34MagickPPExport int Magick::operator > (const Magick::Coordinate& left_,
35  const Magick::Coordinate& right_)
36{
37  return (!(left_ < right_) && (left_ != right_));
38}
39
40MagickPPExport int Magick::operator < (const Magick::Coordinate& left_,
41  const Magick::Coordinate& right_)
42{
43  // Based on distance from origin
44  return((sqrt(left_.x()*left_.x() + left_.y()*left_.y())) <
45    (sqrt(right_.x()*right_.x() + right_.y()*right_.y())));
46}
47
48MagickPPExport int Magick::operator >= (const Magick::Coordinate& left_,
49  const Magick::Coordinate& right_)
50{
51  return((left_ > right_) || (left_ == right_));
52}
53
54MagickPPExport int Magick::operator <= (const Magick::Coordinate& left_,
55  const Magick::Coordinate& right_)
56{
57  return((left_ < right_) || (left_ == right_));
58}
59
60/* DrawableBase */
61Magick::DrawableBase::DrawableBase()
62{
63}
64
65Magick::DrawableBase::~DrawableBase(void)
66{
67}
68
69void Magick::DrawableBase::operator()(MagickCore::DrawingWand * context_) const
70{
71  (void) context_;
72}
73
74Magick::DrawableBase* Magick::DrawableBase::copy() const
75{
76  return new DrawableBase(*this);
77}
78
79/* Drawable */
80Magick::Drawable::Drawable(void)
81  : dp((Magick::DrawableBase *) NULL)
82{
83}
84
85Magick::Drawable::Drawable(const Magick::DrawableBase& original_)
86  : dp(original_.copy())
87{
88}
89
90Magick::Drawable::~Drawable(void)
91{
92  delete dp;
93  dp=(Magick::DrawableBase *) NULL;
94}
95
96Magick::Drawable::Drawable(const Magick::Drawable& original_)
97  : dp((original_.dp != (Magick::DrawableBase *) NULL ? original_.dp->copy() :
98    (Magick::DrawableBase *) NULL))
99{
100}
101
102Magick::Drawable& Magick::Drawable::operator= (
103  const Magick::Drawable& original_)
104{
105  DrawableBase
106    *temp_dp;
107
108  if (this != &original_)
109    {
110      temp_dp=(original_.dp != (Magick::DrawableBase *) NULL ?
111        original_.dp->copy() : (Magick::DrawableBase *) NULL);
112      delete dp;
113      dp=temp_dp;
114    }
115  return(*this);
116}
117
118void Magick::Drawable::operator()(MagickCore::DrawingWand * context_) const
119{
120  if (dp != (Magick::DrawableBase *) NULL)
121    dp->operator()(context_);
122}
123
124/*virtual*/
125Magick::VPathBase::~VPathBase ( void )
126{
127}
128
129// Constructor
130Magick::VPath::VPath ( void )
131  : dp(0)
132{
133}
134
135// Construct from VPathBase
136Magick::VPath::VPath ( const Magick::VPathBase& original_ )
137  : dp(original_.copy())
138{
139}
140
141// Destructor
142/* virtual */ Magick::VPath::~VPath ( void )
143{
144  delete dp;
145  dp = 0;
146}
147
148// Copy constructor
149Magick::VPath::VPath ( const Magick::VPath& original_ )
150  : dp(original_.dp? original_.dp->copy(): 0)
151{
152}
153
154// Assignment operator
155Magick::VPath& Magick::VPath::operator= (const Magick::VPath& original_ )
156{
157  if (this != &original_)
158    {
159      VPathBase* temp_dp = (original_.dp ? original_.dp->copy() : 0);
160      delete dp;
161      dp = temp_dp;
162    }
163  return *this;
164}
165
166// Operator to invoke contained object
167void Magick::VPath::operator()( MagickCore::DrawingWand * context_ ) const
168{
169  if(dp)
170    dp->operator()( context_ );
171}
172
173MagickPPExport int Magick::operator == ( const Magick::VPath& /*left_*/,
174                                        const Magick::VPath& /*right_*/ )
175{
176  return ( 1 );
177}
178MagickPPExport int Magick::operator != ( const Magick::VPath& /*left_*/,
179                                        const Magick::VPath& /*right_*/ )
180{
181  return ( 0 );
182}
183MagickPPExport int Magick::operator > ( const Magick::VPath& /*left_*/,
184                                       const Magick::VPath& /*right_*/ )
185{
186  return ( 0 );
187}
188MagickPPExport int Magick::operator <  ( const Magick::VPath& /*left_*/,
189                                        const Magick::VPath& /*right_*/ )
190{
191  return  ( 0 );
192}
193MagickPPExport int Magick::operator >= ( const Magick::VPath& left_,
194                                        const Magick::VPath& right_ )
195{
196  return ( ( left_ > right_ ) || ( left_ == right_ ) );
197}
198MagickPPExport int Magick::operator <= ( const Magick::VPath& left_,
199                                        const Magick::VPath& right_ )
200{
201  return ( ( left_ < right_ ) || ( left_ == right_ ) );
202}
203
204//
205// Drawable Objects
206//
207
208// Affine (scaling, rotation, and translation)
209Magick::DrawableAffine::DrawableAffine( double sx_, double sy_,
210                                        double rx_, double ry_,
211                                        double tx_, double ty_ )
212{
213  _affine.sx = sx_;
214  _affine.rx = rx_;
215  _affine.ry = ry_;
216  _affine.sy = sy_;
217  _affine.tx = tx_;
218  _affine.ty = ty_;
219}
220Magick::DrawableAffine::DrawableAffine( void )
221{
222  GetAffineMatrix(&_affine);
223}
224Magick::DrawableAffine::~DrawableAffine( void )
225{
226}
227void Magick::DrawableAffine::operator()( MagickCore::DrawingWand * context_ ) const
228{
229  DrawAffine( context_, &_affine );
230}
231Magick::DrawableBase* Magick::DrawableAffine::copy() const
232{
233  return new DrawableAffine(*this);
234}
235
236Magick::DrawableAlpha::~DrawableAlpha(void)
237{
238}
239
240void Magick::DrawableAlpha::operator()(MagickCore::DrawingWand * context_) const
241{
242  DrawAlpha(context_,_x,_y,_paintMethod);
243}
244
245Magick::DrawableBase* Magick::DrawableAlpha::copy() const
246{
247  return new DrawableAlpha(*this);
248}
249
250// Arc
251Magick::DrawableArc::~DrawableArc( void )
252{
253}
254void Magick::DrawableArc::operator()( MagickCore::DrawingWand * context_ ) const
255{
256  DrawArc( context_, _startX, _startY, _endX, _endY, _startDegrees, _endDegrees );
257}
258Magick::DrawableBase* Magick::DrawableArc::copy() const
259{
260  return new DrawableArc(*this);
261}
262
263//
264// Bezier curve
265//
266// Construct from coordinates (Coordinate list must contain at least three members)
267Magick::DrawableBezier::DrawableBezier ( const CoordinateList &coordinates_ )
268  : _coordinates(coordinates_)
269{
270}
271// Copy constructor
272Magick::DrawableBezier::DrawableBezier( const Magick::DrawableBezier& original_ )
273  : DrawableBase (original_),
274    _coordinates(original_._coordinates)
275{
276}
277// Destructor
278Magick::DrawableBezier::~DrawableBezier( void )
279{
280}
281void Magick::DrawableBezier::operator()( MagickCore::DrawingWand * context_ ) const
282{
283  size_t num_coords = (size_t) _coordinates.size();
284  PointInfo *coordinates = new PointInfo[num_coords];
285
286  PointInfo *q = coordinates;
287  CoordinateList::const_iterator p = _coordinates.begin();
288
289  while( p != _coordinates.end() )
290    {
291      q->x = p->x();
292      q->y = p->y();
293      q++;
294      p++;
295    }
296
297  DrawBezier( context_, num_coords, coordinates );
298  delete [] coordinates;
299}
300Magick::DrawableBase* Magick::DrawableBezier::copy() const
301{
302  return new DrawableBezier(*this);
303}
304
305
306/* DrawableBorderColor */
307Magick::DrawableBorderColor::DrawableBorderColor(const Magick::Color &color_)
308  : _color(color_)
309{
310}
311
312Magick::DrawableBorderColor::DrawableBorderColor
313  (const Magick::DrawableBorderColor &original_)
314  : DrawableBase(original_),
315    _color(original_._color)
316{
317}
318
319Magick::DrawableBorderColor::~DrawableBorderColor(void)
320{
321}
322
323void Magick::DrawableBorderColor::operator()(
324  MagickCore::DrawingWand *context_) const
325{
326  PixelInfo
327    color;
328
329  PixelWand
330    *pixel_wand;
331
332  color=static_cast<PixelInfo>(_color);
333  pixel_wand=NewPixelWand();
334  PixelSetPixelColor(pixel_wand,&color);
335  DrawSetBorderColor(context_,pixel_wand);
336  pixel_wand=DestroyPixelWand(pixel_wand);
337}
338
339void Magick::DrawableBorderColor::color(const Color &color_)
340{
341  _color=color_;
342}
343
344Magick::Color Magick::DrawableBorderColor::color(void) const
345{
346  return(_color);
347}
348
349Magick::DrawableBase* Magick::DrawableBorderColor::copy() const
350{
351  return(new DrawableBorderColor(*this));
352}
353
354
355/* DrawableClipRule */
356Magick::DrawableClipRule::DrawableClipRule(const FillRule fillRule_)
357{
358  _fillRule=fillRule_;
359}
360
361Magick::DrawableClipRule::~DrawableClipRule(void)
362{
363}
364
365void Magick::DrawableClipRule::operator()(
366  MagickCore::DrawingWand * context_) const
367{
368  DrawSetClipRule(context_,_fillRule);
369}
370
371void Magick::DrawableClipRule::fillRule(const FillRule fillRule_)
372{
373  _fillRule=fillRule_;
374}
375
376Magick::FillRule Magick::DrawableClipRule::fillRule(void) const
377{
378  return(_fillRule);
379}
380
381Magick::DrawableBase* Magick::DrawableClipRule::copy() const
382{
383  return(new DrawableClipRule(*this));
384}
385
386
387/* DrawableClipUnits */
388Magick::DrawableClipUnits::DrawableClipUnits(const ClipPathUnits units_)
389{
390  _units = units_;
391}
392
393Magick::DrawableClipUnits::~DrawableClipUnits(void)
394{
395}
396
397void Magick::DrawableClipUnits::operator()(
398  MagickCore::DrawingWand * context_) const
399{
400  DrawSetClipUnits(context_, _units);
401}
402
403void Magick::DrawableClipUnits::units(const ClipPathUnits units_)
404{
405  _units = units_;
406}
407
408Magick::ClipPathUnits Magick::DrawableClipUnits::units(void) const
409{
410  return(_units);
411}
412
413Magick::DrawableBase* Magick::DrawableClipUnits::copy() const
414{
415  return(new DrawableClipUnits(*this));
416}
417
418
419//
420//Clip Path
421//
422
423// Pop (terminate) Clip path definition
424Magick::DrawablePopClipPath::~DrawablePopClipPath ( void )
425{
426}
427void Magick::DrawablePopClipPath::operator() ( MagickCore::DrawingWand * context_ ) const
428{
429  DrawPopClipPath( context_ );
430  DrawPopDefs(context_);
431}
432Magick::DrawableBase* Magick::DrawablePopClipPath::copy() const
433{
434  return new DrawablePopClipPath(*this);
435}
436
437// Push clip path definition
438Magick::DrawablePushClipPath::DrawablePushClipPath( const std::string &id_)
439  : _id(id_.c_str())    //multithread safe const char*
440{
441}
442Magick::DrawablePushClipPath::DrawablePushClipPath
443( const Magick::DrawablePushClipPath& original_ ) //multithread safe const char*
444  : DrawableBase (original_),
445    _id(original_._id.c_str())
446{
447}
448Magick::DrawablePushClipPath::~DrawablePushClipPath( void )
449{
450}
451void Magick::DrawablePushClipPath::operator()
452  ( MagickCore::DrawingWand * context_ ) const
453{
454  DrawPushDefs(context_);
455  DrawPushClipPath( context_, _id.c_str());
456}
457Magick::DrawableBase* Magick::DrawablePushClipPath::copy() const
458{
459  return new DrawablePushClipPath(*this);
460}
461//
462// ClipPath
463//
464Magick::DrawableClipPath::DrawableClipPath( const std::string &id_ )
465:_id(id_.c_str())
466{
467}
468
469Magick::DrawableClipPath::DrawableClipPath ( const Magick::DrawableClipPath& original_ )
470  : DrawableBase (original_),
471    _id(original_._id.c_str())
472{
473}
474Magick::DrawableClipPath::~DrawableClipPath( void )
475{
476}
477void Magick::DrawableClipPath::operator()( MagickCore::DrawingWand * context_ ) const
478{
479	(void) DrawSetClipPath( context_, _id.c_str());
480}
481Magick::DrawableBase* Magick::DrawableClipPath::copy() const
482{
483  return new DrawableClipPath(*this);
484}
485
486// Circle
487Magick::DrawableCircle::~DrawableCircle ( void )
488{
489}
490void Magick::DrawableCircle::operator()( MagickCore::DrawingWand * context_ ) const
491{
492  DrawCircle( context_, _originX, _originY, _perimX, _perimY );
493}
494Magick::DrawableBase* Magick::DrawableCircle::copy() const
495{
496  return new DrawableCircle(*this);
497}
498
499// Colorize at point using PaintMethod
500Magick::DrawableColor::~DrawableColor( void )
501{
502}
503void Magick::DrawableColor::operator()( MagickCore::DrawingWand * context_ ) const
504{
505  DrawColor( context_, _x, _y, _paintMethod );
506}
507Magick::DrawableBase* Magick::DrawableColor::copy() const
508{
509  return new DrawableColor(*this);
510}
511
512// Draw image at point
513Magick::DrawableCompositeImage::DrawableCompositeImage
514( double x_, double y_,
515  double width_, double height_,
516  const std::string &filename_,
517  Magick::CompositeOperator composition_ )
518  : _composition(composition_),
519    _x(x_),
520    _y(y_),
521    _width(width_),
522    _height(height_),
523    _image(new Image(filename_))
524{
525}
526Magick::DrawableCompositeImage::DrawableCompositeImage
527( double x_, double y_,
528  double width_, double height_,
529  const Magick::Image &image_,
530  Magick::CompositeOperator composition_ )
531  : _composition(composition_),
532    _x(x_),
533    _y(y_),
534    _width(width_),
535    _height(height_),
536    _image(new Image(image_))
537{
538}
539Magick::DrawableCompositeImage::DrawableCompositeImage
540( double x_, double y_,
541  double width_, double height_,
542  const std::string &filename_ )
543  :_composition(CopyCompositeOp),
544   _x(x_),
545   _y(y_),
546   _width(width_),
547   _height(height_),
548   _image(new Image(filename_))
549{
550}
551Magick::DrawableCompositeImage::DrawableCompositeImage
552( double x_, double y_,
553  double width_, double height_,
554  const Magick::Image &image_ )
555  :_composition(CopyCompositeOp),
556   _x(x_),
557   _y(y_),
558   _width(width_),
559   _height(height_),
560   _image(new Image(image_))
561{
562}
563Magick::DrawableCompositeImage::DrawableCompositeImage
564( double x_, double y_,
565  const std::string &filename_ )
566  : _composition(CopyCompositeOp),
567    _x(x_),
568    _y(y_),
569    _width(0),
570    _height(0),
571    _image(new Image(filename_))
572{
573  _width=_image->columns();
574  _height=_image->rows();
575}
576Magick::DrawableCompositeImage::DrawableCompositeImage
577( double x_, double y_,
578  const Magick::Image &image_ )
579  : _composition(CopyCompositeOp),
580    _x(x_),
581    _y(y_),
582    _width(0),
583    _height(0),
584    _image(new Image(image_))
585{
586  _width=_image->columns();
587  _height=_image->rows();
588}
589// Copy constructor
590Magick::DrawableCompositeImage::DrawableCompositeImage
591( const Magick::DrawableCompositeImage& original_ )
592  :  Magick::DrawableBase(original_),
593     _composition(original_._composition),
594     _x(original_._x),
595     _y(original_._y),
596     _width(original_._width),
597     _height(original_._height),
598     _image(new Image(*original_._image))
599{
600}
601Magick::DrawableCompositeImage::~DrawableCompositeImage( void )
602{
603  delete _image;
604}
605// Assignment operator
606Magick::DrawableCompositeImage& Magick::DrawableCompositeImage::operator=
607(const Magick::DrawableCompositeImage& original_ )
608{
609  // If not being set to ourself
610  if ( this != &original_ )
611    {
612      _composition = original_._composition;
613      _x = original_._x;
614      _y = original_._y;
615      _width = original_._width;
616      _height = original_._height;
617      Image* temp_image = new Image(*original_._image);
618      delete _image;
619      _image = temp_image;
620    }
621  return *this;
622}
623void Magick::DrawableCompositeImage::filename( const std::string &filename_ )
624{
625  Image* temp_image = new Image(filename_);
626  delete _image;
627  _image = temp_image;
628}
629std::string Magick::DrawableCompositeImage::filename( void ) const
630{
631  return _image->fileName();
632}
633
634void Magick::DrawableCompositeImage::image( const Magick::Image &image_ )
635{
636  Image* temp_image = new Image(image_);
637  delete _image;
638  _image = temp_image;
639}
640Magick::Image Magick::DrawableCompositeImage::image( void ) const
641{
642  return *_image;
643}
644
645// Specify image format used to output Base64 inlined image data.
646void Magick::DrawableCompositeImage::magick( std::string magick_ )
647{
648  _image->magick( magick_ );
649}
650std::string Magick::DrawableCompositeImage::magick( void )
651{
652  return _image->magick();
653}
654
655void Magick::DrawableCompositeImage::operator()
656  ( MagickCore::DrawingWand * context_ ) const
657{
658  MagickWand
659    *magick_wand;
660
661  magick_wand=NewMagickWandFromImage(_image->constImage());
662  (void) DrawComposite( context_, _composition, _x, _y, _width, _height,
663     magick_wand );
664  magick_wand=DestroyMagickWand(magick_wand);
665}
666
667Magick::DrawableBase* Magick::DrawableCompositeImage::copy() const
668{
669  return new DrawableCompositeImage(*this);
670}
671
672Magick::DrawableDensity::DrawableDensity(const Point &density_)
673  : _density(density_)
674{
675}
676
677Magick::DrawableDensity::DrawableDensity(const std::string &density_)
678  : _density(density_)
679{
680}
681
682Magick::DrawableDensity::~DrawableDensity(void)
683{
684}
685
686void Magick::DrawableDensity::operator()(
687  MagickCore::DrawingWand *context_) const
688{
689  DrawSetDensity(context_,_density.c_str());
690}
691
692Magick::DrawableBase* Magick::DrawableDensity::copy() const
693{
694  return(new DrawableDensity(*this));
695}
696
697// Ellipse
698Magick::DrawableEllipse::~DrawableEllipse( void )
699{
700}
701void Magick::DrawableEllipse::operator()
702  ( MagickCore::DrawingWand * context_ ) const
703{
704  DrawEllipse( context_, _originX, _originY, _radiusX, _radiusY,
705               _arcStart, _arcEnd );
706}
707Magick::DrawableBase* Magick::DrawableEllipse::copy() const
708{
709  return new DrawableEllipse(*this);
710}
711
712// Specify drawing fill color
713Magick::DrawableFillColor::DrawableFillColor( const Magick::Color &color_ )
714  : _color(color_)
715{
716}
717Magick::DrawableFillColor::DrawableFillColor
718( const Magick::DrawableFillColor& original_ )
719  : DrawableBase (original_),
720    _color(original_._color)
721{
722}
723Magick::DrawableFillColor::~DrawableFillColor( void )
724{
725}
726void Magick::DrawableFillColor::operator()
727  ( MagickCore::DrawingWand * context_ ) const
728{
729  PixelInfo color = static_cast<PixelInfo>(_color);
730  PixelWand *pixel_wand=NewPixelWand();
731  PixelSetPixelColor(pixel_wand,&color);
732  DrawSetFillColor(context_,pixel_wand);
733  pixel_wand=DestroyPixelWand(pixel_wand);
734}
735Magick::DrawableBase* Magick::DrawableFillColor::copy() const
736{
737  return new DrawableFillColor(*this);
738}
739
740/* DrawableFillPatternUrl */
741Magick::DrawableFillPatternUrl::DrawableFillPatternUrl(const std::string &url_)
742  : _url(url_)
743{
744}
745
746Magick::DrawableFillPatternUrl::DrawableFillPatternUrl(
747  const Magick::DrawableFillPatternUrl& original_)
748  : DrawableBase(original_),
749  _url(original_._url)
750{
751}
752
753Magick::DrawableFillPatternUrl::~DrawableFillPatternUrl(void)
754{
755}
756
757void Magick::DrawableFillPatternUrl::operator()(
758  MagickCore::DrawingWand * context_) const
759{
760  DrawSetFillPatternURL(context_, _url.c_str());
761}
762
763void Magick::DrawableFillPatternUrl::url(const std::string &url_)
764{
765  _url = url_;
766}
767
768std::string Magick::DrawableFillPatternUrl::url(void) const
769{
770  return(_url);
771}
772
773Magick::DrawableBase* Magick::DrawableFillPatternUrl::copy() const
774{
775  return(new DrawableFillPatternUrl(*this));
776}
777
778// Specify drawing fill fule
779Magick::DrawableFillRule::~DrawableFillRule ( void )
780{
781}
782void Magick::DrawableFillRule::operator()
783  ( MagickCore::DrawingWand * context_ ) const
784{
785  DrawSetFillRule( context_, _fillRule );
786}
787Magick::DrawableBase* Magick::DrawableFillRule::copy() const
788{
789  return new DrawableFillRule(*this);
790}
791
792Magick::DrawableFillOpacity::~DrawableFillOpacity(void)
793{
794}
795
796void Magick::DrawableFillOpacity::operator()
797  (MagickCore::DrawingWand *context_) const
798{
799  DrawSetFillOpacity(context_,_opacity);
800}
801
802Magick::DrawableBase* Magick::DrawableFillOpacity::copy() const
803{
804  return new DrawableFillOpacity(*this);
805}
806
807// Specify text font
808Magick::DrawableFont::DrawableFont ( const std::string &font_ )
809  : _font(font_),
810    _family(),
811    _style(Magick::AnyStyle),
812    _weight(400),
813    _stretch(Magick::NormalStretch)
814{
815}
816Magick::DrawableFont::DrawableFont ( const std::string &family_,
817                                     Magick::StyleType style_,
818                                     const unsigned int weight_,
819                                     Magick::StretchType stretch_ )
820  : _font(),
821    _family(family_),
822    _style(style_),
823    _weight(weight_),
824    _stretch(stretch_)
825{
826}
827Magick::DrawableFont::DrawableFont ( const Magick::DrawableFont& original_ )
828  : DrawableBase (original_),
829    _font(original_._font),
830    _family(original_._family),
831    _style(original_._style),
832    _weight(original_._weight),
833    _stretch(original_._stretch)
834{
835}
836Magick::DrawableFont::~DrawableFont ( void )
837{
838}
839void Magick::DrawableFont::operator()( MagickCore::DrawingWand * context_ ) const
840{
841  // font
842  if(_font.length())
843    {
844      (void) DrawSetFont( context_, _font.c_str() );
845    }
846
847  if(_family.length())
848    {
849      // font-family
850      (void) DrawSetFontFamily( context_, _family.c_str() );
851
852      // font-style
853      DrawSetFontStyle( context_, _style );
854
855      // font-weight
856      DrawSetFontWeight( context_, _weight );
857
858      // font-stretch
859      DrawSetFontStretch( context_, _stretch );
860    }
861}
862Magick::DrawableBase* Magick::DrawableFont::copy() const
863{
864  return new DrawableFont(*this);
865}
866
867// Specify text positioning gravity
868Magick::DrawableGravity::~DrawableGravity ( void )
869{
870}
871void Magick::DrawableGravity::operator()
872  ( MagickCore::DrawingWand * context_ ) const
873{
874  DrawSetGravity( context_, _gravity );
875}
876Magick::DrawableBase* Magick::DrawableGravity::copy() const
877{
878  return new DrawableGravity(*this);
879}
880
881// Line
882Magick::DrawableLine::~DrawableLine ( void )
883{
884}
885void Magick::DrawableLine::operator()( MagickCore::DrawingWand * context_ ) const
886{
887  DrawLine( context_, _startX, _startY, _endX, _endY );
888}
889Magick::DrawableBase* Magick::DrawableLine::copy() const
890{
891  return new DrawableLine(*this);
892}
893
894// Drawable Path
895Magick::DrawablePath::DrawablePath ( const VPathList &path_ )
896  : _path(path_)
897{
898}
899Magick::DrawablePath::DrawablePath ( const Magick::DrawablePath& original_ )
900  : DrawableBase (original_),
901    _path(original_._path)
902{
903}
904Magick::DrawablePath::~DrawablePath ( void )
905{
906}
907void Magick::DrawablePath::operator()( MagickCore::DrawingWand * context_ ) const
908{
909  DrawPathStart( context_ );
910
911  for( VPathList::const_iterator p = _path.begin();
912       p != _path.end(); p++ )
913    p->operator()( context_ ); // FIXME, how to quit loop on error?
914
915  DrawPathFinish( context_ );
916}
917Magick::DrawableBase* Magick::DrawablePath::copy() const
918{
919  return new DrawablePath(*this);
920}
921
922// Point
923Magick::DrawablePoint::~DrawablePoint ( void )
924{
925}
926void Magick::DrawablePoint::operator()( MagickCore::DrawingWand * context_ ) const
927{
928  DrawPoint( context_, _x, _y );
929}
930Magick::DrawableBase* Magick::DrawablePoint::copy() const
931{
932  return new DrawablePoint(*this);
933}
934
935// Text pointsize
936Magick::DrawablePointSize::~DrawablePointSize ( void )
937{
938}
939void Magick::DrawablePointSize::operator()
940  ( MagickCore::DrawingWand * context_ ) const
941{
942  DrawSetFontSize( context_, _pointSize );
943}
944Magick::DrawableBase* Magick::DrawablePointSize::copy() const
945{
946  return new DrawablePointSize(*this);
947}
948
949// Polygon (Coordinate list must contain at least three members)
950Magick::DrawablePolygon::DrawablePolygon ( const CoordinateList &coordinates_ )
951  : _coordinates(coordinates_)
952{
953}
954Magick::DrawablePolygon::DrawablePolygon
955( const Magick::DrawablePolygon& original_ )
956  : DrawableBase (original_),
957    _coordinates(original_._coordinates)
958{
959}
960Magick::DrawablePolygon::~DrawablePolygon ( void )
961{
962}
963void Magick::DrawablePolygon::operator()
964  ( MagickCore::DrawingWand * context_ ) const
965{
966  size_t num_coords = (size_t) _coordinates.size();
967  PointInfo *coordinates = new PointInfo[num_coords];
968
969  PointInfo *q = coordinates;
970  CoordinateList::const_iterator p = _coordinates.begin();
971
972  while( p != _coordinates.end() )
973    {
974      q->x = p->x();
975      q->y = p->y();
976      q++;
977      p++;
978    }
979
980  DrawPolygon( context_, num_coords, coordinates );
981  delete [] coordinates;
982}
983Magick::DrawableBase* Magick::DrawablePolygon::copy() const
984{
985  return new DrawablePolygon(*this);
986}
987
988// Polyline (Coordinate list must contain at least three members)
989Magick::DrawablePolyline::DrawablePolyline
990( const CoordinateList &coordinates_ )
991  : _coordinates(coordinates_)
992{
993}
994Magick::DrawablePolyline::DrawablePolyline
995( const Magick::DrawablePolyline& original_ )
996  : DrawableBase (original_),
997    _coordinates(original_._coordinates)
998{
999}
1000Magick::DrawablePolyline::~DrawablePolyline ( void )
1001{
1002}
1003void Magick::DrawablePolyline::operator()
1004  ( MagickCore::DrawingWand * context_ ) const
1005{
1006  size_t num_coords = (size_t) _coordinates.size();
1007  PointInfo *coordinates = new PointInfo[num_coords];
1008
1009  PointInfo *q = coordinates;
1010  CoordinateList::const_iterator p = _coordinates.begin();
1011
1012  while( p != _coordinates.end() )
1013    {
1014      q->x = p->x();
1015      q->y = p->y();
1016      q++;
1017      p++;
1018    }
1019
1020  DrawPolyline( context_, num_coords, coordinates );
1021  delete [] coordinates;
1022}
1023Magick::DrawableBase* Magick::DrawablePolyline::copy() const
1024{
1025  return new DrawablePolyline(*this);
1026}
1027
1028// Pop Graphic Context
1029Magick::DrawablePopGraphicContext::~DrawablePopGraphicContext ( void )
1030{
1031}
1032void Magick::DrawablePopGraphicContext::operator()
1033  ( MagickCore::DrawingWand * context_ ) const
1034{
1035  PopDrawingWand( context_ );
1036}
1037Magick::DrawableBase* Magick::DrawablePopGraphicContext::copy() const
1038{
1039  return new DrawablePopGraphicContext(*this);
1040}
1041
1042// Push Graphic Context
1043Magick::DrawablePushGraphicContext::~DrawablePushGraphicContext ( void )
1044{
1045}
1046void Magick::DrawablePushGraphicContext::operator()
1047  ( MagickCore::DrawingWand * context_ ) const
1048{
1049  PushDrawingWand( context_ );
1050}
1051Magick::DrawableBase* Magick::DrawablePushGraphicContext::copy() const
1052{
1053  return new DrawablePushGraphicContext(*this);
1054}
1055
1056// Pop (terminate) Pattern definition
1057Magick::DrawablePopPattern::~DrawablePopPattern ( void )
1058{
1059}
1060void Magick::DrawablePopPattern::operator()
1061  ( MagickCore::DrawingWand * context_ ) const
1062{
1063  (void) DrawPopPattern( context_ );
1064}
1065Magick::DrawableBase* Magick::DrawablePopPattern::copy() const
1066{
1067  return new DrawablePopPattern(*this);
1068}
1069
1070// Push Pattern definition
1071Magick::DrawablePushPattern::DrawablePushPattern
1072( const std::string &id_, ssize_t x_, ssize_t y_,
1073  size_t width_, size_t height_ )
1074  : _id(id_),
1075    _x(x_),
1076    _y(y_),
1077    _width(width_),
1078    _height(height_)
1079{
1080}
1081Magick::DrawablePushPattern::DrawablePushPattern
1082( const Magick::DrawablePushPattern& original_ )
1083  : DrawableBase (original_),
1084    _id(original_._id),
1085    _x(original_._x),
1086    _y(original_._y),
1087    _width(original_._width),
1088    _height(original_._height)
1089{
1090}
1091Magick::DrawablePushPattern::~DrawablePushPattern ( void )
1092{
1093}
1094void Magick::DrawablePushPattern::operator()
1095  ( MagickCore::DrawingWand * context_ ) const
1096{
1097  (void) DrawPushPattern( context_, _id.c_str(), _x, _y, _width, _height );
1098}
1099Magick::DrawableBase* Magick::DrawablePushPattern::copy() const
1100{
1101  return new DrawablePushPattern(*this);
1102}
1103
1104// Rectangle
1105Magick::DrawableRectangle::~DrawableRectangle ( void )
1106{
1107}
1108void Magick::DrawableRectangle::operator()
1109  ( MagickCore::DrawingWand * context_ ) const
1110{
1111  DrawRectangle( context_, _upperLeftX, _upperLeftY,
1112                 _lowerRightX, _lowerRightY );
1113}
1114Magick::DrawableBase* Magick::DrawableRectangle::copy() const
1115{
1116  return new DrawableRectangle(*this);
1117}
1118
1119// Apply Rotation
1120Magick::DrawableRotation::~DrawableRotation ( void )
1121{
1122}
1123void Magick::DrawableRotation::operator()
1124  ( MagickCore::DrawingWand * context_ ) const
1125{
1126  DrawRotate( context_, _angle );
1127}
1128Magick::DrawableBase* Magick::DrawableRotation::copy() const
1129{
1130  return new DrawableRotation(*this);
1131}
1132
1133// Round Rectangle
1134Magick::DrawableRoundRectangle::~DrawableRoundRectangle ( void )
1135{
1136}
1137void Magick::DrawableRoundRectangle::operator()
1138  ( MagickCore::DrawingWand * context_ ) const
1139{
1140  DrawRoundRectangle( context_, _centerX,_centerY, _width,_hight,
1141                      _cornerWidth, _cornerHeight);
1142}
1143Magick::DrawableBase* Magick::DrawableRoundRectangle::copy() const
1144{
1145  return new DrawableRoundRectangle(*this);
1146}
1147
1148// Apply Scaling
1149Magick::DrawableScaling::~DrawableScaling ( void )
1150{
1151}
1152void Magick::DrawableScaling::operator()
1153  ( MagickCore::DrawingWand * context_ ) const
1154{
1155  DrawScale( context_, _x, _y );
1156}
1157Magick::DrawableBase* Magick::DrawableScaling::copy() const
1158{
1159  return new DrawableScaling(*this);
1160}
1161
1162// Apply Skew in the X direction
1163Magick::DrawableSkewX::~DrawableSkewX ( void )
1164{
1165}
1166void Magick::DrawableSkewX::operator()
1167  ( MagickCore::DrawingWand * context_ ) const
1168{
1169  DrawSkewX( context_, _angle );
1170}
1171Magick::DrawableBase* Magick::DrawableSkewX::copy() const
1172{
1173  return new DrawableSkewX(*this);
1174}
1175
1176// Apply Skew in the Y direction
1177Magick::DrawableSkewY::~DrawableSkewY ( void )
1178{
1179}
1180void Magick::DrawableSkewY::operator()( MagickCore::DrawingWand * context_ ) const
1181{
1182  DrawSkewY( context_, _angle );
1183}
1184Magick::DrawableBase* Magick::DrawableSkewY::copy() const
1185{
1186  return new DrawableSkewY(*this);
1187}
1188
1189/* DrawableStrokeDashArray */
1190Magick::DrawableStrokeDashArray::DrawableStrokeDashArray(const double* dasharray_)
1191  : _size(0),
1192    _dasharray(0)
1193{
1194  dasharray(dasharray_);
1195}
1196
1197Magick::DrawableStrokeDashArray::DrawableStrokeDashArray(
1198  const Magick::DrawableStrokeDashArray& original_)
1199  : DrawableBase (original_),
1200    _size(original_._size),
1201    _dasharray(new double[_size+1])
1202{
1203  // Copy elements
1204  {
1205    for (size_t i=0; i < _size; i++)
1206      _dasharray[i]=original_._dasharray[i];
1207    _dasharray[_size]=0.0;
1208  }
1209}
1210
1211Magick::DrawableStrokeDashArray::~DrawableStrokeDashArray(void)
1212{
1213  delete [] _dasharray;
1214  _size=0;
1215  _dasharray=(double *) NULL;
1216}
1217
1218Magick::DrawableStrokeDashArray& Magick::DrawableStrokeDashArray::operator=(
1219  const Magick::DrawableStrokeDashArray &original_)
1220{
1221  if (this != &original_)
1222    {
1223      delete [] _dasharray;
1224      _size=original_._size;
1225      _dasharray = new double[_size+1];
1226      // Copy elements
1227      {
1228        for (size_t i=0; i < _size; i++)
1229          _dasharray[i]=original_._dasharray[i];
1230        _dasharray[_size]=0.0;
1231      }
1232    }
1233  return(*this);
1234}
1235
1236void Magick::DrawableStrokeDashArray::operator()(
1237  MagickCore::DrawingWand *context_) const
1238{
1239  (void) DrawSetStrokeDashArray(context_,(const unsigned long) _size,
1240    _dasharray);
1241}
1242
1243Magick::DrawableBase *Magick::DrawableStrokeDashArray::copy() const
1244{
1245  return(new DrawableStrokeDashArray(*this));
1246}
1247
1248void Magick::DrawableStrokeDashArray::dasharray(const double* dasharray_)
1249{
1250  size_t
1251    n;
1252
1253  delete [] _dasharray;
1254  _size=0;
1255  _dasharray=0;
1256
1257  if (dasharray_ != (const double *) NULL)
1258    {
1259      const double
1260        *p;
1261
1262      // Count elements in dash array
1263      n=0;
1264      {
1265        p = dasharray_;
1266        while(*p++ != 0.0)
1267          n++;
1268      }
1269      _size=n;
1270
1271      // Allocate elements
1272      _dasharray=new double[_size+1];
1273      // Copy elements
1274      {
1275        for (size_t i=0; i < _size; i++)
1276          _dasharray[i]=dasharray_[i];
1277        _dasharray[_size]=0.0;
1278      }
1279    }
1280}
1281
1282const double* Magick::DrawableStrokeDashArray::dasharray(void) const
1283{
1284  return(_dasharray);
1285}
1286
1287/* DrawableStrokeDashOffset */
1288Magick::DrawableStrokeDashOffset::~DrawableStrokeDashOffset(void)
1289{
1290}
1291
1292void Magick::DrawableStrokeDashOffset::operator()
1293  ( MagickCore::DrawingWand * context_) const
1294{
1295  DrawSetStrokeDashOffset(context_,_offset);
1296}
1297
1298Magick::DrawableBase* Magick::DrawableStrokeDashOffset::copy() const
1299{
1300  return(new DrawableStrokeDashOffset(*this));
1301}
1302
1303void Magick::DrawableStrokeDashOffset::offset(const double offset_)
1304{
1305  _offset=offset_;
1306}
1307
1308double Magick::DrawableStrokeDashOffset::offset(void) const
1309{
1310  return(_offset);
1311}
1312
1313// Stroke linecap
1314Magick::DrawableStrokeLineCap::~DrawableStrokeLineCap ( void )
1315{
1316}
1317void Magick::DrawableStrokeLineCap::operator()
1318  ( MagickCore::DrawingWand * context_ ) const
1319{
1320  DrawSetStrokeLineCap( context_, _linecap );
1321}
1322Magick::DrawableBase* Magick::DrawableStrokeLineCap::copy() const
1323{
1324  return new DrawableStrokeLineCap(*this);
1325}
1326
1327// Stroke linejoin
1328Magick::DrawableStrokeLineJoin::~DrawableStrokeLineJoin ( void )
1329{
1330}
1331void Magick::DrawableStrokeLineJoin::operator()
1332  ( MagickCore::DrawingWand * context_ ) const
1333{
1334  DrawSetStrokeLineJoin( context_, _linejoin );
1335}
1336Magick::DrawableBase* Magick::DrawableStrokeLineJoin::copy() const
1337{
1338  return new DrawableStrokeLineJoin(*this);
1339}
1340
1341// Stroke miterlimit
1342Magick::DrawableMiterLimit::~DrawableMiterLimit ( void )
1343{
1344}
1345void Magick::DrawableMiterLimit::operator()
1346  ( MagickCore::DrawingWand * context_ ) const
1347{
1348  DrawSetStrokeMiterLimit( context_, _miterlimit );
1349}
1350Magick::DrawableBase* Magick::DrawableMiterLimit::copy() const
1351{
1352  return new DrawableMiterLimit(*this);
1353}
1354
1355
1356/* DrawableStrokePatternUrl */
1357Magick::DrawableStrokePatternUrl::DrawableStrokePatternUrl(
1358  const std::string &url_)
1359  : _url(url_)
1360{
1361}
1362
1363Magick::DrawableStrokePatternUrl::DrawableStrokePatternUrl(
1364  const Magick::DrawableStrokePatternUrl& original_)
1365  : DrawableBase(original_),
1366  _url(original_._url)
1367{
1368}
1369
1370Magick::DrawableStrokePatternUrl::~DrawableStrokePatternUrl(void)
1371{
1372}
1373
1374void Magick::DrawableStrokePatternUrl::operator()(
1375  MagickCore::DrawingWand * context_) const
1376{
1377  DrawSetStrokePatternURL(context_, _url.c_str());
1378}
1379
1380void Magick::DrawableStrokePatternUrl::url(const std::string &url_)
1381{
1382  _url = url_;
1383}
1384
1385std::string Magick::DrawableStrokePatternUrl::url(void) const
1386{
1387  return(_url);
1388}
1389
1390Magick::DrawableBase* Magick::DrawableStrokePatternUrl::copy() const
1391{
1392  return(new DrawableStrokePatternUrl(*this));
1393}
1394
1395// Stroke antialias
1396Magick::DrawableStrokeAntialias::~DrawableStrokeAntialias ( void )
1397{
1398}
1399void Magick::DrawableStrokeAntialias::operator()
1400( MagickCore::DrawingWand * context_ ) const
1401{
1402  DrawSetStrokeAntialias( context_, static_cast<MagickBooleanType>
1403    (_flag ? MagickTrue : MagickFalse) );
1404}
1405Magick::DrawableBase* Magick::DrawableStrokeAntialias::copy() const
1406{
1407  return new DrawableStrokeAntialias(*this);
1408}
1409
1410// Stroke color
1411Magick::DrawableStrokeColor::DrawableStrokeColor
1412( const Magick::Color &color_ )
1413  : _color(color_)
1414{
1415}
1416Magick::DrawableStrokeColor::DrawableStrokeColor
1417( const Magick::DrawableStrokeColor& original_ )
1418  : DrawableBase (original_),
1419    _color(original_._color)
1420{
1421}
1422Magick::DrawableStrokeColor::~DrawableStrokeColor ( void )
1423{
1424}
1425void Magick::DrawableStrokeColor::operator()
1426  ( MagickCore::DrawingWand * context_ ) const
1427{
1428  PixelInfo color = static_cast<PixelInfo>(_color);
1429  PixelWand *pixel_wand=NewPixelWand();
1430  PixelSetPixelColor(pixel_wand,&color);
1431  DrawSetStrokeColor(context_,pixel_wand);
1432  pixel_wand=DestroyPixelWand(pixel_wand);
1433}
1434Magick::DrawableBase* Magick::DrawableStrokeColor::copy() const
1435{
1436  return new DrawableStrokeColor(*this);
1437}
1438
1439Magick::DrawableStrokeOpacity::~DrawableStrokeOpacity(void)
1440{
1441}
1442
1443void Magick::DrawableStrokeOpacity::operator()
1444  (MagickCore::DrawingWand * context_) const
1445{
1446  DrawSetStrokeOpacity(context_,_opacity);
1447}
1448
1449Magick::DrawableBase* Magick::DrawableStrokeOpacity::copy() const
1450{
1451  return new DrawableStrokeOpacity(*this);
1452}
1453
1454// Stroke width
1455Magick::DrawableStrokeWidth::~DrawableStrokeWidth ( void )
1456{
1457}
1458void Magick::DrawableStrokeWidth::operator()
1459  ( MagickCore::DrawingWand * context_ ) const
1460{
1461  DrawSetStrokeWidth( context_, _width );
1462}
1463Magick::DrawableBase* Magick::DrawableStrokeWidth::copy() const
1464{
1465  return new DrawableStrokeWidth(*this);
1466}
1467
1468// Draw text at point
1469Magick::DrawableText::DrawableText ( const double x_, const double y_,
1470                                     const std::string &text_ )
1471  : _x(x_),
1472    _y(y_),
1473    _text(text_),
1474    _encoding()
1475{
1476}
1477Magick::DrawableText::DrawableText ( const double x_, const double y_,
1478                                     const std::string &text_,  const std::string &encoding_)
1479  : _x(x_),
1480    _y(y_),
1481    _text(text_),
1482    _encoding(encoding_)
1483{
1484}
1485Magick::DrawableText::DrawableText( const Magick::DrawableText& original_ )
1486  : DrawableBase (original_),
1487    _x(original_._x),
1488    _y(original_._y),
1489    _text(original_._text),
1490    _encoding(original_._encoding)
1491{
1492}
1493Magick::DrawableText::~DrawableText ( void )
1494{
1495}
1496void Magick::DrawableText::operator()
1497  ( MagickCore::DrawingWand * context_ ) const
1498{
1499  DrawSetTextEncoding( context_, _encoding.c_str() );
1500  DrawAnnotation( context_, _x, _y,
1501                  reinterpret_cast<const unsigned char*>(_text.c_str()) );
1502}
1503Magick::DrawableBase* Magick::DrawableText::copy() const
1504{
1505  return new DrawableText(*this);
1506}
1507
1508/* DrawableTextAlignment */
1509Magick::DrawableTextAlignment::DrawableTextAlignment(
1510  Magick::AlignType alignment_)
1511  : _alignment(alignment_)
1512{
1513}
1514
1515Magick::DrawableTextAlignment::DrawableTextAlignment
1516(const Magick::DrawableTextAlignment &original_)
1517  : DrawableBase(original_),
1518  _alignment(original_._alignment)
1519{
1520}
1521
1522Magick::DrawableTextAlignment::~DrawableTextAlignment(void)
1523{
1524}
1525
1526void Magick::DrawableTextAlignment::operator()(
1527  MagickCore::DrawingWand * context_) const
1528{
1529  DrawSetTextAlignment(context_, _alignment);
1530}
1531
1532void Magick::DrawableTextAlignment::alignment(AlignType alignment_)
1533{
1534  _alignment=alignment_;
1535}
1536
1537Magick::AlignType Magick::DrawableTextAlignment::alignment(void) const
1538{
1539  return(_alignment);
1540}
1541
1542Magick::DrawableBase* Magick::DrawableTextAlignment::copy() const
1543{
1544  return new DrawableTextAlignment(*this);
1545}
1546
1547// Text antialias
1548Magick::DrawableTextAntialias::DrawableTextAntialias ( bool flag_ )
1549  : _flag(flag_)
1550{
1551}
1552Magick::DrawableTextAntialias::DrawableTextAntialias( const Magick::DrawableTextAntialias &original_ )
1553  : DrawableBase (original_),
1554    _flag(original_._flag)
1555{
1556}
1557Magick::DrawableTextAntialias::~DrawableTextAntialias ( void )
1558{
1559}
1560void Magick::DrawableTextAntialias::operator()
1561  ( MagickCore::DrawingWand * context_ ) const
1562{
1563  DrawSetTextAntialias( context_, static_cast<MagickBooleanType>
1564    (_flag ? MagickTrue : MagickFalse) );
1565}
1566Magick::DrawableBase* Magick::DrawableTextAntialias::copy() const
1567{
1568  return new DrawableTextAntialias(*this);
1569}
1570
1571
1572// Decoration (text decoration)
1573Magick::DrawableTextDecoration::DrawableTextDecoration
1574  ( Magick::DecorationType decoration_ )
1575    : _decoration(decoration_)
1576{
1577}
1578Magick::DrawableTextDecoration::DrawableTextDecoration
1579  ( const Magick::DrawableTextDecoration &original_ )
1580    : DrawableBase (original_),
1581      _decoration(original_._decoration)
1582{
1583}
1584Magick::DrawableTextDecoration::~DrawableTextDecoration( void )
1585{
1586}
1587void Magick::DrawableTextDecoration::operator()
1588  ( MagickCore::DrawingWand * context_ ) const
1589{
1590  DrawSetTextDecoration( context_, _decoration );
1591}
1592Magick::DrawableBase* Magick::DrawableTextDecoration::copy() const
1593{
1594  return new DrawableTextDecoration(*this);
1595}
1596
1597// DrawableTextDirection
1598Magick::DrawableTextDirection::DrawableTextDirection(
1599  DirectionType direction_)
1600  : _direction(direction_)
1601{
1602}
1603
1604Magick::DrawableTextDirection::~DrawableTextDirection(void)
1605{
1606}
1607
1608void Magick::DrawableTextDirection::operator()(
1609  MagickCore::DrawingWand *context_) const
1610{
1611  DrawSetTextDirection(context_,_direction);
1612}
1613
1614void Magick::DrawableTextDirection::direction(DirectionType direction_)
1615{
1616  _direction=direction_;
1617}
1618
1619Magick::DirectionType Magick::DrawableTextDirection::direction(void) const
1620{
1621  return(_direction);
1622}
1623
1624Magick::DrawableBase *Magick::DrawableTextDirection::copy() const
1625{
1626  return new DrawableTextDirection(*this);
1627}
1628
1629// DrawableTextInterlineSpacing
1630Magick::DrawableTextInterlineSpacing::DrawableTextInterlineSpacing(
1631  double spacing_)
1632  : _spacing(spacing_)
1633{
1634}
1635
1636Magick::DrawableTextInterlineSpacing::~DrawableTextInterlineSpacing(void)
1637{
1638}
1639
1640void Magick::DrawableTextInterlineSpacing::operator()(
1641  MagickCore::DrawingWand *context_) const
1642{
1643  DrawSetTextInterlineSpacing(context_,_spacing);
1644}
1645
1646void Magick::DrawableTextInterlineSpacing::spacing(double spacing_)
1647{
1648  _spacing=spacing_;
1649}
1650
1651double Magick::DrawableTextInterlineSpacing::spacing(void) const
1652{
1653  return(_spacing);
1654}
1655
1656Magick::DrawableBase *Magick::DrawableTextInterlineSpacing::copy() const
1657{
1658  return new DrawableTextInterlineSpacing(*this);
1659}
1660
1661// DrawableTextInterwordSpacing
1662Magick::DrawableTextInterwordSpacing::DrawableTextInterwordSpacing(
1663  double spacing_)
1664  : _spacing(spacing_)
1665{
1666}
1667
1668Magick::DrawableTextInterwordSpacing::~DrawableTextInterwordSpacing(void)
1669{
1670}
1671
1672void Magick::DrawableTextInterwordSpacing::operator()(
1673  MagickCore::DrawingWand *context_) const
1674{
1675  DrawSetTextInterwordSpacing(context_,_spacing);
1676}
1677
1678void Magick::DrawableTextInterwordSpacing::spacing(double spacing_)
1679{
1680  _spacing=spacing_;
1681}
1682
1683double Magick::DrawableTextInterwordSpacing::spacing(void) const
1684{
1685  return(_spacing);
1686}
1687
1688Magick::DrawableBase *Magick::DrawableTextInterwordSpacing::copy() const
1689{
1690  return new DrawableTextInterwordSpacing(*this);
1691}
1692
1693// DrawableTextKerning
1694Magick::DrawableTextKerning::DrawableTextKerning(
1695  double kerning_)
1696  : _kerning(kerning_)
1697{
1698}
1699
1700Magick::DrawableTextKerning::~DrawableTextKerning(void)
1701{
1702}
1703
1704void Magick::DrawableTextKerning::operator()(
1705  MagickCore::DrawingWand *context_) const
1706{
1707  DrawSetTextKerning(context_,_kerning);
1708}
1709
1710void Magick::DrawableTextKerning::kerning(double kerning_)
1711{
1712  _kerning=kerning_;
1713}
1714
1715double Magick::DrawableTextKerning::kerning(void) const
1716{
1717  return(_kerning);
1718}
1719
1720Magick::DrawableBase *Magick::DrawableTextKerning::copy() const
1721{
1722  return new DrawableTextKerning(*this);
1723}
1724
1725// Set text undercolor
1726Magick::DrawableTextUnderColor::DrawableTextUnderColor
1727( const Magick::Color &color_ )
1728  : _color(color_)
1729{
1730}
1731Magick::DrawableTextUnderColor::DrawableTextUnderColor
1732( const Magick::DrawableTextUnderColor& original_ )
1733  : DrawableBase (original_),
1734    _color(original_._color)
1735{
1736}
1737Magick::DrawableTextUnderColor::~DrawableTextUnderColor ( void )
1738{
1739}
1740void Magick::DrawableTextUnderColor::operator()
1741  ( MagickCore::DrawingWand * context_ ) const
1742{
1743  PixelInfo color = static_cast<PixelInfo>(_color);
1744  PixelWand *pixel_wand=NewPixelWand();
1745  PixelSetPixelColor(pixel_wand,&color);
1746  DrawSetTextUnderColor(context_,pixel_wand);
1747  pixel_wand=DestroyPixelWand(pixel_wand);
1748}
1749Magick::DrawableBase* Magick::DrawableTextUnderColor::copy() const
1750{
1751  return new DrawableTextUnderColor(*this);
1752}
1753
1754// Apply Translation
1755Magick::DrawableTranslation::~DrawableTranslation ( void )
1756{
1757}
1758void Magick::DrawableTranslation::operator()
1759  ( MagickCore::DrawingWand * context_ ) const
1760{
1761  DrawTranslate( context_, _x, _y );
1762}
1763Magick::DrawableBase* Magick::DrawableTranslation::copy() const
1764{
1765  return new DrawableTranslation(*this);
1766}
1767
1768// Set the size of the viewbox
1769Magick::DrawableViewbox::~DrawableViewbox ( void )
1770{
1771}
1772void Magick::DrawableViewbox::operator()
1773  ( MagickCore::DrawingWand * context_ ) const
1774{
1775  DrawSetViewbox( context_, _x1, _y1, _x2, _y2 );
1776}
1777Magick::DrawableBase* Magick::DrawableViewbox::copy() const
1778{
1779  return new DrawableViewbox(*this);
1780}
1781
1782//
1783// Path Classes
1784//
1785
1786//
1787// PathArcArgs
1788//
1789MagickPPExport int Magick::operator == ( const Magick::PathArcArgs& /*left_*/,
1790                                        const Magick::PathArcArgs& /*right_*/ )
1791{
1792  return ( 1 );
1793}
1794MagickPPExport int Magick::operator != ( const Magick::PathArcArgs& /*left_*/,
1795                                        const Magick::PathArcArgs& /*right_*/ )
1796{
1797  return ( 0 );
1798}
1799MagickPPExport int Magick::operator > ( const Magick::PathArcArgs& /*left_*/,
1800                                       const Magick::PathArcArgs& /*right_*/ )
1801{
1802  return ( 0 );
1803}
1804MagickPPExport int Magick::operator <  ( const Magick::PathArcArgs& /*left_*/,
1805                                        const Magick::PathArcArgs& /*right_*/ )
1806{
1807  return  ( false );
1808}
1809MagickPPExport int Magick::operator >= ( const Magick::PathArcArgs& left_,
1810                                        const Magick::PathArcArgs& right_ )
1811{
1812  return ( ( left_ > right_ ) || ( left_ == right_ ) );
1813}
1814MagickPPExport int Magick::operator <= ( const Magick::PathArcArgs& left_,
1815                                        const Magick::PathArcArgs& right_ )
1816{
1817  return ( ( left_ < right_ ) || ( left_ == right_ ) );
1818}
1819// Default constructor
1820Magick::PathArcArgs::PathArcArgs( void )
1821  :  _radiusX(0),
1822     _radiusY(0),
1823     _xAxisRotation(0),
1824     _largeArcFlag(false),
1825     _sweepFlag(false),
1826     _x(0),
1827     _y(0)
1828{
1829}
1830// Normal constructor
1831Magick::PathArcArgs::PathArcArgs( double radiusX_, double radiusY_,
1832                                  double xAxisRotation_, bool largeArcFlag_,
1833                                  bool sweepFlag_, double x_, double y_ )
1834  : _radiusX(radiusX_),
1835    _radiusY(radiusY_),
1836    _xAxisRotation(xAxisRotation_),
1837    _largeArcFlag(largeArcFlag_),
1838    _sweepFlag(sweepFlag_),
1839    _x(x_),
1840    _y(y_)
1841{
1842}
1843// Copy constructor
1844Magick::PathArcArgs::PathArcArgs( const Magick::PathArcArgs &original_ )
1845  :  _radiusX(original_._radiusX),
1846     _radiusY(original_._radiusY),
1847     _xAxisRotation(original_._xAxisRotation),
1848     _largeArcFlag(original_._largeArcFlag),
1849     _sweepFlag(original_._sweepFlag),
1850     _x(original_._x),
1851     _y(original_._y)
1852{
1853}
1854// Destructor
1855Magick::PathArcArgs::~PathArcArgs ( void )
1856{
1857}
1858
1859// Path Arc
1860Magick::PathArcAbs::PathArcAbs ( const Magick::PathArcArgs &coordinates_ )
1861  : _coordinates(1,coordinates_)
1862{
1863}
1864Magick::PathArcAbs::PathArcAbs ( const PathArcArgsList &coordinates_ )
1865  : _coordinates(coordinates_)
1866{
1867}
1868Magick::PathArcAbs::PathArcAbs ( const Magick::PathArcAbs& original_ )
1869  : VPathBase (original_),
1870    _coordinates(original_._coordinates)
1871{
1872}
1873Magick::PathArcAbs::~PathArcAbs ( void )
1874{
1875}
1876void Magick::PathArcAbs::operator()( MagickCore::DrawingWand * context_ ) const
1877{
1878  for( PathArcArgsList::const_iterator p = _coordinates.begin();
1879       p != _coordinates.end(); p++ )
1880    {
1881      DrawPathEllipticArcAbsolute( context_, p->radiusX(), p->radiusY(),
1882                                   p->xAxisRotation(), (MagickBooleanType) p->largeArcFlag(),
1883                                   (MagickBooleanType) p->sweepFlag(), p->x(), p->y() );
1884    }
1885}
1886Magick::VPathBase* Magick::PathArcAbs::copy() const
1887{
1888  return new PathArcAbs(*this);
1889}
1890
1891Magick::PathArcRel::PathArcRel ( const Magick::PathArcArgs &coordinates_ )
1892  : _coordinates(1,coordinates_)
1893{
1894}
1895Magick::PathArcRel::PathArcRel ( const PathArcArgsList &coordinates_ )
1896  : _coordinates(coordinates_)
1897{
1898}
1899Magick::PathArcRel::PathArcRel ( const Magick::PathArcRel& original_ )
1900  : VPathBase (original_),
1901    _coordinates(original_._coordinates)
1902{
1903}
1904Magick::PathArcRel::~PathArcRel ( void )
1905{
1906}
1907void Magick::PathArcRel::operator()( MagickCore::DrawingWand * context_ ) const
1908{
1909  for( PathArcArgsList::const_iterator p = _coordinates.begin();
1910       p != _coordinates.end(); p++ )
1911    {
1912      DrawPathEllipticArcRelative( context_, p->radiusX(), p->radiusY(),
1913                                   p->xAxisRotation(), (MagickBooleanType) p->largeArcFlag(),
1914                                   (MagickBooleanType) p->sweepFlag(), p->x(), p->y() );
1915    }
1916}
1917Magick::VPathBase* Magick::PathArcRel::copy() const
1918{
1919  return new PathArcRel(*this);
1920}
1921
1922//
1923// Path Closepath
1924//
1925Magick::PathClosePath::~PathClosePath ( void )
1926{
1927}
1928void Magick::PathClosePath::operator()( MagickCore::DrawingWand * context_ ) const
1929{
1930  DrawPathClose( context_ );
1931}
1932Magick::VPathBase* Magick::PathClosePath::copy() const
1933{
1934  return new PathClosePath(*this);
1935}
1936
1937//
1938// Path Curveto (Cubic Bezier)
1939//
1940MagickPPExport int Magick::operator == ( const Magick::PathCurvetoArgs& /*left_*/,
1941                                        const Magick::PathCurvetoArgs& /*right_*/ )
1942{
1943  return ( 1 );
1944}
1945MagickPPExport int Magick::operator != ( const Magick::PathCurvetoArgs& /*left_*/,
1946                                        const Magick::PathCurvetoArgs& /*right_*/ )
1947{
1948  return ( 0 );
1949}
1950MagickPPExport int Magick::operator > ( const Magick::PathCurvetoArgs& /*left_*/,
1951                                       const Magick::PathCurvetoArgs& /*right_*/ )
1952{
1953  return ( 0 );
1954}
1955MagickPPExport int Magick::operator <  ( const Magick::PathCurvetoArgs& /*left_*/,
1956                                        const Magick::PathCurvetoArgs& /*right_*/ )
1957{
1958  return  ( false );
1959}
1960MagickPPExport int Magick::operator >= ( const Magick::PathCurvetoArgs& left_,
1961                                        const Magick::PathCurvetoArgs& right_ )
1962{
1963  return ( ( left_ > right_ ) || ( left_ == right_ ) );
1964}
1965MagickPPExport int Magick::operator <= ( const Magick::PathCurvetoArgs& left_,
1966                                        const Magick::PathCurvetoArgs& right_ )
1967{
1968  return ( ( left_ < right_ ) || ( left_ == right_ ) );
1969}
1970// Default constructor
1971Magick::PathCurvetoArgs::PathCurvetoArgs( void )
1972  : _x1(0),
1973    _y1(0),
1974    _x2(0),
1975    _y2(0),
1976    _x(0),
1977    _y(0)
1978{
1979}
1980// Normal constructor
1981Magick::PathCurvetoArgs::PathCurvetoArgs( double x1_, double y1_,
1982                                          double x2_, double y2_,
1983                                          double x_, double y_ )
1984  : _x1(x1_),
1985    _y1(y1_),
1986    _x2(x2_),
1987    _y2(y2_),
1988    _x(x_),
1989    _y(y_)
1990{
1991}
1992// Copy constructor
1993Magick::PathCurvetoArgs::PathCurvetoArgs( const PathCurvetoArgs &original_ )
1994  : _x1(original_._x1),
1995    _y1(original_._y1),
1996    _x2(original_._x2),
1997    _y2(original_._y2),
1998    _x(original_._x),
1999    _y(original_._y)
2000{
2001}
2002// Destructor
2003Magick::PathCurvetoArgs::~PathCurvetoArgs ( void )
2004{
2005}
2006
2007Magick::PathCurvetoAbs::PathCurvetoAbs ( const Magick::PathCurvetoArgs &args_ )
2008  : _args(1,args_)
2009{
2010}
2011Magick::PathCurvetoAbs::PathCurvetoAbs ( const PathCurveToArgsList &args_ )
2012  : _args(args_)
2013{
2014}
2015Magick::PathCurvetoAbs::PathCurvetoAbs
2016 ( const Magick::PathCurvetoAbs& original_ )
2017   : VPathBase (original_),
2018     _args(original_._args)
2019{
2020}
2021Magick::PathCurvetoAbs::~PathCurvetoAbs ( void )
2022{
2023}
2024void Magick::PathCurvetoAbs::operator()
2025  ( MagickCore::DrawingWand * context_ ) const
2026{
2027  for( PathCurveToArgsList::const_iterator p = _args.begin();
2028       p != _args.end(); p++ )
2029    {
2030      DrawPathCurveToAbsolute( context_, p->x1(), p->y1(), p->x2(), p->y2(),
2031                               p->x(), p->y() );
2032    }
2033}
2034Magick::VPathBase* Magick::PathCurvetoAbs::copy() const
2035{
2036  return new PathCurvetoAbs(*this);
2037}
2038Magick::PathCurvetoRel::PathCurvetoRel ( const Magick::PathCurvetoArgs &args_ )
2039  : _args(1,args_)
2040{
2041}
2042Magick::PathCurvetoRel::PathCurvetoRel ( const PathCurveToArgsList &args_ )
2043  : _args(args_)
2044{
2045}
2046Magick::PathCurvetoRel::PathCurvetoRel
2047( const Magick::PathCurvetoRel& original_ )
2048  : VPathBase (original_),
2049    _args(original_._args)
2050{
2051}
2052Magick::PathCurvetoRel::~PathCurvetoRel ( void )
2053{
2054}
2055void Magick::PathCurvetoRel::operator()
2056  ( MagickCore::DrawingWand * context_ ) const
2057{
2058  for( PathCurveToArgsList::const_iterator p = _args.begin();
2059       p != _args.end(); p++ )
2060    {
2061      DrawPathCurveToRelative( context_, p->x1(), p->y1(), p->x2(), p->y2(),
2062                               p->x(), p->y() );
2063    }
2064}
2065Magick::VPathBase* Magick::PathCurvetoRel::copy() const
2066{
2067  return new PathCurvetoRel(*this);
2068}
2069Magick::PathSmoothCurvetoAbs::PathSmoothCurvetoAbs
2070( const Magick::Coordinate &coordinates_ )
2071  : _coordinates(1,coordinates_)
2072{
2073}
2074Magick::PathSmoothCurvetoAbs::PathSmoothCurvetoAbs
2075( const CoordinateList &coordinates_ )
2076  : _coordinates(coordinates_)
2077{
2078}
2079Magick::PathSmoothCurvetoAbs::PathSmoothCurvetoAbs
2080( const Magick::PathSmoothCurvetoAbs& original_ )
2081  : VPathBase (original_),
2082    _coordinates(original_._coordinates)
2083{
2084}
2085Magick::PathSmoothCurvetoAbs::~PathSmoothCurvetoAbs ( void )
2086{
2087}
2088void Magick::PathSmoothCurvetoAbs::operator()
2089  ( MagickCore::DrawingWand * context_ ) const
2090{
2091  for( CoordinateList::const_iterator p = _coordinates.begin();
2092       p != _coordinates.end(); p++ )
2093    {
2094      double x2 = p->x();
2095      double y2 = p->y();
2096      p++;
2097      if(p != _coordinates.end() )
2098        DrawPathCurveToSmoothAbsolute( context_, x2, y2, p->x(), p->y() );
2099    }
2100}
2101Magick::VPathBase* Magick::PathSmoothCurvetoAbs::copy() const
2102{
2103  return new PathSmoothCurvetoAbs(*this);
2104}
2105Magick::PathSmoothCurvetoRel::PathSmoothCurvetoRel
2106( const Magick::Coordinate &coordinates_ )
2107  : _coordinates(1,coordinates_)
2108{
2109}
2110Magick::PathSmoothCurvetoRel::PathSmoothCurvetoRel
2111( const CoordinateList &coordinates_ )
2112  : _coordinates(coordinates_)
2113{
2114}
2115Magick::PathSmoothCurvetoRel::PathSmoothCurvetoRel
2116( const Magick::PathSmoothCurvetoRel& original_ )
2117  : VPathBase (original_),
2118    _coordinates(original_._coordinates)
2119{
2120}
2121Magick::PathSmoothCurvetoRel::~PathSmoothCurvetoRel ( void )
2122{
2123}
2124void Magick::PathSmoothCurvetoRel::operator()
2125  ( MagickCore::DrawingWand * context_ ) const
2126{
2127  for( CoordinateList::const_iterator p = _coordinates.begin();
2128       p != _coordinates.end(); p++ )
2129    {
2130      double x2 = p->x();
2131      double y2 = p->y();
2132      p++;
2133      if(p != _coordinates.end() )
2134        DrawPathCurveToSmoothRelative( context_, x2, y2, p->x(), p->y() );
2135    }
2136}
2137Magick::VPathBase* Magick::PathSmoothCurvetoRel::copy() const
2138{
2139  return new PathSmoothCurvetoRel(*this);
2140}
2141
2142//
2143// Quadratic Curveto (Quadratic Bezier)
2144//
2145MagickPPExport int Magick::operator ==
2146( const Magick::PathQuadraticCurvetoArgs& /*left_*/,
2147  const Magick::PathQuadraticCurvetoArgs& /*right_*/ )
2148{
2149  return ( 1 );
2150}
2151MagickPPExport int Magick::operator !=
2152( const Magick::PathQuadraticCurvetoArgs& /*left_*/,
2153  const Magick::PathQuadraticCurvetoArgs& /*right_*/ )
2154{
2155  return ( 0 );
2156}
2157MagickPPExport int Magick::operator >
2158( const Magick::PathQuadraticCurvetoArgs& /*left_*/,
2159  const Magick::PathQuadraticCurvetoArgs& /*right_*/ )
2160{
2161  return ( 0 );
2162}
2163MagickPPExport int Magick::operator <
2164( const Magick::PathQuadraticCurvetoArgs& /*left_*/,
2165  const Magick::PathQuadraticCurvetoArgs& /*right_*/ )
2166{
2167  return  ( 0 );
2168}
2169MagickPPExport int Magick::operator >=
2170( const Magick::PathQuadraticCurvetoArgs& left_,
2171  const Magick::PathQuadraticCurvetoArgs& right_ )
2172{
2173  return ( ( left_ > right_ ) || ( left_ == right_ ) );
2174}
2175MagickPPExport int Magick::operator <=
2176( const Magick::PathQuadraticCurvetoArgs& left_,
2177  const Magick::PathQuadraticCurvetoArgs& right_ )
2178{
2179  return ( ( left_ < right_ ) || ( left_ == right_ ) );
2180}
2181// Default Constructor
2182Magick::PathQuadraticCurvetoArgs::PathQuadraticCurvetoArgs( void )
2183  : _x1(0),
2184    _y1(0),
2185    _x(0),
2186    _y(0)
2187{
2188}
2189// Normal Constructor
2190Magick::PathQuadraticCurvetoArgs::PathQuadraticCurvetoArgs( double x1_,
2191                                                            double y1_,
2192                                                            double x_,
2193                                                            double y_ )
2194  : _x1(x1_),
2195    _y1(y1_),
2196    _x(x_),
2197    _y(y_)
2198{
2199}
2200// Copy Constructor
2201Magick::PathQuadraticCurvetoArgs::PathQuadraticCurvetoArgs( const PathQuadraticCurvetoArgs &original_ )
2202  : _x1(original_._x1),
2203    _y1(original_._y1),
2204    _x(original_._x),
2205    _y(original_._y)
2206{
2207}
2208// Destructor
2209Magick::PathQuadraticCurvetoArgs::~PathQuadraticCurvetoArgs ( void )
2210{
2211}
2212
2213Magick::PathQuadraticCurvetoAbs::PathQuadraticCurvetoAbs
2214( const Magick::PathQuadraticCurvetoArgs &args_ )
2215  : _args(1,args_)
2216{
2217}
2218Magick::PathQuadraticCurvetoAbs::PathQuadraticCurvetoAbs
2219( const PathQuadraticCurvetoArgsList &args_ )
2220  : _args(args_)
2221{
2222}
2223Magick::PathQuadraticCurvetoAbs::PathQuadraticCurvetoAbs
2224( const Magick::PathQuadraticCurvetoAbs& original_ )
2225  : VPathBase (original_),
2226    _args(original_._args)
2227{
2228}
2229Magick::PathQuadraticCurvetoAbs::~PathQuadraticCurvetoAbs ( void )
2230{
2231}
2232void Magick::PathQuadraticCurvetoAbs::operator()
2233  ( MagickCore::DrawingWand * context_ ) const
2234{
2235  for( PathQuadraticCurvetoArgsList::const_iterator p = _args.begin();
2236       p != _args.end(); p++ )
2237    {
2238      DrawPathCurveToQuadraticBezierAbsolute( context_, p->x1(), p->y1(),
2239                                              p->x(), p->y() );
2240    }
2241}
2242Magick::VPathBase* Magick::PathQuadraticCurvetoAbs::copy() const
2243{
2244  return new PathQuadraticCurvetoAbs(*this);
2245}
2246Magick::PathQuadraticCurvetoRel::PathQuadraticCurvetoRel
2247( const Magick::PathQuadraticCurvetoArgs &args_ )
2248  : _args(1,args_)
2249{
2250}
2251Magick::PathQuadraticCurvetoRel::PathQuadraticCurvetoRel
2252( const PathQuadraticCurvetoArgsList &args_ )
2253  : _args(args_)
2254{
2255}
2256Magick::PathQuadraticCurvetoRel::PathQuadraticCurvetoRel
2257( const Magick::PathQuadraticCurvetoRel& original_ )
2258  : VPathBase (original_),
2259    _args(original_._args)
2260{
2261}
2262Magick::PathQuadraticCurvetoRel::~PathQuadraticCurvetoRel ( void )
2263{
2264}
2265void Magick::PathQuadraticCurvetoRel::operator()
2266  ( MagickCore::DrawingWand * context_ ) const
2267{
2268  for( PathQuadraticCurvetoArgsList::const_iterator p = _args.begin();
2269       p != _args.end(); p++ )
2270    {
2271      DrawPathCurveToQuadraticBezierRelative( context_, p->x1(), p->y1(),
2272                                              p->x(), p->y() );
2273    }
2274}
2275Magick::VPathBase* Magick::PathQuadraticCurvetoRel::copy() const
2276{
2277  return new PathQuadraticCurvetoRel(*this);
2278}
2279Magick::PathSmoothQuadraticCurvetoAbs::PathSmoothQuadraticCurvetoAbs
2280( const Magick::Coordinate &coordinate_ )
2281  : _coordinates(1,coordinate_)
2282{
2283}
2284Magick::PathSmoothQuadraticCurvetoAbs::PathSmoothQuadraticCurvetoAbs
2285( const CoordinateList &coordinates_ )
2286  : _coordinates(coordinates_)
2287{
2288}
2289Magick::PathSmoothQuadraticCurvetoAbs::PathSmoothQuadraticCurvetoAbs
2290( const Magick::PathSmoothQuadraticCurvetoAbs& original_ )
2291  : VPathBase (original_),
2292    _coordinates(original_._coordinates)
2293{
2294}
2295Magick::PathSmoothQuadraticCurvetoAbs::~PathSmoothQuadraticCurvetoAbs ( void )
2296{
2297}
2298void Magick::PathSmoothQuadraticCurvetoAbs::operator()
2299  ( MagickCore::DrawingWand * context_ ) const
2300{
2301  for( CoordinateList::const_iterator p = _coordinates.begin();
2302       p != _coordinates.end(); p++ )
2303    {
2304      DrawPathCurveToQuadraticBezierSmoothAbsolute( context_, p->x(), p->y() );
2305    }
2306}
2307Magick::VPathBase* Magick::PathSmoothQuadraticCurvetoAbs::copy() const
2308{
2309  return new PathSmoothQuadraticCurvetoAbs(*this);
2310}
2311Magick::PathSmoothQuadraticCurvetoRel::PathSmoothQuadraticCurvetoRel
2312( const Magick::Coordinate &coordinate_ )
2313  : _coordinates(1,coordinate_)
2314{
2315}
2316Magick::PathSmoothQuadraticCurvetoRel::PathSmoothQuadraticCurvetoRel
2317( const CoordinateList &coordinates_ )
2318  : _coordinates(coordinates_)
2319{
2320}
2321Magick::PathSmoothQuadraticCurvetoRel::PathSmoothQuadraticCurvetoRel
2322( const PathSmoothQuadraticCurvetoRel& original_ )
2323  : VPathBase (original_),
2324    _coordinates(original_._coordinates)
2325{
2326}
2327Magick::PathSmoothQuadraticCurvetoRel::~PathSmoothQuadraticCurvetoRel ( void )
2328{
2329}
2330void Magick::PathSmoothQuadraticCurvetoRel::operator()
2331  ( MagickCore::DrawingWand * context_ ) const
2332{
2333  for( CoordinateList::const_iterator p = _coordinates.begin();
2334       p != _coordinates.end(); p++ )
2335    {
2336      DrawPathCurveToQuadraticBezierSmoothRelative( context_, p->x(), p->y() );
2337    }
2338}
2339Magick::VPathBase* Magick::PathSmoothQuadraticCurvetoRel::copy() const
2340{
2341  return new PathSmoothQuadraticCurvetoRel(*this);
2342}
2343
2344//
2345// Path Lineto
2346//
2347Magick::PathLinetoAbs::PathLinetoAbs ( const Magick::Coordinate& coordinate_  )
2348  : _coordinates(1,coordinate_)
2349{
2350}
2351Magick::PathLinetoAbs::PathLinetoAbs ( const CoordinateList &coordinates_ )
2352  : _coordinates(coordinates_)
2353{
2354}
2355Magick::PathLinetoAbs::PathLinetoAbs ( const Magick::PathLinetoAbs& original_ )
2356  : VPathBase (original_),
2357    _coordinates(original_._coordinates)
2358{
2359}
2360Magick::PathLinetoAbs::~PathLinetoAbs ( void )
2361{
2362}
2363void Magick::PathLinetoAbs::operator()( MagickCore::DrawingWand * context_ ) const
2364{
2365  for( CoordinateList::const_iterator p = _coordinates.begin();
2366       p != _coordinates.end(); p++ )
2367    {
2368      DrawPathLineToAbsolute( context_, p->x(), p->y() );
2369    }
2370}
2371Magick::VPathBase* Magick::PathLinetoAbs::copy() const
2372{
2373  return new PathLinetoAbs(*this);
2374}
2375Magick::PathLinetoRel::PathLinetoRel ( const Magick::Coordinate& coordinate_  )
2376  : _coordinates(1,coordinate_)
2377{
2378}
2379Magick::PathLinetoRel::PathLinetoRel ( const CoordinateList &coordinates_ )
2380  : _coordinates(coordinates_)
2381{
2382}
2383Magick::PathLinetoRel::PathLinetoRel ( const Magick::PathLinetoRel& original_ )
2384  : VPathBase (original_),
2385    _coordinates(original_._coordinates)
2386{
2387}
2388Magick::PathLinetoRel::~PathLinetoRel ( void )
2389{
2390}
2391void Magick::PathLinetoRel::operator()( MagickCore::DrawingWand * context_ ) const
2392{
2393  for( CoordinateList::const_iterator p = _coordinates.begin();
2394       p != _coordinates.end(); p++ )
2395    {
2396      DrawPathLineToRelative( context_, p->x(), p->y() );
2397    }
2398}
2399Magick::VPathBase* Magick::PathLinetoRel::copy() const
2400{
2401  return new PathLinetoRel(*this);
2402}
2403
2404//
2405// Path Horizontal Lineto
2406//
2407
2408Magick::PathLinetoHorizontalAbs::~PathLinetoHorizontalAbs ( void )
2409{
2410}
2411void Magick::PathLinetoHorizontalAbs::operator()
2412  ( MagickCore::DrawingWand * context_ ) const
2413{
2414  DrawPathLineToHorizontalAbsolute( context_, _x );
2415}
2416Magick::VPathBase* Magick::PathLinetoHorizontalAbs::copy() const
2417{
2418  return new PathLinetoHorizontalAbs(*this);
2419}
2420Magick::PathLinetoHorizontalRel::~PathLinetoHorizontalRel ( void )
2421{
2422}
2423void Magick::PathLinetoHorizontalRel::operator()
2424  ( MagickCore::DrawingWand * context_ ) const
2425{
2426  DrawPathLineToHorizontalRelative( context_, _x );
2427}
2428Magick::VPathBase* Magick::PathLinetoHorizontalRel::copy() const
2429{
2430  return new PathLinetoHorizontalRel(*this);
2431}
2432
2433//
2434// Path Vertical Lineto
2435//
2436Magick::PathLinetoVerticalAbs::~PathLinetoVerticalAbs ( void )
2437{
2438}
2439void Magick::PathLinetoVerticalAbs::operator()
2440  ( MagickCore::DrawingWand * context_ ) const
2441{
2442  DrawPathLineToVerticalAbsolute( context_, _y );
2443}
2444Magick::VPathBase* Magick::PathLinetoVerticalAbs::copy() const
2445{
2446  return new PathLinetoVerticalAbs(*this);
2447}
2448Magick::PathLinetoVerticalRel::~PathLinetoVerticalRel ( void )
2449{
2450}
2451void Magick::PathLinetoVerticalRel::operator()
2452  ( MagickCore::DrawingWand * context_ ) const
2453{
2454  DrawPathLineToVerticalRelative( context_, _y );
2455}
2456Magick::VPathBase* Magick::PathLinetoVerticalRel::copy() const
2457{
2458  return new PathLinetoVerticalRel(*this);
2459}
2460
2461//
2462// Path Moveto
2463//
2464
2465Magick::PathMovetoAbs::PathMovetoAbs ( const Magick::Coordinate &coordinate_ )
2466  : _coordinates(1,coordinate_)
2467{
2468}
2469Magick::PathMovetoAbs::PathMovetoAbs ( const CoordinateList &coordinates_ )
2470  : _coordinates(coordinates_)
2471{
2472}
2473Magick::PathMovetoAbs::PathMovetoAbs ( const Magick::PathMovetoAbs& original_ )
2474  : VPathBase (original_),
2475    _coordinates(original_._coordinates)
2476{
2477}
2478Magick::PathMovetoAbs::~PathMovetoAbs ( void )
2479{
2480}
2481void Magick::PathMovetoAbs::operator()( MagickCore::DrawingWand * context_ ) const
2482{
2483  for( CoordinateList::const_iterator p = _coordinates.begin();
2484       p != _coordinates.end(); p++ )
2485    {
2486      DrawPathMoveToAbsolute( context_, p->x(), p->y() );
2487    }
2488}
2489Magick::VPathBase* Magick::PathMovetoAbs::copy() const
2490{
2491  return new PathMovetoAbs(*this);
2492}
2493Magick::PathMovetoRel::PathMovetoRel ( const Magick::Coordinate &coordinate_ )
2494  : _coordinates(1,coordinate_)
2495{
2496}
2497Magick::PathMovetoRel::PathMovetoRel ( const CoordinateList &coordinates_ )
2498  : _coordinates(coordinates_)
2499{
2500}
2501Magick::PathMovetoRel::PathMovetoRel ( const Magick::PathMovetoRel& original_ )
2502  : VPathBase (original_),
2503    _coordinates(original_._coordinates)
2504{
2505}
2506Magick::PathMovetoRel::~PathMovetoRel ( void )
2507{
2508}
2509void Magick::PathMovetoRel::operator()( MagickCore::DrawingWand * context_ ) const
2510{
2511  for( CoordinateList::const_iterator p = _coordinates.begin();
2512       p != _coordinates.end(); p++ )
2513    {
2514      DrawPathMoveToRelative( context_, p->x(), p->y() );
2515    }
2516}
2517Magick::VPathBase* Magick::PathMovetoRel::copy() const
2518{
2519  return new PathMovetoRel(*this);
2520}
2521
2522#if defined(EXPLICIT_TEMPLATE_INSTANTIATION)
2523// template class std::vector<Magick::Coordinate>;
2524// template class std::vector<const Magick::Drawable>;
2525// template class std::vector<const Magick::PathArcArgs>;
2526// template class std::vector<const Magick::PathCurvetoArgs>;
2527// template class std::vector<const Magick::PathQuadraticCurvetoArgs>;
2528// template class std::vector<const Magick::VPath>;
2529#endif
2530