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