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