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