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


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