src/msw/graphics.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/graphics.cpp
   3 // Purpose:     wxGCDC class
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     2006-09-30
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2006 Stefan Csomor
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #include "wx/dc.h"
  19
  20 #if wxUSE_GRAPHICS_CONTEXT
  21
  22 #ifndef WX_PRECOMP
  23     #include "wx/msw/wrapcdlg.h"
  24     #include "wx/image.h"
  25     #include "wx/window.h"
  26     #include "wx/utils.h"
  27     #include "wx/dialog.h"
  28     #include "wx/app.h"
  29     #include "wx/bitmap.h"
  30     #include "wx/log.h"
  31     #include "wx/icon.h"
  32     #include "wx/module.h"
  33     // include all dc types that are used as a param
  34     #include "wx/dc.h"
  35     #include "wx/dcclient.h"
  36     #include "wx/dcmemory.h"
  37     #include "wx/dcprint.h"
  38 #endif
  39
  40 #include "wx/stack.h"
  41
  42 #include "wx/private/graphics.h"
  43 #include "wx/msw/wrapgdip.h"
  44 #include "wx/msw/dc.h"
  45 #if wxUSE_ENH_METAFILE
  46     #include "wx/msw/enhmeta.h"
  47 #endif
  48 #include "wx/dcgraph.h"
  49
  50 #include "wx/msw/private.h" // needs to be before #include <commdlg.h>
  51
  52 #if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
  53 #include <commdlg.h>
  54 #endif
  55
  56 namespace
  57 {
  58
  59 //-----------------------------------------------------------------------------
  60 // constants
  61 //-----------------------------------------------------------------------------
  62
  63 const double RAD2DEG = 180.0 / M_PI;
  64
  65 //-----------------------------------------------------------------------------
  66 // Local functions
  67 //-----------------------------------------------------------------------------
  68
  69 inline double dmin(double a, double b) { return a < b ? a : b; }
  70 inline double dmax(double a, double b) { return a > b ? a : b; }
  71
  72 inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
  73 inline double RadToDeg(double deg) { return (deg * 180.0) / M_PI; }
  74
  75 // translate a wxColour to a Color
  76 inline Color wxColourToColor(const wxColour& col)
  77 {
  78     return Color(col.Alpha(), col.Red(), col.Green(), col.Blue());
  79 }
  80
  81 } // anonymous namespace
  82
  83 //-----------------------------------------------------------------------------
  84 // device context implementation
  85 //
  86 // more and more of the dc functionality should be implemented by calling
  87 // the appropricate wxGDIPlusContext, but we will have to do that step by step
  88 // also coordinate conversions should be moved to native matrix ops
  89 //-----------------------------------------------------------------------------
  90
  91 // we always stock two context states, one at entry, to be able to preserve the
  92 // state we were called with, the other one after changing to HI Graphics orientation
  93 // (this one is used for getting back clippings etc)
  94
  95 //-----------------------------------------------------------------------------
  96 // wxGraphicsPath implementation
  97 //-----------------------------------------------------------------------------
  98
  99 class wxGDIPlusContext;
 100
 101 class wxGDIPlusPathData : public wxGraphicsPathData
 102 {
 103 public :
 104     wxGDIPlusPathData(wxGraphicsRenderer* renderer, GraphicsPath* path = NULL);
 105     ~wxGDIPlusPathData();
 106
 107     virtual wxGraphicsObjectRefData *Clone() const;
 108
 109     //
 110     // These are the path primitives from which everything else can be constructed
 111     //
 112
 113     // begins a new subpath at (x,y)
 114     virtual void MoveToPoint( wxDouble x, wxDouble y );
 115
 116     // adds a straight line from the current point to (x,y)
 117     virtual void AddLineToPoint( wxDouble x, wxDouble y );
 118
 119     // adds a cubic Bezier curve from the current point, using two control points and an end point
 120     virtual void AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y );
 121
 122
 123     // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
 124     virtual void AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise ) ;
 125
 126     // gets the last point of the current path, (0,0) if not yet set
 127     virtual void GetCurrentPoint( wxDouble* x, wxDouble* y) const;
 128
 129     // adds another path
 130     virtual void AddPath( const wxGraphicsPathData* path );
 131
 132     // closes the current sub-path
 133     virtual void CloseSubpath();
 134
 135     //
 136     // These are convenience functions which - if not available natively will be assembled
 137     // using the primitives from above
 138     //
 139
 140     // appends a rectangle as a new closed subpath
 141     virtual void AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h ) ;
 142     /*
 143
 144     // appends an ellipsis as a new closed subpath fitting the passed rectangle
 145     virtual void AddEllipsis( wxDouble x, wxDouble y, wxDouble w , wxDouble h ) ;
 146
 147     // 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)
 148     virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )  ;
 149 */
 150
 151     // returns the native path
 152     virtual void * GetNativePath() const { return m_path; }
 153
 154     // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
 155     virtual void UnGetNativePath(void * WXUNUSED(path)) const {}
 156
 157     // transforms each point of this path by the matrix
 158     virtual void Transform( const wxGraphicsMatrixData* matrix ) ;
 159
 160     // gets the bounding box enclosing all points (possibly including control points)
 161     virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const;
 162
 163     virtual bool Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle = wxODDEVEN_RULE) const;
 164
 165 private :
 166     GraphicsPath* m_path;
 167 };
 168
 169 class wxGDIPlusMatrixData : public wxGraphicsMatrixData
 170 {
 171 public :
 172     wxGDIPlusMatrixData(wxGraphicsRenderer* renderer, Matrix* matrix = NULL) ;
 173     virtual ~wxGDIPlusMatrixData() ;
 174
 175     virtual wxGraphicsObjectRefData* Clone() const ;
 176
 177     // concatenates the matrix
 178     virtual void Concat( const wxGraphicsMatrixData *t );
 179
 180     // sets the matrix to the respective values
 181     virtual void Set(wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
 182         wxDouble tx=0.0, wxDouble ty=0.0);
 183
 184     // gets the component valuess of the matrix
 185     virtual void Get(wxDouble* a=NULL, wxDouble* b=NULL,  wxDouble* c=NULL,
 186                      wxDouble* d=NULL, wxDouble* tx=NULL, wxDouble* ty=NULL) const;
 187
 188     // makes this the inverse matrix
 189     virtual void Invert();
 190
 191     // returns true if the elements of the transformation matrix are equal ?
 192     virtual bool IsEqual( const wxGraphicsMatrixData* t) const ;
 193
 194     // return true if this is the identity matrix
 195     virtual bool IsIdentity() const;
 196
 197     //
 198     // transformation
 199     //
 200
 201     // add the translation to this matrix
 202     virtual void Translate( wxDouble dx , wxDouble dy );
 203
 204     // add the scale to this matrix
 205     virtual void Scale( wxDouble xScale , wxDouble yScale );
 206
 207     // add the rotation to this matrix (radians)
 208     virtual void Rotate( wxDouble angle );
 209
 210     //
 211     // apply the transforms
 212     //
 213
 214     // applies that matrix to the point
 215     virtual void TransformPoint( wxDouble *x, wxDouble *y ) const;
 216
 217     // applies the matrix except for translations
 218     virtual void TransformDistance( wxDouble *dx, wxDouble *dy ) const;
 219
 220     // returns the native representation
 221     virtual void * GetNativeMatrix() const;
 222 private:
 223     Matrix* m_matrix ;
 224 } ;
 225
 226 class wxGDIPlusPenData : public wxGraphicsObjectRefData
 227 {
 228 public:
 229     wxGDIPlusPenData( wxGraphicsRenderer* renderer, const wxPen &pen );
 230     ~wxGDIPlusPenData();
 231
 232     void Init();
 233
 234     virtual wxDouble GetWidth() { return m_width; }
 235     virtual Pen* GetGDIPlusPen() { return m_pen; }
 236
 237 protected :
 238     Pen* m_pen;
 239     Image* m_penImage;
 240     Brush* m_penBrush;
 241
 242     wxDouble m_width;
 243 };
 244
 245 class wxGDIPlusBrushData : public wxGraphicsObjectRefData
 246 {
 247 public:
 248     wxGDIPlusBrushData( wxGraphicsRenderer* renderer );
 249     wxGDIPlusBrushData( wxGraphicsRenderer* renderer, const wxBrush &brush );
 250     ~wxGDIPlusBrushData ();
 251
 252     void CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
 253                                    wxDouble x2, wxDouble y2,
 254                                    const wxGraphicsGradientStops& stops);
 255     void CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 256                                    wxDouble xc, wxDouble yc,
 257                                    wxDouble radius,
 258                                    const wxGraphicsGradientStops& stops);
 259
 260     virtual Brush* GetGDIPlusBrush() { return m_brush; }
 261
 262 protected:
 263     virtual void Init();
 264
 265 private:
 266     // common part of Create{Linear,Radial}GradientBrush()
 267     template <typename T>
 268     void SetGradientStops(T *brush, const wxGraphicsGradientStops& stops);
 269
 270     Brush* m_brush;
 271     Image* m_brushImage;
 272     GraphicsPath* m_brushPath;
 273 };
 274
 275 class WXDLLIMPEXP_CORE wxGDIPlusBitmapData : public wxGraphicsObjectRefData
 276 {
 277 public:
 278     wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap );
 279     wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, const wxBitmap &bmp );
 280     ~wxGDIPlusBitmapData ();
 281
 282     virtual Bitmap* GetGDIPlusBitmap() { return m_bitmap; }
 283
 284 private :
 285     Bitmap* m_bitmap;
 286     Bitmap* m_helper;
 287 };
 288
 289 class wxGDIPlusFontData : public wxGraphicsObjectRefData
 290 {
 291 public:
 292     wxGDIPlusFontData( wxGraphicsRenderer* renderer,
 293                        const wxGDIPlusContext* gc,
 294                        const wxFont &font,
 295                        const wxColour& col );
 296     ~wxGDIPlusFontData();
 297
 298     virtual Brush* GetGDIPlusBrush() { return m_textBrush; }
 299     virtual Font* GetGDIPlusFont() { return m_font; }
 300 private :
 301     Brush* m_textBrush;
 302     Font* m_font;
 303 };
 304
 305 class wxGDIPlusContext : public wxGraphicsContext
 306 {
 307 public:
 308     wxGDIPlusContext( wxGraphicsRenderer* renderer, const wxDC& dc );
 309     wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc, wxDouble width, wxDouble height );
 310     wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd );
 311     wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr);
 312     wxGDIPlusContext();
 313
 314     virtual ~wxGDIPlusContext();
 315
 316     virtual void Clip( const wxRegion &region );
 317     // clips drawings to the rect
 318     virtual void Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 319
 320     // resets the clipping to original extent
 321     virtual void ResetClip();
 322
 323     virtual void * GetNativeContext();
 324
 325     virtual void StrokePath( const wxGraphicsPath& p );
 326     virtual void FillPath( const wxGraphicsPath& p , wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
 327
 328     virtual void DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 329
 330     // stroke lines connecting each of the points
 331     virtual void StrokeLines( size_t n, const wxPoint2DDouble *points);
 332
 333     // draws a polygon
 334     virtual void DrawLines( size_t n, const wxPoint2DDouble *points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE );
 335
 336     virtual bool SetAntialiasMode(wxAntialiasMode antialias);
 337
 338     virtual bool SetInterpolationQuality(wxInterpolationQuality interpolation);
 339
 340     virtual bool SetCompositionMode(wxCompositionMode op);
 341
 342     virtual void BeginLayer(wxDouble opacity);
 343
 344     virtual void EndLayer();
 345
 346     virtual void Translate( wxDouble dx , wxDouble dy );
 347     virtual void Scale( wxDouble xScale , wxDouble yScale );
 348     virtual void Rotate( wxDouble angle );
 349
 350     // concatenates this transform with the current transform of this context
 351     virtual void ConcatTransform( const wxGraphicsMatrix& matrix );
 352
 353     // sets the transform of this context
 354     virtual void SetTransform( const wxGraphicsMatrix& matrix );
 355
 356     // gets the matrix of this context
 357     virtual wxGraphicsMatrix GetTransform() const;
 358
 359     virtual void DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 360     virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 361     virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 362     virtual void PushState();
 363     virtual void PopState();
 364
 365     // sets the font of this context
 366     virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) const;
 367
 368     virtual void GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
 369         wxDouble *descent, wxDouble *externalLeading ) const;
 370     virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
 371     virtual bool ShouldOffset() const;
 372     virtual void GetSize( wxDouble* width, wxDouble *height );
 373
 374     Graphics* GetGraphics() const { return m_context; }
 375
 376 protected:
 377
 378     wxDouble m_fontScaleRatio;
 379
 380 private:
 381     void    Init();
 382     void    SetDefaults();
 383
 384     virtual void DoDrawText(const wxString& str, wxDouble x, wxDouble y)
 385         { DoDrawFilledText(str, x, y, wxNullGraphicsBrush); }
 386     virtual void DoDrawFilledText(const wxString& str, wxDouble x, wxDouble y,
 387                                   const wxGraphicsBrush& backgroundBrush);
 388
 389     Graphics* m_context;
 390     wxStack<GraphicsState> m_stateStack;
 391     GraphicsState m_state1;
 392     GraphicsState m_state2;
 393
 394     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusContext)
 395 };
 396
 397 class wxGDIPlusMeasuringContext : public wxGDIPlusContext
 398 {
 399 public:
 400     wxGDIPlusMeasuringContext( wxGraphicsRenderer* renderer ) : wxGDIPlusContext( renderer , m_hdc = GetDC(NULL), 1000, 1000 )
 401     {
 402     }
 403     wxGDIPlusMeasuringContext()
 404     {
 405     }
 406
 407     virtual ~wxGDIPlusMeasuringContext()
 408     {
 409         ReleaseDC( NULL, m_hdc );
 410     }
 411
 412 private:
 413     HDC m_hdc ;
 414     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusMeasuringContext)
 415 } ;
 416
 417 class wxGDIPlusPrintingContext : public wxGDIPlusContext
 418 {
 419 public:
 420     wxGDIPlusPrintingContext( wxGraphicsRenderer* renderer, const wxDC& dc );
 421     virtual ~wxGDIPlusPrintingContext() { }
 422 protected:
 423 };
 424
 425 //-----------------------------------------------------------------------------
 426 // wxGDIPlusRenderer declaration
 427 //-----------------------------------------------------------------------------
 428
 429 class wxGDIPlusRenderer : public wxGraphicsRenderer
 430 {
 431 public :
 432     wxGDIPlusRenderer()
 433     {
 434         m_loaded = -1;
 435         m_gditoken = 0;
 436     }
 437
 438     virtual ~wxGDIPlusRenderer()
 439     {
 440         if ( m_loaded == 1 )
 441         {
 442             Unload();
 443         }
 444     }
 445
 446     // Context
 447
 448     virtual wxGraphicsContext * CreateContext( const wxWindowDC& dc);
 449
 450     virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc);
 451
 452 #if wxUSE_PRINTING_ARCHITECTURE
 453     virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc);
 454 #endif
 455
 456 #if wxUSE_ENH_METAFILE
 457     virtual wxGraphicsContext * CreateContext( const wxEnhMetaFileDC& dc);
 458 #endif
 459
 460     virtual wxGraphicsContext * CreateContextFromNativeContext( void * context );
 461
 462     virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window );
 463
 464     virtual wxGraphicsContext * CreateContext( wxWindow* window );
 465
 466     virtual wxGraphicsContext * CreateMeasuringContext();
 467
 468     // Path
 469
 470     virtual wxGraphicsPath CreatePath();
 471
 472     // Matrix
 473
 474     virtual wxGraphicsMatrix CreateMatrix( wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
 475         wxDouble tx=0.0, wxDouble ty=0.0);
 476
 477
 478     virtual wxGraphicsPen CreatePen(const wxPen& pen) ;
 479
 480     virtual wxGraphicsBrush CreateBrush(const wxBrush& brush ) ;
 481
 482     virtual wxGraphicsBrush
 483     CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
 484                               wxDouble x2, wxDouble y2,
 485                               const wxGraphicsGradientStops& stops);
 486
 487     virtual wxGraphicsBrush
 488     CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 489                               wxDouble xc, wxDouble yc,
 490                               wxDouble radius,
 491                               const wxGraphicsGradientStops& stops);
 492
 493     // create a native bitmap representation
 494     virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap );
 495
 496     // stub: should not be called directly
 497     virtual wxGraphicsFont CreateFont( const wxFont& WXUNUSED(font),
 498                                        const wxColour& WXUNUSED(col) )
 499         { wxFAIL; return wxNullGraphicsFont; }
 500
 501     // this is used to really create the font
 502     wxGraphicsFont CreateGDIPlusFont( const wxGDIPlusContext* gc,
 503                                       const wxFont &font,
 504                                       const wxColour &col );
 505
 506     // create a graphics bitmap from a native bitmap
 507     virtual wxGraphicsBitmap CreateBitmapFromNativeBitmap( void* bitmap );
 508
 509     // create a subimage from a native image representation
 510     virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h  );
 511
 512 protected :
 513     bool EnsureIsLoaded();
 514     void Load();
 515     void Unload();
 516     friend class wxGDIPlusRendererModule;
 517
 518 private :
 519     int m_loaded;
 520     ULONG_PTR m_gditoken;
 521
 522     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusRenderer)
 523 } ;
 524
 525 //-----------------------------------------------------------------------------
 526 // wxGDIPlusPen implementation
 527 //-----------------------------------------------------------------------------
 528
 529 wxGDIPlusPenData::~wxGDIPlusPenData()
 530 {
 531     delete m_pen;
 532     delete m_penImage;
 533     delete m_penBrush;
 534 }
 535
 536 void wxGDIPlusPenData::Init()
 537 {
 538     m_pen = NULL ;
 539     m_penImage = NULL;
 540     m_penBrush = NULL;
 541 }
 542
 543 wxGDIPlusPenData::wxGDIPlusPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
 544 : wxGraphicsObjectRefData(renderer)
 545 {
 546     Init();
 547     m_width = pen.GetWidth();
 548     if (m_width <= 0.0)
 549         m_width = 0.1;
 550
 551     m_pen = new Pen(wxColourToColor(pen.GetColour()), m_width );
 552
 553     LineCap cap;
 554     switch ( pen.GetCap() )
 555     {
 556     case wxCAP_ROUND :
 557         cap = LineCapRound;
 558         break;
 559
 560     case wxCAP_PROJECTING :
 561         cap = LineCapSquare;
 562         break;
 563
 564     case wxCAP_BUTT :
 565         cap = LineCapFlat; // TODO verify
 566         break;
 567
 568     default :
 569         cap = LineCapFlat;
 570         break;
 571     }
 572     m_pen->SetLineCap(cap,cap, DashCapFlat);
 573
 574     LineJoin join;
 575     switch ( pen.GetJoin() )
 576     {
 577     case wxJOIN_BEVEL :
 578         join = LineJoinBevel;
 579         break;
 580
 581     case wxJOIN_MITER :
 582         join = LineJoinMiter;
 583         break;
 584
 585     case wxJOIN_ROUND :
 586         join = LineJoinRound;
 587         break;
 588
 589     default :
 590         join = LineJoinMiter;
 591         break;
 592     }
 593
 594     m_pen->SetLineJoin(join);
 595
 596     m_pen->SetDashStyle(DashStyleSolid);
 597
 598     DashStyle dashStyle = DashStyleSolid;
 599     switch ( pen.GetStyle() )
 600     {
 601     case wxPENSTYLE_SOLID :
 602         break;
 603
 604     case wxPENSTYLE_DOT :
 605         dashStyle = DashStyleDot;
 606         break;
 607
 608     case wxPENSTYLE_LONG_DASH :
 609         dashStyle = DashStyleDash; // TODO verify
 610         break;
 611
 612     case wxPENSTYLE_SHORT_DASH :
 613         dashStyle = DashStyleDash;
 614         break;
 615
 616     case wxPENSTYLE_DOT_DASH :
 617         dashStyle = DashStyleDashDot;
 618         break;
 619     case wxPENSTYLE_USER_DASH :
 620         {
 621             dashStyle = DashStyleCustom;
 622             wxDash *dashes;
 623             int count = pen.GetDashes( &dashes );
 624             if ((dashes != NULL) && (count > 0))
 625             {
 626                 REAL *userLengths = new REAL[count];
 627                 for ( int i = 0; i < count; ++i )
 628                 {
 629                     userLengths[i] = dashes[i];
 630                 }
 631                 m_pen->SetDashPattern( userLengths, count);
 632                 delete[] userLengths;
 633             }
 634         }
 635         break;
 636     case wxPENSTYLE_STIPPLE :
 637         {
 638             wxBitmap* bmp = pen.GetStipple();
 639             if ( bmp && bmp->IsOk() )
 640             {
 641                 m_penImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),
 642 #if wxUSE_PALETTE
 643                     (HPALETTE)bmp->GetPalette()->GetHPALETTE()
 644 #else
 645                     NULL
 646 #endif
 647                 );
 648                 m_penBrush = new TextureBrush(m_penImage);
 649                 m_pen->SetBrush( m_penBrush );
 650             }
 651
 652         }
 653         break;
 654     default :
 655         if ( pen.GetStyle() >= wxPENSTYLE_FIRST_HATCH &&
 656              pen.GetStyle() <= wxPENSTYLE_LAST_HATCH )
 657         {
 658             HatchStyle style;
 659             switch( pen.GetStyle() )
 660             {
 661             case wxPENSTYLE_BDIAGONAL_HATCH :
 662                 style = HatchStyleBackwardDiagonal;
 663                 break ;
 664             case wxPENSTYLE_CROSSDIAG_HATCH :
 665                 style = HatchStyleDiagonalCross;
 666                 break ;
 667             case wxPENSTYLE_FDIAGONAL_HATCH :
 668                 style = HatchStyleForwardDiagonal;
 669                 break ;
 670             case wxPENSTYLE_CROSS_HATCH :
 671                 style = HatchStyleCross;
 672                 break ;
 673             case wxPENSTYLE_HORIZONTAL_HATCH :
 674                 style = HatchStyleHorizontal;
 675                 break ;
 676             case wxPENSTYLE_VERTICAL_HATCH :
 677                 style = HatchStyleVertical;
 678                 break ;
 679             default:
 680                 style = HatchStyleHorizontal;
 681             }
 682             m_penBrush = new HatchBrush
 683                              (
 684                                 style,
 685                                 wxColourToColor(pen.GetColour()),
 686                                 Color::Transparent
 687                              );
 688             m_pen->SetBrush( m_penBrush );
 689         }
 690         break;
 691     }
 692     if ( dashStyle != DashStyleSolid )
 693         m_pen->SetDashStyle(dashStyle);
 694 }
 695
 696 //-----------------------------------------------------------------------------
 697 // wxGDIPlusBrush implementation
 698 //-----------------------------------------------------------------------------
 699
 700 wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer* renderer )
 701 : wxGraphicsObjectRefData(renderer)
 702 {
 703     Init();
 704 }
 705
 706 wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer* renderer , const wxBrush &brush )
 707 : wxGraphicsObjectRefData(renderer)
 708 {
 709     Init();
 710     if ( brush.GetStyle() == wxSOLID)
 711     {
 712         m_brush = new SolidBrush(wxColourToColor( brush.GetColour()));
 713     }
 714     else if ( brush.IsHatch() )
 715     {
 716         HatchStyle style;
 717         switch( brush.GetStyle() )
 718         {
 719         case wxBRUSHSTYLE_BDIAGONAL_HATCH :
 720             style = HatchStyleBackwardDiagonal;
 721             break ;
 722         case wxBRUSHSTYLE_CROSSDIAG_HATCH :
 723             style = HatchStyleDiagonalCross;
 724             break ;
 725         case wxBRUSHSTYLE_FDIAGONAL_HATCH :
 726             style = HatchStyleForwardDiagonal;
 727             break ;
 728         case wxBRUSHSTYLE_CROSS_HATCH :
 729             style = HatchStyleCross;
 730             break ;
 731         case wxBRUSHSTYLE_HORIZONTAL_HATCH :
 732             style = HatchStyleHorizontal;
 733             break ;
 734         case wxBRUSHSTYLE_VERTICAL_HATCH :
 735             style = HatchStyleVertical;
 736             break ;
 737         default:
 738             style = HatchStyleHorizontal;
 739         }
 740         m_brush = new HatchBrush
 741                       (
 742                         style,
 743                         wxColourToColor(brush.GetColour()),
 744                         Color::Transparent
 745                       );
 746     }
 747     else
 748     {
 749         wxBitmap* bmp = brush.GetStipple();
 750         if ( bmp && bmp->IsOk() )
 751         {
 752             wxDELETE( m_brushImage );
 753             m_brushImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),
 754 #if wxUSE_PALETTE
 755                 (HPALETTE)bmp->GetPalette()->GetHPALETTE()
 756 #else
 757                 NULL
 758 #endif
 759             );
 760             m_brush = new TextureBrush(m_brushImage);
 761         }
 762     }
 763 }
 764
 765 wxGDIPlusBrushData::~wxGDIPlusBrushData()
 766 {
 767     delete m_brush;
 768     delete m_brushImage;
 769     delete m_brushPath;
 770 };
 771
 772 void wxGDIPlusBrushData::Init()
 773 {
 774     m_brush = NULL;
 775     m_brushImage= NULL;
 776     m_brushPath= NULL;
 777 }
 778
 779 template <typename T>
 780 void
 781 wxGDIPlusBrushData::SetGradientStops(T *brush,
 782         const wxGraphicsGradientStops& stops)
 783 {
 784     const unsigned numStops = stops.GetCount();
 785     if ( numStops <= 2 )
 786     {
 787         // initial and final colours are set during the brush creation, nothing
 788         // more to do
 789         return;
 790     }
 791
 792     wxVector<Color> colors(numStops);
 793     wxVector<REAL> positions(numStops);
 794
 795     for ( unsigned i = 0; i < numStops; i++ )
 796     {
 797         wxGraphicsGradientStop stop = stops.Item(i);
 798
 799         colors[i] = wxColourToColor(stop.GetColour());
 800         positions[i] = stop.GetPosition();
 801     }
 802
 803     brush->SetInterpolationColors(&colors[0], &positions[0], numStops);
 804 }
 805
 806 void
 807 wxGDIPlusBrushData::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
 808                                               wxDouble x2, wxDouble y2,
 809                                               const wxGraphicsGradientStops& stops)
 810 {
 811     LinearGradientBrush * const
 812         brush = new LinearGradientBrush(PointF(x1, y1) , PointF(x2, y2),
 813                                         wxColourToColor(stops.GetStartColour()),
 814                                         wxColourToColor(stops.GetEndColour()));
 815     m_brush =  brush;
 816
 817     SetGradientStops(brush, stops);
 818 }
 819
 820 void
 821 wxGDIPlusBrushData::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
 822                                               wxDouble xc, wxDouble yc,
 823                                               wxDouble radius,
 824                                               const wxGraphicsGradientStops& stops)
 825 {
 826     m_brushPath = new GraphicsPath();
 827     m_brushPath->AddEllipse( (REAL)(xc-radius), (REAL)(yc-radius),
 828                              (REAL)(2*radius), (REAL)(2*radius));
 829
 830     PathGradientBrush * const brush = new PathGradientBrush(m_brushPath);
 831     m_brush = brush;
 832     brush->SetCenterPoint(PointF(xo, yo));
 833     brush->SetCenterColor(wxColourToColor(stops.GetStartColour()));
 834
 835     const Color col(wxColourToColor(stops.GetEndColour()));
 836     int count = 1;
 837     brush->SetSurroundColors(&col, &count);
 838
 839     SetGradientStops(brush, stops);
 840 }
 841
 842 //-----------------------------------------------------------------------------
 843 // wxGDIPlusFont implementation
 844 //-----------------------------------------------------------------------------
 845
 846 wxGDIPlusFontData::wxGDIPlusFontData( wxGraphicsRenderer* renderer,
 847                                       const wxGDIPlusContext* gc,
 848                                       const wxFont &font,
 849                                       const wxColour& col )
 850     : wxGraphicsObjectRefData( renderer )
 851 {
 852     wxWCharBuffer s = font.GetFaceName().wc_str( *wxConvUI );
 853     int style = FontStyleRegular;
 854     if ( font.GetStyle() == wxFONTSTYLE_ITALIC )
 855         style |= FontStyleItalic;
 856     if ( font.GetUnderlined() )
 857         style |= FontStyleUnderline;
 858     if ( font.GetWeight() == wxFONTWEIGHT_BOLD )
 859         style |= FontStyleBold;
 860
 861     Graphics* context = gc->GetGraphics();
 862
 863     Unit fontUnit = context->GetPageUnit();
 864     // if fontUnit is UnitDisplay, then specify UnitPixel, otherwise
 865     // you'll get a "InvalidParameter" from GDI+
 866     if ( fontUnit == UnitDisplay )
 867         fontUnit = UnitPixel;
 868
 869     REAL points = font.GetPointSize();
 870
 871     // This scaling is needed when we use unit other than the
 872     // default UnitPoint. It works for both display and printing.
 873     REAL size = points * (100.0 / 72.0);
 874
 875     // NB: font unit should match context's unit. We can use UnitPixel,
 876     //     as that is what the print context should use.
 877     m_font = new Font( s, size, style, fontUnit );
 878
 879     m_textBrush = new SolidBrush(wxColourToColor(col));
 880 }
 881
 882 wxGDIPlusFontData::~wxGDIPlusFontData()
 883 {
 884     delete m_textBrush;
 885     delete m_font;
 886 }
 887
 888 // the built-in conversions functions create non-premultiplied bitmaps, while GDIPlus needs them in the
 889 // premultiplied format, therefore in the failing cases we create a new bitmap using the non-premultiplied
 890 // bytes as parameter, since there is no real copying of the data going in, only references are stored
 891 // m_helper has to be kept alive as well
 892
 893 //-----------------------------------------------------------------------------
 894 // wxGDIPlusBitmapData implementation
 895 //-----------------------------------------------------------------------------
 896
 897 wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap ) :
 898     wxGraphicsObjectRefData( renderer ), m_bitmap( bitmap )
 899 {
 900     m_helper = NULL;
 901 }
 902
 903 wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer,
 904                         const wxBitmap &bmp) : wxGraphicsObjectRefData( renderer )
 905 {
 906     m_bitmap = NULL;
 907     m_helper = NULL;
 908
 909     Bitmap* image = NULL;
 910     if ( bmp.GetMask() )
 911     {
 912         Bitmap interim((HBITMAP)bmp.GetHBITMAP(),
 913 #if wxUSE_PALETTE
 914             (HPALETTE)bmp.GetPalette()->GetHPALETTE()
 915 #else
 916             NULL
 917 #endif
 918         );
 919
 920         size_t width = interim.GetWidth();
 921         size_t height = interim.GetHeight();
 922         Rect bounds(0,0,width,height);
 923
 924         image = new Bitmap(width,height,PixelFormat32bppPARGB) ;
 925
 926         Bitmap interimMask((HBITMAP)bmp.GetMask()->GetMaskBitmap(),NULL);
 927         wxASSERT(interimMask.GetPixelFormat() == PixelFormat1bppIndexed);
 928
 929         BitmapData dataMask ;
 930         interimMask.LockBits(&bounds,ImageLockModeRead,
 931             interimMask.GetPixelFormat(),&dataMask);
 932
 933
 934         BitmapData imageData ;
 935         image->LockBits(&bounds,ImageLockModeWrite, PixelFormat32bppPARGB, &imageData);
 936
 937         BYTE maskPattern = 0 ;
 938         BYTE maskByte = 0;
 939         size_t maskIndex ;
 940
 941         for ( size_t y = 0 ; y < height ; ++y)
 942         {
 943             maskIndex = 0 ;
 944             for( size_t x = 0 ; x < width; ++x)
 945             {
 946                 if ( x % 8 == 0)
 947                 {
 948                     maskPattern = 0x80;
 949                     maskByte = *((BYTE*)dataMask.Scan0 + dataMask.Stride*y + maskIndex);
 950                     maskIndex++;
 951                 }
 952                 else
 953                     maskPattern = maskPattern >> 1;
 954
 955                 ARGB *dest = (ARGB*)((BYTE*)imageData.Scan0 + imageData.Stride*y + x*4);
 956                 if ( (maskByte & maskPattern) == 0 )
 957                     *dest = 0x00000000;
 958                 else
 959                 {
 960                     Color c ;
 961                     interim.GetPixel(x,y,&c) ;
 962                     *dest = (c.GetValue() | Color::AlphaMask);
 963                 }
 964             }
 965         }
 966
 967         image->UnlockBits(&imageData);
 968
 969         interimMask.UnlockBits(&dataMask);
 970         interim.UnlockBits(&dataMask);
 971     }
 972     else
 973     {
 974         image = Bitmap::FromHBITMAP((HBITMAP)bmp.GetHBITMAP(),
 975 #if wxUSE_PALETTE
 976             (HPALETTE)bmp.GetPalette()->GetHPALETTE()
 977 #else
 978             NULL
 979 #endif
 980         );
 981         if ( bmp.HasAlpha() && GetPixelFormatSize(image->GetPixelFormat()) == 32 )
 982         {
 983             size_t width = image->GetWidth();
 984             size_t height = image->GetHeight();
 985             Rect bounds(0,0,width,height);
 986             static BitmapData data ;
 987
 988             m_helper = image ;
 989             image = NULL ;
 990             m_helper->LockBits(&bounds, ImageLockModeRead,
 991                 m_helper->GetPixelFormat(),&data);
 992
 993             image = new Bitmap(data.Width, data.Height, data.Stride,
 994                 PixelFormat32bppPARGB , (BYTE*) data.Scan0);
 995
 996             m_helper->UnlockBits(&data);
 997         }
 998     }
 999     if ( image )
1000         m_bitmap = image;
1001 }
1002
1003 wxGDIPlusBitmapData::~wxGDIPlusBitmapData()
1004 {
1005     delete m_bitmap;
1006     delete m_helper;
1007 }
1008
1009 //-----------------------------------------------------------------------------
1010 // wxGDIPlusPath implementation
1011 //-----------------------------------------------------------------------------
1012
1013 wxGDIPlusPathData::wxGDIPlusPathData(wxGraphicsRenderer* renderer, GraphicsPath* path ) : wxGraphicsPathData(renderer)
1014 {
1015     if ( path )
1016         m_path = path;
1017     else
1018         m_path = new GraphicsPath();
1019 }
1020
1021 wxGDIPlusPathData::~wxGDIPlusPathData()
1022 {
1023     delete m_path;
1024 }
1025
1026 wxGraphicsObjectRefData* wxGDIPlusPathData::Clone() const
1027 {
1028     return new wxGDIPlusPathData( GetRenderer() , m_path->Clone());
1029 }
1030
1031 //
1032 // The Primitives
1033 //
1034
1035 void wxGDIPlusPathData::MoveToPoint( wxDouble x , wxDouble y )
1036 {
1037     m_path->StartFigure();
1038     m_path->AddLine((REAL) x,(REAL) y,(REAL) x,(REAL) y);
1039 }
1040
1041 void wxGDIPlusPathData::AddLineToPoint( wxDouble x , wxDouble y )
1042 {
1043     m_path->AddLine((REAL) x,(REAL) y,(REAL) x,(REAL) y);
1044 }
1045
1046 void wxGDIPlusPathData::CloseSubpath()
1047 {
1048     m_path->CloseFigure();
1049 }
1050
1051 void wxGDIPlusPathData::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
1052 {
1053     PointF c1(cx1,cy1);
1054     PointF c2(cx2,cy2);
1055     PointF end(x,y);
1056     PointF start;
1057     m_path->GetLastPoint(&start);
1058     m_path->AddBezier(start,c1,c2,end);
1059 }
1060
1061 // gets the last point of the current path, (0,0) if not yet set
1062 void wxGDIPlusPathData::GetCurrentPoint( wxDouble* x, wxDouble* y) const
1063 {
1064     PointF start;
1065     m_path->GetLastPoint(&start);
1066     *x = start.X ;
1067     *y = start.Y ;
1068 }
1069
1070 void wxGDIPlusPathData::AddArc( wxDouble x, wxDouble y, wxDouble r, double startAngle, double endAngle, bool clockwise )
1071 {
1072     double sweepAngle = endAngle - startAngle ;
1073     if( fabs(sweepAngle) >= 2*M_PI)
1074     {
1075         sweepAngle = 2 * M_PI;
1076     }
1077     else
1078     {
1079         if ( clockwise )
1080         {
1081             if( sweepAngle < 0 )
1082                 sweepAngle += 2 * M_PI;
1083         }
1084         else
1085         {
1086             if( sweepAngle > 0 )
1087                 sweepAngle -= 2 * M_PI;
1088
1089         }
1090    }
1091    m_path->AddArc((REAL) (x-r),(REAL) (y-r),(REAL) (2*r),(REAL) (2*r),RadToDeg(startAngle),RadToDeg(sweepAngle));
1092 }
1093
1094 void wxGDIPlusPathData::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1095 {
1096     m_path->AddRectangle(RectF(x,y,w,h));
1097 }
1098
1099 void wxGDIPlusPathData::AddPath( const wxGraphicsPathData* path )
1100 {
1101     m_path->AddPath( (GraphicsPath*) path->GetNativePath(), FALSE);
1102 }
1103
1104
1105 // transforms each point of this path by the matrix
1106 void wxGDIPlusPathData::Transform( const wxGraphicsMatrixData* matrix )
1107 {
1108     m_path->Transform( (Matrix*) matrix->GetNativeMatrix() );
1109 }
1110
1111 // gets the bounding box enclosing all points (possibly including control points)
1112 void wxGDIPlusPathData::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
1113 {
1114     RectF bounds;
1115     m_path->GetBounds( &bounds, NULL, NULL) ;
1116     *x = bounds.X;
1117     *y = bounds.Y;
1118     *w = bounds.Width;
1119     *h = bounds.Height;
1120 }
1121
1122 bool wxGDIPlusPathData::Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle ) const
1123 {
1124     m_path->SetFillMode( fillStyle == wxODDEVEN_RULE ? FillModeAlternate : FillModeWinding);
1125     return m_path->IsVisible( (FLOAT) x,(FLOAT) y) == TRUE ;
1126 }
1127
1128 //-----------------------------------------------------------------------------
1129 // wxGDIPlusMatrixData implementation
1130 //-----------------------------------------------------------------------------
1131
1132 wxGDIPlusMatrixData::wxGDIPlusMatrixData(wxGraphicsRenderer* renderer, Matrix* matrix )
1133     : wxGraphicsMatrixData(renderer)
1134 {
1135     if ( matrix )
1136         m_matrix = matrix ;
1137     else
1138         m_matrix = new Matrix();
1139 }
1140
1141 wxGDIPlusMatrixData::~wxGDIPlusMatrixData()
1142 {
1143     delete m_matrix;
1144 }
1145
1146 wxGraphicsObjectRefData *wxGDIPlusMatrixData::Clone() const
1147 {
1148     return new wxGDIPlusMatrixData( GetRenderer(), m_matrix->Clone());
1149 }
1150
1151 // concatenates the matrix
1152 void wxGDIPlusMatrixData::Concat( const wxGraphicsMatrixData *t )
1153 {
1154     m_matrix->Multiply( (Matrix*) t->GetNativeMatrix());
1155 }
1156
1157 // sets the matrix to the respective values
1158 void wxGDIPlusMatrixData::Set(wxDouble a, wxDouble b, wxDouble c, wxDouble d,
1159                  wxDouble tx, wxDouble ty)
1160 {
1161     m_matrix->SetElements(a,b,c,d,tx,ty);
1162 }
1163
1164 // gets the component valuess of the matrix
1165 void wxGDIPlusMatrixData::Get(wxDouble* a, wxDouble* b,  wxDouble* c,
1166                               wxDouble* d, wxDouble* tx, wxDouble* ty) const
1167 {
1168     REAL elements[6];
1169     m_matrix->GetElements(elements);
1170     if (a)  *a = elements[0];
1171     if (b)  *b = elements[1];
1172     if (c)  *c = elements[2];
1173     if (d)  *d = elements[3];
1174     if (tx) *tx= elements[4];
1175     if (ty) *ty= elements[5];
1176 }
1177
1178 // makes this the inverse matrix
1179 void wxGDIPlusMatrixData::Invert()
1180 {
1181     m_matrix->Invert();
1182 }
1183
1184 // returns true if the elements of the transformation matrix are equal ?
1185 bool wxGDIPlusMatrixData::IsEqual( const wxGraphicsMatrixData* t) const
1186 {
1187     return m_matrix->Equals((Matrix*) t->GetNativeMatrix())== TRUE ;
1188 }
1189
1190 // return true if this is the identity matrix
1191 bool wxGDIPlusMatrixData::IsIdentity() const
1192 {
1193     return m_matrix->IsIdentity() == TRUE ;
1194 }
1195
1196 //
1197 // transformation
1198 //
1199
1200 // add the translation to this matrix
1201 void wxGDIPlusMatrixData::Translate( wxDouble dx , wxDouble dy )
1202 {
1203     m_matrix->Translate(dx,dy);
1204 }
1205
1206 // add the scale to this matrix
1207 void wxGDIPlusMatrixData::Scale( wxDouble xScale , wxDouble yScale )
1208 {
1209     m_matrix->Scale(xScale,yScale);
1210 }
1211
1212 // add the rotation to this matrix (radians)
1213 void wxGDIPlusMatrixData::Rotate( wxDouble angle )
1214 {
1215     m_matrix->Rotate( RadToDeg(angle) );
1216 }
1217
1218 //
1219 // apply the transforms
1220 //
1221
1222 // applies that matrix to the point
1223 void wxGDIPlusMatrixData::TransformPoint( wxDouble *x, wxDouble *y ) const
1224 {
1225     PointF pt(*x,*y);
1226     m_matrix->TransformPoints(&pt);
1227     *x = pt.X;
1228     *y = pt.Y;
1229 }
1230
1231 // applies the matrix except for translations
1232 void wxGDIPlusMatrixData::TransformDistance( wxDouble *dx, wxDouble *dy ) const
1233 {
1234     PointF pt(*dx,*dy);
1235     m_matrix->TransformVectors(&pt);
1236     *dx = pt.X;
1237     *dy = pt.Y;
1238 }
1239
1240 // returns the native representation
1241 void * wxGDIPlusMatrixData::GetNativeMatrix() const
1242 {
1243     return m_matrix;
1244 }
1245
1246 //-----------------------------------------------------------------------------
1247 // wxGDIPlusContext implementation
1248 //-----------------------------------------------------------------------------
1249
1250 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusContext,wxGraphicsContext)
1251 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusMeasuringContext,wxGDIPlusContext)
1252
1253 class wxGDIPlusOffsetHelper
1254 {
1255 public :
1256     wxGDIPlusOffsetHelper( Graphics* gr , bool offset )
1257     {
1258         m_gr = gr;
1259         m_offset = offset;
1260         if ( m_offset )
1261             m_gr->TranslateTransform( 0.5, 0.5 );
1262     }
1263     ~wxGDIPlusOffsetHelper( )
1264     {
1265         if ( m_offset )
1266             m_gr->TranslateTransform( -0.5, -0.5 );
1267     }
1268 public :
1269     Graphics* m_gr;
1270     bool m_offset;
1271 } ;
1272
1273 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc, wxDouble width, wxDouble height   )
1274     : wxGraphicsContext(renderer)
1275 {
1276     Init();
1277     m_context = new Graphics( hdc);
1278     m_width = width;
1279     m_height = height;
1280     SetDefaults();
1281 }
1282
1283 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, const wxDC& dc )
1284     : wxGraphicsContext(renderer)
1285 {
1286     Init();
1287
1288     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
1289     HDC hdc = (HDC) msw->GetHDC();
1290
1291     m_context = new Graphics(hdc);
1292     wxSize sz = dc.GetSize();
1293     m_width = sz.x;
1294     m_height = sz.y;
1295
1296     SetDefaults();
1297 }
1298
1299 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd  )
1300     : wxGraphicsContext(renderer)
1301 {
1302     Init();
1303     m_enableOffset = true;
1304     m_context = new Graphics( hwnd);
1305     RECT rect = wxGetWindowRect(hwnd);
1306     m_width = rect.right - rect.left;
1307     m_height = rect.bottom - rect.top;
1308     SetDefaults();
1309 }
1310
1311 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr  )
1312     : wxGraphicsContext(renderer)
1313 {
1314     Init();
1315     m_context = gr;
1316     SetDefaults();
1317 }
1318
1319 wxGDIPlusContext::wxGDIPlusContext() : wxGraphicsContext(NULL)
1320 {
1321     Init();
1322 }
1323
1324 void wxGDIPlusContext::Init()
1325 {
1326     m_context = NULL;
1327     m_state1 = 0;
1328     m_state2= 0;
1329     m_height = 0;
1330     m_width = 0;
1331     m_fontScaleRatio = 1.0;
1332 }
1333
1334 void wxGDIPlusContext::SetDefaults()
1335 {
1336     m_context->SetTextRenderingHint(TextRenderingHintSystemDefault);
1337     m_context->SetPixelOffsetMode(PixelOffsetModeHalf);
1338     m_context->SetSmoothingMode(SmoothingModeHighQuality);
1339     m_state1 = m_context->Save();
1340     m_state2 = m_context->Save();
1341 }
1342
1343 wxGDIPlusContext::~wxGDIPlusContext()
1344 {
1345     if ( m_context )
1346     {
1347         m_context->Restore( m_state2 );
1348         m_context->Restore( m_state1 );
1349         delete m_context;
1350     }
1351 }
1352
1353
1354 void wxGDIPlusContext::Clip( const wxRegion &region )
1355 {
1356     Region rgn((HRGN)region.GetHRGN());
1357     m_context->SetClip(&rgn,CombineModeIntersect);
1358 }
1359
1360 void wxGDIPlusContext::Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1361 {
1362     m_context->SetClip(RectF(x,y,w,h),CombineModeIntersect);
1363 }
1364
1365 void wxGDIPlusContext::ResetClip()
1366 {
1367     m_context->ResetClip();
1368 }
1369
1370 void wxGDIPlusContext::DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1371 {
1372     if (m_composition == wxCOMPOSITION_DEST)
1373         return;
1374
1375     wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
1376     Brush *brush = m_brush.IsNull() ? NULL : ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush();
1377     Pen *pen = m_pen.IsNull() ? NULL : ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen();
1378
1379     if ( brush )
1380     {
1381         // the offset is used to fill only the inside of the rectangle and not paint underneath
1382         // its border which may influence a transparent Pen
1383         REAL offset = 0;
1384         if ( pen )
1385              offset = pen->GetWidth();
1386         m_context->FillRectangle( brush, (REAL)x + offset/2, (REAL)y + offset/2, (REAL)w - offset, (REAL)h - offset);
1387     }
1388
1389     if ( pen )
1390     {
1391         m_context->DrawRectangle( pen, (REAL)x, (REAL)y, (REAL)w, (REAL)h );
1392     }
1393 }
1394
1395 void wxGDIPlusContext::StrokeLines( size_t n, const wxPoint2DDouble *points)
1396 {
1397    if (m_composition == wxCOMPOSITION_DEST)
1398         return;
1399
1400    if ( !m_pen.IsNull() )
1401    {
1402        wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
1403        Point *cpoints = new Point[n];
1404        for (size_t i = 0; i < n; i++)
1405        {
1406            cpoints[i].X = (int)(points[i].m_x );
1407            cpoints[i].Y = (int)(points[i].m_y );
1408
1409        } // for (size_t i = 0; i < n; i++)
1410        m_context->DrawLines( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , cpoints , n ) ;
1411        delete[] cpoints;
1412    }
1413 }
1414
1415 void wxGDIPlusContext::DrawLines( size_t n, const wxPoint2DDouble *points, wxPolygonFillMode WXUNUSED(fillStyle) )
1416 {
1417    if (m_composition == wxCOMPOSITION_DEST)
1418         return;
1419
1420     wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
1421     Point *cpoints = new Point[n];
1422     for (size_t i = 0; i < n; i++)
1423     {
1424         cpoints[i].X = (int)(points[i].m_x );
1425         cpoints[i].Y = (int)(points[i].m_y );
1426
1427     } // for (int i = 0; i < n; i++)
1428     if ( !m_brush.IsNull() )
1429         m_context->FillPolygon( ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush() , cpoints , n ) ;
1430     if ( !m_pen.IsNull() )
1431         m_context->DrawLines( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , cpoints , n ) ;
1432     delete[] cpoints;
1433 }
1434
1435 void wxGDIPlusContext::StrokePath( const wxGraphicsPath& path )
1436 {
1437    if (m_composition == wxCOMPOSITION_DEST)
1438         return;
1439
1440     if ( !m_pen.IsNull() )
1441     {
1442         wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
1443         m_context->DrawPath( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , (GraphicsPath*) path.GetNativePath() );
1444     }
1445 }
1446
1447 void wxGDIPlusContext::FillPath( const wxGraphicsPath& path , wxPolygonFillMode fillStyle )
1448 {
1449    if (m_composition == wxCOMPOSITION_DEST)
1450         return;
1451
1452     if ( !m_brush.IsNull() )
1453     {
1454         wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
1455         ((GraphicsPath*) path.GetNativePath())->SetFillMode( fillStyle == wxODDEVEN_RULE ? FillModeAlternate : FillModeWinding);
1456         m_context->FillPath( ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush() ,
1457             (GraphicsPath*) path.GetNativePath());
1458     }
1459 }
1460
1461 bool wxGDIPlusContext::SetAntialiasMode(wxAntialiasMode antialias)
1462 {
1463     if (m_antialias == antialias)
1464         return true;
1465
1466     m_antialias = antialias;
1467
1468     SmoothingMode antialiasMode;
1469     switch (antialias)
1470     {
1471         case wxANTIALIAS_DEFAULT:
1472             antialiasMode = SmoothingModeHighQuality;
1473             break;
1474         case wxANTIALIAS_NONE:
1475             antialiasMode = SmoothingModeNone;
1476             break;
1477         default:
1478             return false;
1479     }
1480     m_context->SetSmoothingMode(antialiasMode);
1481     return true;
1482 }
1483
1484 bool wxGDIPlusContext::SetInterpolationQuality(wxInterpolationQuality WXUNUSED(interpolation))
1485 {
1486     // placeholder
1487     return false;
1488 }
1489
1490 bool wxGDIPlusContext::SetCompositionMode(wxCompositionMode op)
1491 {
1492     if ( m_composition == op )
1493         return true;
1494
1495     m_composition = op;
1496
1497     if (m_composition == wxCOMPOSITION_DEST)
1498         return true;
1499
1500     CompositingMode cop;
1501     switch (op)
1502     {
1503         case wxCOMPOSITION_SOURCE:
1504             cop = CompositingModeSourceCopy;
1505             break;
1506         case wxCOMPOSITION_OVER:
1507             cop = CompositingModeSourceOver;
1508             break;
1509         default:
1510             return false;
1511     }
1512
1513     m_context->SetCompositingMode(cop);
1514     return true;
1515 }
1516
1517 void wxGDIPlusContext::BeginLayer(wxDouble /* opacity */)
1518 {
1519     // TODO
1520 }
1521
1522 void wxGDIPlusContext::EndLayer()
1523 {
1524     // TODO
1525 }
1526
1527 void wxGDIPlusContext::Rotate( wxDouble angle )
1528 {
1529     m_context->RotateTransform( RadToDeg(angle) );
1530 }
1531
1532 void wxGDIPlusContext::Translate( wxDouble dx , wxDouble dy )
1533 {
1534     m_context->TranslateTransform( dx , dy );
1535 }
1536
1537 void wxGDIPlusContext::Scale( wxDouble xScale , wxDouble yScale )
1538 {
1539     m_context->ScaleTransform(xScale,yScale);
1540 }
1541
1542 void wxGDIPlusContext::PushState()
1543 {
1544     GraphicsState state = m_context->Save();
1545     m_stateStack.push(state);
1546 }
1547
1548 void wxGDIPlusContext::PopState()
1549 {
1550     wxCHECK_RET( !m_stateStack.empty(), wxT("No state to pop") );
1551
1552     GraphicsState state = m_stateStack.top();
1553     m_stateStack.pop();
1554     m_context->Restore(state);
1555 }
1556
1557 void wxGDIPlusContext::DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1558 {
1559    if (m_composition == wxCOMPOSITION_DEST)
1560         return;
1561
1562     Bitmap* image = static_cast<wxGDIPlusBitmapData*>(bmp.GetRefData())->GetGDIPlusBitmap();
1563     if ( image )
1564     {
1565         if( image->GetWidth() != (UINT) w || image->GetHeight() != (UINT) h )
1566         {
1567             Rect drawRect((REAL) x, (REAL)y, (REAL)w, (REAL)h);
1568             m_context->SetPixelOffsetMode( PixelOffsetModeNone );
1569             m_context->DrawImage(image, drawRect, 0 , 0 , image->GetWidth(), image->GetHeight(), UnitPixel ) ;
1570             m_context->SetPixelOffsetMode( PixelOffsetModeHalf );
1571         }
1572         else
1573             m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
1574     }
1575 }
1576
1577 void wxGDIPlusContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1578 {
1579     wxGraphicsBitmap bitmap = GetRenderer()->CreateBitmap(bmp);
1580     DrawBitmap(bitmap, x, y, w, h);
1581 }
1582
1583 void wxGDIPlusContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1584 {
1585    if (m_composition == wxCOMPOSITION_DEST)
1586         return;
1587
1588     // the built-in conversion fails when there is alpha in the HICON (eg XP style icons), we can only
1589     // find out by looking at the bitmap data whether there really was alpha in it
1590     HICON hIcon = (HICON)icon.GetHICON();
1591     ICONINFO iconInfo ;
1592     // IconInfo creates the bitmaps for color and mask, we must dispose of them after use
1593     if (!GetIconInfo(hIcon,&iconInfo))
1594         return;
1595
1596     Bitmap interim(iconInfo.hbmColor,NULL);
1597
1598     Bitmap* image = NULL ;
1599
1600     // if it's not 32 bit, it doesn't have an alpha channel, note that since the conversion doesn't
1601     // work correctly, asking IsAlphaPixelFormat at this point fails as well
1602     if( GetPixelFormatSize(interim.GetPixelFormat())!= 32 )
1603     {
1604         image = Bitmap::FromHICON(hIcon);
1605     }
1606     else
1607     {
1608         size_t width = interim.GetWidth();
1609         size_t height = interim.GetHeight();
1610         Rect bounds(0,0,width,height);
1611         BitmapData data ;
1612
1613         interim.LockBits(&bounds, ImageLockModeRead,
1614             interim.GetPixelFormat(),&data);
1615
1616         bool hasAlpha = false;
1617         for ( size_t y = 0 ; y < height && !hasAlpha ; ++y)
1618         {
1619             for( size_t x = 0 ; x < width && !hasAlpha; ++x)
1620             {
1621                 ARGB *dest = (ARGB*)((BYTE*)data.Scan0 + data.Stride*y + x*4);
1622                 if ( ( *dest & Color::AlphaMask ) != 0 )
1623                     hasAlpha = true;
1624             }
1625         }
1626
1627         if ( hasAlpha )
1628         {
1629         image = new Bitmap(data.Width, data.Height, data.Stride,
1630             PixelFormat32bppARGB , (BYTE*) data.Scan0);
1631         }
1632         else
1633         {
1634             image = Bitmap::FromHICON(hIcon);
1635         }
1636
1637         interim.UnlockBits(&data);
1638     }
1639
1640     m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
1641
1642     delete image ;
1643     DeleteObject(iconInfo.hbmColor);
1644     DeleteObject(iconInfo.hbmMask);
1645 }
1646
1647 wxGraphicsFont wxGDIPlusContext::CreateFont( const wxFont &font,
1648                                              const wxColour &col ) const
1649 {
1650     wxGDIPlusRenderer* renderer =
1651         static_cast<wxGDIPlusRenderer*>(GetRenderer());
1652     return renderer->CreateGDIPlusFont(this, font, col);
1653 }
1654
1655 void wxGDIPlusContext::DoDrawFilledText(const wxString& str,
1656                                         wxDouble x, wxDouble y,
1657                                         const wxGraphicsBrush& brush)
1658 {
1659    if (m_composition == wxCOMPOSITION_DEST)
1660         return;
1661
1662     wxCHECK_RET( !m_font.IsNull(),
1663                  wxT("wxGDIPlusContext::DrawText - no valid font set") );
1664
1665     if ( str.IsEmpty())
1666         return ;
1667
1668     wxGDIPlusFontData * const
1669         fontData = (wxGDIPlusFontData *)m_font.GetRefData();
1670     wxGDIPlusBrushData * const
1671         brushData = (wxGDIPlusBrushData *)brush.GetRefData();
1672
1673     m_context->DrawString
1674                (
1675                     str.wc_str(*wxConvUI),  // string to draw, always Unicode
1676                     -1,                     // length: string is NUL-terminated
1677                     fontData->GetGDIPlusFont(),
1678                     PointF(x, y),
1679                     StringFormat::GenericTypographic(),
1680                     brushData ? brushData->GetGDIPlusBrush()
1681                               : fontData->GetGDIPlusBrush()
1682                );
1683 }
1684
1685 void wxGDIPlusContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
1686                                      wxDouble *descent, wxDouble *externalLeading ) const
1687 {
1688     wxCHECK_RET( !m_font.IsNull(), wxT("wxGDIPlusContext::GetTextExtent - no valid font set") );
1689
1690     wxWCharBuffer s = str.wc_str( *wxConvUI );
1691     FontFamily ffamily ;
1692     Font* f = ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont();
1693
1694     f->GetFamily(&ffamily) ;
1695
1696     REAL factorY = m_fontScaleRatio;
1697
1698     REAL rDescent = ffamily.GetCellDescent(FontStyleRegular) *
1699         f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
1700     REAL rAscent = ffamily.GetCellAscent(FontStyleRegular) *
1701         f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
1702     REAL rHeight = ffamily.GetLineSpacing(FontStyleRegular) *
1703         f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
1704
1705     if ( height )
1706         *height = rHeight * factorY;
1707     if ( descent )
1708         *descent = rDescent * factorY;
1709     if ( externalLeading )
1710         *externalLeading = (rHeight - rAscent - rDescent) * factorY;
1711     // measuring empty strings is not guaranteed, so do it by hand
1712     if ( str.IsEmpty())
1713     {
1714         if ( width )
1715             *width = 0 ;
1716     }
1717     else
1718     {
1719         RectF layoutRect(0,0, 100000.0f, 100000.0f);
1720         StringFormat strFormat( StringFormat::GenericTypographic() );
1721         strFormat.SetFormatFlags( StringFormatFlagsMeasureTrailingSpaces | strFormat.GetFormatFlags() );
1722
1723         RectF bounds ;
1724         m_context->MeasureString((const wchar_t *) s , wcslen(s) , f, layoutRect, &strFormat, &bounds ) ;
1725         if ( width )
1726             *width = bounds.Width;
1727         if ( height )
1728             *height = bounds.Height;
1729     }
1730 }
1731
1732 void wxGDIPlusContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
1733 {
1734     widths.Empty();
1735     widths.Add(0, text.length());
1736
1737     wxCHECK_RET( !m_font.IsNull(), wxT("wxGDIPlusContext::GetPartialTextExtents - no valid font set") );
1738
1739     if (text.empty())
1740         return;
1741
1742     Font* f = ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont();
1743     wxWCharBuffer ws = text.wc_str( *wxConvUI );
1744     size_t len = wcslen( ws ) ;
1745     wxASSERT_MSG(text.length() == len , wxT("GetPartialTextExtents not yet implemented for multichar situations"));
1746
1747     RectF layoutRect(0,0, 100000.0f, 100000.0f);
1748     StringFormat strFormat( StringFormat::GenericTypographic() );
1749
1750     size_t startPosition = 0;
1751     size_t remainder = len;
1752     const size_t maxSpan = 32;
1753     CharacterRange* ranges = new CharacterRange[maxSpan] ;
1754     Region* regions = new Region[maxSpan];
1755
1756     while( remainder > 0 )
1757     {
1758         size_t span = wxMin( maxSpan, remainder );
1759
1760         for( size_t i = 0 ; i < span ; ++i)
1761         {
1762             ranges[i].First = 0 ;
1763             ranges[i].Length = startPosition+i+1 ;
1764         }
1765         strFormat.SetMeasurableCharacterRanges(span,ranges);
1766         strFormat.SetFormatFlags( StringFormatFlagsMeasureTrailingSpaces | strFormat.GetFormatFlags() );
1767         m_context->MeasureCharacterRanges(ws, -1 , f,layoutRect, &strFormat,span,regions) ;
1768
1769         RectF bbox ;
1770         for ( size_t i = 0 ; i < span ; ++i)
1771         {
1772             regions[i].GetBounds(&bbox,m_context);
1773             widths[startPosition+i] = bbox.Width;
1774         }
1775         remainder -= span;
1776         startPosition += span;
1777     }
1778
1779     delete[] ranges;
1780     delete[] regions;
1781 }
1782
1783 bool wxGDIPlusContext::ShouldOffset() const
1784 {
1785     if ( !m_enableOffset )
1786         return false;
1787
1788     int penwidth = 0 ;
1789     if ( !m_pen.IsNull() )
1790     {
1791         penwidth = (int)((wxGDIPlusPenData*)m_pen.GetRefData())->GetWidth();
1792         if ( penwidth == 0 )
1793             penwidth = 1;
1794     }
1795     return ( penwidth % 2 ) == 1;
1796 }
1797
1798 void* wxGDIPlusContext::GetNativeContext()
1799 {
1800     return m_context;
1801 }
1802
1803 // concatenates this transform with the current transform of this context
1804 void wxGDIPlusContext::ConcatTransform( const wxGraphicsMatrix& matrix )
1805 {
1806     m_context->MultiplyTransform((Matrix*) matrix.GetNativeMatrix());
1807 }
1808
1809 // sets the transform of this context
1810 void wxGDIPlusContext::SetTransform( const wxGraphicsMatrix& matrix )
1811 {
1812     m_context->SetTransform((Matrix*) matrix.GetNativeMatrix());
1813 }
1814
1815 // gets the matrix of this context
1816 wxGraphicsMatrix wxGDIPlusContext::GetTransform() const
1817 {
1818     wxGraphicsMatrix matrix = CreateMatrix();
1819     m_context->GetTransform((Matrix*) matrix.GetNativeMatrix());
1820     return matrix;
1821 }
1822
1823 void wxGDIPlusContext::GetSize( wxDouble* width, wxDouble *height )
1824 {
1825     *width = m_width;
1826     *height = m_height;
1827 }
1828
1829 //-----------------------------------------------------------------------------
1830 // wxGDIPlusPrintingContext implementation
1831 //-----------------------------------------------------------------------------
1832
1833 wxGDIPlusPrintingContext::wxGDIPlusPrintingContext( wxGraphicsRenderer* renderer,
1834                                                     const wxDC& dc )
1835     : wxGDIPlusContext(renderer, dc)
1836 {
1837     Graphics* context = GetGraphics();
1838
1839     //m_context->SetPageUnit(UnitDocument);
1840
1841     // Setup page scale, based on DPI ratio.
1842     // Antecedent should be 100dpi when the default page unit
1843     // (UnitDisplay) is used. Page unit UnitDocument would require 300dpi
1844     // instead. Note that calling SetPageScale() does not have effect on
1845     // non-printing DCs (that is, any other than wxPrinterDC or
1846     // wxEnhMetaFileDC).
1847     REAL dpiRatio = 100.0 / context->GetDpiY();
1848     context->SetPageScale(dpiRatio);
1849
1850     // We use this modifier when measuring fonts. It is needed because the
1851     // page scale is modified above.
1852     m_fontScaleRatio = context->GetDpiY() / 72.0;
1853 }
1854
1855 //-----------------------------------------------------------------------------
1856 // wxGDIPlusRenderer implementation
1857 //-----------------------------------------------------------------------------
1858
1859 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusRenderer,wxGraphicsRenderer)
1860
1861 static wxGDIPlusRenderer gs_GDIPlusRenderer;
1862
1863 wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer()
1864 {
1865     return &gs_GDIPlusRenderer;
1866 }
1867
1868 bool wxGDIPlusRenderer::EnsureIsLoaded()
1869 {
1870     // load gdiplus.dll if not yet loaded, but don't bother doing it again
1871     // if we already tried and failed (we don't want to spend lot of time
1872     // returning NULL from wxGraphicsContext::Create(), which may be called
1873     // relatively frequently):
1874     if ( m_loaded == -1 )
1875     {
1876         Load();
1877     }
1878
1879     return m_loaded == 1;
1880 }
1881
1882 // call EnsureIsLoaded() and return returnOnFail value if it fails
1883 #define ENSURE_LOADED_OR_RETURN(returnOnFail)  \
1884     if ( !EnsureIsLoaded() )                   \
1885         return (returnOnFail)
1886
1887
1888 void wxGDIPlusRenderer::Load()
1889 {
1890     GdiplusStartupInput input;
1891     GdiplusStartupOutput output;
1892     if ( GdiplusStartup(&m_gditoken,&input,&output) == Gdiplus::Ok )
1893     {
1894         wxLogTrace("gdiplus", "successfully initialized GDI+");
1895         m_loaded = 1;
1896     }
1897     else
1898     {
1899         wxLogTrace("gdiplus", "failed to initialize GDI+, missing gdiplus.dll?");
1900         m_loaded = 0;
1901     }
1902 }
1903
1904 void wxGDIPlusRenderer::Unload()
1905 {
1906     if ( m_gditoken )
1907     {
1908         GdiplusShutdown(m_gditoken);
1909         m_gditoken = 0;
1910     }
1911     m_loaded = -1; // next Load() will try again
1912 }
1913
1914 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxWindowDC& dc)
1915 {
1916     ENSURE_LOADED_OR_RETURN(NULL);
1917     wxGDIPlusContext* context = new wxGDIPlusContext(this, dc);
1918     context->EnableOffset(true);
1919     return context;
1920 }
1921
1922 #if wxUSE_PRINTING_ARCHITECTURE
1923 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxPrinterDC& dc)
1924 {
1925     ENSURE_LOADED_OR_RETURN(NULL);
1926     wxGDIPlusContext* context = new wxGDIPlusPrintingContext(this, dc);
1927     return context;
1928 }
1929 #endif
1930
1931 #if wxUSE_ENH_METAFILE
1932 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxEnhMetaFileDC& dc)
1933 {
1934     ENSURE_LOADED_OR_RETURN(NULL);
1935     wxGDIPlusContext* context = new wxGDIPlusPrintingContext(this, dc);
1936     return context;
1937 }
1938 #endif
1939
1940 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxMemoryDC& dc)
1941 {
1942     ENSURE_LOADED_OR_RETURN(NULL);
1943     wxGDIPlusContext* context = new wxGDIPlusContext(this, dc);
1944     context->EnableOffset(true);
1945     return context;
1946 }
1947
1948 wxGraphicsContext * wxGDIPlusRenderer::CreateMeasuringContext()
1949 {
1950     ENSURE_LOADED_OR_RETURN(NULL);
1951     return new wxGDIPlusMeasuringContext(this);
1952 }
1953
1954 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeContext( void * context )
1955 {
1956     ENSURE_LOADED_OR_RETURN(NULL);
1957     return new wxGDIPlusContext(this,(Graphics*) context);
1958 }
1959
1960
1961 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeWindow( void * window )
1962 {
1963     ENSURE_LOADED_OR_RETURN(NULL);
1964     return new wxGDIPlusContext(this,(HWND) window);
1965 }
1966
1967 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( wxWindow* window )
1968 {
1969     ENSURE_LOADED_OR_RETURN(NULL);
1970     return new wxGDIPlusContext(this, (HWND) window->GetHWND() );
1971 }
1972
1973 // Path
1974
1975 wxGraphicsPath wxGDIPlusRenderer::CreatePath()
1976 {
1977     ENSURE_LOADED_OR_RETURN(wxNullGraphicsPath);
1978     wxGraphicsPath m;
1979     m.SetRefData( new wxGDIPlusPathData(this));
1980     return m;
1981 }
1982
1983
1984 // Matrix
1985
1986 wxGraphicsMatrix wxGDIPlusRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
1987                                                            wxDouble tx, wxDouble ty)
1988
1989 {
1990     ENSURE_LOADED_OR_RETURN(wxNullGraphicsMatrix);
1991     wxGraphicsMatrix m;
1992     wxGDIPlusMatrixData* data = new wxGDIPlusMatrixData( this );
1993     data->Set( a,b,c,d,tx,ty ) ;
1994     m.SetRefData(data);
1995     return m;
1996 }
1997
1998 wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
1999 {
2000     ENSURE_LOADED_OR_RETURN(wxNullGraphicsPen);
2001     if ( !pen.IsOk() || pen.GetStyle() == wxTRANSPARENT )
2002         return wxNullGraphicsPen;
2003     else
2004     {
2005         wxGraphicsPen p;
2006         p.SetRefData(new wxGDIPlusPenData( this, pen ));
2007         return p;
2008     }
2009 }
2010
2011 wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush )
2012 {
2013     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
2014     if ( !brush.IsOk() || brush.GetStyle() == wxTRANSPARENT )
2015         return wxNullGraphicsBrush;
2016     else
2017     {
2018         wxGraphicsBrush p;
2019         p.SetRefData(new wxGDIPlusBrushData( this, brush ));
2020         return p;
2021     }
2022 }
2023
2024 wxGraphicsBrush
2025 wxGDIPlusRenderer::CreateLinearGradientBrush(wxDouble x1, wxDouble y1,
2026                                              wxDouble x2, wxDouble y2,
2027                                              const wxGraphicsGradientStops& stops)
2028 {
2029     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
2030     wxGraphicsBrush p;
2031     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
2032     d->CreateLinearGradientBrush(x1, y1, x2, y2, stops);
2033     p.SetRefData(d);
2034     return p;
2035  }
2036
2037 wxGraphicsBrush
2038 wxGDIPlusRenderer::CreateRadialGradientBrush(wxDouble xo, wxDouble yo,
2039                                              wxDouble xc, wxDouble yc,
2040                                              wxDouble radius,
2041                                              const wxGraphicsGradientStops& stops)
2042 {
2043     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBrush);
2044     wxGraphicsBrush p;
2045     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
2046     d->CreateRadialGradientBrush(xo,yo,xc,yc,radius,stops);
2047     p.SetRefData(d);
2048     return p;
2049 }
2050
2051 wxGraphicsFont
2052 wxGDIPlusRenderer::CreateGDIPlusFont( const wxGDIPlusContext* gc,
2053                                       const wxFont &font,
2054                                       const wxColour &col )
2055 {
2056     ENSURE_LOADED_OR_RETURN(wxNullGraphicsFont);
2057     if ( font.IsOk() )
2058     {
2059         wxGraphicsFont p;
2060         p.SetRefData(new wxGDIPlusFontData( this, gc, font, col ));
2061         return p;
2062     }
2063     else
2064         return wxNullGraphicsFont;
2065 }
2066
2067 wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmap( const wxBitmap &bitmap )
2068 {
2069     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
2070     if ( bitmap.IsOk() )
2071     {
2072         wxGraphicsBitmap p;
2073         p.SetRefData(new wxGDIPlusBitmapData( this , bitmap ));
2074         return p;
2075     }
2076     else
2077         return wxNullGraphicsBitmap;
2078 }
2079
2080 wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmapFromNativeBitmap( void *bitmap )
2081 {
2082     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
2083     if ( bitmap != NULL )
2084     {
2085         wxGraphicsBitmap p;
2086         p.SetRefData(new wxGDIPlusBitmapData( this , (Bitmap*) bitmap ));
2087         return p;
2088     }
2089     else
2090         return wxNullGraphicsBitmap;
2091 }
2092
2093 wxGraphicsBitmap wxGDIPlusRenderer::CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h  )
2094 {
2095     ENSURE_LOADED_OR_RETURN(wxNullGraphicsBitmap);
2096     Bitmap* image = static_cast<wxGDIPlusBitmapData*>(bitmap.GetRefData())->GetGDIPlusBitmap();
2097     if ( image )
2098     {
2099         wxGraphicsBitmap p;
2100         p.SetRefData(new wxGDIPlusBitmapData( this , image->Clone( (REAL) x , (REAL) y , (REAL) w , (REAL) h , PixelFormat32bppPARGB) ));
2101         return p;
2102     }
2103     else
2104         return wxNullGraphicsBitmap;
2105 }
2106
2107 // Shutdown GDI+ at app exit, before possible dll unload
2108 class wxGDIPlusRendererModule : public wxModule
2109 {
2110 public:
2111     virtual bool OnInit() { return true; }
2112     virtual void OnExit() { gs_GDIPlusRenderer.Unload(); }
2113
2114 private:
2115     DECLARE_DYNAMIC_CLASS(wxGDIPlusRendererModule)
2116 };
2117
2118 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusRendererModule, wxModule)
2119
2120 // ----------------------------------------------------------------------------
2121 // wxMSW-specific parts of wxGCDC
2122 // ----------------------------------------------------------------------------
2123
2124 WXHDC wxGCDC::AcquireHDC()
2125 {
2126     wxGraphicsContext * const gc = GetGraphicsContext();
2127     if ( !gc )
2128         return NULL;
2129
2130 #if wxUSE_CAIRO
2131     // we can't get the HDC if it is not a GDI+ context
2132     wxGraphicsRenderer* r1 = gc->GetRenderer();
2133     wxGraphicsRenderer* r2 = wxGraphicsRenderer::GetCairoRenderer();
2134     if (r1 == r2)
2135         return NULL;
2136 #endif
2137
2138     Graphics * const g = static_cast<Graphics *>(gc->GetNativeContext());
2139     return g ? g->GetHDC() : NULL;
2140 }
2141
2142 void wxGCDC::ReleaseHDC(WXHDC hdc)
2143 {
2144     if ( !hdc )
2145         return;
2146
2147     wxGraphicsContext * const gc = GetGraphicsContext();
2148     wxCHECK_RET( gc, "can't release HDC because there is no wxGraphicsContext" );
2149
2150 #if wxUSE_CAIRO
2151     // we can't get the HDC if it is not a GDI+ context
2152     wxGraphicsRenderer* r1 = gc->GetRenderer();
2153     wxGraphicsRenderer* r2 = wxGraphicsRenderer::GetCairoRenderer();
2154     if (r1 == r2)
2155         return;
2156 #endif
2157
2158     Graphics * const g = static_cast<Graphics *>(gc->GetNativeContext());
2159     wxCHECK_RET( g, "can't release HDC because there is no Graphics" );
2160
2161     g->ReleaseHDC((HDC)hdc);
2162 }
2163
2164 #endif  // wxUSE_GRAPHICS_CONTEXT