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