]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/graphcmn.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
use common bottleneck
[wxWidgets.git] / src / common / graphcmn.cpp
diff --git a/src/common/graphcmn.cpp b/src/common/graphcmn.cpp
index 380209a6081eb27b54162a0292aee4bd30f6ff22..9a75c2bf7167ca202accd9ace860a9c5a5915e95 100644 (file)
--- a/src/common/graphcmn.cpp
+++ b/src/common/graphcmn.cpp
@@ -3,7 +3,7 @@
 // Purpose:     graphics context methods common to all platforms
 // Author:      Stefan Csomor
 // Modified by:
 // Purpose:     graphics context methods common to all platforms
 // Author:      Stefan Csomor
 // Modified by:
-// Created:     
+// Created:
 // RCS-ID:      $Id$
 // Copyright:   (c) Stefan Csomor
 // Licence:     wxWindows licence
 // RCS-ID:      $Id$
 // Copyright:   (c) Stefan Csomor
 // Licence:     wxWindows licence
@@ -25,17 +25,10 @@
     #include "wx/bitmap.h"
     #include "wx/dcmemory.h"
     #include "wx/region.h"
     #include "wx/bitmap.h"
     #include "wx/dcmemory.h"
     #include "wx/region.h"
+    #include "wx/log.h"
 #endif
 
 #endif
 
-#if !defined(wxMAC_USE_CORE_GRAPHICS_BLEND_MODES)
-#define wxMAC_USE_CORE_GRAPHICS_BLEND_MODES 0
-#endif
-
-//-----------------------------------------------------------------------------
-// constants
-//-----------------------------------------------------------------------------
-
-static const double RAD2DEG = 180.0 / M_PI;
+#include "wx/private/graphics.h"
 
 //-----------------------------------------------------------------------------
 // Local functions
 
 //-----------------------------------------------------------------------------
 // Local functions
@@ -48,1321 +41,895 @@ static inline double DegToRad(double deg)
 
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 
-wxPoint2DDouble wxGraphicsPath::GetCurrentPoint()
+//-----------------------------------------------------------------------------
+// wxGraphicsObject
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxGraphicsObject, wxObject)
+
+wxGraphicsObjectRefData::wxGraphicsObjectRefData( wxGraphicsRenderer* renderer )
 {
 {
-    wxDouble x,y ;
-    GetCurrentPoint(x,y);
-    return wxPoint2DDouble(x,y);
+    m_renderer = renderer;
 }
 }
-
-void wxGraphicsPath::MoveToPoint( const wxPoint2DDouble& p)
+wxGraphicsObjectRefData::wxGraphicsObjectRefData( const wxGraphicsObjectRefData* data )
 {
 {
-    MoveToPoint( p.m_x , p.m_y);
+    m_renderer = data->m_renderer;
 }
 }
-
-void wxGraphicsPath::AddLineToPoint( const wxPoint2DDouble& p)
+wxGraphicsRenderer* wxGraphicsObjectRefData::GetRenderer() const
 {
 {
-    AddLineToPoint( p.m_x , p.m_y);
+    return m_renderer ;
 }
 
 }
 
-void wxGraphicsPath::AddCurveToPoint( const wxPoint2DDouble& c1, const wxPoint2DDouble& c2, const wxPoint2DDouble& e)
+wxGraphicsObjectRefData* wxGraphicsObjectRefData::Clone() const
 {
 {
-    AddCurveToPoint(c1.m_x, c1.m_y, c2.m_x, c2.m_y, e.m_x, e.m_y);
+    return new wxGraphicsObjectRefData(this);
 }
 
 }
 
-void wxGraphicsPath::AddArc( const wxPoint2DDouble& c, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise)
+wxGraphicsObject::wxGraphicsObject()
 {
 {
-    AddArc(c.m_x, c.m_y, r, startAngle, endAngle, clockwise);
 }
 
 }
 
-//
-// Emulations
-//
-
-void wxGraphicsPath::AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y )
+wxGraphicsObject::wxGraphicsObject( wxGraphicsRenderer* renderer )
 {
 {
-    // calculate using degree elevation to a cubic bezier
-    wxPoint2DDouble c1 ;
-    wxPoint2DDouble c2 ;
-
-    wxPoint2DDouble start = GetCurrentPoint() ;
-    wxPoint2DDouble end(x,y);
-    wxPoint2DDouble c(cx,cy);
-    c1 = wxDouble(1/3.0) * start + wxDouble(2/3.0) * c;
-    c2 = wxDouble(2/3.0) * c + wxDouble(1/3.0) * end ;
-    AddCurveToPoint(c1.m_x,c1.m_y,c2.m_x,c2.m_y,x,y);
+    SetRefData( new wxGraphicsObjectRefData(renderer));
 }
 
 }
 
-void wxGraphicsPath::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
+wxGraphicsObject::~wxGraphicsObject()
 {
 {
-    MoveToPoint(x,y);
-    AddLineToPoint(x,y+h);
-    AddLineToPoint(x+w,y+h);
-    AddLineToPoint(x+w,y);
-    CloseSubpath();
 }
 
 }
 
-void wxGraphicsPath::AddCircle( wxDouble x, wxDouble y, wxDouble r )
+bool wxGraphicsObject::IsNull() const
 {
 {
-    MoveToPoint(x+r,y);
-    AddArc( x,y,r,0,2*M_PI,false);
-    CloseSubpath();
+    return m_refData == NULL;
 }
 
 }
 
-// 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)
-void wxGraphicsPath::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
-{   
-    wxPoint2DDouble current = GetCurrentPoint();
-    wxPoint2DDouble p1(x1,y1);
-    wxPoint2DDouble p2(x2,y2);
-
-    wxPoint2DDouble v1 = current - p1 ;
-    v1.Normalize();
-    wxPoint2DDouble v2 = p2 - p1 ;
-    v2.Normalize();
-
-    wxDouble alpha = v1.GetVectorAngle() - v2.GetVectorAngle();
+wxGraphicsRenderer* wxGraphicsObject::GetRenderer() const
+{
+    return ( IsNull() ? NULL : GetGraphicsData()->GetRenderer() );
+}
 
 
-    if ( alpha < 0 )
-        alpha = 360 + alpha ;
-    // TODO obtuse angles
+wxGraphicsObjectRefData* wxGraphicsObject::GetGraphicsData() const
+{
+    return (wxGraphicsObjectRefData*) m_refData;
+}
 
 
-    alpha = DegToRad(alpha);
+wxObjectRefData* wxGraphicsObject::CreateRefData() const
+{
+    wxLogDebug(wxT("A Null Object cannot be changed"));
+    return NULL;
+}
 
 
-    wxDouble dist = r / sin(alpha/2) * cos(alpha/2) ;
-    // calculate tangential points
-    wxPoint2DDouble t1 = dist*v1 + p1 ;
-    wxPoint2DDouble t2 = dist*v2 + p1 ;
+wxObjectRefData* wxGraphicsObject::CloneRefData(const wxObjectRefData* data) const
+{
+    const wxGraphicsObjectRefData* ptr = (const wxGraphicsObjectRefData*) data;
+    return ptr->Clone();
+}
 
 
-    wxPoint2DDouble nv1 = v1 ;
-    nv1.SetVectorAngle(v1.GetVectorAngle()-90);
-    wxPoint2DDouble c = t1 + r*nv1;
+//-----------------------------------------------------------------------------
+// pens etc.
+//-----------------------------------------------------------------------------
 
 
-    wxDouble a1 = v1.GetVectorAngle()+90 ;
-    wxDouble a2 = v2.GetVectorAngle()-90 ;
+IMPLEMENT_DYNAMIC_CLASS(wxGraphicsPen, wxGraphicsObject)
+IMPLEMENT_DYNAMIC_CLASS(wxGraphicsBrush, wxGraphicsObject)
+IMPLEMENT_DYNAMIC_CLASS(wxGraphicsFont, wxGraphicsObject)
+IMPLEMENT_DYNAMIC_CLASS(wxGraphicsBitmap, wxGraphicsObject)
 
 
-    AddLineToPoint(t1);
-    AddArc(c.m_x,c.m_y,r,DegToRad(a1),DegToRad(a2),true);
-    AddLineToPoint(p2);
-}
+WXDLLIMPEXP_DATA_CORE(wxGraphicsPen) wxNullGraphicsPen;
+WXDLLIMPEXP_DATA_CORE(wxGraphicsBrush) wxNullGraphicsBrush;
+WXDLLIMPEXP_DATA_CORE(wxGraphicsFont) wxNullGraphicsFont;
+WXDLLIMPEXP_DATA_CORE(wxGraphicsBitmap) wxNullGraphicsBitmap;
 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
-// wxGraphicsContext Convenience Methods
+// matrix
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 
-void wxGraphicsContext::DrawPath( const wxGraphicsPath *path, int fillStyle )
+IMPLEMENT_DYNAMIC_CLASS(wxGraphicsMatrix, wxGraphicsObject)
+WXDLLIMPEXP_DATA_CORE(wxGraphicsMatrix) wxNullGraphicsMatrix;
+
+// concatenates the matrix
+void wxGraphicsMatrix::Concat( const wxGraphicsMatrix *t )
 {
 {
-    FillPath( path , fillStyle );
-    StrokePath( path );
+    AllocExclusive();
+    GetMatrixData()->Concat(t->GetMatrixData());
 }
 
 }
 
-void wxGraphicsContext::DrawText( const wxString &str, wxDouble x, wxDouble y, wxDouble angle )
+// sets the matrix to the respective values
+void wxGraphicsMatrix::Set(wxDouble a, wxDouble b, wxDouble c, wxDouble d,
+                           wxDouble tx, wxDouble ty)
 {
 {
-    Translate(x,y) ;
-    Rotate( -angle );
-    DrawText( str , 0, 0 );
-    Rotate( angle );
-    Translate(-x,-y) ;
+    AllocExclusive();
+    GetMatrixData()->Set(a,b,c,d,tx,ty);
 }
 
 }
 
-void wxGraphicsContext::StrokeLine( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2)
+// gets the component valuess of the matrix
+void wxGraphicsMatrix::Get(wxDouble* a, wxDouble* b,  wxDouble* c,
+                           wxDouble* d, wxDouble* tx, wxDouble* ty) const
 {
 {
-    wxGraphicsPath* path = CreatePath();
-    path->MoveToPoint(x1, y1) ;
-    path->AddLineToPoint( x2, y2 );
-    StrokePath( path );
-    delete path;
+    GetMatrixData()->Get(a, b, c, d, tx, ty);
 }
 
 }
 
-void wxGraphicsContext::DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
+// makes this the inverse matrix
+void wxGraphicsMatrix::Invert()
 {
 {
-    wxGraphicsPath* path = CreatePath();
-    path->AddRectangle( x , y , w , h );
-    DrawPath( path );
-    delete path;
+    AllocExclusive();
+    GetMatrixData()->Invert();
 }
 
 }
 
-void wxGraphicsContext::DrawEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
+// returns true if the elements of the transformation matrix are equal ?
+bool wxGraphicsMatrix::IsEqual( const wxGraphicsMatrix* t) const
 {
 {
-    wxGraphicsPath* path = CreatePath();
-    if ( w == h )
-    {
-        path->AddCircle( x+w/2,y+w/2,w/2);
-        DrawPath(path);
-    }
-    else
-    {
-        PushState();
-        Translate(x+w/2,y+h/2);
-        wxDouble factor = ((wxDouble) w) / h ;
-        Scale( factor , 1.0) ;
-        path->AddCircle(0,0,h/2);
-        DrawPath(path);
-        PopState();
-    }
-    delete path;
+    return GetMatrixData()->IsEqual(t->GetMatrixData());
 }
 
 }
 
-void wxGraphicsContext::DrawRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
+// return true if this is the identity matrix
+bool wxGraphicsMatrix::IsIdentity() const
 {
 {
-    wxGraphicsPath* path = CreatePath();
-    if ( radius == 0)
-    {
-        path->AddRectangle( x , y , w , h );
-        DrawPath( path );
-    }
-    else
-    {
-        PushState();
-        Translate( x , y );
-
-        path->MoveToPoint(w, h / 2);
-        path->AddArcToPoint(w, h, w / 2, h, radius);
-        path->AddArcToPoint(0, h, 0, h / 2, radius);
-        path->AddArcToPoint(0, 0, w / 2, 0, radius);
-        path->AddArcToPoint(w, 0, w, h / 2, radius);
-        path->CloseSubpath();
-        DrawPath( path );
-        PopState();
-    }
-    delete path;
+    return GetMatrixData()->IsIdentity();
 }
 
 }
 
-void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *points)
+// add the translation to this matrix
+void wxGraphicsMatrix::Translate( wxDouble dx , wxDouble dy )
 {
 {
-    wxASSERT(n > 1);
-    wxGraphicsPath* path = CreatePath();
-    path->MoveToPoint(points[0].m_x, points[0].m_y) ;
-    for ( size_t i = 1 ; i < n; ++i)
-        path->AddLineToPoint( points[i].m_x, points[i].m_y );
-    StrokePath( path );
-    delete path;
+    AllocExclusive();
+    GetMatrixData()->Translate(dx,dy);
 }
 
 }
 
-void wxGraphicsContext::DrawLines( size_t n, const wxPoint2DDouble *points, int fillStyle)
+// add the scale to this matrix
+void wxGraphicsMatrix::Scale( wxDouble xScale , wxDouble yScale )
 {
 {
-    wxASSERT(n > 1);
-    wxGraphicsPath* path = CreatePath();
-    path->MoveToPoint(points[0].m_x, points[0].m_y) ;
-    for ( size_t i = 1 ; i < n; ++i)
-        path->AddLineToPoint( points[i].m_x, points[i].m_y );
-    DrawPath( path , fillStyle);
-    delete path;
+    AllocExclusive();
+    GetMatrixData()->Scale(xScale,yScale);
 }
 
 }
 
-void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *beginPoints, const wxPoint2DDouble *endPoints)
+// add the rotation to this matrix (radians)
+void wxGraphicsMatrix::Rotate( wxDouble angle )
 {
 {
-    wxASSERT(n > 0);
-    wxGraphicsPath* path = CreatePath();
-    for ( size_t i = 0 ; i < n; ++i)
-    {
-        path->MoveToPoint(beginPoints[i].m_x, beginPoints[i].m_y) ;
-        path->AddLineToPoint( endPoints[i].m_x, endPoints[i].m_y );
-    }
-    StrokePath( path );
-    delete path;
+    AllocExclusive();
+    GetMatrixData()->Rotate(angle);
 }
 
 }
 
-IMPLEMENT_ABSTRACT_CLASS(wxGCDC, wxObject)
-
-//-----------------------------------------------------------------------------
-// wxDC bridge class
-//-----------------------------------------------------------------------------
+//
+// apply the transforms
+//
 
 
-wxGCDC::wxGCDC()
+// applies that matrix to the point
+void wxGraphicsMatrix::TransformPoint( wxDouble *x, wxDouble *y ) const
 {
 {
-    Init();
+    GetMatrixData()->TransformPoint(x,y);
 }
 
 }
 
-
-wxGCDC::wxGCDC(const wxWindowDC& dc)
+// applies the matrix except for translations
+void wxGraphicsMatrix::TransformDistance( wxDouble *dx, wxDouble *dy ) const
 {
 {
-    Init();
-    m_graphicContext = wxGraphicsContext::Create(dc);
-    m_ok = true;
-    if ( dc.GetFont().Ok())
-        m_graphicContext->SetFont(dc.GetFont());
-    if ( dc.GetPen().Ok())
-        m_graphicContext->SetPen(dc.GetPen());
-    if ( dc.GetBrush().Ok())
-        m_graphicContext->SetBrush(dc.GetBrush());
-    m_graphicContext->SetTextColor(dc.GetTextForeground());
+    GetMatrixData()->TransformDistance(dx,dy);
 }
 
 }
 
-void wxGCDC::Init()
+// returns the native representation
+void * wxGraphicsMatrix::GetNativeMatrix() const
 {
 {
-    m_ok = false;
-    m_colour = true;
-    m_mm_to_pix_x = mm2pt;
-    m_mm_to_pix_y = mm2pt;
+    return GetMatrixData()->GetNativeMatrix();
+}
 
 
-    m_pen = *wxBLACK_PEN;
-    m_font = *wxNORMAL_FONT;
-    m_brush = *wxWHITE_BRUSH;
+//-----------------------------------------------------------------------------
+// path
+//-----------------------------------------------------------------------------
 
 
-    m_graphicContext = NULL;
-}
+IMPLEMENT_DYNAMIC_CLASS(wxGraphicsPath, wxGraphicsObject)
+WXDLLIMPEXP_DATA_CORE(wxGraphicsPath) wxNullGraphicsPath;
 
 
+// convenience functions, for using wxPoint2DDouble etc
 
 
-wxGCDC::~wxGCDC()
+wxPoint2DDouble wxGraphicsPath::GetCurrentPoint() const
 {
 {
-    delete m_graphicContext;
+    wxDouble x,y;
+    GetCurrentPoint(&x,&y);
+    return wxPoint2DDouble(x,y);
 }
 
 }
 
-void wxGCDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool WXUNUSED(useMask) )
+void wxGraphicsPath::MoveToPoint( const wxPoint2DDouble& p)
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid DC") );
-    wxCHECK_RET( bmp.Ok(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid bitmap") );
-
-    wxCoord xx = LogicalToDeviceX(x);
-    wxCoord yy = LogicalToDeviceY(y);
-    wxCoord w = bmp.GetWidth();
-    wxCoord h = bmp.GetHeight();
-    wxCoord ww = LogicalToDeviceXRel(w);
-    wxCoord hh = LogicalToDeviceYRel(h);
-
-    m_graphicContext->DrawBitmap( bmp, xx , yy , ww , hh );
+    MoveToPoint( p.m_x , p.m_y);
 }
 
 }
 
-void wxGCDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y )
+void wxGraphicsPath::AddLineToPoint( const wxPoint2DDouble& p)
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawIcon - invalid DC") );
-    wxCHECK_RET( icon.Ok(), wxT("wxGCDC(cg)::DoDrawIcon - invalid icon") );
-
-    wxCoord xx = LogicalToDeviceX(x);
-    wxCoord yy = LogicalToDeviceY(y);
-    wxCoord w = icon.GetWidth();
-    wxCoord h = icon.GetHeight();
-    wxCoord ww = LogicalToDeviceXRel(w);
-    wxCoord hh = LogicalToDeviceYRel(h);
-
-    m_graphicContext->DrawIcon( icon , xx, yy, ww, hh );
+    AddLineToPoint( p.m_x , p.m_y);
 }
 
 }
 
-void wxGCDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
+void wxGraphicsPath::AddCurveToPoint( const wxPoint2DDouble& c1, const wxPoint2DDouble& c2, const wxPoint2DDouble& e)
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoSetClippingRegion - invalid DC") );
-
-    wxCoord xx, yy, ww, hh;
-    xx = LogicalToDeviceX(x);
-    yy = LogicalToDeviceY(y);
-    ww = LogicalToDeviceXRel(width);
-    hh = LogicalToDeviceYRel(height);
-
-       m_graphicContext->Clip( xx, yy, ww, hh );
-    if ( m_clipping )
-    {
-        m_clipX1 = wxMax( m_clipX1, xx );
-        m_clipY1 = wxMax( m_clipY1, yy );
-        m_clipX2 = wxMin( m_clipX2, (xx + ww) );
-        m_clipY2 = wxMin( m_clipY2, (yy + hh) );
-    }
-    else
-    {
-        m_clipping = true;
-
-        m_clipX1 = xx;
-        m_clipY1 = yy;
-        m_clipX2 = xx + ww;
-        m_clipY2 = yy + hh;
-    }
+    AddCurveToPoint(c1.m_x, c1.m_y, c2.m_x, c2.m_y, e.m_x, e.m_y);
 }
 
 }
 
-void wxGCDC::DoSetClippingRegionAsRegion( const wxRegion &region )
+void wxGraphicsPath::AddArc( const wxPoint2DDouble& c, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise)
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoSetClippingRegionAsRegion - invalid DC") );
-
-    if (region.Empty())
-    {
-        DestroyClippingRegion();
-        return;
-    }
-
-    wxCoord x, y, w, h;
-    region.GetBox( x, y, w, h );
-    wxCoord xx, yy, ww, hh;
-    xx = LogicalToDeviceX(x);
-    yy = LogicalToDeviceY(y);
-    ww = LogicalToDeviceXRel(w);
-    hh = LogicalToDeviceYRel(h);
-
-    // if we have a scaling that we cannot map onto native regions
-    // we must use the box
-    if ( ww != w || hh != h )
-    {
-        wxGCDC::DoSetClippingRegion( x, y, w, h );
-    }
-    else
-    {
-               m_graphicContext->Clip( region ) ;
-               if ( m_clipping )
-               {
-                       m_clipX1 = wxMax( m_clipX1, xx );
-                       m_clipY1 = wxMax( m_clipY1, yy );
-                       m_clipX2 = wxMin( m_clipX2, (xx + ww) );
-                       m_clipY2 = wxMin( m_clipY2, (yy + hh) );
-               }
-               else
-               {
-                       m_clipping = true;
-
-                       m_clipX1 = xx;
-                       m_clipY1 = yy;
-                       m_clipX2 = xx + ww;
-                       m_clipY2 = yy + hh;
-               }
-       }
+    AddArc(c.m_x, c.m_y, r, startAngle, endAngle, clockwise);
 }
 
 }
 
-void wxGCDC::DestroyClippingRegion()
+wxRect2DDouble wxGraphicsPath::GetBox() const
 {
 {
-       m_graphicContext->ResetClip() ;
-    m_graphicContext->SetPen( m_pen ) ;
-    m_graphicContext->SetBrush( m_brush ) ;
-
-    m_clipping = false;
+    wxDouble x,y,w,h;
+    GetBox(&x,&y,&w,&h);
+    return wxRect2DDouble( x,y,w,h );
 }
 
 }
 
-void wxGCDC::DoGetSizeMM( int* width, int* height ) const
+bool wxGraphicsPath::Contains( const wxPoint2DDouble& c, wxPolygonFillMode fillStyle ) const
 {
 {
-    int w = 0, h = 0;
-
-    GetSize( &w, &h );
-    if (width)
-        *width = long( double(w) / (m_scaleX * m_mm_to_pix_x) );
-    if (height)
-        *height = long( double(h) / (m_scaleY * m_mm_to_pix_y) );
+    return Contains( c.m_x, c.m_y, fillStyle);
 }
 
 }
 
-void wxGCDC::SetTextForeground( const wxColour &col )
-{
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::SetTextForeground - invalid DC") );
+// true redirections
 
 
-    if ( col != m_textForegroundColour )
-    {
-        m_textForegroundColour = col;
-        m_graphicContext->SetTextColor( col );
-    }
+// begins a new subpath at (x,y)
+void wxGraphicsPath::MoveToPoint( wxDouble x, wxDouble y )
+{
+    AllocExclusive();
+    GetPathData()->MoveToPoint(x,y);
 }
 
 }
 
-void wxGCDC::SetTextBackground( const wxColour &col )
+// adds a straight line from the current point to (x,y)
+void wxGraphicsPath::AddLineToPoint( wxDouble x, wxDouble y )
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::SetTextBackground - invalid DC") );
-
-    m_textBackgroundColour = col;
+    AllocExclusive();
+    GetPathData()->AddLineToPoint(x,y);
 }
 
 }
 
-void wxGCDC::SetMapMode( int mode )
+// adds a cubic Bezier curve from the current point, using two control points and an end point
+void wxGraphicsPath::AddCurveToPoint( wxDouble cx1, wxDouble cy1, wxDouble cx2, wxDouble cy2, wxDouble x, wxDouble y )
 {
 {
-    switch (mode)
-    {
-    case wxMM_TWIPS:
-        SetLogicalScale( twips2mm * m_mm_to_pix_x, twips2mm * m_mm_to_pix_y );
-        break;
-
-    case wxMM_POINTS:
-        SetLogicalScale( pt2mm * m_mm_to_pix_x, pt2mm * m_mm_to_pix_y );
-        break;
-
-    case wxMM_METRIC:
-        SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
-        break;
-
-    case wxMM_LOMETRIC:
-        SetLogicalScale( m_mm_to_pix_x / 10.0, m_mm_to_pix_y / 10.0 );
-        break;
-
-    case wxMM_TEXT:
-    default:
-        SetLogicalScale( 1.0, 1.0 );
-        break;
-    }
-
-    ComputeScaleAndOrigin();
+    AllocExclusive();
+    GetPathData()->AddCurveToPoint(cx1,cy1,cx2,cy2,x,y);
 }
 
 }
 
-void wxGCDC::SetUserScale( double x, double y )
+// adds another path
+void wxGraphicsPath::AddPath( const wxGraphicsPath& path )
 {
 {
-    // allow negative ? -> no
-
-    m_userScaleX = x;
-    m_userScaleY = y;
-       ComputeScaleAndOrigin();
+    AllocExclusive();
+    GetPathData()->AddPath(path.GetPathData());
 }
 
 }
 
-void wxGCDC::SetLogicalScale( double x, double y )
+// closes the current sub-path
+void wxGraphicsPath::CloseSubpath()
 {
 {
-    // allow negative ?
-    m_logicalScaleX = x;
-    m_logicalScaleY = y;
-    ComputeScaleAndOrigin();
+    AllocExclusive();
+    GetPathData()->CloseSubpath();
 }
 
 }
 
-void wxGCDC::SetLogicalOrigin( wxCoord x, wxCoord y )
+// gets the last point of the current path, (0,0) if not yet set
+void wxGraphicsPath::GetCurrentPoint( wxDouble* x, wxDouble* y) const
 {
 {
-    m_logicalOriginX = x * m_signX;   // is this still correct ?
-    m_logicalOriginY = y * m_signY;
-    ComputeScaleAndOrigin();
+    GetPathData()->GetCurrentPoint(x,y);
 }
 
 }
 
-void wxGCDC::SetDeviceOrigin( wxCoord x, wxCoord y )
+// adds an arc of a circle centering at (x,y) with radius (r) from startAngle to endAngle
+void wxGraphicsPath::AddArc( wxDouble x, wxDouble y, wxDouble r, wxDouble startAngle, wxDouble endAngle, bool clockwise )
 {
 {
-    m_deviceOriginX = x;
-    m_deviceOriginY = y;
-    ComputeScaleAndOrigin();
+    AllocExclusive();
+    GetPathData()->AddArc(x,y,r,startAngle,endAngle,clockwise);
 }
 
 }
 
-void wxGCDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
+//
+// These are convenience functions which - if not available natively will be assembled
+// using the primitives from above
+//
+
+// adds a quadratic Bezier curve from the current point, using a control point and an end point
+void wxGraphicsPath::AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y )
 {
 {
-    m_signX = (xLeftRight ?  1 : -1);
-    m_signY = (yBottomUp ? -1 :  1);
-    ComputeScaleAndOrigin();
+    AllocExclusive();
+    GetPathData()->AddQuadCurveToPoint(cx,cy,x,y);
 }
 
 }
 
-wxSize wxGCDC::GetPPI() const
+// appends a rectangle as a new closed subpath
+void wxGraphicsPath::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 {
 {
-    return wxSize(72, 72);
+    AllocExclusive();
+    GetPathData()->AddRectangle(x,y,w,h);
 }
 
 }
 
-int wxGCDC::GetDepth() const
+// appends an ellipsis as a new closed subpath fitting the passed rectangle
+void wxGraphicsPath::AddCircle( wxDouble x, wxDouble y, wxDouble r )
 {
 {
-    return 32;
+    AllocExclusive();
+    GetPathData()->AddCircle(x,y,r);
 }
 
 }
 
-void wxGCDC::ComputeScaleAndOrigin()
+// 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)
+void wxGraphicsPath::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
 {
 {
-    // CMB: copy scale to see if it changes
-    double origScaleX = m_scaleX;
-    double origScaleY = m_scaleY;
-    m_scaleX = m_logicalScaleX * m_userScaleX;
-    m_scaleY = m_logicalScaleY * m_userScaleY;
-    m_deviceOriginX = m_deviceOriginX + m_logicalOriginX;
-    m_deviceOriginY = m_deviceOriginY + m_logicalOriginY;
-
-    // CMB: if scale has changed call SetPen to recalulate the line width
-    if (m_scaleX != origScaleX || m_scaleY != origScaleY)
-    {
-        // this is a bit artificial, but we need to force wxDC to think
-        // the pen has changed
-        wxPen pen(GetPen());
-        m_pen = wxNullPen;
-        SetPen(pen);
-               SetFont(m_font);
-    }
+    GetPathData()->AddArcToPoint(x1,y1,x2,y2,r);
 }
 
 }
 
-void wxGCDC::SetPalette( const wxPalette& WXUNUSED(palette) )
+// appends an ellipse
+void wxGraphicsPath::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
 {
 {
-
+    AllocExclusive();
+    GetPathData()->AddEllipse(x,y,w,h);
 }
 
 }
 
-void wxGCDC::SetBackgroundMode( int mode )
+// appends a rounded rectangle
+void wxGraphicsPath::AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
 {
 {
-    m_backgroundMode = mode;
+    AllocExclusive();
+    GetPathData()->AddRoundedRectangle(x,y,w,h,radius);
 }
 
 }
 
-void wxGCDC::SetFont( const wxFont &font )
+// returns the native path
+void * wxGraphicsPath::GetNativePath() const
 {
 {
-    m_font = font;
-    if ( m_graphicContext )
-       {
-               wxFont f = font ;
-               f.SetPointSize( LogicalToDeviceYRel(font.GetPointSize())) ;
-        m_graphicContext->SetFont( f );
-       }
+    return GetPathData()->GetNativePath();
 }
 
 }
 
-void wxGCDC::SetPen( const wxPen &pen )
+// give the native path returned by GetNativePath() back (there might be some deallocations necessary)
+void wxGraphicsPath::UnGetNativePath(void *p)const
 {
 {
-    if ( m_pen == pen )
-        return;
-
-    m_pen = pen;
-    if ( m_graphicContext )
-    {
-        if ( m_pen.GetStyle() == wxSOLID || m_pen.GetStyle() == wxTRANSPARENT )
-        {
-            m_graphicContext->SetPen( m_pen );
-        }
-        else
-        {
-            // we have to compensate for moved device origins etc. otherwise patterned pens are standing still
-            // eg when using a wxScrollWindow and scrolling around
-            int origX = LogicalToDeviceX( 0 );
-            int origY = LogicalToDeviceY( 0 );
-            m_graphicContext->Translate( origX , origY );
-            m_graphicContext->SetPen( m_pen );
-            m_graphicContext->Translate( -origX , -origY );
-        }
-    }
+    GetPathData()->UnGetNativePath(p);
 }
 
 }
 
-void wxGCDC::SetBrush( const wxBrush &brush )
+// transforms each point of this path by the matrix
+void wxGraphicsPath::Transform( const wxGraphicsMatrix& matrix )
 {
 {
-    if (m_brush == brush)
-        return;
-
-    m_brush = brush;
-    if ( m_graphicContext )
-    {
-        if ( brush.GetStyle() == wxSOLID || brush.GetStyle() == wxTRANSPARENT )
-        {
-            m_graphicContext->SetBrush( m_brush );
-        }
-        else
-        {
-            // we have to compensate for moved device origins etc. otherwise patterned brushes are standing still
-            // eg when using a wxScrollWindow and scrolling around
-            // TODO on MSW / GDIPlus this still occurs with hatched brushes
-            int origX = LogicalToDeviceX(0);
-            int origY = LogicalToDeviceY(0);
-            m_graphicContext->Translate( origX , origY );
-            m_graphicContext->SetBrush( m_brush );
-            m_graphicContext->Translate( -origX , -origY );
-        }
-    }
+    AllocExclusive();
+    GetPathData()->Transform(matrix.GetMatrixData());
 }
 
 }
 
-void wxGCDC::SetBackground( const wxBrush &brush )
+// gets the bounding box enclosing all points (possibly including control points)
+void wxGraphicsPath::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const
 {
 {
-    if (m_backgroundBrush == brush)
-        return;
-
-    m_backgroundBrush = brush;
-    if (!m_backgroundBrush.Ok())
-        return;
+    GetPathData()->GetBox(x,y,w,h);
 }
 
 }
 
-void wxGCDC::SetLogicalFunction( int function )
+bool wxGraphicsPath::Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle ) const
 {
 {
-    if (m_logicalFunction == function)
-        return;
+    return GetPathData()->Contains(x,y,fillStyle);
+}
 
 
-    m_logicalFunction = function;
-#if wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
+//
+// Emulations, these mus be implemented in the ...Data classes in order to allow for proper overrides
+//
 
 
-    CGContextRef cgContext = ((wxCairoContext*)(m_graphicContext))->GetNativeContext();
-    if ( m_logicalFunction == wxCOPY )
-        CGContextSetBlendMode( cgContext, kCGBlendModeNormal );
-    else if ( m_logicalFunction == wxINVERT )
-        CGContextSetBlendMode( cgContext, kCGBlendModeExclusion );
-    else
-        CGContextSetBlendMode( cgContext, kCGBlendModeNormal );
-#endif
+void wxGraphicsPathData::AddQuadCurveToPoint( wxDouble cx, wxDouble cy, wxDouble x, wxDouble y )
+{
+    // calculate using degree elevation to a cubic bezier
+    wxPoint2DDouble c1;
+    wxPoint2DDouble c2;
 
 
+    wxPoint2DDouble start;
+    GetCurrentPoint(&start.m_x,&start.m_y);
+    wxPoint2DDouble end(x,y);
+    wxPoint2DDouble c(cx,cy);
+    c1 = wxDouble(1/3.0) * start + wxDouble(2/3.0) * c;
+    c2 = wxDouble(2/3.0) * c + wxDouble(1/3.0) * end;
+    AddCurveToPoint(c1.m_x,c1.m_y,c2.m_x,c2.m_y,x,y);
 }
 
 }
 
-bool wxGCDC::DoFloodFill(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
-                         const wxColour& WXUNUSED(col), int WXUNUSED(style))
+void wxGraphicsPathData::AddRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 {
 {
-    return false;
+    MoveToPoint(x,y);
+    AddLineToPoint(x,y+h);
+    AddLineToPoint(x+w,y+h);
+    AddLineToPoint(x+w,y);
+    CloseSubpath();
 }
 
 }
 
-bool wxGCDC::DoGetPixel( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y), wxColour *WXUNUSED(col) ) const
+void wxGraphicsPathData::AddCircle( wxDouble x, wxDouble y, wxDouble r )
 {
 {
-    //  wxCHECK_MSG( 0 , false, wxT("wxGCDC(cg)::DoGetPixel - not implemented") );
-    return false;
+    MoveToPoint(x+r,y);
+    AddArc( x,y,r,0,2*M_PI,false);
+    CloseSubpath();
 }
 
 }
 
-void wxGCDC::DoDrawLine( wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2 )
+void wxGraphicsPathData::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawLine - invalid DC") );
+    if (w <= 0. || h <= 0.)
+      return;
 
 
-#if !wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
-
-    if ( m_logicalFunction != wxCOPY )
-        return;
-#endif
-
-    wxCoord xx1 = LogicalToDeviceX(x1);
-    wxCoord yy1 = LogicalToDeviceY(y1);
-    wxCoord xx2 = LogicalToDeviceX(x2);
-    wxCoord yy2 = LogicalToDeviceY(y2);
-
-    m_graphicContext->StrokeLine(xx1,yy1,xx2,yy2);
+    wxDouble rw = w/2;
+    wxDouble rh = h/2;
+    wxDouble xc = x + rw;
+    wxDouble yc = y + rh;
+    wxGraphicsMatrix m = GetRenderer()->CreateMatrix();
+    m.Translate(xc,yc);
+    m.Scale(rw/rh,1.0);
+    wxGraphicsPath p = GetRenderer()->CreatePath();
+    p.AddCircle(0,0,rh);
+    p.Transform(m);
+    AddPath(p.GetPathData());
+}
 
 
-    CalcBoundingBox(x1, y1);
-    CalcBoundingBox(x2, y2);
+void wxGraphicsPathData::AddRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
+{
+    if ( radius == 0 )
+        AddRectangle(x,y,w,h);
+    else
+    {
+        MoveToPoint( x + w, y + h / 2);
+        AddArcToPoint(x + w, y + h, x + w / 2, y + h, radius);
+        AddArcToPoint(x, y + h, x, y + h / 2, radius);
+        AddArcToPoint(x, y , x + w / 2, y, radius);
+        AddArcToPoint(x + w, y, x + w, y + h / 2, radius);
+        CloseSubpath();
+    }
 }
 
 }
 
-void wxGCDC::DoCrossHair( wxCoord x, wxCoord y )
+// 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)
+void wxGraphicsPathData::AddArcToPoint( wxDouble x1, wxDouble y1 , wxDouble x2, wxDouble y2, wxDouble r )
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoCrossHair - invalid DC") );
+    wxPoint2DDouble current;
+    GetCurrentPoint(&current.m_x,&current.m_y);
+    wxPoint2DDouble p1(x1,y1);
+    wxPoint2DDouble p2(x2,y2);
 
 
-    if ( m_logicalFunction != wxCOPY )
-        return;
+    wxPoint2DDouble v1 = current - p1;
+    v1.Normalize();
+    wxPoint2DDouble v2 = p2 - p1;
+    v2.Normalize();
 
 
-    int w = 0, h = 0;
+    wxDouble alpha = v1.GetVectorAngle() - v2.GetVectorAngle();
 
 
-    GetSize( &w, &h );
+    if ( alpha < 0 )
+        alpha = 360 + alpha;
+    // TODO obtuse angles
 
 
-    wxCoord xx = LogicalToDeviceX(x);
-    wxCoord yy = LogicalToDeviceY(y);
-    wxCoord xw = LogicalToDeviceX(w);
-    wxCoord x0 = LogicalToDeviceX(0);
-    wxCoord y0 = LogicalToDeviceY(0);
-    wxCoord yh = LogicalToDeviceY(h);
+    alpha = DegToRad(alpha);
 
 
-    m_graphicContext->StrokeLine(x0,yy,xw,yy);
-    m_graphicContext->StrokeLine(xx,y0,xx,yh);
+    wxDouble dist = r / sin(alpha/2) * cos(alpha/2);
+    // calculate tangential points
+    wxPoint2DDouble t1 = dist*v1 + p1;
 
 
-    CalcBoundingBox(x0, y0);
-    CalcBoundingBox(x0+xw, y0+yh);
-}
+    wxPoint2DDouble nv1 = v1;
+    nv1.SetVectorAngle(v1.GetVectorAngle()-90);
+    wxPoint2DDouble c = t1 + r*nv1;
 
 
-void wxGCDC::DoDrawArc( wxCoord x1, wxCoord y1,
-                        wxCoord x2, wxCoord y2,
-                        wxCoord xc, wxCoord yc )
-{
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawArc - invalid DC") );
+    wxDouble a1 = v1.GetVectorAngle()+90;
+    wxDouble a2 = v2.GetVectorAngle()-90;
 
 
-    if ( m_logicalFunction != wxCOPY )
-        return;
+    AddLineToPoint(t1.m_x,t1.m_y);
+    AddArc(c.m_x,c.m_y,r,DegToRad(a1),DegToRad(a2),true);
+    AddLineToPoint(p2.m_x,p2.m_y);
+}
 
 
-    wxCoord xx1 = LogicalToDeviceX(x1);
-    wxCoord yy1 = LogicalToDeviceY(y1);
-    wxCoord xx2 = LogicalToDeviceX(x2);
-    wxCoord yy2 = LogicalToDeviceY(y2);
-    wxCoord xxc = LogicalToDeviceX(xc);
-    wxCoord yyc = LogicalToDeviceY(yc);
+//-----------------------------------------------------------------------------
+// wxGraphicsGradientStops
+//-----------------------------------------------------------------------------
 
 
-    double dx = xx1 - xxc;
-    double dy = yy1 - yyc;
-    double radius = sqrt((double)(dx * dx + dy * dy));
-    wxCoord rad = (wxCoord)radius;
-    double sa, ea;
-    if (xx1 == xx2 && yy1 == yy2)
+void wxGraphicsGradientStops::Add(const wxGraphicsGradientStop& stop)
+{
+    for ( wxVector<wxGraphicsGradientStop>::iterator it = m_stops.begin();
+          it != m_stops.end();
+          ++it )
     {
     {
-        sa = 0.0;
-        ea = 360.0;
+        if ( stop.GetPosition() < it->GetPosition() )
+        {
+            if ( it != m_stops.begin() )
+            {
+                m_stops.insert(it, stop);
+            }
+            else // we shouldn't be inserting it at the beginning
+            {
+                wxFAIL_MSG( "invalid gradient stop position < 0" );
+            }
+
+            return;
+        }
     }
     }
-    else if (radius == 0.0)
+
+    if ( stop.GetPosition() == 1. )
     {
     {
-        sa = ea = 0.0;
+        m_stops.insert(m_stops.end() - 1, stop);
     }
     else
     {
     }
     else
     {
-        sa = (xx1 - xxc == 0) ?
-     (yy1 - yyc < 0) ? 90.0 : -90.0 :
-             -atan2(double(yy1 - yyc), double(xx1 - xxc)) * RAD2DEG;
-        ea = (xx2 - xxc == 0) ?
-     (yy2 - yyc < 0) ? 90.0 : -90.0 :
-             -atan2(double(yy2 - yyc), double(xx2 - xxc)) * RAD2DEG;
+        wxFAIL_MSG( "invalid gradient stop position > 1" );
     }
     }
-
-    bool fill = m_brush.GetStyle() != wxTRANSPARENT;
-
-    wxGraphicsPath* path = m_graphicContext->CreatePath();
-    if ( fill && ((x1!=x2)||(y1!=y2)) )
-        path->MoveToPoint( xxc, yyc );
-    path->AddArc( xxc, yyc , rad , DegToRad(sa) , DegToRad(ea), false );
-    if ( fill && ((x1!=x2)||(y1!=y2)) )
-        path->AddLineToPoint( xxc, yyc );
-    m_graphicContext->DrawPath(path);
-    delete path;
 }
 
 }
 
-void wxGCDC::DoDrawEllipticArc( wxCoord x, wxCoord y, wxCoord w, wxCoord h,
-                                double sa, double ea )
+void * wxGraphicsBitmap::GetNativeBitmap() const
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawEllipticArc - invalid DC") );
+    return GetBitmapData()->GetNativeBitmap();
+}
 
 
-    if ( m_logicalFunction != wxCOPY )
-        return;
+//-----------------------------------------------------------------------------
+// wxGraphicsContext Convenience Methods
+//-----------------------------------------------------------------------------
 
 
-    wxCoord xx = LogicalToDeviceX(x);
-    wxCoord yy = LogicalToDeviceY(y);
-    wxCoord ww = m_signX * LogicalToDeviceXRel(w);
-    wxCoord hh = m_signY * LogicalToDeviceYRel(h);
+IMPLEMENT_ABSTRACT_CLASS(wxGraphicsContext, wxObject)
 
 
-    // handle -ve width and/or height
-    if (ww < 0)
-    {
-        ww = -ww;
-        xx = xx - ww;
-    }
-    if (hh < 0)
-    {
-        hh = -hh;
-        yy = yy - hh;
-    }
 
 
-    bool fill = m_brush.GetStyle() != wxTRANSPARENT;
-
-    wxGraphicsPath* path = m_graphicContext->CreatePath();
-    m_graphicContext->PushState();
-    m_graphicContext->Translate(xx+ww/2,yy+hh/2);
-    wxDouble factor = ((wxDouble) ww) / hh ;
-    m_graphicContext->Scale( factor , 1.0) ;
-    if ( fill && (sa!=ea) )
-        path->MoveToPoint(0,0);
-    // since these angles (ea,sa) are measured counter-clockwise, we invert them to
-    // get clockwise angles
-    path->AddArc( 0, 0, hh/2 , DegToRad(-sa) , DegToRad(-ea), sa > ea );
-    if ( fill && (sa!=ea) )
-        path->AddLineToPoint(0,0);
-    m_graphicContext->DrawPath( path );
-    m_graphicContext->PopState();
-    delete path;
+wxGraphicsContext::wxGraphicsContext(wxGraphicsRenderer* renderer) :
+    wxGraphicsObject(renderer),
+      m_antialias(wxANTIALIAS_DEFAULT),
+      m_composition(wxCOMPOSITION_OVER),
+      m_enableOffset(false)
+{
 }
 
 }
 
-void wxGCDC::DoDrawPoint( wxCoord x, wxCoord y )
+wxGraphicsContext::~wxGraphicsContext()
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawPoint - invalid DC") );
-
-    DoDrawLine( x , y , x + 1 , y + 1 );
 }
 
 }
 
-void wxGCDC::DoDrawLines(int n, wxPoint points[],
-                         wxCoord xoffset, wxCoord yoffset)
+bool wxGraphicsContext::StartDoc(const wxString& WXUNUSED(message))
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawLines - invalid DC") );
-
-#if !wxMAC_USE_CORE_GRAPHICS_BLEND_MODES
-
-    if ( m_logicalFunction != wxCOPY )
-        return;
-#endif
-
-    wxPoint2DDouble* pointsD = new wxPoint2DDouble[n] ;
-    for( int i = 0 ; i < n; ++i)
-    {
-        pointsD[i].m_x = LogicalToDeviceX(points[i].x + xoffset);
-        pointsD[i].m_y = LogicalToDeviceY(points[i].y + yoffset);
-    }
-
-    m_graphicContext->StrokeLines( n , pointsD) ;
-    delete[] pointsD;
+    return true;
 }
 
 }
 
-#if wxUSE_SPLINES
-void wxGCDC::DoDrawSpline(wxList *points)
+void wxGraphicsContext::EndDoc()
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawSpline - invalid DC") );
-
-    if ( m_logicalFunction != wxCOPY )
-        return;
-
-    wxGraphicsPath* path = m_graphicContext->CreatePath();
-
-    wxList::compatibility_iterator node = points->GetFirst();
-    if (node == wxList::compatibility_iterator())
-        // empty list
-        return;
-
-    wxPoint *p = (wxPoint *)node->GetData();
-
-    wxCoord x1 = p->x;
-    wxCoord y1 = p->y;
-
-    node = node->GetNext();
-    p = (wxPoint *)node->GetData();
-
-    wxCoord x2 = p->x;
-    wxCoord y2 = p->y;
-    wxCoord cx1 = ( x1 + x2 ) / 2;
-    wxCoord cy1 = ( y1 + y2 ) / 2;
-
-    path->MoveToPoint( LogicalToDeviceX( x1 ) , LogicalToDeviceY( y1 ) );
-    path->AddLineToPoint( LogicalToDeviceX( cx1 ) , LogicalToDeviceY( cy1 ) );
-#if !wxUSE_STL
-
-    while ((node = node->GetNext()) != NULL)
-#else
-
-    while ((node = node->GetNext()))
-#endif // !wxUSE_STL
-
-    {
-        p = (wxPoint *)node->GetData();
-        x1 = x2;
-        y1 = y2;
-        x2 = p->x;
-        y2 = p->y;
-        wxCoord cx4 = (x1 + x2) / 2;
-        wxCoord cy4 = (y1 + y2) / 2;
-
-        path->AddQuadCurveToPoint(
-            LogicalToDeviceX( x1 ) , LogicalToDeviceY( y1 ) ,
-            LogicalToDeviceX( cx4 ) , LogicalToDeviceY( cy4 ) );
-
-        cx1 = cx4;
-        cy1 = cy4;
-    }
-
-    path->AddLineToPoint( LogicalToDeviceX( x2 ) , LogicalToDeviceY( y2 ) );
-
-    m_graphicContext->StrokePath( path );
-    delete path;
 }
 }
-#endif // wxUSE_SPLINES
 
 
-void wxGCDC::DoDrawPolygon( int n, wxPoint points[],
-                            wxCoord xoffset, wxCoord yoffset,
-                            int fillStyle )
+void wxGraphicsContext::StartPage(wxDouble WXUNUSED(width),
+                                  wxDouble WXUNUSED(height))
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawPolygon - invalid DC") );
-
-    if ( n <= 0 || (m_brush.GetStyle() == wxTRANSPARENT && m_pen.GetStyle() == wxTRANSPARENT ) )
-        return;
-    if ( m_logicalFunction != wxCOPY )
-        return;
-
-    bool closeIt = false ;
-    if (points[n-1] != points[0])
-        closeIt = true ;
-
-    wxPoint2DDouble* pointsD = new wxPoint2DDouble[n+(closeIt?1:0)] ;
-    for( int i = 0 ; i < n; ++i)
-    {
-        pointsD[i].m_x = LogicalToDeviceX(points[i].x + xoffset);
-        pointsD[i].m_y = LogicalToDeviceY(points[i].y + yoffset);
-    }
-    if ( closeIt )
-        pointsD[n] = pointsD[0];
-
-    m_graphicContext->DrawLines( n+(closeIt?1:0) , pointsD, fillStyle) ;
-    delete[] pointsD;
 }
 
 }
 
-void wxGCDC::DoDrawPolyPolygon(int n,
-                               int count[],
-                               wxPoint points[],
-                               wxCoord xoffset,
-                               wxCoord yoffset,
-                               int fillStyle)
+void wxGraphicsContext::EndPage()
 {
 {
-    wxASSERT(n > 1);
-    wxGraphicsPath* path = m_graphicContext->CreatePath();
-
-    int i = 0 ;
-    for ( int j = 0 ; j < n ; ++j)
-    {
-        wxPoint start = points[i];
-        path->MoveToPoint(LogicalToDeviceX(start.x+ xoffset), LogicalToDeviceY(start.y+ yoffset)) ;
-        ++i;
-        int l = count[j];
-        for ( int k = 1 ; k < l ; ++k)
-        {
-            path->AddLineToPoint( LogicalToDeviceX(points[i].x+ xoffset), LogicalToDeviceY(points[i].y+ yoffset));
-            ++i ;
-        }
-        // close the polygon
-        if ( start != points[i-1])
-            path->AddLineToPoint( LogicalToDeviceX(start.x+ xoffset), LogicalToDeviceY(start.y+ yoffset));
-    }
-    m_graphicContext->DrawPath( path , fillStyle);
-    delete path;
 }
 
 }
 
-void wxGCDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+void wxGraphicsContext::Flush()
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawRectangle - invalid DC") );
-
-    if ( m_logicalFunction != wxCOPY )
-        return;
-
-    wxCoord xx = LogicalToDeviceX(x);
-    wxCoord yy = LogicalToDeviceY(y);
-    wxCoord ww = m_signX * LogicalToDeviceXRel(width);
-    wxCoord hh = m_signY * LogicalToDeviceYRel(height);
-
-    // CMB: draw nothing if transformed w or h is 0
-    if (ww == 0 || hh == 0)
-        return;
+}
 
 
-    // CMB: handle -ve width and/or height
-    if (ww < 0)
-    {
-        ww = -ww;
-        xx = xx - ww;
-    }
-    if (hh < 0)
-    {
-        hh = -hh;
-        yy = yy - hh;
-    }
-    m_graphicContext->DrawRectangle( xx,yy,ww,hh);
+void wxGraphicsContext::EnableOffset(bool enable) 
+{ 
+    m_enableOffset = enable; 
 }
 
 }
 
-void wxGCDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y,
-                                    wxCoord width, wxCoord height,
-                                    double radius)
+#if 0
+void wxGraphicsContext::SetAlpha( wxDouble WXUNUSED(alpha) )
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawRoundedRectangle - invalid DC") );
-
-    if ( m_logicalFunction != wxCOPY )
-        return;
-
-    if (radius < 0.0)
-        radius = - radius * ((width < height) ? width : height);
-    wxCoord xx = LogicalToDeviceX(x);
-    wxCoord yy = LogicalToDeviceY(y);
-    wxCoord ww = m_signX * LogicalToDeviceXRel(width);
-    wxCoord hh = m_signY * LogicalToDeviceYRel(height);
-
-    // CMB: draw nothing if transformed w or h is 0
-    if (ww == 0 || hh == 0)
-        return;
-
-    // CMB: handle -ve width and/or height
-    if (ww < 0)
-    {
-        ww = -ww;
-        xx = xx - ww;
-    }
-    if (hh < 0)
-    {
-        hh = -hh;
-        yy = yy - hh;
-    }
-
-    m_graphicContext->DrawRoundedRectangle( xx,yy,ww,hh,radius);
 }
 
 }
 
-void wxGCDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+wxDouble wxGraphicsContext::GetAlpha() const
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawEllipse - invalid DC") );
-
-    if ( m_logicalFunction != wxCOPY )
-        return;
-
-    wxCoord xx = LogicalToDeviceX(x);
-    wxCoord yy = LogicalToDeviceY(y);
-    wxDouble ww = m_signX * LogicalToDeviceXRel(width);
-    wxCoord hh = m_signY * LogicalToDeviceYRel(height);
-
-    // CMB: draw nothing if transformed w or h is 0
-    if (ww == 0 || hh == 0)
-        return;
-
-    // CMB: handle -ve width and/or height
-    if (ww < 0)
-    {
-        ww = -ww;
-        xx = xx - ww;
-    }
-    if (hh < 0)
-    {
-        hh = -hh;
-        yy = yy - hh;
-    }
-
-    m_graphicContext->DrawEllipse(xx,yy,ww,hh);
+    return 1.0;
 }
 }
+#endif
 
 
-bool wxGCDC::CanDrawBitmap() const
+void wxGraphicsContext::GetDPI( wxDouble* dpiX, wxDouble* dpiY)
 {
 {
-    return true;
+    *dpiX = 72.0;
+    *dpiY = 72.0;
 }
 
 }
 
-bool wxGCDC::DoBlit(
-    wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
-    wxDC *source, wxCoord xsrc, wxCoord ysrc, int logical_func , bool WXUNUSED(useMask),
-    wxCoord xsrcMask, wxCoord ysrcMask )
+// sets the pen
+void wxGraphicsContext::SetPen( const wxGraphicsPen& pen )
 {
 {
-    wxCHECK_MSG( Ok(), false, wxT("wxGCDC(cg)::DoBlit - invalid DC") );
-    wxCHECK_MSG( source->Ok(), false, wxT("wxGCDC(cg)::DoBlit - invalid source DC") );
-
-    if ( logical_func == wxNO_OP )
-        return true;
-
-    if (xsrcMask == -1 && ysrcMask == -1)
-    {
-        xsrcMask = xsrc;
-        ysrcMask = ysrc;
-    }
-
-    wxCoord yysrc = source-> LogicalToDeviceY(ysrc);
-    wxCoord xxsrc = source-> LogicalToDeviceX(xsrc);
-    wxCoord wwsrc = source-> LogicalToDeviceXRel(width);
-    wxCoord hhsrc = source-> LogicalToDeviceYRel(height);
-
-    wxCoord yydest = LogicalToDeviceY(ydest);
-    wxCoord xxdest = LogicalToDeviceX(xdest);
-    wxCoord wwdest = LogicalToDeviceXRel(width);
-    wxCoord hhdest = LogicalToDeviceYRel(height);
-
-    wxMemoryDC* memdc = dynamic_cast<wxMemoryDC*>(source);
-    if ( memdc && logical_func == wxCOPY )
-    {
-        wxBitmap blit = memdc->GetSelectedBitmap();
-
-        wxASSERT_MSG( blit.Ok() , wxT("Invalid bitmap for blitting") );
-
-        wxCoord bmpwidth = blit.GetWidth();
-        wxCoord bmpheight = blit.GetHeight();
-
-        if ( xxsrc != 0 || yysrc != 0 || bmpwidth != wwsrc || bmpheight != hhsrc )
-        {
-            wwsrc = wxMin( wwsrc , bmpwidth - xxsrc );
-            hhsrc = wxMin( hhsrc , bmpheight - yysrc );
-            if ( wwsrc > 0 && hhsrc > 0 )
-            {
-                if ( xxsrc >= 0 && yysrc >= 0 )
-                {
-                    wxRect subrect( xxsrc, yysrc, wwsrc , hhsrc );
-                    // TODO we perhaps could add a DrawSubBitmap call to dc for performance reasons
-                    blit = blit.GetSubBitmap( subrect );
-                }
-                else
-                {
-                    // in this case we'd probably have to adjust the different coordinates, but
-                    // we have to find out proper contract first
-                    blit = wxNullBitmap;
-                }
-            }
-            else
-            {
-                blit = wxNullBitmap;
-            }
-        }
+    m_pen = pen;
+}
 
 
-        if ( blit.Ok() )
-        {
-            m_graphicContext->DrawBitmap( blit, xxdest , yydest , wwdest , hhdest );
-        }
-    }
+void wxGraphicsContext::SetPen( const wxPen& pen )
+{
+    if ( !pen.IsOk() || pen.GetStyle() == wxPENSTYLE_TRANSPARENT )
+        SetPen( wxNullGraphicsPen );
     else
     else
-    {
-        wxFAIL_MSG( wxT("Blitting is only supported from bitmap contexts") );
-        return false;
-    }
-
-    return true;
+        SetPen( CreatePen( pen ) );
 }
 
 }
 
-void wxGCDC::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
-                               double angle)
+// sets the brush for filling
+void wxGraphicsContext::SetBrush( const wxGraphicsBrush& brush )
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawRotatedText - invalid DC") );
-
-    if ( str.length() == 0 )
-        return;
-    if ( m_logicalFunction != wxCOPY )
-        return;
-
-    int drawX = LogicalToDeviceX(x);
-    int drawY = LogicalToDeviceY(y);
-
-    m_graphicContext->DrawText( str, drawX ,drawY , DegToRad(angle ));
+    m_brush = brush;
 }
 
 }
 
-void wxGCDC::DoDrawText(const wxString& str, wxCoord x, wxCoord y)
+void wxGraphicsContext::SetBrush( const wxBrush& brush )
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoDrawRotatedText - invalid DC") );
+    if ( !brush.IsOk() || brush.GetStyle() == wxBRUSHSTYLE_TRANSPARENT )
+        SetBrush( wxNullGraphicsBrush );
+    else
+        SetBrush( CreateBrush( brush ) );
+}
 
 
-    if ( str.length() == 0 )
-        return;
-    if ( m_logicalFunction != wxCOPY )
-        return;
+// sets the brush for filling
+void wxGraphicsContext::SetFont( const wxGraphicsFont& font )
+{
+    m_font = font;
+}
 
 
-    int drawX = LogicalToDeviceX(x);
-    int drawY = LogicalToDeviceY(y);
+void wxGraphicsContext::SetFont( const wxFont& font, const wxColour& colour )
+{
+    if ( font.IsOk() )
+        SetFont( CreateFont( font, colour ) );
+    else
+        SetFont( wxNullGraphicsFont );
+}
 
 
-    m_graphicContext->DrawText( str, drawX ,drawY);
+void wxGraphicsContext::DrawPath( const wxGraphicsPath& path, wxPolygonFillMode fillStyle )
+{
+    FillPath( path , fillStyle );
+    StrokePath( path );
 }
 
 }
 
-bool wxGCDC::CanGetTextExtent() const
+void
+wxGraphicsContext::DoDrawRotatedText(const wxString &str,
+                                     wxDouble x,
+                                     wxDouble y,
+                                     wxDouble angle)
 {
 {
-    wxCHECK_MSG( Ok(), false, wxT("wxGCDC(cg)::CanGetTextExtent - invalid DC") );
+    Translate(x,y);
+    Rotate( -angle );
+    DrawText( str , 0, 0 );
+    Rotate( angle );
+    Translate(-x,-y);
+}
+
+void
+wxGraphicsContext::DoDrawFilledText(const wxString &str,
+                                    wxDouble x,
+                                    wxDouble y,
+                                    const wxGraphicsBrush& backgroundBrush)
+{
+    wxGraphicsBrush formerBrush = m_brush;
+    wxGraphicsPen formerPen = m_pen;
+    wxDouble width;
+    wxDouble height;
+    wxDouble descent;
+    wxDouble externalLeading;
+    GetTextExtent( str , &width, &height, &descent, &externalLeading );
+    SetBrush( backgroundBrush );
+    // to make sure our 'OffsetToPixelBoundaries' doesn't move the fill shape
+    SetPen( wxNullGraphicsPen );
+
+    DrawRectangle(x , y, width, height);
+
+    DrawText( str, x ,y);
+    SetBrush( formerBrush );
+    SetPen( formerPen );
+}
+
+void
+wxGraphicsContext::DoDrawRotatedFilledText(const wxString &str,
+                                           wxDouble x, wxDouble y,
+                                           wxDouble angle,
+                                           const wxGraphicsBrush& backgroundBrush)
+{
+    wxGraphicsBrush formerBrush = m_brush;
+    wxGraphicsPen formerPen = m_pen;
+
+    wxDouble width;
+    wxDouble height;
+    wxDouble descent;
+    wxDouble externalLeading;
+    GetTextExtent( str , &width, &height, &descent, &externalLeading );
+    SetBrush( backgroundBrush );
+    // to make sure our 'OffsetToPixelBoundaries' doesn't move the fill shape
+    SetPen( wxNullGraphicsPen );
+
+    wxGraphicsPath path = CreatePath();
+    path.MoveToPoint( x , y );
+    path.AddLineToPoint( (int) (x + sin(angle) * height) , (int) (y + cos(angle) * height) );
+    path.AddLineToPoint(
+        (int) (x + sin(angle) * height + cos(angle) * width) ,
+        (int) (y + cos(angle) * height - sin(angle) * width));
+    path.AddLineToPoint((int) (x + cos(angle) * width) , (int) (y - sin(angle) * width) );
+    FillPath( path );
+    DrawText( str, x ,y, angle);
+    SetBrush( formerBrush );
+    SetPen( formerPen );
+}
 
 
-    return true;
+void wxGraphicsContext::StrokeLine( wxDouble x1, wxDouble y1, wxDouble x2, wxDouble y2)
+{
+    wxGraphicsPath path = CreatePath();
+    path.MoveToPoint(x1, y1);
+    path.AddLineToPoint( x2, y2 );
+    StrokePath( path );
 }
 
 }
 
-void wxGCDC::DoGetTextExtent( const wxString &str, wxCoord *width, wxCoord *height,
-                              wxCoord *descent, wxCoord *externalLeading ,
-                              wxFont *theFont ) const
+void wxGraphicsContext::DrawRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::DoGetTextExtent - invalid DC") );
+    wxGraphicsPath path = CreatePath();
+    path.AddRectangle( x , y , w , h );
+    DrawPath( path );
+}
 
 
-    if ( theFont )
-    {
-        m_graphicContext->SetFont( *theFont );
-    }
+void wxGraphicsContext::DrawEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h)
+{
+    wxGraphicsPath path = CreatePath();
+    path.AddEllipse(x,y,w,h);
+    DrawPath(path);
+}
 
 
-    wxDouble h , d , e , w;
+void wxGraphicsContext::DrawRoundedRectangle( wxDouble x, wxDouble y, wxDouble w, wxDouble h, wxDouble radius)
+{
+    wxGraphicsPath path = CreatePath();
+    path.AddRoundedRectangle(x,y,w,h,radius);
+    DrawPath(path);
+}
 
 
-    m_graphicContext->GetTextExtent( str, &w, &h, &d, &e );
+void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *points)
+{
+    wxASSERT(n > 1);
+    wxGraphicsPath path = CreatePath();
+    path.MoveToPoint(points[0].m_x, points[0].m_y);
+    for ( size_t i = 1; i < n; ++i)
+        path.AddLineToPoint( points[i].m_x, points[i].m_y );
+    StrokePath( path );
+}
 
 
-    if ( height )
-        *height = DeviceToLogicalYRel( h );
-    if ( descent )
-        *descent =DeviceToLogicalYRel( d);
-    if ( externalLeading )
-        *externalLeading = DeviceToLogicalYRel( e);
-    if ( width )
-        *width = DeviceToLogicalXRel( w );
+void wxGraphicsContext::DrawLines( size_t n, const wxPoint2DDouble *points, wxPolygonFillMode fillStyle)
+{
+    wxASSERT(n > 1);
+    wxGraphicsPath path = CreatePath();
+    path.MoveToPoint(points[0].m_x, points[0].m_y);
+    for ( size_t i = 1; i < n; ++i)
+        path.AddLineToPoint( points[i].m_x, points[i].m_y );
+    DrawPath( path , fillStyle);
+}
 
 
-    if ( theFont )
+void wxGraphicsContext::StrokeLines( size_t n, const wxPoint2DDouble *beginPoints, const wxPoint2DDouble *endPoints)
+{
+    wxASSERT(n > 0);
+    wxGraphicsPath path = CreatePath();
+    for ( size_t i = 0; i < n; ++i)
     {
     {
-        m_graphicContext->SetFont( m_font );
+        path.MoveToPoint(beginPoints[i].m_x, beginPoints[i].m_y);
+        path.AddLineToPoint( endPoints[i].m_x, endPoints[i].m_y );
     }
     }
+    StrokePath( path );
 }
 
 }
 
-bool wxGCDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
+// create a 'native' matrix corresponding to these values
+wxGraphicsMatrix wxGraphicsContext::CreateMatrix( wxDouble a, wxDouble b, wxDouble c, wxDouble d,
+    wxDouble tx, wxDouble ty) const
 {
 {
-    wxCHECK_MSG( Ok(), false, wxT("wxGCDC(cg)::DoGetPartialTextExtents - invalid DC") );
-    widths.Clear();
-    widths.Add(0,text.Length());
-    if ( text.IsEmpty() )
-        return true ;
-
-    wxArrayDouble widthsD ;
-
-    m_graphicContext->GetPartialTextExtents( text, widthsD );
-    for ( size_t i = 0; i < widths.GetCount(); ++i )
-        widths[i] = DeviceToLogicalXRel( widthsD[i] + 0.5 ) ;
+    return GetRenderer()->CreateMatrix(a,b,c,d,tx,ty);
+}
 
 
-    return true;
+wxGraphicsPath wxGraphicsContext::CreatePath() const
+{
+    return GetRenderer()->CreatePath();
 }
 
 }
 
-wxCoord wxGCDC::GetCharWidth(void) const
+wxGraphicsPen wxGraphicsContext::CreatePen(const wxPen& pen) const
 {
 {
-    wxCoord width;
-    DoGetTextExtent( wxT("g") , &width , NULL , NULL , NULL , NULL );
+    return GetRenderer()->CreatePen(pen);
+}
 
 
-    return width;
+wxGraphicsBrush wxGraphicsContext::CreateBrush(const wxBrush& brush ) const
+{
+    return GetRenderer()->CreateBrush(brush);
 }
 
 }
 
-wxCoord wxGCDC::GetCharHeight(void) const
+wxGraphicsBrush
+wxGraphicsContext::CreateLinearGradientBrush(
+    wxDouble x1, wxDouble y1,
+    wxDouble x2, wxDouble y2,
+    const wxColour& c1, const wxColour& c2) const
 {
 {
-    wxCoord height;
-    DoGetTextExtent( wxT("g") , NULL , &height , NULL , NULL , NULL );
+    return GetRenderer()->CreateLinearGradientBrush
+                          (
+                            x1, y1,
+                            x2, y2,
+                            wxGraphicsGradientStops(c1,c2)
+                          );
+}
 
 
-    return height;
+wxGraphicsBrush
+wxGraphicsContext::CreateLinearGradientBrush(
+    wxDouble x1, wxDouble y1,
+    wxDouble x2, wxDouble y2,
+    const wxGraphicsGradientStops& gradientStops) const
+{
+    return GetRenderer()->CreateLinearGradientBrush(x1,y1,x2,y2, gradientStops);
 }
 
 }
 
-void wxGCDC::Clear(void)
+wxGraphicsBrush
+wxGraphicsContext::CreateRadialGradientBrush(
+        wxDouble xo, wxDouble yo,
+        wxDouble xc, wxDouble yc, wxDouble radius,
+        const wxColour &oColor, const wxColour &cColor) const
 {
 {
-    wxCHECK_RET( Ok(), wxT("wxGCDC(cg)::Clear - invalid DC") );
-    // TODO better implementation / incorporate size info into wxGCDC or context
-       m_graphicContext->SetBrush( m_backgroundBrush );
-       wxPen p = *wxTRANSPARENT_PEN ;
-       m_graphicContext->SetPen( p );
-       DoDrawRectangle( 0, 0, 32000 , 32000 );
-       m_graphicContext->SetPen( m_pen ) ;     
-       m_graphicContext->SetBrush( m_brush );
+    return GetRenderer()->CreateRadialGradientBrush
+                          (
+                            xo, yo,
+                            xc, yc, radius,
+                            wxGraphicsGradientStops(oColor, cColor)
+                          );
 }
 
 }
 
-void wxGCDC::DoGetSize(int *width, int *height) const
+wxGraphicsBrush
+wxGraphicsContext::CreateRadialGradientBrush(
+        wxDouble xo, wxDouble yo,
+        wxDouble xc, wxDouble yc, wxDouble radius,
+        const wxGraphicsGradientStops& gradientStops) const
 {
 {
-    *width = 1000;
-    *height = 1000;
+    return GetRenderer()->CreateRadialGradientBrush
+                          (
+                            xo, yo,
+                            xc, yc, radius,
+                            gradientStops
+                          );
 }
 
 }
 
-void wxGCDC::DoGradientFillLinear(const wxRect& rect,
-                                  const wxColour& initialColour,
-                                  const wxColour& destColour,
-                                  wxDirection nDirection )
+wxGraphicsFont wxGraphicsContext::CreateFont( const wxFont &font , const wxColour &col ) const
 {
 {
-    wxPoint start ;
-    wxPoint end ;
-    switch( nDirection)
-    {
-    case wxWEST :
-        start = rect.GetRightBottom();
-        start.x++;
-        end = rect.GetLeftBottom();
-        break ;
-    case wxEAST :
-        start = rect.GetLeftBottom();
-        end = rect.GetRightBottom();
-        end.x++;
-        break ;
-    case wxNORTH :
-        start = rect.GetLeftBottom();
-        start.y++;
-        end = rect.GetLeftTop();
-        break ;
-    case wxSOUTH :
-        start = rect.GetLeftTop();
-        end = rect.GetLeftBottom();
-        end.y++;
-        break ;
-       default :
-               break;
-    }
+    return GetRenderer()->CreateFont(font,col);
+}
 
 
-    m_graphicContext->SetLinearGradientBrush(
-        LogicalToDeviceX(start.x),LogicalToDeviceY(start.y),
-        LogicalToDeviceX(end.x),LogicalToDeviceY(end.y), initialColour, destColour);
+wxGraphicsFont
+wxGraphicsContext::CreateFont(double size,
+                              const wxString& facename,
+                              int flags,
+                              const wxColour& col) const
+{
+    return GetRenderer()->CreateFont(size, facename, flags, col);
+}
 
 
-    wxCoord xx = LogicalToDeviceX(rect.x);
-    wxCoord yy = LogicalToDeviceY(rect.y);
-    wxDouble ww = m_signX * LogicalToDeviceXRel(rect.width);
-    wxCoord hh = m_signY * LogicalToDeviceYRel(rect.height);
+wxGraphicsBitmap wxGraphicsContext::CreateBitmap( const wxBitmap& bmp ) const
+{
+    return GetRenderer()->CreateBitmap(bmp);
+}
 
 
-    if (ww == 0 || hh == 0)
-        return;
+#if wxUSE_IMAGE
+wxGraphicsBitmap wxGraphicsContext::CreateBitmapFromImage(const wxImage& image) const
+{
+    return GetRenderer()->CreateBitmapFromImage(image);
+}
+#endif // wxUSE_IMAGE
 
 
-    if (ww < 0)
-    {
-        ww = -ww;
-        xx = xx - ww;
-    }
-    if (hh < 0)
-    {
-        hh = -hh;
-        yy = yy - hh;
-    }
+wxGraphicsBitmap wxGraphicsContext::CreateSubBitmap( const wxGraphicsBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h   ) const
+{
+    return GetRenderer()->CreateSubBitmap(bmp,x,y,w,h);
+}
 
 
-    m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
-    m_graphicContext->DrawRectangle(xx,yy,ww,hh);
-    m_graphicContext->SetPen(m_pen);
+/* static */ wxGraphicsContext* wxGraphicsContext::Create( const wxWindowDC& dc)
+{
+    return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
 }
 
 }
 
-void wxGCDC::DoGradientFillConcentric(const wxRect& rect,
-                                      const wxColour& initialColour,
-                                      const wxColour& destColour,
-                                      const wxPoint& circleCenter)
+/* static */ wxGraphicsContext* wxGraphicsContext::Create( const wxMemoryDC& dc)
 {
 {
-    //Radius
-    wxInt32 cx = rect.GetWidth() / 2;
-    wxInt32 cy = rect.GetHeight() / 2;
-    wxInt32 nRadius;
-    if (cx < cy)
-        nRadius = cx;
-    else
-        nRadius = cy;
+    return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
+}
 
 
-    wxCoord xx = LogicalToDeviceX(rect.x);
-    wxCoord yy = LogicalToDeviceY(rect.y);
-    wxDouble ww = m_signX * LogicalToDeviceXRel(rect.width);
-    wxCoord hh = m_signY * LogicalToDeviceYRel(rect.height);
+#if wxUSE_PRINTING_ARCHITECTURE
+/* static */ wxGraphicsContext* wxGraphicsContext::Create( const wxPrinterDC& dc)
+{
+    return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
+}
+#endif
 
 
-    if (ww == 0 || hh == 0)
-        return;
+#ifdef __WXMSW__
+#if wxUSE_ENH_METAFILE
+/* static */ wxGraphicsContext* wxGraphicsContext::Create( const wxEnhMetaFileDC& dc)
+{
+    return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(dc);
+}
+#endif
+#endif
 
 
-    if (ww < 0)
-    {
-        ww = -ww;
-        xx = xx - ww;
-    }
-    if (hh < 0)
-    {
-        hh = -hh;
-        yy = yy - hh;
-    }
+wxGraphicsContext* wxGraphicsContext::CreateFromNative( void * context )
+{
+    return wxGraphicsRenderer::GetDefaultRenderer()->CreateContextFromNativeContext(context);
+}
 
 
-    m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
-    m_graphicContext->SetBrush( wxBrush( destColour) ) ;
-    m_graphicContext->DrawRectangle( xx,yy,ww,hh);
+wxGraphicsContext* wxGraphicsContext::CreateFromNativeWindow( void * window )
+{
+    return wxGraphicsRenderer::GetDefaultRenderer()->CreateContextFromNativeWindow(window);
+}
 
 
-    m_graphicContext->SetRadialGradientBrush(
-        xx+LogicalToDeviceX(circleCenter.x),yy+LogicalToDeviceY(circleCenter.y),
-        xx+LogicalToDeviceX(circleCenter.x),yy+LogicalToDeviceY(circleCenter.y),
-        LogicalToDeviceXRel(nRadius),
-        initialColour,destColour);
+wxGraphicsContext* wxGraphicsContext::Create( wxWindow* window )
+{
+    return wxGraphicsRenderer::GetDefaultRenderer()->CreateContext(window);
+}
 
 
-    m_graphicContext->DrawRectangle( xx,yy,ww,hh);
-    m_graphicContext->SetPen(m_pen);
+#if wxUSE_IMAGE
+/* static */ wxGraphicsContext* wxGraphicsContext::Create(wxImage& image)
+{
+    return wxGraphicsRenderer::GetDefaultRenderer()->CreateContextFromImage(image);
 }
 }
+#endif // wxUSE_IMAGE
 
 
-void wxGCDC::DoDrawCheckMark(wxCoord x, wxCoord y,
-                             wxCoord width, wxCoord height)
+wxGraphicsContext* wxGraphicsContext::Create()
 {
 {
-    wxDCBase::DoDrawCheckMark(x,y,width,height);
+    return wxGraphicsRenderer::GetDefaultRenderer()->CreateMeasuringContext();
 }
 
 }
 
+//-----------------------------------------------------------------------------
+// wxGraphicsRenderer
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxGraphicsRenderer, wxObject)
+
 #endif // wxUSE_GRAPHICS_CONTEXT
 #endif // wxUSE_GRAPHICS_CONTEXT
wxWidgets (Impactor)