interface/wx/graphics.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        graphics.h
   3 // Purpose:     interface of wxGraphicsPath
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows license
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 /**
  10     @class wxGraphicsPath
  11
  12     A wxGraphicsPath is a native representation of an geometric path. The contents
  13     are specific an private to the respective renderer. Instances are ref counted and can
  14     therefore be assigned as usual. The only way to get a valid instance is via
  15     wxGraphicsContext::CreatePath or wxGraphicsRenderer::CreatePath.
  16
  17     @library{wxcore}
  18     @category{FIXME}
  19 */
  20 class wxGraphicsPath : public wxGraphicsObject
  21 {
  22 public:
  23     //@{
  24     /**
  25
  26     */
  27     void AddArc(wxDouble x, wxDouble y, wxDouble r,
  28                 wxDouble startAngle,
  29                 wxDouble endAngle, bool clockwise);
  30     void AddArc(const wxPoint2DDouble& c, wxDouble r,
  31                 wxDouble startAngle,
  32                 wxDouble endAngle,
  33                 bool clockwise);
  34     //@}
  35
  36     /**
  37         Appends a an arc to two tangents connecting (current) to (x1,y1) and (x1,y1) to
  38         (x2,y2), also a straight line from (current) to (x1,y1).
  39     */
  40     virtual void AddArcToPoint(wxDouble x1, wxDouble y1, wxDouble x2,
  41                                wxDouble y2, wxDouble r);
  42
  43     /**
  44         Appends a circle around (x,y) with radius r as a new closed subpath.
  45     */
  46     virtual void AddCircle(wxDouble x, wxDouble y, wxDouble r);
  47
  48     //@{
  49     /**
  50
  51     */
  52     void AddCurveToPoint(wxDouble cx1, wxDouble cy1, wxDouble cx2,
  53                          wxDouble cy2,
  54                          wxDouble x,
  55                          wxDouble y);
  56     void AddCurveToPoint(const wxPoint2DDouble& c1,
  57                          const wxPoint2DDouble& c2,
  58                          const wxPoint2DDouble& e);
  59     //@}
  60
  61     /**
  62         Appends an ellipse fitting into the passed in rectangle.
  63     */
  64     virtual void AddEllipse(wxDouble x, wxDouble y, wxDouble w, wxDouble h);
  65
  66     //@{
  67     /**
  68
  69     */
  70     void AddLineToPoint(wxDouble x, wxDouble y);
  71     void AddLineToPoint(const wxPoint2DDouble& p);
  72     //@}
  73
  74     /**
  75         Adds another path.
  76     */
  77     virtual void AddPath(const wxGraphicsPath& path);
  78
  79     /**
  80         Adds a quadratic Bezier curve from the current point, using a control point and
  81         an end point.
  82     */
  83     void AddQuadCurveToPoint(wxDouble cx, wxDouble cy, wxDouble x,
  84                              wxDouble y);
  85
  86     /**
  87         Appends a rectangle as a new closed subpath.
  88     */
  89     virtual void AddRectangle(wxDouble x, wxDouble y, wxDouble w, wxDouble h);
  90
  91     /**
  92         Appends a rounded rectangle as a new closed subpath.
  93     */
  94     virtual void AddRoundedRectangle(wxDouble x, wxDouble y, wxDouble w,
  95                                      wxDouble h, wxDouble radius);
  96
  97     /**
  98         Closes the current sub-path.
  99     */
 100     virtual void CloseSubpath();
 101
 102     //@{
 103     /**
 104         Returns @true if the point is within the path.
 105     */
 106     bool Contains(const wxPoint2DDouble& c,
 107                   int fillStyle = wxODDEVEN_RULE) const;
 108     const bool Contains(wxDouble x, wxDouble y,
 109                         int fillStyle = wxODDEVEN_RULE) const;
 110     //@}
 111
 112     //@{
 113     /**
 114         Gets the bounding box enclosing all points (possibly including control points).
 115     */
 116     wxRect2DDouble GetBox() const;
 117     const void GetBox(wxDouble* x, wxDouble* y, wxDouble* w,
 118                       wxDouble* h) const;
 119     //@}
 120
 121     //@{
 122     /**
 123         Gets the last point of the current path, (0,0) if not yet set.
 124     */
 125     void GetCurrentPoint(wxDouble* x, wxDouble* y) const;
 126     const wxPoint2DDouble GetCurrentPoint() const;
 127     //@}
 128
 129     /**
 130         Returns the native path (CGPathRef for Core Graphics, Path pointer for GDIPlus
 131         and a cairo_path_t pointer for cairo).
 132     */
 133     virtual void* GetNativePath() const;
 134
 135     //@{
 136     /**
 137         Begins a new subpath at (x,y)
 138     */
 139     void MoveToPoint(wxDouble x, wxDouble y);
 140     void MoveToPoint(const wxPoint2DDouble& p);
 141     //@}
 142
 143     /**
 144         Transforms each point of this path by the matrix.
 145     */
 146     virtual void Transform(const wxGraphicsMatrix& matrix);
 147
 148     /**
 149         Gives back the native path returned by GetNativePath() because there might be
 150         some deallocations necessary (eg on cairo the native path returned by
 151         GetNativePath is newly allocated each time).
 152     */
 153     virtual void UnGetNativePath(void* p) const;
 154 };
 155
 156
 157
 158 /**
 159     @class wxGraphicsObject
 160
 161     This class is the superclass of native graphics objects like pens etc. It
 162     allows reference counting. Not instantiated by user code.
 163
 164     @library{wxcore}
 165     @category{FIXME}
 166
 167     @see wxGraphicsBrush, wxGraphicsPen, wxGraphicsMatrix, wxGraphicsPath
 168 */
 169 class wxGraphicsObject : public wxObject
 170 {
 171 public:
 172     /**
 173         Returns the renderer that was used to create this instance, or @NULL if it has
 174         not been initialized yet
 175     */
 176     wxGraphicsRenderer* GetRenderer() const;
 177
 178     /**
 179         Is this object valid (@false) or still empty (@true)?
 180     */
 181     bool IsNull() const;
 182 };
 183
 184
 185
 186 /**
 187     @class wxGraphicsContext
 188
 189     A wxGraphicsContext instance is the object that is drawn upon. It is created by
 190     a renderer using wxGraphicsRenderer::CreateContext(). This can be either directly
 191     using a renderer instance, or indirectly using the static convenience Create()
 192     functions of wxGraphicsContext that always delegate the task to the default renderer.
 193
 194     @code
 195     void MyCanvas::OnPaint(wxPaintEvent &event)
 196     {
 197         // Create paint DC
 198         wxPaintDC dc(this);
 199
 200         // Create graphics context from it
 201         wxGraphicsContext *gc = wxGraphicsContext::Create( dc );
 202
 203         if (gc)
 204         {
 205             // make a path that contains a circle and some lines
 206             gc->SetPen( *wxRED_PEN );
 207             wxGraphicsPath path = gc->CreatePath();
 208             path.AddCircle( 50.0, 50.0, 50.0 );
 209             path.MoveToPoint(0.0, 50.0);
 210             path.AddLineToPoint(100.0, 50.0);
 211             path.MoveToPoint(50.0, 0.0);
 212             path.AddLineToPoint(50.0, 100.0 );
 213             path.CloseSubpath();
 214             path.AddRectangle(25.0, 25.0, 50.0, 50.0);
 215
 216             gc->StrokePath(path);
 217
 218             delete gc;
 219         }
 220     }
 221     @endcode
 222
 223
 224     @library{wxcore}
 225     @category{FIXME}
 226
 227     @see wxGraphicsRenderer::CreateContext(), wxGCDC, wxDC
 228 */
 229 class wxGraphicsContext : public wxGraphicsObject
 230 {
 231 public:
 232     /**
 233         Creates a wxGraphicsContext from a wxWindow.
 234
 235         @see wxGraphicsRenderer::CreateContext()
 236     */
 237     static wxGraphicsContext* Create( wxWindow* window ) ;
 238
 239     /**
 240         Creates a wxGraphicsContext from a wxWindowDC
 241
 242         @see wxGraphicsRenderer::CreateContext()
 243     */
 244     static wxGraphicsContext* Create( const wxWindowDC& dc) ;
 245
 246     /**
 247         Creates a wxGraphicsContext from a wxMemoryDC
 248
 249         @see wxGraphicsRenderer::CreateContext()
 250     */
 251     static wxGraphicsContext * Create( const wxMemoryDC& dc) ;
 252
 253     /**
 254         Creates a wxGraphicsContext from a wxPrinterDC. Under
 255         GTK+, this will only work when using the GtkPrint
 256         printing backend which is available since GTK+ 2.10.
 257
 258         @see wxGraphicsRenderer::CreateContext(), @ref overview_unixprinting "Printing under Unix"
 259     */
 260     static wxGraphicsContext * Create( const wxPrinterDC& dc) ;
 261
 262     /**
 263         Clips drawings to the region
 264     */
 265     virtual void Clip(const wxRegion& region) = 0;
 266
 267     /**
 268         Clips drawings to the rectangle.
 269     */
 270     virtual void Clip(wxDouble x, wxDouble y, wxDouble w, wxDouble h) = 0;
 271
 272     /**
 273         Concatenates the passed in transform with the current transform of this context
 274     */
 275     virtual void ConcatTransform(const wxGraphicsMatrix& matrix) = 0;
 276
 277
 278     /**
 279         Creates a native brush from a wxBrush.
 280     */
 281     virtual wxGraphicsBrush CreateBrush(const wxBrush& brush) const;
 282
 283     /**
 284         Creates a native graphics font from a wxFont and a text colour.
 285     */
 286     wxGraphicsFont CreateFont(const wxFont& font,
 287                               const wxColour& col = wxBLACK) const;
 288
 289     /**
 290         Creates a wxGraphicsContext from a native context. This native context must be
 291         eg a CGContextRef for Core Graphics, a Graphics pointer for GDIPlus or a
 292         cairo_t pointer for cairo.
 293
 294         @see wxGraphicsRenderer:: CreateContextFromNativeContext
 295     */
 296     static wxGraphicsContext* CreateFromNative(void* context);
 297
 298     /**
 299         Creates a wxGraphicsContext from a native window.
 300
 301         @see wxGraphicsRenderer:: CreateContextFromNativeWindow
 302     */
 303     static wxGraphicsContext* CreateFromNativeWindow(void* window);
 304
 305     /**
 306         Creates a native brush, having a linear gradient, starting at (x1,y1) with
 307         color c1 to (x2,y2) with color c2
 308     */
 309     wxGraphicsBrush CreateLinearGradientBrush(wxDouble x1,
 310             wxDouble y1,
 311             wxDouble x2,
 312             wxDouble y2,
 313             const wxColouramp;c1,
 314             const wxColouramp;c2) const;
 315
 316     /**
 317         Creates a native affine transformation matrix from the passed in values. The
 318         defaults result in an identity matrix.
 319     */
 320     wxGraphicsMatrix CreateMatrix(wxDouble a = 1.0, wxDouble b = 0.0,
 321                                   wxDouble c = 0.0,
 322                                   wxDouble d = 1.0,
 323                                   wxDouble tx = 0.0,
 324                                   wxDouble ty = 0.0) const;
 325
 326     /**
 327         Creates a native graphics path which is initially empty.
 328     */
 329     wxGraphicsPath CreatePath() const;
 330
 331     /**
 332         Creates a native pen from a wxPen.
 333     */
 334     virtual wxGraphicsPen CreatePen(const wxPen& pen) const;
 335
 336     /**
 337         Creates a native brush, having a radial gradient originating at (xo,yc) with
 338         color oColour and ends on a circle around (xc,yc) with radius r and color cColour
 339     */
 340     virtual wxGraphicsBrush CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 341                                                       wxDouble xc, wxDouble yc,
 342                                                       wxDouble radius,
 343                                                       const wxColour& oColor,
 344                                                       const wxColour& cColor) const;
 345
 346     /**
 347         Draws the bitmap. In case of a mono bitmap, this is treated as a mask and the
 348         current brushed is used for filling.
 349     */
 350     void DrawBitmap(const wxBitmap& bmp, wxDouble x, wxDouble y,
 351                     wxDouble w, wxDouble h);
 352
 353     /**
 354         Draws an ellipse.
 355     */
 356     virtual void DrawEllipse(wxDouble x, wxDouble y, wxDouble w, wxDouble h);
 357
 358     /**
 359         Draws the icon.
 360     */
 361     void DrawIcon(const wxIcon& icon, wxDouble x, wxDouble y,
 362                   wxDouble w, wxDouble h);
 363
 364     /**
 365         Draws a polygon.
 366     */
 367     void DrawLines(size_t n, const wxPoint2DDouble* points,
 368                    int fillStyle = wxODDEVEN_RULE);
 369
 370     /**
 371         Draws the path by first filling and then stroking.
 372     */
 373     void DrawPath(const wxGraphicsPath& path,
 374                   int fillStyle = wxODDEVEN_RULE);
 375
 376     /**
 377         Draws a rectangle.
 378     */
 379     void DrawRectangle(wxDouble x, wxDouble y, wxDouble w,
 380                        wxDouble h);
 381
 382     /**
 383         Draws a rounded rectangle.
 384     */
 385     virtual void DrawRoundedRectangle(wxDouble x, wxDouble y, wxDouble w,
 386                                       wxDouble h, wxDouble radius);
 387
 388     //@{
 389     /**
 390         Draws a text at the defined position, at the given angle.
 391     */
 392     void DrawText(const wxString& str, wxDouble x, wxDouble y,
 393                   wxDouble angle);
 394     void DrawText(const wxString& str, wxDouble x, wxDouble y);
 395     //@}
 396
 397     /**
 398         Fills the path with the current brush.
 399     */
 400     void FillPath(const wxGraphicsPath& path,
 401                   int fillStyle = wxODDEVEN_RULE);
 402
 403     /**
 404         Returns the native context (CGContextRef for Core Graphics, Graphics pointer
 405         for GDIPlus and cairo_t pointer for cairo).
 406     */
 407     virtual void* GetNativeContext() = 0;
 408
 409     /**
 410         Fills the @a widths array with the widths from the beginning of
 411         @a text to the corresponding character of @e text.
 412     */
 413     void GetPartialTextExtents(const wxString& text,
 414                                wxArrayDouble& widths) const;
 415
 416     /**
 417         Gets the dimensions of the string using the currently selected font.
 418         @e string is the text string to measure, @e w and @e h are
 419         the total width and height respectively, @a descent is the
 420         dimension from the baseline of the font to the bottom of the
 421         descender, and @a externalLeading is any extra vertical space added
 422         to the font by the font designer (usually is zero).
 423     */
 424     virtual void GetTextExtent(const wxString& text, wxDouble* width,
 425                                wxDouble* height, wxDouble* descent,
 426                                wxDouble* externalLeading) const = 0;
 427
 428     /**
 429         Gets the current transformation matrix of this context.
 430     */
 431     virtual wxGraphicsMatrix GetTransform() const = 0;
 432
 433     /**
 434         Resets the clipping to original shape.
 435     */
 436     virtual void ResetClip() = 0;
 437
 438     /**
 439         Rotates the current transformation matrix (radians),
 440     */
 441     virtual void Rotate(wxDouble angle) = 0;
 442
 443     /**
 444         Scales the current transformation matrix.
 445     */
 446     virtual void Scale(wxDouble xScale, wxDouble yScale) = 0;
 447
 448     //@{
 449     /**
 450         Sets the brush for filling paths.
 451     */
 452     void SetBrush(const wxBrush& brush);
 453     void SetBrush(const wxGraphicsBrush& brush);
 454     //@}
 455
 456     //@{
 457     /**
 458         Sets the font for drawing text.
 459     */
 460     void SetFont(const wxFont& font, const wxColour& colour);
 461     void SetFont(const wxGraphicsFont& font);
 462     //@}
 463
 464     //@{
 465     /**
 466         Sets the pen used for stroking.
 467     */
 468     void SetPen(const wxGraphicsPen& pen);
 469     void SetPen(const wxPen& pen);
 470     //@}
 471
 472     /**
 473         Sets the current transformation matrix of this context
 474     */
 475     virtual void SetTransform(const wxGraphicsMatrix& matrix) = 0;
 476
 477     /**
 478         Strokes a single line.
 479     */
 480     void StrokeLine(wxDouble x1, wxDouble y1, wxDouble x2,
 481                     wxDouble y2);
 482
 483     //@{
 484     /**
 485         Stroke disconnected lines from begin to end points, fastest method available
 486         for this purpose.
 487     */
 488     void StrokeLines(size_t n, const wxPoint2DDouble* beginPoints,
 489                      const wxPoint2DDouble* endPoints);
 490     void StrokeLines(size_t n, const wxPoint2DDouble* points);
 491     //@}
 492
 493     /**
 494         Strokes along a path with the current pen.
 495     */
 496     virtual void StrokePath(const wxGraphicsPath& path) = 0;
 497
 498     /**
 499         Translates the current transformation matrix.
 500     */
 501     virtual void Translate(wxDouble dx, wxDouble dy) = 0;
 502 };
 503
 504
 505
 506 /**
 507     @class wxGraphicsRenderer
 508
 509     A wxGraphicsRenderer is the instance corresponding to the rendering engine
 510     used. There may be multiple instances on a system, if there are different
 511     rendering engines present, but there is always only one instance per engine.
 512     This instance is pointed back to by all objects created by it (wxGraphicsContext,
 513     wxGraphicsPath etc) and can be retrieved through their wxGraphicsObject::GetRenderer()
 514     method. Therefore you can create an additional instance of a path etc. by calling
 515     wxGraphicsObject::GetRenderer() and then using the appropriate CreateXXX function
 516     of that renderer.
 517
 518     @code
 519     wxGraphicsPath *path = // from somewhere
 520     wxGraphicsBrush *brush = path->GetRenderer()->CreateBrush( *wxBLACK_BRUSH );
 521     @endcode
 522
 523     @library{wxcore}
 524     @category{FIXME}
 525 */
 526 class wxGraphicsRenderer : public wxObject
 527 {
 528 public:
 529     /**
 530         Creates a wxGraphicsContext from a wxWindow.
 531     */
 532     virtual wxGraphicsContext* CreateContext(wxWindow* window) = 0;
 533
 534     /**
 535         Creates a wxGraphicsContext from a wxWindowDC
 536     */
 537     virtual wxGraphicsContext * CreateContext( const wxWindowDC& dc) = 0 ;
 538
 539     /**
 540         Creates a wxGraphicsContext from a wxMemoryDC
 541     */
 542     virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc) = 0 ;
 543
 544     /**
 545         Creates a wxGraphicsContext from a wxPrinterDC
 546     */
 547     virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc) = 0 ;
 548
 549     /**
 550         Creates a native brush from a wxBrush.
 551     */
 552     virtual wxGraphicsBrush CreateBrush(const wxBrush& brush) = 0;
 553
 554
 555     /**
 556         Creates a wxGraphicsContext from a native context. This native context must be
 557         eg a CGContextRef for Core Graphics, a Graphics pointer for GDIPlus or a cairo_t
 558         pointer for cairo.
 559     */
 560     virtual wxGraphicsContext* CreateContextFromNativeContext(void* context) = 0;
 561
 562     /**
 563         Creates a wxGraphicsContext from a native window.
 564     */
 565     virtual wxGraphicsContext* CreateContextFromNativeWindow(void* window) = 0;
 566
 567     /**
 568         Creates a native graphics font from a wxFont and a text colour.
 569     */
 570     wxGraphicsFont CreateFont(const wxFont& font,
 571                               const wxColour& col = wxBLACK);
 572
 573     /**
 574         Creates a native brush, having a linear gradient, starting at (x1,y1) with
 575         color c1 to (x2,y2) with color c2
 576     */
 577     wxGraphicsBrush CreateLinearGradientBrush(wxDouble x1,
 578             wxDouble y1,
 579             wxDouble x2,
 580             wxDouble y2,
 581             const wxColouramp;c1,
 582             const wxColouramp;c2);
 583
 584     /**
 585         Creates a native affine transformation matrix from the passed in values. The
 586         defaults result in an identity matrix.
 587     */
 588     wxGraphicsMatrix CreateMatrix(wxDouble a = 1.0, wxDouble b = 0.0,
 589                                   wxDouble c = 0.0,
 590                                   wxDouble d = 1.0,
 591                                   wxDouble tx = 0.0,
 592                                   wxDouble ty = 0.0);
 593
 594     /**
 595         Creates a native graphics path which is initially empty.
 596     */
 597     virtual wxGraphicsPath CreatePath() = 0;
 598
 599     /**
 600         Creates a native pen from a wxPen.
 601     */
 602     virtual wxGraphicsPen CreatePen(const wxPen& pen) = 0;
 603
 604     /**
 605         Creates a native brush, having a radial gradient originating at (xo,yc) with
 606         color oColour and ends on a circle around (xc,yc) with radius r and color cColour
 607     */
 608     virtual wxGraphicsBrush CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 609                                                       wxDouble xc, wxDouble yc,
 610                                                       wxDouble radius,
 611                                                       const wxColour& oColour,
 612                                                       const wxColour& cColour) = 0;
 613
 614     /**
 615         Returns the default renderer on this platform. On OS X this is the Core
 616         Graphics (a.k.a. Quartz 2D) renderer, on MSW the GDIPlus renderer, and on GTK we currently default to the cairo renderer.
 617     */
 618     static wxGraphicsRenderer* GetDefaultRenderer();
 619 };
 620
 621
 622
 623 /**
 624     @class wxGraphicsBrush
 625
 626     A wxGraphicsBrush is a native representation of a brush. The contents
 627     are specific and private to the respective renderer. Instances are ref counted and can
 628     therefore be assigned as usual. The only way to get a valid instance is via
 629     wxGraphicsContext::CreateBrush or wxGraphicsRenderer::CreateBrush.
 630
 631     @library{wxcore}
 632     @category{FIXME}
 633 */
 634 class wxGraphicsBrush : public wxGraphicsObject
 635 {
 636 public:
 637
 638 };
 639
 640
 641
 642 /**
 643     @class wxGraphicsFont
 644
 645     A wxGraphicsFont is a native representation of a font. The contents
 646     are specific and private to the respective renderer. Instances are ref counted and can
 647     therefore be assigned as usual. The only way to get a valid instance is via
 648     wxGraphicsContext::CreateFont or wxGraphicsRenderer::CreateFont.
 649
 650     @library{wxcore}
 651     @category{FIXME}
 652 */
 653 class wxGraphicsFont : public wxGraphicsObject
 654 {
 655 public:
 656
 657 };
 658
 659
 660
 661 /**
 662     @class wxGraphicsPen
 663
 664     A wxGraphicsPen is a native representation of a pen. The contents
 665     are specific and private to the respective renderer. Instances are ref counted and can
 666     therefore be assigned as usual. The only way to get a valid instance is via
 667     wxGraphicsContext::CreatePen or wxGraphicsRenderer::CreatePen.
 668
 669     @library{wxcore}
 670     @category{FIXME}
 671 */
 672 class wxGraphicsPen : public wxGraphicsObject
 673 {
 674 public:
 675
 676 };
 677
 678
 679
 680 /**
 681     @class wxGraphicsMatrix
 682
 683     A wxGraphicsMatrix is a native representation of an affine matrix. The contents
 684     are specific and private to the respective renderer. Instances are ref counted and can
 685     therefore be assigned as usual. The only way to get a valid instance is via
 686     wxGraphicsContext::CreateMatrix or wxGraphicsRenderer::CreateMatrix.
 687
 688     @library{wxcore}
 689     @category{FIXME}
 690 */
 691 class wxGraphicsMatrix : public wxGraphicsObject
 692 {
 693 public:
 694     //@{
 695     /**
 696
 697     */
 698     void Concat(const wxGraphicsMatrix* t);
 699     void Concat(const wxGraphicsMatrix& t);
 700     //@}
 701
 702     /**
 703         Returns the component values of the matrix via the argument pointers.
 704     */
 705     virtual void Get(wxDouble* a = NULL, wxDouble* b = NULL, wxDouble* c = NULL,
 706                      wxDouble* d = NULL, wxDouble* tx = NULL,
 707                      wxDouble* ty = NULL) const;
 708
 709     /**
 710         Returns the native representation of the matrix. For CoreGraphics this is a
 711         CFAffineMatrix pointer. For GDIPlus a Matrix Pointer and for Cairo a cairo_matrix_t pointer.
 712     */
 713     virtual void* GetNativeMatrix() const;
 714
 715     /**
 716         Inverts the matrix.
 717     */
 718     virtual void Invert();
 719
 720     /**
 721         Returns @true if the elements of the transformation matrix are equal.
 722     */
 723     bool IsEqual(const wxGraphicsMatrix& t) const;
 724
 725     /**
 726         Return @true if this is the identity matrix.
 727     */
 728     virtual bool IsIdentity() const;
 729
 730     /**
 731         Rotates this matrix (radians).
 732     */
 733     virtual void Rotate(wxDouble angle);
 734
 735     /**
 736         Scales this matrix.
 737     */
 738     virtual void Scale(wxDouble xScale, wxDouble yScale);
 739
 740     /**
 741         Sets the matrix to the respective values (default values are the identity
 742         matrix)
 743     */
 744     void Set(wxDouble a = 1.0, wxDouble b = 0.0, wxDouble c = 0.0,
 745              wxDouble d = 1.0, wxDouble tx = 0.0,
 746              wxDouble ty = 0.0);
 747
 748     /**
 749         Applies this matrix to a distance (ie. performs all transforms except
 750         translations)
 751     */
 752     virtual void TransformDistance(wxDouble* dx, wxDouble* dy) const;
 753
 754     /**
 755         Applies this matrix to a point.
 756     */
 757     virtual void TransformPoint(wxDouble* x, wxDouble* y) const;
 758
 759     /**
 760         Translates this matrix.
 761     */
 762     virtual void Translate(wxDouble dx, wxDouble dy);
 763 };
 764