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_,

25const Magick::Coordinate& right_)

26 {

27return((left_.x() == right_.x()) && (left_.y() == right_.y()));

28 }

29

30 MagickPPExport int Magick::operator !=(const Magick::Coordinate& left_,

31const Magick::Coordinate& right_)

32 {

33return(!(left_ == right_));

34 }

35

36 MagickPPExport int Magick::operator >(const Magick::Coordinate& left_,

37const Magick::Coordinate& right_)

38 {

39return (!(left_ < right_) && (left_ != right_));

40 }

41

42 MagickPPExport int Magick::operator <(const Magick::Coordinate& left_,

43const Magick::Coordinate& right_)

44 {

45// Based on distance from origin

46return((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_,

51const Magick::Coordinate& right_)

52 {

53return((left_ > right_) || (left_ == right_));

54 }

55

56 MagickPPExport int Magick::operator <=(const Magick::Coordinate& left_,

57const Magick::Coordinate& right_)

58 {

59return((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 {

78return 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 {

94delete 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=(

105const Magick::Drawable& original_)

106 {

107DrawableBase

108 *temp_dp;

109

110if (this != &original_)

111 {

112 temp_dp=(original_.dp != (Magick::DrawableBase *) NULL ?

113 original_.dp->copy() : (Magick::DrawableBase *) NULL);

114delete dp;

115 dp=temp_dp;

116 }

117return(*this);

118 }

119

120 void Magick::Drawable::operator()(MagickCore::DrawingWand * context_) const

121 {

122if (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 {

146delete 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 {

159if (this != &original_)

160 {

161VPathBase* temp_dp = (original_.dp ? original_.dp->copy() : 0);

162delete dp;

163 dp = temp_dp;

164 }

165return *this;

166 }

167

168 // Operator to invoke contained object

169 void Magick::VPath::operator()( MagickCore::DrawingWand * context_ ) const

170 {

171if(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_,

181double rx_, double ry_,

182double 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 {

204return 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 {

218return 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 {

231return 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 {

254size_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

260while( 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 );

269delete [] coordinates;

270 }

271 Magick::DrawableBase* Magick::DrawableBezier::copy() const

272 {

273return 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 {

317return(_color);

318 }

319

320 Magick::DrawableBase* Magick::DrawableBorderColor::copy() const

321 {

322return(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 {

349return(_fillRule);

350 }

351

352 Magick::DrawableBase* Magick::DrawableClipRule::copy() const

353 {

354return(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 {

381return(_units);

382 }

383

384 Magick::DrawableBase* Magick::DrawableClipUnits::copy() const

385 {

386return(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 {

405return 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 {

430return 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 {

454return 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 {

467return 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 {

480return new DrawableColor(*this);

481 }

482

483 // Draw image at point

484 Magick::DrawableCompositeImage::DrawableCompositeImage

485 ( double x_, double y_,

486double width_, double height_,

487const 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_,

499double width_, double height_,

500const 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_,

512double width_, double height_,

513const 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_,

524double width_, double height_,

525const 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_,

536const 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_,

549const 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 {

574delete _image;

575 }

576 // Assignment operator

577 Magick::DrawableCompositeImage& Magick::DrawableCompositeImage::operator=

578 (const Magick::DrawableCompositeImage& original_ )

579 {

580// If not being set to ourself

581if ( this != &original_ )

582 {

583 _composition = original_._composition;

584 _x = original_._x;

585 _y = original_._y;

586 _width = original_._width;

587 _height = original_._height;

588Image* temp_image = new Image(*original_._image);

589delete _image;

590 _image = temp_image;

591 }

592return *this;

593 }

594 void Magick::DrawableCompositeImage::filename( const std::string &filename_ )

595 {

596Image* temp_image = new Image(filename_);

597delete _image;

598 _image = temp_image;

599 }

600 std::string Magick::DrawableCompositeImage::filename( void ) const

601 {

602return _image->fileName();

603 }

604

605 void Magick::DrawableCompositeImage::image( const Magick::Image &image_ )

606 {

607Image* temp_image = new Image(image_);

608delete _image;

609 _image = temp_image;

610 }

611 Magick::Image Magick::DrawableCompositeImage::image( void ) const

612 {

613return *_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 {

623return _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 {

640return 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 {

665return(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 {

680return 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 {

708return 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(

718const 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 {

741return(_url);

742 }

743

744 Magick::DrawableBase* Magick::DrawableFillPatternUrl::copy() const

745 {

746return(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 {

760return 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 {

775return 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_,

789const 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

813if(_font.length())

814 {

815 (void) DrawSetFont( context_, _font.c_str() );

816 }

817

818if(_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 {

835return 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 {

849return 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 {

862return 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

882for( 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 {

890return 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 {

903return 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 {

917return 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 {

937size_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

943while( 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 );

952delete [] coordinates;

953 }

954 Magick::DrawableBase* Magick::DrawablePolygon::copy() const

955 {

956return 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 {

977size_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

983while( 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 );

992delete [] coordinates;

993 }

994 Magick::DrawableBase* Magick::DrawablePolyline::copy() const

995 {

996return 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 {

1010return 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 {

1024return 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 {

1038return new DrawablePopPattern(*this);

1039 }

1040

1041 // Push Pattern definition

1042 Magick::DrawablePushPattern::DrawablePushPattern

1043 ( const std::string &id_, ssize_t x_, ssize_t y_,

1044size_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 {

1072return 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 {

1087return 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 {

1101return 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 {

1116return 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 {

1130return 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 {

1144return 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 {

1157return new DrawableSkewY(*this);

1158 }

1159

1160 /* DrawableStrokeDashArray */

1161 Magick::DrawableStrokeDashArray::DrawableStrokeDashArray(const double* dasharray_)

1162 : _size(0),

1163 _dasharray(0)

1164 {

1165dasharray(dasharray_);

1166 }

1167

1168 Magick::DrawableStrokeDashArray::DrawableStrokeDashArray(

1169const Magick::DrawableStrokeDashArray& original_)

1170 : DrawableBase (original_),

1171 _size(original_._size),

1172 _dasharray(new double[_size+1])

1173 {

1174// Copy elements

1175 {

1176for (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 {

1184delete [] _dasharray;

1185 _size=0;

1186 _dasharray=(double *) NULL;

1187 }

1188

1189 Magick::DrawableStrokeDashArray& Magick::DrawableStrokeDashArray::operator=(

1190const Magick::DrawableStrokeDashArray &original_)

1191 {

1192if (this != &original_)

1193 {

1194delete [] _dasharray;

1195 _size=original_._size;

1196 _dasharray = new double[_size+1];

1197// Copy elements

1198 {

1199for (size_t i=0; i < _size; i++)

1200 _dasharray[i]=original_._dasharray[i];

1201 _dasharray[_size]=0.0;

1202 }

1203 }

1204return(*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 {

1216return(new DrawableStrokeDashArray(*this));

1217 }

1218

1219 void Magick::DrawableStrokeDashArray::dasharray(const double* dasharray_)

1220 {

1221size_t

1222 n;

1223

1224delete [] _dasharray;

1225 _size=0;

1226 _dasharray=0;

1227

1228if (dasharray_ != (const double *) NULL)

1229 {

1230const double

1231 *p;

1232

1233// Count elements in dash array

1234 n=0;

1235 {

1236 p = dasharray_;

1237while(*p++ != 0.0)

1238 n++;

1239 }

1240 _size=n;

1241

1242// Allocate elements

1243 _dasharray=new double[_size+1];

1244// Copy elements

1245 {

1246for (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 {

1255return(_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 {

1271return(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 {

1281return(_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 {

1295return 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 {

1309return 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 {

1323return new DrawableMiterLimit(*this);

1324 }

1325

1326

1327 /* DrawableStrokePatternUrl */

1328 Magick::DrawableStrokePatternUrl::DrawableStrokePatternUrl(

1329const std::string &url_)

1330 : _url(url_)

1331 {

1332 }

1333

1334 Magick::DrawableStrokePatternUrl::DrawableStrokePatternUrl(

1335const 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 {

1358return(_url);

1359 }

1360

1361 Magick::DrawableBase* Magick::DrawableStrokePatternUrl::copy() const

1362 {

1363return(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 {

1378return 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 {

1407return 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 {

1422return 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 {

1436return new DrawableStrokeWidth(*this);

1437 }

1438

1439 // Draw text at point

1440 Magick::DrawableText::DrawableText ( const double x_, const double y_,

1441const 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_,

1449const 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 {

1476return 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 {

1510return(_alignment);

1511 }

1512

1513 Magick::DrawableBase* Magick::DrawableTextAlignment::copy() const

1514 {

1515return 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 {

1539return 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 {

1565return 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 {

1592return(_direction);

1593 }

1594

1595 Magick::DrawableBase *Magick::DrawableTextDirection::copy() const

1596 {

1597return new DrawableTextDirection(*this);

1598 }

1599

1600 // DrawableTextInterlineSpacing

1601 Magick::DrawableTextInterlineSpacing::DrawableTextInterlineSpacing(

1602double 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 {

1624return(_spacing);

1625 }

1626

1627 Magick::DrawableBase *Magick::DrawableTextInterlineSpacing::copy() const

1628 {

1629return new DrawableTextInterlineSpacing(*this);

1630 }

1631

1632 // DrawableTextInterwordSpacing

1633 Magick::DrawableTextInterwordSpacing::DrawableTextInterwordSpacing(

1634double 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 {

1656return(_spacing);

1657 }

1658

1659 Magick::DrawableBase *Magick::DrawableTextInterwordSpacing::copy() const

1660 {

1661return new DrawableTextInterwordSpacing(*this);

1662 }

1663

1664 // DrawableTextKerning

1665 Magick::DrawableTextKerning::DrawableTextKerning(

1666double 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 {

1688return(_kerning);

1689 }

1690

1691 Magick::DrawableBase *Magick::DrawableTextKerning::copy() const

1692 {

1693return 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 {

1722return 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 {

1736return 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 {

1750return new DrawableViewbox(*this);

1751 }

1752

1753 //

1754 // Path Classes

1755 //

1756

1757 //

1758 // PathArcArgs

1759 //

1760 MagickPPExport int Magick::operator ==( const Magick::PathArcArgs& /*left_*/,

1761const Magick::PathArcArgs& /*right_*/ )

1762 {

1763return ( 1 );

1764 }

1765 MagickPPExport int Magick::operator !=( const Magick::PathArcArgs& /*left_*/,

1766const Magick::PathArcArgs& /*right_*/ )

1767 {

1768return ( 0 );

1769 }

1770 MagickPPExport int Magick::operator >( const Magick::PathArcArgs& /*left_*/,

1771const Magick::PathArcArgs& /*right_*/ )

1772 {

1773return ( 0 );

1774 }

1775 MagickPPExport int Magick::operator <( const Magick::PathArcArgs& /*left_*/,

1776const Magick::PathArcArgs& /*right_*/ )

1777 {

1778return ( false );

1779 }

1780 MagickPPExport int Magick::operator >=( const Magick::PathArcArgs& left_,

1781const Magick::PathArcArgs& right_ )

1782 {

1783return ( ( left_ > right_ ) || ( left_ == right_ ) );

1784 }

1785 MagickPPExport int Magick::operator <=( const Magick::PathArcArgs& left_,

1786const Magick::PathArcArgs& right_ )

1787 {

1788return ( ( 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_,

1803double xAxisRotation_, bool largeArcFlag_,

1804bool 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 {

1849for( 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 {

1859return 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 {

1880for( 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 {

1890return 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 {

1905return new PathClosePath(*this);

1906 }

1907

1908 //

1909 // Path Curveto (Cubic Bezier)

1910 //

1911 MagickPPExport int Magick::operator ==( const Magick::PathCurvetoArgs& /*left_*/,

1912const Magick::PathCurvetoArgs& /*right_*/ )

1913 {

1914return ( 1 );

1915 }

1916 MagickPPExport int Magick::operator !=( const Magick::PathCurvetoArgs& /*left_*/,

1917const Magick::PathCurvetoArgs& /*right_*/ )

1918 {

1919return ( 0 );

1920 }

1921 MagickPPExport int Magick::operator >( const Magick::PathCurvetoArgs& /*left_*/,

1922const Magick::PathCurvetoArgs& /*right_*/ )

1923 {

1924return ( 0 );

1925 }

1926 MagickPPExport int Magick::operator <( const Magick::PathCurvetoArgs& /*left_*/,

1927const Magick::PathCurvetoArgs& /*right_*/ )

1928 {

1929return ( false );

1930 }

1931 MagickPPExport int Magick::operator >=( const Magick::PathCurvetoArgs& left_,

1932const Magick::PathCurvetoArgs& right_ )

1933 {

1934return ( ( left_ > right_ ) || ( left_ == right_ ) );

1935 }

1936 MagickPPExport int Magick::operator <=( const Magick::PathCurvetoArgs& left_,

1937const Magick::PathCurvetoArgs& right_ )

1938 {

1939return ( ( 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_,

1953double x2_, double y2_,

1954double 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 {

1998for( 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 {

2007return 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 {

2029for( 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 {

2038return 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 {

2062for( CoordinateList::const_iterator p = _coordinates.begin();

2063 p != _coordinates.end(); p++ )

2064 {

2065double x2 = p->x();

2066double y2 = p->y();

2067 p++;

2068if (p == _coordinates.end() )

2069break;

2070 DrawPathCurveToSmoothAbsolute( context_, x2, y2, p->x(), p->y() );

2071 }

2072 }

2073 Magick::VPathBase* Magick::PathSmoothCurvetoAbs::copy() const

2074 {

2075return 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 {

2099for( CoordinateList::const_iterator p = _coordinates.begin();

2100 p != _coordinates.end(); p++ )

2101 {

2102double x2 = p->x();

2103double y2 = p->y();

2104 p++;

2105if (p == _coordinates.end() )

2106break;

2107 DrawPathCurveToSmoothRelative( context_, x2, y2, p->x(), p->y() );

2108 }

2109 }

2110 Magick::VPathBase* Magick::PathSmoothCurvetoRel::copy() const

2111 {

2112return new PathSmoothCurvetoRel(*this);

2113 }

2114

2115 //

2116 // Quadratic Curveto (Quadratic Bezier)

2117 //

2118 MagickPPExport int Magick::operator ==

2119 ( const Magick::PathQuadraticCurvetoArgs& /*left_*/,

2120const Magick::PathQuadraticCurvetoArgs& /*right_*/ )

2121 {

2122return ( 1 );

2123 }

2124 MagickPPExport int Magick::operator !=

2125 ( const Magick::PathQuadraticCurvetoArgs& /*left_*/,

2126const Magick::PathQuadraticCurvetoArgs& /*right_*/ )

2127 {

2128return ( 0 );

2129 }

2130 MagickPPExport int Magick::operator >

2131 ( const Magick::PathQuadraticCurvetoArgs& /*left_*/,

2132const Magick::PathQuadraticCurvetoArgs& /*right_*/ )

2133 {

2134return ( 0 );

2135 }

2136 MagickPPExport int Magick::operator <

2137 ( const Magick::PathQuadraticCurvetoArgs& /*left_*/,

2138const Magick::PathQuadraticCurvetoArgs& /*right_*/ )

2139 {

2140return ( 0 );

2141 }

2142 MagickPPExport int Magick::operator >=

2143 ( const Magick::PathQuadraticCurvetoArgs& left_,

2144const Magick::PathQuadraticCurvetoArgs& right_ )

2145 {

2146return ( ( left_ > right_ ) || ( left_ == right_ ) );

2147 }

2148 MagickPPExport int Magick::operator <=

2149 ( const Magick::PathQuadraticCurvetoArgs& left_,

2150const Magick::PathQuadraticCurvetoArgs& right_ )

2151 {

2152return ( ( 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_,

2164double y1_,

2165double x_,

2166double 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 {

2208for( 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 {

2217return 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 {

2241for( 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 {

2250return 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 {

2274for( 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 {

2282return 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 {

2306for( 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 {

2314return 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 {

2338for( 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 {

2346return 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 {

2366for( 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 {

2374return 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 {

2391return 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 {

2403return 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 {

2419return 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 {

2431return 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 {

2456for( 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 {

2464return 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 {

2484for( 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 {

2492return 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

• home
• cristy
• ImageMagick-7
• Magick++
• lib
• Drawable.cpp
• Generated by 1.8.14