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


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