src/common/dcgraph.cpp

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