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