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     Anti-aliasing modes used by wxGraphicsContext::SetAntialisingMode
 199 */
 200 enum wxAntialiasMode
 201 {
 202     /** No anti-aliasing */
 203     wxANTIALIAS_NONE,
 204
 205     /** The default anti-aliasing */
 206     wxANTIALIAS_DEFAULT,
 207 };
 208
 209 /**
 210     Compositing is done using Porter-Duff compositions
 211     (see http://keithp.com/~keithp/porterduff/p253-porter.pdf) with
 212     wxGraphicsContext::SetCompositionMode
 213
 214     The description give a short equation on how the values of a resulting
 215     pixel are calculated.
 216     @R = Result, @S = Source, @D = Destination, colors premultiplied with alpha
 217     @Ra, @Sa, @Da their alpha components
 218 */
 219 enum wxCompositionMode
 220 {
 221
 222     /** classic Porter-Duff compositions */
 223     wxCOMPOSITION_CLEAR, /**< @R = 0 */
 224     wxCOMPOSITION_SOURCE, /**< @R = S */
 225     wxCOMPOSITION_OVER, /**< @R = @S + @D*(1 - @Sa) */
 226     wxCOMPOSITION_IN, /**< @R = @S*@Da */
 227     wxCOMPOSITION_OUT, /**< @R = @S*(1 - @Da) */
 228     wxCOMPOSITION_ATOP, /**< @R = @S*@Da + @D*(1 - @Sa) */
 229
 230     wxCOMPOSITION_DEST, /**< @R = @D, essentially a noop */
 231     wxCOMPOSITION_DEST_OVER, /**< @R = @S*(1 - @Da) + @D */
 232     wxCOMPOSITION_DEST_IN, /**< @R = @D*@Sa */
 233     wxCOMPOSITION_DEST_OUT, /**< @R = @D*(1 - @Sa) */
 234     wxCOMPOSITION_DEST_ATOP, /**< @R = @S*(1 - @Da) + @D*@Sa */
 235     wxCOMPOSITION_XOR, /**< @R = @S*(1 - @Da) + @D*(1 - @Sa) */
 236
 237     /** mathematical compositions */
 238     wxCOMPOSITION_ADD, /**< @R = @S + @D */
 239 };
 240
 241
 242 /**
 243     @class wxGraphicsContext
 244
 245     A wxGraphicsContext instance is the object that is drawn upon. It is
 246     created by a renderer using wxGraphicsRenderer::CreateContext(). This can
 247     be either directly using a renderer instance, or indirectly using the
 248     static convenience Create() functions of wxGraphicsContext that always
 249     delegate the task to the default renderer.
 250
 251     @code
 252     void MyCanvas::OnPaint(wxPaintEvent &event)
 253     {
 254         // Create paint DC
 255         wxPaintDC dc(this);
 256
 257         // Create graphics context from it
 258         wxGraphicsContext *gc = wxGraphicsContext::Create( dc );
 259
 260         if (gc)
 261         {
 262             // make a path that contains a circle and some lines
 263             gc->SetPen( *wxRED_PEN );
 264             wxGraphicsPath path = gc->CreatePath();
 265             path.AddCircle( 50.0, 50.0, 50.0 );
 266             path.MoveToPoint(0.0, 50.0);
 267             path.AddLineToPoint(100.0, 50.0);
 268             path.MoveToPoint(50.0, 0.0);
 269             path.AddLineToPoint(50.0, 100.0 );
 270             path.CloseSubpath();
 271             path.AddRectangle(25.0, 25.0, 50.0, 50.0);
 272
 273             gc->StrokePath(path);
 274
 275             delete gc;
 276         }
 277     }
 278     @endcode
 279
 280     @library{wxcore}
 281     @category{gdi,dc}
 282
 283     @see wxGraphicsRenderer::CreateContext(), wxGCDC, wxDC
 284 */
 285 class wxGraphicsContext : public wxGraphicsObject
 286 {
 287 public:
 288     /**
 289         Creates a wxGraphicsContext from a wxWindow.
 290
 291         @see wxGraphicsRenderer::CreateContext()
 292     */
 293     static wxGraphicsContext* Create(wxWindow* window);
 294
 295     /**
 296         Creates a wxGraphicsContext from a wxWindowDC
 297
 298         @see wxGraphicsRenderer::CreateContext()
 299     */
 300     static wxGraphicsContext* Create(const wxWindowDC& dc);
 301
 302     /**
 303         Creates a wxGraphicsContext from a wxMemoryDC
 304
 305         @see wxGraphicsRenderer::CreateContext()
 306     */
 307     static wxGraphicsContext* Create(const wxMemoryDC& dc);
 308
 309     /**
 310         Creates a wxGraphicsContext from a wxPrinterDC. Under GTK+, this will
 311         only work when using the GtkPrint printing backend which is available
 312         since GTK+ 2.10.
 313
 314         @see wxGraphicsRenderer::CreateContext(), @ref overview_unixprinting
 315     */
 316     static wxGraphicsContext* Create(const wxPrinterDC& dc);
 317
 318     /**
 319         Clips drawings to the specified region.
 320     */
 321     virtual void Clip(const wxRegion& region) = 0;
 322
 323     /**
 324         Clips drawings to the specified rectangle.
 325     */
 326     virtual void Clip(wxDouble x, wxDouble y, wxDouble w, wxDouble h) = 0;
 327
 328     /**
 329         Concatenates the passed in transform with the current transform of this
 330         context.
 331     */
 332     virtual void ConcatTransform(const wxGraphicsMatrix& matrix) = 0;
 333
 334     /**
 335         Creates a native brush from a wxBrush.
 336     */
 337     virtual wxGraphicsBrush CreateBrush(const wxBrush& brush) const;
 338
 339     /**
 340         Creates a native graphics font from a wxFont and a text colour.
 341     */
 342     virtual wxGraphicsFont CreateFont(const wxFont& font,
 343                                       const wxColour& col = *wxBLACK) const;
 344
 345     /**
 346         Creates a wxGraphicsContext from a native context. This native context
 347         must be a CGContextRef for Core Graphics, a Graphics pointer for
 348         GDIPlus, or a cairo_t pointer for cairo.
 349
 350         @see wxGraphicsRenderer::CreateContextFromNativeContext()
 351     */
 352     static wxGraphicsContext* CreateFromNative(void* context);
 353
 354     /**
 355         Creates a wxGraphicsContext from a native window.
 356
 357         @see wxGraphicsRenderer::CreateContextFromNativeWindow()
 358     */
 359     static wxGraphicsContext* CreateFromNativeWindow(void* window);
 360
 361     /**
 362         Creates a native brush, having a linear gradient, starting at
 363         (@a x1, @a y1) with color @a c1 to (@a x2, @a y2) with color @a c2.
 364     */
 365     virtual wxGraphicsBrush CreateLinearGradientBrush(wxDouble x1,
 366                                                       wxDouble y1,
 367                                                       wxDouble x2,
 368                                                       wxDouble y2,
 369                                                       const wxColour& c1,
 370                                                       const wxColour& c2) const;
 371
 372     /**
 373         Creates a native affine transformation matrix from the passed in
 374         values. The default parameters result in an identity matrix.
 375     */
 376     virtual wxGraphicsMatrix CreateMatrix(wxDouble a = 1.0, wxDouble b = 0.0,
 377                                           wxDouble c = 0.0, wxDouble d = 1.0,
 378                                           wxDouble tx = 0.0,
 379                                           wxDouble ty = 0.0) const;
 380
 381     /**
 382         Creates a native graphics path which is initially empty.
 383     */
 384     wxGraphicsPath CreatePath() const;
 385
 386     /**
 387         Creates a native pen from a wxPen.
 388     */
 389     virtual wxGraphicsPen CreatePen(const wxPen& pen) const;
 390
 391     /**
 392         Creates a native brush, having a radial gradient originating at
 393         (@a xo, @a yc) with color @a oColour and ends on a circle around
 394         (@a xc, @a yc) with the given @a radius and color @a cColour.
 395     */
 396     virtual wxGraphicsBrush CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 397                                                       wxDouble xc, wxDouble yc,
 398                                                       wxDouble radius,
 399                                                       const wxColour& oColor,
 400                                                       const wxColour& cColor) const;
 401
 402     /**
 403         Draws the bitmap. In case of a mono bitmap, this is treated as a mask
 404         and the current brushed is used for filling.
 405     */
 406     virtual void DrawBitmap(const wxBitmap& bmp, wxDouble x, wxDouble y,
 407                             wxDouble w, wxDouble h) = 0;
 408
 409     /**
 410         Draws an ellipse.
 411     */
 412     virtual void DrawEllipse(wxDouble x, wxDouble y, wxDouble w, wxDouble h);
 413
 414     /**
 415         Draws the icon.
 416     */
 417     virtual void DrawIcon(const wxIcon& icon, wxDouble x, wxDouble y,
 418                           wxDouble w, wxDouble h) = 0;
 419
 420     /**
 421         Draws a polygon.
 422     */
 423     virtual void DrawLines(size_t n, const wxPoint2DDouble* points,
 424                            wxPolygonFillMode fillStyle = wxODDEVEN_RULE);
 425
 426     /**
 427         Draws the path by first filling and then stroking.
 428     */
 429     virtual void DrawPath(const wxGraphicsPath& path,
 430                           wxPolygonFillMode fillStyle = wxODDEVEN_RULE);
 431
 432     /**
 433         Draws a rectangle.
 434     */
 435     virtual void DrawRectangle(wxDouble x, wxDouble y, wxDouble w, wxDouble h);
 436
 437     /**
 438         Draws a rounded rectangle.
 439     */
 440     virtual void DrawRoundedRectangle(wxDouble x, wxDouble y, wxDouble w,
 441                                       wxDouble h, wxDouble radius);
 442
 443     /**
 444         Draws text at the defined position.
 445     */
 446     void DrawText(const wxString& str, wxDouble x, wxDouble y);
 447     /**
 448         Draws text at the defined position.
 449
 450         @param str
 451             The text to draw.
 452         @param x
 453             The x coordinate position to draw the text at.
 454         @param y
 455             The y coordinate position to draw the text at.
 456         @param angle
 457             The angle relative to the (default) horizontal direction to draw
 458             the string.
 459     */
 460     void DrawText(const wxString& str, wxDouble x, wxDouble y, wxDouble angle);
 461     /**
 462         Draws text at the defined position.
 463
 464         @param str
 465             The text to draw.
 466         @param x
 467             The x coordinate position to draw the text at.
 468         @param y
 469             The y coordinate position to draw the text at.
 470         @param backgroundBrush
 471             Brush to fill the text with.
 472     */
 473     void DrawText(const wxString& str, wxDouble x, wxDouble y,
 474                   const wxGraphicsBrush& backgroundBrush);
 475     /**
 476         Draws text at the defined position.
 477
 478         @param str
 479             The text to draw.
 480         @param x
 481             The x coordinate position to draw the text at.
 482         @param y
 483             The y coordinate position to draw the text at.
 484         @param angle
 485             The angle relative to the (default) horizontal direction to draw
 486             the string.
 487         @param backgroundBrush
 488             Brush to fill the text with.
 489     */
 490     void DrawText(const wxString& str, wxDouble x, wxDouble y,
 491                   wxDouble angle, const wxGraphicsBrush& backgroundBrush);
 492
 493     /**
 494         Fills the path with the current brush.
 495     */
 496     virtual void FillPath(const wxGraphicsPath& path,
 497                           wxPolygonFillMode fillStyle = wxODDEVEN_RULE) = 0;
 498
 499     /**
 500         Returns the native context (CGContextRef for Core Graphics, Graphics
 501         pointer for GDIPlus and cairo_t pointer for cairo).
 502     */
 503     virtual void* GetNativeContext() = 0;
 504
 505     /**
 506         Fills the @a widths array with the widths from the beginning of
 507         @a text to the corresponding character of @a text.
 508     */
 509     virtual void GetPartialTextExtents(const wxString& text,
 510                                        wxArrayDouble& widths) const = 0;
 511
 512     /**
 513         Gets the dimensions of the string using the currently selected font.
 514
 515         @param text
 516             The text string to measure.
 517         @param width
 518             Variable to store the total calculated width of the text.
 519         @param height
 520             Variable to store the total calculated height of the text.
 521         @param descent
 522             Variable to store the dimension from the baseline of the font to
 523             the bottom of the descender.
 524         @param externalLeading
 525             Any extra vertical space added to the font by the font designer
 526             (usually is zero).
 527     */
 528     virtual void GetTextExtent(const wxString& text, wxDouble* width,
 529                                wxDouble* height, wxDouble* descent,
 530                                wxDouble* externalLeading) const = 0;
 531
 532     /**
 533         Gets the current transformation matrix of this context.
 534     */
 535     virtual wxGraphicsMatrix GetTransform() const = 0;
 536
 537     /**
 538         Resets the clipping to original shape.
 539     */
 540     virtual void ResetClip() = 0;
 541
 542     /**
 543         Rotates the current transformation matrix (in radians).
 544     */
 545     virtual void Rotate(wxDouble angle) = 0;
 546
 547     /**
 548         Scales the current transformation matrix.
 549     */
 550     virtual void Scale(wxDouble xScale, wxDouble yScale) = 0;
 551
 552     /**
 553         Sets the brush for filling paths.
 554     */
 555     void SetBrush(const wxBrush& brush);
 556     /**
 557         Sets the brush for filling paths.
 558     */
 559     virtual void SetBrush(const wxGraphicsBrush& brush);
 560
 561     /**
 562         Sets the font for drawing text.
 563     */
 564     void SetFont(const wxFont& font, const wxColour& colour);
 565     /**
 566         Sets the font for drawing text.
 567     */
 568     virtual void SetFont(const wxGraphicsFont& font);
 569
 570     /**
 571         Sets the pen used for stroking.
 572     */
 573     void SetPen(const wxPen& pen);
 574     /**
 575         Sets the pen used for stroking.
 576     */
 577     virtual void SetPen(const wxGraphicsPen& pen);
 578
 579     /**
 580         Sets the current transformation matrix of this context
 581     */
 582     virtual void SetTransform(const wxGraphicsMatrix& matrix) = 0;
 583
 584     /**
 585         Strokes a single line.
 586     */
 587     virtual void StrokeLine(wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2);
 588
 589     /**
 590         Stroke disconnected lines from begin to end points, fastest method
 591         available for this purpose.
 592     */
 593     virtual void StrokeLines(size_t n, const wxPoint2DDouble* beginPoints,
 594                              const wxPoint2DDouble* endPoints);
 595     /**
 596         Stroke disconnected lines from begin to end points, fastest method
 597         available for this purpose.
 598     */
 599     virtual void StrokeLines(size_t n, const wxPoint2DDouble* points);
 600
 601     /**
 602         Strokes along a path with the current pen.
 603     */
 604     virtual void StrokePath(const wxGraphicsPath& path) = 0;
 605
 606     /**
 607         Translates the current transformation matrix.
 608     */
 609     virtual void Translate(wxDouble dx, wxDouble dy) = 0;
 610
 611     /**
 612         Redirects all rendering is done into a fully transparent temporary context
 613     */
 614     virtual void BeginLayer(wxDouble opacity) = 0;
 615
 616     /**
 617         Composites back the drawings into the context with the opacity given at
 618         the BeginLayer call
 619     */
 620     virtual void EndLayer() = 0;
 621
 622     /**
 623         Sets the antialiasing mode, returns true if it supported
 624     */
 625     virtual bool SetAntialiasMode(wxAntialiasMode antialias) = 0;
 626
 627     /**
 628         Returns the current shape antialiasing mode
 629     */
 630     virtual wxAntialiasMode GetAntialiasMode() const ;
 631
 632     /**
 633         Sets the compositing operator, returns true if it supported
 634     */
 635     virtual bool SetCompositionMode(wxCompositionMode op) = 0;
 636
 637     /**
 638         Returns the current compositing operator
 639     */
 640     virtual wxCompositionMode GetCompositionMode() const;
 641
 642 };
 643
 644
 645
 646 /**
 647     @class wxGraphicsRenderer
 648
 649     A wxGraphicsRenderer is the instance corresponding to the rendering engine
 650     used. There may be multiple instances on a system, if there are different
 651     rendering engines present, but there is always only one instance per
 652     engine. This instance is pointed back to by all objects created by it
 653     (wxGraphicsContext, wxGraphicsPath etc) and can be retrieved through their
 654     wxGraphicsObject::GetRenderer() method. Therefore you can create an
 655     additional instance of a path etc. by calling
 656     wxGraphicsObject::GetRenderer() and then using the appropriate CreateXXX()
 657     function of that renderer.
 658
 659     @code
 660     wxGraphicsPath *path = // from somewhere
 661     wxGraphicsBrush *brush = path->GetRenderer()->CreateBrush( *wxBLACK_BRUSH );
 662     @endcode
 663
 664     @library{wxcore}
 665     @category{gdi}
 666 */
 667 class wxGraphicsRenderer : public wxObject
 668 {
 669 public:
 670     /**
 671         Creates a wxGraphicsContext from a wxWindow.
 672     */
 673     virtual wxGraphicsContext* CreateContext(wxWindow* window) = 0;
 674
 675     /**
 676         Creates a wxGraphicsContext from a wxWindowDC
 677     */
 678     virtual wxGraphicsContext* CreateContext(const wxWindowDC& dc) = 0 ;
 679
 680     /**
 681         Creates a wxGraphicsContext from a wxMemoryDC
 682     */
 683     virtual wxGraphicsContext* CreateContext(const wxMemoryDC& dc) = 0 ;
 684
 685     /**
 686         Creates a wxGraphicsContext from a wxPrinterDC
 687     */
 688     virtual wxGraphicsContext* CreateContext(const wxPrinterDC& dc) = 0 ;
 689
 690     /**
 691         Creates a native brush from a wxBrush.
 692     */
 693     virtual wxGraphicsBrush CreateBrush(const wxBrush& brush) = 0;
 694
 695     /**
 696         Creates a wxGraphicsContext from a native context. This native context
 697         must be a CGContextRef for Core Graphics, a Graphics pointer for
 698         GDIPlus, or a cairo_t pointer for cairo.
 699     */
 700     virtual wxGraphicsContext* CreateContextFromNativeContext(void* context) = 0;
 701
 702     /**
 703         Creates a wxGraphicsContext from a native window.
 704     */
 705     virtual wxGraphicsContext* CreateContextFromNativeWindow(void* window) = 0;
 706
 707     /**
 708         Creates a native graphics font from a wxFont and a text colour.
 709     */
 710     virtual wxGraphicsFont CreateFont(const wxFont& font,
 711                                       const wxColour& col = *wxBLACK) = 0;
 712
 713     /**
 714         Creates a native brush, having a linear gradient, starting at
 715         (@a x1, @a y1) with color @a c1 to (@a x2, @a y2) with color @a c2.
 716     */
 717     virtual wxGraphicsBrush CreateLinearGradientBrush(wxDouble x1,
 718                                                       wxDouble y1,
 719                                                       wxDouble x2,
 720                                                       wxDouble y2,
 721                                                       const wxColour& c1,
 722                                                       const wxColour& c2) = 0;
 723
 724     /**
 725         Creates a native affine transformation matrix from the passed in
 726         values. The defaults result in an identity matrix.
 727     */
 728     virtual wxGraphicsMatrix CreateMatrix(wxDouble a = 1.0, wxDouble b = 0.0,
 729                                           wxDouble c = 0.0, wxDouble d = 1.0,
 730                                           wxDouble tx = 0.0,
 731                                           wxDouble ty = 0.0) = 0;
 732
 733     /**
 734         Creates a native graphics path which is initially empty.
 735     */
 736     virtual wxGraphicsPath CreatePath() = 0;
 737
 738     /**
 739         Creates a native pen from a wxPen.
 740     */
 741     virtual wxGraphicsPen CreatePen(const wxPen& pen) = 0;
 742
 743     /**
 744         Creates a native brush, having a radial gradient originating at
 745         (@a xo, @a yc) with color @a oColour and ends on a circle around
 746         (@a xc, @a yc) with the given @a radius and color @a cColour.
 747     */
 748     virtual wxGraphicsBrush CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 749                                                       wxDouble xc, wxDouble yc,
 750                                                       wxDouble radius,
 751                                                       const wxColour& oColour,
 752                                                       const wxColour& cColour) = 0;
 753
 754     /**
 755         Returns the default renderer on this platform. On OS X this is the Core
 756         Graphics (a.k.a. Quartz 2D) renderer, on MSW the GDIPlus renderer, and
 757         on GTK we currently default to the cairo renderer.
 758     */
 759     static wxGraphicsRenderer* GetDefaultRenderer();
 760 };
 761
 762
 763
 764 /**
 765     @class wxGraphicsBrush
 766
 767     A wxGraphicsBrush is a native representation of a brush. The contents are
 768     specific and private to the respective renderer. Instances are ref counted
 769     and can therefore be assigned as usual. The only way to get a valid
 770     instance is via wxGraphicsContext::CreateBrush() or
 771     wxGraphicsRenderer::CreateBrush().
 772
 773     @library{wxcore}
 774     @category{gdi}
 775 */
 776 class wxGraphicsBrush : public wxGraphicsObject
 777 {
 778 public:
 779
 780 };
 781
 782
 783
 784 /**
 785     @class wxGraphicsFont
 786
 787     A wxGraphicsFont is a native representation of a font. The contents are
 788     specific and private to the respective renderer. Instances are ref counted
 789     and can therefore be assigned as usual. The only way to get a valid
 790     instance is via wxGraphicsContext::CreateFont() or
 791     wxGraphicsRenderer::CreateFont().
 792
 793     @library{wxcore}
 794     @category{gdi}
 795 */
 796 class wxGraphicsFont : public wxGraphicsObject
 797 {
 798 public:
 799
 800 };
 801
 802
 803
 804 /**
 805     @class wxGraphicsPen
 806
 807     A wxGraphicsPen is a native representation of a pen. The contents are
 808     specific and private to the respective renderer. Instances are ref counted
 809     and can therefore be assigned as usual. The only way to get a valid
 810     instance is via wxGraphicsContext::CreatePen() or
 811     wxGraphicsRenderer::CreatePen().
 812
 813     @library{wxcore}
 814     @category{gdi}
 815 */
 816 class wxGraphicsPen : public wxGraphicsObject
 817 {
 818 public:
 819
 820 };
 821
 822
 823
 824 /**
 825     @class wxGraphicsMatrix
 826
 827     A wxGraphicsMatrix is a native representation of an affine matrix. The
 828     contents are specific and private to the respective renderer. Instances are
 829     ref counted and can therefore be assigned as usual. The only way to get a
 830     valid instance is via wxGraphicsContext::CreateMatrix() or
 831     wxGraphicsRenderer::CreateMatrix().
 832
 833     @library{wxcore}
 834     @category{gdi}
 835 */
 836 class wxGraphicsMatrix : public wxGraphicsObject
 837 {
 838 public:
 839     /**
 840         Concatenates the matrix passed with the current matrix.
 841     */
 842     virtual void Concat(const wxGraphicsMatrix* t);
 843     /**
 844         Concatenates the matrix passed with the current matrix.
 845     */
 846     void Concat(const wxGraphicsMatrix& t);
 847
 848     /**
 849         Returns the component values of the matrix via the argument pointers.
 850     */
 851     virtual void Get(wxDouble* a = NULL, wxDouble* b = NULL,
 852                      wxDouble* c = NULL, wxDouble* d = NULL,
 853                      wxDouble* tx = NULL, wxDouble* ty = NULL) const;
 854
 855     /**
 856         Returns the native representation of the matrix. For CoreGraphics this
 857         is a CFAffineMatrix pointer, for GDIPlus a Matrix Pointer, and for
 858         Cairo a cairo_matrix_t pointer.
 859     */
 860     virtual void* GetNativeMatrix() const;
 861
 862     /**
 863         Inverts the matrix.
 864     */
 865     virtual void Invert();
 866
 867     /**
 868         Returns @true if the elements of the transformation matrix are equal.
 869     */
 870     virtual bool IsEqual(const wxGraphicsMatrix* t) const;
 871     /**
 872         Returns @true if the elements of the transformation matrix are equal.
 873     */
 874     bool IsEqual(const wxGraphicsMatrix& t) const;
 875
 876     /**
 877         Return @true if this is the identity matrix.
 878     */
 879     virtual bool IsIdentity() const;
 880
 881     /**
 882         Rotates this matrix (in radians).
 883     */
 884     virtual void Rotate(wxDouble angle);
 885
 886     /**
 887         Scales this matrix.
 888     */
 889     virtual void Scale(wxDouble xScale, wxDouble yScale);
 890
 891     /**
 892         Sets the matrix to the respective values (default values are the
 893         identity matrix).
 894     */
 895     virtual void Set(wxDouble a = 1.0, wxDouble b = 0.0, wxDouble c = 0.0,
 896                      wxDouble d = 1.0, wxDouble tx = 0.0, wxDouble ty = 0.0);
 897
 898     /**
 899         Applies this matrix to a distance (ie. performs all transforms except
 900         translations).
 901     */
 902     virtual void TransformDistance(wxDouble* dx, wxDouble* dy) const;
 903
 904     /**
 905         Applies this matrix to a point.
 906     */
 907     virtual void TransformPoint(wxDouble* x, wxDouble* y) const;
 908
 909     /**
 910         Translates this matrix.
 911     */
 912     virtual void Translate(wxDouble dx, wxDouble dy);
 913 };
 914