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/graphics.h"
  39
  40 #include <vector>
  41
  42 using namespace std;
  43
  44 #include "wx/msw/wrapgdip.h"
  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 WXDLLIMPEXP_CORE 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 WXDLLIMPEXP_CORE 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 WXDLLIMPEXP_CORE 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 WXDLLIMPEXP_CORE 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 wxGDIPlusFontData : public wxGraphicsObjectRefData
 251 {
 252 public:
 253     wxGDIPlusFontData( wxGraphicsRenderer* renderer, const wxFont &font, const wxColour& col );
 254     ~wxGDIPlusFontData();
 255
 256     virtual Brush* GetGDIPlusBrush() { return m_textBrush; }
 257     virtual Font* GetGDIPlusFont() { return m_font; }
 258 private :
 259     Brush* m_textBrush;
 260     Font* m_font;
 261 };
 262
 263 class WXDLLIMPEXP_CORE wxGDIPlusContext : public wxGraphicsContext
 264 {
 265 public:
 266     wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc );
 267     wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd );
 268     wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr);
 269     wxGDIPlusContext();
 270
 271     virtual ~wxGDIPlusContext();
 272
 273     virtual void Clip( const wxRegion &region );
 274     // clips drawings to the rect
 275     virtual void Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 276
 277     // resets the clipping to original extent
 278     virtual void ResetClip();
 279
 280     virtual void * GetNativeContext();
 281
 282     virtual void StrokePath( const wxGraphicsPath& p );
 283     virtual void FillPath( const wxGraphicsPath& p , int fillStyle = wxODDEVEN_RULE );
 284
 285     virtual void Translate( wxDouble dx , wxDouble dy );
 286     virtual void Scale( wxDouble xScale , wxDouble yScale );
 287     virtual void Rotate( wxDouble angle );
 288
 289     // concatenates this transform with the current transform of this context
 290     virtual void ConcatTransform( const wxGraphicsMatrix& matrix );
 291
 292     // sets the transform of this context
 293     virtual void SetTransform( const wxGraphicsMatrix& matrix );
 294
 295     // gets the matrix of this context
 296     virtual wxGraphicsMatrix GetTransform() const;
 297
 298     virtual void DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 299     virtual void DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h );
 300     virtual void PushState();
 301     virtual void PopState();
 302
 303     virtual void DrawText( const wxString &str, wxDouble x, wxDouble y);
 304     virtual void GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
 305         wxDouble *descent, wxDouble *externalLeading ) const;
 306     virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
 307
 308 private:
 309     void    Init();
 310     void    SetDefaults();
 311
 312     Graphics* m_context;
 313     vector<GraphicsState> m_stateStack;
 314     GraphicsState m_state1;
 315     GraphicsState m_state2;
 316
 317     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusContext)
 318 };
 319
 320 //-----------------------------------------------------------------------------
 321 // wxGDIPlusPen implementation
 322 //-----------------------------------------------------------------------------
 323
 324 wxGDIPlusPenData::~wxGDIPlusPenData()
 325 {
 326     delete m_pen;
 327     delete m_penImage;
 328     delete m_penBrush;
 329 }
 330
 331 void wxGDIPlusPenData::Init()
 332 {
 333     m_pen = NULL ;
 334     m_penImage = NULL;
 335     m_penBrush = NULL;
 336 }
 337
 338 wxGDIPlusPenData::wxGDIPlusPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
 339 : wxGraphicsObjectRefData(renderer)
 340 {
 341     Init();
 342     m_width = pen.GetWidth();
 343     if (m_width <= 0.0)
 344         m_width = 0.1;
 345
 346     m_pen = new Pen(Color( pen.GetColour().Alpha() , pen.GetColour().Red() ,
 347         pen.GetColour().Green() , pen.GetColour().Blue() ), m_width );
 348
 349     LineCap cap;
 350     switch ( pen.GetCap() )
 351     {
 352     case wxCAP_ROUND :
 353         cap = LineCapRound;
 354         break;
 355
 356     case wxCAP_PROJECTING :
 357         cap = LineCapSquare;
 358         break;
 359
 360     case wxCAP_BUTT :
 361         cap = LineCapFlat; // TODO verify
 362         break;
 363
 364     default :
 365         cap = LineCapFlat;
 366         break;
 367     }
 368     m_pen->SetLineCap(cap,cap, DashCapFlat);
 369
 370     LineJoin join;
 371     switch ( pen.GetJoin() )
 372     {
 373     case wxJOIN_BEVEL :
 374         join = LineJoinBevel;
 375         break;
 376
 377     case wxJOIN_MITER :
 378         join = LineJoinMiter;
 379         break;
 380
 381     case wxJOIN_ROUND :
 382         join = LineJoinRound;
 383         break;
 384
 385     default :
 386         join = LineJoinMiter;
 387         break;
 388     }
 389
 390     m_pen->SetLineJoin(join);
 391
 392     m_pen->SetDashStyle(DashStyleSolid);
 393
 394     DashStyle dashStyle = DashStyleSolid;
 395     switch ( pen.GetStyle() )
 396     {
 397     case wxSOLID :
 398         break;
 399
 400     case wxDOT :
 401         dashStyle = DashStyleDot;
 402         break;
 403
 404     case wxLONG_DASH :
 405         dashStyle = DashStyleDash; // TODO verify
 406         break;
 407
 408     case wxSHORT_DASH :
 409         dashStyle = DashStyleDash;
 410         break;
 411
 412     case wxDOT_DASH :
 413         dashStyle = DashStyleDashDot;
 414         break;
 415     case wxUSER_DASH :
 416         {
 417             dashStyle = DashStyleCustom;
 418             wxDash *dashes;
 419             int count = pen.GetDashes( &dashes );
 420             if ((dashes != NULL) && (count > 0))
 421             {
 422                 REAL *userLengths = new REAL[count];
 423                 for ( int i = 0; i < count; ++i )
 424                 {
 425                     userLengths[i] = dashes[i];
 426                 }
 427                 m_pen->SetDashPattern( userLengths, count);
 428                 delete[] userLengths;
 429             }
 430         }
 431         break;
 432     case wxSTIPPLE :
 433         {
 434             wxBitmap* bmp = pen.GetStipple();
 435             if ( bmp && bmp->Ok() )
 436             {
 437                 m_penImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
 438                 m_penBrush = new TextureBrush(m_penImage);
 439                 m_pen->SetBrush( m_penBrush );
 440             }
 441
 442         }
 443         break;
 444     default :
 445         if ( pen.GetStyle() >= wxFIRST_HATCH && pen.GetStyle() <= wxLAST_HATCH )
 446         {
 447             HatchStyle style = HatchStyleHorizontal;
 448             switch( pen.GetStyle() )
 449             {
 450             case wxBDIAGONAL_HATCH :
 451                 style = HatchStyleBackwardDiagonal;
 452                 break ;
 453             case wxCROSSDIAG_HATCH :
 454                 style = HatchStyleDiagonalCross;
 455                 break ;
 456             case wxFDIAGONAL_HATCH :
 457                 style = HatchStyleForwardDiagonal;
 458                 break ;
 459             case wxCROSS_HATCH :
 460                 style = HatchStyleCross;
 461                 break ;
 462             case wxHORIZONTAL_HATCH :
 463                 style = HatchStyleHorizontal;
 464                 break ;
 465             case wxVERTICAL_HATCH :
 466                 style = HatchStyleVertical;
 467                 break ;
 468
 469             }
 470             m_penBrush = new HatchBrush(style,Color( pen.GetColour().Alpha() , pen.GetColour().Red() ,
 471                 pen.GetColour().Green() , pen.GetColour().Blue() ), Color::Transparent );
 472             m_pen->SetBrush( m_penBrush );
 473         }
 474         break;
 475     }
 476     if ( dashStyle != DashStyleSolid )
 477         m_pen->SetDashStyle(dashStyle);
 478 }
 479
 480 //-----------------------------------------------------------------------------
 481 // wxGDIPlusBrush implementation
 482 //-----------------------------------------------------------------------------
 483
 484 wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer* renderer )
 485 : wxGraphicsObjectRefData(renderer)
 486 {
 487     Init();
 488 }
 489
 490 wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer* renderer , const wxBrush &brush )
 491 : wxGraphicsObjectRefData(renderer)
 492 {
 493     Init();
 494     if ( brush.GetStyle() == wxSOLID)
 495     {
 496         m_brush = new SolidBrush( Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
 497             brush.GetColour().Green() , brush.GetColour().Blue() ) );
 498     }
 499     else if ( brush.IsHatch() )
 500     {
 501         HatchStyle style = HatchStyleHorizontal;
 502         switch( brush.GetStyle() )
 503         {
 504         case wxBDIAGONAL_HATCH :
 505             style = HatchStyleBackwardDiagonal;
 506             break ;
 507         case wxCROSSDIAG_HATCH :
 508             style = HatchStyleDiagonalCross;
 509             break ;
 510         case wxFDIAGONAL_HATCH :
 511             style = HatchStyleForwardDiagonal;
 512             break ;
 513         case wxCROSS_HATCH :
 514             style = HatchStyleCross;
 515             break ;
 516         case wxHORIZONTAL_HATCH :
 517             style = HatchStyleHorizontal;
 518             break ;
 519         case wxVERTICAL_HATCH :
 520             style = HatchStyleVertical;
 521             break ;
 522
 523         }
 524         m_brush = new HatchBrush(style,Color( brush.GetColour().Alpha() , brush.GetColour().Red() ,
 525             brush.GetColour().Green() , brush.GetColour().Blue() ), Color::Transparent );
 526     }
 527     else
 528     {
 529         wxBitmap* bmp = brush.GetStipple();
 530         if ( bmp && bmp->Ok() )
 531         {
 532             wxDELETE( m_brushImage );
 533             m_brushImage = Bitmap::FromHBITMAP((HBITMAP)bmp->GetHBITMAP(),(HPALETTE)bmp->GetPalette()->GetHPALETTE());
 534             m_brush = new TextureBrush(m_brushImage);
 535         }
 536     }
 537 }
 538
 539 wxGDIPlusBrushData::~wxGDIPlusBrushData()
 540 {
 541     delete m_brush;
 542     delete m_brushImage;
 543     delete m_brushPath;
 544 };
 545
 546 void wxGDIPlusBrushData::Init()
 547 {
 548     m_brush = NULL;
 549     m_brushImage= NULL;
 550     m_brushPath= NULL;
 551 }
 552
 553 void wxGDIPlusBrushData::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2, const wxColour&c1, const wxColour&c2)
 554 {
 555     m_brush = new LinearGradientBrush( PointF( x1,y1) , PointF( x2,y2),
 556         Color( c1.Alpha(), c1.Red(),c1.Green() , c1.Blue() ),
 557         Color( c2.Alpha(), c2.Red(),c2.Green() , c2.Blue() ));
 558 }
 559
 560 void wxGDIPlusBrushData::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
 561                                                const wxColour &oColor, const wxColour &cColor)
 562 {
 563     // Create a path that consists of a single circle.
 564     m_brushPath = new GraphicsPath();
 565     m_brushPath->AddEllipse( (REAL)(xc-radius), (REAL)(yc-radius), (REAL)(2*radius), (REAL)(2*radius));
 566
 567     PathGradientBrush *b = new PathGradientBrush(m_brushPath);
 568     m_brush = b;
 569     b->SetCenterPoint( PointF(xo,yo));
 570     b->SetCenterColor(Color( oColor.Alpha(), oColor.Red(),oColor.Green() , oColor.Blue() ));
 571
 572     Color colors[] = {Color( cColor.Alpha(), cColor.Red(),cColor.Green() , cColor.Blue() )};
 573     int count = 1;
 574     b->SetSurroundColors(colors, &count);
 575 }
 576
 577 //-----------------------------------------------------------------------------
 578 // wxGDIPlusFont implementation
 579 //-----------------------------------------------------------------------------
 580
 581 wxGDIPlusFontData::wxGDIPlusFontData( wxGraphicsRenderer* renderer, const wxFont &font,
 582                              const wxColour& col ) : wxGraphicsObjectRefData( renderer )
 583 {
 584     m_textBrush = NULL;
 585     m_font = NULL;
 586
 587     wxWCharBuffer s = font.GetFaceName().wc_str( *wxConvUI );
 588     int size = font.GetPointSize();
 589     int style = FontStyleRegular;
 590     if ( font.GetStyle() == wxFONTSTYLE_ITALIC )
 591         style |= FontStyleItalic;
 592     if ( font.GetUnderlined() )
 593         style |= FontStyleUnderline;
 594     if ( font.GetWeight() == wxFONTWEIGHT_BOLD )
 595         style |= FontStyleBold;
 596     m_font = new Font( s , size , style );
 597     m_textBrush = new SolidBrush( Color( col.Alpha() , col.Red() ,
 598         col.Green() , col.Blue() ));
 599 }
 600
 601 wxGDIPlusFontData::~wxGDIPlusFontData()
 602 {
 603     delete m_textBrush;
 604     delete m_font;
 605 }
 606
 607 //-----------------------------------------------------------------------------
 608 // wxGDIPlusPath implementation
 609 //-----------------------------------------------------------------------------
 610
 611 wxGDIPlusPathData::wxGDIPlusPathData(wxGraphicsRenderer* renderer, GraphicsPath* path ) : wxGraphicsPathData(renderer)
 612 {
 613     if ( path )
 614         m_path = path;
 615     else
 616         m_path = new GraphicsPath();
 617 }
 618
 619 wxGDIPlusPathData::~wxGDIPlusPathData()
 620 {
 621     delete m_path;
 622 }
 623
 624 wxGraphicsObjectRefData* wxGDIPlusPathData::Clone() const
 625 {
 626     return new wxGDIPlusPathData( GetRenderer() , m_path->Clone());
 627 }
 628
 629 //
 630 // The Primitives
 631 //
 632
 633 void wxGDIPlusPathData::MoveToPoint( wxDouble x , wxDouble y )
 634 {
 635     m_path->StartFigure();
 636     m_path->AddLine((REAL) x,(REAL) y,(REAL) x,(REAL) y);
 637 }
 638
 639 void wxGDIPlusPathData::AddLineToPoint( wxDouble x , wxDouble y )
 640 {
 641     m_path->AddLine((REAL) x,(REAL) y,(REAL) x,(REAL) y);
 642 }
 643
 644 void wxGDIPlusPathData::CloseSubpath()
 645 {
 646     m_path->CloseFigure();
 647 }
 648
 649 void wxGDIPlusPathData::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
 650 {
 651     PointF c1(cx1,cy1);
 652     PointF c2(cx2,cy2);
 653     PointF end(x,y);
 654     PointF start;
 655     m_path->GetLastPoint(&start);
 656     m_path->AddBezier(start,c1,c2,end);
 657 }
 658
 659 // gets the last point of the current path, (0,0) if not yet set
 660 void wxGDIPlusPathData::GetCurrentPoint( wxDouble* x, wxDouble* y) const
 661 {
 662     PointF start;
 663     m_path->GetLastPoint(&start);
 664     *x = start.X ;
 665     *y = start.Y ;
 666 }
 667
 668 void wxGDIPlusPathData::AddArc( wxDouble x, wxDouble y, wxDouble r, double startAngle, double endAngle, bool clockwise )
 669 {
 670     double sweepAngle = endAngle - startAngle ;
 671     if( abs(sweepAngle) >= 2*M_PI)
 672     {
 673         sweepAngle = 2 * M_PI;
 674     }
 675     else
 676     {
 677         if ( clockwise )
 678         {
 679             if( sweepAngle < 0 )
 680                 sweepAngle += 2 * M_PI;
 681         }
 682         else
 683         {
 684             if( sweepAngle > 0 )
 685                 sweepAngle -= 2 * M_PI;
 686
 687         }
 688    }
 689    m_path->AddArc((REAL) (x-r),(REAL) (y-r),(REAL) (2*r),(REAL) (2*r),RadToDeg(startAngle),RadToDeg(sweepAngle));
 690 }
 691
 692 void wxGDIPlusPathData::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 693 {
 694     m_path->AddRectangle(RectF(x,y,w,h));
 695 }
 696
 697 void wxGDIPlusPathData::AddPath( const wxGraphicsPathData* path )
 698 {
 699     m_path->AddPath( (GraphicsPath*) path->GetNativePath(), FALSE);
 700 }
 701
 702
 703 // transforms each point of this path by the matrix
 704 void wxGDIPlusPathData::Transform( const wxGraphicsMatrixData* matrix )
 705 {
 706     m_path->Transform( (Matrix*) matrix->GetNativeMatrix() );
 707 }
 708
 709 // gets the bounding box enclosing all points (possibly including control points)
 710 void wxGDIPlusPathData::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
 711 {
 712     RectF bounds;
 713     m_path->GetBounds( &bounds, NULL, NULL) ;
 714     *x = bounds.X;
 715     *y = bounds.Y;
 716     *w = bounds.Width;
 717     *h = bounds.Height;
 718 }
 719
 720 bool wxGDIPlusPathData::Contains( wxDouble x, wxDouble y, int fillStyle ) const
 721 {
 722     m_path->SetFillMode( fillStyle == wxODDEVEN_RULE ? FillModeAlternate : FillModeWinding);
 723     return m_path->IsVisible( (FLOAT) x,(FLOAT) y) == TRUE ;
 724 }
 725
 726 //-----------------------------------------------------------------------------
 727 // wxGDIPlusMatrixData implementation
 728 //-----------------------------------------------------------------------------
 729
 730 wxGDIPlusMatrixData::wxGDIPlusMatrixData(wxGraphicsRenderer* renderer, Matrix* matrix )
 731     : wxGraphicsMatrixData(renderer)
 732 {
 733     if ( matrix )
 734         m_matrix = matrix ;
 735     else
 736         m_matrix = new Matrix();
 737 }
 738
 739 wxGDIPlusMatrixData::~wxGDIPlusMatrixData()
 740 {
 741     delete m_matrix;
 742 }
 743
 744 wxGraphicsObjectRefData *wxGDIPlusMatrixData::Clone() const
 745 {
 746     return new wxGDIPlusMatrixData( GetRenderer(), m_matrix->Clone());
 747 }
 748
 749 // concatenates the matrix
 750 void wxGDIPlusMatrixData::Concat( const wxGraphicsMatrixData *t )
 751 {
 752     m_matrix->Multiply( (Matrix*) t->GetNativeMatrix());
 753 }
 754
 755 // sets the matrix to the respective values
 756 void wxGDIPlusMatrixData::Set(wxDouble a, wxDouble b, wxDouble c, wxDouble d,
 757                  wxDouble tx, wxDouble ty)
 758 {
 759     m_matrix->SetElements(a,b,c,d,tx,ty);
 760 }
 761
 762 // gets the component valuess of the matrix
 763 void wxGDIPlusMatrixData::Get(wxDouble* a, wxDouble* b,  wxDouble* c,
 764                               wxDouble* d, wxDouble* tx, wxDouble* ty) const
 765 {
 766     REAL elements[6];
 767     m_matrix->GetElements(elements);
 768     if (a)  *a = elements[0];
 769     if (b)  *b = elements[1];
 770     if (c)  *c = elements[2];
 771     if (d)  *d = elements[3];
 772     if (tx) *tx= elements[4];
 773     if (ty) *ty= elements[5];
 774 }
 775
 776 // makes this the inverse matrix
 777 void wxGDIPlusMatrixData::Invert()
 778 {
 779     m_matrix->Invert();
 780 }
 781
 782 // returns true if the elements of the transformation matrix are equal ?
 783 bool wxGDIPlusMatrixData::IsEqual( const wxGraphicsMatrixData* t) const
 784 {
 785     return m_matrix->Equals((Matrix*) t->GetNativeMatrix())== TRUE ;
 786 }
 787
 788 // return true if this is the identity matrix
 789 bool wxGDIPlusMatrixData::IsIdentity() const
 790 {
 791     return m_matrix->IsIdentity() == TRUE ;
 792 }
 793
 794 //
 795 // transformation
 796 //
 797
 798 // add the translation to this matrix
 799 void wxGDIPlusMatrixData::Translate( wxDouble dx , wxDouble dy )
 800 {
 801     m_matrix->Translate(dx,dy);
 802 }
 803
 804 // add the scale to this matrix
 805 void wxGDIPlusMatrixData::Scale( wxDouble xScale , wxDouble yScale )
 806 {
 807     m_matrix->Scale(xScale,yScale);
 808 }
 809
 810 // add the rotation to this matrix (radians)
 811 void wxGDIPlusMatrixData::Rotate( wxDouble angle )
 812 {
 813     m_matrix->Rotate( angle );
 814 }
 815
 816 //
 817 // apply the transforms
 818 //
 819
 820 // applies that matrix to the point
 821 void wxGDIPlusMatrixData::TransformPoint( wxDouble *x, wxDouble *y ) const
 822 {
 823     PointF pt(*x,*y);
 824     m_matrix->TransformPoints(&pt);
 825     *x = pt.X;
 826     *y = pt.Y;
 827 }
 828
 829 // applies the matrix except for translations
 830 void wxGDIPlusMatrixData::TransformDistance( wxDouble *dx, wxDouble *dy ) const
 831 {
 832     PointF pt(*dx,*dy);
 833     m_matrix->TransformVectors(&pt);
 834     *dx = pt.X;
 835     *dy = pt.Y;
 836 }
 837
 838 // returns the native representation
 839 void * wxGDIPlusMatrixData::GetNativeMatrix() const
 840 {
 841     return m_matrix;
 842 }
 843
 844 //-----------------------------------------------------------------------------
 845 // wxGDIPlusContext implementation
 846 //-----------------------------------------------------------------------------
 847
 848 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusContext,wxGraphicsContext)
 849
 850 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HDC hdc  )
 851     : wxGraphicsContext(renderer)
 852 {
 853     Init();
 854     m_context = new Graphics( hdc);
 855     SetDefaults();
 856 }
 857
 858 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, HWND hwnd  )
 859     : wxGraphicsContext(renderer)
 860 {
 861     Init();
 862     m_context = new Graphics( hwnd);
 863     SetDefaults();
 864 }
 865
 866 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer* renderer, Graphics* gr  )
 867     : wxGraphicsContext(renderer)
 868 {
 869     Init();
 870     m_context = gr;
 871     SetDefaults();
 872 }
 873
 874 wxGDIPlusContext::wxGDIPlusContext() : wxGraphicsContext(NULL)
 875 {
 876     Init();
 877 }
 878
 879 void wxGDIPlusContext::Init()
 880 {
 881     m_context = NULL;
 882     m_state1 = 0;
 883     m_state2= 0;
 884 }
 885
 886 void wxGDIPlusContext::SetDefaults()
 887 {
 888     m_context->SetSmoothingMode(SmoothingModeHighQuality);
 889     m_state1 = m_context->Save();
 890     m_state2 = m_context->Save();
 891 }
 892
 893 wxGDIPlusContext::~wxGDIPlusContext()
 894 {
 895     if ( m_context )
 896     {
 897         m_context->Restore( m_state2 );
 898         m_context->Restore( m_state1 );
 899         delete m_context;
 900     }
 901 }
 902
 903
 904 void wxGDIPlusContext::Clip( const wxRegion &region )
 905 {
 906     Region rgn((HRGN)region.GetHRGN());
 907     m_context->SetClip(&rgn,CombineModeIntersect);
 908 }
 909
 910 void wxGDIPlusContext::Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 911 {
 912     m_context->SetClip(RectF(x,y,w,h),CombineModeIntersect);
 913 }
 914
 915 void wxGDIPlusContext::ResetClip()
 916 {
 917     m_context->ResetClip();
 918 }
 919
 920 void wxGDIPlusContext::StrokePath( const wxGraphicsPath& path )
 921 {
 922     if ( !m_pen.IsNull() )
 923     {
 924         m_context->DrawPath( ((wxGDIPlusPenData*)m_pen.GetGraphicsData())->GetGDIPlusPen() , (GraphicsPath*) path.GetNativePath() );
 925     }
 926 }
 927
 928 void wxGDIPlusContext::FillPath( const wxGraphicsPath& path , int fillStyle )
 929 {
 930     if ( !m_brush.IsNull() )
 931     {
 932         ((GraphicsPath*) path.GetNativePath())->SetFillMode( fillStyle == wxODDEVEN_RULE ? FillModeAlternate : FillModeWinding);
 933         m_context->FillPath( ((wxGDIPlusBrushData*)m_brush.GetRefData())->GetGDIPlusBrush() ,
 934             (GraphicsPath*) path.GetNativePath());
 935     }
 936 }
 937
 938 void wxGDIPlusContext::Rotate( wxDouble angle )
 939 {
 940     m_context->RotateTransform( RadToDeg(angle) );
 941 }
 942
 943 void wxGDIPlusContext::Translate( wxDouble dx , wxDouble dy )
 944 {
 945     m_context->TranslateTransform( dx , dy );
 946 }
 947
 948 void wxGDIPlusContext::Scale( wxDouble xScale , wxDouble yScale )
 949 {
 950     m_context->ScaleTransform(xScale,yScale);
 951 }
 952
 953 void wxGDIPlusContext::PushState()
 954 {
 955     GraphicsState state = m_context->Save();
 956     m_stateStack.push_back(state);
 957 }
 958
 959 void wxGDIPlusContext::PopState()
 960 {
 961     GraphicsState state = m_stateStack.back();
 962     m_stateStack.pop_back();
 963     m_context->Restore(state);
 964 }
 965
 966 // the built-in conversions functions create non-premultiplied bitmaps, while GDIPlus needs them in the
 967 // premultiplied format, therefore in the failing cases we create a new bitmap using the non-premultiplied
 968 // bytes as parameter
 969
 970 void wxGDIPlusContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 971 {
 972     Bitmap* image = NULL;
 973     Bitmap* helper = NULL;
 974     if ( bmp.GetMask() )
 975     {
 976         Bitmap interim((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE()) ;
 977
 978         size_t width = interim.GetWidth();
 979         size_t height = interim.GetHeight();
 980         Rect bounds(0,0,width,height);
 981
 982         image = new Bitmap(width,height,PixelFormat32bppPARGB) ;
 983
 984         Bitmap interimMask((HBITMAP)bmp.GetMask()->GetMaskBitmap(),NULL);
 985         wxASSERT(interimMask.GetPixelFormat() == PixelFormat1bppIndexed);
 986
 987         BitmapData dataMask ;
 988         interimMask.LockBits(&bounds,ImageLockModeRead,
 989             interimMask.GetPixelFormat(),&dataMask);
 990
 991
 992         BitmapData imageData ;
 993         image->LockBits(&bounds,ImageLockModeWrite, PixelFormat32bppPARGB, &imageData);
 994
 995         BYTE maskPattern = 0 ;
 996         BYTE maskByte = 0;
 997         size_t maskIndex ;
 998
 999         for ( size_t y = 0 ; y < height ; ++y)
1000         {
1001             maskIndex = 0 ;
1002             for( size_t x = 0 ; x < width; ++x)
1003             {
1004                 if ( x % 8 == 0)
1005                 {
1006                     maskPattern = 0x80;
1007                     maskByte = *((BYTE*)dataMask.Scan0 + dataMask.Stride*y + maskIndex);
1008                     maskIndex++;
1009                 }
1010                 else
1011                     maskPattern = maskPattern >> 1;
1012
1013                 ARGB *dest = (ARGB*)((BYTE*)imageData.Scan0 + imageData.Stride*y + x*4);
1014                 if ( (maskByte & maskPattern) == 0 )
1015                     *dest = 0x00000000;
1016                 else
1017                 {
1018                     Color c ;
1019                     interim.GetPixel(x,y,&c) ;
1020                     *dest = (c.GetValue() | Color::AlphaMask);
1021                 }
1022             }
1023         }
1024
1025         image->UnlockBits(&imageData);
1026
1027         interimMask.UnlockBits(&dataMask);
1028         interim.UnlockBits(&dataMask);
1029     }
1030     else
1031     {
1032         image = Bitmap::FromHBITMAP((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE());
1033         if ( GetPixelFormatSize(image->GetPixelFormat()) == 32 )
1034         {
1035             size_t width = image->GetWidth();
1036             size_t height = image->GetHeight();
1037             Rect bounds(0,0,width,height);
1038             BitmapData data ;
1039
1040             helper = image ;
1041             image = NULL ;
1042             helper->LockBits(&bounds, ImageLockModeRead,
1043                 helper->GetPixelFormat(),&data);
1044
1045             image = new Bitmap(data.Width, data.Height, data.Stride,
1046                 PixelFormat32bppARGB , (BYTE*) data.Scan0);
1047
1048             helper->UnlockBits(&data);
1049         }
1050     }
1051     if ( image )
1052         m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
1053     delete image ;
1054     delete helper ;
1055 }
1056
1057 void wxGDIPlusContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
1058 {
1059     HICON hIcon = (HICON)icon.GetHICON();
1060     ICONINFO iconInfo ;
1061     // IconInfo creates the bitmaps for color and mask, we must dispose of them after use
1062     if (!GetIconInfo(hIcon,&iconInfo))
1063         return;
1064
1065     BITMAP iconBmpData ;
1066     GetObject(iconInfo.hbmColor,sizeof(BITMAP),&iconBmpData);
1067     Bitmap interim(iconInfo.hbmColor,NULL);
1068
1069     Bitmap* image = NULL ;
1070
1071     if( GetPixelFormatSize(interim.GetPixelFormat())!= 32 )
1072     {
1073         image = Bitmap::FromHICON(hIcon);
1074     }
1075     else
1076     {
1077         size_t width = interim.GetWidth();
1078         size_t height = interim.GetHeight();
1079         Rect bounds(0,0,width,height);
1080         BitmapData data ;
1081
1082         interim.LockBits(&bounds, ImageLockModeRead,
1083             interim.GetPixelFormat(),&data);
1084         image = new Bitmap(data.Width, data.Height, data.Stride,
1085             PixelFormat32bppARGB , (BYTE*) data.Scan0);
1086         interim.UnlockBits(&data);
1087     }
1088
1089     m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
1090
1091     delete image ;
1092     DeleteObject(iconInfo.hbmColor);
1093     DeleteObject(iconInfo.hbmMask);
1094 }
1095
1096 void wxGDIPlusContext::DrawText( const wxString &str, wxDouble x, wxDouble y )
1097 {
1098     if ( m_font.IsNull() || str.IsEmpty())
1099         return ;
1100
1101     wxWCharBuffer s = str.wc_str( *wxConvUI );
1102     m_context->DrawString( s , -1 , ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont() ,
1103             PointF( x , y ) , ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusBrush() );
1104     // TODO m_backgroundMode == wxSOLID
1105 }
1106
1107 void wxGDIPlusContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
1108                                      wxDouble *descent, wxDouble *externalLeading ) const
1109 {
1110     wxWCharBuffer s = str.wc_str( *wxConvUI );
1111     FontFamily ffamily ;
1112     Font* f = ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont();
1113
1114     f->GetFamily(&ffamily) ;
1115
1116     REAL factorY = m_context->GetDpiY() / 72.0 ;
1117
1118     REAL rDescent = ffamily.GetCellDescent(FontStyleRegular) *
1119         f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
1120     REAL rAscent = ffamily.GetCellAscent(FontStyleRegular) *
1121         f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
1122     REAL rHeight = ffamily.GetLineSpacing(FontStyleRegular) *
1123         f->GetSize() / ffamily.GetEmHeight(FontStyleRegular);
1124
1125     if ( height )
1126         *height = rHeight * factorY + 0.5 ;
1127     if ( descent )
1128         *descent = rDescent * factorY + 0.5 ;
1129     if ( externalLeading )
1130         *externalLeading = (rHeight - rAscent - rDescent) * factorY + 0.5 ;
1131     // measuring empty strings is not guaranteed, so do it by hand
1132     if ( str.IsEmpty())
1133     {
1134         if ( width )
1135             *width = 0 ;
1136     }
1137     else
1138     {
1139         // MeasureString does return a rectangle that is way too large, so it is
1140         // not usable here
1141         RectF layoutRect(0,0, 100000.0f, 100000.0f);
1142         StringFormat strFormat;
1143         CharacterRange strRange(0,wcslen(s));
1144         strFormat.SetMeasurableCharacterRanges(1,&strRange);
1145         Region region ;
1146         m_context->MeasureCharacterRanges(s, -1 , f,layoutRect, &strFormat,1,&region) ;
1147         RectF bbox ;
1148         region.GetBounds(&bbox,m_context);
1149         if ( width )
1150             *width = bbox.GetRight()-bbox.GetLeft()+0.5;
1151     }
1152 }
1153
1154 void wxGDIPlusContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
1155 {
1156     widths.Empty();
1157     widths.Add(0, text.length());
1158
1159     if (text.empty())
1160         return;
1161
1162     Font* f = ((wxGDIPlusFontData*)m_font.GetRefData())->GetGDIPlusFont();
1163     wxWCharBuffer ws = text.wc_str( *wxConvUI );
1164     size_t len = wcslen( ws ) ;
1165     wxASSERT_MSG(text.length() == len , wxT("GetPartialTextExtents not yet implemented for multichar situations"));
1166
1167     RectF layoutRect(0,0, 100000.0f, 100000.0f);
1168     StringFormat strFormat;
1169
1170     CharacterRange* ranges = new CharacterRange[len] ;
1171     Region* regions = new Region[len];
1172     size_t i;
1173     for( i = 0 ; i < len ; ++i)
1174     {
1175         ranges[i].First = i ;
1176         ranges[i].Length = 1 ;
1177     }
1178     strFormat.SetMeasurableCharacterRanges(len,ranges);
1179     m_context->MeasureCharacterRanges(ws, -1 , f,layoutRect, &strFormat,1,regions) ;
1180
1181     RectF bbox ;
1182     for ( i = 0 ; i < len ; ++i)
1183     {
1184         regions[i].GetBounds(&bbox,m_context);
1185         widths[i] = bbox.GetRight()-bbox.GetLeft();
1186     }
1187 }
1188
1189 void* wxGDIPlusContext::GetNativeContext()
1190 {
1191     return m_context;
1192 }
1193
1194 // concatenates this transform with the current transform of this context
1195 void wxGDIPlusContext::ConcatTransform( const wxGraphicsMatrix& matrix )
1196 {
1197     m_context->MultiplyTransform((Matrix*) matrix.GetNativeMatrix());
1198 }
1199
1200 // sets the transform of this context
1201 void wxGDIPlusContext::SetTransform( const wxGraphicsMatrix& matrix )
1202 {
1203     m_context->SetTransform((Matrix*) matrix.GetNativeMatrix());
1204 }
1205
1206 // gets the matrix of this context
1207 wxGraphicsMatrix wxGDIPlusContext::GetTransform() const
1208 {
1209     wxGraphicsMatrix matrix = CreateMatrix();
1210     m_context->GetTransform((Matrix*) matrix.GetNativeMatrix());
1211     return matrix;
1212 }
1213 //-----------------------------------------------------------------------------
1214 // wxGDIPlusRenderer declaration
1215 //-----------------------------------------------------------------------------
1216
1217 class WXDLLIMPEXP_CORE wxGDIPlusRenderer : public wxGraphicsRenderer
1218 {
1219 public :
1220     wxGDIPlusRenderer()
1221     {
1222         m_loaded = false;
1223         m_gditoken = 0;
1224     }
1225
1226     virtual ~wxGDIPlusRenderer()
1227     {
1228         if (m_loaded)
1229         {
1230             Unload();
1231         }
1232     }
1233
1234     // Context
1235
1236     virtual wxGraphicsContext * CreateContext( const wxWindowDC& dc);
1237
1238     virtual wxGraphicsContext * CreateContext( const wxMemoryDC& dc);
1239
1240     virtual wxGraphicsContext * CreateContextFromNativeContext( void * context );
1241
1242     virtual wxGraphicsContext * CreateContextFromNativeWindow( void * window );
1243
1244     virtual wxGraphicsContext * CreateContext( wxWindow* window );
1245
1246     virtual wxGraphicsContext * CreateMeasuringContext();
1247
1248     // Path
1249
1250     virtual wxGraphicsPath CreatePath();
1251
1252     // Matrix
1253
1254     virtual wxGraphicsMatrix CreateMatrix( wxDouble a=1.0, wxDouble b=0.0, wxDouble c=0.0, wxDouble d=1.0,
1255         wxDouble tx=0.0, wxDouble ty=0.0);
1256
1257
1258     virtual wxGraphicsPen CreatePen(const wxPen& pen) ;
1259
1260     virtual wxGraphicsBrush CreateBrush(const wxBrush& brush ) ;
1261
1262     // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
1263     virtual wxGraphicsBrush CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
1264         const wxColour&c1, const wxColour&c2) ;
1265
1266     // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
1267     // with radius r and color cColor
1268     virtual wxGraphicsBrush CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
1269         const wxColour &oColor, const wxColour &cColor) ;
1270
1271     // sets the font
1272     virtual wxGraphicsFont CreateFont( const wxFont &font , const wxColour &col = *wxBLACK ) ;
1273 protected :
1274     void EnsureIsLoaded();
1275     void Load();
1276     void Unload();
1277
1278 private :
1279     bool m_loaded;
1280     ULONG_PTR m_gditoken;
1281
1282     DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusRenderer)
1283 } ;
1284
1285 //-----------------------------------------------------------------------------
1286 // wxGDIPlusRenderer implementation
1287 //-----------------------------------------------------------------------------
1288
1289 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusRenderer,wxGraphicsRenderer)
1290
1291 static wxGDIPlusRenderer gs_GDIPlusRenderer;
1292
1293 wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer()
1294 {
1295     return &gs_GDIPlusRenderer;
1296 }
1297
1298 void wxGDIPlusRenderer::EnsureIsLoaded()
1299 {
1300     if (!m_loaded)
1301     {
1302         Load();
1303     }
1304 }
1305
1306 void wxGDIPlusRenderer::Load()
1307 {
1308     GdiplusStartupInput input;
1309     GdiplusStartupOutput output;
1310     GdiplusStartup(&m_gditoken,&input,&output);
1311     m_loaded = true;
1312 }
1313
1314 void wxGDIPlusRenderer::Unload()
1315 {
1316     if ( m_gditoken )
1317         GdiplusShutdown(m_gditoken);
1318 }
1319
1320 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxWindowDC& dc)
1321 {
1322     EnsureIsLoaded();
1323     return new wxGDIPlusContext(this,(HDC) dc.GetHDC());
1324 }
1325
1326 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( const wxMemoryDC& dc)
1327 {
1328     EnsureIsLoaded();
1329     return new wxGDIPlusContext(this,(HDC) dc.GetHDC());
1330 }
1331
1332 wxGraphicsContext * wxGDIPlusRenderer::CreateMeasuringContext()
1333 {
1334     EnsureIsLoaded();
1335     return NULL;
1336     // TODO use GetDC(NULL) but then we have to release it from the context
1337     //return new wxGDIPlusContext(this,(HDC) dc.GetHDC());
1338 }
1339
1340 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeContext( void * context )
1341 {
1342     EnsureIsLoaded();
1343     return new wxGDIPlusContext(this,(Graphics*) context);
1344 }
1345
1346
1347 wxGraphicsContext * wxGDIPlusRenderer::CreateContextFromNativeWindow( void * window )
1348 {
1349     EnsureIsLoaded();
1350     return new wxGDIPlusContext(this,(HWND) window);
1351 }
1352
1353 wxGraphicsContext * wxGDIPlusRenderer::CreateContext( wxWindow* window )
1354 {
1355     EnsureIsLoaded();
1356     return new wxGDIPlusContext(this, (HWND) window->GetHWND() );
1357 }
1358
1359 // Path
1360
1361 wxGraphicsPath wxGDIPlusRenderer::CreatePath()
1362 {
1363     EnsureIsLoaded();
1364     wxGraphicsPath m;
1365     m.SetRefData( new wxGDIPlusPathData(this));
1366     return m;
1367 }
1368
1369
1370 // Matrix
1371
1372 wxGraphicsMatrix wxGDIPlusRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
1373                                                            wxDouble tx, wxDouble ty)
1374
1375 {
1376     EnsureIsLoaded();
1377     wxGraphicsMatrix m;
1378     wxGDIPlusMatrixData* data = new wxGDIPlusMatrixData( this );
1379     data->Set( a,b,c,d,tx,ty ) ;
1380     m.SetRefData(data);
1381     return m;
1382 }
1383
1384 wxGraphicsPen wxGDIPlusRenderer::CreatePen(const wxPen& pen)
1385 {
1386     EnsureIsLoaded();
1387     if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
1388         return wxNullGraphicsPen;
1389     else
1390     {
1391         wxGraphicsPen p;
1392         p.SetRefData(new wxGDIPlusPenData( this, pen ));
1393         return p;
1394     }
1395 }
1396
1397 wxGraphicsBrush wxGDIPlusRenderer::CreateBrush(const wxBrush& brush )
1398 {
1399     EnsureIsLoaded();
1400     if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
1401         return wxNullGraphicsBrush;
1402     else
1403     {
1404         wxGraphicsBrush p;
1405         p.SetRefData(new wxGDIPlusBrushData( this, brush ));
1406         return p;
1407     }
1408 }
1409
1410 // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
1411 wxGraphicsBrush wxGDIPlusRenderer::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
1412                                                                       const wxColour&c1, const wxColour&c2)
1413 {
1414     EnsureIsLoaded();
1415     wxGraphicsBrush p;
1416     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
1417     d->CreateLinearGradientBrush(x1, y1, x2, y2, c1, c2);
1418     p.SetRefData(d);
1419     return p;
1420  }
1421
1422 // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
1423 // with radius r and color cColor
1424 wxGraphicsBrush wxGDIPlusRenderer::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
1425                                                                       const wxColour &oColor, const wxColour &cColor)
1426 {
1427     EnsureIsLoaded();
1428     wxGraphicsBrush p;
1429     wxGDIPlusBrushData* d = new wxGDIPlusBrushData( this );
1430     d->CreateRadialGradientBrush(xo,yo,xc,yc,radius,oColor,cColor);
1431     p.SetRefData(d);
1432     return p;
1433 }
1434
1435 // sets the font
1436 wxGraphicsFont wxGDIPlusRenderer::CreateFont( const wxFont &font , const wxColour &col )
1437 {
1438     EnsureIsLoaded();
1439     if ( font.Ok() )
1440     {
1441         wxGraphicsFont p;
1442         p.SetRefData(new wxGDIPlusFontData( this , font, col ));
1443         return p;
1444     }
1445     else
1446         return wxNullGraphicsFont;
1447 }
1448
1449 #endif  // wxUSE_GRAPHICS_CONTEXT