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     virtual 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     virtual void DrawBitmap(const wxBitmap& bmp, wxDouble x, wxDouble y,
 351                             wxDouble w, wxDouble h) = 0;
 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     virtual void DrawIcon(const wxIcon& icon, wxDouble x, wxDouble y,
 362                           wxDouble w, wxDouble h) = 0;
 363
 364     /**
 365         Draws a polygon.
 366     */
 367     virtual 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     virtual void DrawPath(const wxGraphicsPath& path,
 374                           int fillStyle = wxODDEVEN_RULE);
 375
 376     /**
 377         Draws a rectangle.
 378     */
 379     virtual void DrawRectangle(wxDouble x, wxDouble y, wxDouble w, wxDouble h);
 380
 381     /**
 382         Draws a rounded rectangle.
 383     */
 384     virtual void DrawRoundedRectangle(wxDouble x, wxDouble y, wxDouble w,
 385                                       wxDouble h, wxDouble radius);
 386
 387     //@{
 388     /**
 389         Draws a text at the defined position, at the given angle.
 390     */
 391     void DrawText(const wxString& str, wxDouble x, wxDouble y,
 392                   wxDouble angle);
 393     void DrawText(const wxString& str, wxDouble x, wxDouble y);
 394     //@}
 395
 396     /**
 397         Fills the path with the current brush.
 398     */
 399     virtual void FillPath(const wxGraphicsPath& path,
 400                           int fillStyle = wxODDEVEN_RULE) = 0;
 401
 402     /**
 403         Returns the native context (CGContextRef for Core Graphics, Graphics pointer
 404         for GDIPlus and cairo_t pointer for cairo).
 405     */
 406     virtual void* GetNativeContext() = 0;
 407
 408     /**
 409         Fills the @a widths array with the widths from the beginning of
 410         @a text to the corresponding character of @e text.
 411     */
 412     virtual void GetPartialTextExtents(const wxString& text,
 413                                        wxArrayDouble& widths) const = 0;
 414
 415     /**
 416         Gets the dimensions of the string using the currently selected font.
 417         @e string is the text string to measure, @e w and @e h are
 418         the total width and height respectively, @a descent is the
 419         dimension from the baseline of the font to the bottom of the
 420         descender, and @a externalLeading is any extra vertical space added
 421         to the font by the font designer (usually is zero).
 422     */
 423     virtual void GetTextExtent(const wxString& text, wxDouble* width,
 424                                wxDouble* height, wxDouble* descent,
 425                                wxDouble* externalLeading) const = 0;
 426
 427     /**
 428         Gets the current transformation matrix of this context.
 429     */
 430     virtual wxGraphicsMatrix GetTransform() const = 0;
 431
 432     /**
 433         Resets the clipping to original shape.
 434     */
 435     virtual void ResetClip() = 0;
 436
 437     /**
 438         Rotates the current transformation matrix (radians),
 439     */
 440     virtual void Rotate(wxDouble angle) = 0;
 441
 442     /**
 443         Scales the current transformation matrix.
 444     */
 445     virtual void Scale(wxDouble xScale, wxDouble yScale) = 0;
 446
 447     //@{
 448     /**
 449         Sets the brush for filling paths.
 450     */
 451     void SetBrush(const wxBrush& brush);
 452     void SetBrush(const wxGraphicsBrush& brush);
 453     //@}
 454
 455     //@{
 456     /**
 457         Sets the font for drawing text.
 458     */
 459     void SetFont(const wxFont& font, const wxColour& colour);
 460     void SetFont(const wxGraphicsFont& font);
 461     //@}
 462
 463     //@{
 464     /**
 465         Sets the pen used for stroking.
 466     */
 467     void SetPen(const wxGraphicsPen& pen);
 468     void SetPen(const wxPen& pen);
 469     //@}
 470
 471     /**
 472         Sets the current transformation matrix of this context
 473     */
 474     virtual void SetTransform(const wxGraphicsMatrix& matrix) = 0;
 475
 476     /**
 477         Strokes a single line.
 478     */
 479     virtual void StrokeLine(wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2);
 480
 481     //@{
 482     /**
 483         Stroke disconnected lines from begin to end points, fastest method available
 484         for this purpose.
 485     */
 486     void StrokeLines(size_t n, const wxPoint2DDouble* beginPoints,
 487                      const wxPoint2DDouble* endPoints);
 488     void StrokeLines(size_t n, const wxPoint2DDouble* points);
 489     //@}
 490
 491     /**
 492         Strokes along a path with the current pen.
 493     */
 494     virtual void StrokePath(const wxGraphicsPath& path) = 0;
 495
 496     /**
 497         Translates the current transformation matrix.
 498     */
 499     virtual void Translate(wxDouble dx, wxDouble dy) = 0;
 500 };
 501
 502
 503
 504 /**
 505     @class wxGraphicsRenderer
 506
 507     A wxGraphicsRenderer is the instance corresponding to the rendering engine
 508     used. There may be multiple instances on a system, if there are different
 509     rendering engines present, but there is always only one instance per engine.
 510     This instance is pointed back to by all objects created by it (wxGraphicsContext,
 511     wxGraphicsPath etc) and can be retrieved through their wxGraphicsObject::GetRenderer()
 512     method. Therefore you can create an additional instance of a path etc. by calling
 513     wxGraphicsObject::GetRenderer() and then using the appropriate CreateXXX function
 514     of that renderer.
 515
 516     @code
 517     wxGraphicsPath *path = // from somewhere
 518     wxGraphicsBrush *brush = path->GetRenderer()->CreateBrush( *wxBLACK_BRUSH );
 519     @endcode
 520
 521     @library{wxcore}
 522     @category{FIXME}
 523 */
 524 class wxGraphicsRenderer : public wxObject
 525 {
 526 public:
 527     /**
 528         Creates a wxGraphicsContext from a wxWindow.
 529     */
 530     virtual wxGraphicsContext* CreateContext(wxWindow* window) = 0;
 531
 532     /**
 533         Creates a wxGraphicsContext from a wxWindowDC
 534     */
 535     virtual wxGraphicsContext * CreateContext( const wxWindowDC& dc) = 0 ;
 536
 537     /**
 538         Creates a wxGraphicsContext from a wxMemoryDC
 539     */
 540     virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc) = 0 ;
 541
 542     /**
 543         Creates a wxGraphicsContext from a wxPrinterDC
 544     */
 545     virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc) = 0 ;
 546
 547     /**
 548         Creates a native brush from a wxBrush.
 549     */
 550     virtual wxGraphicsBrush CreateBrush(const wxBrush& brush) = 0;
 551
 552
 553     /**
 554         Creates a wxGraphicsContext from a native context. This native context must be
 555         eg a CGContextRef for Core Graphics, a Graphics pointer for GDIPlus or a cairo_t
 556         pointer for cairo.
 557     */
 558     virtual wxGraphicsContext* CreateContextFromNativeContext(void* context) = 0;
 559
 560     /**
 561         Creates a wxGraphicsContext from a native window.
 562     */
 563     virtual wxGraphicsContext* CreateContextFromNativeWindow(void* window) = 0;
 564
 565     /**
 566         Creates a native graphics font from a wxFont and a text colour.
 567     */
 568     wxGraphicsFont CreateFont(const wxFont& font,
 569                               const wxColour& col = wxBLACK);
 570
 571     /**
 572         Creates a native brush, having a linear gradient, starting at (x1,y1) with
 573         color c1 to (x2,y2) with color c2
 574     */
 575     wxGraphicsBrush CreateLinearGradientBrush(wxDouble x1,
 576             wxDouble y1,
 577             wxDouble x2,
 578             wxDouble y2,
 579             const wxColouramp;c1,
 580             const wxColouramp;c2);
 581
 582     /**
 583         Creates a native affine transformation matrix from the passed in values. The
 584         defaults result in an identity matrix.
 585     */
 586     wxGraphicsMatrix CreateMatrix(wxDouble a = 1.0, wxDouble b = 0.0,
 587                                   wxDouble c = 0.0,
 588                                   wxDouble d = 1.0,
 589                                   wxDouble tx = 0.0,
 590                                   wxDouble ty = 0.0);
 591
 592     /**
 593         Creates a native graphics path which is initially empty.
 594     */
 595     virtual wxGraphicsPath CreatePath() = 0;
 596
 597     /**
 598         Creates a native pen from a wxPen.
 599     */
 600     virtual wxGraphicsPen CreatePen(const wxPen& pen) = 0;
 601
 602     /**
 603         Creates a native brush, having a radial gradient originating at (xo,yc) with
 604         color oColour and ends on a circle around (xc,yc) with radius r and color cColour
 605     */
 606     virtual wxGraphicsBrush CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 607                                                       wxDouble xc, wxDouble yc,
 608                                                       wxDouble radius,
 609                                                       const wxColour& oColour,
 610                                                       const wxColour& cColour) = 0;
 611
 612     /**
 613         Returns the default renderer on this platform. On OS X this is the Core
 614         Graphics (a.k.a. Quartz 2D) renderer, on MSW the GDIPlus renderer, and on GTK we currently default to the cairo renderer.
 615     */
 616     static wxGraphicsRenderer* GetDefaultRenderer();
 617 };
 618
 619
 620
 621 /**
 622     @class wxGraphicsBrush
 623
 624     A wxGraphicsBrush is a native representation of a brush. The contents
 625     are specific and private to the respective renderer. Instances are ref counted and can
 626     therefore be assigned as usual. The only way to get a valid instance is via
 627     wxGraphicsContext::CreateBrush or wxGraphicsRenderer::CreateBrush.
 628
 629     @library{wxcore}
 630     @category{FIXME}
 631 */
 632 class wxGraphicsBrush : public wxGraphicsObject
 633 {
 634 public:
 635
 636 };
 637
 638
 639
 640 /**
 641     @class wxGraphicsFont
 642
 643     A wxGraphicsFont is a native representation of a font. The contents
 644     are specific and private to the respective renderer. Instances are ref counted and can
 645     therefore be assigned as usual. The only way to get a valid instance is via
 646     wxGraphicsContext::CreateFont or wxGraphicsRenderer::CreateFont.
 647
 648     @library{wxcore}
 649     @category{FIXME}
 650 */
 651 class wxGraphicsFont : public wxGraphicsObject
 652 {
 653 public:
 654
 655 };
 656
 657
 658
 659 /**
 660     @class wxGraphicsPen
 661
 662     A wxGraphicsPen is a native representation of a pen. The contents
 663     are specific and private to the respective renderer. Instances are ref counted and can
 664     therefore be assigned as usual. The only way to get a valid instance is via
 665     wxGraphicsContext::CreatePen or wxGraphicsRenderer::CreatePen.
 666
 667     @library{wxcore}
 668     @category{FIXME}
 669 */
 670 class wxGraphicsPen : public wxGraphicsObject
 671 {
 672 public:
 673
 674 };
 675
 676
 677
 678 /**
 679     @class wxGraphicsMatrix
 680
 681     A wxGraphicsMatrix is a native representation of an affine matrix. The contents
 682     are specific and private to the respective renderer. Instances are ref counted and can
 683     therefore be assigned as usual. The only way to get a valid instance is via
 684     wxGraphicsContext::CreateMatrix or wxGraphicsRenderer::CreateMatrix.
 685
 686     @library{wxcore}
 687     @category{FIXME}
 688 */
 689 class wxGraphicsMatrix : public wxGraphicsObject
 690 {
 691 public:
 692     //@{
 693     /**
 694
 695     */
 696     void Concat(const wxGraphicsMatrix* t);
 697     void Concat(const wxGraphicsMatrix& t);
 698     //@}
 699
 700     /**
 701         Returns the component values of the matrix via the argument pointers.
 702     */
 703     virtual void Get(wxDouble* a = NULL, wxDouble* b = NULL, wxDouble* c = NULL,
 704                      wxDouble* d = NULL, wxDouble* tx = NULL,
 705                      wxDouble* ty = NULL) const;
 706
 707     /**
 708         Returns the native representation of the matrix. For CoreGraphics this is a
 709         CFAffineMatrix pointer. For GDIPlus a Matrix Pointer and for Cairo a cairo_matrix_t pointer.
 710     */
 711     virtual void* GetNativeMatrix() const;
 712
 713     /**
 714         Inverts the matrix.
 715     */
 716     virtual void Invert();
 717
 718     /**
 719         Returns @true if the elements of the transformation matrix are equal.
 720     */
 721     bool IsEqual(const wxGraphicsMatrix& t) const;
 722
 723     /**
 724         Return @true if this is the identity matrix.
 725     */
 726     virtual bool IsIdentity() const;
 727
 728     /**
 729         Rotates this matrix (radians).
 730     */
 731     virtual void Rotate(wxDouble angle);
 732
 733     /**
 734         Scales this matrix.
 735     */
 736     virtual void Scale(wxDouble xScale, wxDouble yScale);
 737
 738     /**
 739         Sets the matrix to the respective values (default values are the identity
 740         matrix)
 741     */
 742     void Set(wxDouble a = 1.0, wxDouble b = 0.0, wxDouble c = 0.0,
 743              wxDouble d = 1.0, wxDouble tx = 0.0,
 744              wxDouble ty = 0.0);
 745
 746     /**
 747         Applies this matrix to a distance (ie. performs all transforms except
 748         translations)
 749     */
 750     virtual void TransformDistance(wxDouble* dx, wxDouble* dy) const;
 751
 752     /**
 753         Applies this matrix to a point.
 754     */
 755     virtual void TransformPoint(wxDouble* x, wxDouble* y) const;
 756
 757     /**
 758         Translates this matrix.
 759     */
 760     virtual void Translate(wxDouble dx, wxDouble dy);
 761 };
 762