src/common/graphcmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/graphcmn.cpp
   3 // Purpose:     graphics context methods common to all platforms
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Stefan Csomor
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #if defined(__BORLANDC__)
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_GRAPHICS_CONTEXT
  20
  21 #include "wx/private/graphics.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/icon.h"
  25     #include "wx/bitmap.h"
  26     #include "wx/dcmemory.h"
  27     #include "wx/region.h"
  28     #include "wx/log.h"
  29 #endif
  30
  31 //-----------------------------------------------------------------------------
  32 // constants
  33 //-----------------------------------------------------------------------------
  34
  35 static const double RAD2DEG = 180.0 / M_PI;
  36
  37 //-----------------------------------------------------------------------------
  38 // Local functions
  39 //-----------------------------------------------------------------------------
  40
  41 static inline double DegToRad(double deg)
  42 {
  43     return (deg * M_PI) / 180.0;
  44 }
  45
  46 //-----------------------------------------------------------------------------
  47
  48 //-----------------------------------------------------------------------------
  49 // wxGraphicsObject
  50 //-----------------------------------------------------------------------------
  51
  52 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsObject, wxObject)
  53
  54 wxGraphicsObjectRefData::wxGraphicsObjectRefData( wxGraphicsRenderer* renderer )
  55 {
  56     m_renderer = renderer;
  57 }
  58 wxGraphicsObjectRefData::wxGraphicsObjectRefData( const wxGraphicsObjectRefData* data )
  59 {
  60     m_renderer = data->m_renderer;
  61 }
  62 wxGraphicsRenderer* wxGraphicsObjectRefData::GetRenderer() const
  63 {
  64     return m_renderer ;
  65 }
  66
  67 wxGraphicsObjectRefData* wxGraphicsObjectRefData::Clone() const
  68 {
  69     return new wxGraphicsObjectRefData(this);
  70 }
  71
  72 wxGraphicsObject::wxGraphicsObject()
  73 {
  74 }
  75
  76 wxGraphicsObject::wxGraphicsObject( wxGraphicsRenderer* renderer )
  77 {
  78     SetRefData( new wxGraphicsObjectRefData(renderer));
  79 }
  80
  81 wxGraphicsObject::~wxGraphicsObject()
  82 {
  83 }
  84
  85 bool wxGraphicsObject::IsNull() const
  86 {
  87     return m_refData == NULL;
  88 }
  89
  90 wxGraphicsRenderer* wxGraphicsObject::GetRenderer() const
  91 {
  92     return ( IsNull() ? NULL : GetGraphicsData()->GetRenderer() );
  93 }
  94
  95 wxGraphicsObjectRefData* wxGraphicsObject::GetGraphicsData() const
  96 {
  97     return (wxGraphicsObjectRefData*) m_refData;
  98 }
  99
 100 wxObjectRefData* wxGraphicsObject::CreateRefData() const
 101 {
 102     wxLogDebug(wxT("A Null Object cannot be changed"));
 103     return NULL;
 104 }
 105
 106 wxObjectRefData* wxGraphicsObject::CloneRefData(const wxObjectRefData* data) const
 107 {
 108     const wxGraphicsObjectRefData* ptr = (const wxGraphicsObjectRefData*) data;
 109     return ptr->Clone();
 110 }
 111
 112 //-----------------------------------------------------------------------------
 113 // pens etc.
 114 //-----------------------------------------------------------------------------
 115
 116 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsPen, wxGraphicsObject)
 117 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsBrush, wxGraphicsObject)
 118 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsFont, wxGraphicsObject)
 119 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsBitmap, wxGraphicsObject)
 120
 121 WXDLLIMPEXP_DATA_CORE(wxGraphicsPen) wxNullGraphicsPen;
 122 WXDLLIMPEXP_DATA_CORE(wxGraphicsBrush) wxNullGraphicsBrush;
 123 WXDLLIMPEXP_DATA_CORE(wxGraphicsFont) wxNullGraphicsFont;
 124 WXDLLIMPEXP_DATA_CORE(wxGraphicsBitmap) wxNullGraphicsBitmap;
 125
 126 //-----------------------------------------------------------------------------
 127 // matrix
 128 //-----------------------------------------------------------------------------
 129
 130 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsMatrix, wxGraphicsObject)
 131 WXDLLIMPEXP_DATA_CORE(wxGraphicsMatrix) wxNullGraphicsMatrix;
 132
 133 // concatenates the matrix
 134 void wxGraphicsMatrix::Concat( const wxGraphicsMatrix *t )
 135 {
 136     AllocExclusive();
 137     GetMatrixData()->Concat(t->GetMatrixData());
 138 }
 139
 140 // sets the matrix to the respective values
 141 void wxGraphicsMatrix::Set(wxDouble a, wxDouble b, wxDouble c, wxDouble d,
 142                            wxDouble tx, wxDouble ty)
 143 {
 144     AllocExclusive();
 145     GetMatrixData()->Set(a,b,c,d,tx,ty);
 146 }
 147
 148 // gets the component valuess of the matrix
 149 void wxGraphicsMatrix::Get(wxDouble* a, wxDouble* b,  wxDouble* c,
 150                            wxDouble* d, wxDouble* tx, wxDouble* ty) const
 151 {
 152     GetMatrixData()->Get(a, b, c, d, tx, ty);
 153 }
 154
 155 // makes this the inverse matrix
 156 void wxGraphicsMatrix::Invert()
 157 {
 158     AllocExclusive();
 159     GetMatrixData()->Invert();
 160 }
 161
 162 // returns true if the elements of the transformation matrix are equal ?
 163 bool wxGraphicsMatrix::IsEqual( const wxGraphicsMatrix* t) const
 164 {
 165     return GetMatrixData()->IsEqual(t->GetMatrixData());
 166 }
 167
 168 // return true if this is the identity matrix
 169 bool wxGraphicsMatrix::IsIdentity() const
 170 {
 171     return GetMatrixData()->IsIdentity();
 172 }
 173
 174 // add the translation to this matrix
 175 void wxGraphicsMatrix::Translate( wxDouble dx , wxDouble dy )
 176 {
 177     AllocExclusive();
 178     GetMatrixData()->Translate(dx,dy);
 179 }
 180
 181 // add the scale to this matrix
 182 void wxGraphicsMatrix::Scale( wxDouble xScale , wxDouble yScale )
 183 {
 184     AllocExclusive();
 185     GetMatrixData()->Scale(xScale,yScale);
 186 }
 187
 188 // add the rotation to this matrix (radians)
 189 void wxGraphicsMatrix::Rotate( wxDouble angle )
 190 {
 191     AllocExclusive();
 192     GetMatrixData()->Rotate(angle);
 193 }
 194
 195 //
 196 // apply the transforms
 197 //
 198
 199 // applies that matrix to the point
 200 void wxGraphicsMatrix::TransformPoint( wxDouble *x, wxDouble *y ) const
 201 {
 202     GetMatrixData()->TransformPoint(x,y);
 203 }
 204
 205 // applies the matrix except for translations
 206 void wxGraphicsMatrix::TransformDistance( wxDouble *dx, wxDouble *dy ) const
 207 {
 208     GetMatrixData()->TransformDistance(dx,dy);
 209 }
 210
 211 // returns the native representation
 212 void * wxGraphicsMatrix::GetNativeMatrix() const
 213 {
 214     return GetMatrixData()->GetNativeMatrix();
 215 }
 216
 217 //-----------------------------------------------------------------------------
 218 // path
 219 //-----------------------------------------------------------------------------
 220
 221 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsPath, wxGraphicsObject)
 222 WXDLLIMPEXP_DATA_CORE(wxGraphicsPath) wxNullGraphicsPath;
 223
 224 // convenience functions, for using wxPoint2DDouble etc
 225
 226 wxPoint2DDouble wxGraphicsPath::GetCurrentPoint() const
 227 {
 228     wxDouble x,y;
 229     GetCurrentPoint(&x,&y);
 230     return wxPoint2DDouble(x,y);
 231 }
 232
 233 void wxGraphicsPath::MoveToPoint( const wxPoint2DDouble& p)
 234 {
 235     MoveToPoint( p.m_x , p.m_y);
 236 }
 237
 238 void wxGraphicsPath::AddLineToPoint( const wxPoint2DDouble& p)
 239 {
 240     AddLineToPoint( p.m_x , p.m_y);
 241 }
 242
 243 void wxGraphicsPath::AddCurveToPoint( const wxPoint2DDouble& c1, const wxPoint2DDouble& c2, const wxPoint2DDouble& e)
 244 {
 245     AddCurveToPoint(c1.m_x, c1.m_y, c2.m_x, c2.m_y, e.m_x, e.m_y);
 246 }
 247
 248 void wxGraphicsPath::AddArc( const wxPoint2DDouble& c, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise)
 249 {
 250     AddArc(c.m_x, c.m_y, r, startAngle, endAngle, clockwise);
 251 }
 252
 253 wxRect2DDouble wxGraphicsPath::GetBox() const
 254 {
 255         wxDouble x,y,w,h;
 256         GetBox(&x,&y,&w,&h);
 257         return wxRect2DDouble( x,y,w,h );
 258 }
 259
 260 bool wxGraphicsPath::Contains( const wxPoint2DDouble& c, int fillStyle ) const
 261 {
 262     return Contains( c.m_x, c.m_y, fillStyle);
 263 }
 264
 265 // true redirections
 266
 267 // begins a new subpath at (x,y)
 268 void wxGraphicsPath::MoveToPoint( wxDouble x, wxDouble y )
 269 {
 270     AllocExclusive();
 271     GetPathData()->MoveToPoint(x,y);
 272 }
 273
 274 // adds a straight line from the current point to (x,y)
 275 void wxGraphicsPath::AddLineToPoint( wxDouble x, wxDouble y )
 276 {
 277     AllocExclusive();
 278     GetPathData()->AddLineToPoint(x,y);
 279 }
 280
 281 // adds a cubic Bezier curve from the current point, using two control points and an end point
 282 void wxGraphicsPath::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
 283 {
 284     AllocExclusive();
 285     GetPathData()->AddCurveToPoint(cx1,cy1,cx2,cy2,x,y);
 286 }
 287
 288 // adds another path
 289 void wxGraphicsPath::AddPath( const wxGraphicsPath& path )
 290 {
 291     AllocExclusive();
 292     GetPathData()->AddPath(path.GetPathData());
 293 }
 294
 295 // closes the current sub-path
 296 void wxGraphicsPath::CloseSubpath()
 297 {
 298     AllocExclusive();
 299     GetPathData()->CloseSubpath();
 300 }
 301
 302 // gets the last point of the current path, (0,0) if not yet set
 303 void wxGraphicsPath::GetCurrentPoint( wxDouble* x, wxDouble* y) const
 304 {
 305     GetPathData()->GetCurrentPoint(x,y);
 306 }
 307
 308 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
 309 void wxGraphicsPath::AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise )
 310 {
 311     AllocExclusive();
 312     GetPathData()->AddArc(x,y,r,startAngle,endAngle,clockwise);
 313 }
 314
 315 //
 316 // These are convenience functions which - if not available natively will be assembled
 317 // using the primitives from above
 318 //
 319
 320 // adds a quadratic Bezier curve from the current point, using a control point and an end point
 321 void wxGraphicsPath::AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y )
 322 {
 323     AllocExclusive();
 324     GetPathData()->AddQuadCurveToPoint(cx,cy,x,y);
 325 }
 326
 327 // appends a rectangle as a new closed subpath
 328 void wxGraphicsPath::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 329 {
 330     AllocExclusive();
 331     GetPathData()->AddRectangle(x,y,w,h);
 332 }
 333
 334 // appends an ellipsis as a new closed subpath fitting the passed rectangle
 335 void wxGraphicsPath::AddCircle( wxDouble x, wxDouble y, wxDouble r )
 336 {
 337     AllocExclusive();
 338     GetPathData()->AddCircle(x,y,r);
 339 }
 340
 341 // appends a an arc to two tangents connecting (current) to (x1,y1) and (x1,y1) to (x2,y2), also a straight line from (current) to (x1,y1)
 342 void wxGraphicsPath::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
 343 {
 344     GetPathData()->AddArcToPoint(x1,y1,x2,y2,r);
 345 }
 346
 347 // appends an ellipse
 348 void wxGraphicsPath::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
 349 {
 350     AllocExclusive();
 351     GetPathData()->AddEllipse(x,y,w,h);
 352 }
 353
 354 // appends a rounded rectangle
 355 void wxGraphicsPath::AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
 356 {
 357     AllocExclusive();
 358     GetPathData()->AddRoundedRectangle(x,y,w,h,radius);
 359 }
 360
 361 // returns the native path
 362 void * wxGraphicsPath::GetNativePath() const
 363 {
 364     return GetPathData()->GetNativePath();
 365 }
 366
 367 // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
 368 void wxGraphicsPath::UnGetNativePath(void *p)const
 369 {
 370     GetPathData()->UnGetNativePath(p);
 371 }
 372
 373 // transforms each point of this path by the matrix
 374 void wxGraphicsPath::Transform( const wxGraphicsMatrix& matrix )
 375 {
 376     AllocExclusive();
 377     GetPathData()->Transform(matrix.GetMatrixData());
 378 }
 379
 380 // gets the bounding box enclosing all points (possibly including control points)
 381 void wxGraphicsPath::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
 382 {
 383     GetPathData()->GetBox(x,y,w,h);
 384 }
 385
 386 bool wxGraphicsPath::Contains( wxDouble x, wxDouble y, int fillStyle ) const
 387 {
 388     return GetPathData()->Contains(x,y,fillStyle);
 389 }
 390
 391 //
 392 // Emulations, these mus be implemented in the ...Data classes in order to allow for proper overrides
 393 //
 394
 395 void wxGraphicsPathData::AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y )
 396 {
 397     // calculate using degree elevation to a cubic bezier
 398     wxPoint2DDouble c1;
 399     wxPoint2DDouble c2;
 400
 401     wxPoint2DDouble start;
 402     GetCurrentPoint(&start.m_x,&start.m_y);
 403     wxPoint2DDouble end(x,y);
 404     wxPoint2DDouble c(cx,cy);
 405     c1 = wxDouble(1/3.0) * start + wxDouble(2/3.0) * c;
 406     c2 = wxDouble(2/3.0) * c + wxDouble(1/3.0) * end;
 407     AddCurveToPoint(c1.m_x,c1.m_y,c2.m_x,c2.m_y,x,y);
 408 }
 409
 410 void wxGraphicsPathData::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 411 {
 412     MoveToPoint(x,y);
 413     AddLineToPoint(x,y+h);
 414     AddLineToPoint(x+w,y+h);
 415     AddLineToPoint(x+w,y);
 416     CloseSubpath();
 417 }
 418
 419 void wxGraphicsPathData::AddCircle( wxDouble x, wxDouble y, wxDouble r )
 420 {
 421     MoveToPoint(x+r,y);
 422     AddArc( x,y,r,0,2*M_PI,false);
 423     CloseSubpath();
 424 }
 425
 426 void wxGraphicsPathData::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
 427 {
 428     if (w <= 0. || h <= 0.)
 429       return;
 430
 431     wxDouble rw = w/2;
 432     wxDouble rh = h/2;
 433     wxDouble xc = x + rw;
 434     wxDouble yc = y + rh;
 435     wxGraphicsMatrix m = GetRenderer()->CreateMatrix();
 436     m.Translate(xc,yc);
 437     m.Scale(rw/rh,1.0);
 438     wxGraphicsPath p = GetRenderer()->CreatePath();
 439     p.AddCircle(0,0,rh);
 440     p.Transform(m);
 441     AddPath(p.GetPathData());
 442 }
 443
 444 void wxGraphicsPathData::AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
 445 {
 446     if ( radius == 0 )
 447         AddRectangle(x,y,w,h);
 448     else
 449     {
 450         MoveToPoint( x + w, y + h / 2);
 451         AddArcToPoint(x + w, y + h, x + w / 2, y + h, radius);
 452         AddArcToPoint(x, y + h, x, y + h / 2, radius);
 453         AddArcToPoint(x, y , x + w / 2, y, radius);
 454         AddArcToPoint(x + w, y, x + w, y + h / 2, radius);
 455         CloseSubpath();
 456     }
 457 }
 458
 459 // draws a an arc to two tangents connecting (current) to (x1,y1) and (x1,y1) to (x2,y2), also a straight line from (current) to (x1,y1)
 460 void wxGraphicsPathData::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
 461 {
 462     wxPoint2DDouble current;
 463     GetCurrentPoint(&current.m_x,&current.m_y);
 464     wxPoint2DDouble p1(x1,y1);
 465     wxPoint2DDouble p2(x2,y2);
 466
 467     wxPoint2DDouble v1 = current - p1;
 468     v1.Normalize();
 469     wxPoint2DDouble v2 = p2 - p1;
 470     v2.Normalize();
 471
 472     wxDouble alpha = v1.GetVectorAngle() - v2.GetVectorAngle();
 473
 474     if ( alpha < 0 )
 475         alpha = 360 + alpha;
 476     // TODO obtuse angles
 477
 478     alpha = DegToRad(alpha);
 479
 480     wxDouble dist = r / sin(alpha/2) * cos(alpha/2);
 481     // calculate tangential points
 482     wxPoint2DDouble t1 = dist*v1 + p1;
 483     wxPoint2DDouble t2 = dist*v2 + p1;
 484
 485     wxPoint2DDouble nv1 = v1;
 486     nv1.SetVectorAngle(v1.GetVectorAngle()-90);
 487     wxPoint2DDouble c = t1 + r*nv1;
 488
 489     wxDouble a1 = v1.GetVectorAngle()+90;
 490     wxDouble a2 = v2.GetVectorAngle()-90;
 491
 492     AddLineToPoint(t1.m_x,t1.m_y);
 493     AddArc(c.m_x,c.m_y,r,DegToRad(a1),DegToRad(a2),true);
 494     AddLineToPoint(p2.m_x,p2.m_y);
 495 }
 496
 497 //-----------------------------------------------------------------------------
 498 // wxGraphicsContext Convenience Methods
 499 //-----------------------------------------------------------------------------
 500
 501 IMPLEMENT_ABSTRACT_CLASS(wxGraphicsContext, wxObject)
 502
 503
 504 wxGraphicsContext::wxGraphicsContext(wxGraphicsRenderer* renderer) : wxGraphicsObject(renderer)
 505 {
 506     m_logicalFunction = wxCOPY;
 507 }
 508
 509 wxGraphicsContext::~wxGraphicsContext()
 510 {
 511 }
 512
 513 bool wxGraphicsContext::StartDoc(const wxString& WXUNUSED(message))
 514 {
 515     return true;
 516 }
 517
 518 void wxGraphicsContext::EndDoc()
 519 {
 520 }
 521
 522 void wxGraphicsContext::StartPage(wxDouble WXUNUSED(width),
 523                                   wxDouble WXUNUSED(height))
 524 {
 525 }
 526
 527 void wxGraphicsContext::EndPage()
 528 {
 529 }
 530
 531 void wxGraphicsContext::Flush()
 532 {
 533 }
 534
 535 #if 0
 536 void wxGraphicsContext::SetAlpha( wxDouble WXUNUSED(alpha) )
 537 {
 538 }
 539
 540 wxDouble wxGraphicsContext::GetAlpha() const
 541 {
 542     return 1.0;
 543 }
 544 #endif
 545
 546 void wxGraphicsContext::GetSize( wxDouble* width, wxDouble* height)
 547 {
 548     *width = 10000.0;
 549     *height = 10000.0;
 550 }
 551
 552 void wxGraphicsContext::GetDPI( wxDouble* dpiX, wxDouble* dpiY)
 553 {
 554     *dpiX = 72.0;
 555     *dpiY = 72.0;
 556 }
 557
 558 // sets the pen
 559 void wxGraphicsContext::SetPen( const wxGraphicsPen& pen )
 560 {
 561     m_pen = pen;
 562 }
 563
 564 void wxGraphicsContext::SetPen( const wxPen& pen )
 565 {
 566     if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
 567         SetPen( wxNullGraphicsPen );
 568     else
 569         SetPen( CreatePen( pen ) );
 570 }
 571
 572 // sets the brush for filling
 573 void wxGraphicsContext::SetBrush( const wxGraphicsBrush& brush )
 574 {
 575     m_brush = brush;
 576 }
 577
 578 void wxGraphicsContext::SetBrush( const wxBrush& brush )
 579 {
 580     if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
 581         SetBrush( wxNullGraphicsBrush );
 582     else
 583         SetBrush( CreateBrush( brush ) );
 584 }
 585
 586 // sets the brush for filling
 587 void wxGraphicsContext::SetFont( const wxGraphicsFont& font )
 588 {
 589     m_font = font;
 590 }
 591
 592 bool wxGraphicsContext::SetLogicalFunction( int function )
 593 {
 594     if ( function == wxCOPY )
 595     {
 596         m_logicalFunction = function;
 597         return true;
 598     }
 599     return false;
 600 }
 601
 602 void wxGraphicsContext::SetFont( const wxFont& font, const wxColour& colour )
 603 {
 604     if ( font.Ok() )
 605         SetFont( CreateFont( font, colour ) );
 606     else
 607         SetFont( wxNullGraphicsFont );
 608 }
 609
 610 void wxGraphicsContext::DrawPath( const wxGraphicsPath& path, int fillStyle )
 611 {
 612     FillPath( path , fillStyle );
 613     StrokePath( path );
 614 }
 615
 616 void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle )
 617 {
 618     Translate(x,y);
 619     Rotate( -angle );
 620     DrawText( str , 0, 0 );
 621     Rotate( angle );
 622     Translate(-x,-y);
 623 }
 624
 625 void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, const wxGraphicsBrush& backgroundBrush )
 626 {
 627     wxGraphicsBrush formerBrush = m_brush;
 628         wxGraphicsPen formerPen = m_pen;
 629     wxDouble width;
 630     wxDouble height;
 631     wxDouble descent;
 632     wxDouble externalLeading;
 633     GetTextExtent( str , &width, &height, &descent, &externalLeading );
 634     SetBrush( backgroundBrush );
 635         // to make sure our 'OffsetToPixelBoundaries' doesn't move the fill shape
 636         SetPen( wxNullGraphicsPen );
 637
 638     wxGraphicsPath path = CreatePath();
 639     path.AddRectangle( x , y, width, height );
 640     FillPath( path );
 641
 642     DrawText( str, x ,y);
 643     SetBrush( formerBrush );
 644         SetPen( formerPen );
 645 }
 646
 647 void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle, const wxGraphicsBrush& backgroundBrush )
 648 {
 649     wxGraphicsBrush formerBrush = m_brush;
 650         wxGraphicsPen formerPen = m_pen;
 651
 652     wxDouble width;
 653     wxDouble height;
 654     wxDouble descent;
 655     wxDouble externalLeading;
 656     GetTextExtent( str , &width, &height, &descent, &externalLeading );
 657     SetBrush( backgroundBrush );
 658         // to make sure our 'OffsetToPixelBoundaries' doesn't move the fill shape
 659         SetPen( wxNullGraphicsPen );
 660
 661     wxGraphicsPath path = CreatePath();
 662     path.MoveToPoint( x , y );
 663     path.AddLineToPoint( (int) (x + sin(angle) * height) , (int) (y + cos(angle) * height) );
 664     path.AddLineToPoint(
 665         (int) (x + sin(angle) * height + cos(angle) * width) ,
 666         (int) (y + cos(angle) * height - sin(angle) * width));
 667     path.AddLineToPoint((int) (x + cos(angle) * width) , (int) (y - sin(angle) * width) );
 668     FillPath( path );
 669     DrawText( str, x ,y, angle);
 670     SetBrush( formerBrush );
 671         SetPen( formerPen );
 672 }
 673
 674 void wxGraphicsContext::StrokeLine( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2)
 675 {
 676     wxGraphicsPath path = CreatePath();
 677     path.MoveToPoint(x1, y1);
 678     path.AddLineToPoint( x2, y2 );
 679     StrokePath( path );
 680 }
 681
 682 void wxGraphicsContext::DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
 683 {
 684     wxGraphicsPath path = CreatePath();
 685     path.AddRectangle( x , y , w , h );
 686     DrawPath( path );
 687 }
 688
 689 void wxGraphicsContext::DrawEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
 690 {
 691     wxGraphicsPath path = CreatePath();
 692     path.AddEllipse(x,y,w,h);
 693     DrawPath(path);
 694 }
 695
 696 void wxGraphicsContext::DrawRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
 697 {
 698     wxGraphicsPath path = CreatePath();
 699     path.AddRoundedRectangle(x,y,w,h,radius);
 700     DrawPath(path);
 701 }
 702
 703 void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *points)
 704 {
 705     wxASSERT(n > 1);
 706     wxGraphicsPath path = CreatePath();
 707     path.MoveToPoint(points[0].m_x, points[0].m_y);
 708     for ( size_t i = 1; i < n; ++i)
 709         path.AddLineToPoint( points[i].m_x, points[i].m_y );
 710     StrokePath( path );
 711 }
 712
 713 void wxGraphicsContext::DrawLines( size_t n, const wxPoint2DDouble *points, int fillStyle)
 714 {
 715     wxASSERT(n > 1);
 716     wxGraphicsPath path = CreatePath();
 717     path.MoveToPoint(points[0].m_x, points[0].m_y);
 718     for ( size_t i = 1; i < n; ++i)
 719         path.AddLineToPoint( points[i].m_x, points[i].m_y );
 720     DrawPath( path , fillStyle);
 721 }
 722
 723 void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *beginPoints, const wxPoint2DDouble *endPoints)
 724 {
 725     wxASSERT(n > 0);
 726     wxGraphicsPath path = CreatePath();
 727     for ( size_t i = 0; i < n; ++i)
 728     {
 729         path.MoveToPoint(beginPoints[i].m_x, beginPoints[i].m_y);
 730         path.AddLineToPoint( endPoints[i].m_x, endPoints[i].m_y );
 731     }
 732     StrokePath( path );
 733 }
 734
 735 // create a 'native' matrix corresponding to these values
 736 wxGraphicsMatrix wxGraphicsContext::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
 737     wxDouble tx, wxDouble ty) const
 738 {
 739     return GetRenderer()->CreateMatrix(a,b,c,d,tx,ty);
 740 }
 741
 742 wxGraphicsPath wxGraphicsContext::CreatePath() const
 743 {
 744     return GetRenderer()->CreatePath();
 745 }
 746
 747 wxGraphicsPen wxGraphicsContext::CreatePen(const wxPen& pen) const
 748 {
 749     return GetRenderer()->CreatePen(pen);
 750 }
 751
 752 wxGraphicsBrush wxGraphicsContext::CreateBrush(const wxBrush& brush ) const
 753 {
 754     return GetRenderer()->CreateBrush(brush);
 755 }
 756
 757 // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
 758 wxGraphicsBrush wxGraphicsContext::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
 759                                                    const wxColour&c1, const wxColour&c2) const
 760 {
 761     return GetRenderer()->CreateLinearGradientBrush(x1,y1,x2,y2,c1,c2);
 762 }
 763
 764 // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
 765 // with radius r and color cColor
 766 wxGraphicsBrush wxGraphicsContext::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
 767                                                    const wxColour &oColor, const wxColour &cColor) const
 768 {
 769     return GetRenderer()->CreateRadialGradientBrush(xo,yo,xc,yc,radius,oColor,cColor);
 770 }
 771
 772 // sets the font
 773 wxGraphicsFont wxGraphicsContext::CreateFont( const wxFont &font , const wxColour &col ) const
 774 {
 775     return GetRenderer()->CreateFont(font,col);
 776 }
 777
 778 wxGraphicsBitmap wxGraphicsContext::CreateBitmap( const wxBitmap& bmp ) const
 779 {
 780 #ifndef __WXGTK20__
 781     return GetRenderer()->CreateBitmap(bmp);
 782 #else
 783     return wxNullGraphicsBitmap;
 784 #endif
 785 }
 786
 787 wxGraphicsBitmap wxGraphicsContext::CreateSubBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h   ) const
 788 {
 789 #ifndef __WXGTK20__
 790     return GetRenderer()->CreateSubBitmap(bmp,x,y,w,h);
 791 #else
 792     return wxNullGraphicsBitmap;
 793 #endif
 794 }
 795
 796 /* static */ wxGraphicsContext* wxGraphicsContext::Create( const wxWindowDC& dc)
 797 {
 798     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
 799 }
 800
 801 /* static */ wxGraphicsContext* wxGraphicsContext::Create( const wxMemoryDC& dc)
 802 {
 803     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
 804 }
 805
 806 #if wxUSE_PRINTING_ARCHITECTURE
 807 /* static */ wxGraphicsContext* wxGraphicsContext::Create( const wxPrinterDC& dc)
 808 {
 809     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
 810 }
 811 #endif
 812
 813 wxGraphicsContext* wxGraphicsContext::CreateFromNative( void * context )
 814 {
 815     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContextFromNativeContext(context);
 816 }
 817
 818 wxGraphicsContext* wxGraphicsContext::CreateFromNativeWindow( void * window )
 819 {
 820     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContextFromNativeWindow(window);
 821 }
 822
 823 wxGraphicsContext* wxGraphicsContext::Create( wxWindow* window )
 824 {
 825     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(window);
 826 }
 827
 828 wxGraphicsContext* wxGraphicsContext::Create()
 829 {
 830     return wxGraphicsRenderer::GetDefaultRenderer()->CreateMeasuringContext();
 831 }
 832
 833 //-----------------------------------------------------------------------------
 834 // wxGraphicsRenderer
 835 //-----------------------------------------------------------------------------
 836
 837 IMPLEMENT_ABSTRACT_CLASS(wxGraphicsRenderer, wxObject)
 838
 839 #endif // wxUSE_GRAPHICS_CONTEXT