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


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