]> git.saurik.com Git - wxWidgets.git/blob - src/msw/graphics.cpp
projects / wxWidgets.git / blob
? search:


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