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