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