1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/graphics.cpp
3 // Purpose: wxGCDC class
4 // Author: Stefan Csomor
8 // Copyright: (c) 2006 Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #include "wx/wxprec.h"
20 #if wxUSE_GRAPHICS_CONTEXT
23 #include "wx/msw/wrapcdlg.h"
25 #include "wx/window.h"
28 #include "wx/dialog.h"
30 #include "wx/bitmap.h"
31 #include "wx/dcmemory.h"
34 #include "wx/dcprint.h"
35 #include "wx/module.h"
38 #include "wx/graphics.h"
39 #include "wx/msw/wrapgdip.h"
43 WX_DECLARE_STACK(GraphicsState
, GraphicsStates
);
45 //-----------------------------------------------------------------------------
47 //-----------------------------------------------------------------------------
49 const double RAD2DEG
= 180.0 / M_PI
;
51 //-----------------------------------------------------------------------------
53 //-----------------------------------------------------------------------------
55 static inline double dmin(double a
, double b
) { return a
< b
? a
: b
; }
56 static inline double dmax(double a
, double b
) { return a
> b
? a
: b
; }
58 static inline double DegToRad(double deg
) { return (deg
* M_PI
) / 180.0; }
59 static inline double RadToDeg(double deg
) { return (deg
* 180.0) / M_PI
; }
61 //-----------------------------------------------------------------------------
62 // device context implementation
64 // more and more of the dc functionality should be implemented by calling
65 // the appropricate wxGDIPlusContext, but we will have to do that step by step
66 // also coordinate conversions should be moved to native matrix ops
67 //-----------------------------------------------------------------------------
69 // we always stock two context states, one at entry, to be able to preserve the
70 // state we were called with, the other one after changing to HI Graphics orientation
71 // (this one is used for getting back clippings etc)
73 //-----------------------------------------------------------------------------
74 // wxGraphicsPath implementation
75 //-----------------------------------------------------------------------------
77 #include "wx/msw/private.h" // needs to be before #include <commdlg.h>
79 #if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
83 class wxGDIPlusPathData
: public wxGraphicsPathData
86 wxGDIPlusPathData(wxGraphicsRenderer
* renderer
, GraphicsPath
* path
= NULL
);
89 virtual wxGraphicsObjectRefData
*Clone() const;
92 // These are the path primitives from which everything else can be constructed
95 // begins a new subpath at (x,y)
96 virtual void MoveToPoint( wxDouble x
, wxDouble y
);
98 // adds a straight line from the current point to (x,y)
99 virtual void AddLineToPoint( wxDouble x
, wxDouble y
);
101 // adds a cubic Bezier curve from the current point, using two control points and an end point
102 virtual void AddCurveToPoint( wxDouble cx1
, wxDouble cy1
, wxDouble cx2
, wxDouble cy2
, wxDouble x
, wxDouble y
);
105 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
106 virtual void AddArc( wxDouble x
, wxDouble y
, wxDouble r
, wxDouble startAngle
, wxDouble endAngle
, bool clockwise
) ;
108 // gets the last point of the current path, (0,0) if not yet set
109 virtual void GetCurrentPoint( wxDouble
* x
, wxDouble
* y
) const;
112 virtual void AddPath( const wxGraphicsPathData
* path
);
114 // closes the current sub-path
115 virtual void CloseSubpath();
118 // These are convenience functions which - if not available natively will be assembled
119 // using the primitives from above
122 // appends a rectangle as a new closed subpath
123 virtual void AddRectangle( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
) ;
126 // appends an ellipsis as a new closed subpath fitting the passed rectangle
127 virtual void AddEllipsis( wxDouble x, wxDouble y, wxDouble w , wxDouble h ) ;
129 // 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)
130 virtual void AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r ) ;
133 // returns the native path
134 virtual void * GetNativePath() const { return m_path
; }
136 // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
137 virtual void UnGetNativePath(void * WXUNUSED(path
)) const {}
139 // transforms each point of this path by the matrix
140 virtual void Transform( const wxGraphicsMatrixData
* matrix
) ;
142 // gets the bounding box enclosing all points (possibly including control points)
143 virtual void GetBox(wxDouble
*x
, wxDouble
*y
, wxDouble
*w
, wxDouble
*h
) const;
145 virtual bool Contains( wxDouble x
, wxDouble y
, int fillStyle
= wxODDEVEN_RULE
) const;
148 GraphicsPath
* m_path
;
151 class wxGDIPlusMatrixData
: public wxGraphicsMatrixData
154 wxGDIPlusMatrixData(wxGraphicsRenderer
* renderer
, Matrix
* matrix
= NULL
) ;
155 virtual ~wxGDIPlusMatrixData() ;
157 virtual wxGraphicsObjectRefData
* Clone() const ;
159 // concatenates the matrix
160 virtual void Concat( const wxGraphicsMatrixData
*t
);
162 // sets the matrix to the respective values
163 virtual void Set(wxDouble a
=1.0, wxDouble b
=0.0, wxDouble c
=0.0, wxDouble d
=1.0,
164 wxDouble tx
=0.0, wxDouble ty
=0.0);
166 // gets the component valuess of the matrix
167 virtual void Get(wxDouble
* a
=NULL
, wxDouble
* b
=NULL
, wxDouble
* c
=NULL
,
168 wxDouble
* d
=NULL
, wxDouble
* tx
=NULL
, wxDouble
* ty
=NULL
) const;
170 // makes this the inverse matrix
171 virtual void Invert();
173 // returns true if the elements of the transformation matrix are equal ?
174 virtual bool IsEqual( const wxGraphicsMatrixData
* t
) const ;
176 // return true if this is the identity matrix
177 virtual bool IsIdentity() const;
183 // add the translation to this matrix
184 virtual void Translate( wxDouble dx
, wxDouble dy
);
186 // add the scale to this matrix
187 virtual void Scale( wxDouble xScale
, wxDouble yScale
);
189 // add the rotation to this matrix (radians)
190 virtual void Rotate( wxDouble angle
);
193 // apply the transforms
196 // applies that matrix to the point
197 virtual void TransformPoint( wxDouble
*x
, wxDouble
*y
) const;
199 // applies the matrix except for translations
200 virtual void TransformDistance( wxDouble
*dx
, wxDouble
*dy
) const;
202 // returns the native representation
203 virtual void * GetNativeMatrix() const;
208 class wxGDIPlusPenData
: public wxGraphicsObjectRefData
211 wxGDIPlusPenData( wxGraphicsRenderer
* renderer
, const wxPen
&pen
);
216 virtual wxDouble
GetWidth() { return m_width
; }
217 virtual Pen
* GetGDIPlusPen() { return m_pen
; }
227 class wxGDIPlusBrushData
: public wxGraphicsObjectRefData
230 wxGDIPlusBrushData( wxGraphicsRenderer
* renderer
);
231 wxGDIPlusBrushData( wxGraphicsRenderer
* renderer
, const wxBrush
&brush
);
232 ~wxGDIPlusBrushData ();
234 void CreateLinearGradientBrush( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
,
235 const wxColour
&c1
, const wxColour
&c2
);
236 void CreateRadialGradientBrush( wxDouble xo
, wxDouble yo
, wxDouble xc
, wxDouble yc
, wxDouble radius
,
237 const wxColour
&oColor
, const wxColour
&cColor
);
238 virtual Brush
* GetGDIPlusBrush() { return m_brush
; }
246 GraphicsPath
* m_brushPath
;
249 class wxGDIPlusFontData
: public wxGraphicsObjectRefData
252 wxGDIPlusFontData( wxGraphicsRenderer
* renderer
, const wxFont
&font
, const wxColour
& col
);
253 ~wxGDIPlusFontData();
255 virtual Brush
* GetGDIPlusBrush() { return m_textBrush
; }
256 virtual Font
* GetGDIPlusFont() { return m_font
; }
262 class wxGDIPlusContext
: public wxGraphicsContext
265 wxGDIPlusContext( wxGraphicsRenderer
* renderer
, HDC hdc
);
266 wxGDIPlusContext( wxGraphicsRenderer
* renderer
, HWND hwnd
);
267 wxGDIPlusContext( wxGraphicsRenderer
* renderer
, Graphics
* gr
);
270 virtual ~wxGDIPlusContext();
272 virtual void Clip( const wxRegion
®ion
);
273 // clips drawings to the rect
274 virtual void Clip( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
276 // resets the clipping to original extent
277 virtual void ResetClip();
279 virtual void * GetNativeContext();
281 virtual void StrokePath( const wxGraphicsPath
& p
);
282 virtual void FillPath( const wxGraphicsPath
& p
, int fillStyle
= wxODDEVEN_RULE
);
284 virtual void Translate( wxDouble dx
, wxDouble dy
);
285 virtual void Scale( wxDouble xScale
, wxDouble yScale
);
286 virtual void Rotate( wxDouble angle
);
288 // concatenates this transform with the current transform of this context
289 virtual void ConcatTransform( const wxGraphicsMatrix
& matrix
);
291 // sets the transform of this context
292 virtual void SetTransform( const wxGraphicsMatrix
& matrix
);
294 // gets the matrix of this context
295 virtual wxGraphicsMatrix
GetTransform() const;
297 virtual void DrawBitmap( const wxBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
298 virtual void DrawIcon( const wxIcon
&icon
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
);
299 virtual void PushState();
300 virtual void PopState();
302 virtual void DrawText( const wxString
&str
, wxDouble x
, wxDouble y
);
303 virtual void GetTextExtent( const wxString
&str
, wxDouble
*width
, wxDouble
*height
,
304 wxDouble
*descent
, wxDouble
*externalLeading
) const;
305 virtual void GetPartialTextExtents(const wxString
& text
, wxArrayDouble
& widths
) const;
312 GraphicsStates m_stateStack
;
313 GraphicsState m_state1
;
314 GraphicsState m_state2
;
316 DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusContext
)
319 //-----------------------------------------------------------------------------
320 // wxGDIPlusPen implementation
321 //-----------------------------------------------------------------------------
323 wxGDIPlusPenData::~wxGDIPlusPenData()
330 void wxGDIPlusPenData::Init()
337 wxGDIPlusPenData::wxGDIPlusPenData( wxGraphicsRenderer
* renderer
, const wxPen
&pen
)
338 : wxGraphicsObjectRefData(renderer
)
341 m_width
= pen
.GetWidth();
345 m_pen
= new Pen(Color( pen
.GetColour().Alpha() , pen
.GetColour().Red() ,
346 pen
.GetColour().Green() , pen
.GetColour().Blue() ), m_width
);
349 switch ( pen
.GetCap() )
355 case wxCAP_PROJECTING
:
360 cap
= LineCapFlat
; // TODO verify
367 m_pen
->SetLineCap(cap
,cap
, DashCapFlat
);
370 switch ( pen
.GetJoin() )
373 join
= LineJoinBevel
;
377 join
= LineJoinMiter
;
381 join
= LineJoinRound
;
385 join
= LineJoinMiter
;
389 m_pen
->SetLineJoin(join
);
391 m_pen
->SetDashStyle(DashStyleSolid
);
393 DashStyle dashStyle
= DashStyleSolid
;
394 switch ( pen
.GetStyle() )
400 dashStyle
= DashStyleDot
;
404 dashStyle
= DashStyleDash
; // TODO verify
408 dashStyle
= DashStyleDash
;
412 dashStyle
= DashStyleDashDot
;
416 dashStyle
= DashStyleCustom
;
418 int count
= pen
.GetDashes( &dashes
);
419 if ((dashes
!= NULL
) && (count
> 0))
421 REAL
*userLengths
= new REAL
[count
];
422 for ( int i
= 0; i
< count
; ++i
)
424 userLengths
[i
] = dashes
[i
];
426 m_pen
->SetDashPattern( userLengths
, count
);
427 delete[] userLengths
;
433 wxBitmap
* bmp
= pen
.GetStipple();
434 if ( bmp
&& bmp
->Ok() )
436 m_penImage
= Bitmap::FromHBITMAP((HBITMAP
)bmp
->GetHBITMAP(),(HPALETTE
)bmp
->GetPalette()->GetHPALETTE());
437 m_penBrush
= new TextureBrush(m_penImage
);
438 m_pen
->SetBrush( m_penBrush
);
444 if ( pen
.GetStyle() >= wxFIRST_HATCH
&& pen
.GetStyle() <= wxLAST_HATCH
)
446 HatchStyle style
= HatchStyleHorizontal
;
447 switch( pen
.GetStyle() )
449 case wxBDIAGONAL_HATCH
:
450 style
= HatchStyleBackwardDiagonal
;
452 case wxCROSSDIAG_HATCH
:
453 style
= HatchStyleDiagonalCross
;
455 case wxFDIAGONAL_HATCH
:
456 style
= HatchStyleForwardDiagonal
;
459 style
= HatchStyleCross
;
461 case wxHORIZONTAL_HATCH
:
462 style
= HatchStyleHorizontal
;
464 case wxVERTICAL_HATCH
:
465 style
= HatchStyleVertical
;
469 m_penBrush
= new HatchBrush(style
,Color( pen
.GetColour().Alpha() , pen
.GetColour().Red() ,
470 pen
.GetColour().Green() , pen
.GetColour().Blue() ), Color::Transparent
);
471 m_pen
->SetBrush( m_penBrush
);
475 if ( dashStyle
!= DashStyleSolid
)
476 m_pen
->SetDashStyle(dashStyle
);
479 //-----------------------------------------------------------------------------
480 // wxGDIPlusBrush implementation
481 //-----------------------------------------------------------------------------
483 wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer
* renderer
)
484 : wxGraphicsObjectRefData(renderer
)
489 wxGDIPlusBrushData::wxGDIPlusBrushData( wxGraphicsRenderer
* renderer
, const wxBrush
&brush
)
490 : wxGraphicsObjectRefData(renderer
)
493 if ( brush
.GetStyle() == wxSOLID
)
495 m_brush
= new SolidBrush( Color( brush
.GetColour().Alpha() , brush
.GetColour().Red() ,
496 brush
.GetColour().Green() , brush
.GetColour().Blue() ) );
498 else if ( brush
.IsHatch() )
500 HatchStyle style
= HatchStyleHorizontal
;
501 switch( brush
.GetStyle() )
503 case wxBDIAGONAL_HATCH
:
504 style
= HatchStyleBackwardDiagonal
;
506 case wxCROSSDIAG_HATCH
:
507 style
= HatchStyleDiagonalCross
;
509 case wxFDIAGONAL_HATCH
:
510 style
= HatchStyleForwardDiagonal
;
513 style
= HatchStyleCross
;
515 case wxHORIZONTAL_HATCH
:
516 style
= HatchStyleHorizontal
;
518 case wxVERTICAL_HATCH
:
519 style
= HatchStyleVertical
;
523 m_brush
= new HatchBrush(style
,Color( brush
.GetColour().Alpha() , brush
.GetColour().Red() ,
524 brush
.GetColour().Green() , brush
.GetColour().Blue() ), Color::Transparent
);
528 wxBitmap
* bmp
= brush
.GetStipple();
529 if ( bmp
&& bmp
->Ok() )
531 wxDELETE( m_brushImage
);
532 m_brushImage
= Bitmap::FromHBITMAP((HBITMAP
)bmp
->GetHBITMAP(),(HPALETTE
)bmp
->GetPalette()->GetHPALETTE());
533 m_brush
= new TextureBrush(m_brushImage
);
538 wxGDIPlusBrushData::~wxGDIPlusBrushData()
545 void wxGDIPlusBrushData::Init()
552 void wxGDIPlusBrushData::CreateLinearGradientBrush( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
, const wxColour
&c1
, const wxColour
&c2
)
554 m_brush
= new LinearGradientBrush( PointF( x1
,y1
) , PointF( x2
,y2
),
555 Color( c1
.Alpha(), c1
.Red(),c1
.Green() , c1
.Blue() ),
556 Color( c2
.Alpha(), c2
.Red(),c2
.Green() , c2
.Blue() ));
559 void wxGDIPlusBrushData::CreateRadialGradientBrush( wxDouble xo
, wxDouble yo
, wxDouble xc
, wxDouble yc
, wxDouble radius
,
560 const wxColour
&oColor
, const wxColour
&cColor
)
562 // Create a path that consists of a single circle.
563 m_brushPath
= new GraphicsPath();
564 m_brushPath
->AddEllipse( (REAL
)(xc
-radius
), (REAL
)(yc
-radius
), (REAL
)(2*radius
), (REAL
)(2*radius
));
566 PathGradientBrush
*b
= new PathGradientBrush(m_brushPath
);
568 b
->SetCenterPoint( PointF(xo
,yo
));
569 b
->SetCenterColor(Color( oColor
.Alpha(), oColor
.Red(),oColor
.Green() , oColor
.Blue() ));
571 Color colors
[] = {Color( cColor
.Alpha(), cColor
.Red(),cColor
.Green() , cColor
.Blue() )};
573 b
->SetSurroundColors(colors
, &count
);
576 //-----------------------------------------------------------------------------
577 // wxGDIPlusFont implementation
578 //-----------------------------------------------------------------------------
580 wxGDIPlusFontData::wxGDIPlusFontData( wxGraphicsRenderer
* renderer
, const wxFont
&font
,
581 const wxColour
& col
) : wxGraphicsObjectRefData( renderer
)
586 wxWCharBuffer s
= font
.GetFaceName().wc_str( *wxConvUI
);
587 int size
= font
.GetPointSize();
588 int style
= FontStyleRegular
;
589 if ( font
.GetStyle() == wxFONTSTYLE_ITALIC
)
590 style
|= FontStyleItalic
;
591 if ( font
.GetUnderlined() )
592 style
|= FontStyleUnderline
;
593 if ( font
.GetWeight() == wxFONTWEIGHT_BOLD
)
594 style
|= FontStyleBold
;
595 m_font
= new Font( s
, size
, style
);
596 m_textBrush
= new SolidBrush( Color( col
.Alpha() , col
.Red() ,
597 col
.Green() , col
.Blue() ));
600 wxGDIPlusFontData::~wxGDIPlusFontData()
606 //-----------------------------------------------------------------------------
607 // wxGDIPlusPath implementation
608 //-----------------------------------------------------------------------------
610 wxGDIPlusPathData::wxGDIPlusPathData(wxGraphicsRenderer
* renderer
, GraphicsPath
* path
) : wxGraphicsPathData(renderer
)
615 m_path
= new GraphicsPath();
618 wxGDIPlusPathData::~wxGDIPlusPathData()
623 wxGraphicsObjectRefData
* wxGDIPlusPathData::Clone() const
625 return new wxGDIPlusPathData( GetRenderer() , m_path
->Clone());
632 void wxGDIPlusPathData::MoveToPoint( wxDouble x
, wxDouble y
)
634 m_path
->StartFigure();
635 m_path
->AddLine((REAL
) x
,(REAL
) y
,(REAL
) x
,(REAL
) y
);
638 void wxGDIPlusPathData::AddLineToPoint( wxDouble x
, wxDouble y
)
640 m_path
->AddLine((REAL
) x
,(REAL
) y
,(REAL
) x
,(REAL
) y
);
643 void wxGDIPlusPathData::CloseSubpath()
645 m_path
->CloseFigure();
648 void wxGDIPlusPathData::AddCurveToPoint( wxDouble cx1
, wxDouble cy1
, wxDouble cx2
, wxDouble cy2
, wxDouble x
, wxDouble y
)
654 m_path
->GetLastPoint(&start
);
655 m_path
->AddBezier(start
,c1
,c2
,end
);
658 // gets the last point of the current path, (0,0) if not yet set
659 void wxGDIPlusPathData::GetCurrentPoint( wxDouble
* x
, wxDouble
* y
) const
662 m_path
->GetLastPoint(&start
);
667 void wxGDIPlusPathData::AddArc( wxDouble x
, wxDouble y
, wxDouble r
, double startAngle
, double endAngle
, bool clockwise
)
669 double sweepAngle
= endAngle
- startAngle
;
670 if( abs(sweepAngle
) >= 2*M_PI
)
672 sweepAngle
= 2 * M_PI
;
679 sweepAngle
+= 2 * M_PI
;
684 sweepAngle
-= 2 * M_PI
;
688 m_path
->AddArc((REAL
) (x
-r
),(REAL
) (y
-r
),(REAL
) (2*r
),(REAL
) (2*r
),RadToDeg(startAngle
),RadToDeg(sweepAngle
));
691 void wxGDIPlusPathData::AddRectangle( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
693 m_path
->AddRectangle(RectF(x
,y
,w
,h
));
696 void wxGDIPlusPathData::AddPath( const wxGraphicsPathData
* path
)
698 m_path
->AddPath( (GraphicsPath
*) path
->GetNativePath(), FALSE
);
702 // transforms each point of this path by the matrix
703 void wxGDIPlusPathData::Transform( const wxGraphicsMatrixData
* matrix
)
705 m_path
->Transform( (Matrix
*) matrix
->GetNativeMatrix() );
708 // gets the bounding box enclosing all points (possibly including control points)
709 void wxGDIPlusPathData::GetBox(wxDouble
*x
, wxDouble
*y
, wxDouble
*w
, wxDouble
*h
) const
712 m_path
->GetBounds( &bounds
, NULL
, NULL
) ;
719 bool wxGDIPlusPathData::Contains( wxDouble x
, wxDouble y
, int fillStyle
) const
721 m_path
->SetFillMode( fillStyle
== wxODDEVEN_RULE
? FillModeAlternate
: FillModeWinding
);
722 return m_path
->IsVisible( (FLOAT
) x
,(FLOAT
) y
) == TRUE
;
725 //-----------------------------------------------------------------------------
726 // wxGDIPlusMatrixData implementation
727 //-----------------------------------------------------------------------------
729 wxGDIPlusMatrixData::wxGDIPlusMatrixData(wxGraphicsRenderer
* renderer
, Matrix
* matrix
)
730 : wxGraphicsMatrixData(renderer
)
735 m_matrix
= new Matrix();
738 wxGDIPlusMatrixData::~wxGDIPlusMatrixData()
743 wxGraphicsObjectRefData
*wxGDIPlusMatrixData::Clone() const
745 return new wxGDIPlusMatrixData( GetRenderer(), m_matrix
->Clone());
748 // concatenates the matrix
749 void wxGDIPlusMatrixData::Concat( const wxGraphicsMatrixData
*t
)
751 m_matrix
->Multiply( (Matrix
*) t
->GetNativeMatrix());
754 // sets the matrix to the respective values
755 void wxGDIPlusMatrixData::Set(wxDouble a
, wxDouble b
, wxDouble c
, wxDouble d
,
756 wxDouble tx
, wxDouble ty
)
758 m_matrix
->SetElements(a
,b
,c
,d
,tx
,ty
);
761 // gets the component valuess of the matrix
762 void wxGDIPlusMatrixData::Get(wxDouble
* a
, wxDouble
* b
, wxDouble
* c
,
763 wxDouble
* d
, wxDouble
* tx
, wxDouble
* ty
) const
766 m_matrix
->GetElements(elements
);
767 if (a
) *a
= elements
[0];
768 if (b
) *b
= elements
[1];
769 if (c
) *c
= elements
[2];
770 if (d
) *d
= elements
[3];
771 if (tx
) *tx
= elements
[4];
772 if (ty
) *ty
= elements
[5];
775 // makes this the inverse matrix
776 void wxGDIPlusMatrixData::Invert()
781 // returns true if the elements of the transformation matrix are equal ?
782 bool wxGDIPlusMatrixData::IsEqual( const wxGraphicsMatrixData
* t
) const
784 return m_matrix
->Equals((Matrix
*) t
->GetNativeMatrix())== TRUE
;
787 // return true if this is the identity matrix
788 bool wxGDIPlusMatrixData::IsIdentity() const
790 return m_matrix
->IsIdentity() == TRUE
;
797 // add the translation to this matrix
798 void wxGDIPlusMatrixData::Translate( wxDouble dx
, wxDouble dy
)
800 m_matrix
->Translate(dx
,dy
);
803 // add the scale to this matrix
804 void wxGDIPlusMatrixData::Scale( wxDouble xScale
, wxDouble yScale
)
806 m_matrix
->Scale(xScale
,yScale
);
809 // add the rotation to this matrix (radians)
810 void wxGDIPlusMatrixData::Rotate( wxDouble angle
)
812 m_matrix
->Rotate( angle
);
816 // apply the transforms
819 // applies that matrix to the point
820 void wxGDIPlusMatrixData::TransformPoint( wxDouble
*x
, wxDouble
*y
) const
823 m_matrix
->TransformPoints(&pt
);
828 // applies the matrix except for translations
829 void wxGDIPlusMatrixData::TransformDistance( wxDouble
*dx
, wxDouble
*dy
) const
832 m_matrix
->TransformVectors(&pt
);
837 // returns the native representation
838 void * wxGDIPlusMatrixData::GetNativeMatrix() const
843 //-----------------------------------------------------------------------------
844 // wxGDIPlusContext implementation
845 //-----------------------------------------------------------------------------
847 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusContext
,wxGraphicsContext
)
849 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer
* renderer
, HDC hdc
)
850 : wxGraphicsContext(renderer
)
853 m_context
= new Graphics( hdc
);
857 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer
* renderer
, HWND hwnd
)
858 : wxGraphicsContext(renderer
)
861 m_context
= new Graphics( hwnd
);
865 wxGDIPlusContext::wxGDIPlusContext( wxGraphicsRenderer
* renderer
, Graphics
* gr
)
866 : wxGraphicsContext(renderer
)
873 wxGDIPlusContext::wxGDIPlusContext() : wxGraphicsContext(NULL
)
878 void wxGDIPlusContext::Init()
885 void wxGDIPlusContext::SetDefaults()
887 m_context
->SetSmoothingMode(SmoothingModeHighQuality
);
888 m_state1
= m_context
->Save();
889 m_state2
= m_context
->Save();
892 wxGDIPlusContext::~wxGDIPlusContext()
896 m_context
->Restore( m_state2
);
897 m_context
->Restore( m_state1
);
903 void wxGDIPlusContext::Clip( const wxRegion
®ion
)
905 Region
rgn((HRGN
)region
.GetHRGN());
906 m_context
->SetClip(&rgn
,CombineModeIntersect
);
909 void wxGDIPlusContext::Clip( wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
911 m_context
->SetClip(RectF(x
,y
,w
,h
),CombineModeIntersect
);
914 void wxGDIPlusContext::ResetClip()
916 m_context
->ResetClip();
919 void wxGDIPlusContext::StrokePath( const wxGraphicsPath
& path
)
921 if ( !m_pen
.IsNull() )
923 m_context
->DrawPath( ((wxGDIPlusPenData
*)m_pen
.GetGraphicsData())->GetGDIPlusPen() , (GraphicsPath
*) path
.GetNativePath() );
927 void wxGDIPlusContext::FillPath( const wxGraphicsPath
& path
, int fillStyle
)
929 if ( !m_brush
.IsNull() )
931 ((GraphicsPath
*) path
.GetNativePath())->SetFillMode( fillStyle
== wxODDEVEN_RULE
? FillModeAlternate
: FillModeWinding
);
932 m_context
->FillPath( ((wxGDIPlusBrushData
*)m_brush
.GetRefData())->GetGDIPlusBrush() ,
933 (GraphicsPath
*) path
.GetNativePath());
937 void wxGDIPlusContext::Rotate( wxDouble angle
)
939 m_context
->RotateTransform( RadToDeg(angle
) );
942 void wxGDIPlusContext::Translate( wxDouble dx
, wxDouble dy
)
944 m_context
->TranslateTransform( dx
, dy
);
947 void wxGDIPlusContext::Scale( wxDouble xScale
, wxDouble yScale
)
949 m_context
->ScaleTransform(xScale
,yScale
);
952 void wxGDIPlusContext::PushState()
954 GraphicsState state
= m_context
->Save();
955 m_stateStack
.push(state
);
958 void wxGDIPlusContext::PopState()
960 GraphicsState state
= m_stateStack
.top();
962 m_context
->Restore(state
);
965 // the built-in conversions functions create non-premultiplied bitmaps, while GDIPlus needs them in the
966 // premultiplied format, therefore in the failing cases we create a new bitmap using the non-premultiplied
967 // bytes as parameter
969 void wxGDIPlusContext::DrawBitmap( const wxBitmap
&bmp
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
971 Bitmap
* image
= NULL
;
972 Bitmap
* helper
= NULL
;
975 Bitmap
interim((HBITMAP
)bmp
.GetHBITMAP(),(HPALETTE
)bmp
.GetPalette()->GetHPALETTE()) ;
977 size_t width
= interim
.GetWidth();
978 size_t height
= interim
.GetHeight();
979 Rect
bounds(0,0,width
,height
);
981 image
= new Bitmap(width
,height
,PixelFormat32bppPARGB
) ;
983 Bitmap
interimMask((HBITMAP
)bmp
.GetMask()->GetMaskBitmap(),NULL
);
984 wxASSERT(interimMask
.GetPixelFormat() == PixelFormat1bppIndexed
);
986 BitmapData dataMask
;
987 interimMask
.LockBits(&bounds
,ImageLockModeRead
,
988 interimMask
.GetPixelFormat(),&dataMask
);
991 BitmapData imageData
;
992 image
->LockBits(&bounds
,ImageLockModeWrite
, PixelFormat32bppPARGB
, &imageData
);
994 BYTE maskPattern
= 0 ;
998 for ( size_t y
= 0 ; y
< height
; ++y
)
1001 for( size_t x
= 0 ; x
< width
; ++x
)
1006 maskByte
= *((BYTE
*)dataMask
.Scan0
+ dataMask
.Stride
*y
+ maskIndex
);
1010 maskPattern
= maskPattern
>> 1;
1012 ARGB
*dest
= (ARGB
*)((BYTE
*)imageData
.Scan0
+ imageData
.Stride
*y
+ x
*4);
1013 if ( (maskByte
& maskPattern
) == 0 )
1018 interim
.GetPixel(x
,y
,&c
) ;
1019 *dest
= (c
.GetValue() | Color::AlphaMask
);
1024 image
->UnlockBits(&imageData
);
1026 interimMask
.UnlockBits(&dataMask
);
1027 interim
.UnlockBits(&dataMask
);
1031 image
= Bitmap::FromHBITMAP((HBITMAP
)bmp
.GetHBITMAP(),(HPALETTE
)bmp
.GetPalette()->GetHPALETTE());
1032 if ( GetPixelFormatSize(image
->GetPixelFormat()) == 32 )
1034 size_t width
= image
->GetWidth();
1035 size_t height
= image
->GetHeight();
1036 Rect
bounds(0,0,width
,height
);
1041 helper
->LockBits(&bounds
, ImageLockModeRead
,
1042 helper
->GetPixelFormat(),&data
);
1044 image
= new Bitmap(data
.Width
, data
.Height
, data
.Stride
,
1045 PixelFormat32bppARGB
, (BYTE
*) data
.Scan0
);
1047 helper
->UnlockBits(&data
);
1051 m_context
->DrawImage(image
,(REAL
) x
,(REAL
) y
,(REAL
) w
,(REAL
) h
) ;
1056 void wxGDIPlusContext::DrawIcon( const wxIcon
&icon
, wxDouble x
, wxDouble y
, wxDouble w
, wxDouble h
)
1058 HICON hIcon
= (HICON
)icon
.GetHICON();
1060 // IconInfo creates the bitmaps for color and mask, we must dispose of them after use
1061 if (!GetIconInfo(hIcon
,&iconInfo
))
1064 BITMAP iconBmpData
;
1065 GetObject(iconInfo
.hbmColor
,sizeof(BITMAP
),&iconBmpData
);
1066 Bitmap
interim(iconInfo
.hbmColor
,NULL
);
1068 Bitmap
* image
= NULL
;
1070 if( GetPixelFormatSize(interim
.GetPixelFormat())!= 32 )
1072 image
= Bitmap::FromHICON(hIcon
);
1076 size_t width
= interim
.GetWidth();
1077 size_t height
= interim
.GetHeight();
1078 Rect
bounds(0,0,width
,height
);
1081 interim
.LockBits(&bounds
, ImageLockModeRead
,
1082 interim
.GetPixelFormat(),&data
);
1083 image
= new Bitmap(data
.Width
, data
.Height
, data
.Stride
,
1084 PixelFormat32bppARGB
, (BYTE
*) data
.Scan0
);
1085 interim
.UnlockBits(&data
);
1088 m_context
->DrawImage(image
,(REAL
) x
,(REAL
) y
,(REAL
) w
,(REAL
) h
) ;
1091 DeleteObject(iconInfo
.hbmColor
);
1092 DeleteObject(iconInfo
.hbmMask
);
1095 void wxGDIPlusContext::DrawText( const wxString
&str
, wxDouble x
, wxDouble y
)
1097 if ( m_font
.IsNull() || str
.IsEmpty())
1100 wxWCharBuffer s
= str
.wc_str( *wxConvUI
);
1101 m_context
->DrawString( s
, -1 , ((wxGDIPlusFontData
*)m_font
.GetRefData())->GetGDIPlusFont() ,
1102 PointF( x
, y
) , ((wxGDIPlusFontData
*)m_font
.GetRefData())->GetGDIPlusBrush() );
1103 // TODO m_backgroundMode == wxSOLID
1106 void wxGDIPlusContext::GetTextExtent( const wxString
&str
, wxDouble
*width
, wxDouble
*height
,
1107 wxDouble
*descent
, wxDouble
*externalLeading
) const
1109 wxWCharBuffer s
= str
.wc_str( *wxConvUI
);
1110 FontFamily ffamily
;
1111 Font
* f
= ((wxGDIPlusFontData
*)m_font
.GetRefData())->GetGDIPlusFont();
1113 f
->GetFamily(&ffamily
) ;
1115 REAL factorY
= m_context
->GetDpiY() / 72.0 ;
1117 REAL rDescent
= ffamily
.GetCellDescent(FontStyleRegular
) *
1118 f
->GetSize() / ffamily
.GetEmHeight(FontStyleRegular
);
1119 REAL rAscent
= ffamily
.GetCellAscent(FontStyleRegular
) *
1120 f
->GetSize() / ffamily
.GetEmHeight(FontStyleRegular
);
1121 REAL rHeight
= ffamily
.GetLineSpacing(FontStyleRegular
) *
1122 f
->GetSize() / ffamily
.GetEmHeight(FontStyleRegular
);
1125 *height
= rHeight
* factorY
+ 0.5 ;
1127 *descent
= rDescent
* factorY
+ 0.5 ;
1128 if ( externalLeading
)
1129 *externalLeading
= (rHeight
- rAscent
- rDescent
) * factorY
+ 0.5 ;
1130 // measuring empty strings is not guaranteed, so do it by hand
1138 // MeasureString does return a rectangle that is way too large, so it is
1140 RectF
layoutRect(0,0, 100000.0f
, 100000.0f
);
1141 StringFormat strFormat
;
1142 CharacterRange
strRange(0,wcslen(s
));
1143 strFormat
.SetMeasurableCharacterRanges(1,&strRange
);
1145 m_context
->MeasureCharacterRanges(s
, -1 , f
,layoutRect
, &strFormat
,1,®ion
) ;
1147 region
.GetBounds(&bbox
,m_context
);
1149 *width
= bbox
.GetRight()-bbox
.GetLeft()+0.5;
1153 void wxGDIPlusContext::GetPartialTextExtents(const wxString
& text
, wxArrayDouble
& widths
) const
1156 widths
.Add(0, text
.length());
1161 Font
* f
= ((wxGDIPlusFontData
*)m_font
.GetRefData())->GetGDIPlusFont();
1162 wxWCharBuffer ws
= text
.wc_str( *wxConvUI
);
1163 size_t len
= wcslen( ws
) ;
1164 wxASSERT_MSG(text
.length() == len
, wxT("GetPartialTextExtents not yet implemented for multichar situations"));
1166 RectF
layoutRect(0,0, 100000.0f
, 100000.0f
);
1167 StringFormat strFormat
;
1169 CharacterRange
* ranges
= new CharacterRange
[len
] ;
1170 Region
* regions
= new Region
[len
];
1172 for( i
= 0 ; i
< len
; ++i
)
1174 ranges
[i
].First
= i
;
1175 ranges
[i
].Length
= 1 ;
1177 strFormat
.SetMeasurableCharacterRanges(len
,ranges
);
1178 m_context
->MeasureCharacterRanges(ws
, -1 , f
,layoutRect
, &strFormat
,1,regions
) ;
1181 for ( i
= 0 ; i
< len
; ++i
)
1183 regions
[i
].GetBounds(&bbox
,m_context
);
1184 widths
[i
] = bbox
.GetRight()-bbox
.GetLeft();
1188 void* wxGDIPlusContext::GetNativeContext()
1193 // concatenates this transform with the current transform of this context
1194 void wxGDIPlusContext::ConcatTransform( const wxGraphicsMatrix
& matrix
)
1196 m_context
->MultiplyTransform((Matrix
*) matrix
.GetNativeMatrix());
1199 // sets the transform of this context
1200 void wxGDIPlusContext::SetTransform( const wxGraphicsMatrix
& matrix
)
1202 m_context
->SetTransform((Matrix
*) matrix
.GetNativeMatrix());
1205 // gets the matrix of this context
1206 wxGraphicsMatrix
wxGDIPlusContext::GetTransform() const
1208 wxGraphicsMatrix matrix
= CreateMatrix();
1209 m_context
->GetTransform((Matrix
*) matrix
.GetNativeMatrix());
1212 //-----------------------------------------------------------------------------
1213 // wxGDIPlusRenderer declaration
1214 //-----------------------------------------------------------------------------
1216 class wxGDIPlusRenderer
: public wxGraphicsRenderer
1225 virtual ~wxGDIPlusRenderer()
1235 virtual wxGraphicsContext
* CreateContext( const wxWindowDC
& dc
);
1237 virtual wxGraphicsContext
* CreateContext( const wxMemoryDC
& dc
);
1239 virtual wxGraphicsContext
* CreateContextFromNativeContext( void * context
);
1241 virtual wxGraphicsContext
* CreateContextFromNativeWindow( void * window
);
1243 virtual wxGraphicsContext
* CreateContext( wxWindow
* window
);
1245 virtual wxGraphicsContext
* CreateMeasuringContext();
1249 virtual wxGraphicsPath
CreatePath();
1253 virtual wxGraphicsMatrix
CreateMatrix( wxDouble a
=1.0, wxDouble b
=0.0, wxDouble c
=0.0, wxDouble d
=1.0,
1254 wxDouble tx
=0.0, wxDouble ty
=0.0);
1257 virtual wxGraphicsPen
CreatePen(const wxPen
& pen
) ;
1259 virtual wxGraphicsBrush
CreateBrush(const wxBrush
& brush
) ;
1261 // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
1262 virtual wxGraphicsBrush
CreateLinearGradientBrush( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
,
1263 const wxColour
&c1
, const wxColour
&c2
) ;
1265 // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
1266 // with radius r and color cColor
1267 virtual wxGraphicsBrush
CreateRadialGradientBrush( wxDouble xo
, wxDouble yo
, wxDouble xc
, wxDouble yc
, wxDouble radius
,
1268 const wxColour
&oColor
, const wxColour
&cColor
) ;
1271 virtual wxGraphicsFont
CreateFont( const wxFont
&font
, const wxColour
&col
= *wxBLACK
) ;
1273 void EnsureIsLoaded();
1279 ULONG_PTR m_gditoken
;
1281 DECLARE_DYNAMIC_CLASS_NO_COPY(wxGDIPlusRenderer
)
1284 //-----------------------------------------------------------------------------
1285 // wxGDIPlusRenderer implementation
1286 //-----------------------------------------------------------------------------
1288 IMPLEMENT_DYNAMIC_CLASS(wxGDIPlusRenderer
,wxGraphicsRenderer
)
1290 static wxGDIPlusRenderer gs_GDIPlusRenderer
;
1292 wxGraphicsRenderer
* wxGraphicsRenderer::GetDefaultRenderer()
1294 return &gs_GDIPlusRenderer
;
1297 void wxGDIPlusRenderer::EnsureIsLoaded()
1305 void wxGDIPlusRenderer::Load()
1307 GdiplusStartupInput input
;
1308 GdiplusStartupOutput output
;
1309 GdiplusStartup(&m_gditoken
,&input
,&output
);
1313 void wxGDIPlusRenderer::Unload()
1316 GdiplusShutdown(m_gditoken
);
1319 wxGraphicsContext
* wxGDIPlusRenderer::CreateContext( const wxWindowDC
& dc
)
1322 return new wxGDIPlusContext(this,(HDC
) dc
.GetHDC());
1325 wxGraphicsContext
* wxGDIPlusRenderer::CreateContext( const wxMemoryDC
& dc
)
1328 return new wxGDIPlusContext(this,(HDC
) dc
.GetHDC());
1331 wxGraphicsContext
* wxGDIPlusRenderer::CreateMeasuringContext()
1335 // TODO use GetDC(NULL) but then we have to release it from the context
1336 //return new wxGDIPlusContext(this,(HDC) dc.GetHDC());
1339 wxGraphicsContext
* wxGDIPlusRenderer::CreateContextFromNativeContext( void * context
)
1342 return new wxGDIPlusContext(this,(Graphics
*) context
);
1346 wxGraphicsContext
* wxGDIPlusRenderer::CreateContextFromNativeWindow( void * window
)
1349 return new wxGDIPlusContext(this,(HWND
) window
);
1352 wxGraphicsContext
* wxGDIPlusRenderer::CreateContext( wxWindow
* window
)
1355 return new wxGDIPlusContext(this, (HWND
) window
->GetHWND() );
1360 wxGraphicsPath
wxGDIPlusRenderer::CreatePath()
1364 m
.SetRefData( new wxGDIPlusPathData(this));
1371 wxGraphicsMatrix
wxGDIPlusRenderer::CreateMatrix( wxDouble a
, wxDouble b
, wxDouble c
, wxDouble d
,
1372 wxDouble tx
, wxDouble ty
)
1377 wxGDIPlusMatrixData
* data
= new wxGDIPlusMatrixData( this );
1378 data
->Set( a
,b
,c
,d
,tx
,ty
) ;
1383 wxGraphicsPen
wxGDIPlusRenderer::CreatePen(const wxPen
& pen
)
1386 if ( !pen
.Ok() || pen
.GetStyle() == wxTRANSPARENT
)
1387 return wxNullGraphicsPen
;
1391 p
.SetRefData(new wxGDIPlusPenData( this, pen
));
1396 wxGraphicsBrush
wxGDIPlusRenderer::CreateBrush(const wxBrush
& brush
)
1399 if ( !brush
.Ok() || brush
.GetStyle() == wxTRANSPARENT
)
1400 return wxNullGraphicsBrush
;
1404 p
.SetRefData(new wxGDIPlusBrushData( this, brush
));
1409 // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
1410 wxGraphicsBrush
wxGDIPlusRenderer::CreateLinearGradientBrush( wxDouble x1
, wxDouble y1
, wxDouble x2
, wxDouble y2
,
1411 const wxColour
&c1
, const wxColour
&c2
)
1415 wxGDIPlusBrushData
* d
= new wxGDIPlusBrushData( this );
1416 d
->CreateLinearGradientBrush(x1
, y1
, x2
, y2
, c1
, c2
);
1421 // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
1422 // with radius r and color cColor
1423 wxGraphicsBrush
wxGDIPlusRenderer::CreateRadialGradientBrush( wxDouble xo
, wxDouble yo
, wxDouble xc
, wxDouble yc
, wxDouble radius
,
1424 const wxColour
&oColor
, const wxColour
&cColor
)
1428 wxGDIPlusBrushData
* d
= new wxGDIPlusBrushData( this );
1429 d
->CreateRadialGradientBrush(xo
,yo
,xc
,yc
,radius
,oColor
,cColor
);
1435 wxGraphicsFont
wxGDIPlusRenderer::CreateFont( const wxFont
&font
, const wxColour
&col
)
1441 p
.SetRefData(new wxGDIPlusFontData( this , font
, col
));
1445 return wxNullGraphicsFont
;
1448 #endif // wxUSE_GRAPHICS_CONTEXT