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 #include "wx/dc.h"
  15
  16 #ifdef __BORLANDC__
  17 #pragma hdrstop
  18 #endif
  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/dc.h"
  27     #include "wx/utils.h"
  28     #include "wx/dialog.h"
  29     #include "wx/app.h"
  30     #include "wx/bitmap.h"
  31     #include "wx/dcmemory.h"
  32     #include "wx/log.h"
  33     #include "wx/icon.h"
  34     #include "wx/dcprint.h"
  35     #include "wx/module.h"
  36 #endif
  37
  38 #include "wx/private/graphics.h"
  39 #include "wx/msw/wrapgdip.h"
  40 #include "wx/msw/dc.h"
  41
  42 #include "wx/stack.h"
  43
  44 WX_DECLARE_STACK(GraphicsState, GraphicsStates);
  45
  46 //-----------------------------------------------------------------------------
  47 // constants
  48 //-----------------------------------------------------------------------------
  49
  50 const double RAD2DEG = 180.0 / M_PI;
  51
  52 //-----------------------------------------------------------------------------
  53 // Local functions
  54 //-----------------------------------------------------------------------------
  55
  56 static inline double dmin(double a, double b) { return a < b ? a : b; }
  57 static inline double dmax(double a, double b) { return a > b ? a : b; }
  58
  59 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
  60 static inline double RadToDeg(double deg) { return (deg * 180.0) / M_PI; }
  61
  62 //-----------------------------------------------------------------------------
  63 // device context implementation
  64 //
  65 // more and more of the dc functionality should be implemented by calling
  66 // the appropricate wxGDIPlusContext, but we will have to do that step by step
  67 // also coordinate conversions should be moved to native matrix ops
  68 //-----------------------------------------------------------------------------
  69
  70 // we always stock two context states, one at entry, to be able to preserve the
  71 // state we were called with, the other one after changing to HI Graphics orientation
  72 // (this one is used for getting back clippings etc)
  73
  74 //-----------------------------------------------------------------------------
  75 // wxGraphicsPath implementation
  76 //-----------------------------------------------------------------------------
  77
  78 #include "wx/msw/private.h" // needs to be before #include <commdlg.h>
  79
  80 #if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
  81 #include <commdlg.h>
  82 #endif
  83
  84 class wxGDIPlusPathData : public wxGraphicsPathData
  85 {
  86 public :
  87     wxGDIPlusPathData(wxGraphicsRenderer* renderer, GraphicsPath* path = NULL);
  88     ~wxGDIPlusPathData();
  89
  90     virtual wxGraphicsObjectRefData *Clone() const;
  91
  92     //
  93     // These are the path primitives from which everything else can be constructed
  94     //
  95
  96     // begins a new subpath at (x,y)
  97     virtual void MoveToPoint( wxDouble x, wxDouble y );
  98
  99     // adds a straight line from the current point to (x,y)
 100     virtual void AddLineToPoint( wxDouble x, wxDouble y );
 101
 102     // adds a cubic Bezier curve from the current point, using two control points and an end point
 103     virtual void AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y );
 104
 105
 106     // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
 107     virtual void AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise ) ;
 108
 109     // gets the last point of the current path, (0,0) if not yet set
 110     virtual void GetCurrentPoint( wxDouble* x, wxDouble* y) const;
 111
 112     // adds another path
 113     virtual void AddPath( const wxGraphicsPathData* path );
 114
 115     // closes the current sub-path
 116     virtual void CloseSubpath();
 117
 118     //
 119     // These are convenience functions which - if not available natively will be assembled
 120     // using the primitives from above
 121     //
 122
 123     // appends a rectangle as a new closed subpath
 124     virtual void AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h ) ;
 125     /*
 126
 127     // appends an ellipsis as a new closed subpath fitting the passed rectangle
 128     virtual void AddEllipsis( wxDouble x, wxDouble y, wxDouble w , wxDouble h ) ;
 129
 130     // 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)
 131     virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )  ;
 132 */
 133
 134     // returns the native path
 135     virtual void * GetNativePath() const { return m_path; }
 136
 137     // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
 138     virtual void UnGetNativePath(void * WXUNUSED(path)) const {}
 139
 140     // transforms each point of this path by the matrix
 141     virtual void Transform( const wxGraphicsMatrixData* matrix ) ;
 142
 143     // gets the bounding box enclosing all points (possibly including control points)
 144     virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const;
 145
 146     virtual bool Contains( wxDouble x, wxDouble y, int fillStyle = wxODDEVEN_RULE) const;
 147
 148 private :
 149     GraphicsPath* m_path;
 150 };
 151
 152 class wxGDIPlusMatrixData : public wxGraphicsMatrixData
 153 {
 154 public :
 155     wxGDIPlusMatrixData(wxGraphicsRenderer* renderer, Matrix* matrix = NULL) ;
 156     virtual ~wxGDIPlusMatrixData() ;
 157
 158     virtual wxGraphicsObjectRefData* Clone() const ;
 159
 160     // concatenates the matrix
 161     virtual void Concat( const wxGraphicsMatrixData *t );
 162
 163     // sets the matrix to the respective values
 164     virtual void Set(wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
 165         wxDouble tx=0.0, wxDouble ty=0.0);
 166
 167     // gets the component valuess of the matrix
 168     virtual void Get(wxDouble* a=NULL, wxDouble* b=NULL,  wxDouble* c=NULL,
 169                      wxDouble* d=NULL, wxDouble* tx=NULL, wxDouble* ty=NULL) const;
 170
 171     // makes this the inverse matrix
 172     virtual void Invert();
 173
 174     // returns true if the elements of the transformation matrix are equal ?
 175     virtual bool IsEqual( const wxGraphicsMatrixData* t) const ;
 176
 177     // return true if this is the identity matrix
 178     virtual bool IsIdentity() const;
 179
 180     //
 181     // transformation
 182     //
 183
 184     // add the translation to this matrix
 185     virtual void Translate( wxDouble dx , wxDouble dy );
 186
 187     // add the scale to this matrix
 188     virtual void Scale( wxDouble xScale , wxDouble yScale );
 189
 190     // add the rotation to this matrix (radians)
 191     virtual void Rotate( wxDouble angle );
 192
 193     //
 194     // apply the transforms
 195     //
 196
 197     // applies that matrix to the point
 198     virtual void TransformPoint( wxDouble *x, wxDouble *y ) const;
 199
 200     // applies the matrix except for translations
 201     virtual void TransformDistance( wxDouble *dx, wxDouble *dy ) const;
 202
 203     // returns the native representation
 204     virtual void * GetNativeMatrix() const;
 205 private:
 206     Matrix* m_matrix ;
 207 } ;
 208
 209 class wxGDIPlusPenData : public wxGraphicsObjectRefData
 210 {
 211 public:
 212     wxGDIPlusPenData( wxGraphicsRenderer* renderer, const wxPen &pen );
 213     ~wxGDIPlusPenData();
 214
 215     void Init();
 216
 217     virtual wxDouble GetWidth() { return m_width; }
 218     virtual Pen* GetGDIPlusPen() { return m_pen; }
 219
 220 protected :
 221     Pen* m_pen;
 222     Image* m_penImage;
 223     Brush* m_penBrush;
 224
 225     wxDouble m_width;
 226 };
 227
 228 class wxGDIPlusBrushData : public wxGraphicsObjectRefData
 229 {
 230 public:
 231     wxGDIPlusBrushData( wxGraphicsRenderer* renderer );
 232     wxGDIPlusBrushData( wxGraphicsRenderer* renderer, const wxBrush &brush );
 233     ~wxGDIPlusBrushData ();
 234
 235     void CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
 236         const wxColour&c1, const wxColour&c2 );
 237     void CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
 238         const wxColour &oColor, const wxColour &cColor );
 239     virtual Brush* GetGDIPlusBrush() { return m_brush; }
 240
 241 protected:
 242     virtual void Init();
 243
 244 private :
 245     Brush* m_brush;
 246     Image* m_brushImage;
 247     GraphicsPath* m_brushPath;
 248 };
 249
 250 class WXDLLIMPEXP_CORE wxGDIPlusBitmapData : public wxGraphicsObjectRefData
 251 {
 252 public:
 253     wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap );
 254     wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, const wxBitmap &bmp );
 255     ~wxGDIPlusBitmapData ();
 256
 257     virtual Bitmap* GetGDIPlusBitmap() { return m_bitmap; }
 258
 259 private :
 260     Bitmap* m_bitmap;
 261     Bitmap* m_helper;
 262 };
 263
 264 class wxGDIPlusFontData : public wxGraphicsObjectRefData
 265 {
 266 public:
 267     wxGDIPlusFontData( wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col );
 268     ~wxGDIPlusFontData();
 269
 270     virtual Brush* GetGDIPlusBrush() { return m_textBrush; }
 271     virtual Font* GetGDIPlusFont() { return m_font; }
 272 private :
 273     Brush* m_textBrush;
 274     Font* m_font;
 275 };
 276
 277 class wxGDIPlusContext : public wxGraphicsContext
 278 {
 279 public:
 280     wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc );
 281     wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd );
 282     wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr);
 283     wxGDIPlusContext();
 284
 285     virtual ~wxGDIPlusContext();
 286
 287     virtual void Clip( const wxRegion &region );
 288     // clips drawings to the rect
 289     virtual void Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 290
 291     // resets the clipping to original extent
 292     virtual void ResetClip();
 293
 294     virtual void * GetNativeContext();
 295
 296     virtual void StrokePath( const wxGraphicsPath& p );
 297     virtual void FillPath( const wxGraphicsPath& p , int fillStyle = wxODDEVEN_RULE );
 298
 299         // stroke lines connecting each of the points
 300     virtual void StrokeLines( size_t n, const wxPoint2DDouble *points);
 301
 302     // draws a polygon
 303     virtual void DrawLines( size_t n, const wxPoint2DDouble *points, int fillStyle = wxODDEVEN_RULE );
 304
 305     virtual void Translate( wxDouble dx , wxDouble dy );
 306     virtual void Scale( wxDouble xScale , wxDouble yScale );
 307     virtual void Rotate( wxDouble angle );
 308
 309     // concatenates this transform with the current transform of this context
 310     virtual void ConcatTransform( const wxGraphicsMatrix& matrix );
 311
 312     // sets the transform of this context
 313     virtual void SetTransform( const wxGraphicsMatrix& matrix );
 314
 315     // gets the matrix of this context
 316     virtual wxGraphicsMatrix GetTransform() const;
 317
 318     virtual void DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 319     virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 320     virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 321     virtual void PushState();
 322     virtual void PopState();
 323
 324     virtual void DrawText( const wxString &str, wxDouble x, wxDouble y);
 325     virtual void GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
 326         wxDouble *descent, wxDouble *externalLeading ) const;
 327     virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
 328     virtual bool ShouldOffset() const;
 329
 330 private:
 331     void    Init();
 332     void    SetDefaults();
 333
 334     Graphics* m_context;
 335     GraphicsStates m_stateStack;
 336     GraphicsState m_state1;
 337     GraphicsState m_state2;
 338
 339     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusContext)
 340 };
 341
 342 class WXDLLIMPEXP_CORE wxGDIPlusMeasuringContext : public wxGDIPlusContext
 343 {
 344 public:
 345     wxGDIPlusMeasuringContext( wxGraphicsRenderer* renderer ) : wxGDIPlusContext( renderer , m_hdc = GetDC(NULL) )
 346     {
 347     }
 348     wxGDIPlusMeasuringContext()
 349     {
 350     }
 351
 352     virtual ~wxGDIPlusMeasuringContext()
 353     {
 354         ReleaseDC( NULL, m_hdc );
 355     }
 356
 357 private:
 358     HDC m_hdc ;
 359     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusMeasuringContext)
 360 } ;
 361
 362 //-----------------------------------------------------------------------------
 363 // wxGDIPlusPen implementation
 364 //-----------------------------------------------------------------------------
 365
 366 wxGDIPlusPenData::~wxGDIPlusPenData()
 367 {
 368     delete m_pen;
 369     delete m_penImage;
 370     delete m_penBrush;
 371 }
 372
 373 void wxGDIPlusPenData::Init()
 374 {
 375     m_pen = NULL ;
 376     m_penImage = NULL;
 377     m_penBrush = NULL;
 378 }
 379
 380 wxGDIPlusPenData::wxGDIPlusPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
 381 : wxGraphicsObjectRefData(renderer)
 382 {
 383     Init();
 384     m_width = pen.GetWidth();
 385     if (m_width <= 0.0)
 386         m_width = 0.1;
 387
 388     m_pen = new Pen(Color( pen.GetColour().Alpha() , pen.GetColour().Red() ,
 389         pen.GetColour().Green() , pen.GetColour().Blue() ), m_width );
 390
 391     LineCap cap;
 392     switch ( pen.GetCap() )
 393     {
 394     case wxCAP_ROUND :
 395         cap = LineCapRound;
 396         break;
 397
 398     case wxCAP_PROJECTING :
 399         cap = LineCapSquare;
 400         break;
 401
 402     case wxCAP_BUTT :
 403         cap = LineCapFlat; // TODO verify
 404         break;
 405
 406     default :
 407         cap = LineCapFlat;
 408         break;
 409     }
 410     m_pen->SetLineCap(cap,cap, DashCapFlat);
 411
 412     LineJoin join;
 413     switch ( pen.GetJoin() )
 414     {
 415     case wxJOIN_BEVEL :
 416         join = LineJoinBevel;
 417         break;
 418
 419     case wxJOIN_MITER :
 420         join = LineJoinMiter;
 421         break;
 422
 423     case wxJOIN_ROUND :
 424         join = LineJoinRound;
 425         break;
 426
 427     default :
 428         join = LineJoinMiter;
 429         break;
 430     }
 431
 432     m_pen->SetLineJoin(join);
 433
 434     m_pen->SetDashStyle(DashStyleSolid);
 435
 436     DashStyle dashStyle = DashStyleSolid;
 437     switch ( pen.GetStyle() )
 438     {
 439     case wxSOLID :
 440         break;
 441
 442     case wxDOT :
 443         dashStyle = DashStyleDot;
 444         break;
 445
 446     case wxLONG_DASH :
 447         dashStyle = DashStyleDash; // TODO verify
 448         break;
 449
 450     case wxSHORT_DASH :
 451         dashStyle = DashStyleDash;
 452         break;
 453
 454     case wxDOT_DASH :
 455         dashStyle = DashStyleDashDot;
 456         break;
 457     case wxUSER_DASH :
 458         {
 459             dashStyle = DashStyleCustom;
 460             wxDash *dashes;
 461             int count = pen.GetDashes( &dashes );
 462             if ((dashes != NULL) && (count > 0))
 463             {
 464                 REAL *userLengths = new REAL[count];
 465                 for ( int i = 0; i < count; ++i )
 466                 {
 467                     userLengths[i] = dashes[i];
 468                 }
 469                 m_pen->SetDashPattern( userLengths, count);
 470                 delete[] userLengths;
 471             }
 472         }
 473         break;
 474     case wxSTIPPLE :
 475         {
 476             wxBitmap* bmp = pen.GetStipple();
 477             if ( bmp && bmp->Ok() )
 478             {
 479                 m_penImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
 480                 m_penBrush = new TextureBrush(m_penImage);
 481                 m_pen->SetBrush( m_penBrush );
 482             }
 483
 484         }
 485         break;
 486     default :
 487         if ( pen.GetStyle() >= wxFIRST_HATCH && pen.GetStyle() <= wxLAST_HATCH )
 488         {
 489             HatchStyle style = HatchStyleHorizontal;
 490             switch( pen.GetStyle() )
 491             {
 492             case wxBDIAGONAL_HATCH :
 493                 style = HatchStyleBackwardDiagonal;
 494                 break ;
 495             case wxCROSSDIAG_HATCH :
 496                 style = HatchStyleDiagonalCross;
 497                 break ;
 498             case wxFDIAGONAL_HATCH :
 499                 style = HatchStyleForwardDiagonal;
 500                 break ;
 501             case wxCROSS_HATCH :
 502                 style = HatchStyleCross;
 503                 break ;
 504             case wxHORIZONTAL_HATCH :
 505                 style = HatchStyleHorizontal;
 506                 break ;
 507             case wxVERTICAL_HATCH :
 508                 style = HatchStyleVertical;
 509                 break ;
 510
 511             }
 512             m_penBrush = new HatchBrush(style,Color( pen.GetColour().Alpha() , pen.GetColour().Red() ,
 513                 pen.GetColour().Green() , pen.GetColour().Blue() ), Color::Transparent );
 514             m_pen->SetBrush( m_penBrush );
 515         }
 516         break;
 517     }
 518     if ( dashStyle != DashStyleSolid )
 519         m_pen->SetDashStyle(dashStyle);
 520 }
 521
 522 //-----------------------------------------------------------------------------
 523 // wxGDIPlusBrush implementation
 524 //-----------------------------------------------------------------------------
 525
 526 wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer* renderer )
 527 : wxGraphicsObjectRefData(renderer)
 528 {
 529     Init();
 530 }
 531
 532 wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer* renderer , const wxBrush &brush )
 533 : wxGraphicsObjectRefData(renderer)
 534 {
 535     Init();
 536     if ( brush.GetStyle() == wxSOLID)
 537     {
 538         m_brush = new SolidBrush( Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
 539             brush.GetColour().Green() , brush.GetColour().Blue() ) );
 540     }
 541     else if ( brush.IsHatch() )
 542     {
 543         HatchStyle style = HatchStyleHorizontal;
 544         switch( brush.GetStyle() )
 545         {
 546         case wxBDIAGONAL_HATCH :
 547             style = HatchStyleBackwardDiagonal;
 548             break ;
 549         case wxCROSSDIAG_HATCH :
 550             style = HatchStyleDiagonalCross;
 551             break ;
 552         case wxFDIAGONAL_HATCH :
 553             style = HatchStyleForwardDiagonal;
 554             break ;
 555         case wxCROSS_HATCH :
 556             style = HatchStyleCross;
 557             break ;
 558         case wxHORIZONTAL_HATCH :
 559             style = HatchStyleHorizontal;
 560             break ;
 561         case wxVERTICAL_HATCH :
 562             style = HatchStyleVertical;
 563             break ;
 564
 565         }
 566         m_brush = new HatchBrush(style,Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
 567             brush.GetColour().Green() , brush.GetColour().Blue() ), Color::Transparent );
 568     }
 569     else
 570     {
 571         wxBitmap* bmp = brush.GetStipple();
 572         if ( bmp && bmp->Ok() )
 573         {
 574             wxDELETE( m_brushImage );
 575             m_brushImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
 576             m_brush = new TextureBrush(m_brushImage);
 577         }
 578     }
 579 }
 580
 581 wxGDIPlusBrushData::~wxGDIPlusBrushData()
 582 {
 583     delete m_brush;
 584     delete m_brushImage;
 585     delete m_brushPath;
 586 };
 587
 588 void wxGDIPlusBrushData::Init()
 589 {
 590     m_brush = NULL;
 591     m_brushImage= NULL;
 592     m_brushPath= NULL;
 593 }
 594
 595 void wxGDIPlusBrushData::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2, const wxColour&c1, const wxColour&c2)
 596 {
 597     m_brush = new LinearGradientBrush( PointF( x1,y1) , PointF( x2,y2),
 598         Color( c1.Alpha(), c1.Red(),c1.Green() , c1.Blue() ),
 599         Color( c2.Alpha(), c2.Red(),c2.Green() , c2.Blue() ));
 600 }
 601
 602 void wxGDIPlusBrushData::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
 603                                                const wxColour &oColor, const wxColour &cColor)
 604 {
 605     // Create a path that consists of a single circle.
 606     m_brushPath = new GraphicsPath();
 607     m_brushPath->AddEllipse( (REAL)(xc-radius), (REAL)(yc-radius), (REAL)(2*radius), (REAL)(2*radius));
 608
 609     PathGradientBrush *b = new PathGradientBrush(m_brushPath);
 610     m_brush = b;
 611     b->SetCenterPoint( PointF(xo,yo));
 612     b->SetCenterColor(Color( oColor.Alpha(), oColor.Red(),oColor.Green() , oColor.Blue() ));
 613
 614     Color colors[] = {Color( cColor.Alpha(), cColor.Red(),cColor.Green() , cColor.Blue() )};
 615     int count = 1;
 616     b->SetSurroundColors(colors, &count);
 617 }
 618
 619 //-----------------------------------------------------------------------------
 620 // wxGDIPlusFont implementation
 621 //-----------------------------------------------------------------------------
 622
 623 wxGDIPlusFontData::wxGDIPlusFontData( wxGraphicsRenderer* renderer, const wxFont &font,
 624                              const wxColour& col ) : wxGraphicsObjectRefData( renderer )
 625 {
 626     m_textBrush = NULL;
 627     m_font = NULL;
 628
 629     wxWCharBuffer s = font.GetFaceName().wc_str( *wxConvUI );
 630     int size = font.GetPointSize();
 631     int style = FontStyleRegular;
 632     if ( font.GetStyle() == wxFONTSTYLE_ITALIC )
 633         style |= FontStyleItalic;
 634     if ( font.GetUnderlined() )
 635         style |= FontStyleUnderline;
 636     if ( font.GetWeight() == wxFONTWEIGHT_BOLD )
 637         style |= FontStyleBold;
 638     m_font = new Font( s , size , style );
 639     m_textBrush = new SolidBrush( Color( col.Alpha() , col.Red() ,
 640         col.Green() , col.Blue() ));
 641 }
 642
 643 wxGDIPlusFontData::~wxGDIPlusFontData()
 644 {
 645     delete m_textBrush;
 646     delete m_font;
 647 }
 648
 649 // the built-in conversions functions create non-premultiplied bitmaps, while GDIPlus needs them in the
 650 // premultiplied format, therefore in the failing cases we create a new bitmap using the non-premultiplied
 651 // bytes as parameter, since there is no real copying of the data going in, only references are stored
 652 // m_helper has to be kept alive as well
 653
 654 //-----------------------------------------------------------------------------
 655 // wxGDIPlusBitmapData implementation
 656 //-----------------------------------------------------------------------------
 657
 658 wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer, Bitmap* bitmap ) :
 659     wxGraphicsObjectRefData( renderer ), m_bitmap( bitmap )
 660 {
 661     m_helper = NULL;
 662 }
 663
 664 wxGDIPlusBitmapData::wxGDIPlusBitmapData( wxGraphicsRenderer* renderer,
 665                         const wxBitmap &bmp) : wxGraphicsObjectRefData( renderer )
 666 {
 667     m_bitmap = NULL;
 668     m_helper = NULL;
 669
 670     Bitmap* image = NULL;
 671     if ( bmp.GetMask() )
 672     {
 673         Bitmap interim((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE()) ;
 674
 675         size_t width = interim.GetWidth();
 676         size_t height = interim.GetHeight();
 677         Rect bounds(0,0,width,height);
 678
 679         image = new Bitmap(width,height,PixelFormat32bppPARGB) ;
 680
 681         Bitmap interimMask((HBITMAP)bmp.GetMask()->GetMaskBitmap(),NULL);
 682         wxASSERT(interimMask.GetPixelFormat() == PixelFormat1bppIndexed);
 683
 684         BitmapData dataMask ;
 685         interimMask.LockBits(&bounds,ImageLockModeRead,
 686             interimMask.GetPixelFormat(),&dataMask);
 687
 688
 689         BitmapData imageData ;
 690         image->LockBits(&bounds,ImageLockModeWrite, PixelFormat32bppPARGB, &imageData);
 691
 692         BYTE maskPattern = 0 ;
 693         BYTE maskByte = 0;
 694         size_t maskIndex ;
 695
 696         for ( size_t y = 0 ; y < height ; ++y)
 697         {
 698             maskIndex = 0 ;
 699             for( size_t x = 0 ; x < width; ++x)
 700             {
 701                 if ( x % 8 == 0)
 702                 {
 703                     maskPattern = 0x80;
 704                     maskByte = *((BYTE*)dataMask.Scan0 + dataMask.Stride*y + maskIndex);
 705                     maskIndex++;
 706                 }
 707                 else
 708                     maskPattern = maskPattern >> 1;
 709
 710                 ARGB *dest = (ARGB*)((BYTE*)imageData.Scan0 + imageData.Stride*y + x*4);
 711                 if ( (maskByte & maskPattern) == 0 )
 712                     *dest = 0x00000000;
 713                 else
 714                 {
 715                     Color c ;
 716                     interim.GetPixel(x,y,&c) ;
 717                     *dest = (c.GetValue() | Color::AlphaMask);
 718                 }
 719             }
 720         }
 721
 722         image->UnlockBits(&imageData);
 723
 724         interimMask.UnlockBits(&dataMask);
 725         interim.UnlockBits(&dataMask);
 726     }
 727     else
 728     {
 729         image = Bitmap::FromHBITMAP((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE());
 730         if ( bmp.HasAlpha() && GetPixelFormatSize(image->GetPixelFormat()) == 32 )
 731         {
 732             size_t width = image->GetWidth();
 733             size_t height = image->GetHeight();
 734             Rect bounds(0,0,width,height);
 735             static BitmapData data ;
 736
 737             m_helper = image ;
 738             image = NULL ;
 739             m_helper->LockBits(&bounds, ImageLockModeRead,
 740                 m_helper->GetPixelFormat(),&data);
 741
 742             image = new Bitmap(data.Width, data.Height, data.Stride,
 743                 PixelFormat32bppPARGB , (BYTE*) data.Scan0);
 744
 745             m_helper->UnlockBits(&data);
 746         }
 747     }
 748     if ( image )
 749         m_bitmap = image;
 750 }
 751
 752 wxGDIPlusBitmapData::~wxGDIPlusBitmapData()
 753 {
 754     delete m_bitmap;
 755     delete m_helper;
 756 }
 757
 758 //-----------------------------------------------------------------------------
 759 // wxGDIPlusPath implementation
 760 //-----------------------------------------------------------------------------
 761
 762 wxGDIPlusPathData::wxGDIPlusPathData(wxGraphicsRenderer* renderer, GraphicsPath* path ) : wxGraphicsPathData(renderer)
 763 {
 764     if ( path )
 765         m_path = path;
 766     else
 767         m_path = new GraphicsPath();
 768 }
 769
 770 wxGDIPlusPathData::~wxGDIPlusPathData()
 771 {
 772     delete m_path;
 773 }
 774
 775 wxGraphicsObjectRefData* wxGDIPlusPathData::Clone() const
 776 {
 777     return new wxGDIPlusPathData( GetRenderer() , m_path->Clone());
 778 }
 779
 780 //
 781 // The Primitives
 782 //
 783
 784 void wxGDIPlusPathData::MoveToPoint( wxDouble x , wxDouble y )
 785 {
 786     m_path->StartFigure();
 787     m_path->AddLine((REAL) x,(REAL) y,(REAL) x,(REAL) y);
 788 }
 789
 790 void wxGDIPlusPathData::AddLineToPoint( wxDouble x , wxDouble y )
 791 {
 792     m_path->AddLine((REAL) x,(REAL) y,(REAL) x,(REAL) y);
 793 }
 794
 795 void wxGDIPlusPathData::CloseSubpath()
 796 {
 797     m_path->CloseFigure();
 798 }
 799
 800 void wxGDIPlusPathData::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
 801 {
 802     PointF c1(cx1,cy1);
 803     PointF c2(cx2,cy2);
 804     PointF end(x,y);
 805     PointF start;
 806     m_path->GetLastPoint(&start);
 807     m_path->AddBezier(start,c1,c2,end);
 808 }
 809
 810 // gets the last point of the current path, (0,0) if not yet set
 811 void wxGDIPlusPathData::GetCurrentPoint( wxDouble* x, wxDouble* y) const
 812 {
 813     PointF start;
 814     m_path->GetLastPoint(&start);
 815     *x = start.X ;
 816     *y = start.Y ;
 817 }
 818
 819 void wxGDIPlusPathData::AddArc( wxDouble x, wxDouble y, wxDouble r, double startAngle, double endAngle, bool clockwise )
 820 {
 821     double sweepAngle = endAngle - startAngle ;
 822     if( fabs(sweepAngle) >= 2*M_PI)
 823     {
 824         sweepAngle = 2 * M_PI;
 825     }
 826     else
 827     {
 828         if ( clockwise )
 829         {
 830             if( sweepAngle < 0 )
 831                 sweepAngle += 2 * M_PI;
 832         }
 833         else
 834         {
 835             if( sweepAngle > 0 )
 836                 sweepAngle -= 2 * M_PI;
 837
 838         }
 839    }
 840    m_path->AddArc((REAL) (x-r),(REAL) (y-r),(REAL) (2*r),(REAL) (2*r),RadToDeg(startAngle),RadToDeg(sweepAngle));
 841 }
 842
 843 void wxGDIPlusPathData::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 844 {
 845     m_path->AddRectangle(RectF(x,y,w,h));
 846 }
 847
 848 void wxGDIPlusPathData::AddPath( const wxGraphicsPathData* path )
 849 {
 850     m_path->AddPath( (GraphicsPath*) path->GetNativePath(), FALSE);
 851 }
 852
 853
 854 // transforms each point of this path by the matrix
 855 void wxGDIPlusPathData::Transform( const wxGraphicsMatrixData* matrix )
 856 {
 857     m_path->Transform( (Matrix*) matrix->GetNativeMatrix() );
 858 }
 859
 860 // gets the bounding box enclosing all points (possibly including control points)
 861 void wxGDIPlusPathData::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
 862 {
 863     RectF bounds;
 864     m_path->GetBounds( &bounds, NULL, NULL) ;
 865     *x = bounds.X;
 866     *y = bounds.Y;
 867     *w = bounds.Width;
 868     *h = bounds.Height;
 869 }
 870
 871 bool wxGDIPlusPathData::Contains( wxDouble x, wxDouble y, int fillStyle ) const
 872 {
 873     m_path->SetFillMode( fillStyle == wxODDEVEN_RULE ? FillModeAlternate : FillModeWinding);
 874     return m_path->IsVisible( (FLOAT) x,(FLOAT) y) == TRUE ;
 875 }
 876
 877 //-----------------------------------------------------------------------------
 878 // wxGDIPlusMatrixData implementation
 879 //-----------------------------------------------------------------------------
 880
 881 wxGDIPlusMatrixData::wxGDIPlusMatrixData(wxGraphicsRenderer* renderer, Matrix* matrix )
 882     : wxGraphicsMatrixData(renderer)
 883 {
 884     if ( matrix )
 885         m_matrix = matrix ;
 886     else
 887         m_matrix = new Matrix();
 888 }
 889
 890 wxGDIPlusMatrixData::~wxGDIPlusMatrixData()
 891 {
 892     delete m_matrix;
 893 }
 894
 895 wxGraphicsObjectRefData *wxGDIPlusMatrixData::Clone() const
 896 {
 897     return new wxGDIPlusMatrixData( GetRenderer(), m_matrix->Clone());
 898 }
 899
 900 // concatenates the matrix
 901 void wxGDIPlusMatrixData::Concat( const wxGraphicsMatrixData *t )
 902 {
 903     m_matrix->Multiply( (Matrix*) t->GetNativeMatrix());
 904 }
 905
 906 // sets the matrix to the respective values
 907 void wxGDIPlusMatrixData::Set(wxDouble a, wxDouble b, wxDouble c, wxDouble d,
 908                  wxDouble tx, wxDouble ty)
 909 {
 910     m_matrix->SetElements(a,b,c,d,tx,ty);
 911 }
 912
 913 // gets the component valuess of the matrix
 914 void wxGDIPlusMatrixData::Get(wxDouble* a, wxDouble* b,  wxDouble* c,
 915                               wxDouble* d, wxDouble* tx, wxDouble* ty) const
 916 {
 917     REAL elements[6];
 918     m_matrix->GetElements(elements);
 919     if (a)  *a = elements[0];
 920     if (b)  *b = elements[1];
 921     if (c)  *c = elements[2];
 922     if (d)  *d = elements[3];
 923     if (tx) *tx= elements[4];
 924     if (ty) *ty= elements[5];
 925 }
 926
 927 // makes this the inverse matrix
 928 void wxGDIPlusMatrixData::Invert()
 929 {
 930     m_matrix->Invert();
 931 }
 932
 933 // returns true if the elements of the transformation matrix are equal ?
 934 bool wxGDIPlusMatrixData::IsEqual( const wxGraphicsMatrixData* t) const
 935 {
 936     return m_matrix->Equals((Matrix*) t->GetNativeMatrix())== TRUE ;
 937 }
 938
 939 // return true if this is the identity matrix
 940 bool wxGDIPlusMatrixData::IsIdentity() const
 941 {
 942     return m_matrix->IsIdentity() == TRUE ;
 943 }
 944
 945 //
 946 // transformation
 947 //
 948
 949 // add the translation to this matrix
 950 void wxGDIPlusMatrixData::Translate( wxDouble dx , wxDouble dy )
 951 {
 952     m_matrix->Translate(dx,dy);
 953 }
 954
 955 // add the scale to this matrix
 956 void wxGDIPlusMatrixData::Scale( wxDouble xScale , wxDouble yScale )
 957 {
 958     m_matrix->Scale(xScale,yScale);
 959 }
 960
 961 // add the rotation to this matrix (radians)
 962 void wxGDIPlusMatrixData::Rotate( wxDouble angle )
 963 {
 964     m_matrix->Rotate( angle );
 965 }
 966
 967 //
 968 // apply the transforms
 969 //
 970
 971 // applies that matrix to the point
 972 void wxGDIPlusMatrixData::TransformPoint( wxDouble *x, wxDouble *y ) const
 973 {
 974     PointF pt(*x,*y);
 975     m_matrix->TransformPoints(&pt);
 976     *x = pt.X;
 977     *y = pt.Y;
 978 }
 979
 980 // applies the matrix except for translations
 981 void wxGDIPlusMatrixData::TransformDistance( wxDouble *dx, wxDouble *dy ) const
 982 {
 983     PointF pt(*dx,*dy);
 984     m_matrix->TransformVectors(&pt);
 985     *dx = pt.X;
 986     *dy = pt.Y;
 987 }
 988
 989 // returns the native representation
 990 void * wxGDIPlusMatrixData::GetNativeMatrix() const
 991 {
 992     return m_matrix;
 993 }
 994
 995 //-----------------------------------------------------------------------------
 996 // wxGDIPlusContext implementation
 997 //-----------------------------------------------------------------------------
 998
 999 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusContext,wxGraphicsContext)
1000 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusMeasuringContext,wxGDIPlusContext)
1001
1002 class wxGDIPlusOffsetHelper
1003 {
1004 public :
1005     wxGDIPlusOffsetHelper( Graphics* gr , bool offset )
1006     {
1007         m_gr = gr;
1008         m_offset = offset;
1009         if ( m_offset )
1010             m_gr->TranslateTransform( 0.5, 0.5 );
1011     }
1012     ~wxGDIPlusOffsetHelper( )
1013     {
1014         if ( m_offset )
1015             m_gr->TranslateTransform( -0.5, -0.5 );
1016     }
1017 public :
1018     Graphics* m_gr;
1019     bool m_offset;
1020 } ;
1021
1022 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc  )
1023     : wxGraphicsContext(renderer)
1024 {
1025     Init();
1026     m_context = new Graphics( hdc);
1027     SetDefaults();
1028 }
1029
1030 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd  )
1031     : wxGraphicsContext(renderer)
1032 {
1033     Init();
1034     m_context = new Graphics( hwnd);
1035     SetDefaults();
1036 }
1037
1038 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr  )
1039     : wxGraphicsContext(renderer)
1040 {
1041     Init();
1042     m_context = gr;
1043     SetDefaults();
1044 }
1045
1046 wxGDIPlusContext::wxGDIPlusContext() : wxGraphicsContext(NULL)
1047 {
1048     Init();
1049 }
1050
1051 void wxGDIPlusContext::Init()
1052 {
1053     m_context = NULL;
1054     m_state1 = 0;
1055     m_state2= 0;
1056 }
1057
1058 void wxGDIPlusContext::SetDefaults()
1059 {
1060     m_context->SetTextRenderingHint(TextRenderingHintSystemDefault);
1061     m_context->SetPixelOffsetMode(PixelOffsetModeHalf);
1062     m_context->SetSmoothingMode(SmoothingModeHighQuality);
1063     m_state1 = m_context->Save();
1064     m_state2 = m_context->Save();
1065 }
1066
1067 wxGDIPlusContext::~wxGDIPlusContext()
1068 {
1069     if ( m_context )
1070     {
1071         m_context->Restore( m_state2 );
1072         m_context->Restore( m_state1 );
1073         delete m_context;
1074     }
1075 }
1076
1077
1078 void wxGDIPlusContext::Clip( const wxRegion &region )
1079 {
1080     Region rgn((HRGN)region.GetHRGN());
1081     m_context->SetClip(&rgn,CombineModeIntersect);
1082 }
1083
1084 void wxGDIPlusContext::Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1085 {
1086     m_context->SetClip(RectF(x,y,w,h),CombineModeIntersect);
1087 }
1088
1089 void wxGDIPlusContext::ResetClip()
1090 {
1091     m_context->ResetClip();
1092 }
1093
1094 void wxGDIPlusContext::StrokeLines( size_t n, const wxPoint2DDouble *points)
1095 {
1096         if ( !m_pen.IsNull() )
1097         {
1098         wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
1099                 Point *cpoints = new Point[n];
1100                 for (size_t i = 0; i < n; i++)
1101                 {
1102                         cpoints[i].X = (int)(points[i].m_x );
1103                         cpoints[i].Y = (int)(points[i].m_y );
1104
1105                 } // for (size_t i = 0; i < n; i++)
1106                 m_context->DrawLines( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , cpoints , n ) ;
1107                 delete[] cpoints;
1108         }
1109 }
1110
1111 void wxGDIPlusContext::DrawLines( size_t n, const wxPoint2DDouble *points, int WXUNUSED(fillStyle) )
1112 {
1113     wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
1114         Point *cpoints = new Point[n];
1115         for (size_t i = 0; i < n; i++)
1116         {
1117                 cpoints[i].X = (int)(points[i].m_x );
1118                 cpoints[i].Y = (int)(points[i].m_y );
1119
1120         } // for (int i = 0; i < n; i++)
1121         if ( !m_brush.IsNull() )
1122                 m_context->FillPolygon( ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush() , cpoints , n ) ;
1123         if ( !m_pen.IsNull() )
1124                 m_context->DrawLines( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , cpoints , n ) ;
1125         delete[] cpoints;
1126 }
1127
1128 void wxGDIPlusContext::StrokePath( const wxGraphicsPath& path )
1129 {
1130     if ( !m_pen.IsNull() )
1131     {
1132         wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
1133         m_context->DrawPath( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , (GraphicsPath*) path.GetNativePath() );
1134     }
1135 }
1136
1137 void wxGDIPlusContext::FillPath( const wxGraphicsPath& path , int fillStyle )
1138 {
1139     if ( !m_brush.IsNull() )
1140     {
1141         wxGDIPlusOffsetHelper helper( m_context , ShouldOffset() );
1142         ((GraphicsPath*) path.GetNativePath())->SetFillMode( fillStyle == wxODDEVEN_RULE ? FillModeAlternate : FillModeWinding);
1143         m_context->FillPath( ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush() ,
1144             (GraphicsPath*) path.GetNativePath());
1145     }
1146 }
1147
1148 void wxGDIPlusContext::Rotate( wxDouble angle )
1149 {
1150     m_context->RotateTransform( RadToDeg(angle) );
1151 }
1152
1153 void wxGDIPlusContext::Translate( wxDouble dx , wxDouble dy )
1154 {
1155     m_context->TranslateTransform( dx , dy );
1156 }
1157
1158 void wxGDIPlusContext::Scale( wxDouble xScale , wxDouble yScale )
1159 {
1160     m_context->ScaleTransform(xScale,yScale);
1161 }
1162
1163 void wxGDIPlusContext::PushState()
1164 {
1165     GraphicsState state = m_context->Save();
1166     m_stateStack.push(state);
1167 }
1168
1169 void wxGDIPlusContext::PopState()
1170 {
1171     GraphicsState state = m_stateStack.top();
1172     m_stateStack.pop();
1173     m_context->Restore(state);
1174 }
1175
1176 void wxGDIPlusContext::DrawBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1177 {
1178     Bitmap* image = static_cast<wxGDIPlusBitmapData*>(bmp.GetRefData())->GetGDIPlusBitmap();
1179     if ( image )
1180     {
1181         if( image->GetWidth() != (UINT) w || image->GetHeight() != (UINT) h )
1182         {
1183             Rect drawRect((REAL) x, (REAL)y, (REAL)w, (REAL)h);
1184             m_context->SetPixelOffsetMode( PixelOffsetModeNone );
1185             m_context->DrawImage(image, drawRect, 0 , 0 , image->GetWidth()-1, image->GetHeight()-1, UnitPixel ) ;
1186             m_context->SetPixelOffsetMode( PixelOffsetModeHalf );
1187         }
1188         else
1189             m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
1190     }
1191 }
1192
1193 void wxGDIPlusContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1194 {
1195     wxGraphicsBitmap bitmap = GetRenderer()->CreateBitmap(bmp);
1196     DrawBitmap(bitmap, x, y, w, h);
1197 }
1198
1199 void wxGDIPlusContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1200 {
1201     // the built-in conversion fails when there is alpha in the HICON (eg XP style icons), we can only
1202     // find out by looking at the bitmap data whether there really was alpha in it
1203     HICON hIcon = (HICON)icon.GetHICON();
1204     ICONINFO iconInfo ;
1205     // IconInfo creates the bitmaps for color and mask, we must dispose of them after use
1206     if (!GetIconInfo(hIcon,&iconInfo))
1207         return;
1208
1209     Bitmap interim(iconInfo.hbmColor,NULL);
1210
1211     Bitmap* image = NULL ;
1212
1213     // if it's not 32 bit, it doesn't have an alpha channel, note that since the conversion doesn't
1214     // work correctly, asking IsAlphaPixelFormat at this point fails as well
1215     if( GetPixelFormatSize(interim.GetPixelFormat())!= 32 )
1216     {
1217         image = Bitmap::FromHICON(hIcon);
1218     }
1219     else
1220     {
1221         size_t width = interim.GetWidth();
1222         size_t height = interim.GetHeight();
1223         Rect bounds(0,0,width,height);
1224         BitmapData data ;
1225
1226         interim.LockBits(&bounds, ImageLockModeRead,
1227             interim.GetPixelFormat(),&data);
1228
1229         bool hasAlpha = false;
1230         for ( size_t y = 0 ; y < height && !hasAlpha ; ++y)
1231         {
1232             for( size_t x = 0 ; x < width && !hasAlpha; ++x)
1233             {
1234                 ARGB *dest = (ARGB*)((BYTE*)data.Scan0 + data.Stride*y + x*4);
1235                 if ( ( *dest & Color::AlphaMask ) != 0 )
1236                     hasAlpha = true;
1237             }
1238         }
1239
1240         if ( hasAlpha )
1241         {
1242         image = new Bitmap(data.Width, data.Height, data.Stride,
1243             PixelFormat32bppARGB , (BYTE*) data.Scan0);
1244         }
1245         else
1246         {
1247             image = Bitmap::FromHICON(hIcon);
1248         }
1249
1250         interim.UnlockBits(&data);
1251     }
1252
1253     m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
1254
1255     delete image ;
1256     DeleteObject(iconInfo.hbmColor);
1257     DeleteObject(iconInfo.hbmMask);
1258 }
1259
1260 void wxGDIPlusContext::DrawText( const wxString &str, wxDouble x, wxDouble y )
1261 {
1262     if ( m_font.IsNull() || str.IsEmpty())
1263         return ;
1264
1265     wxWCharBuffer s = str.wc_str( *wxConvUI );
1266     m_context->DrawString( s , -1 , ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont() ,
1267             PointF( x , y ) , StringFormat::GenericTypographic() , ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusBrush() );
1268 }
1269
1270 void wxGDIPlusContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
1271                                      wxDouble *descent, wxDouble *externalLeading ) const
1272 {
1273     wxWCharBuffer s = str.wc_str( *wxConvUI );
1274     FontFamily ffamily ;
1275     Font* f = ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont();
1276
1277     f->GetFamily(&ffamily) ;
1278
1279     REAL factorY = m_context->GetDpiY() / 72.0 ;
1280
1281     REAL rDescent = ffamily.GetCellDescent(FontStyleRegular) *
1282         f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
1283     REAL rAscent = ffamily.GetCellAscent(FontStyleRegular) *
1284         f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
1285     REAL rHeight = ffamily.GetLineSpacing(FontStyleRegular) *
1286         f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
1287
1288     if ( height )
1289         *height = rHeight * factorY;
1290     if ( descent )
1291         *descent = rDescent * factorY;
1292     if ( externalLeading )
1293         *externalLeading = (rHeight - rAscent - rDescent) * factorY;
1294     // measuring empty strings is not guaranteed, so do it by hand
1295     if ( str.IsEmpty())
1296     {
1297         if ( width )
1298             *width = 0 ;
1299     }
1300     else
1301     {
1302         RectF layoutRect(0,0, 100000.0f, 100000.0f);
1303         StringFormat strFormat( StringFormat::GenericTypographic() );
1304         strFormat.SetFormatFlags( StringFormatFlagsMeasureTrailingSpaces | strFormat.GetFormatFlags() );
1305
1306         RectF bounds ;
1307         m_context->MeasureString((const wchar_t *) s , wcslen(s) , f, layoutRect, &strFormat, &bounds ) ;
1308         if ( width )
1309             *width = bounds.Width;
1310     }
1311 }
1312
1313 void wxGDIPlusContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
1314 {
1315     widths.Empty();
1316     widths.Add(0, text.length());
1317
1318     if (text.empty())
1319         return;
1320
1321     Font* f = ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont();
1322     wxWCharBuffer ws = text.wc_str( *wxConvUI );
1323     size_t len = wcslen( ws ) ;
1324     wxASSERT_MSG(text.length() == len , wxT("GetPartialTextExtents not yet implemented for multichar situations"));
1325
1326     RectF layoutRect(0,0, 100000.0f, 100000.0f);
1327     StringFormat strFormat( StringFormat::GenericTypographic() );
1328
1329     CharacterRange* ranges = new CharacterRange[len] ;
1330     Region* regions = new Region[len];
1331     for( size_t i = 0 ; i < len ; ++i)
1332     {
1333         ranges[i].First = i ;
1334         ranges[i].Length = 1 ;
1335     }
1336     strFormat.SetMeasurableCharacterRanges(len,ranges);
1337     strFormat.SetFormatFlags( StringFormatFlagsMeasureTrailingSpaces | strFormat.GetFormatFlags() );
1338     m_context->MeasureCharacterRanges(ws, -1 , f,layoutRect, &strFormat,1,regions) ;
1339
1340     RectF bbox ;
1341     for ( size_t i = 0 ; i < len ; ++i)
1342     {
1343         regions[i].GetBounds(&bbox,m_context);
1344         widths[i] = bbox.GetRight()-bbox.GetLeft();
1345     }
1346 }
1347
1348 bool wxGDIPlusContext::ShouldOffset() const
1349 {
1350     int penwidth = 0 ;
1351     if ( !m_pen.IsNull() )
1352     {
1353         penwidth = (int)((wxGDIPlusPenData*)m_pen.GetRefData())->GetWidth();
1354         if ( penwidth == 0 )
1355             penwidth = 1;
1356     }
1357     return ( penwidth % 2 ) == 1;
1358 }
1359
1360 void* wxGDIPlusContext::GetNativeContext()
1361 {
1362     return m_context;
1363 }
1364
1365 // concatenates this transform with the current transform of this context
1366 void wxGDIPlusContext::ConcatTransform( const wxGraphicsMatrix& matrix )
1367 {
1368     m_context->MultiplyTransform((Matrix*) matrix.GetNativeMatrix());
1369 }
1370
1371 // sets the transform of this context
1372 void wxGDIPlusContext::SetTransform( const wxGraphicsMatrix& matrix )
1373 {
1374     m_context->SetTransform((Matrix*) matrix.GetNativeMatrix());
1375 }
1376
1377 // gets the matrix of this context
1378 wxGraphicsMatrix wxGDIPlusContext::GetTransform() const
1379 {
1380     wxGraphicsMatrix matrix = CreateMatrix();
1381     m_context->GetTransform((Matrix*) matrix.GetNativeMatrix());
1382     return matrix;
1383 }
1384 //-----------------------------------------------------------------------------
1385 // wxGDIPlusRenderer declaration
1386 //-----------------------------------------------------------------------------
1387
1388 class wxGDIPlusRenderer : public wxGraphicsRenderer
1389 {
1390 public :
1391     wxGDIPlusRenderer()
1392     {
1393         m_loaded = false;
1394         m_gditoken = 0;
1395     }
1396
1397     virtual ~wxGDIPlusRenderer()
1398     {
1399         if (m_loaded)
1400         {
1401             Unload();
1402         }
1403     }
1404
1405     // Context
1406
1407     virtual wxGraphicsContext * CreateContext( const wxWindowDC& dc);
1408
1409     virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc);
1410
1411     virtual wxGraphicsContext * CreateContext( const wxPrinterDC& dc);
1412
1413     virtual wxGraphicsContext * CreateContextFromNativeContext( void * context );
1414
1415     virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window );
1416
1417     virtual wxGraphicsContext * CreateContext( wxWindow* window );
1418
1419     virtual wxGraphicsContext * CreateMeasuringContext();
1420
1421     // Path
1422
1423     virtual wxGraphicsPath CreatePath();
1424
1425     // Matrix
1426
1427     virtual wxGraphicsMatrix CreateMatrix( wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
1428         wxDouble tx=0.0, wxDouble ty=0.0);
1429
1430
1431     virtual wxGraphicsPen CreatePen(const wxPen& pen) ;
1432
1433     virtual wxGraphicsBrush CreateBrush(const wxBrush& brush ) ;
1434
1435     // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
1436     virtual wxGraphicsBrush CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
1437         const wxColour&c1, const wxColour&c2) ;
1438
1439     // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
1440     // with radius r and color cColor
1441     virtual wxGraphicsBrush CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
1442         const wxColour &oColor, const wxColour &cColor) ;
1443
1444     // sets the font
1445     virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ;
1446
1447     // create a native bitmap representation
1448     virtual wxGraphicsBitmap CreateBitmap( const wxBitmap &bitmap );
1449
1450     // create a subimage from a native image representation
1451     virtual wxGraphicsBitmap CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h  );
1452
1453 protected :
1454     void EnsureIsLoaded();
1455     void Load();
1456     void Unload();
1457     friend class wxGDIPlusRendererModule;
1458
1459 private :
1460     bool m_loaded;
1461     ULONG_PTR m_gditoken;
1462
1463     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusRenderer)
1464 } ;
1465
1466 //-----------------------------------------------------------------------------
1467 // wxGDIPlusRenderer implementation
1468 //-----------------------------------------------------------------------------
1469
1470 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusRenderer,wxGraphicsRenderer)
1471
1472 static wxGDIPlusRenderer gs_GDIPlusRenderer;
1473
1474 wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer()
1475 {
1476     return &gs_GDIPlusRenderer;
1477 }
1478
1479 void wxGDIPlusRenderer::EnsureIsLoaded()
1480 {
1481     if (!m_loaded)
1482     {
1483         Load();
1484     }
1485 }
1486
1487 void wxGDIPlusRenderer::Load()
1488 {
1489     GdiplusStartupInput input;
1490     GdiplusStartupOutput output;
1491     GdiplusStartup(&m_gditoken,&input,&output);
1492     m_loaded = true;
1493 }
1494
1495 void wxGDIPlusRenderer::Unload()
1496 {
1497     if ( m_gditoken )
1498     {
1499         GdiplusShutdown(m_gditoken);
1500         m_gditoken = NULL;
1501     }
1502     m_loaded = false;
1503 }
1504
1505 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxWindowDC& dc)
1506 {
1507     EnsureIsLoaded();
1508     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
1509     return new wxGDIPlusContext(this,(HDC) msw->GetHDC());
1510 }
1511
1512 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxPrinterDC& dc)
1513 {
1514     EnsureIsLoaded();
1515     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
1516     return new wxGDIPlusContext(this,(HDC) msw->GetHDC());
1517 }
1518
1519 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxMemoryDC& dc)
1520 {
1521     EnsureIsLoaded();
1522     wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
1523     return new wxGDIPlusContext(this,(HDC) msw->GetHDC());
1524 }
1525
1526 wxGraphicsContext * wxGDIPlusRenderer::CreateMeasuringContext()
1527 {
1528     EnsureIsLoaded();
1529     return new wxGDIPlusMeasuringContext(this);
1530 }
1531
1532 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeContext( void * context )
1533 {
1534     EnsureIsLoaded();
1535     return new wxGDIPlusContext(this,(Graphics*) context);
1536 }
1537
1538
1539 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeWindow( void * window )
1540 {
1541     EnsureIsLoaded();
1542     return new wxGDIPlusContext(this,(HWND) window);
1543 }
1544
1545 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( wxWindow* window )
1546 {
1547     EnsureIsLoaded();
1548     return new wxGDIPlusContext(this, (HWND) window->GetHWND() );
1549 }
1550
1551 // Path
1552
1553 wxGraphicsPath wxGDIPlusRenderer::CreatePath()
1554 {
1555     EnsureIsLoaded();
1556     wxGraphicsPath m;
1557     m.SetRefData( new wxGDIPlusPathData(this));
1558     return m;
1559 }
1560
1561
1562 // Matrix
1563
1564 wxGraphicsMatrix wxGDIPlusRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
1565                                                            wxDouble tx, wxDouble ty)
1566
1567 {
1568     EnsureIsLoaded();
1569     wxGraphicsMatrix m;
1570     wxGDIPlusMatrixData* data = new wxGDIPlusMatrixData( this );
1571     data->Set( a,b,c,d,tx,ty ) ;
1572     m.SetRefData(data);
1573     return m;
1574 }
1575
1576 wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
1577 {
1578     EnsureIsLoaded();
1579     if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
1580         return wxNullGraphicsPen;
1581     else
1582     {
1583         wxGraphicsPen p;
1584         p.SetRefData(new wxGDIPlusPenData( this, pen ));
1585         return p;
1586     }
1587 }
1588
1589 wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush )
1590 {
1591     EnsureIsLoaded();
1592     if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
1593         return wxNullGraphicsBrush;
1594     else
1595     {
1596         wxGraphicsBrush p;
1597         p.SetRefData(new wxGDIPlusBrushData( this, brush ));
1598         return p;
1599     }
1600 }
1601
1602 // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
1603 wxGraphicsBrush wxGDIPlusRenderer::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
1604                                                                       const wxColour&c1, const wxColour&c2)
1605 {
1606     EnsureIsLoaded();
1607     wxGraphicsBrush p;
1608     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
1609     d->CreateLinearGradientBrush(x1, y1, x2, y2, c1, c2);
1610     p.SetRefData(d);
1611     return p;
1612  }
1613
1614 // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
1615 // with radius r and color cColor
1616 wxGraphicsBrush wxGDIPlusRenderer::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
1617                                                                       const wxColour &oColor, const wxColour &cColor)
1618 {
1619     EnsureIsLoaded();
1620     wxGraphicsBrush p;
1621     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
1622     d->CreateRadialGradientBrush(xo,yo,xc,yc,radius,oColor,cColor);
1623     p.SetRefData(d);
1624     return p;
1625 }
1626
1627 // sets the font
1628 wxGraphicsFont wxGDIPlusRenderer::CreateFont( const wxFont &font , const wxColour &col )
1629 {
1630     EnsureIsLoaded();
1631     if ( font.Ok() )
1632     {
1633         wxGraphicsFont p;
1634         p.SetRefData(new wxGDIPlusFontData( this , font, col ));
1635         return p;
1636     }
1637     else
1638         return wxNullGraphicsFont;
1639 }
1640
1641 wxGraphicsBitmap wxGDIPlusRenderer::CreateBitmap( const wxBitmap &bitmap )
1642 {
1643     EnsureIsLoaded();
1644     if ( bitmap.Ok() )
1645     {
1646         wxGraphicsBitmap p;
1647         p.SetRefData(new wxGDIPlusBitmapData( this , bitmap ));
1648         return p;
1649     }
1650     else
1651         return wxNullGraphicsBitmap;
1652 }
1653
1654 wxGraphicsBitmap wxGDIPlusRenderer::CreateSubBitmap( const wxGraphicsBitmap &bitmap, wxDouble x, wxDouble y, wxDouble w, wxDouble h  )
1655 {
1656     EnsureIsLoaded();
1657     Bitmap* image = static_cast<wxGDIPlusBitmapData*>(bitmap.GetRefData())->GetGDIPlusBitmap();
1658     if ( image )
1659     {
1660         wxGraphicsBitmap p;
1661         p.SetRefData(new wxGDIPlusBitmapData( this , image->Clone( (REAL) x , (REAL) y , (REAL) w , (REAL) h , PixelFormat32bppPARGB) ));
1662         return p;
1663     }
1664     else
1665         return wxNullGraphicsBitmap;
1666 }
1667
1668 // Shutdown GDI+ at app exit, before possible dll unload
1669 class wxGDIPlusRendererModule : public wxModule
1670 {
1671 public:
1672     virtual bool OnInit() { return true; }
1673     virtual void OnExit() { gs_GDIPlusRenderer.Unload(); }
1674
1675 private:
1676     DECLARE_DYNAMIC_CLASS(wxGDIPlusRendererModule)
1677 };
1678
1679 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusRendererModule, wxModule)
1680
1681 #endif  // wxUSE_GRAPHICS_CONTEXT