/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/graphcmn.cpp
ViewVC logotype

Annotation of /trunk/3rdparty/wxWidgets/src/common/graphcmn.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (hide annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 4 months ago) by william
File size: 22667 byte(s)
committing r3113 initial commit again...
1 william 31 /////////////////////////////////////////////////////////////////////////////
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: graphcmn.cpp 56801 2008-11-16 23:25:09Z KO $
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     IMPLEMENT_DYNAMIC_CLASS(wxGraphicsBitmap, wxGraphicsObject)
124    
125     WXDLLIMPEXP_DATA_CORE(wxGraphicsPen) wxNullGraphicsPen;
126     WXDLLIMPEXP_DATA_CORE(wxGraphicsBrush) wxNullGraphicsBrush;
127     WXDLLIMPEXP_DATA_CORE(wxGraphicsFont) wxNullGraphicsFont;
128     WXDLLIMPEXP_DATA_CORE(wxGraphicsBitmap) wxNullGraphicsBitmap;
129    
130     //-----------------------------------------------------------------------------
131     // matrix
132     //-----------------------------------------------------------------------------
133    
134     IMPLEMENT_DYNAMIC_CLASS(wxGraphicsMatrix, wxGraphicsObject)
135     WXDLLIMPEXP_DATA_CORE(wxGraphicsMatrix) wxNullGraphicsMatrix;
136    
137     // concatenates the matrix
138     void wxGraphicsMatrix::Concat( const wxGraphicsMatrix *t )
139     {
140     AllocExclusive();
141     GetMatrixData()->Concat(t->GetMatrixData());
142     }
143    
144     // sets the matrix to the respective values
145     void wxGraphicsMatrix::Set(wxDouble a, wxDouble b, wxDouble c, wxDouble d,
146     wxDouble tx, wxDouble ty)
147     {
148     AllocExclusive();
149     GetMatrixData()->Set(a,b,c,d,tx,ty);
150     }
151    
152     // gets the component valuess of the matrix
153     void wxGraphicsMatrix::Get(wxDouble* a, wxDouble* b, wxDouble* c,
154     wxDouble* d, wxDouble* tx, wxDouble* ty) const
155     {
156     GetMatrixData()->Get(a, b, c, d, tx, ty);
157     }
158    
159     // makes this the inverse matrix
160     void wxGraphicsMatrix::Invert()
161     {
162     AllocExclusive();
163     GetMatrixData()->Invert();
164     }
165    
166     // returns true if the elements of the transformation matrix are equal ?
167     bool wxGraphicsMatrix::IsEqual( const wxGraphicsMatrix* t) const
168     {
169     return GetMatrixData()->IsEqual(t->GetMatrixData());
170     }
171    
172     // return true if this is the identity matrix
173     bool wxGraphicsMatrix::IsIdentity() const
174     {
175     return GetMatrixData()->IsIdentity();
176     }
177    
178     // add the translation to this matrix
179     void wxGraphicsMatrix::Translate( wxDouble dx , wxDouble dy )
180     {
181     AllocExclusive();
182     GetMatrixData()->Translate(dx,dy);
183     }
184    
185     // add the scale to this matrix
186     void wxGraphicsMatrix::Scale( wxDouble xScale , wxDouble yScale )
187     {
188     AllocExclusive();
189     GetMatrixData()->Scale(xScale,yScale);
190     }
191    
192     // add the rotation to this matrix (radians)
193     void wxGraphicsMatrix::Rotate( wxDouble angle )
194     {
195     AllocExclusive();
196     GetMatrixData()->Rotate(angle);
197     }
198    
199     //
200     // apply the transforms
201     //
202    
203     // applies that matrix to the point
204     void wxGraphicsMatrix::TransformPoint( wxDouble *x, wxDouble *y ) const
205     {
206     GetMatrixData()->TransformPoint(x,y);
207     }
208    
209     // applies the matrix except for translations
210     void wxGraphicsMatrix::TransformDistance( wxDouble *dx, wxDouble *dy ) const
211     {
212     GetMatrixData()->TransformDistance(dx,dy);
213     }
214    
215     // returns the native representation
216     void * wxGraphicsMatrix::GetNativeMatrix() const
217     {
218     return GetMatrixData()->GetNativeMatrix();
219     }
220    
221     //-----------------------------------------------------------------------------
222     // path
223     //-----------------------------------------------------------------------------
224    
225     IMPLEMENT_DYNAMIC_CLASS(wxGraphicsPath, wxGraphicsObject)
226     WXDLLIMPEXP_DATA_CORE(wxGraphicsPath) wxNullGraphicsPath;
227    
228     // convenience functions, for using wxPoint2DDouble etc
229    
230     wxPoint2DDouble wxGraphicsPath::GetCurrentPoint() const
231     {
232     wxDouble x,y;
233     GetCurrentPoint(&x,&y);
234     return wxPoint2DDouble(x,y);
235     }
236    
237     void wxGraphicsPath::MoveToPoint( const wxPoint2DDouble& p)
238     {
239     MoveToPoint( p.m_x , p.m_y);
240     }
241    
242     void wxGraphicsPath::AddLineToPoint( const wxPoint2DDouble& p)
243     {
244     AddLineToPoint( p.m_x , p.m_y);
245     }
246    
247     void wxGraphicsPath::AddCurveToPoint( const wxPoint2DDouble& c1, const wxPoint2DDouble& c2, const wxPoint2DDouble& e)
248     {
249     AddCurveToPoint(c1.m_x, c1.m_y, c2.m_x, c2.m_y, e.m_x, e.m_y);
250     }
251    
252     void wxGraphicsPath::AddArc( const wxPoint2DDouble& c, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise)
253     {
254     AddArc(c.m_x, c.m_y, r, startAngle, endAngle, clockwise);
255     }
256    
257     wxRect2DDouble wxGraphicsPath::GetBox() const
258     {
259     wxDouble x,y,w,h;
260     GetBox(&x,&y,&w,&h);
261     return wxRect2DDouble( x,y,w,h );
262     }
263    
264     bool wxGraphicsPath::Contains( const wxPoint2DDouble& c, int fillStyle ) const
265     {
266     return Contains( c.m_x, c.m_y, fillStyle);
267     }
268    
269     // true redirections
270    
271     // begins a new subpath at (x,y)
272     void wxGraphicsPath::MoveToPoint( wxDouble x, wxDouble y )
273     {
274     AllocExclusive();
275     GetPathData()->MoveToPoint(x,y);
276     }
277    
278     // adds a straight line from the current point to (x,y)
279     void wxGraphicsPath::AddLineToPoint( wxDouble x, wxDouble y )
280     {
281     AllocExclusive();
282     GetPathData()->AddLineToPoint(x,y);
283     }
284    
285     // adds a cubic Bezier curve from the current point, using two control points and an end point
286     void wxGraphicsPath::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
287     {
288     AllocExclusive();
289     GetPathData()->AddCurveToPoint(cx1,cy1,cx2,cy2,x,y);
290     }
291    
292     // adds another path
293     void wxGraphicsPath::AddPath( const wxGraphicsPath& path )
294     {
295     AllocExclusive();
296     GetPathData()->AddPath(path.GetPathData());
297     }
298    
299     // closes the current sub-path
300     void wxGraphicsPath::CloseSubpath()
301     {
302     AllocExclusive();
303     GetPathData()->CloseSubpath();
304     }
305    
306     // gets the last point of the current path, (0,0) if not yet set
307     void wxGraphicsPath::GetCurrentPoint( wxDouble* x, wxDouble* y) const
308     {
309     GetPathData()->GetCurrentPoint(x,y);
310     }
311    
312     // adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
313     void wxGraphicsPath::AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise )
314     {
315     AllocExclusive();
316     GetPathData()->AddArc(x,y,r,startAngle,endAngle,clockwise);
317     }
318    
319     //
320     // These are convenience functions which - if not available natively will be assembled
321     // using the primitives from above
322     //
323    
324     // adds a quadratic Bezier curve from the current point, using a control point and an end point
325     void wxGraphicsPath::AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y )
326     {
327     AllocExclusive();
328     GetPathData()->AddQuadCurveToPoint(cx,cy,x,y);
329     }
330    
331     // appends a rectangle as a new closed subpath
332     void wxGraphicsPath::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
333     {
334     AllocExclusive();
335     GetPathData()->AddRectangle(x,y,w,h);
336     }
337    
338     // appends an ellipsis as a new closed subpath fitting the passed rectangle
339     void wxGraphicsPath::AddCircle( wxDouble x, wxDouble y, wxDouble r )
340     {
341     AllocExclusive();
342     GetPathData()->AddCircle(x,y,r);
343     }
344    
345     // 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)
346     void wxGraphicsPath::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
347     {
348     GetPathData()->AddArcToPoint(x1,y1,x2,y2,r);
349     }
350    
351     // appends an ellipse
352     void wxGraphicsPath::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
353     {
354     AllocExclusive();
355     GetPathData()->AddEllipse(x,y,w,h);
356     }
357    
358     // appends a rounded rectangle
359     void wxGraphicsPath::AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
360     {
361     AllocExclusive();
362     GetPathData()->AddRoundedRectangle(x,y,w,h,radius);
363     }
364    
365     // returns the native path
366     void * wxGraphicsPath::GetNativePath() const
367     {
368     return GetPathData()->GetNativePath();
369     }
370    
371     // give the native path returned by GetNativePath() back (there might be some deallocations necessary)
372     void wxGraphicsPath::UnGetNativePath(void *p)const
373     {
374     GetPathData()->UnGetNativePath(p);
375     }
376    
377     // transforms each point of this path by the matrix
378     void wxGraphicsPath::Transform( const wxGraphicsMatrix& matrix )
379     {
380     AllocExclusive();
381     GetPathData()->Transform(matrix.GetMatrixData());
382     }
383    
384     // gets the bounding box enclosing all points (possibly including control points)
385     void wxGraphicsPath::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
386     {
387     GetPathData()->GetBox(x,y,w,h);
388     }
389    
390     bool wxGraphicsPath::Contains( wxDouble x, wxDouble y, int fillStyle ) const
391     {
392     return GetPathData()->Contains(x,y,fillStyle);
393     }
394    
395     //
396     // Emulations, these mus be implemented in the ...Data classes in order to allow for proper overrides
397     //
398    
399     void wxGraphicsPathData::AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y )
400     {
401     // calculate using degree elevation to a cubic bezier
402     wxPoint2DDouble c1;
403     wxPoint2DDouble c2;
404    
405     wxPoint2DDouble start;
406     GetCurrentPoint(&start.m_x,&start.m_y);
407     wxPoint2DDouble end(x,y);
408     wxPoint2DDouble c(cx,cy);
409     c1 = wxDouble(1/3.0) * start + wxDouble(2/3.0) * c;
410     c2 = wxDouble(2/3.0) * c + wxDouble(1/3.0) * end;
411     AddCurveToPoint(c1.m_x,c1.m_y,c2.m_x,c2.m_y,x,y);
412     }
413    
414     void wxGraphicsPathData::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
415     {
416     MoveToPoint(x,y);
417     AddLineToPoint(x,y+h);
418     AddLineToPoint(x+w,y+h);
419     AddLineToPoint(x+w,y);
420     CloseSubpath();
421     }
422    
423     void wxGraphicsPathData::AddCircle( wxDouble x, wxDouble y, wxDouble r )
424     {
425     MoveToPoint(x+r,y);
426     AddArc( x,y,r,0,2*M_PI,false);
427     CloseSubpath();
428     }
429    
430     void wxGraphicsPathData::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
431     {
432     wxDouble rw = w/2;
433     wxDouble rh = h/2;
434     wxDouble xc = x + rw;
435     wxDouble yc = y + rh;
436     wxGraphicsMatrix m = GetRenderer()->CreateMatrix();
437     m.Translate(xc,yc);
438     m.Scale(rw/rh,1.0);
439     wxGraphicsPath p = GetRenderer()->CreatePath();
440     p.AddCircle(0,0,rh);
441     p.Transform(m);
442     AddPath(p.GetPathData());
443     }
444    
445     void wxGraphicsPathData::AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
446     {
447     if ( radius == 0 )
448     AddRectangle(x,y,w,h);
449     else
450     {
451     MoveToPoint( x + w, y + h / 2);
452     AddArcToPoint(x + w, y + h, x + w / 2, y + h, radius);
453     AddArcToPoint(x, y + h, x, y + h / 2, radius);
454     AddArcToPoint(x, y , x + w / 2, y, radius);
455     AddArcToPoint(x + w, y, x + w, y + h / 2, radius);
456     CloseSubpath();
457     }
458     }
459    
460     // 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)
461     void wxGraphicsPathData::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
462     {
463     wxPoint2DDouble current;
464     GetCurrentPoint(&current.m_x,&current.m_y);
465     wxPoint2DDouble p1(x1,y1);
466     wxPoint2DDouble p2(x2,y2);
467    
468     wxPoint2DDouble v1 = current - p1;
469     v1.Normalize();
470     wxPoint2DDouble v2 = p2 - p1;
471     v2.Normalize();
472    
473     wxDouble alpha = v1.GetVectorAngle() - v2.GetVectorAngle();
474    
475     if ( alpha < 0 )
476     alpha = 360 + alpha;
477     // TODO obtuse angles
478    
479     alpha = DegToRad(alpha);
480    
481     wxDouble dist = r / sin(alpha/2) * cos(alpha/2);
482     // calculate tangential points
483     wxPoint2DDouble t1 = dist*v1 + p1;
484     wxPoint2DDouble t2 = dist*v2 + p1;
485    
486     wxPoint2DDouble nv1 = v1;
487     nv1.SetVectorAngle(v1.GetVectorAngle()-90);
488     wxPoint2DDouble c = t1 + r*nv1;
489    
490     wxDouble a1 = v1.GetVectorAngle()+90;
491     wxDouble a2 = v2.GetVectorAngle()-90;
492    
493     AddLineToPoint(t1.m_x,t1.m_y);
494     AddArc(c.m_x,c.m_y,r,DegToRad(a1),DegToRad(a2),true);
495     AddLineToPoint(p2.m_x,p2.m_y);
496     }
497    
498     //-----------------------------------------------------------------------------
499     // wxGraphicsContext Convenience Methods
500     //-----------------------------------------------------------------------------
501    
502     IMPLEMENT_ABSTRACT_CLASS(wxGraphicsContext, wxObject)
503    
504    
505     wxGraphicsContext::wxGraphicsContext(wxGraphicsRenderer* renderer) : wxGraphicsObject(renderer)
506     {
507     m_logicalFunction = wxCOPY;
508     }
509    
510     wxGraphicsContext::~wxGraphicsContext()
511     {
512     }
513    
514     // sets the pen
515     void wxGraphicsContext::SetPen( const wxGraphicsPen& pen )
516     {
517     m_pen = pen;
518     }
519    
520     void wxGraphicsContext::SetPen( const wxPen& pen )
521     {
522     if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
523     SetPen( wxNullGraphicsPen );
524     else
525     SetPen( CreatePen( pen ) );
526     }
527    
528     // sets the brush for filling
529     void wxGraphicsContext::SetBrush( const wxGraphicsBrush& brush )
530     {
531     m_brush = brush;
532     }
533    
534     void wxGraphicsContext::SetBrush( const wxBrush& brush )
535     {
536     if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
537     SetBrush( wxNullGraphicsBrush );
538     else
539     SetBrush( CreateBrush( brush ) );
540     }
541    
542     // sets the brush for filling
543     void wxGraphicsContext::SetFont( const wxGraphicsFont& font )
544     {
545     m_font = font;
546     }
547    
548     bool wxGraphicsContext::SetLogicalFunction( int function )
549     {
550     if ( function == wxCOPY )
551     {
552     m_logicalFunction = function;
553     return true;
554     }
555     return false;
556     }
557    
558     void wxGraphicsContext::SetFont( const wxFont& font, const wxColour& colour )
559     {
560     if ( font.Ok() )
561     SetFont( CreateFont( font, colour ) );
562     else
563     SetFont( wxNullGraphicsFont );
564     }
565    
566     void wxGraphicsContext::DrawPath( const wxGraphicsPath& path, int fillStyle )
567     {
568     FillPath( path , fillStyle );
569     StrokePath( path );
570     }
571    
572     void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle )
573     {
574     Translate(x,y);
575     Rotate( -angle );
576     DrawText( str , 0, 0 );
577     Rotate( angle );
578     Translate(-x,-y);
579     }
580    
581     void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, const wxGraphicsBrush& backgroundBrush )
582     {
583     wxGraphicsBrush formerBrush = m_brush;
584     wxGraphicsPen formerPen = m_pen;
585     wxDouble width;
586     wxDouble height;
587     wxDouble descent;
588     wxDouble externalLeading;
589     GetTextExtent( str , &width, &height, &descent, &externalLeading );
590     SetBrush( backgroundBrush );
591     // to make sure our 'OffsetToPixelBoundaries' doesn't move the fill shape
592     SetPen( wxNullGraphicsPen );
593    
594     wxGraphicsPath path = CreatePath();
595     path.AddRectangle( x , y, width, height );
596     FillPath( path );
597    
598     DrawText( str, x ,y);
599     SetBrush( formerBrush );
600     SetPen( formerPen );
601     }
602    
603     void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle, const wxGraphicsBrush& backgroundBrush )
604     {
605     wxGraphicsBrush formerBrush = m_brush;
606     wxGraphicsPen formerPen = m_pen;
607    
608     wxDouble width;
609     wxDouble height;
610     wxDouble descent;
611     wxDouble externalLeading;
612     GetTextExtent( str , &width, &height, &descent, &externalLeading );
613     SetBrush( backgroundBrush );
614     // to make sure our 'OffsetToPixelBoundaries' doesn't move the fill shape
615     SetPen( wxNullGraphicsPen );
616    
617     wxGraphicsPath path = CreatePath();
618     path.MoveToPoint( x , y );
619     path.AddLineToPoint( (int) (x + sin(angle) * height) , (int) (y + cos(angle) * height) );
620     path.AddLineToPoint(
621     (int) (x + sin(angle) * height + cos(angle) * width) ,
622     (int) (y + cos(angle) * height - sin(angle) * width));
623     path.AddLineToPoint((int) (x + cos(angle) * width) , (int) (y - sin(angle) * width) );
624     FillPath( path );
625     DrawText( str, x ,y, angle);
626     SetBrush( formerBrush );
627     SetPen( formerPen );
628     }
629    
630     void wxGraphicsContext::StrokeLine( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2)
631     {
632     wxGraphicsPath path = CreatePath();
633     path.MoveToPoint(x1, y1);
634     path.AddLineToPoint( x2, y2 );
635     StrokePath( path );
636     }
637    
638     void wxGraphicsContext::DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
639     {
640     wxGraphicsPath path = CreatePath();
641     path.AddRectangle( x , y , w , h );
642     DrawPath( path );
643     }
644    
645     void wxGraphicsContext::DrawEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
646     {
647     wxGraphicsPath path = CreatePath();
648     path.AddEllipse(x,y,w,h);
649     DrawPath(path);
650     }
651    
652     void wxGraphicsContext::DrawRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
653     {
654     wxGraphicsPath path = CreatePath();
655     path.AddRoundedRectangle(x,y,w,h,radius);
656     DrawPath(path);
657     }
658    
659     void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *points)
660     {
661     wxASSERT(n > 1);
662     wxGraphicsPath path = CreatePath();
663     path.MoveToPoint(points[0].m_x, points[0].m_y);
664     for ( size_t i = 1; i < n; ++i)
665     path.AddLineToPoint( points[i].m_x, points[i].m_y );
666     StrokePath( path );
667     }
668    
669     void wxGraphicsContext::DrawLines( size_t n, const wxPoint2DDouble *points, int fillStyle)
670     {
671     wxASSERT(n > 1);
672     wxGraphicsPath path = CreatePath();
673     path.MoveToPoint(points[0].m_x, points[0].m_y);
674     for ( size_t i = 1; i < n; ++i)
675     path.AddLineToPoint( points[i].m_x, points[i].m_y );
676     DrawPath( path , fillStyle);
677     }
678    
679     void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *beginPoints, const wxPoint2DDouble *endPoints)
680     {
681     wxASSERT(n > 0);
682     wxGraphicsPath path = CreatePath();
683     for ( size_t i = 0; i < n; ++i)
684     {
685     path.MoveToPoint(beginPoints[i].m_x, beginPoints[i].m_y);
686     path.AddLineToPoint( endPoints[i].m_x, endPoints[i].m_y );
687     }
688     StrokePath( path );
689     }
690    
691     // create a 'native' matrix corresponding to these values
692     wxGraphicsMatrix wxGraphicsContext::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
693     wxDouble tx, wxDouble ty) const
694     {
695     return GetRenderer()->CreateMatrix(a,b,c,d,tx,ty);
696     }
697    
698     wxGraphicsPath wxGraphicsContext::CreatePath() const
699     {
700     return GetRenderer()->CreatePath();
701     }
702    
703     wxGraphicsPen wxGraphicsContext::CreatePen(const wxPen& pen) const
704     {
705     return GetRenderer()->CreatePen(pen);
706     }
707    
708     wxGraphicsBrush wxGraphicsContext::CreateBrush(const wxBrush& brush ) const
709     {
710     return GetRenderer()->CreateBrush(brush);
711     }
712    
713     // sets the brush to a linear gradient, starting at (x1,y1) with color c1 to (x2,y2) with color c2
714     wxGraphicsBrush wxGraphicsContext::CreateLinearGradientBrush( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2,
715     const wxColour&c1, const wxColour&c2) const
716     {
717     return GetRenderer()->CreateLinearGradientBrush(x1,y1,x2,y2,c1,c2);
718     }
719    
720     // sets the brush to a radial gradient originating at (xo,yc) with color oColor and ends on a circle around (xc,yc)
721     // with radius r and color cColor
722     wxGraphicsBrush wxGraphicsContext::CreateRadialGradientBrush( wxDouble xo, wxDouble yo, wxDouble xc, wxDouble yc, wxDouble radius,
723     const wxColour &oColor, const wxColour &cColor) const
724     {
725     return GetRenderer()->CreateRadialGradientBrush(xo,yo,xc,yc,radius,oColor,cColor);
726     }
727    
728     // sets the font
729     wxGraphicsFont wxGraphicsContext::CreateFont( const wxFont &font , const wxColour &col ) const
730     {
731     return GetRenderer()->CreateFont(font,col);
732     }
733    
734     wxGraphicsBitmap wxGraphicsContext::CreateBitmap( const wxBitmap& bmp ) const
735     {
736     return GetRenderer()->CreateBitmap(bmp);
737     }
738    
739     wxGraphicsContext* wxGraphicsContext::Create( const wxWindowDC& dc)
740     {
741     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
742     }
743     #ifdef __WXMSW__
744     wxGraphicsContext* wxGraphicsContext::Create( const wxMemoryDC& dc)
745     {
746     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
747     }
748     #endif
749    
750     wxGraphicsContext* wxGraphicsContext::CreateFromNative( void * context )
751     {
752     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContextFromNativeContext(context);
753     }
754    
755     wxGraphicsContext* wxGraphicsContext::CreateFromNativeWindow( void * window )
756     {
757     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContextFromNativeWindow(window);
758     }
759    
760     wxGraphicsContext* wxGraphicsContext::Create( wxWindow* window )
761     {
762     return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(window);
763     }
764    
765     wxGraphicsContext* wxGraphicsContext::Create()
766     {
767     return wxGraphicsRenderer::GetDefaultRenderer()->CreateMeasuringContext();
768     }
769    
770     //-----------------------------------------------------------------------------
771     // wxGraphicsRenderer
772     //-----------------------------------------------------------------------------
773    
774     IMPLEMENT_ABSTRACT_CLASS(wxGraphicsRenderer, wxObject)
775    
776     #endif // wxUSE_GRAPHICS_CONTEXT

  ViewVC Help
Powered by ViewVC 1.1.22