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 wxGraphicsContext that can be used for measuring texts only.
 705         No drawing commands are allowed.
 706     */
 707     virtual wxGraphicsContext * CreateMeasuringContext() = 0;
 708
 709     /**
 710         Creates a native graphics font from a wxFont and a text colour.
 711     */
 712     virtual wxGraphicsFont CreateFont(const wxFont& font,
 713                                       const wxColour& col = *wxBLACK) = 0;
 714
 715     /**
 716         Creates a native brush, having a linear gradient, starting at
 717         (@a x1, @a y1) with color @a c1 to (@a x2, @a y2) with color @a c2.
 718     */
 719     virtual wxGraphicsBrush CreateLinearGradientBrush(wxDouble x1,
 720                                                       wxDouble y1,
 721                                                       wxDouble x2,
 722                                                       wxDouble y2,
 723                                                       const wxColour& c1,
 724                                                       const wxColour& c2) = 0;
 725
 726     /**
 727         Creates a native affine transformation matrix from the passed in
 728         values. The defaults result in an identity matrix.
 729     */
 730     virtual wxGraphicsMatrix CreateMatrix(wxDouble a = 1.0, wxDouble b = 0.0,
 731                                           wxDouble c = 0.0, wxDouble d = 1.0,
 732                                           wxDouble tx = 0.0,
 733                                           wxDouble ty = 0.0) = 0;
 734
 735     /**
 736         Creates a native graphics path which is initially empty.
 737     */
 738     virtual wxGraphicsPath CreatePath() = 0;
 739
 740     /**
 741         Creates a native pen from a wxPen.
 742     */
 743     virtual wxGraphicsPen CreatePen(const wxPen& pen) = 0;
 744
 745     /**
 746         Creates a native brush, having a radial gradient originating at
 747         (@a xo, @a yc) with color @a oColour and ends on a circle around
 748         (@a xc, @a yc) with the given @a radius and color @a cColour.
 749     */
 750     virtual wxGraphicsBrush CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 751                                                       wxDouble xc, wxDouble yc,
 752                                                       wxDouble radius,
 753                                                       const wxColour& oColour,
 754                                                       const wxColour& cColour) = 0;
 755
 756     /**
 757         Returns the default renderer on this platform. On OS X this is the Core
 758         Graphics (a.k.a. Quartz 2D) renderer, on MSW the GDIPlus renderer, and
 759         on GTK we currently default to the cairo renderer.
 760     */
 761     static wxGraphicsRenderer* GetDefaultRenderer();
 762 };
 763
 764
 765
 766 /**
 767     @class wxGraphicsBrush
 768
 769     A wxGraphicsBrush is a native representation of a brush. The contents are
 770     specific and private to the respective renderer. Instances are ref counted
 771     and can therefore be assigned as usual. The only way to get a valid
 772     instance is via wxGraphicsContext::CreateBrush() or
 773     wxGraphicsRenderer::CreateBrush().
 774
 775     @library{wxcore}
 776     @category{gdi}
 777 */
 778 class wxGraphicsBrush : public wxGraphicsObject
 779 {
 780 public:
 781
 782 };
 783
 784
 785
 786 /**
 787     @class wxGraphicsFont
 788
 789     A wxGraphicsFont is a native representation of a font. The contents are
 790     specific and private to the respective renderer. Instances are ref counted
 791     and can therefore be assigned as usual. The only way to get a valid
 792     instance is via wxGraphicsContext::CreateFont() or
 793     wxGraphicsRenderer::CreateFont().
 794
 795     @library{wxcore}
 796     @category{gdi}
 797 */
 798 class wxGraphicsFont : public wxGraphicsObject
 799 {
 800 public:
 801
 802 };
 803
 804
 805
 806 /**
 807     @class wxGraphicsPen
 808
 809     A wxGraphicsPen is a native representation of a pen. The contents are
 810     specific and private to the respective renderer. Instances are ref counted
 811     and can therefore be assigned as usual. The only way to get a valid
 812     instance is via wxGraphicsContext::CreatePen() or
 813     wxGraphicsRenderer::CreatePen().
 814
 815     @library{wxcore}
 816     @category{gdi}
 817 */
 818 class wxGraphicsPen : public wxGraphicsObject
 819 {
 820 public:
 821
 822 };
 823
 824
 825
 826 /**
 827     @class wxGraphicsMatrix
 828
 829     A wxGraphicsMatrix is a native representation of an affine matrix. The
 830     contents are specific and private to the respective renderer. Instances are
 831     ref counted and can therefore be assigned as usual. The only way to get a
 832     valid instance is via wxGraphicsContext::CreateMatrix() or
 833     wxGraphicsRenderer::CreateMatrix().
 834
 835     @library{wxcore}
 836     @category{gdi}
 837 */
 838 class wxGraphicsMatrix : public wxGraphicsObject
 839 {
 840 public:
 841     /**
 842         Concatenates the matrix passed with the current matrix.
 843     */
 844     virtual void Concat(const wxGraphicsMatrix* t);
 845     /**
 846         Concatenates the matrix passed with the current matrix.
 847     */
 848     void Concat(const wxGraphicsMatrix& t);
 849
 850     /**
 851         Returns the component values of the matrix via the argument pointers.
 852     */
 853     virtual void Get(wxDouble* a = NULL, wxDouble* b = NULL,
 854                      wxDouble* c = NULL, wxDouble* d = NULL,
 855                      wxDouble* tx = NULL, wxDouble* ty = NULL) const;
 856
 857     /**
 858         Returns the native representation of the matrix. For CoreGraphics this
 859         is a CFAffineMatrix pointer, for GDIPlus a Matrix Pointer, and for
 860         Cairo a cairo_matrix_t pointer.
 861     */
 862     virtual void* GetNativeMatrix() const;
 863
 864     /**
 865         Inverts the matrix.
 866     */
 867     virtual void Invert();
 868
 869     /**
 870         Returns @true if the elements of the transformation matrix are equal.
 871     */
 872     virtual bool IsEqual(const wxGraphicsMatrix* t) const;
 873     /**
 874         Returns @true if the elements of the transformation matrix are equal.
 875     */
 876     bool IsEqual(const wxGraphicsMatrix& t) const;
 877
 878     /**
 879         Return @true if this is the identity matrix.
 880     */
 881     virtual bool IsIdentity() const;
 882
 883     /**
 884         Rotates this matrix (in radians).
 885     */
 886     virtual void Rotate(wxDouble angle);
 887
 888     /**
 889         Scales this matrix.
 890     */
 891     virtual void Scale(wxDouble xScale, wxDouble yScale);
 892
 893     /**
 894         Sets the matrix to the respective values (default values are the
 895         identity matrix).
 896     */
 897     virtual void Set(wxDouble a = 1.0, wxDouble b = 0.0, wxDouble c = 0.0,
 898                      wxDouble d = 1.0, wxDouble tx = 0.0, wxDouble ty = 0.0);
 899
 900     /**
 901         Applies this matrix to a distance (ie. performs all transforms except
 902         translations).
 903     */
 904     virtual void TransformDistance(wxDouble* dx, wxDouble* dy) const;
 905
 906     /**
 907         Applies this matrix to a point.
 908     */
 909     virtual void TransformPoint(wxDouble* x, wxDouble* y) const;
 910
 911     /**
 912         Translates this matrix.
 913     */
 914     virtual void Translate(wxDouble dx, wxDouble dy);
 915 };
 916