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