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