interface/wx/graphics.h

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