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