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