Magick++: Drawable.h Source File - Imagemagick

| Magick++ 7.1.0 |

Drawable.h

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

4 //

5 // Copyright @ 2014 ImageMagick Studio LLC, a non-profit organization

6 // dedicated to making software imaging solutions freely available.

7 //

8 // Definition of Drawable (Graphic objects)

9 //

10 // The technique used for instantiating classes which derive from STL

11 // templates is described in Microsoft MSDN Article ID: Q168958

12 // "HOWTO: Exporting STL Components Inside & Outside of a Class".

13 // "http://support.microsoft.com/kb/168958"

14 //

15 // Note that version 3.0 of this article says that that only STL

16 // container template which supports DLL export is <vector> and we are

17 // not using <vector> as part of the Drawable implementation.

18 //

20 #if !defined(Magick_Drawable_header)

21 #define Magick_Drawable_header

23 #include "Magick++/Include.h"

25 #include <functional>

26 #include <string>

27 #include <vector>

28 #include <utility>

29 #include "Magick++/Color.h"

30 #include "Magick++/Geometry.h"

32 #if defined(MagickDLLExplicitTemplate)

33 # if defined(MAGICK_PLUSPLUS_IMPLEMENTATION)

34 # define MagickDrawableExtern

35 # else

36 # pragma warning( disable: 4231 ) // Disable warning regarding using extern

37 # define MagickDrawableExtern extern

38 # endif // MAGICK_PLUSPLUS_IMPLEMENTATION

39 #else

40 # define MagickDrawableExtern

41 #endif // MagickDLLExplicitTemplate

43 namespace Magick

44 {

45//

46// Representation of an x,y coordinate

47//

48class MagickPPExport Coordinate

49 {

50public:

52 Coordinate(void)

53 : _x(0),

54 _y(0) {}

56 Coordinate(double x_,double y_)

57 : _x(x_),

58 _y(y_) {}

60virtual ~Coordinate() {}

62void x(double x_) { _x=x_; }

63double x(void) const { return _x; }

65void y(double y_) { _y=y_; }

66double y(void) const { return _y; }

68private:

69double _x;

70double _y;

71 };

73typedef std::vector<Magick::Coordinate> CoordinateList;

75 #if defined(MagickDLLExplicitTemplate)

77MagickDrawableExtern template class MagickPPExport

78 std::allocator<Magick::Coordinate>;

80 #endif // MagickDLLExplicitTemplate

82// Compare two Coordinate objects regardless of LHS/RHS

83extern MagickPPExport int operator ==

84 (const Coordinate& left_,const Coordinate& right_);

85extern MagickPPExport int operator !=

86 (const Coordinate& left_, const Coordinate& right_);

87extern MagickPPExport int operator >

88 (const Coordinate& left_, const Coordinate& right_);

89extern MagickPPExport int operator <

90 (const Coordinate& left_, const Coordinate& right_);

91extern MagickPPExport int operator >=

92 (const Coordinate& left_, const Coordinate& right_);

93extern MagickPPExport int operator <=

94 (const Coordinate& left_, const Coordinate& right_);

96//

97// Base class for all drawable objects

98//

99class MagickPPExport DrawableBase

100 {

101public:

102

103// Default constructor

104DrawableBase(void);

105

106// Destructor

107virtual ~DrawableBase(void);

108

109// Operator to invoke equivalent draw API call

110virtual void operator()(MagickCore::DrawingWand *) const;

111

112// Return polymorphic copy of object

113virtual DrawableBase* copy() const;

114 };

115

116//

117// Representation of a drawable surrogate object to manage drawable objects

118//

119 #undef Drawable // Conflict with <X11/Xproto.h>

120class MagickPPExport Drawable

121 {

122public:

123

124// Default constructor

125Drawable(void);

126

127// Construct from DrawableBase

128Drawable(const DrawableBase& original_);

129

130// Destructor

131 ~Drawable(void);

132

133// Copy constructor

134Drawable(const Drawable& original_);

135

136// Assignment operator

137Drawable& operator=(const Drawable& original_);

138

139// Operator to invoke contained object

140void operator()(MagickCore::DrawingWand *) const;

141

142private:

143DrawableBase* dp;

144 };

145

146typedef std::vector<Magick::Drawable> DrawableList;

147

148 #if defined(MagickDLLExplicitTemplate)

149

150MagickDrawableExtern template class MagickPPExport

151 std::allocator<Magick::Drawable>;

152

153 #endif // MagickDLLExplicitTemplate

154

155 //

156 // Base class for all drawable path elements for use with

157 // DrawablePath

158 //

159 class MagickPPExport VPathBase

160 {

161 public:

162// Constructor

163 VPathBase ( void )

164 { }

165

166// Destructor

167virtual ~VPathBase ( void );

168

169// Assignment operator

170// const VPathBase& operator= (const VPathBase& original_ );

171

172// Operator to invoke equivalent draw API call

173virtual void operator()( MagickCore::DrawingWand *context_ ) const = 0;

174

175// Return polymorphic copy of object

176virtual VPathBase* copy() const = 0;

177 };

178

179 //

180 // Representation of a drawable path element surrogate object to

181 // manage drawable path elements so they may be passed as a list to

182 // DrawablePath.

183 //

184 class MagickPPExport VPath

185 {

186 public:

187// Constructor

188VPath ( void );

189

190// Construct from VPathBase

191VPath ( const VPathBase& original_ );

192

193// Destructor

194virtual ~VPath ( void );

195

196// Copy constructor

197VPath ( const VPath& original_ );

198

199// Assignment operator

200VPath& operator= (const VPath& original_ );

201

202// Operator to invoke contained object

203void operator()( MagickCore::DrawingWand *context_ ) const;

204

205 private:

206VPathBase* dp;

207 };

208

209 typedef std::vector<Magick::VPath> VPathList;

210

211 #if defined(MagickDLLExplicitTemplate)

212

213 MagickDrawableExtern template class MagickPPExport

214 std::allocator<Magick::VPath>;

215

216 // MagickDrawableExtern template class MagickPPExport

217 // std::vector<Magick::VPath, std::allocator<Magick::VPath> >;

218

219 #endif // MagickDLLExplicitTemplate

220

221 //

222 // Drawable Objects

223 //

224

225 // Affine (scaling, rotation, and translation)

226 class MagickPPExport DrawableAffine : public DrawableBase

227 {

228 public:

229DrawableAffine ( double sx_, double sy_,

230double rx_, double ry_,

231double tx_, double ty_ );

232

233DrawableAffine ( void );

234

235/*virtual*/ ~DrawableAffine( void );

236

237// Operator to invoke equivalent draw API call

238/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

239

240// Return polymorphic copy of object

241/*virtual*/

242DrawableBase* copy() const;

243

244void sx( const double sx_ )

245 {

246 _affine.sx = sx_;

247 }

248double sx( void ) const

249 {

250return _affine.sx;

251 }

252

253void sy( const double sy_ )

254 {

255 _affine.sy = sy_;

256 }

257double sy( void ) const

258 {

259return _affine.sy;

260 }

261

262void rx( const double rx_ )

263 {

264 _affine.rx = rx_;

265 }

266double rx( void ) const

267 {

268return _affine.rx;

269 }

270

271void ry( const double ry_ )

272 {

273 _affine.ry = ry_;

274 }

275double ry( void ) const

276 {

277return _affine.ry;

278 }

279

280void tx( const double tx_ )

281 {

282 _affine.tx = tx_;

283 }

284double tx( void ) const

285 {

286return _affine.tx;

287 }

288

289void ty( const double ty_ )

290 {

291 _affine.ty = ty_;

292 }

293double ty( void ) const

294 {

295return _affine.ty;

296 }

297

298 private:

299 MagickCore::AffineMatrix _affine;

300 };

301

302 // Change pixel alpha value to transparent using PaintMethod

303 class MagickPPExport DrawableAlpha : public DrawableBase

304 {

305 public:

306

307 DrawableAlpha(double x_, double y_,PaintMethod paintMethod_)

308 : _x(x_),

309 _y(y_),

310 _paintMethod(paintMethod_)

311 {

312 }

313

314 ~DrawableAlpha(void);

315

316// Operator to invoke equivalent draw API call

317void operator()(MagickCore::DrawingWand *context_) const;

318

319// Return polymorphic copy of object

320DrawableBase* copy() const;

321

322void x(double x_)

323 {

324 _x=x_;

325 }

326

327double x(void) const

328 {

329return(_x);

330 }

331

332void y(double y_)

333 {

334 _y=y_;

335 }

336

337double y(void) const

338 {

339return(_y);

340 }

341

342void paintMethod(PaintMethod paintMethod_)

343 {

344 _paintMethod=paintMethod_;

345 }

346

347 PaintMethod paintMethod(void) const

348 {

349return(_paintMethod);

350 }

351

352private:

353

354double _x;

355double _y;

356 PaintMethod _paintMethod;

357 };

358

359 // Arc

360 class MagickPPExport DrawableArc : public DrawableBase

361 {

362 public:

363 DrawableArc ( double startX_, double startY_,

364double endX_, double endY_,

365double startDegrees_, double endDegrees_ )

366 : _startX(startX_),

367 _startY(startY_),

368 _endX(endX_),

369 _endY(endY_),

370 _startDegrees(startDegrees_),

371 _endDegrees(endDegrees_)

372 { }

373

374/*virtual*/ ~DrawableArc( void );

375

376// Operator to invoke equivalent draw API call

377/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

378

379// Return polymorphic copy of object

380/*virtual*/ DrawableBase* copy() const;

381

382void startX( double startX_ )

383 {

384 _startX = startX_;

385 }

386double startX( void ) const

387 {

388return _startX;

389 }

390

391void startY( double startY_ )

392 {

393 _startY = startY_;

394 }

395double startY( void ) const

396 {

397return _startY;

398 }

399

400void endX( double endX_ )

401 {

402 _endX = endX_;

403 }

404double endX( void ) const

405 {

406return _endX;

407 }

408

409void endY( double endY_ )

410 {

411 _endY = endY_;

412 }

413double endY( void ) const

414 {

415return _endY;

416 }

417

418void startDegrees( double startDegrees_ )

419 {

420 _startDegrees = startDegrees_;

421 }

422double startDegrees( void ) const

423 {

424return _startDegrees;

425 }

426

427void endDegrees( double endDegrees_ )

428 {

429 _endDegrees = endDegrees_;

430 }

431double endDegrees( void ) const

432 {

433return _endDegrees;

434 }

435

436 private:

437double _startX;

438double _startY;

439double _endX;

440double _endY;

441double _startDegrees;

442double _endDegrees;

443 };

444

445 // Bezier curve (Coordinate list must contain at least three members)

446 class MagickPPExport DrawableBezier : public DrawableBase

447 {

448 public:

449// Construct from coordinates

450DrawableBezier ( const CoordinateList &coordinates_ );

451

452// Copy constructor

453DrawableBezier ( const DrawableBezier& original_ );

454

455// Destructor

456/*virtual*/ ~DrawableBezier ( void );

457

458// Operator to invoke equivalent draw API call

459/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

460

461// Return polymorphic copy of object

462/*virtual*/ DrawableBase* copy() const;

463

464 private:

465CoordinateList _coordinates;

466 };

467

468// Sets the border color to be used for drawing bordered objects.

469class MagickPPExport DrawableBorderColor : public DrawableBase

470 {

471public:

472

473DrawableBorderColor(const Color &color_);

474

475DrawableBorderColor(const DrawableBorderColor &original_);

476

477 ~DrawableBorderColor(void);

478

479// Operator to invoke equivalent draw API call

480void operator()(MagickCore::DrawingWand *context_) const;

481

482void color(const Color &color_);

483Color color(void) const;

484

485// Return polymorphic copy of object

486DrawableBase* copy() const;

487

488private:

489Color _color;

490 };

491

492// Sets the polygon fill rule to be used by the clipping path.

493class MagickPPExport DrawableClipRule : public DrawableBase

494 {

495public:

496

497DrawableClipRule(const FillRule fillRule_);

498

499 ~DrawableClipRule(void);

500

501// Operator to invoke equivalent draw API call

502void operator()(MagickCore::DrawingWand *context_) const;

503

504void fillRule(const FillRule fillRule_);

505 FillRule fillRule(void) const;

506

507// Return polymorphic copy of object

508DrawableBase* copy() const;

509

510private:

511 FillRule _fillRule;

512 };

513

514// Sets the interpretation of clip path units.

515class MagickPPExport DrawableClipUnits : public DrawableBase

516 {

517public:

518

519DrawableClipUnits(const ClipPathUnits units_);

520

521 ~DrawableClipUnits(void);

522

523// Operator to invoke equivalent draw API call

524void operator()(MagickCore::DrawingWand *context_) const;

525

526void units(const ClipPathUnits units_);

527 ClipPathUnits units(void) const;

528

529// Return polymorphic copy of object

530DrawableBase* copy() const;

531

532private:

533 ClipPathUnits _units;

534 };

535

536 // Pop (terminate) clip path definition

537 class MagickPPExport DrawablePopClipPath : public DrawableBase

538 {

539 public:

540 DrawablePopClipPath ( void )

541 : _dummy(0)

542 {

543 }

544

545/*virtual*/ ~DrawablePopClipPath ( void );

546

547// Operator to invoke equivalent draw API call

548/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

549

550// Return polymorphic copy of object

551/*virtual*/ DrawableBase* copy() const;

552

553 private:

554 ::ssize_t _dummy;

555 };

556

557 // Push (create) Clip path definition

558 class MagickPPExport DrawablePushClipPath : public DrawableBase

559 {

560 public:

561DrawablePushClipPath ( const std::string &id_);

562

563DrawablePushClipPath ( const DrawablePushClipPath& original_ );

564

565/*virtual*/ ~DrawablePushClipPath ( void );

566

567// Operator to invoke equivalent draw API call

568/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

569

570// Return polymorphic copy of object

571/*virtual*/ DrawableBase* copy() const;

572

573 private:

574 std::string _id;

575 };

576

577 // Named Clip Path

578 class MagickPPExport DrawableClipPath : public DrawableBase

579 {

580 public:

581DrawableClipPath ( const std::string &id_ );

582DrawableClipPath ( const DrawableClipPath& original_ );

583

584/*virtual*/ ~DrawableClipPath ( void );

585

586// Operator to invoke equivalent draw API call

587/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

588

589// Return polymorphic copy of object

590/*virtual*/ DrawableBase* copy() const;

591

592void clip_path( const std::string &id_ )

593 {

594 _id = id_.c_str(); //multithread safe

595 }

596 std::string clip_path( void ) const

597 {

598return _id;

599 }

600

601 private:

602 std::string _id;

603 };

604

605 // Circle

606 class MagickPPExport DrawableCircle : public DrawableBase

607 {

608 public:

609 DrawableCircle ( double originX_, double originY_,

610double perimX_, double perimY_ )

611 : _originX(originX_),

612 _originY(originY_),

613 _perimX(perimX_),

614 _perimY(perimY_)

615 {

616 }

617

618/*virtual*/ ~DrawableCircle ( void );

619

620// Operator to invoke equivalent draw API call

621/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

622

623// Return polymorphic copy of object

624/*virtual*/ DrawableBase* copy() const;

625

626void originX( double originX_ )

627 {

628 _originX = originX_;

629 }

630double originX( void ) const

631 {

632return _originX;

633 }

634

635void originY( double originY_ )

636 {

637 _originY = originY_;

638 }

639double originY( void ) const

640 {

641return _originY;

642 }

643

644void perimX( double perimX_ )

645 {

646 _perimX = perimX_;

647 }

648double perimX( void ) const

649 {

650return _perimX;

651 }

652

653void perimY( double perimY_ )

654 {

655 _perimY = perimY_;

656 }

657double perimY( void ) const

658 {

659return _perimY;

660 }

661

662 private:

663double _originX;

664double _originY;

665double _perimX;

666double _perimY;

667 };

668

669 // Colorize at point using PaintMethod

670 class MagickPPExport DrawableColor : public DrawableBase

671 {

672 public:

673 DrawableColor ( double x_, double y_,

674 PaintMethod paintMethod_ )

675 : _x(x_),

676 _y(y_),

677 _paintMethod(paintMethod_)

678 { }

679

680/*virtual*/ ~DrawableColor ( void );

681

682// Operator to invoke equivalent draw API call

683/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

684

685// Return polymorphic copy of object

686/*virtual*/ DrawableBase* copy() const;

687

688void x( double x_ )

689 {

690 _x = x_;

691 }

692double x( void ) const

693 {

694return _x;

695 }

696

697void y( double y_ )

698 {

699 _y = y_;

700 }

701double y( void ) const

702 {

703return _y;

704 }

705

706void paintMethod( PaintMethod paintMethod_ )

707 {

708 _paintMethod = paintMethod_;

709 }

710 PaintMethod paintMethod( void ) const

711 {

712return _paintMethod;

713 }

714

715 private:

716double _x;

717double _y;

718 PaintMethod _paintMethod;

719 };

720

721 // Draw image at point, scaled to size specified by width and height

722 class MagickPPExport Image;

723 class MagickPPExport DrawableCompositeImage : public DrawableBase

724 {

725 public:

726DrawableCompositeImage ( double x_, double y_,

727const std::string &filename_ );

728

729DrawableCompositeImage ( double x_, double y_,

730const Image &image_ );

731

732DrawableCompositeImage ( double x_, double y_,

733double width_, double height_,

734const std::string &filename_ );

735

736DrawableCompositeImage ( double x_, double y_,

737double width_, double height_,

738const Image &image_ );

739

740DrawableCompositeImage ( double x_, double y_,

741double width_, double height_,

742const std::string &filename_,

743 CompositeOperator composition_ );

744

745DrawableCompositeImage ( double x_, double y_,

746double width_, double height_,

747const Image &image_,

748 CompositeOperator composition_ );

749

750// Copy constructor

751DrawableCompositeImage ( const DrawableCompositeImage& original_ );

752

753// Destructor

754/*virtual*/ ~DrawableCompositeImage( void );

755

756// Assignment operator

757DrawableCompositeImage& operator=

758 (const DrawableCompositeImage& original_ );

759

760// Operator to invoke equivalent draw API call

761/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

762

763// Return polymorphic copy of object

764/*virtual*/ DrawableBase* copy() const;

765

766void composition( CompositeOperator composition_ )

767 {

768 _composition = composition_;

769 }

770 CompositeOperator composition( void ) const

771 {

772return _composition;

773 }

774

775void filename( const std::string &image_ );

776 std::string filename( void ) const;

777

778void x( double x_ )

779 {

780 _x = x_;

781 }

782double x( void ) const

783 {

784return _x;

785 }

786

787void y( double y_ )

788 {

789 _y = y_;

790 }

791double y( void ) const

792 {

793return _y;

794 }

795

796void width( double width_ )

797 {

798 _width = width_;

799 }

800double width( void ) const

801 {

802return _width;

803 }

804

805void height( double height_ )

806 {

807 _height = height_;

808 }

809double height( void ) const

810 {

811return _height;

812 }

813

814void image( const Image &image_ );

815Magick::Image image( void ) const;

816

817// Specify image format used to output Base64 inlined image data.

818void magick( std::string magick_ );

819 std::string magick( void );

820

821 private:

822 CompositeOperator _composition;

823double _x;

824double _y;

825double _width;

826double _height;

827Image* _image;

828 };

829

830 // Density

831 class MagickPPExport DrawableDensity : public DrawableBase

832 {

833 public:

834

835DrawableDensity(const Point &density_);

836

837DrawableDensity(const std::string &density_);

838

839 ~DrawableDensity(void);

840

841void operator()(MagickCore::DrawingWand *context_) const;

842

843DrawableBase* copy() const;

844

845 private:

846 std::string _density;

847 };

848

849 // Ellipse

850 class MagickPPExport DrawableEllipse : public DrawableBase

851 {

852 public:

853 DrawableEllipse ( double originX_, double originY_,

854double radiusX_, double radiusY_,

855double arcStart_, double arcEnd_ )

856 : _originX(originX_),

857 _originY(originY_),

858 _radiusX(radiusX_),

859 _radiusY(radiusY_),

860 _arcStart(arcStart_),

861 _arcEnd(arcEnd_)

862 { }

863

864/*virtual*/ ~DrawableEllipse( void );

865

866// Operator to invoke equivalent draw API call

867/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

868

869// Return polymorphic copy of object

870/*virtual*/ DrawableBase* copy() const;

871

872void originX( double originX_ )

873 {

874 _originX = originX_;

875 }

876double originX( void ) const

877 {

878return _originX;

879 }

880

881void originY( double originY_ )

882 {

883 _originY = originY_;

884 }

885double originY( void ) const

886 {

887return _originY;

888 }

889

890void radiusX( double radiusX_ )

891 {

892 _radiusX = radiusX_;

893 }

894double radiusX( void ) const

895 {

896return _radiusX;

897 }

898

899void radiusY( double radiusY_ )

900 {

901 _radiusY = radiusY_;

902 }

903double radiusY( void ) const

904 {

905return _radiusY;

906 }

907

908void arcStart( double arcStart_ )

909 {

910 _arcStart = arcStart_;

911 }

912double arcStart( void ) const

913 {

914return _arcStart;

915 }

916

917void arcEnd( double arcEnd_ )

918 {

919 _arcEnd = arcEnd_;

920 }

921double arcEnd( void ) const

922 {

923return _arcEnd;

924 }

925

926 private:

927double _originX;

928double _originY;

929double _radiusX;

930double _radiusY;

931double _arcStart;

932double _arcEnd;

933 };

934

935 // Specify drawing fill color

936 class MagickPPExport DrawableFillColor : public DrawableBase

937 {

938 public:

939DrawableFillColor ( const Color &color_ );

940

941DrawableFillColor ( const DrawableFillColor& original_ );

942

943/*virtual*/ ~DrawableFillColor( void );

944

945// Operator to invoke equivalent draw API call

946/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

947

948// Return polymorphic copy of object

949/*virtual*/ DrawableBase* copy() const;

950

951void color( const Color &color_ )

952 {

953 _color = color_;

954 }

955 Color color( void ) const

956 {

957return _color;

958 }

959

960 private:

961Color _color;

962 };

963

964// Sets the URL to use as a fill pattern for filling objects. Only local

965// URLs("#identifier") are supported at this time. These local URLs are

966// normally created by defining a named fill pattern with

967// DrawablePushPattern/DrawablePopPattern.

968class MagickPPExport DrawableFillPatternUrl : public DrawableBase

969 {

970public:

971

972DrawableFillPatternUrl(const std::string &url_);

973

974 ~DrawableFillPatternUrl(void);

975

976DrawableFillPatternUrl(const DrawableFillPatternUrl& original_);

977

978// Operator to invoke equivalent draw API call

979void operator()(MagickCore::DrawingWand *context_) const;

980

981void url(const std::string &url_);

982 std::string url(void) const;

983

984// Return polymorphic copy of object

985DrawableBase* copy() const;

986

987private:

988 std::string _url;

989 };

990

991 // Specify fill rule (fill-rule)

992 class MagickPPExport DrawableFillRule : public DrawableBase

993 {

994 public:

995 DrawableFillRule ( const FillRule fillRule_ )

996 : _fillRule(fillRule_)

997 {

998 }

999

1000/*virtual*/ ~DrawableFillRule ( void );

1001

1002// Operator to invoke equivalent draw API call

1003/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1004

1005// Return polymorphic copy of object

1006/*virtual*/ DrawableBase* copy() const;

1007

1008void fillRule( const FillRule fillRule_ )

1009 {

1010 _fillRule = fillRule_;

1011 }

1012 FillRule fillRule( void ) const

1013 {

1014return _fillRule;

1015 }

1016

1017 private:

1018 FillRule _fillRule;

1019 };

1020

1021 // Specify drawing fill alpha

1022 class MagickPPExport DrawableFillOpacity : public DrawableBase

1023 {

1024 public:

1025

1026 DrawableFillOpacity(double opacity_)

1027 : _opacity(opacity_)

1028 {

1029 }

1030

1031 ~DrawableFillOpacity ( void );

1032

1033// Operator to invoke equivalent draw API call

1034void operator()(MagickCore::DrawingWand *context_) const;

1035

1036// Return polymorphic copy of object

1037DrawableBase* copy() const;

1038

1039void opacity(double opacity_)

1040 {

1041 _opacity=opacity_;

1042 }

1043

1044double opacity(void) const

1045 {

1046return(_opacity);

1047 }

1048

1049 private:

1050double _opacity;

1051 };

1052

1053 // Specify text font

1054 class MagickPPExport DrawableFont : public DrawableBase

1055 {

1056 public:

1057DrawableFont ( const std::string &font_ );

1058

1059DrawableFont ( const std::string &family_,

1060 StyleType style_,

1061const unsigned int weight_,

1062 StretchType stretch_ );

1063DrawableFont ( const DrawableFont& original_ );

1064

1065/*virtual*/ ~DrawableFont ( void );

1066

1067// Operator to invoke equivalent draw API call

1068/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1069

1070// Return polymorphic copy of object

1071/*virtual*/ DrawableBase* copy() const;

1072

1073void font( const std::string &font_ )

1074 {

1075 _font = font_;

1076 }

1077 std::string font( void ) const

1078 {

1079return _font;

1080 }

1081

1082 private:

1083 std::string _font;

1084 std::string _family;

1085 StyleType _style;

1086unsigned int _weight;

1087 StretchType _stretch;

1088 };

1089

1090 // Specify text positioning gravity

1091 class MagickPPExport DrawableGravity : public DrawableBase

1092 {

1093 public:

1094 DrawableGravity ( GravityType gravity_ )

1095 : _gravity(gravity_)

1096 {

1097 }

1098

1099/*virtual*/ ~DrawableGravity ( void );

1100

1101// Operator to invoke equivalent draw API call

1102/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1103

1104// Return polymorphic copy of object

1105/*virtual*/ DrawableBase* copy() const;

1106

1107void gravity( GravityType gravity_ )

1108 {

1109 _gravity = gravity_;

1110 }

1111 GravityType gravity( void ) const

1112 {

1113return _gravity;

1114 }

1115

1116 private:

1117 GravityType _gravity;

1118 };

1119

1120 // Line

1121 class MagickPPExport DrawableLine : public DrawableBase

1122 {

1123 public:

1124 DrawableLine ( double startX_, double startY_,

1125double endX_, double endY_ )

1126 : _startX(startX_),

1127 _startY(startY_),

1128 _endX(endX_),

1129 _endY(endY_)

1130 { }

1131

1132/*virtual*/ ~DrawableLine ( void );

1133

1134// Operator to invoke equivalent draw API call

1135/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1136

1137// Return polymorphic copy of object

1138/*virtual*/ DrawableBase* copy() const;

1139

1140void startX( double startX_ )

1141 {

1142 _startX = startX_;

1143 }

1144double startX( void ) const

1145 {

1146return _startX;

1147 }

1148

1149void startY( double startY_ )

1150 {

1151 _startY = startY_;

1152 }

1153double startY( void ) const

1154 {

1155return _startY;

1156 }

1157

1158void endX( double endX_ )

1159 {

1160 _endX = endX_;

1161 }

1162double endX( void ) const

1163 {

1164return _endX;

1165 }

1166

1167void endY( double endY_ )

1168 {

1169 _endY = endY_;

1170 }

1171double endY( void ) const

1172 {

1173return _endY;

1174 }

1175

1176 private:

1177double _startX;

1178double _startY;

1179double _endX;

1180double _endY;

1181 };

1182

1183 // Drawable Path

1184 class MagickPPExport DrawablePath : public DrawableBase

1185 {

1186 public:

1187DrawablePath ( const VPathList &path_ );

1188

1189DrawablePath ( const DrawablePath& original_ );

1190

1191/*virtual*/ ~DrawablePath ( void );

1192

1193// Operator to invoke equivalent draw API call

1194/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1195

1196// Return polymorphic copy of object

1197/*virtual*/ DrawableBase* copy() const;

1198

1199 private:

1200VPathList _path;

1201 };

1202

1203 // Point

1204 class MagickPPExport DrawablePoint : public DrawableBase

1205 {

1206 public:

1207 DrawablePoint ( double x_, double y_ )

1208 : _x(x_),

1209 _y(y_)

1210 { }

1211

1212/*virtual*/ ~DrawablePoint ( void );

1213

1214// Operator to invoke equivalent draw API call

1215/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1216

1217// Return polymorphic copy of object

1218/*virtual*/ DrawableBase* copy() const;

1219

1220void x( double x_ )

1221 {

1222 _x = x_;

1223 }

1224double x( void ) const

1225 {

1226return _x;

1227 }

1228

1229void y( double y_ )

1230 {

1231 _y = y_;

1232 }

1233double y( void ) const

1234 {

1235return _y;

1236 }

1237

1238 private:

1239double _x;

1240double _y;

1241 };

1242

1243 // Text pointsize

1244 class MagickPPExport DrawablePointSize : public DrawableBase

1245 {

1246 public:

1247 DrawablePointSize ( double pointSize_ )

1248 : _pointSize(pointSize_)

1249 { }

1250

1251/*virtual*/ ~DrawablePointSize ( void );

1252

1253// Operator to invoke equivalent draw API call

1254/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1255

1256// Return polymorphic copy of object

1257/*virtual*/ DrawableBase* copy() const;

1258

1259void pointSize( double pointSize_ )

1260 {

1261 _pointSize = pointSize_;

1262 }

1263double pointSize( void ) const

1264 {

1265return _pointSize;

1266 }

1267

1268 private:

1269double _pointSize;

1270 };

1271

1272 // Polygon (Coordinate list must contain at least three members)

1273 class MagickPPExport DrawablePolygon : public DrawableBase

1274 {

1275 public:

1276DrawablePolygon ( const CoordinateList &coordinates_ );

1277

1278DrawablePolygon ( const DrawablePolygon& original_ );

1279

1280/*virtual*/ ~DrawablePolygon ( void );

1281

1282// Operator to invoke equivalent draw API call

1283/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1284

1285// Return polymorphic copy of object

1286/*virtual*/ DrawableBase* copy() const;

1287

1288 private:

1289CoordinateList _coordinates;

1290 };

1291

1292 // Polyline (Coordinate list must contain at least three members)

1293 class MagickPPExport DrawablePolyline : public DrawableBase

1294 {

1295 public:

1296DrawablePolyline ( const CoordinateList &coordinates_ );

1297

1298DrawablePolyline ( const DrawablePolyline& original_ );

1299

1300/*virtual*/ ~DrawablePolyline ( void );

1301

1302// Operator to invoke equivalent draw API call

1303/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1304

1305// Return polymorphic copy of object

1306/*virtual*/ DrawableBase* copy() const;

1307

1308 private:

1309CoordinateList _coordinates;

1310 };

1311

1312 // Pop Graphic Context

1313 class MagickPPExport DrawablePopGraphicContext : public DrawableBase

1314 {

1315 public:

1316 DrawablePopGraphicContext ( void )

1317 : _dummy(0)

1318 {

1319 }

1320

1321/*virtual*/ ~DrawablePopGraphicContext ( void );

1322

1323// Operator to invoke equivalent draw API call

1324/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1325

1326// Return polymorphic copy of object

1327/*virtual*/ DrawableBase* copy() const;

1328

1329 private:

1330 ::ssize_t _dummy;

1331 };

1332

1333 // Push Graphic Context

1334 class MagickPPExport DrawablePushGraphicContext : public DrawableBase

1335 {

1336 public:

1337 DrawablePushGraphicContext ( void )

1338 : _dummy(0)

1339 {

1340 }

1341

1342/*virtual*/ ~DrawablePushGraphicContext ( void );

1343

1344// Operator to invoke equivalent draw API call

1345/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1346

1347// Return polymorphic copy of object

1348/*virtual*/ DrawableBase* copy() const;

1349

1350 private:

1351 ::ssize_t _dummy;

1352 };

1353

1354 // Pop (terminate) Pattern definition

1355 class MagickPPExport DrawablePopPattern : public DrawableBase

1356 {

1357 public:

1358 DrawablePopPattern ( void )

1359 : _dummy(0)

1360 {

1361 }

1362

1363/*virtual*/ ~DrawablePopPattern ( void );

1364

1365// Operator to invoke equivalent draw API call

1366/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1367

1368// Return polymorphic copy of object

1369/*virtual*/ DrawableBase* copy() const;

1370

1371 private:

1372 ::ssize_t _dummy;

1373 };

1374

1375 // Push (create) Pattern definition

1376 class MagickPPExport DrawablePushPattern : public DrawableBase

1377 {

1378 public:

1379DrawablePushPattern ( const std::string &id_, ::ssize_t x_, ::ssize_t y_,

1380size_t width_, size_t height_ );

1381

1382DrawablePushPattern ( const DrawablePushPattern& original_ );

1383

1384/*virtual*/ ~DrawablePushPattern ( void );

1385

1386// Operator to invoke equivalent draw API call

1387/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1388

1389// Return polymorphic copy of object

1390/*virtual*/ DrawableBase* copy() const;

1391

1392 private:

1393 std::string _id;

1394 ::ssize_t _x;

1395 ::ssize_t _y;

1396size_t _width;

1397size_t _height;

1398 };

1399

1400 // Rectangle

1401 class MagickPPExport DrawableRectangle : public DrawableBase

1402 {

1403 public:

1404 DrawableRectangle ( double upperLeftX_, double upperLeftY_,

1405double lowerRightX_, double lowerRightY_ )

1406 : _upperLeftX(upperLeftX_),

1407 _upperLeftY(upperLeftY_),

1408 _lowerRightX(lowerRightX_),

1409 _lowerRightY(lowerRightY_)

1410 { }

1411

1412/*virtual*/ ~DrawableRectangle ( void );

1413

1414// Operator to invoke equivalent draw API call

1415/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1416

1417// Return polymorphic copy of object

1418/*virtual*/ DrawableBase* copy() const;

1419

1420void upperLeftX( double upperLeftX_ )

1421 {

1422 _upperLeftX = upperLeftX_;

1423 }

1424double upperLeftX( void ) const

1425 {

1426return _upperLeftX;

1427 }

1428

1429void upperLeftY( double upperLeftY_ )

1430 {

1431 _upperLeftY = upperLeftY_;

1432 }

1433double upperLeftY( void ) const

1434 {

1435return _upperLeftY;

1436 }

1437

1438void lowerRightX( double lowerRightX_ )

1439 {

1440 _lowerRightX = lowerRightX_;

1441 }

1442double lowerRightX( void ) const

1443 {

1444return _lowerRightX;

1445 }

1446

1447void lowerRightY( double lowerRightY_ )

1448 {

1449 _lowerRightY = lowerRightY_;

1450 }

1451double lowerRightY( void ) const

1452 {

1453return _lowerRightY;

1454 }

1455

1456 private:

1457double _upperLeftX;

1458double _upperLeftY;

1459double _lowerRightX;

1460double _lowerRightY;

1461 };

1462

1463 // Apply Rotation

1464 class MagickPPExport DrawableRotation : public DrawableBase

1465 {

1466 public:

1467 DrawableRotation ( double angle_ )

1468 : _angle( angle_ )

1469 { }

1470

1471/*virtual*/ ~DrawableRotation ( void );

1472

1473// Operator to invoke equivalent draw API call

1474/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1475

1476// Return polymorphic copy of object

1477/*virtual*/ DrawableBase* copy() const;

1478

1479void angle( double angle_ )

1480 {

1481 _angle = angle_;

1482 }

1483double angle( void ) const

1484 {

1485return _angle;

1486 }

1487

1488 private:

1489double _angle;

1490 };

1491

1492 // Round Rectangle

1493 class MagickPPExport DrawableRoundRectangle : public DrawableBase

1494 {

1495 public:

1496 DrawableRoundRectangle ( double upperLeftX_, double upperLeftY_,

1497double lowerRightX_, double lowerRightY_,

1498double cornerWidth_, double cornerHeight_ )

1499 : _upperLeftX(upperLeftX_),

1500 _upperLeftY(upperLeftY_),

1501 _lowerRightX(lowerRightX_),

1502 _lowerRightY(lowerRightY_),

1503 _cornerWidth(cornerWidth_),

1504 _cornerHeight(cornerHeight_)

1505 { }

1506

1507/*virtual*/ ~DrawableRoundRectangle ( void );

1508

1509// Operator to invoke equivalent draw API call

1510/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1511

1512// Return polymorphic copy of object

1513/*virtual*/ DrawableBase* copy() const;

1514

1515 #if !defined(MAGICKCORE_EXCLUDE_DEPRECATED)

1516

1517void centerX( double centerX_ )

1518 {

1519 _upperLeftX = centerX_;

1520 }

1521double centerX( void ) const

1522 {

1523return _upperLeftX;

1524 }

1525

1526void centerY( double centerY_ )

1527 {

1528 _upperLeftY = centerY_;

1529 }

1530double centerY( void ) const

1531 {

1532return _upperLeftY;

1533 }

1534

1535void width( double width_ )

1536 {

1537 _lowerRightX = width_;

1538 }

1539double width( void ) const

1540 {

1541return _lowerRightX;

1542 }

1543

1544void hight( double hight_ )

1545 {

1546 _lowerRightY = hight_;

1547 }

1548double hight( void ) const

1549 {

1550return _lowerRightY;

1551 }

1552

1553 #endif

1554

1555void upperLeftX( double upperLeftX_ )

1556 {

1557 _upperLeftX = upperLeftX_;

1558 }

1559double upperLeftX( void ) const

1560 {

1561return _upperLeftX;

1562 }

1563

1564void upperLeftY( double upperLeftY_ )

1565 {

1566 _upperLeftY = upperLeftY_;

1567 }

1568double upperLeftY( void ) const

1569 {

1570return _upperLeftY;

1571 }

1572

1573void lowerRightX( double lowerRightX_ )

1574 {

1575 _lowerRightX = lowerRightX_;

1576 }

1577double lowerRightX( void ) const

1578 {

1579return _lowerRightX;

1580 }

1581

1582void lowerRightY( double lowerRightY_ )

1583 {

1584 _lowerRightY = lowerRightY_;

1585 }

1586double lowerRightY( void ) const

1587 {

1588return _lowerRightY;

1589 }

1590

1591void cornerWidth( double cornerWidth_ )

1592 {

1593 _cornerWidth = cornerWidth_;

1594 }

1595double cornerWidth( void ) const

1596 {

1597return _cornerWidth;

1598 }

1599

1600void cornerHeight( double cornerHeight_ )

1601 {

1602 _cornerHeight = cornerHeight_;

1603 }

1604double cornerHeight( void ) const

1605 {

1606return _cornerHeight;

1607 }

1608

1609 private:

1610double _upperLeftX;

1611double _upperLeftY;

1612double _lowerRightX;

1613double _lowerRightY;

1614double _cornerWidth;

1615double _cornerHeight;

1616 };

1617

1618 // Apply Scaling

1619 class MagickPPExport DrawableScaling : public DrawableBase

1620 {

1621 public:

1622 DrawableScaling ( double x_, double y_ )

1623 : _x(x_),

1624 _y(y_)

1625 { }

1626

1627/*virtual*/ ~DrawableScaling ( void );

1628

1629// Operator to invoke equivalent draw API call

1630/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1631

1632// Return polymorphic copy of object

1633/*virtual*/ DrawableBase* copy() const;

1634

1635void x( double x_ )

1636 {

1637 _x = x_;

1638 }

1639double x( void ) const

1640 {

1641return _x;

1642 }

1643

1644void y( double y_ )

1645 {

1646 _y = y_;

1647 }

1648double y( void ) const

1649 {

1650return _y;

1651 }

1652

1653 private:

1654double _x;

1655double _y;

1656 };

1657

1658 // Apply Skew in X direction

1659 class MagickPPExport DrawableSkewX : public DrawableBase

1660 {

1661 public:

1662 DrawableSkewX ( double angle_ )

1663 : _angle(angle_)

1664 { }

1665

1666/*virtual*/ ~DrawableSkewX ( void );

1667

1668// Operator to invoke equivalent draw API call

1669/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1670

1671// Return polymorphic copy of object

1672/*virtual*/ DrawableBase* copy() const;

1673

1674void angle( double angle_ )

1675 {

1676 _angle = angle_;

1677 }

1678double angle( void ) const

1679 {

1680return _angle;

1681 }

1682

1683 private:

1684double _angle;

1685 };

1686

1687 // Apply Skew in Y direction

1688 class MagickPPExport DrawableSkewY : public DrawableBase

1689 {

1690 public:

1691 DrawableSkewY ( double angle_ )

1692 : _angle(angle_)

1693 { }

1694

1695/*virtual*/ ~DrawableSkewY ( void );

1696

1697// Operator to invoke equivalent draw API call

1698/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1699

1700// Return polymorphic copy of object

1701/*virtual*/ DrawableBase* copy() const;

1702

1703void angle( double angle_ )

1704 {

1705 _angle = angle_;

1706 }

1707double angle( void ) const

1708 {

1709return _angle;

1710 }

1711

1712 private:

1713double _angle;

1714 };

1715

1716// Stroke dasharray

1717//

1718// dasharray_ is an allocated array terminated by value 0.0 or 0.

1719// The array is copied so the original does not need to be preserved.

1720// Pass a null pointer to clear an existing dash array setting.

1721class MagickPPExport DrawableStrokeDashArray : public DrawableBase

1722 {

1723public:

1724

1725DrawableStrokeDashArray(const double* dasharray_);

1726

1727DrawableStrokeDashArray(const Magick::DrawableStrokeDashArray &original_);

1728

1729 ~DrawableStrokeDashArray(void);

1730

1731// Operator to invoke equivalent draw API call

1732void operator()(MagickCore::DrawingWand *context_) const;

1733

1734// Return polymorphic copy of object

1735DrawableBase* copy() const;

1736

1737void dasharray(const double* dasharray_);

1738const double* dasharray(void) const;

1739

1740DrawableStrokeDashArray& operator=(

1741const Magick::DrawableStrokeDashArray &original_);

1742

1743private:

1744size_t _size;

1745double *_dasharray;

1746 };

1747

1748// Stroke dashoffset

1749class MagickPPExport DrawableStrokeDashOffset : public DrawableBase

1750 {

1751public:

1752 DrawableStrokeDashOffset(const double offset_)

1753 : _offset(offset_)

1754 { }

1755

1756 ~DrawableStrokeDashOffset(void);

1757

1758// Operator to invoke equivalent draw API call

1759void operator()(MagickCore::DrawingWand *context_) const;

1760

1761// Return polymorphic copy of object

1762DrawableBase* copy() const;

1763

1764void offset(const double offset_);

1765double offset(void) const;

1766

1767private:

1768double _offset;

1769 };

1770

1771 // Stroke linecap

1772 class MagickPPExport DrawableStrokeLineCap : public DrawableBase

1773 {

1774 public:

1775 DrawableStrokeLineCap ( LineCap linecap_ )

1776 : _linecap(linecap_)

1777 { }

1778

1779/*virtual*/ ~DrawableStrokeLineCap ( void );

1780

1781// Operator to invoke equivalent draw API call

1782/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1783

1784// Return polymorphic copy of object

1785/*virtual*/ DrawableBase* copy() const;

1786

1787void linecap( LineCap linecap_ )

1788 {

1789 _linecap = linecap_;

1790 }

1791 LineCap linecap( void ) const

1792 {

1793return _linecap;

1794 }

1795

1796 private:

1797 LineCap _linecap;

1798 };

1799

1800 // Stroke linejoin

1801 class MagickPPExport DrawableStrokeLineJoin : public DrawableBase

1802 {

1803 public:

1804 DrawableStrokeLineJoin ( LineJoin linejoin_ )

1805 : _linejoin(linejoin_)

1806 { }

1807

1808/*virtual*/ ~DrawableStrokeLineJoin ( void );

1809

1810// Operator to invoke equivalent draw API call

1811/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1812

1813// Return polymorphic copy of object

1814/*virtual*/ DrawableBase* copy() const;

1815

1816void linejoin( LineJoin linejoin_ )

1817 {

1818 _linejoin = linejoin_;

1819 }

1820 LineJoin linejoin( void ) const

1821 {

1822return _linejoin;

1823 }

1824

1825 private:

1826 LineJoin _linejoin;

1827 };

1828

1829 // Stroke miterlimit

1830 class MagickPPExport DrawableMiterLimit : public DrawableBase

1831 {

1832 public:

1833 DrawableMiterLimit ( size_t miterlimit_ )

1834 : _miterlimit(miterlimit_)

1835 { }

1836

1837/*virtual*/ ~DrawableMiterLimit ( void );

1838

1839// Operator to invoke equivalent draw API call

1840/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1841

1842// Return polymorphic copy of object

1843/*virtual*/ DrawableBase* copy() const;

1844

1845void miterlimit( size_t miterlimit_ )

1846 {

1847 _miterlimit = miterlimit_;

1848 }

1849size_t miterlimit( void ) const

1850 {

1851return _miterlimit;

1852 }

1853

1854 private:

1855size_t _miterlimit;

1856 };

1857

1858 // Sets the pattern used for stroking object outlines.

1859 class MagickPPExport DrawableStrokePatternUrl : public DrawableBase

1860 {

1861 public:

1862

1863DrawableStrokePatternUrl(const std::string &url_);

1864

1865 ~DrawableStrokePatternUrl(void);

1866

1867DrawableStrokePatternUrl(const DrawableStrokePatternUrl& original_);

1868

1869// Operator to invoke equivalent draw API call

1870void operator()(MagickCore::DrawingWand *context_) const;

1871

1872void url(const std::string &url_);

1873 std::string url(void) const;

1874

1875// Return polymorphic copy of object

1876DrawableBase* copy() const;

1877

1878 private:

1879 std::string _url;

1880 };

1881

1882 // Stroke antialias

1883 class MagickPPExport DrawableStrokeAntialias : public DrawableBase

1884 {

1885 public:

1886 DrawableStrokeAntialias ( bool flag_ )

1887 : _flag(flag_)

1888 { }

1889

1890/*virtual*/ ~DrawableStrokeAntialias ( void );

1891

1892// Operator to invoke equivalent draw API call

1893/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1894

1895// Return polymorphic copy of object

1896/*virtual*/ DrawableBase* copy() const;

1897

1898void flag( bool flag_ )

1899 {

1900 _flag = flag_;

1901 }

1902bool flag( void ) const

1903 {

1904return _flag;

1905 }

1906

1907 private:

1908bool _flag;

1909 };

1910

1911 // Stroke color

1912 class MagickPPExport DrawableStrokeColor : public DrawableBase

1913 {

1914 public:

1915DrawableStrokeColor ( const Color &color_ );

1916

1917DrawableStrokeColor ( const DrawableStrokeColor& original_ );

1918

1919/*virtual*/ ~DrawableStrokeColor ( void );

1920

1921// Operator to invoke equivalent draw API call

1922/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1923

1924// Return polymorphic copy of object

1925/*virtual*/ DrawableBase* copy() const;

1926

1927void color( const Color& color_ )

1928 {

1929 _color = color_;

1930 }

1931 Color color( void ) const

1932 {

1933return _color;

1934 }

1935

1936 private:

1937Color _color;

1938 };

1939

1940 // Stroke opacity

1941 class MagickPPExport DrawableStrokeOpacity : public DrawableBase

1942 {

1943 public:

1944

1945 DrawableStrokeOpacity(double opacity_)

1946 : _opacity(opacity_)

1947 {

1948 }

1949

1950 ~DrawableStrokeOpacity(void);

1951

1952// Operator to invoke equivalent draw API call

1953void operator()(MagickCore::DrawingWand *context_) const;

1954

1955// Return polymorphic copy of object

1956DrawableBase* copy() const;

1957

1958void opacity(double opacity_)

1959 {

1960 _opacity=opacity_;

1961 }

1962

1963double opacity(void) const

1964 {

1965return(_opacity);

1966 }

1967

1968 private:

1969double _opacity;

1970 };

1971

1972 // Stroke width

1973 class MagickPPExport DrawableStrokeWidth : public DrawableBase

1974 {

1975 public:

1976 DrawableStrokeWidth ( double width_ )

1977 : _width(width_)

1978 { }

1979

1980/*virtual*/ ~DrawableStrokeWidth ( void );

1981

1982// Operator to invoke equivalent draw API call

1983/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

1984

1985// Return polymorphic copy of object

1986/*virtual*/ DrawableBase* copy() const;

1987

1988void width( double width_ )

1989 {

1990 _width = width_;

1991 }

1992double width( void ) const

1993 {

1994return _width;

1995 }

1996

1997 private:

1998double _width;

1999 };

2000

2001 // Draw text at point

2002 class MagickPPExport DrawableText : public DrawableBase

2003 {

2004 public:

2005DrawableText ( const double x_, const double y_,

2006const std::string &text_ );

2007DrawableText ( const double x_, const double y_,

2008const std::string &text_, const std::string &encoding_);

2009

2010DrawableText ( const DrawableText& original_ );

2011

2012/*virtual*/ ~DrawableText ( void );

2013

2014// Operator to invoke equivalent draw API call

2015/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2016

2017// Return polymorphic copy of object

2018/*virtual*/ DrawableBase* copy() const;

2019

2020void encoding(const std::string &encoding_)

2021 {

2022 _encoding = encoding_;

2023 }

2024

2025void x( double x_ )

2026 {

2027 _x = x_;

2028 }

2029double x( void ) const

2030 {

2031return _x;

2032 }

2033

2034void y( double y_ )

2035 {

2036 _y = y_;

2037 }

2038double y( void ) const

2039 {

2040return _y;

2041 }

2042

2043void text( const std::string &text_ )

2044 {

2045 _text = text_;

2046 }

2047 std::string text( void ) const

2048 {

2049return _text;

2050 }

2051

2052 private:

2053double _x;

2054double _y;

2055 std::string _text;

2056 std::string _encoding;

2057 };

2058

2059 // Text alignment

2060 class MagickPPExport DrawableTextAlignment : public DrawableBase

2061 {

2062 public:

2063

2064DrawableTextAlignment(AlignType alignment_);

2065

2066DrawableTextAlignment(const DrawableTextAlignment& original_);

2067

2068 ~DrawableTextAlignment(void);

2069

2070// Operator to invoke equivalent draw API call

2071void operator()(MagickCore::DrawingWand *context_) const;

2072

2073void alignment(AlignType alignment_);

2074 AlignType alignment(void) const;

2075

2076// Return polymorphic copy of object

2077DrawableBase* copy() const;

2078

2079 private:

2080 AlignType _alignment;

2081 };

2082

2083 // Text antialias

2084 class MagickPPExport DrawableTextAntialias : public DrawableBase

2085 {

2086 public:

2087DrawableTextAntialias ( bool flag_ );

2088

2089DrawableTextAntialias( const DrawableTextAntialias &original_ );

2090

2091/*virtual*/ ~DrawableTextAntialias ( void );

2092

2093// Operator to invoke equivalent draw API call

2094/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2095

2096// Return polymorphic copy of object

2097/*virtual*/ DrawableBase* copy() const;

2098

2099void flag( bool flag_ )

2100 {

2101 _flag = flag_;

2102 }

2103bool flag( void ) const

2104 {

2105return _flag;

2106 }

2107

2108 private:

2109bool _flag;

2110 };

2111

2112 // Decoration (text decoration)

2113 class MagickPPExport DrawableTextDecoration : public DrawableBase

2114 {

2115 public:

2116DrawableTextDecoration ( DecorationType decoration_ );

2117

2118DrawableTextDecoration ( const DrawableTextDecoration& original_ );

2119

2120/*virtual*/ ~DrawableTextDecoration( void );

2121

2122// Operator to invoke equivalent draw API call

2123/*virtual*/void operator()( MagickCore::DrawingWand *context_ ) const;

2124

2125// Return polymorphic copy of object

2126/*virtual*/ DrawableBase* copy() const;

2127

2128void decoration( DecorationType decoration_ )

2129 {

2130 _decoration = decoration_;

2131 }

2132 DecorationType decoration( void ) const

2133 {

2134return _decoration;

2135 }

2136

2137 private:

2138 DecorationType _decoration;

2139 };

2140

2141// Render text right-to-left or left-to-right.

2142class MagickPPExport DrawableTextDirection : public DrawableBase

2143 {

2144public:

2145

2146DrawableTextDirection(DirectionType direction_);

2147

2148 ~DrawableTextDirection(void);

2149

2150void operator()(MagickCore::DrawingWand *context_) const;

2151

2152void direction(DirectionType direction_);

2153 DirectionType direction(void) const;

2154

2155DrawableBase* copy() const;

2156

2157private:

2158 DirectionType _direction;

2159 };

2160

2161// Specify text inter-line spacing

2162class MagickPPExport DrawableTextInterlineSpacing : public DrawableBase

2163 {

2164public:

2165

2166DrawableTextInterlineSpacing(double spacing_);

2167

2168 ~DrawableTextInterlineSpacing(void);

2169

2170void operator()(MagickCore::DrawingWand *context_) const;

2171

2172void spacing(double spacing_);

2173double spacing(void) const;

2174

2175DrawableBase* copy() const;

2176

2177private:

2178double _spacing;

2179 };

2180

2181// Specify text inter-word spacing

2182class MagickPPExport DrawableTextInterwordSpacing : public DrawableBase

2183 {

2184public:

2185

2186DrawableTextInterwordSpacing(double spacing_);

2187

2188 ~DrawableTextInterwordSpacing(void);

2189

2190void operator()(MagickCore::DrawingWand *context_) const;

2191

2192void spacing(double spacing_);

2193double spacing(void) const;

2194

2195DrawableBase *copy() const;

2196

2197private:

2198double _spacing;

2199 };

2200

2201// Specify text kerning

2202class MagickPPExport DrawableTextKerning : public DrawableBase

2203 {

2204public:

2205

2206DrawableTextKerning(double kerning_);

2207

2208 ~DrawableTextKerning(void);

2209

2210void operator()(MagickCore::DrawingWand *context_) const;

2211

2212void kerning(double kerning_);

2213double kerning(void) const;

2214

2215DrawableBase *copy() const;

2216

2217private:

2218double _kerning;

2219 };

2220

2221 // Text undercolor box

2222 class MagickPPExport DrawableTextUnderColor : public DrawableBase

2223 {

2224 public:

2225DrawableTextUnderColor ( const Color &color_ );

2226

2227DrawableTextUnderColor ( const DrawableTextUnderColor& original_ );

2228

2229/*virtual*/ ~DrawableTextUnderColor ( void );

2230

2231// Operator to invoke equivalent draw API call

2232/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2233

2234// Return polymorphic copy of object

2235/*virtual*/ DrawableBase* copy() const;

2236

2237void color( const Color& color_ )

2238 {

2239 _color = color_;

2240 }

2241 Color color( void ) const

2242 {

2243return _color;

2244 }

2245

2246 private:

2247Color _color;

2248 };

2249

2250 // Apply Translation

2251 class MagickPPExport DrawableTranslation : public DrawableBase

2252 {

2253 public:

2254 DrawableTranslation ( double x_, double y_ )

2255 : _x(x_),

2256 _y(y_)

2257 { }

2258

2259/*virtual*/ ~DrawableTranslation ( void );

2260

2261// Operator to invoke equivalent draw API call

2262/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2263

2264// Return polymorphic copy of object

2265/*virtual*/ DrawableBase* copy() const;

2266

2267void x( double x_ )

2268 {

2269 _x = x_;

2270 }

2271double x( void ) const

2272 {

2273return _x;

2274 }

2275

2276void y( double y_ )

2277 {

2278 _y = y_;

2279 }

2280double y( void ) const

2281 {

2282return _y;

2283 }

2284

2285 private:

2286double _x;

2287double _y;

2288 };

2289

2290 // Set the size of the viewbox

2291 class MagickPPExport DrawableViewbox : public DrawableBase

2292 {

2293 public:

2294 DrawableViewbox(::ssize_t x1_, ::ssize_t y1_,

2295 ::ssize_t x2_, ::ssize_t y2_)

2296 : _x1(x1_),

2297 _y1(y1_),

2298 _x2(x2_),

2299 _y2(y2_) { }

2300

2301/*virtual*/ ~DrawableViewbox ( void );

2302

2303// Operator to invoke equivalent draw API call

2304/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2305

2306// Return polymorphic copy of object

2307/*virtual*/

2308DrawableBase* copy() const;

2309

2310void x1( ::ssize_t x1_ )

2311 {

2312 _x1 = x1_;

2313 }

2314 ::ssize_t x1( void ) const

2315 {

2316return _x1;

2317 }

2318

2319void y1( ::ssize_t y1_ )

2320 {

2321 _y1 = y1_;

2322 }

2323 ::ssize_t y1( void ) const

2324 {

2325return _y1;

2326 }

2327

2328void x2( ::ssize_t x2_ )

2329 {

2330 _x2 = x2_;

2331 }

2332 ::ssize_t x2( void ) const

2333 {

2334return _x2;

2335 }

2336

2337void y2( ::ssize_t y2_ )

2338 {

2339 _y2 = y2_;

2340 }

2341 ::ssize_t y2( void ) const

2342 {

2343return _y2;

2344 }

2345

2346 private:

2347 ::ssize_t _x1;

2348 ::ssize_t _y1;

2349 ::ssize_t _x2;

2350 ::ssize_t _y2;

2351 };

2352

2353 //

2354 // Path Element Classes To Support DrawablePath

2355 //

2356 class MagickPPExport PathArcArgs

2357 {

2358 public:

2359PathArcArgs( void );

2360

2361PathArcArgs( double radiusX_, double radiusY_,

2362double xAxisRotation_, bool largeArcFlag_,

2363bool sweepFlag_, double x_, double y_ );

2364

2365PathArcArgs( const PathArcArgs &original_ );

2366

2367 ~PathArcArgs ( void );

2368

2369void radiusX( double radiusX_ )

2370 {

2371 _radiusX = radiusX_;

2372 }

2373double radiusX( void ) const

2374 {

2375return _radiusX;

2376 }

2377

2378void radiusY( double radiusY_ )

2379 {

2380 _radiusY = radiusY_;

2381 }

2382double radiusY( void ) const

2383 {

2384return _radiusY;

2385 }

2386

2387void xAxisRotation( double xAxisRotation_ )

2388 {

2389 _xAxisRotation = xAxisRotation_;

2390 }

2391double xAxisRotation( void ) const

2392 {

2393return _xAxisRotation;

2394 }

2395

2396void largeArcFlag( bool largeArcFlag_ )

2397 {

2398 _largeArcFlag = largeArcFlag_;

2399 }

2400bool largeArcFlag( void ) const

2401 {

2402return _largeArcFlag;

2403 }

2404

2405void sweepFlag( bool sweepFlag_ )

2406 {

2407 _sweepFlag = sweepFlag_;

2408 }

2409bool sweepFlag( void ) const

2410 {

2411return _sweepFlag;

2412 }

2413

2414void x( double x_ )

2415 {

2416 _x = x_;

2417 }

2418double x( void ) const

2419 {

2420return _x;

2421 }

2422

2423void y( double y_ )

2424 {

2425 _y = y_;

2426 }

2427double y( void ) const

2428 {

2429return _y;

2430 }

2431

2432 private:

2433double _radiusX; // X radius

2434double _radiusY; // Y radius

2435double _xAxisRotation; // Rotation relative to X axis

2436bool _largeArcFlag; // Draw longer of the two matching arcs

2437bool _sweepFlag; // Draw arc matching clock-wise rotation

2438double _x; // End-point X

2439double _y; // End-point Y

2440 };

2441

2442 // Compare two PathArcArgs objects regardless of LHS/RHS

2443 extern MagickPPExport int operator ==( const PathArcArgs& left_,

2444const PathArcArgs& right_ );

2445 extern MagickPPExport int operator !=( const PathArcArgs& left_,

2446const PathArcArgs& right_ );

2447 extern MagickPPExport int operator >( const PathArcArgs& left_,

2448const PathArcArgs& right_ );

2449 extern MagickPPExport int operator <( const PathArcArgs& left_,

2450const PathArcArgs& right_ );

2451 extern MagickPPExport int operator >=( const PathArcArgs& left_,

2452const PathArcArgs& right_ );

2453 extern MagickPPExport int operator <=( const PathArcArgs& left_,

2454const PathArcArgs& right_ );

2455

2456 typedef std::vector<Magick::PathArcArgs> PathArcArgsList;

2457

2458 #if defined(MagickDLLExplicitTemplate)

2459

2460 MagickDrawableExtern template class MagickPPExport

2461 std::allocator<Magick::PathArcArgs>;

2462

2463 // MagickDrawableExtern template class MagickPPExport

2464 // std::vector<Magick::PathArcArgs, std::allocator<Magick::PathArcArgs> >;

2465

2466 #endif // MagickDLLExplicitTemplate

2467

2468 // Path Arc (Elliptical Arc)

2469 class MagickPPExport PathArcAbs : public VPathBase

2470 {

2471 public:

2472// Draw a single arc segment

2473PathArcAbs ( const PathArcArgs &coordinates_ );

2474

2475// Draw multiple arc segments

2476PathArcAbs ( const PathArcArgsList &coordinates_ );

2477

2478// Copy constructor

2479PathArcAbs ( const PathArcAbs& original_ );

2480

2481// Destructor

2482/*virtual*/ ~PathArcAbs ( void );

2483

2484// Operator to invoke equivalent draw API call

2485/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2486

2487// Return polymorphic copy of object

2488/*virtual*/ VPathBase* copy() const;

2489

2490 private:

2491PathArcArgsList _coordinates;

2492 };

2493 class MagickPPExport PathArcRel : public VPathBase

2494 {

2495 public:

2496// Draw a single arc segment

2497PathArcRel ( const PathArcArgs &coordinates_ );

2498

2499// Draw multiple arc segments

2500PathArcRel ( const PathArcArgsList &coordinates_ );

2501

2502PathArcRel ( const PathArcRel& original_ );

2503

2504/*virtual*/ ~PathArcRel ( void );

2505

2506// Operator to invoke equivalent draw API call

2507/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2508

2509// Return polymorphic copy of object

2510/*virtual*/ VPathBase* copy() const;

2511

2512 private:

2513PathArcArgsList _coordinates;

2514 };

2515

2516 // Path Closepath

2517 class MagickPPExport PathClosePath : public VPathBase

2518 {

2519 public:

2520 PathClosePath ( void )

2521 : _dummy(0)

2522 {

2523 }

2524

2525/*virtual*/ ~PathClosePath ( void );

2526

2527// Operator to invoke equivalent draw API call

2528/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2529

2530// Return polymorphic copy of object

2531/*virtual*/ VPathBase* copy() const;

2532

2533 private:

2534 ::ssize_t _dummy;

2535 };

2536

2537 //

2538 // Curveto (Cubic Bezier)

2539 //

2540 class MagickPPExport PathCurvetoArgs

2541 {

2542 public:

2543PathCurvetoArgs( void );

2544

2545PathCurvetoArgs( double x1_, double y1_,

2546double x2_, double y2_,

2547double x_, double y_ );

2548

2549PathCurvetoArgs( const PathCurvetoArgs &original_ );

2550

2551 ~PathCurvetoArgs ( void );

2552

2553void x1( double x1_ )

2554 {

2555 _x1 = x1_;

2556 }

2557 double x1( void ) const

2558 {

2559return _x1;

2560 }

2561

2562 void y1( double y1_ )

2563 {

2564 _y1 = y1_;

2565 }

2566 double y1( void ) const

2567 {

2568return _y1;

2569 }

2570

2571 void x2( double x2_ )

2572 {

2573 _x2 = x2_;

2574 }

2575 double x2( void ) const

2576 {

2577return _x2;

2578 }

2579

2580 void y2( double y2_ )

2581 {

2582 _y2 = y2_;

2583 }

2584 double y2( void ) const

2585 {

2586return _y2;

2587 }

2588

2589 void x( double x_ )

2590 {

2591 _x = x_;

2592 }

2593 double x( void ) const

2594 {

2595return _x;

2596 }

2597

2598 void y( double y_ )

2599 {

2600 _y = y_;

2601 }

2602 double y( void ) const

2603 {

2604return _y;

2605 }

2606

2607 private:

2608 double _x1;

2609 double _y1;

2610 double _x2;

2611 double _y2;

2612 double _x;

2613 double _y;

2614 };

2615

2616 // Compare two PathCurvetoArgs objects regardless of LHS/RHS

2617 extern MagickPPExport int operator ==( const PathCurvetoArgs& left_,

2618const PathCurvetoArgs& right_ );

2619 extern MagickPPExport int operator !=( const PathCurvetoArgs& left_,

2620const PathCurvetoArgs& right_ );

2621 extern MagickPPExport int operator >( const PathCurvetoArgs& left_,

2622const PathCurvetoArgs& right_ );

2623 extern MagickPPExport int operator <( const PathCurvetoArgs& left_,

2624const PathCurvetoArgs& right_ );

2625 extern MagickPPExport int operator >=( const PathCurvetoArgs& left_,

2626const PathCurvetoArgs& right_ );

2627 extern MagickPPExport int operator <=( const PathCurvetoArgs& left_,

2628const PathCurvetoArgs& right_ );

2629

2630 typedef std::vector<Magick::PathCurvetoArgs> PathCurveToArgsList;

2631

2632 #if defined(MagickDLLExplicitTemplate)

2633

2634 MagickDrawableExtern template class MagickPPExport

2635 std::allocator<Magick::PathCurvetoArgs>;

2636

2637 // MagickDrawableExtern template class MagickPPExport

2638 // std::vector<Magick::PathCurvetoArgs, std::allocator<Magick::PathCurvetoArgs> >;

2639

2640 #endif // MagickDLLExplicitTemplate

2641

2642 class MagickPPExport PathCurvetoAbs : public VPathBase

2643 {

2644 public:

2645// Draw a single curve

2646PathCurvetoAbs ( const PathCurvetoArgs &args_ );

2647

2648// Draw multiple curves

2649PathCurvetoAbs ( const PathCurveToArgsList &args_ );

2650

2651// Copy constructor

2652PathCurvetoAbs ( const PathCurvetoAbs& original_ );

2653

2654// Destructor

2655/*virtual*/ ~PathCurvetoAbs ( void );

2656

2657// Operator to invoke equivalent draw API call

2658/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2659

2660// Return polymorphic copy of object

2661/*virtual*/ VPathBase* copy() const;

2662

2663 private:

2664PathCurveToArgsList _args;

2665 };

2666 class MagickPPExport PathCurvetoRel : public VPathBase

2667 {

2668 public:

2669// Draw a single curve

2670PathCurvetoRel ( const PathCurvetoArgs &args_ );

2671

2672// Draw multiple curves

2673PathCurvetoRel ( const PathCurveToArgsList &args_ );

2674

2675// Copy constructor

2676PathCurvetoRel ( const PathCurvetoRel& original_ );

2677

2678/*virtual*/ ~PathCurvetoRel ( void );

2679

2680// Operator to invoke equivalent draw API call

2681/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2682

2683// Return polymorphic copy of object

2684/*virtual*/ VPathBase* copy() const;

2685

2686 private:

2687PathCurveToArgsList _args;

2688 };

2689 class MagickPPExport PathSmoothCurvetoAbs : public VPathBase

2690 {

2691 public:

2692// Draw a single curve

2693PathSmoothCurvetoAbs ( const Magick::Coordinate &coordinates_ );

2694

2695// Draw multiple curves

2696PathSmoothCurvetoAbs ( const CoordinateList &coordinates_ );

2697

2698// Copy constructor

2699PathSmoothCurvetoAbs ( const PathSmoothCurvetoAbs& original_ );

2700

2701/*virtual*/ ~PathSmoothCurvetoAbs ( void );

2702

2703// Operator to invoke equivalent draw API call

2704/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2705

2706// Return polymorphic copy of object

2707/*virtual*/

2708VPathBase* copy() const;

2709

2710 private:

2711CoordinateList _coordinates;

2712 };

2713 class MagickPPExport PathSmoothCurvetoRel : public VPathBase

2714 {

2715 public:

2716// Draw a single curve

2717PathSmoothCurvetoRel ( const Coordinate &coordinates_ );

2718

2719// Draw multiple curves

2720PathSmoothCurvetoRel ( const CoordinateList &coordinates_ );

2721

2722// Copy constructor

2723PathSmoothCurvetoRel ( const PathSmoothCurvetoRel& original_ );

2724

2725// Destructor

2726/*virtual*/ ~PathSmoothCurvetoRel ( void );

2727

2728// Operator to invoke equivalent draw API call

2729/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2730

2731// Return polymorphic copy of object

2732/*virtual*/

2733VPathBase* copy() const;

2734

2735 private:

2736CoordinateList _coordinates;

2737 };

2738

2739 //

2740 // Quadratic Curveto (Quadratic Bezier)

2741 //

2742 class MagickPPExport PathQuadraticCurvetoArgs

2743 {

2744 public:

2745PathQuadraticCurvetoArgs( void );

2746

2747PathQuadraticCurvetoArgs( double x1_, double y1_,

2748double x_, double y_ );

2749

2750PathQuadraticCurvetoArgs( const PathQuadraticCurvetoArgs &original_ );

2751

2752 ~PathQuadraticCurvetoArgs ( void );

2753

2754void x1( double x1_ )

2755 {

2756 _x1 = x1_;

2757 }

2758double x1( void ) const

2759 {

2760return _x1;

2761 }

2762

2763void y1( double y1_ )

2764 {

2765 _y1 = y1_;

2766 }

2767double y1( void ) const

2768 {

2769return _y1;

2770 }

2771

2772void x( double x_ )

2773 {

2774 _x = x_;

2775 }

2776double x( void ) const

2777 {

2778return _x;

2779 }

2780

2781void y( double y_ )

2782 {

2783 _y = y_;

2784 }

2785double y( void ) const

2786 {

2787return _y;

2788 }

2789

2790 private:

2791double _x1;

2792double _y1;

2793double _x;

2794double _y;

2795 };

2796

2797 // Compare two PathQuadraticCurvetoArgs objects regardless of LHS/RHS

2798 extern MagickPPExport int operator ==( const PathQuadraticCurvetoArgs& left_,

2799const PathQuadraticCurvetoArgs& right_ );

2800 extern MagickPPExport int operator !=( const PathQuadraticCurvetoArgs& left_,

2801const PathQuadraticCurvetoArgs& right_);

2802 extern MagickPPExport int operator >( const PathQuadraticCurvetoArgs& left_,

2803const PathQuadraticCurvetoArgs& right_);

2804 extern MagickPPExport int operator <( const PathQuadraticCurvetoArgs& left_,

2805const PathQuadraticCurvetoArgs& right_);

2806 extern MagickPPExport int operator >=( const PathQuadraticCurvetoArgs& left_,

2807const PathQuadraticCurvetoArgs& right_ );

2808 extern MagickPPExport int operator <=( const PathQuadraticCurvetoArgs& left_,

2809const PathQuadraticCurvetoArgs& right_ );

2810

2811 typedef std::vector<Magick::PathQuadraticCurvetoArgs> PathQuadraticCurvetoArgsList;

2812

2813 #if defined(MagickDLLExplicitTemplate)

2814

2815 MagickDrawableExtern template class MagickPPExport

2816 std::allocator<Magick::PathQuadraticCurvetoArgs>;

2817

2818 // MagickDrawableExtern template class MagickPPExport

2819 // std::vector<Magick::PathQuadraticCurvetoArgs, std::allocator<Magick::PathQuadraticCurvetoArgs> >;

2820

2821 #endif // MagickDLLExplicitTemplate

2822

2823 class MagickPPExport PathQuadraticCurvetoAbs : public VPathBase

2824 {

2825 public:

2826// Draw a single curve

2827PathQuadraticCurvetoAbs ( const Magick::PathQuadraticCurvetoArgs &args_ );

2828

2829// Draw multiple curves

2830PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoArgsList &args_ );

2831

2832// Copy constructor

2833PathQuadraticCurvetoAbs ( const PathQuadraticCurvetoAbs& original_ );

2834

2835// Destructor

2836/*virtual*/ ~PathQuadraticCurvetoAbs ( void );

2837

2838// Operator to invoke equivalent draw API call

2839/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2840

2841// Return polymorphic copy of object

2842/*virtual*/ VPathBase* copy() const;

2843

2844 private:

2845PathQuadraticCurvetoArgsList _args;

2846 };

2847 class MagickPPExport PathQuadraticCurvetoRel : public VPathBase

2848 {

2849 public:

2850// Draw a single curve

2851PathQuadraticCurvetoRel ( const Magick::PathQuadraticCurvetoArgs &args_ );

2852

2853// Draw multiple curves

2854PathQuadraticCurvetoRel ( const PathQuadraticCurvetoArgsList &args_ );

2855

2856// Copy constructor

2857PathQuadraticCurvetoRel ( const PathQuadraticCurvetoRel& original_ );

2858

2859// Destructor

2860/*virtual*/ ~PathQuadraticCurvetoRel ( void );

2861

2862// Operator to invoke equivalent draw API call

2863/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2864

2865// Return polymorphic copy of object

2866/*virtual*/ VPathBase* copy() const;

2867

2868 private:

2869PathQuadraticCurvetoArgsList _args;

2870 };

2871 class MagickPPExport PathSmoothQuadraticCurvetoAbs : public VPathBase

2872 {

2873 public:

2874// Draw a single curve

2875PathSmoothQuadraticCurvetoAbs ( const Magick::Coordinate &coordinate_ );

2876

2877// Draw multiple curves

2878PathSmoothQuadraticCurvetoAbs ( const CoordinateList &coordinates_ );

2879

2880// Copy constructor

2881PathSmoothQuadraticCurvetoAbs ( const PathSmoothQuadraticCurvetoAbs& original_ );

2882

2883// Destructor

2884/*virtual*/ ~PathSmoothQuadraticCurvetoAbs ( void );

2885

2886// Operator to invoke equivalent draw API call

2887/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2888

2889// Return polymorphic copy of object

2890/*virtual*/ VPathBase* copy() const;

2891

2892 private:

2893CoordinateList _coordinates;

2894 };

2895 class MagickPPExport PathSmoothQuadraticCurvetoRel : public VPathBase

2896 {

2897 public:

2898// Draw a single curve

2899PathSmoothQuadraticCurvetoRel ( const Magick::Coordinate &coordinate_ );

2900

2901// Draw multiple curves

2902PathSmoothQuadraticCurvetoRel ( const CoordinateList &coordinates_ );

2903

2904// Copy constructor

2905PathSmoothQuadraticCurvetoRel ( const PathSmoothQuadraticCurvetoRel& original_ );

2906

2907// Destructor

2908/*virtual*/ ~PathSmoothQuadraticCurvetoRel ( void );

2909

2910// Operator to invoke equivalent draw API call

2911/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2912

2913// Return polymorphic copy of object

2914/*virtual*/ VPathBase* copy() const;

2915

2916 private:

2917CoordinateList _coordinates;

2918 };

2919

2920 //

2921 // Path Lineto

2922 //

2923 class MagickPPExport PathLinetoAbs : public VPathBase

2924 {

2925 public:

2926// Draw to a single point

2927PathLinetoAbs ( const Magick::Coordinate& coordinate_ );

2928

2929// Draw to multiple points

2930PathLinetoAbs ( const CoordinateList &coordinates_ );

2931

2932// Copy constructor

2933PathLinetoAbs ( const PathLinetoAbs& original_ );

2934

2935// Destructor

2936/*virtual*/ ~PathLinetoAbs ( void );

2937

2938// Operator to invoke equivalent draw API call

2939/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2940

2941// Return polymorphic copy of object

2942/*virtual*/ VPathBase* copy() const;

2943

2944 private:

2945CoordinateList _coordinates;

2946 };

2947 class MagickPPExport PathLinetoRel : public VPathBase

2948 {

2949 public:

2950// Draw to a single point

2951PathLinetoRel ( const Magick::Coordinate& coordinate_ );

2952

2953// Draw to multiple points

2954PathLinetoRel ( const CoordinateList &coordinates_ );

2955

2956// Copy constructor

2957PathLinetoRel ( const PathLinetoRel& original_ );

2958

2959// Destructor

2960/*virtual*/ ~PathLinetoRel ( void );

2961

2962// Operator to invoke equivalent draw API call

2963/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2964

2965// Return polymorphic copy of object

2966/*virtual*/ VPathBase* copy() const;

2967

2968 private:

2969CoordinateList _coordinates;

2970 };

2971

2972 // Path Horizontal Lineto

2973 class MagickPPExport PathLinetoHorizontalAbs : public VPathBase

2974 {

2975 public:

2976 PathLinetoHorizontalAbs ( double x_ )

2977 : _x(x_)

2978 {

2979 }

2980

2981/*virtual*/ ~PathLinetoHorizontalAbs ( void );

2982

2983// Operator to invoke equivalent draw API call

2984/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

2985

2986// Return polymorphic copy of object

2987/*virtual*/ VPathBase* copy() const;

2988

2989void x( double x_ )

2990 {

2991 _x = x_;

2992 }

2993double x( void ) const

2994 {

2995return _x;

2996 }

2997

2998 private:

2999double _x;

3000 };

3001 class MagickPPExport PathLinetoHorizontalRel : public VPathBase

3002 {

3003 public:

3004 PathLinetoHorizontalRel ( double x_ )

3005 : _x(x_)

3006 {

3007 }

3008

3009/*virtual*/ ~PathLinetoHorizontalRel ( void );

3010

3011// Operator to invoke equivalent draw API call

3012/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

3013

3014// Return polymorphic copy of object

3015/*virtual*/ VPathBase* copy() const;

3016

3017void x( double x_ )

3018 {

3019 _x = x_;

3020 }

3021double x( void ) const

3022 {

3023return _x;

3024 }

3025

3026 private:

3027double _x;

3028 };

3029

3030 // Path Vertical Lineto

3031 class MagickPPExport PathLinetoVerticalAbs : public VPathBase

3032 {

3033 public:

3034 PathLinetoVerticalAbs ( double y_ )

3035 : _y(y_)

3036 {

3037 }

3038

3039/*virtual*/ ~PathLinetoVerticalAbs ( void );

3040

3041// Operator to invoke equivalent draw API call

3042/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

3043

3044// Return polymorphic copy of object

3045/*virtual*/ VPathBase* copy() const;

3046

3047void y( double y_ )

3048 {

3049 _y = y_;

3050 }

3051double y( void ) const

3052 {

3053return _y;

3054 }

3055

3056 private:

3057double _y;

3058 };

3059 class MagickPPExport PathLinetoVerticalRel : public VPathBase

3060 {

3061 public:

3062 PathLinetoVerticalRel ( double y_ )

3063 : _y(y_)

3064 {

3065 }

3066

3067/*virtual*/ ~PathLinetoVerticalRel ( void );

3068

3069// Operator to invoke equivalent draw API call

3070/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

3071

3072// Return polymorphic copy of object

3073/*virtual*/ VPathBase* copy() const;

3074

3075void y( double y_ )

3076 {

3077 _y = y_;

3078 }

3079double y( void ) const

3080 {

3081return _y;

3082 }

3083

3084 private:

3085double _y;

3086 };

3087

3088 // Path Moveto

3089 class MagickPPExport PathMovetoAbs : public VPathBase

3090 {

3091 public:

3092// Simple moveto

3093PathMovetoAbs ( const Magick::Coordinate &coordinate_ );

3094

3095// Moveto followed by implicit linetos

3096PathMovetoAbs ( const CoordinateList &coordinates_ );

3097

3098// Copy constructor

3099PathMovetoAbs ( const PathMovetoAbs& original_ );

3100

3101// Destructor

3102/*virtual*/ ~PathMovetoAbs ( void );

3103

3104// Operator to invoke equivalent draw API call

3105/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

3106

3107// Return polymorphic copy of object

3108/*virtual*/ VPathBase* copy() const;

3109

3110 private:

3111CoordinateList _coordinates;

3112 };

3113 class MagickPPExport PathMovetoRel : public VPathBase

3114 {

3115 public:

3116// Simple moveto

3117PathMovetoRel ( const Magick::Coordinate &coordinate_ );

3118

3119// Moveto followed by implicit linetos

3120PathMovetoRel ( const CoordinateList &coordinates_ );

3121

3122// Copy constructor

3123PathMovetoRel ( const PathMovetoRel& original_ );

3124

3125// Destructor

3126/*virtual*/ ~PathMovetoRel ( void );

3127

3128// Operator to invoke equivalent draw API call

3129/*virtual*/ void operator()( MagickCore::DrawingWand *context_ ) const;

3130

3131// Return polymorphic copy of object

3132/*virtual*/ VPathBase* copy() const;

3133

3134 private:

3135CoordinateList _coordinates;

3136 };

3137

3138 } // namespace Magick

3139

3140 #endif // Magick_Drawable_header

Magick::DrawableRectangle

Definition: Drawable.h:1401

Magick::DrawableRectangle::upperLeftY

void upperLeftY(double upperLeftY_)

Definition: Drawable.h:1429

Magick::DrawableDensity

Definition: Drawable.h:831

Magick::DrawableGravity::gravity

GravityType gravity(void) const

Definition: Drawable.h:1111

Magick::PathLinetoVerticalAbs::y

void y(double y_)

Definition: Drawable.h:3047

Magick::DrawableAlpha::paintMethod

PaintMethod paintMethod(void) const

Definition: Drawable.h:347

Magick::DrawableMiterLimit::miterlimit

size_t miterlimit(void) const

Definition: Drawable.h:1849

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::DrawableCompositeImage::composition

void composition(CompositeOperator composition_)

Definition: Drawable.h:766

Magick::DrawableLine::startX

double startX(void) const

Definition: Drawable.h:1144

Magick::DrawableCircle::originY

double originY(void) const

Definition: Drawable.h:639

Magick::PathLinetoVerticalRel::PathLinetoVerticalRel

PathLinetoVerticalRel(double y_)

Definition: Drawable.h:3062

Magick::PathArcArgs::xAxisRotation

double xAxisRotation(void) const

Definition: Drawable.h:2391

Magick::DrawableRoundRectangle::upperLeftY

void upperLeftY(double upperLeftY_)

Definition: Drawable.h:1564

Magick::DrawableAffine::sy

double sy(void) const

Definition: Drawable.h:257

Magick::DrawableCompositeImage::x

double x(void) const

Definition: Drawable.h:782

Magick::DrawableStrokeDashOffset::DrawableStrokeDashOffset

DrawableStrokeDashOffset(const double offset_)

Definition: Drawable.h:1752

Magick::DrawableAffine::ty

void ty(const double ty_)

Definition: Drawable.h:289

Magick::DrawableAffine::rx

double rx(void) const

Definition: Drawable.h:266

Magick::DrawableArc::endY

double endY(void) const

Definition: Drawable.h:413

Magick::DrawableText::x

void x(double x_)

Definition: Drawable.h:2025

Magick::DrawableRoundRectangle::centerX

void centerX(double centerX_)

Definition: Drawable.h:1517

Magick::DrawablePolyline

Definition: Drawable.h:1293

Magick::DrawableStrokeAntialias::DrawableStrokeAntialias

DrawableStrokeAntialias(bool flag_)

Definition: Drawable.h:1886

Magick::Coordinate::y

void y(double y_)

Definition: Drawable.h:65

Magick::DrawableRectangle::DrawableRectangle

DrawableRectangle(double upperLeftX_, double upperLeftY_, double lowerRightX_, double lowerRightY_)

Definition: Drawable.h:1404

Magick::PathCurvetoArgs::x2

void x2(double x2_)

Definition: Drawable.h:2571

Magick::PathCurveToArgsList

std::vector< Magick::PathCurvetoArgs > PathCurveToArgsList

Definition: Drawable.h:2630

Magick::PathQuadraticCurvetoArgs::y1

double y1(void) const

Definition: Drawable.h:2767

Magick::DrawableFillOpacity::opacity

double opacity(void) const

Definition: Drawable.h:1044

Magick::PathCurvetoArgs

Definition: Drawable.h:2540

Magick::DrawableRoundRectangle::lowerRightY

double lowerRightY(void) const

Definition: Drawable.h:1586

Magick::DrawableFont::font

void font(const std::string &font_)

Definition: Drawable.h:1073

Magick::PathLinetoHorizontalRel::PathLinetoHorizontalRel

PathLinetoHorizontalRel(double x_)

Definition: Drawable.h:3004

Magick::DrawablePoint::DrawablePoint

DrawablePoint(double x_, double y_)

Definition: Drawable.h:1207

Magick::DrawableClipUnits

Definition: Drawable.h:515

Magick::DrawablePoint::y

void y(double y_)

Definition: Drawable.h:1229

Magick::DrawableAlpha::paintMethod

void paintMethod(PaintMethod paintMethod_)

Definition: Drawable.h:342

Magick::DrawableRoundRectangle::DrawableRoundRectangle

DrawableRoundRectangle(double upperLeftX_, double upperLeftY_, double lowerRightX_, double lowerRightY_, double cornerWidth_, double cornerHeight_)

Definition: Drawable.h:1496

Magick::DrawableArc::startX

double startX(void) const

Definition: Drawable.h:386

Magick::DrawableEllipse::DrawableEllipse

DrawableEllipse(double originX_, double originY_, double radiusX_, double radiusY_, double arcStart_, double arcEnd_)

Definition: Drawable.h:853

Magick::DrawablePopGraphicContext::DrawablePopGraphicContext

DrawablePopGraphicContext(void)

Definition: Drawable.h:1316

Magick::DrawableAlpha::x

double x(void) const

Definition: Drawable.h:327

Magick::PathArcAbs

Definition: Drawable.h:2469

Magick::DrawableLine::endX

void endX(double endX_)

Definition: Drawable.h:1158

Magick::DrawablePoint::x

double x(void) const

Definition: Drawable.h:1224

Magick::DrawableCompositeImage::width

void width(double width_)

Definition: Drawable.h:796

Magick::Coordinate::Coordinate

Coordinate(double x_, double y_)

Definition: Drawable.h:56

Magick::DrawableText::x

double x(void) const

Definition: Drawable.h:2029

Magick::DrawableTranslation

Definition: Drawable.h:2251

Magick::PathQuadraticCurvetoArgs::x1

void x1(double x1_)

Definition: Drawable.h:2754

Magick::DrawableRectangle::upperLeftY

double upperLeftY(void) const

Definition: Drawable.h:1433

Magick::DrawableTextDecoration

Definition: Drawable.h:2113

Magick::Point

Definition: Geometry.h:208

Magick::DrawableRoundRectangle::upperLeftX

double upperLeftX(void) const

Definition: Drawable.h:1559

Magick::PathArcArgs::x

double x(void) const

Definition: Drawable.h:2418

Magick::DrawableStrokeLineJoin::linejoin

LineJoin linejoin(void) const

Definition: Drawable.h:1820

Magick::DrawableSkewY::angle

void angle(double angle_)

Definition: Drawable.h:1703

Magick::DrawableEllipse

Definition: Drawable.h:850

Magick::DrawableClipPath::clip_path

std::string clip_path(void) const

Definition: Drawable.h:596

Magick::DrawableFillRule::fillRule

FillRule fillRule(void) const

Definition: Drawable.h:1012

Magick::DrawableArc::startY

double startY(void) const

Definition: Drawable.h:395

Magick::DrawableScaling::y

double y(void) const

Definition: Drawable.h:1648

Magick::DrawablePointSize::pointSize

double pointSize(void) const

Definition: Drawable.h:1263

Magick::DrawableArc::DrawableArc

DrawableArc(double startX_, double startY_, double endX_, double endY_, double startDegrees_, double endDegrees_)

Definition: Drawable.h:363

Magick::PathQuadraticCurvetoArgsList

std::vector< Magick::PathQuadraticCurvetoArgs > PathQuadraticCurvetoArgsList

Definition: Drawable.h:2811

Magick::DrawableFillColor::color

void color(const Color &color_)

Definition: Drawable.h:951

Magick::DrawableStrokeOpacity

Definition: Drawable.h:1941

Magick::DrawablePointSize

Definition: Drawable.h:1244

Magick::PathLinetoHorizontalRel::x

double x(void) const

Definition: Drawable.h:3021

Magick::DrawableGravity

Definition: Drawable.h:1091

Magick::DrawableTranslation::y

double y(void) const

Definition: Drawable.h:2280

Magick::DrawableAffine::tx

void tx(const double tx_)

Definition: Drawable.h:280

Magick::Coordinate::y

double y(void) const

Definition: Drawable.h:66

Magick::PathClosePath::PathClosePath

PathClosePath(void)

Definition: Drawable.h:2520

Magick::DrawableTextUnderColor

Definition: Drawable.h:2222

Magick::DrawableStrokeLineJoin

Definition: Drawable.h:1801

Magick::DrawableSkewY

Definition: Drawable.h:1688

Magick::DrawableViewbox::DrawableViewbox

DrawableViewbox(::ssize_t x1_, ::ssize_t y1_, ::ssize_t x2_, ::ssize_t y2_)

Definition: Drawable.h:2294

Magick::DrawableFont

Definition: Drawable.h:1054

Magick::PathArcArgs::radiusY

double radiusY(void) const

Definition: Drawable.h:2382

Magick::DrawableTextUnderColor::color

Color color(void) const

Definition: Drawable.h:2241

Magick::DrawableViewbox::y2

void y2(::ssize_t y2_)

Definition: Drawable.h:2337

Magick::DrawableCircle::perimY

double perimY(void) const

Definition: Drawable.h:657

Magick::PathQuadraticCurvetoArgs::y

void y(double y_)

Definition: Drawable.h:2781

Magick::DrawableViewbox::y1

::ssize_t y1(void) const

Definition: Drawable.h:2323

Magick::DrawableStrokeDashArray

Definition: Drawable.h:1721

Magick::DrawableViewbox::x2

void x2(::ssize_t x2_)

Definition: Drawable.h:2328

Magick::PathQuadraticCurvetoArgs::x1

double x1(void) const

Definition: Drawable.h:2758

Magick::DrawableRoundRectangle::upperLeftX

void upperLeftX(double upperLeftX_)

Definition: Drawable.h:1555

Magick::DrawableEllipse::originY

double originY(void) const

Definition: Drawable.h:885

Magick::PathSmoothCurvetoRel

Definition: Drawable.h:2713

Magick::PathArcArgs::largeArcFlag

void largeArcFlag(bool largeArcFlag_)

Definition: Drawable.h:2396

Magick::PathSmoothCurvetoAbs

Definition: Drawable.h:2689

Magick::DrawableStrokeLineJoin::linejoin

void linejoin(LineJoin linejoin_)

Definition: Drawable.h:1816

Magick::PathLinetoHorizontalAbs::PathLinetoHorizontalAbs

PathLinetoHorizontalAbs(double x_)

Definition: Drawable.h:2976

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::PathLinetoVerticalRel::y

double y(void) const

Definition: Drawable.h:3079

Magick::DrawableTextDecoration::decoration

DecorationType decoration(void) const

Definition: Drawable.h:2132

Magick::Coordinate::Coordinate

Coordinate(void)

Definition: Drawable.h:52

Magick::PathSmoothQuadraticCurvetoRel

Definition: Drawable.h:2895

Magick::DrawableRoundRectangle::lowerRightX

double lowerRightX(void) const

Definition: Drawable.h:1577

Magick::DrawableLine

Definition: Drawable.h:1121

Magick::DrawableArc::startDegrees

void startDegrees(double startDegrees_)

Definition: Drawable.h:418

Magick::DrawableViewbox::y2

::ssize_t y2(void) const

Definition: Drawable.h:2341

Magick::DrawableCompositeImage::x

void x(double x_)

Definition: Drawable.h:778

Magick::DrawableLine::endY

void endY(double endY_)

Definition: Drawable.h:1167

Magick::PathLinetoHorizontalAbs::x

double x(void) const

Definition: Drawable.h:2993

Magick::DrawableStrokeOpacity::opacity

double opacity(void) const

Definition: Drawable.h:1963

Magick::Coordinate

Definition: Drawable.h:48

Magick::PathMovetoRel

Definition: Drawable.h:3113

Magick::DrawablePushGraphicContext::DrawablePushGraphicContext

DrawablePushGraphicContext(void)

Definition: Drawable.h:1337

Magick::PathSmoothQuadraticCurvetoAbs

Definition: Drawable.h:2871

Magick::DrawableEllipse::radiusX

double radiusX(void) const

Definition: Drawable.h:894

Magick::DrawableFillRule::fillRule

void fillRule(const FillRule fillRule_)

Definition: Drawable.h:1008

Magick::PathArcArgs::sweepFlag

void sweepFlag(bool sweepFlag_)

Definition: Drawable.h:2405

Magick::DrawableArc::endX

void endX(double endX_)

Definition: Drawable.h:400

Magick::PathQuadraticCurvetoRel

Definition: Drawable.h:2847

Magick::DrawableStrokeLineJoin::DrawableStrokeLineJoin

DrawableStrokeLineJoin(LineJoin linejoin_)

Definition: Drawable.h:1804

Magick::DrawableRoundRectangle::upperLeftY

double upperLeftY(void) const

Definition: Drawable.h:1568

Magick::DrawableTextUnderColor::color

void color(const Color &color_)

Definition: Drawable.h:2237

Magick::DrawableCompositeImage::y

void y(double y_)

Definition: Drawable.h:787

Magick::DrawableFillOpacity::opacity

void opacity(double opacity_)

Definition: Drawable.h:1039

Magick::DrawableEllipse::arcEnd

double arcEnd(void) const

Definition: Drawable.h:921

Magick::DrawableColor::x

double x(void) const

Definition: Drawable.h:692

Magick::PathCurvetoArgs::y1

void y1(double y1_)

Definition: Drawable.h:2562

Magick::DrawableCircle::perimY

void perimY(double perimY_)

Definition: Drawable.h:653

Magick::DrawableLine::startX

void startX(double startX_)

Definition: Drawable.h:1140

Magick::DrawablePoint::x

void x(double x_)

Definition: Drawable.h:1220

Magick::DrawableTextKerning

Definition: Drawable.h:2202

Magick::operator<=

MagickPPExport int operator<=(const Magick::Color &left_, const Magick::Color &right_)

Definition: Color.cpp:72

Magick::PathQuadraticCurvetoArgs::x

double x(void) const

Definition: Drawable.h:2776

Magick::PathArcArgs::xAxisRotation

void xAxisRotation(double xAxisRotation_)

Definition: Drawable.h:2387

Magick::operator>=

MagickPPExport int operator>=(const Magick::Color &left_, const Magick::Color &right_)

Definition: Color.cpp:66

Magick::DrawableTextDecoration::decoration

void decoration(DecorationType decoration_)

Definition: Drawable.h:2128

Magick::DrawableEllipse::radiusX

void radiusX(double radiusX_)

Definition: Drawable.h:890

Magick::DrawableColor::paintMethod

void paintMethod(PaintMethod paintMethod_)

Definition: Drawable.h:706

Magick::DrawableScaling::x

double x(void) const

Definition: Drawable.h:1639

Magick::PathLinetoHorizontalAbs::x

void x(double x_)

Definition: Drawable.h:2989

Magick::PathCurvetoArgs::x1

void x1(double x1_)

Definition: Drawable.h:2553

Magick::DrawableTranslation::DrawableTranslation

DrawableTranslation(double x_, double y_)

Definition: Drawable.h:2254

Magick::DrawableRectangle::lowerRightY

void lowerRightY(double lowerRightY_)

Definition: Drawable.h:1447

Magick::DrawableText::encoding

void encoding(const std::string &encoding_)

Definition: Drawable.h:2020

Magick::DrawableLine::startY

void startY(double startY_)

Definition: Drawable.h:1149

Magick::PathArcArgs::sweepFlag

bool sweepFlag(void) const

Definition: Drawable.h:2409

Magick::VPath

Definition: Drawable.h:184

Magick::DrawableScaling::x

void x(double x_)

Definition: Drawable.h:1635

Magick::DrawableGravity::gravity

void gravity(GravityType gravity_)

Definition: Drawable.h:1107

Magick::DrawableGravity::DrawableGravity

DrawableGravity(GravityType gravity_)

Definition: Drawable.h:1094

Magick::PathArcArgs

Definition: Drawable.h:2356

Magick::DrawableStrokeOpacity::DrawableStrokeOpacity

DrawableStrokeOpacity(double opacity_)

Definition: Drawable.h:1945

Magick::DrawableScaling::DrawableScaling

DrawableScaling(double x_, double y_)

Definition: Drawable.h:1622

Magick::DrawableFillOpacity

Definition: Drawable.h:1022

Magick::VPathBase::VPathBase

VPathBase(void)

Definition: Drawable.h:163

Magick::DrawableStrokeLineCap::linecap

LineCap linecap(void) const

Definition: Drawable.h:1791

Magick::DrawableCircle::perimX

double perimX(void) const

Definition: Drawable.h:648

Magick::Coordinate::~Coordinate

virtual ~Coordinate()

Definition: Drawable.h:60

Magick::PathLinetoVerticalAbs::PathLinetoVerticalAbs

PathLinetoVerticalAbs(double y_)

Definition: Drawable.h:3034

MagickPPExport

#define MagickPPExport

Definition: Include.h:297

Magick::VPathBase

Definition: Drawable.h:159

Magick::DrawableFillPatternUrl

Definition: Drawable.h:968

Magick::DrawableRectangle::lowerRightY

double lowerRightY(void) const

Definition: Drawable.h:1451

Magick::DrawableViewbox::x1

void x1(::ssize_t x1_)

Definition: Drawable.h:2310

Magick::DrawableSkewX::DrawableSkewX

DrawableSkewX(double angle_)

Definition: Drawable.h:1662

Magick::DrawableScaling

Definition: Drawable.h:1619

Magick::DrawableList

std::vector< Magick::Drawable > DrawableList

Definition: Drawable.h:146

Magick::Coordinate::x

double x(void) const

Definition: Drawable.h:63

Magick::DrawableStrokeDashOffset

Definition: Drawable.h:1749

Magick::DrawableRectangle::lowerRightX

double lowerRightX(void) const

Definition: Drawable.h:1442

Magick::DrawableEllipse::arcEnd

void arcEnd(double arcEnd_)

Definition: Drawable.h:917

Magick::DrawableTextAlignment

Definition: Drawable.h:2060

Magick::DrawableCircle::DrawableCircle

DrawableCircle(double originX_, double originY_, double perimX_, double perimY_)

Definition: Drawable.h:609

Magick::PathQuadraticCurvetoArgs

Definition: Drawable.h:2742

Magick::PathLinetoHorizontalRel::x

void x(double x_)

Definition: Drawable.h:3017

Magick::DrawableCircle::originX

void originX(double originX_)

Definition: Drawable.h:626

Magick::PathArcArgs::x

void x(double x_)

Definition: Drawable.h:2414

Magick::DrawableArc::endDegrees

double endDegrees(void) const

Definition: Drawable.h:431

Magick::DrawableColor::x

void x(double x_)

Definition: Drawable.h:688

Magick::DrawableMiterLimit::miterlimit

void miterlimit(size_t miterlimit_)

Definition: Drawable.h:1845

Magick::PathLinetoVerticalAbs

Definition: Drawable.h:3031

Magick::DrawableText::y

void y(double y_)

Definition: Drawable.h:2034

Magick::DrawableStrokeLineCap::DrawableStrokeLineCap

DrawableStrokeLineCap(LineCap linecap_)

Definition: Drawable.h:1775

Magick::PathQuadraticCurvetoArgs::x

void x(double x_)

Definition: Drawable.h:2772

Magick::DrawableClipRule

Definition: Drawable.h:493

Magick::DrawableAffine::sy

void sy(const double sy_)

Definition: Drawable.h:253

Magick::VPathList

std::vector< Magick::VPath > VPathList

Definition: Drawable.h:209

Magick::DrawableText

Definition: Drawable.h:2002

Magick::PathLinetoAbs

Definition: Drawable.h:2923

Magick::DrawableFont::font

std::string font(void) const

Definition: Drawable.h:1077

Magick::DrawableRoundRectangle::width

void width(double width_)

Definition: Drawable.h:1535

Magick::DrawableEllipse::originX

double originX(void) const

Definition: Drawable.h:876

Magick::DrawableStrokePatternUrl

Definition: Drawable.h:1859

Magick::PathQuadraticCurvetoArgs::y1

void y1(double y1_)

Definition: Drawable.h:2763

Magick::DrawableTranslation::x

void x(double x_)

Definition: Drawable.h:2267

Magick::Color

Definition: Color.h:36

Magick::DrawableAffine::sx

void sx(const double sx_)

Definition: Drawable.h:244

Magick::PathCurvetoArgs::y

double y(void) const

Definition: Drawable.h:2602

Magick::DrawableCompositeImage::height

double height(void) const

Definition: Drawable.h:809

Magick::DrawableArc::startX

void startX(double startX_)

Definition: Drawable.h:382

Magick::DrawablePopPattern

Definition: Drawable.h:1355

Magick::PathArcArgs::y

void y(double y_)

Definition: Drawable.h:2423

Magick::DrawableAffine

Definition: Drawable.h:226

Magick::PathCurvetoArgs::y1

double y1(void) const

Definition: Drawable.h:2566

Magick::DrawableLine::endY

double endY(void) const

Definition: Drawable.h:1171

Magick::DrawableEllipse::radiusY

void radiusY(double radiusY_)

Definition: Drawable.h:899

Magick::DrawableSkewY::DrawableSkewY

DrawableSkewY(double angle_)

Definition: Drawable.h:1691

Magick::DrawableColor

Definition: Drawable.h:670

Magick::PathLinetoHorizontalRel

Definition: Drawable.h:3001

Magick::DrawableTextAntialias::flag

bool flag(void) const

Definition: Drawable.h:2103

Magick::DrawableMiterLimit

Definition: Drawable.h:1830

Magick::DrawableArc::endY

void endY(double endY_)

Definition: Drawable.h:409

Magick::DrawableRoundRectangle::centerY

void centerY(double centerY_)

Definition: Drawable.h:1526

Magick::DrawableEllipse::originY

void originY(double originY_)

Definition: Drawable.h:881

Magick::DrawableCompositeImage::composition

CompositeOperator composition(void) const

Definition: Drawable.h:770

Magick::DrawableFillColor

Definition: Drawable.h:936

MagickDrawableExtern

#define MagickDrawableExtern

Definition: Drawable.h:40

Magick::DrawableAlpha::DrawableAlpha

DrawableAlpha(double x_, double y_, PaintMethod paintMethod_)

Definition: Drawable.h:307

Magick::DrawableRoundRectangle::hight

double hight(void) const

Definition: Drawable.h:1548

Magick::DrawableRotation

Definition: Drawable.h:1464

Magick::DrawableStrokeColor::color

void color(const Color &color_)

Definition: Drawable.h:1927

Magick::DrawableCircle

Definition: Drawable.h:606

Magick::DrawableTextAntialias

Definition: Drawable.h:2084

Magick::DrawableRoundRectangle::lowerRightY

void lowerRightY(double lowerRightY_)

Definition: Drawable.h:1582

Magick::DrawablePath

Definition: Drawable.h:1184

Magick::PathCurvetoArgs::x2

double x2(void) const

Definition: Drawable.h:2575

Magick::DrawableLine::DrawableLine

DrawableLine(double startX_, double startY_, double endX_, double endY_)

Definition: Drawable.h:1124

Magick::DrawableBezier

Definition: Drawable.h:446

Magick::DrawableStrokeLineCap

Definition: Drawable.h:1772

Magick::DrawableStrokeWidth::DrawableStrokeWidth

DrawableStrokeWidth(double width_)

Definition: Drawable.h:1976

Magick::DrawableStrokeLineCap::linecap

void linecap(LineCap linecap_)

Definition: Drawable.h:1787

Magick::DrawablePopClipPath

Definition: Drawable.h:537

Magick::DrawableRoundRectangle::cornerHeight

double cornerHeight(void) const

Definition: Drawable.h:1604

Magick::DrawableAffine::ty

double ty(void) const

Definition: Drawable.h:293

Magick::DrawableCompositeImage::height

void height(double height_)

Definition: Drawable.h:805

Magick::DrawableAffine::rx

void rx(const double rx_)

Definition: Drawable.h:262

Magick::DrawableAlpha::y

double y(void) const

Definition: Drawable.h:337

Magick::PathQuadraticCurvetoAbs

Definition: Drawable.h:2823

Magick::DrawableTextInterwordSpacing

Definition: Drawable.h:2182

Color.h

Magick::PathMovetoAbs

Definition: Drawable.h:3089

Magick::DrawableClipPath

Definition: Drawable.h:578

Magick::DrawableText::text

void text(const std::string &text_)

Definition: Drawable.h:2043

Magick::DrawableRotation::DrawableRotation

DrawableRotation(double angle_)

Definition: Drawable.h:1467

Magick::DrawableLine::endX

double endX(void) const

Definition: Drawable.h:1162

Magick::DrawableStrokeAntialias

Definition: Drawable.h:1883

Magick::PathCurvetoArgs::x

double x(void) const

Definition: Drawable.h:2593

Magick::PathLinetoRel

Definition: Drawable.h:2947

Magick::DrawableCompositeImage

Definition: Drawable.h:723

Include.h

Magick::DrawableStrokeAntialias::flag

bool flag(void) const

Definition: Drawable.h:1902

Magick::DrawableColor::y

double y(void) const

Definition: Drawable.h:701

Magick::PathArcArgsList

std::vector< Magick::PathArcArgs > PathArcArgsList

Definition: Drawable.h:2456

Magick::DrawableArc::endDegrees

void endDegrees(double endDegrees_)

Definition: Drawable.h:427

Magick::DrawableStrokeWidth::width

void width(double width_)

Definition: Drawable.h:1988

Magick::DrawableMiterLimit::DrawableMiterLimit

DrawableMiterLimit(size_t miterlimit_)

Definition: Drawable.h:1833

Magick::DrawableRectangle::upperLeftX

double upperLeftX(void) const

Definition: Drawable.h:1424

Magick::PathArcArgs::radiusX

void radiusX(double radiusX_)

Definition: Drawable.h:2369

Magick::DrawableRoundRectangle

Definition: Drawable.h:1493

Magick::DrawablePoint

Definition: Drawable.h:1204

Magick::DrawableSkewX::angle

void angle(double angle_)

Definition: Drawable.h:1674

Magick::DrawablePopClipPath::DrawablePopClipPath

DrawablePopClipPath(void)

Definition: Drawable.h:540

Magick::DrawableRoundRectangle::cornerWidth

double cornerWidth(void) const

Definition: Drawable.h:1595

Magick::DrawableRoundRectangle::width

double width(void) const

Definition: Drawable.h:1539

Magick::DrawableArc::startY

void startY(double startY_)

Definition: Drawable.h:391

Magick::DrawableTextDirection

Definition: Drawable.h:2142

Magick::DrawableRotation::angle

double angle(void) const

Definition: Drawable.h:1483

Magick::DrawableCompositeImage::width

double width(void) const

Definition: Drawable.h:800

Magick::DrawableScaling::y

void y(double y_)

Definition: Drawable.h:1644

Magick::DrawableLine::startY

double startY(void) const

Definition: Drawable.h:1153

Magick::DrawableCircle::originX

double originX(void) const

Definition: Drawable.h:630

Magick::DrawableAffine::tx

double tx(void) const

Definition: Drawable.h:284

Magick::DrawableViewbox::x1

::ssize_t x1(void) const

Definition: Drawable.h:2314

Magick::DrawableColor::y

void y(double y_)

Definition: Drawable.h:697

Magick::DrawableStrokeWidth::width

double width(void) const

Definition: Drawable.h:1992

Magick::PathLinetoVerticalRel::y

void y(double y_)

Definition: Drawable.h:3075

Magick::DrawableAffine::ry

double ry(void) const

Definition: Drawable.h:275

Magick::DrawableRoundRectangle::cornerHeight

void cornerHeight(double cornerHeight_)

Definition: Drawable.h:1600

Magick::DrawablePointSize::DrawablePointSize

DrawablePointSize(double pointSize_)

Definition: Drawable.h:1247

Magick::Drawable

Definition: Drawable.h:120

Magick::DrawableCircle::perimX

void perimX(double perimX_)

Definition: Drawable.h:644

Magick::DrawableStrokeWidth

Definition: Drawable.h:1973

Magick::DrawableRoundRectangle::cornerWidth

void cornerWidth(double cornerWidth_)

Definition: Drawable.h:1591

Magick::DrawableAffine::ry

void ry(const double ry_)

Definition: Drawable.h:271

Magick::DrawableArc::endX

double endX(void) const

Definition: Drawable.h:404

Magick::Coordinate::x

void x(double x_)

Definition: Drawable.h:62

Magick::DrawableViewbox::x2

::ssize_t x2(void) const

Definition: Drawable.h:2332

Magick::DrawablePushGraphicContext

Definition: Drawable.h:1334

Magick::operator>

MagickPPExport int operator>(const Magick::Color &left_, const Magick::Color &right_)

Definition: Color.cpp:44

Magick::PathQuadraticCurvetoArgs::y

double y(void) const

Definition: Drawable.h:2785

Magick::DrawableSkewX::angle

double angle(void) const

Definition: Drawable.h:1678

Magick::DrawableClipPath::clip_path

void clip_path(const std::string &id_)

Definition: Drawable.h:592

Magick::operator==

MagickPPExport int operator==(const Magick::Color &left_, const Magick::Color &right_)

Definition: Color.cpp:22

Magick::Image

class MagickPPExport Image

Definition: Drawable.h:722

Magick::DrawablePointSize::pointSize

void pointSize(double pointSize_)

Definition: Drawable.h:1259

Magick::DrawableEllipse::arcStart

double arcStart(void) const

Definition: Drawable.h:912

Magick::DrawableText::y

double y(void) const

Definition: Drawable.h:2038

Magick::PathCurvetoRel

Definition: Drawable.h:2666

Magick::DrawableRoundRectangle::lowerRightX

void lowerRightX(double lowerRightX_)

Definition: Drawable.h:1573

Magick::PathCurvetoArgs::y2

double y2(void) const

Definition: Drawable.h:2584

Magick::DrawableBase

Definition: Drawable.h:99

Magick::DrawableColor::paintMethod

PaintMethod paintMethod(void) const

Definition: Drawable.h:710

Magick::DrawableEllipse::originX

void originX(double originX_)

Definition: Drawable.h:872

Magick

Definition: Blob.h:17

Magick::DrawableRoundRectangle::centerY

double centerY(void) const

Definition: Drawable.h:1530

Magick::PathLinetoVerticalAbs::y

double y(void) const

Definition: Drawable.h:3051

Magick::DrawablePushPattern

Definition: Drawable.h:1376

Magick::DrawablePopPattern::DrawablePopPattern

DrawablePopPattern(void)

Definition: Drawable.h:1358

Magick::DrawableSkewX

Definition: Drawable.h:1659

Magick::DrawableArc

Definition: Drawable.h:360

Magick::DrawableViewbox::y1

void y1(::ssize_t y1_)

Definition: Drawable.h:2319

Magick::DrawableFillOpacity::DrawableFillOpacity

DrawableFillOpacity(double opacity_)

Definition: Drawable.h:1026

Magick::DrawablePopGraphicContext

Definition: Drawable.h:1313

Magick::DrawableStrokeColor

Definition: Drawable.h:1912

Magick::PathArcArgs::y

double y(void) const

Definition: Drawable.h:2427

Magick::DrawableTranslation::y

void y(double y_)

Definition: Drawable.h:2276

Magick::PathLinetoVerticalRel

Definition: Drawable.h:3059

Magick::DrawableAffine::sx

double sx(void) const

Definition: Drawable.h:248

Magick::DrawableEllipse::arcStart

void arcStart(double arcStart_)

Definition: Drawable.h:908

Magick::CoordinateList

std::vector< Magick::Coordinate > CoordinateList

Definition: Drawable.h:73

Magick::PathCurvetoArgs::x1

double x1(void) const

Definition: Drawable.h:2557

Magick::DrawableRotation::angle

void angle(double angle_)

Definition: Drawable.h:1479

Magick::DrawableAlpha::y

void y(double y_)

Definition: Drawable.h:332

Magick::DrawableTextAntialias::flag

void flag(bool flag_)

Definition: Drawable.h:2099

Magick::DrawableTranslation::x

double x(void) const

Definition: Drawable.h:2271

Magick::PathArcArgs::radiusX

double radiusX(void) const

Definition: Drawable.h:2373

Magick::DrawableRoundRectangle::hight

void hight(double hight_)

Definition: Drawable.h:1544

Magick::DrawableCompositeImage::y

double y(void) const

Definition: Drawable.h:791

Magick::PathArcRel

Definition: Drawable.h:2493

Magick::DrawableRectangle::lowerRightX

void lowerRightX(double lowerRightX_)

Definition: Drawable.h:1438

Magick::DrawablePolygon

Definition: Drawable.h:1273

Magick::DrawableStrokeColor::color

Color color(void) const

Definition: Drawable.h:1931

Magick::DrawableArc::startDegrees

double startDegrees(void) const

Definition: Drawable.h:422

Magick::Image

Definition: Image.h:55

Magick::DrawablePushClipPath

Definition: Drawable.h:558

Magick::DrawableStrokeOpacity::opacity

void opacity(double opacity_)

Definition: Drawable.h:1958

Magick::PathCurvetoArgs::x

void x(double x_)

Definition: Drawable.h:2589

Magick::DrawableFillRule::DrawableFillRule

DrawableFillRule(const FillRule fillRule_)

Definition: Drawable.h:995

Magick::PathArcArgs::largeArcFlag

bool largeArcFlag(void) const

Definition: Drawable.h:2400

Magick::PathCurvetoArgs::y

void y(double y_)

Definition: Drawable.h:2598

Magick::DrawableRoundRectangle::centerX

double centerX(void) const

Definition: Drawable.h:1521

Magick::DrawableBorderColor

Definition: Drawable.h:469

Magick::DrawableColor::DrawableColor

DrawableColor(double x_, double y_, PaintMethod paintMethod_)

Definition: Drawable.h:673

Magick::DrawableViewbox

Definition: Drawable.h:2291

Geometry.h

Magick::DrawableStrokeAntialias::flag

void flag(bool flag_)

Definition: Drawable.h:1898

Magick::DrawableText::text

std::string text(void) const

Definition: Drawable.h:2047

Magick::DrawableSkewY::angle

double angle(void) const

Definition: Drawable.h:1707

Magick::PathCurvetoArgs::y2

void y2(double y2_)

Definition: Drawable.h:2580

Magick::DrawablePoint::y

double y(void) const

Definition: Drawable.h:1233

Magick::PathArcArgs::radiusY

void radiusY(double radiusY_)

Definition: Drawable.h:2378

Magick::DrawableCircle::originY

void originY(double originY_)

Definition: Drawable.h:635

Magick::DrawableRectangle::upperLeftX

void upperLeftX(double upperLeftX_)

Definition: Drawable.h:1420

Magick::DrawableAlpha::x

void x(double x_)

Definition: Drawable.h:322

Magick::DrawableFillColor::color

Color color(void) const

Definition: Drawable.h:955

Magick::DrawableEllipse::radiusY

double radiusY(void) const

Definition: Drawable.h:903

Magick::PathLinetoHorizontalAbs

Definition: Drawable.h:2973

Magick::DrawableAlpha

Definition: Drawable.h:303