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


da313ef55fcbfed0796697d72e3ae762a5b06389
[wxWidgets.git] / src / common / graphcmn.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/graphcmn.cpp
3 // Purpose: graphics context methods common to all platforms
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created:
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #if defined(__BORLANDC__)
16 #pragma hdrstop
17 #endif
18
19 #if wxUSE_GRAPHICS_CONTEXT
20
21 #include "wx/graphics.h"
22
23 #ifndef WX_PRECOMP
24 #include "wx/icon.h"
25 #include "wx/bitmap.h"
26 #include "wx/dcmemory.h"
27 #include "wx/region.h"
28 #include "wx/log.h"
29 #endif
30
31 #if !defined(wxMAC_USE_CORE_GRAPHICS_BLEND_MODES)
32 #define wxMAC_USE_CORE_GRAPHICS_BLEND_MODES 0
33 #endif
34
35 //-----------------------------------------------------------------------------
36 // constants
37 //-----------------------------------------------------------------------------
38
39 static const double RAD2DEG = 180.0 / M_PI;
40
41 //-----------------------------------------------------------------------------
42 // Local functions
43 //-----------------------------------------------------------------------------
44
45 static inline double DegToRad(double deg)
46 {
47 return (deg * M_PI) / 180.0;
48 }
49
50 //-----------------------------------------------------------------------------
51
52 //-----------------------------------------------------------------------------
53 // wxGraphicsObject
54 //-----------------------------------------------------------------------------
55
56 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsObject, wxObject)
57
58 wxGraphicsObjectRefData::wxGraphicsObjectRefData( wxGraphicsRenderer* renderer )
59 {
60 m_renderer = renderer;
61 }
62 wxGraphicsObjectRefData::wxGraphicsObjectRefData( const wxGraphicsObjectRefData* data )
63 {
64 m_renderer = data->m_renderer;
65 }
66 wxGraphicsRenderer* wxGraphicsObjectRefData::GetRenderer() const
67 {
68 return m_renderer ;
69 }
70
71 wxGraphicsObjectRefData* wxGraphicsObjectRefData::Clone() const
72 {
73 return new wxGraphicsObjectRefData(this);
74 }
75
76 wxGraphicsObject::wxGraphicsObject()
77 {
78 }
79
80 wxGraphicsObject::wxGraphicsObject( wxGraphicsRenderer* renderer )
81 {
82 SetRefData( new wxGraphicsObjectRefData(renderer));
83 }
84
85 wxGraphicsObject::~wxGraphicsObject()
86 {
87 }
88
89 bool wxGraphicsObject::IsNull() const
90 {
91 return m_refData == NULL;
92 }
93
94 wxGraphicsRenderer* wxGraphicsObject::GetRenderer() const
95 {
96 return ( IsNull() ? NULL : GetGraphicsData()->GetRenderer() );
97 }
98
99 wxGraphicsObjectRefData* wxGraphicsObject::GetGraphicsData() const
100 {
101 return (wxGraphicsObjectRefData*) m_refData;
102 }
103
104 wxObjectRefData* wxGraphicsObject::CreateRefData() const
105 {
106 wxLogDebug(wxT("A Null Object cannot be changed"));
107 return NULL;
108 }
109
110 wxObjectRefData* wxGraphicsObject::CloneRefData(const wxObjectRefData* data) const
111 {
112 const wxGraphicsObjectRefData* ptr = (const wxGraphicsObjectRefData*) data;
113 return ptr->Clone();
114 }
115
116 //-----------------------------------------------------------------------------
117 // pens etc.
118 //-----------------------------------------------------------------------------
119
120 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsPen, wxGraphicsObject)
121 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsBrush, wxGraphicsObject)
122 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsFont, wxGraphicsObject)
123
124 WXDLLIMPEXP_DATA_CORE(wxGraphicsPen) wxNullGraphicsPen;
125 WXDLLIMPEXP_DATA_CORE(wxGraphicsBrush) wxNullGraphicsBrush;
126 WXDLLIMPEXP_DATA_CORE(wxGraphicsFont) wxNullGraphicsFont;
127
128 //-----------------------------------------------------------------------------
129 // matrix
130 //-----------------------------------------------------------------------------
131
132 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsMatrix, wxGraphicsObject)
133 WXDLLIMPEXP_DATA_CORE(wxGraphicsMatrix) wxNullGraphicsMatrix;
134
135 // concatenates the matrix
136 void wxGraphicsMatrix::Concat( const wxGraphicsMatrix *t )
137 {
138 AllocExclusive();
139 GetMatrixData()->Concat(t->GetMatrixData());
140 }
141
142 // sets the matrix to the respective values
143 void wxGraphicsMatrix::Set(wxDouble a, wxDouble b, wxDouble c, wxDouble d,
144 wxDouble tx, wxDouble ty)
145 {
146 AllocExclusive();
147 GetMatrixData()->Set(a,b,c,d,tx,ty);
148 }
149
150 // gets the component valuess of the matrix
151 void wxGraphicsMatrix::Get(wxDouble* a, wxDouble* b, wxDouble* c,
152 wxDouble* d, wxDouble* tx, wxDouble* ty) const
153 {
154 GetMatrixData()->Get(a, b, c, d, tx, ty);
155 }
156
157 // makes this the inverse matrix
158 void wxGraphicsMatrix::Invert()
159 {
160 AllocExclusive();
161 GetMatrixData()->Invert();
162 }
163
164 // returns true if the elements of the transformation matrix are equal ?
165 bool wxGraphicsMatrix::IsEqual( const wxGraphicsMatrix* t) const
166 {
167 return GetMatrixData()->IsEqual(t->GetMatrixData());
168 }
169
170 // return true if this is the identity matrix
171 bool wxGraphicsMatrix::IsIdentity() const
172 {
173 return GetMatrixData()->IsIdentity();
174 }
175
176 // add the translation to this matrix
177 void wxGraphicsMatrix::Translate( wxDouble dx , wxDouble dy )
178 {
179 AllocExclusive();
180 GetMatrixData()->Translate(dx,dy);
181 }
182
183 // add the scale to this matrix
184 void wxGraphicsMatrix::Scale( wxDouble xScale , wxDouble yScale )
185 {
186 AllocExclusive();
187 GetMatrixData()->Scale(xScale,yScale);
188 }
189
190 // add the rotation to this matrix (radians)
191 void wxGraphicsMatrix::Rotate( wxDouble angle )
192 {
193 AllocExclusive();
194 GetMatrixData()->Rotate(angle);
195 }
196
197 //
198 // apply the transforms
199 //
200
201 // applies that matrix to the point
202 void wxGraphicsMatrix::TransformPoint( wxDouble *x, wxDouble *y ) const
203 {
204 GetMatrixData()->TransformPoint(x,y);
205 }
206
207 // applies the matrix except for translations
208 void wxGraphicsMatrix::TransformDistance( wxDouble *dx, wxDouble *dy ) const
209 {
210 GetMatrixData()->TransformDistance(dx,dy);
211 }
212
213 // returns the native representation
214 void * wxGraphicsMatrix::GetNativeMatrix() const
215 {
216 return GetMatrixData()->GetNativeMatrix();
217 }
218
219 //-----------------------------------------------------------------------------
220 // path
221 //-----------------------------------------------------------------------------
222
223 IMPLEMENT_DYNAMIC_CLASS(wxGraphicsPath, wxGraphicsObject)
224 WXDLLIMPEXP_DATA_CORE(wxGraphicsPath) wxNullGraphicsPath;
225
226 // convenience functions, for using wxPoint2DDouble etc
227
228 wxPoint2DDouble wxGraphicsPath::GetCurrentPoint() const
229 {
230 wxDouble x,y;
231 GetCurrentPoint(&x,&y);
232 return wxPoint2DDouble(x,y);
233 }
234
235 void wxGraphicsPath::MoveToPoint( const wxPoint2DDouble& p)
236 {
237 MoveToPoint( p.m_x , p.m_y);
238 }
239
240 void wxGraphicsPath::AddLineToPoint( const wxPoint2DDouble& p)
241 {
242 AddLineToPoint( p.m_x , p.m_y);
243 }
244
245 void wxGraphicsPath::AddCurveToPoint( const wxPoint2DDouble& c1, const wxPoint2DDouble& c2, const wxPoint2DDouble& e)
246 {
247 AddCurveToPoint(c1.m_x, c1.m_y, c2.m_x, c2.m_y, e.m_x, e.m_y);
248 }
249
250 void wxGraphicsPath::AddArc( const wxPoint2DDouble& c, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise)
251 {
252 AddArc(c.m_x, c.m_y, r, startAngle, endAngle, clockwise);
253 }
254
255 wxRect2DDouble wxGraphicsPath::GetBox() const
256 {
257 wxDouble x,y,w,h;
258 GetBox(&x,&y,&w,&h);
259 return wxRect2DDouble( x,y,w,h );
260 }
261
262 bool wxGraphicsPath::Contains( const wxPoint2DDouble& c, int fillStyle ) const
263 {
264 return Contains( c.m_x, c.m_y, fillStyle);
265 }
266
267 // true redirections
268
269 // begins a new subpath at (x,y)
270 void wxGraphicsPath::MoveToPoint( wxDouble x, wxDouble y )
271 {
272 AllocExclusive();
273 GetPathData()->MoveToPoint(x,y);
274 }
275
276 // adds a straight line from the current point to (x,y)
277 void wxGraphicsPath::AddLineToPoint( wxDouble x, wxDouble y )
278 {
279 AllocExclusive();
280 GetPathData()->AddLineToPoint(x,y);
281 }
282
283 // adds a cubic Bezier curve from the current point, using two control points and an end point
284 void wxGraphicsPath::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
285 {
286 AllocExclusive();
287 GetPathData()->AddCurveToPoint(cx1,cy1,cx2,cy2,x,y);
288 }
289
290 // adds another path
291 void wxGraphicsPath::AddPath( const wxGraphicsPath& path )
292 {
293 AllocExclusive();
294 GetPathData()->AddPath(path.GetPathData());
295 }
296
297 // closes the current sub-path
298 void wxGraphicsPath::CloseSubpath()
299 {
300 AllocExclusive();
301 GetPathData()->CloseSubpath();
302 }
303
304 // gets the last point of the current path, (0,0) if not yet set
305 void wxGraphicsPath::GetCurrentPoint( wxDouble* x, wxDouble* y) const
306 {
307 GetPathData()->GetCurrentPoint(x,y);
308 }
309
310 // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
311 void wxGraphicsPath::AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise )
312 {
313 AllocExclusive();
314 GetPathData()->AddArc(x,y,r,startAngle,endAngle,clockwise);
315 }
316
317 //
318 // These are convenience functions which - if not available natively will be assembled
319 // using the primitives from above
320 //
321
322 // adds a quadratic Bezier curve from the current point, using a control point and an end point
323 void wxGraphicsPath::AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y )
324 {
325 AllocExclusive();
326 GetPathData()->AddQuadCurveToPoint(cx,cy,x,y);
327 }
328
329 // appends a rectangle as a new closed subpath
330 void wxGraphicsPath::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
331 {
332 AllocExclusive();
333 GetPathData()->AddRectangle(x,y,w,h);
334 }
335
336 // appends an ellipsis as a new closed subpath fitting the passed rectangle
337 void wxGraphicsPath::AddCircle( wxDouble x, wxDouble y, wxDouble r )
338 {
339 AllocExclusive();
340 GetPathData()->AddCircle(x,y,r);
341 }
342
343 // appends 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)
344 void wxGraphicsPath::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
345 {
346 GetPathData()->AddArcToPoint(x1,y1,x2,y2,r);
347 }
348
349 // appends an ellipse
350 void wxGraphicsPath::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
351 {
352 AllocExclusive();
353 GetPathData()->AddEllipse(x,y,w,h);
354 }
355
356 // appends a rounded rectangle
357 void wxGraphicsPath::AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
358 {
359 AllocExclusive();
360 GetPathData()->AddRoundedRectangle(x,y,w,h,radius);
361 }
362
363 // returns the native path
364 void * wxGraphicsPath::GetNativePath() const
365 {
366 return GetPathData()->GetNativePath();
367 }
368
369 // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
370 void wxGraphicsPath::UnGetNativePath(void *p)const
371 {
372 GetPathData()->UnGetNativePath(p);
373 }
374
375 // transforms each point of this path by the matrix
376 void wxGraphicsPath::Transform( const wxGraphicsMatrix& matrix )
377 {
378 AllocExclusive();
379 GetPathData()->Transform(matrix.GetMatrixData());
380 }
381
382 // gets the bounding box enclosing all points (possibly including control points)
383 void wxGraphicsPath::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
384 {
385 GetPathData()->GetBox(x,y,w,h);
386 }
387
388 bool wxGraphicsPath::Contains( wxDouble x, wxDouble y, int fillStyle ) const
389 {
390 return GetPathData()->Contains(x,y,fillStyle);
391 }
392
393 //
394 // Emulations, these mus be implemented in the ...Data classes in order to allow for proper overrides
395 //
396
397 void wxGraphicsPathData::AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y )
398 {
399 // calculate using degree elevation to a cubic bezier
400 wxPoint2DDouble c1;
401 wxPoint2DDouble c2;
402
403 wxPoint2DDouble start;
404 GetCurrentPoint(&start.m_x,&start.m_y);
405 wxPoint2DDouble end(x,y);
406 wxPoint2DDouble c(cx,cy);
407 c1 = wxDouble(1/3.0) * start + wxDouble(2/3.0) * c;
408 c2 = wxDouble(2/3.0) * c + wxDouble(1/3.0) * end;
409 AddCurveToPoint(c1.m_x,c1.m_y,c2.m_x,c2.m_y,x,y);
410 }
411
412 void wxGraphicsPathData::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
413 {
414 MoveToPoint(x,y);
415 AddLineToPoint(x,y+h);
416 AddLineToPoint(x+w,y+h);
417 AddLineToPoint(x+w,y);
418 CloseSubpath();
419 }
420
421 void wxGraphicsPathData::AddCircle( wxDouble x, wxDouble y, wxDouble r )
422 {
423 MoveToPoint(x+r,y);
424 AddArc( x,y,r,0,2*M_PI,false);
425 CloseSubpath();
426 }
427
428 void wxGraphicsPathData::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
429 {
430 wxDouble rw = w/2;
431 wxDouble rh = h/2;
432 wxDouble xc = x + rw;
433 wxDouble yc = y + rh;
434 wxGraphicsMatrix m = GetRenderer()->CreateMatrix();
435 m.Translate(xc,yc);
436 m.Scale(rw/rh,1.0);
437 wxGraphicsPath p = GetRenderer()->CreatePath();
438 p.AddCircle(0,0,rh);
439 p.Transform(m);
440 AddPath(p.GetPathData());
441 }
442
443 void wxGraphicsPathData::AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
444 {
445 if ( radius == 0 )
446 AddRectangle(x,y,w,h);
447 else
448 {
449 MoveToPoint( x + w, y + h / 2);
450 AddArcToPoint(x + w, y + h, x + w / 2, y + h, radius);
451 AddArcToPoint(x, y + h, x, y + h / 2, radius);
452 AddArcToPoint(x, y , x + w / 2, y, radius);
453 AddArcToPoint(x + w, y, x + w, y + h / 2, radius);
454 CloseSubpath();
455 }
456 }
457
458 // 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)
459 void wxGraphicsPathData::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
460 {
461 wxPoint2DDouble current;
462 GetCurrentPoint(&current.m_x,&current.m_y);
463 wxPoint2DDouble p1(x1,y1);
464 wxPoint2DDouble p2(x2,y2);
465
466 wxPoint2DDouble v1 = current - p1;
467 v1.Normalize();
468 wxPoint2DDouble v2 = p2 - p1;
469 v2.Normalize();
470
471 wxDouble alpha = v1.GetVectorAngle() - v2.GetVectorAngle();
472
473 if ( alpha < 0 )
474 alpha = 360 + alpha;
475 // TODO obtuse angles
476
477 alpha = DegToRad(alpha);
478
479 wxDouble dist = r / sin(alpha/2) * cos(alpha/2);
480 // calculate tangential points
481 wxPoint2DDouble t1 = dist*v1 + p1;
482 wxPoint2DDouble t2 = dist*v2 + p1;
483
484 wxPoint2DDouble nv1 = v1;
485 nv1.SetVectorAngle(v1.GetVectorAngle()-90);
486 wxPoint2DDouble c = t1 + r*nv1;
487
488 wxDouble a1 = v1.GetVectorAngle()+90;
489 wxDouble a2 = v2.GetVectorAngle()-90;
490
491 AddLineToPoint(t1.m_x,t1.m_y);
492 AddArc(c.m_x,c.m_y,r,DegToRad(a1),DegToRad(a2),true);
493 AddLineToPoint(p2.m_x,p2.m_y);
494 }
495
496 //-----------------------------------------------------------------------------
497 // wxGraphicsContext Convenience Methods
498 //-----------------------------------------------------------------------------
499
500 IMPLEMENT_ABSTRACT_CLASS(wxGraphicsContext, wxObject)
501
502
503 wxGraphicsContext::wxGraphicsContext(wxGraphicsRenderer* renderer) : wxGraphicsObject(renderer)
504 {
505 m_logicalFunction = wxCOPY;
506 }
507
508 wxGraphicsContext::~wxGraphicsContext()
509 {
510 }
511
512 bool wxGraphicsContext::StartDoc(const wxString& WXUNUSED(message))
513 {
514 return true;
515 }
516
517 void wxGraphicsContext::EndDoc()
518 {
519 }
520
521 void wxGraphicsContext::StartPage(wxDouble WXUNUSED(width),
522 wxDouble WXUNUSED(height))
523 {
524 }
525
526 void wxGraphicsContext::EndPage()
527 {
528 }
529
530 void wxGraphicsContext::Flush()
531 {
532 }
533
534 #if 0
535 void wxGraphicsContext::SetAlpha( wxDouble WXUNUSED(alpha) )
536 {
537 }
538
539 wxDouble wxGraphicsContext::GetAlpha() const
540 {
541 return 1.0;
542 }
543 #endif
544
545 void wxGraphicsContext::GetSize( wxDouble* width, wxDouble* height)
546 {
547 *width = 10000.0;
548 *height = 10000.0;
549 }
550
551 void wxGraphicsContext::GetDPI( wxDouble* dpiX, wxDouble* dpiY)
552 {
553 *dpiX = 72.0;
554 *dpiY = 72.0;
555 }
556
557 // sets the pen
558 void wxGraphicsContext::SetPen( const wxGraphicsPen& pen )
559 {
560 m_pen = pen;
561 }
562
563 void wxGraphicsContext::SetPen( const wxPen& pen )
564 {
565 if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
566 SetPen( wxNullGraphicsPen );
567 else
568 SetPen( CreatePen( pen ) );
569 }
570
571 // sets the brush for filling
572 void wxGraphicsContext::SetBrush( const wxGraphicsBrush& brush )
573 {
574 m_brush = brush;
575 }
576
577 void wxGraphicsContext::SetBrush( const wxBrush& brush )
578 {
579 if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
580 SetBrush( wxNullGraphicsBrush );
581 else
582 SetBrush( CreateBrush( brush ) );
583 }
584
585 // sets the brush for filling
586 void wxGraphicsContext::SetFont( const wxGraphicsFont& font )
587 {
588 m_font = font;
589 }
590
591 bool wxGraphicsContext::SetLogicalFunction( int function )
592 {
593 if ( function == wxCOPY )
594 {
595 m_logicalFunction = function;
596 return true;
597 }
598 return false;
599 }
600
601 void wxGraphicsContext::SetFont( const wxFont& font, const wxColour& colour )
602 {
603 if ( font.Ok() )
604 SetFont( CreateFont( font, colour ) );
605 else
606 SetFont( wxNullGraphicsFont );
607 }
608
609 void wxGraphicsContext::DrawPath( const wxGraphicsPath& path, int fillStyle )
610 {
611 FillPath( path , fillStyle );
612 StrokePath( path );
613 }
614
615 void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle )
616 {
617 Translate(x,y);
618 Rotate( -angle );
619 DrawText( str , 0, 0 );
620 Rotate( angle );
621 Translate(-x,-y);
622 }
623
624 void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, const wxGraphicsBrush& backgroundBrush )
625 {
626 wxGraphicsBrush formerBrush = m_brush;
627 wxGraphicsPen formerPen = m_pen;
628 wxDouble width;
629 wxDouble height;
630 wxDouble descent;
631 wxDouble externalLeading;
632 GetTextExtent( str , &width, &height, &descent, &externalLeading );
633 SetBrush( backgroundBrush );
634 // to make sure our 'OffsetToPixelBoundaries' doesn't move the fill shape
635 SetPen( wxNullGraphicsPen );
636
637 wxGraphicsPath path = CreatePath();
638 path.AddRectangle( x , y, width, height );
639 FillPath( path );
640
641 DrawText( str, x ,y);
642 SetBrush( formerBrush );
643 SetPen( formerPen );
644 }
645
646 void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle, const wxGraphicsBrush& backgroundBrush )
647 {
648 wxGraphicsBrush formerBrush = m_brush;
649 wxGraphicsPen formerPen = m_pen;
650
651 wxDouble width;
652 wxDouble height;
653 wxDouble descent;
654 wxDouble externalLeading;
655 GetTextExtent( str , &width, &height, &descent, &externalLeading );
656 SetBrush( backgroundBrush );
657 // to make sure our 'OffsetToPixelBoundaries' doesn't move the fill shape
658 SetPen( wxNullGraphicsPen );
659
660 wxGraphicsPath path = CreatePath();
661 path.MoveToPoint( x , y );
662 path.AddLineToPoint( (int) (x + sin(angle) * height) , (int) (y + cos(angle) * height) );
663 path.AddLineToPoint(
664 (int) (x + sin(angle) * height + cos(angle) * width) ,
665 (int) (y + cos(angle) * height - sin(angle) * width));
666 path.AddLineToPoint((int) (x + cos(angle) * width) , (int) (y - sin(angle) * width) );
667 FillPath( path );
668 DrawText( str, x ,y, angle);
669 SetBrush( formerBrush );
670 SetPen( formerPen );
671 }
672
673 void wxGraphicsContext::StrokeLine( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2)
674 {
675 wxGraphicsPath path = CreatePath();
676 path.MoveToPoint(x1, y1);
677 path.AddLineToPoint( x2, y2 );
678 StrokePath( path );
679 }
680
681 void wxGraphicsContext::DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
682 {
683 wxGraphicsPath path = CreatePath();
684 path.AddRectangle( x , y , w , h );
685 DrawPath( path );
686 }
687
688 void wxGraphicsContext::DrawEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
689 {
690 wxGraphicsPath path = CreatePath();
691 path.AddEllipse(x,y,w,h);
692 DrawPath(path);
693 }
694
695 void wxGraphicsContext::DrawRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
696 {
697 wxGraphicsPath path = CreatePath();
698 path.AddRoundedRectangle(x,y,w,h,radius);
699 DrawPath(path);
700 }
701
702 void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *points)
703 {
704 wxASSERT(n > 1);
705 wxGraphicsPath path = CreatePath();
706 path.MoveToPoint(points[0].m_x, points[0].m_y);
707 for ( size_t i = 1; i < n; ++i)
708 path.AddLineToPoint( points[i].m_x, points[i].m_y );
709 StrokePath( path );
710 }
711
712 void wxGraphicsContext::DrawLines( size_t n, const wxPoint2DDouble *points, int fillStyle)
713 {
714 wxASSERT(n > 1);
715 wxGraphicsPath path = CreatePath();
716 path.MoveToPoint(points[0].m_x, points[0].m_y);
717 for ( size_t i = 1; i < n; ++i)
718 path.AddLineToPoint( points[i].m_x, points[i].m_y );
719 DrawPath( path , fillStyle);
720 }
721
722 void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *beginPoints, const wxPoint2DDouble *endPoints)
723 {
724 wxASSERT(n > 0);
725 wxGraphicsPath path = CreatePath();
726 for ( size_t i = 0; i < n; ++i)
727 {
728 path.MoveToPoint(beginPoints[i].m_x, beginPoints[i].m_y);
729 path.AddLineToPoint( endPoints[i].m_x, endPoints[i].m_y );
730 }
731 StrokePath( path );
732 }
733
734 // create a 'native' matrix corresponding to these values
735 wxGraphicsMatrix wxGraphicsContext::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
736 wxDouble tx, wxDouble ty) const
737 {
738 return GetRenderer()->CreateMatrix(a,b,c,d,tx,ty);
739 }
740
741 wxGraphicsPath wxGraphicsContext::CreatePath() const
742 {
743 return GetRenderer()->CreatePath();
744 }
745
746 wxGraphicsPen wxGraphicsContext::CreatePen(const wxPen& pen) const
747 {
748 return GetRenderer()->CreatePen(pen);
749 }
750
751 wxGraphicsBrush wxGraphicsContext::CreateBrush(const wxBrush& brush ) const
752 {
753 return GetRenderer()->CreateBrush(brush);
754 }
755
756 // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
757 wxGraphicsBrush wxGraphicsContext::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
758 const wxColour&c1, const wxColour&c2) const
759 {
760 return GetRenderer()->CreateLinearGradientBrush(x1,y1,x2,y2,c1,c2);
761 }
762
763 // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
764 // with radius r and color cColor
765 wxGraphicsBrush wxGraphicsContext::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
766 const wxColour &oColor, const wxColour &cColor) const
767 {
768 return GetRenderer()->CreateRadialGradientBrush(xo,yo,xc,yc,radius,oColor,cColor);
769 }
770
771 // sets the font
772 wxGraphicsFont wxGraphicsContext::CreateFont( const wxFont &font , const wxColour &col ) const
773 {
774 return GetRenderer()->CreateFont(font,col);
775 }
776
777 wxGraphicsContext* wxGraphicsContext::Create( const wxWindowDC& dc)
778 {
779 return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
780 }
781 #ifdef __WXMSW__
782 wxGraphicsContext* wxGraphicsContext::Create( const wxMemoryDC& dc)
783 {
784 return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
785 }
786 #endif
787
788 wxGraphicsContext* wxGraphicsContext::CreateFromNative( void * context )
789 {
790 return wxGraphicsRenderer::GetDefaultRenderer()->CreateContextFromNativeContext(context);
791 }
792
793 wxGraphicsContext* wxGraphicsContext::CreateFromNativeWindow( void * window )
794 {
795 return wxGraphicsRenderer::GetDefaultRenderer()->CreateContextFromNativeWindow(window);
796 }
797
798 wxGraphicsContext* wxGraphicsContext::Create( wxWindow* window )
799 {
800 return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(window);
801 }
802
803 wxGraphicsContext* wxGraphicsContext::Create()
804 {
805 return wxGraphicsRenderer::GetDefaultRenderer()->CreateMeasuringContext();
806 }
807
808 //-----------------------------------------------------------------------------
809 // wxGraphicsRenderer
810 //-----------------------------------------------------------------------------
811
812 IMPLEMENT_ABSTRACT_CLASS(wxGraphicsRenderer, wxObject)
813
814 #endif // wxUSE_GRAPHICS_CONTEXT
wxWidgets (Impactor)