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


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