Magick++: Drawable.cpp Source File

Magick++ 7.1.0

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