src/common/dcgraph.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 #include "wx/dcgraph.h"
  23
  24 #ifndef WX_PRECOMP
  25     #include "wx/icon.h"
  26     #include "wx/bitmap.h"
  27     #include "wx/dcmemory.h"
  28     #include "wx/region.h"
  29 #endif
  30
  31 #ifdef __WXMAC__
  32 #include "wx/mac/private.h"
  33 #endif
  34 //-----------------------------------------------------------------------------
  35 // constants
  36 //-----------------------------------------------------------------------------
  37
  38 static const double RAD2DEG = 180.0 / M_PI;
  39
  40 //-----------------------------------------------------------------------------
  41 // Local functions
  42 //-----------------------------------------------------------------------------
  43
  44 static inline double DegToRad(double deg)
  45 {
  46     return (deg * M_PI) / 180.0;
  47 }
  48
  49 //-----------------------------------------------------------------------------
  50 // wxDC bridge class
  51 //-----------------------------------------------------------------------------
  52
  53 IMPLEMENT_DYNAMIC_CLASS(wxGCDC, wxDC)
  54
  55 wxGCDC::wxGCDC(const wxWindowDC& dc)
  56 {
  57     m_pimpl = new wxGCDCImpl( this, dc );
  58 }
  59
  60 wxGCDC::wxGCDC( const wxMemoryDC& dc)
  61 {
  62     m_pimpl = new wxGCDCImpl( this, dc );
  63 }
  64
  65 wxGCDC::wxGCDC()
  66 {
  67     m_pimpl = new wxGCDCImpl( this );
  68 }
  69
  70 wxGraphicsContext* wxGCDC::GetGraphicsContext()
  71 {
  72     if (!m_pimpl) return NULL;
  73     wxGCDCImpl *gc_impl = (wxGCDCImpl*) m_pimpl;
  74     return gc_impl->GetGraphicsContext();
  75 }
  76
  77 void wxGCDC::SetGraphicsContext( wxGraphicsContext* ctx )
  78 {
  79     if (!m_pimpl) return;
  80     wxGCDCImpl *gc_impl = (wxGCDCImpl*) m_pimpl;
  81     gc_impl->SetGraphicsContext( ctx );
  82 }
  83
  84 IMPLEMENT_ABSTRACT_CLASS(wxGCDCImpl, wxDCImpl)
  85
  86 wxGCDCImpl::wxGCDCImpl( wxDC *owner ) :
  87    wxDCImpl( owner )
  88 {
  89     Init();
  90 }
  91
  92 void wxGCDCImpl::SetGraphicsContext( wxGraphicsContext* ctx )
  93 {
  94     delete m_graphicContext;
  95     m_graphicContext = ctx;
  96     if ( m_graphicContext )
  97     {
  98         m_matrixOriginal = m_graphicContext->GetTransform();
  99         m_ok = true;
 100         // apply the stored transformations to the passed in context
 101         ComputeScaleAndOrigin();
 102         m_graphicContext->SetFont( m_font , m_textForegroundColour );
 103         m_graphicContext->SetPen( m_pen );
 104         m_graphicContext->SetBrush( m_brush);
 105     }
 106 }
 107
 108 wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxWindowDC& dc ) :
 109    wxDCImpl( owner )
 110 {
 111     Init();
 112     SetGraphicsContext( wxGraphicsContext::Create(dc) );
 113 }
 114
 115 wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxMemoryDC& dc ) :
 116    wxDCImpl( owner )
 117 {
 118     Init();
 119     SetGraphicsContext( wxGraphicsContext::Create(dc) );
 120 }
 121
 122 void wxGCDCImpl::Init()
 123 {
 124     m_ok = false;
 125     m_colour = true;
 126     m_mm_to_pix_x = mm2pt;
 127     m_mm_to_pix_y = mm2pt;
 128
 129     m_pen = *wxBLACK_PEN;
 130     m_font = *wxNORMAL_FONT;
 131     m_brush = *wxWHITE_BRUSH;
 132
 133     m_graphicContext = NULL;
 134     m_logicalFunctionSupported = true;
 135 }
 136
 137
 138 wxGCDCImpl::~wxGCDCImpl()
 139 {
 140     delete m_graphicContext;
 141 }
 142
 143 void wxGCDCImpl::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool WXUNUSED(useMask) )
 144 {
 145     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid DC") );
 146     wxCHECK_RET( bmp.IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid bitmap") );
 147
 148     if ( bmp.GetDepth() == 1 )
 149     {
 150         m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
 151         m_graphicContext->SetBrush( wxBrush( m_textBackgroundColour , wxSOLID ) );
 152         m_graphicContext->DrawRectangle( x , y , bmp.GetWidth() , bmp.GetHeight() );
 153         m_graphicContext->SetBrush( wxBrush( m_textForegroundColour , wxSOLID ) );
 154         m_graphicContext->DrawBitmap( bmp, x , y , bmp.GetWidth() , bmp.GetHeight() );
 155         m_graphicContext->SetBrush( m_graphicContext->CreateBrush(m_brush));
 156         m_graphicContext->SetPen( m_graphicContext->CreatePen(m_pen));
 157     }
 158     else
 159         m_graphicContext->DrawBitmap( bmp, x , y , bmp.GetWidth() , bmp.GetHeight() );
 160 }
 161
 162 void wxGCDCImpl::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
 163 {
 164     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawIcon - invalid DC") );
 165     wxCHECK_RET( icon.IsOk(), wxT("wxGCDC(cg)::DoDrawIcon - invalid icon") );
 166
 167     wxCoord w = icon.GetWidth();
 168     wxCoord h = icon.GetHeight();
 169
 170     m_graphicContext->DrawIcon( icon , x, y, w, h );
 171 }
 172
 173 bool wxGCDCImpl::StartDoc( const wxString& WXUNUSED(message) )
 174 {
 175     return false;
 176 }
 177
 178 void wxGCDCImpl::EndDoc()
 179 {
 180 }
 181
 182 void wxGCDCImpl::StartPage()
 183 {
 184 }
 185
 186 void wxGCDCImpl::EndPage()
 187 {
 188 }
 189
 190 void wxGCDCImpl::Flush()
 191 {
 192 #ifdef __WXMAC__
 193     CGContextFlush( (CGContextRef) m_graphicContext->GetNativeContext() );
 194 #endif
 195 }
 196
 197 void wxGCDCImpl::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
 198 {
 199     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoSetClippingRegion - invalid DC") );
 200
 201     m_graphicContext->Clip( x, y, w, h );
 202     if ( m_clipping )
 203     {
 204         m_clipX1 = wxMax( m_clipX1, x );
 205         m_clipY1 = wxMax( m_clipY1, y );
 206         m_clipX2 = wxMin( m_clipX2, (x + w) );
 207         m_clipY2 = wxMin( m_clipY2, (y + h) );
 208     }
 209     else
 210     {
 211         m_clipping = true;
 212
 213         m_clipX1 = x;
 214         m_clipY1 = y;
 215         m_clipX2 = x + w;
 216         m_clipY2 = y + h;
 217     }
 218 }
 219
 220 void wxGCDCImpl::DoSetClippingRegionAsRegion( const wxRegion &region )
 221 {
 222     // region is in device coordinates
 223     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoSetClippingRegionAsRegion - invalid DC") );
 224
 225     if (region.Empty())
 226     {
 227         //DestroyClippingRegion();
 228         return;
 229     }
 230
 231     wxRegion logRegion( region );
 232     wxCoord x, y, w, h;
 233
 234     logRegion.Offset( DeviceToLogicalX(0), DeviceToLogicalY(0) );
 235     logRegion.GetBox( x, y, w, h );
 236
 237     m_graphicContext->Clip( logRegion );
 238     if ( m_clipping )
 239     {
 240         m_clipX1 = wxMax( m_clipX1, x );
 241         m_clipY1 = wxMax( m_clipY1, y );
 242         m_clipX2 = wxMin( m_clipX2, (x + w) );
 243         m_clipY2 = wxMin( m_clipY2, (y + h) );
 244     }
 245     else
 246     {
 247         m_clipping = true;
 248
 249         m_clipX1 = x;
 250         m_clipY1 = y;
 251         m_clipX2 = x + w;
 252         m_clipY2 = y + h;
 253     }
 254 }
 255
 256 void wxGCDCImpl::DestroyClippingRegion()
 257 {
 258     m_graphicContext->ResetClip();
 259     // currently the clip eg of a window extends to the area between the scrollbars
 260     // so we must explicitely make sure it only covers the area we want it to draw
 261     int width, height ;
 262     GetOwner()->GetSize( &width , &height ) ;
 263     m_graphicContext->Clip( DeviceToLogicalX(0) , DeviceToLogicalY(0) , DeviceToLogicalXRel(width), DeviceToLogicalYRel(height) );
 264
 265     m_graphicContext->SetPen( m_pen );
 266     m_graphicContext->SetBrush( m_brush );
 267
 268     m_clipping = false;
 269 }
 270
 271 void wxGCDCImpl::DoGetSizeMM( int* width, int* height ) const
 272 {
 273     int w = 0, h = 0;
 274
 275     GetOwner()->GetSize( &w, &h );
 276     if (width)
 277         *width = long( double(w) / (m_scaleX * m_mm_to_pix_x) );
 278     if (height)
 279         *height = long( double(h) / (m_scaleY * m_mm_to_pix_y) );
 280 }
 281
 282 void wxGCDCImpl::SetTextForeground( const wxColour &col )
 283 {
 284     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::SetTextForeground - invalid DC") );
 285
 286     if ( col != m_textForegroundColour )
 287     {
 288         m_textForegroundColour = col;
 289         m_graphicContext->SetFont( m_font, m_textForegroundColour );
 290     }
 291 }
 292
 293 void wxGCDCImpl::SetTextBackground( const wxColour &col )
 294 {
 295     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::SetTextBackground - invalid DC") );
 296
 297     m_textBackgroundColour = col;
 298 }
 299
 300 void wxGCDCImpl::SetMapMode( int mode )
 301 {
 302     switch (mode)
 303     {
 304     case wxMM_TWIPS:
 305         SetLogicalScale( twips2mm * m_mm_to_pix_x, twips2mm * m_mm_to_pix_y );
 306         break;
 307
 308     case wxMM_POINTS:
 309         SetLogicalScale( pt2mm * m_mm_to_pix_x, pt2mm * m_mm_to_pix_y );
 310         break;
 311
 312     case wxMM_METRIC:
 313         SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
 314         break;
 315
 316     case wxMM_LOMETRIC:
 317         SetLogicalScale( m_mm_to_pix_x / 10.0, m_mm_to_pix_y / 10.0 );
 318         break;
 319
 320     case wxMM_TEXT:
 321     default:
 322         SetLogicalScale( 1.0, 1.0 );
 323         break;
 324     }
 325
 326     ComputeScaleAndOrigin();
 327 }
 328
 329 wxSize wxGCDCImpl::GetPPI() const
 330 {
 331     return wxSize(72, 72);
 332 }
 333
 334 int wxGCDCImpl::GetDepth() const
 335 {
 336     return 32;
 337 }
 338
 339 void wxGCDCImpl::ComputeScaleAndOrigin()
 340 {
 341     wxDCImpl::ComputeScaleAndOrigin();
 342
 343     if ( m_graphicContext )
 344     {
 345         m_matrixCurrent = m_graphicContext->CreateMatrix();
 346         m_matrixCurrent.Translate( m_deviceOriginX, m_deviceOriginY );
 347         m_matrixCurrent.Scale( m_scaleX, m_scaleY );
 348         // the logical origin sets the origin to have new coordinates
 349         m_matrixCurrent.Translate( -m_logicalOriginX, -m_logicalOriginY );
 350
 351         m_graphicContext->SetTransform( m_matrixOriginal );
 352         m_graphicContext->ConcatTransform( m_matrixCurrent );
 353     }
 354 }
 355
 356 void wxGCDCImpl::SetPalette( const wxPalette& WXUNUSED(palette) )
 357 {
 358
 359 }
 360
 361 void wxGCDCImpl::SetBackgroundMode( int mode )
 362 {
 363     m_backgroundMode = mode;
 364 }
 365
 366 void wxGCDCImpl::SetFont( const wxFont &font )
 367 {
 368     m_font = font;
 369     if ( m_graphicContext )
 370     {
 371         wxFont f = font;
 372         if ( f.IsOk() )
 373             f.SetPointSize( /*LogicalToDeviceYRel*/(font.GetPointSize()));
 374         m_graphicContext->SetFont( f, m_textForegroundColour );
 375     }
 376 }
 377
 378 void wxGCDCImpl::SetPen( const wxPen &pen )
 379 {
 380     if ( m_pen == pen )
 381         return;
 382
 383     m_pen = pen;
 384     if ( m_graphicContext )
 385     {
 386         m_graphicContext->SetPen( m_pen );
 387     }
 388 }
 389
 390 void wxGCDCImpl::SetBrush( const wxBrush &brush )
 391 {
 392     if (m_brush == brush)
 393         return;
 394
 395     m_brush = brush;
 396     if ( m_graphicContext )
 397     {
 398         m_graphicContext->SetBrush( m_brush );
 399     }
 400 }
 401
 402 void wxGCDCImpl::SetBackground( const wxBrush &brush )
 403 {
 404     if (m_backgroundBrush == brush)
 405         return;
 406
 407     m_backgroundBrush = brush;
 408     if (!m_backgroundBrush.IsOk())
 409         return;
 410 }
 411
 412 void wxGCDCImpl::SetLogicalFunction( int function )
 413 {
 414     if (m_logicalFunction == function)
 415         return;
 416
 417     m_logicalFunction = function;
 418     if ( m_graphicContext->SetLogicalFunction( function ) )
 419         m_logicalFunctionSupported=true;
 420     else
 421         m_logicalFunctionSupported=false;
 422 }
 423
 424 bool wxGCDCImpl::DoFloodFill(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
 425                          const wxColour& WXUNUSED(col), int WXUNUSED(style))
 426 {
 427     return false;
 428 }
 429
 430 bool wxGCDCImpl::DoGetPixel( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxColour *WXUNUSED(col) ) const
 431 {
 432     //  wxCHECK_MSG( 0 , false, wxT("wxGCDC(cg)::DoGetPixel - not implemented") );
 433     return false;
 434 }
 435
 436 void wxGCDCImpl::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
 437 {
 438     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawLine - invalid DC") );
 439
 440     if ( !m_logicalFunctionSupported )
 441         return;
 442
 443     m_graphicContext->StrokeLine(x1,y1,x2,y2);
 444
 445     CalcBoundingBox(x1, y1);
 446     CalcBoundingBox(x2, y2);
 447 }
 448
 449 void wxGCDCImpl::DoCrossHair( wxCoord x, wxCoord y )
 450 {
 451     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoCrossHair - invalid DC") );
 452
 453     if ( !m_logicalFunctionSupported )
 454         return;
 455
 456     int w = 0, h = 0;
 457
 458     GetOwner()->GetSize( &w, &h );
 459
 460     m_graphicContext->StrokeLine(0,y,w,y);
 461     m_graphicContext->StrokeLine(x,0,x,h);
 462
 463     CalcBoundingBox(0, 0);
 464     CalcBoundingBox(0+w, 0+h);
 465 }
 466
 467 void wxGCDCImpl::DoDrawArc( wxCoord x1, wxCoord y1,
 468                         wxCoord x2, wxCoord y2,
 469                         wxCoord xc, wxCoord yc )
 470 {
 471     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawArc - invalid DC") );
 472
 473     if ( !m_logicalFunctionSupported )
 474         return;
 475
 476     double dx = x1 - xc;
 477     double dy = y1 - yc;
 478     double radius = sqrt((double)(dx * dx + dy * dy));
 479     wxCoord rad = (wxCoord)radius;
 480     double sa, ea;
 481     if (x1 == x2 && y1 == y2)
 482     {
 483         sa = 0.0;
 484         ea = 360.0;
 485     }
 486     else if (radius == 0.0)
 487     {
 488         sa = ea = 0.0;
 489     }
 490     else
 491     {
 492         sa = (x1 - xc == 0) ?
 493      (y1 - yc < 0) ? 90.0 : -90.0 :
 494              -atan2(double(y1 - yc), double(x1 - xc)) * RAD2DEG;
 495         ea = (x2 - xc == 0) ?
 496      (y2 - yc < 0) ? 90.0 : -90.0 :
 497              -atan2(double(y2 - yc), double(x2 - xc)) * RAD2DEG;
 498     }
 499
 500     bool fill = m_brush.GetStyle() != wxTRANSPARENT;
 501
 502     wxGraphicsPath path = m_graphicContext->CreatePath();
 503     if ( fill && ((x1!=x2)||(y1!=y2)) )
 504         path.MoveToPoint( xc, yc );
 505     // since these angles (ea,sa) are measured counter-clockwise, we invert them to
 506     // get clockwise angles
 507     path.AddArc( xc, yc , rad , DegToRad(-sa) , DegToRad(-ea), false );
 508     if ( fill && ((x1!=x2)||(y1!=y2)) )
 509         path.AddLineToPoint( xc, yc );
 510     m_graphicContext->DrawPath(path);
 511 }
 512
 513 void wxGCDCImpl::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord w, wxCoord h,
 514                                 double sa, double ea )
 515 {
 516     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawEllipticArc - invalid DC") );
 517
 518     if ( !m_logicalFunctionSupported )
 519         return;
 520
 521     m_graphicContext->PushState();
 522     m_graphicContext->Translate(x+w/2.0,y+h/2.0);
 523     wxDouble factor = ((wxDouble) w) / h;
 524     m_graphicContext->Scale( factor , 1.0);
 525
 526     // since these angles (ea,sa) are measured counter-clockwise, we invert them to
 527     // get clockwise angles
 528     if ( m_brush.GetStyle() != wxTRANSPARENT )
 529     {
 530         wxGraphicsPath path = m_graphicContext->CreatePath();
 531         path.MoveToPoint( 0, 0 );
 532         path.AddLineToPoint( h / 2.0 * cos(DegToRad(sa)) , h / 2.0 * sin(DegToRad(-sa)) );
 533         path.AddLineToPoint( h / 2.0 * cos(DegToRad(ea)) , h / 2.0 * sin(DegToRad(-ea)) );
 534         path.AddLineToPoint( 0, 0 );
 535         m_graphicContext->FillPath( path );
 536
 537         path = m_graphicContext->CreatePath();
 538         path.AddArc( 0, 0, h/2.0 , DegToRad(-sa) , DegToRad(-ea), sa > ea );
 539         m_graphicContext->FillPath( path );
 540         m_graphicContext->StrokePath( path );
 541     }
 542     else
 543     {
 544         wxGraphicsPath path = m_graphicContext->CreatePath();
 545     path.AddArc( 0, 0, h/2.0 , DegToRad(-sa) , DegToRad(-ea), sa > ea );
 546     m_graphicContext->DrawPath( path );
 547     }
 548
 549     m_graphicContext->PopState();
 550 }
 551
 552 void wxGCDCImpl::DoDrawPoint( wxCoord x, wxCoord y )
 553 {
 554     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawPoint - invalid DC") );
 555
 556     DoDrawLine( x , y , x + 1 , y + 1 );
 557 }
 558
 559 void wxGCDCImpl::DoDrawLines(int n, wxPoint points[],
 560                          wxCoord xoffset, wxCoord yoffset)
 561 {
 562     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawLines - invalid DC") );
 563
 564     if ( !m_logicalFunctionSupported )
 565         return;
 566
 567     wxPoint2DDouble* pointsD = new wxPoint2DDouble[n];
 568     for( int i = 0; i < n; ++i)
 569     {
 570         pointsD[i].m_x = points[i].x + xoffset;
 571         pointsD[i].m_y = points[i].y + yoffset;
 572     }
 573
 574     m_graphicContext->StrokeLines( n , pointsD);
 575     delete[] pointsD;
 576 }
 577
 578 #if wxUSE_SPLINES
 579 void wxGCDCImpl::DoDrawSpline(const wxPointList *points)
 580 {
 581     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawSpline - invalid DC") );
 582
 583     if ( !m_logicalFunctionSupported )
 584         return;
 585
 586     wxGraphicsPath path = m_graphicContext->CreatePath();
 587
 588     wxPointList::compatibility_iterator node = points->GetFirst();
 589     if (node == wxPointList::compatibility_iterator())
 590         // empty list
 591         return;
 592
 593     wxPoint *p = node->GetData();
 594
 595     wxCoord x1 = p->x;
 596     wxCoord y1 = p->y;
 597
 598     node = node->GetNext();
 599     p = node->GetData();
 600
 601     wxCoord x2 = p->x;
 602     wxCoord y2 = p->y;
 603     wxCoord cx1 = ( x1 + x2 ) / 2;
 604     wxCoord cy1 = ( y1 + y2 ) / 2;
 605
 606     path.MoveToPoint( x1 , y1 );
 607     path.AddLineToPoint( cx1 , cy1 );
 608 #if !wxUSE_STL
 609
 610     while ((node = node->GetNext()) != NULL)
 611 #else
 612
 613     while ((node = node->GetNext()))
 614 #endif // !wxUSE_STL
 615
 616     {
 617         p = node->GetData();
 618         x1 = x2;
 619         y1 = y2;
 620         x2 = p->x;
 621         y2 = p->y;
 622         wxCoord cx4 = (x1 + x2) / 2;
 623         wxCoord cy4 = (y1 + y2) / 2;
 624
 625         path.AddQuadCurveToPoint(x1 , y1 ,cx4 , cy4 );
 626
 627         cx1 = cx4;
 628         cy1 = cy4;
 629     }
 630
 631     path.AddLineToPoint( x2 , y2 );
 632
 633     m_graphicContext->StrokePath( path );
 634 }
 635 #endif // wxUSE_SPLINES
 636
 637 void wxGCDCImpl::DoDrawPolygon( int n, wxPoint points[],
 638                             wxCoord xoffset, wxCoord yoffset,
 639                             int fillStyle )
 640 {
 641     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawPolygon - invalid DC") );
 642
 643     if ( n <= 0 || (m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT ) )
 644         return;
 645     if ( !m_logicalFunctionSupported )
 646         return;
 647
 648     bool closeIt = false;
 649     if (points[n-1] != points[0])
 650         closeIt = true;
 651
 652     wxPoint2DDouble* pointsD = new wxPoint2DDouble[n+(closeIt?1:0)];
 653     for( int i = 0; i < n; ++i)
 654     {
 655         pointsD[i].m_x = points[i].x + xoffset;
 656         pointsD[i].m_y = points[i].y + yoffset;
 657     }
 658     if ( closeIt )
 659         pointsD[n] = pointsD[0];
 660
 661     m_graphicContext->DrawLines( n+(closeIt?1:0) , pointsD, fillStyle);
 662     delete[] pointsD;
 663 }
 664
 665 void wxGCDCImpl::DoDrawPolyPolygon(int n,
 666                                int count[],
 667                                wxPoint points[],
 668                                wxCoord xoffset,
 669                                wxCoord yoffset,
 670                                int fillStyle)
 671 {
 672     wxASSERT(n > 1);
 673     wxGraphicsPath path = m_graphicContext->CreatePath();
 674
 675     int i = 0;
 676     for ( int j = 0; j < n; ++j)
 677     {
 678         wxPoint start = points[i];
 679         path.MoveToPoint( start.x+ xoffset, start.y+ yoffset);
 680         ++i;
 681         int l = count[j];
 682         for ( int k = 1; k < l; ++k)
 683         {
 684             path.AddLineToPoint( points[i].x+ xoffset, points[i].y+ yoffset);
 685             ++i;
 686         }
 687         // close the polygon
 688         if ( start != points[i-1])
 689             path.AddLineToPoint( start.x+ xoffset, start.y+ yoffset);
 690     }
 691     m_graphicContext->DrawPath( path , fillStyle);
 692 }
 693
 694 void wxGCDCImpl::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
 695 {
 696     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRectangle - invalid DC") );
 697
 698     if ( !m_logicalFunctionSupported )
 699         return;
 700
 701     // CMB: draw nothing if transformed w or h is 0
 702     if (w == 0 || h == 0)
 703         return;
 704
 705     if ( m_graphicContext->ShouldOffset() )
 706     {
 707         // if we are offsetting the entire rectangle is moved 0.5, so the
 708         // border line gets off by 1
 709         w -= 1;
 710         h -= 1;
 711     }
 712     m_graphicContext->DrawRectangle(x,y,w,h);
 713 }
 714
 715 void wxGCDCImpl::DoDrawRoundedRectangle(wxCoord x, wxCoord y,
 716                                     wxCoord w, wxCoord h,
 717                                     double radius)
 718 {
 719     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRoundedRectangle - invalid DC") );
 720
 721     if ( !m_logicalFunctionSupported )
 722         return;
 723
 724     if (radius < 0.0)
 725         radius = - radius * ((w < h) ? w : h);
 726
 727     // CMB: draw nothing if transformed w or h is 0
 728     if (w == 0 || h == 0)
 729         return;
 730
 731     if ( m_graphicContext->ShouldOffset() )
 732     {
 733         // if we are offsetting the entire rectangle is moved 0.5, so the
 734         // border line gets off by 1
 735         w -= 1;
 736         h -= 1;
 737     }
 738     m_graphicContext->DrawRoundedRectangle( x,y,w,h,radius);
 739 }
 740
 741 void wxGCDCImpl::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
 742 {
 743     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawEllipse - invalid DC") );
 744
 745     if ( !m_logicalFunctionSupported )
 746         return;
 747
 748     if ( m_graphicContext->ShouldOffset() )
 749     {
 750         // if we are offsetting the entire rectangle is moved 0.5, so the
 751         // border line gets off by 1
 752         w -= 1;
 753         h -= 1;
 754     }
 755     m_graphicContext->DrawEllipse(x,y,w,h);
 756 }
 757
 758 bool wxGCDCImpl::CanDrawBitmap() const
 759 {
 760     return true;
 761 }
 762
 763 bool wxGCDCImpl::DoBlit(
 764     wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
 765     wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func , bool useMask,
 766     wxCoord xsrcMask, wxCoord ysrcMask )
 767 {
 768     return DoStretchBlit( xdest, ydest, width, height,
 769         source, xsrc, ysrc, width, height, logical_func, useMask,
 770         xsrcMask,ysrcMask );
 771 }
 772
 773 bool wxGCDCImpl::DoStretchBlit(
 774     wxCoord xdest, wxCoord ydest, wxCoord dstWidth, wxCoord dstHeight,
 775     wxDC *source, wxCoord xsrc, wxCoord ysrc, wxCoord srcWidth, wxCoord srcHeight,
 776     int logical_func , bool WXUNUSED(useMask),
 777     wxCoord xsrcMask, wxCoord ysrcMask )
 778 {
 779     wxCHECK_MSG( IsOk(), false, wxT("wxGCDC(cg)::DoStretchBlit - invalid DC") );
 780     wxCHECK_MSG( source->IsOk(), false, wxT("wxGCDC(cg)::DoStretchBlit - invalid source DC") );
 781
 782     if ( logical_func == wxNO_OP )
 783         return true;
 784     else if ( !m_graphicContext->SetLogicalFunction( logical_func ) )
 785
 786     {
 787         wxFAIL_MSG( wxT("Blitting is only supported with wxCOPY logical operation.") );
 788         return false;
 789     }
 790
 791     if (xsrcMask == -1 && ysrcMask == -1)
 792     {
 793         xsrcMask = xsrc;
 794         ysrcMask = ysrc;
 795     }
 796
 797     wxRect subrect(source->LogicalToDeviceX(xsrc),
 798                    source->LogicalToDeviceY(ysrc),
 799                    source->LogicalToDeviceXRel(srcWidth),
 800                    source->LogicalToDeviceYRel(srcHeight));
 801
 802     // if needed clip the subrect down to the size of the source DC
 803     wxCoord sw, sh;
 804     source->GetSize(&sw, &sh);
 805     sw = source->LogicalToDeviceXRel(sw);
 806     sh = source->LogicalToDeviceYRel(sh);
 807     if (subrect.x + subrect.width > sw)
 808         subrect.width = sw - subrect.x;
 809     if (subrect.y + subrect.height > sh)
 810         subrect.height = sh - subrect.y;
 811
 812     wxBitmap blit = source->GetAsBitmap( &subrect );
 813
 814     if ( blit.IsOk() )
 815     {
 816         m_graphicContext->DrawBitmap( blit, xdest, ydest,
 817                                       dstWidth, dstHeight);
 818     }
 819     else
 820     {
 821         wxFAIL_MSG( wxT("Cannot Blit. Unable to get contents of DC as bitmap.") );
 822         return false;
 823     }
 824
 825     // reset logical function
 826     m_graphicContext->SetLogicalFunction( m_logicalFunction );
 827
 828     return true;
 829 }
 830
 831 void wxGCDCImpl::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
 832                                double angle)
 833 {
 834     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRotatedText - invalid DC") );
 835
 836     if ( str.length() == 0 )
 837         return;
 838     if ( !m_logicalFunctionSupported )
 839         return;
 840
 841     if ( m_backgroundMode == wxTRANSPARENT )
 842         m_graphicContext->DrawText( str, x ,y , DegToRad(angle ));
 843     else
 844         m_graphicContext->DrawText( str, x ,y , DegToRad(angle ), m_graphicContext->CreateBrush( wxBrush(m_textBackgroundColour,wxSOLID) ) );
 845 }
 846
 847 void wxGCDCImpl::DoDrawText(const wxString& str, wxCoord x, wxCoord y)
 848 {
 849     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawRotatedText - invalid DC") );
 850
 851     if ( str.length() == 0 )
 852         return;
 853
 854     if ( !m_logicalFunctionSupported )
 855         return;
 856
 857     if ( m_backgroundMode == wxTRANSPARENT )
 858         m_graphicContext->DrawText( str, x ,y);
 859     else
 860         m_graphicContext->DrawText( str, x ,y , m_graphicContext->CreateBrush( wxBrush(m_textBackgroundColour,wxSOLID) ) );
 861 }
 862
 863 bool wxGCDCImpl::CanGetTextExtent() const
 864 {
 865     wxCHECK_MSG( IsOk(), false, wxT("wxGCDC(cg)::CanGetTextExtent - invalid DC") );
 866
 867     return true;
 868 }
 869
 870 void wxGCDCImpl::DoGetTextExtent( const wxString &str, wxCoord *width, wxCoord *height,
 871                               wxCoord *descent, wxCoord *externalLeading ,
 872                               const wxFont *theFont ) const
 873 {
 874     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoGetTextExtent - invalid DC") );
 875
 876     if ( theFont )
 877     {
 878         m_graphicContext->SetFont( *theFont, m_textForegroundColour );
 879     }
 880
 881     wxDouble h , d , e , w;
 882
 883     m_graphicContext->GetTextExtent( str, &w, &h, &d, &e );
 884
 885     if ( height )
 886         *height = (wxCoord)(h+0.5);
 887     if ( descent )
 888         *descent = (wxCoord)(d+0.5);
 889     if ( externalLeading )
 890         *externalLeading = (wxCoord)(e+0.5);
 891     if ( width )
 892         *width = (wxCoord)(w+0.5);
 893
 894     if ( theFont )
 895     {
 896         m_graphicContext->SetFont( m_font, m_textForegroundColour );
 897     }
 898 }
 899
 900 bool wxGCDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
 901 {
 902     wxCHECK_MSG( IsOk(), false, wxT("wxGCDC(cg)::DoGetPartialTextExtents - invalid DC") );
 903     widths.Clear();
 904     widths.Add(0,text.Length());
 905     if ( text.IsEmpty() )
 906         return true;
 907
 908     wxArrayDouble widthsD;
 909
 910     m_graphicContext->GetPartialTextExtents( text, widthsD );
 911     for ( size_t i = 0; i < widths.GetCount(); ++i )
 912         widths[i] = (wxCoord)(widthsD[i] + 0.5);
 913
 914     return true;
 915 }
 916
 917 wxCoord wxGCDCImpl::GetCharWidth(void) const
 918 {
 919     wxCoord width;
 920     DoGetTextExtent( wxT("g") , &width , NULL , NULL , NULL , NULL );
 921
 922     return width;
 923 }
 924
 925 wxCoord wxGCDCImpl::GetCharHeight(void) const
 926 {
 927     wxCoord height;
 928     DoGetTextExtent( wxT("g") , NULL , &height , NULL , NULL , NULL );
 929
 930     return height;
 931 }
 932
 933 void wxGCDCImpl::Clear(void)
 934 {
 935     wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::Clear - invalid DC") );
 936     // TODO better implementation / incorporate size info into wxGCDC or context
 937     m_graphicContext->SetBrush( m_backgroundBrush );
 938     wxPen p = *wxTRANSPARENT_PEN;
 939     m_graphicContext->SetPen( p );
 940     DoDrawRectangle( 0, 0, 32000 , 32000 );
 941     m_graphicContext->SetPen( m_pen );
 942     m_graphicContext->SetBrush( m_brush );
 943 }
 944
 945 void wxGCDCImpl::DoGetSize(int *width, int *height) const
 946 {
 947     *width = 10000;
 948     *height = 10000;
 949 }
 950
 951 void wxGCDCImpl::DoGradientFillLinear(const wxRect& rect,
 952                                   const wxColour& initialColour,
 953                                   const wxColour& destColour,
 954                                   wxDirection nDirection )
 955 {
 956     wxPoint start;
 957     wxPoint end;
 958     switch( nDirection)
 959     {
 960     case wxWEST :
 961         start = rect.GetRightBottom();
 962         start.x++;
 963         end = rect.GetLeftBottom();
 964         break;
 965     case wxEAST :
 966         start = rect.GetLeftBottom();
 967         end = rect.GetRightBottom();
 968         end.x++;
 969         break;
 970     case wxNORTH :
 971         start = rect.GetLeftBottom();
 972         start.y++;
 973         end = rect.GetLeftTop();
 974         break;
 975     case wxSOUTH :
 976         start = rect.GetLeftTop();
 977         end = rect.GetLeftBottom();
 978         end.y++;
 979         break;
 980     default :
 981         break;
 982     }
 983
 984     if (rect.width == 0 || rect.height == 0)
 985         return;
 986
 987     m_graphicContext->SetBrush( m_graphicContext->CreateLinearGradientBrush(
 988         start.x,start.y,end.x,end.y, initialColour, destColour));
 989     m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
 990     m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height);
 991     m_graphicContext->SetPen(m_pen);
 992 }
 993
 994 void wxGCDCImpl::DoGradientFillConcentric(const wxRect& rect,
 995                                       const wxColour& initialColour,
 996                                       const wxColour& destColour,
 997                                       const wxPoint& circleCenter)
 998 {
 999     //Radius
1000     wxInt32 cx = rect.GetWidth() / 2;
1001     wxInt32 cy = rect.GetHeight() / 2;
1002     wxInt32 nRadius;
1003     if (cx < cy)
1004         nRadius = cx;
1005     else
1006         nRadius = cy;
1007
1008     // make sure the background is filled (todo move into specific platform implementation ?)
1009     m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
1010     m_graphicContext->SetBrush( wxBrush( destColour) );
1011     m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height);
1012
1013     m_graphicContext->SetBrush( m_graphicContext->CreateRadialGradientBrush(
1014         rect.x+circleCenter.x,rect.y+circleCenter.y,
1015         rect.x+circleCenter.x,rect.y+circleCenter.y,
1016         nRadius,initialColour,destColour));
1017
1018     m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height);
1019     m_graphicContext->SetPen(m_pen);
1020 }
1021
1022 void wxGCDCImpl::DoDrawCheckMark(wxCoord x, wxCoord y,
1023                              wxCoord width, wxCoord height)
1024 {
1025     wxDCImpl::DoDrawCheckMark(x,y,width,height);
1026 }
1027
1028 #endif // wxUSE_GRAPHICS_CONTEXT