remove warnings

[wxWidgets.git] / include / wx / dc.h

diff --git a/include/wx/dc.h b/include/wx/dc.h
index a77cfee664c9ccda56a7c426a59cfc9a9bb4296d..97f362589cfb08348713732e93690bbfb28f33ef 100644 (file)
--- a/include/wx/dc.h
+++ b/include/wx/dc.h
@@ -26,7 +26,6 @@
 #include "wx/brush.h"
 #include "wx/pen.h"
 #include "wx/palette.h"
 #include "wx/brush.h"
 #include "wx/pen.h"
 #include "wx/palette.h"

-#include "wx/list.h"            // we use wxList in inline functions

 #include "wx/dynarray.h"
 #include "wx/math.h"
 #include "wx/image.h"
 #include "wx/dynarray.h"
 #include "wx/math.h"
 #include "wx/image.h"


@@ -35,6 +34,81 @@
 #define wxUSE_NEW_DC 0
 
 
 #define wxUSE_NEW_DC 0
 
 

+#if wxUSE_NEW_DC
+class WXDLLIMPEXP_FWD_CORE wxDC;
+class WXDLLIMPEXP_FWD_CORE wxClientDC;
+class WXDLLIMPEXP_FWD_CORE wxPaintDC;
+class WXDLLIMPEXP_FWD_CORE wxWindowDC;
+class WXDLLIMPEXP_FWD_CORE wxScreenDC;
+class WXDLLIMPEXP_FWD_CORE wxMemoryDC;
+class WXDLLIMPEXP_FWD_CORE wxPrinterDC;
+#include "wx/cmndata.h"
+#else
+class WXDLLIMPEXP_FWD_CORE wxDCBase;
+#endif
+
+class WXDLLEXPORT wxDrawObject
+{
+public:
+
+    wxDrawObject()
+        : m_isBBoxValid(false)
+        , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
+    { }
+
+    virtual ~wxDrawObject() { }
+
+#if wxUSE_NEW_DC
+    virtual void Draw(wxDC&) const { }
+#else
+    virtual void Draw(wxDCBase&) const { }
+#endif
+
+    virtual void CalcBoundingBox(wxCoord x, wxCoord y)
+    {
+      if ( m_isBBoxValid )
+      {
+         if ( x < m_minX ) m_minX = x;
+         if ( y < m_minY ) m_minY = y;
+         if ( x > m_maxX ) m_maxX = x;
+         if ( y > m_maxY ) m_maxY = y;
+      }
+      else
+      {
+         m_isBBoxValid = true;
+
+         m_minX = x;
+         m_minY = y;
+         m_maxX = x;
+         m_maxY = y;
+      }
+    }
+
+    void ResetBoundingBox()
+    {
+        m_isBBoxValid = false;
+
+        m_minX = m_maxX = m_minY = m_maxY = 0;
+    }
+
+    // Get the final bounding box of the PostScript or Metafile picture.
+
+    wxCoord MinX() const { return m_minX; }
+    wxCoord MaxX() const { return m_maxX; }
+    wxCoord MinY() const { return m_minY; }
+    wxCoord MaxY() const { return m_maxY; }
+
+    //to define the type of object for derived objects
+    virtual int GetType()=0;
+
+protected:
+    //for boundingbox calculation
+    bool m_isBBoxValid:1;
+    //for boundingbox calculation
+    wxCoord m_minX, m_minY, m_maxX, m_maxY;
+};
+
+

 #if wxUSE_NEW_DC
 
 //-----------------------------------------------------------------------------
 #if wxUSE_NEW_DC
 
 //-----------------------------------------------------------------------------


@@ -49,15 +123,17 @@ public:
     wxDCFactory() {}
     virtual ~wxDCFactory() {}
     
     wxDCFactory() {}
     virtual ~wxDCFactory() {}
     

-    virtual wxImplDC* CreateWindowDC() = 0;
-    virtual wxImplDC* CreateWindowDC( wxWindow *window ) = 0;
-    virtual wxImplDC* CreateClientDC() = 0;
-    virtual wxImplDC* CreateClientDC( wxWindow *window ) = 0;
-    virtual wxImplDC* CreatePaintDC() = 0;
-    virtual wxImplDC* CreatePaintDC( wxWindow *window ) = 0;
-    virtual wxImplDC* CreateMemoryDC() = 0;
-    virtual wxImplDC* CreateMemoryDC( wxBitmap &bitmap ) = 0;
-    virtual wxImplDC* CreateMemoryDC( wxDC *dc ) = 0;
+    virtual wxImplDC* CreateWindowDC( wxWindowDC *owner ) = 0;
+    virtual wxImplDC* CreateWindowDC( wxWindowDC *owner, wxWindow *window ) = 0;
+    virtual wxImplDC* CreateClientDC( wxClientDC *owner ) = 0;
+    virtual wxImplDC* CreateClientDC( wxClientDC *owner, wxWindow *window ) = 0;
+    virtual wxImplDC* CreatePaintDC( wxPaintDC *owner ) = 0;
+    virtual wxImplDC* CreatePaintDC( wxPaintDC *owner, wxWindow *window ) = 0;
+    virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner ) = 0;
+    virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap ) = 0;
+    virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxDC *dc ) = 0;
+    virtual wxImplDC* CreateScreenDC( wxScreenDC *owner ) = 0;
+    virtual wxImplDC* CreatePrinterDC( wxPrinterDC *owner, const wxPrintData &data  ) = 0;

     
     static void SetDCFactory( wxDCFactory *factory );
     static wxDCFactory *GetFactory();
     
     static void SetDCFactory( wxDCFactory *factory );
     static wxDCFactory *GetFactory();


@@ -69,77 +145,22 @@ private:
 // wxNativeDCFactory
 //-----------------------------------------------------------------------------
 
 // wxNativeDCFactory
 //-----------------------------------------------------------------------------
 

-class WXDLLIMPEXP_CORE wxDCFactory
+class WXDLLIMPEXP_CORE wxNativeDCFactory: public wxDCFactory

 {
 public:
     wxNativeDCFactory() {}
     
 {
 public:
     wxNativeDCFactory() {}
     

-    virtual wxImplDC* CreateWindowDC();
-    virtual wxImplDC* CreateWindowDC( wxWindow *window );
-    virtual wxImplDC* CreateClientDC();
-    virtual wxImplDC* CreateClientDC( wxWindow *window );
-    virtual wxImplDC* CreatePaintDC();
-    virtual wxImplDC* CreatePaintDC( wxWindow *window );
-    virtual wxImplDC* CreateMemoryDC();
-    virtual wxImplDC* CreateMemoryDC( wxBitmap &bitmap );
-    virtual wxImplDC* CreateMemoryDC( wxDC *dc );
-};
-
-//-----------------------------------------------------------------------------
-// wxWindowDC
-//-----------------------------------------------------------------------------
-
-class WXDLLIMPEXP_CORE wxWindowDC : public wxDC
-{
-public:
-    wxWindowDC();
-    wxWindowDC( wxWindow *win );
-
-private:
-    DECLARE_DYNAMIC_CLASS(wxWindowDC)
-};
-
-//-----------------------------------------------------------------------------
-// wxClientDC
-//-----------------------------------------------------------------------------
-
-class WXDLLIMPEXP_CORE wxClientDC : public wxDC
-{
-public:
-    wxClientDC();
-    wxClientDC( wxWindow *win );
-
-private:
-    DECLARE_DYNAMIC_CLASS(wxClientDC)
-};
-
-//-----------------------------------------------------------------------------
-// wxMemoryDC
-//-----------------------------------------------------------------------------
-
-class WXDLLIMPEXP_CORE wxMemoryDC: public wxDC
-{
-public:
-    wxMemoryDC();
-    wxMemoryDC( wxBitmap& bitmap );
-    wxMemoryDC( wxDC *dc );
-    
-private:
-    DECLARE_DYNAMIC_CLASS(wxMemoryDC)
-};
-    
-//-----------------------------------------------------------------------------
-// wxPaintDC
-//-----------------------------------------------------------------------------
-
-class WXDLLIMPEXP_CORE wxPaintDC : public wxDC
-{
-public:
-    wxPaintDC();
-    wxPaintDC( wxWindow *win );
-
-private:
-    DECLARE_DYNAMIC_CLASS(wxPaintDC)
+    virtual wxImplDC* CreateWindowDC( wxWindowDC *owner );
+    virtual wxImplDC* CreateWindowDC( wxWindowDC *owner, wxWindow *window );
+    virtual wxImplDC* CreateClientDC( wxClientDC *owner );
+    virtual wxImplDC* CreateClientDC( wxClientDC *owner, wxWindow *window );
+    virtual wxImplDC* CreatePaintDC( wxPaintDC *owner );
+    virtual wxImplDC* CreatePaintDC( wxPaintDC *owner, wxWindow *window );
+    virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner );
+    virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxBitmap &bitmap );
+    virtual wxImplDC* CreateMemoryDC( wxMemoryDC *owner, wxDC *dc );
+    virtual wxImplDC* CreateScreenDC( wxScreenDC *owner );
+    virtual wxImplDC* CreatePrinterDC( wxPrinterDC *owner, const wxPrintData &data  );

 };
 
 //-----------------------------------------------------------------------------
 };
 
 //-----------------------------------------------------------------------------


@@ -152,7 +173,7 @@ public:
     wxImplDC( wxDC *owner );
     ~wxImplDC();
     
     wxImplDC( wxDC *owner );
     ~wxImplDC();
     

-    wxDC *GetOwner() { return m_owner; }
+    wxDC *GetOwner() const { return m_owner; }

     
     virtual bool IsOk() const { return m_ok; }
 
     
     virtual bool IsOk() const { return m_ok; }
 


@@ -182,9 +203,12 @@ public:
     virtual void StartPage() { }
     virtual void EndPage() { }
 
     virtual void StartPage() { }
     virtual void EndPage() { }
 

+    // flushing the content of this dc immediately eg onto screen
+    virtual void Flush() { }
+

     // bounding box
 
     // bounding box
 

-    virtual void CalcBoundingBox(wxCoord x, wxCoord y);
+    virtual void CalcBoundingBox(wxCoord x, wxCoord y)

     {
       if ( m_isBBoxValid )
       {
     {
       if ( m_isBBoxValid )
       {


@@ -203,7 +227,7 @@ public:
          m_maxY = y;
       }
     }
          m_maxY = y;
       }
     }

-    void ResetBoundingBox();
+    void ResetBoundingBox()

     {
         m_isBBoxValid = false;
 
     {
         m_isBBoxValid = false;
 


@@ -410,20 +434,47 @@ public:
 
 
     virtual void DoDrawLines(int n, wxPoint points[],
 
 
     virtual void DoDrawLines(int n, wxPoint points[],

-                             wxCoord xoffset, wxCoord yoffset) = 0;
+                             wxCoord xoffset, wxCoord yoffset ) = 0;
+    virtual void DrawLines(const wxPointList *list,
+                           wxCoord xoffset, wxCoord yoffset );
+                           

     virtual void DoDrawPolygon(int n, wxPoint points[],
                                wxCoord xoffset, wxCoord yoffset,
                                int fillStyle = wxODDEVEN_RULE) = 0;
     virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
                                wxCoord xoffset, wxCoord yoffset,
                                int fillStyle);
     virtual void DoDrawPolygon(int n, wxPoint points[],
                                wxCoord xoffset, wxCoord yoffset,
                                int fillStyle = wxODDEVEN_RULE) = 0;
     virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
                                wxCoord xoffset, wxCoord yoffset,
                                int fillStyle);

-
+    void DrawPolygon(const wxPointList *list,
+                     wxCoord xoffset, wxCoord yoffset,
+                     int fillStyle );

 
 
 #if wxUSE_SPLINES
 
 
 #if wxUSE_SPLINES

-    virtual void DoDrawSpline(wxList *points);
+    virtual void DoDrawSpline(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3);
+    virtual void DoDrawSpline(int n, wxPoint points[]);
+    virtual void DoDrawSpline(const wxPointList *points);

 #endif
     
 #endif
     

+    // ---------------------------------------------------------
+    // wxMemoryDC Impl API
+
+    virtual void DoSelect(const wxBitmap& WXUNUSED(bmp))
+       { }
+    
+    virtual const wxBitmap& GetSelectedBitmap() const
+        { return wxNullBitmap; }
+    virtual wxBitmap& GetSelectedBitmap()
+        { return wxNullBitmap; }
+  
+    // ---------------------------------------------------------
+    // wxPrinterDC Impl API
+
+    virtual wxRect GetPaperRect()
+        { int w = 0; int h = 0; DoGetSize( &w, &h ); return wxRect(0,0,w,h); }
+        
+    virtual int GetResolution()
+        { return -1; }
+

 private:
     wxDC    *m_owner;
 
 private:
     wxDC    *m_owner;
 


@@ -486,7 +537,7 @@ protected:
 
 private:
     DECLARE_ABSTRACT_CLASS(wxImplDC)
 
 private:
     DECLARE_ABSTRACT_CLASS(wxImplDC)

-}
+};

 
 
 class wxDC: public wxObject
 
 
 class wxDC: public wxObject


@@ -494,6 +545,12 @@ class wxDC: public wxObject
 public:
     wxDC()   { m_pimpl = NULL; }
 
 public:
     wxDC()   { m_pimpl = NULL; }
 

+    wxImplDC *GetImpl()
+        { return m_pimpl; }
+    const wxImplDC *GetImpl() const
+        { return m_pimpl; }
+
+

     bool IsOk() const 
         { return m_pimpl && m_pimpl->IsOk(); }
 
     bool IsOk() const 
         { return m_pimpl && m_pimpl->IsOk(); }
 


@@ -530,6 +587,9 @@ public:
     wxSize GetPPI() const
         { return m_pimpl->GetPPI(); }
 
     wxSize GetPPI() const
         { return m_pimpl->GetPPI(); }
 

+    virtual int GetResolution()
+        { return m_pimpl->GetResolution(); }
+        

     // Right-To-Left (RTL) modes
     
     void SetLayoutDirection(wxLayoutDirection dir)
     // Right-To-Left (RTL) modes
     
     void SetLayoutDirection(wxLayoutDirection dir)


@@ -588,9 +648,9 @@ public:
         { return m_pimpl->GetBackground(); }
     
     void SetBackgroundMode(int mode)
         { return m_pimpl->GetBackground(); }
     
     void SetBackgroundMode(int mode)

-        { m_pimpl->SetBackground( mode ); }
+        { m_pimpl->SetBackgroundMode( mode ); }

     int GetBackgroundMode() const
     int GetBackgroundMode() const

-        { return m_pimpl->GetBackground(); }
+        { return m_pimpl->GetBackgroundMode(); }

 
     void SetTextForeground(const wxColour& colour)
         { m_pimpl->SetTextForeground(colour); }
 
     void SetTextForeground(const wxColour& colour)
         { m_pimpl->SetTextForeground(colour); }


@@ -680,19 +740,19 @@ public:
 
     wxCoord DeviceToLogicalX(wxCoord x) const
         { return m_pimpl->DeviceToLogicalX(x); }
 
     wxCoord DeviceToLogicalX(wxCoord x) const
         { return m_pimpl->DeviceToLogicalX(x); }

-    wxCoord DeviceToLogicalY(wxCoord y) const;
+    wxCoord DeviceToLogicalY(wxCoord y) const

         { return m_pimpl->DeviceToLogicalY(y); }
         { return m_pimpl->DeviceToLogicalY(y); }

-    wxCoord DeviceToLogicalXRel(wxCoord x) const;
+    wxCoord DeviceToLogicalXRel(wxCoord x) const

         { return m_pimpl->DeviceToLogicalXRel(x); }
         { return m_pimpl->DeviceToLogicalXRel(x); }

-    wxCoord DeviceToLogicalYRel(wxCoord y) const;
+    wxCoord DeviceToLogicalYRel(wxCoord y) const

         { return m_pimpl->DeviceToLogicalYRel(y); }
         { return m_pimpl->DeviceToLogicalYRel(y); }

-    wxCoord LogicalToDeviceX(wxCoord x) const;
+    wxCoord LogicalToDeviceX(wxCoord x) const

         { return m_pimpl->LogicalToDeviceX(x); }
         { return m_pimpl->LogicalToDeviceX(x); }

-    wxCoord LogicalToDeviceY(wxCoord y) const;
+    wxCoord LogicalToDeviceY(wxCoord y) const

         { return m_pimpl->LogicalToDeviceY(y); }
         { return m_pimpl->LogicalToDeviceY(y); }

-    wxCoord LogicalToDeviceXRel(wxCoord x) const;
+    wxCoord LogicalToDeviceXRel(wxCoord x) const

         { return m_pimpl->LogicalToDeviceXRel(x); }
         { return m_pimpl->LogicalToDeviceXRel(x); }

-    wxCoord LogicalToDeviceYRel(wxCoord y) const;
+    wxCoord LogicalToDeviceYRel(wxCoord y) const

         { return m_pimpl->LogicalToDeviceYRel(y); }
 
     void SetMapMode(int mode)
         { return m_pimpl->LogicalToDeviceYRel(y); }
 
     void SetMapMode(int mode)


@@ -756,9 +816,9 @@ public:
     void GradientFillConcentric(const wxRect& rect,
                                 const wxColour& initialColour,
                                 const wxColour& destColour)
     void GradientFillConcentric(const wxRect& rect,
                                 const wxColour& initialColour,
                                 const wxColour& destColour)

-        { m_pimpl->GradientFillConcentric(rect, initialColour, destColour,
-                                 wxPoint(rect.GetWidth() / 2,
-                                         rect.GetHeight() / 2)); }
+        { m_pimpl->DoGradientFillConcentric( rect, initialColour, destColour,
+                                             wxPoint(rect.GetWidth() / 2,
+                                                     rect.GetHeight() / 2)); }

 
     void GradientFillConcentric(const wxRect& rect,
                                 const wxColour& initialColour,
 
     void GradientFillConcentric(const wxRect& rect,
                                 const wxColour& initialColour,


@@ -815,24 +875,31 @@ public:
     void DrawLines(int n, wxPoint points[],
                    wxCoord xoffset = 0, wxCoord yoffset = 0)
         { m_pimpl->DoDrawLines(n, points, xoffset, yoffset); }
     void DrawLines(int n, wxPoint points[],
                    wxCoord xoffset = 0, wxCoord yoffset = 0)
         { m_pimpl->DoDrawLines(n, points, xoffset, yoffset); }

-    void DrawLines(const wxList *list,
+    void DrawLines(const wxPointList *list,

                    wxCoord xoffset = 0, wxCoord yoffset = 0)
                    wxCoord xoffset = 0, wxCoord yoffset = 0)

-        { m_pimpl->DrawLines( list, xoffset, yoffset ); }
+        { m_pimpl->DrawLines( list, xoffset, yoffset ); }      
+#if WXWIN_COMPATIBILITY_2_8
+    wxDEPRECATED( void DrawLines(const wxList *list,
+                                 wxCoord xoffset = 0, wxCoord yoffset = 0) );
+#endif  // WXWIN_COMPATIBILITY_2_8

 
     void DrawPolygon(int n, wxPoint points[],
                      wxCoord xoffset = 0, wxCoord yoffset = 0,
                      int fillStyle = wxODDEVEN_RULE)
         { m_pimpl->DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
 
     void DrawPolygon(int n, wxPoint points[],
                      wxCoord xoffset = 0, wxCoord yoffset = 0,
                      int fillStyle = wxODDEVEN_RULE)
         { m_pimpl->DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }

-
-    void DrawPolygon(const wxList *list,
+    void DrawPolygon(const wxPointList *list,

                      wxCoord xoffset = 0, wxCoord yoffset = 0,
                      int fillStyle = wxODDEVEN_RULE)
         { m_pimpl->DrawPolygon( list, xoffset, yoffset, fillStyle ); }
                      wxCoord xoffset = 0, wxCoord yoffset = 0,
                      int fillStyle = wxODDEVEN_RULE)
         { m_pimpl->DrawPolygon( list, xoffset, yoffset, fillStyle ); }

-

     void DrawPolyPolygon(int n, int count[], wxPoint points[],
                          wxCoord xoffset = 0, wxCoord yoffset = 0,
                          int fillStyle = wxODDEVEN_RULE)
         { m_pimpl->DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle); }
     void DrawPolyPolygon(int n, int count[], wxPoint points[],
                          wxCoord xoffset = 0, wxCoord yoffset = 0,
                          int fillStyle = wxODDEVEN_RULE)
         { m_pimpl->DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle); }

+#if WXWIN_COMPATIBILITY_2_8
+    wxDEPRECATED( void DrawPolygon(const wxList *list,
+                     wxCoord xoffset = 0, wxCoord yoffset = 0,
+                     int fillStyle = wxODDEVEN_RULE) );
+#endif  // WXWIN_COMPATIBILITY_2_8

 
     void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
         { m_pimpl->DoDrawRectangle(x, y, width, height); }
 
     void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
         { m_pimpl->DoDrawRectangle(x, y, width, height); }


@@ -853,7 +920,7 @@ public:
     void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
         { m_pimpl->DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
     void DrawCircle(const wxPoint& pt, wxCoord radius)
     void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
         { m_pimpl->DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
     void DrawCircle(const wxPoint& pt, wxCoord radius)

-        { m_pimpl->DrawCircle(pt.x, pt.y, radius); }
+        { m_pimpl->DoDrawEllipse(pt.x - radius, pt.y - radius, 2*radius, 2*radius); }

 
     void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
         { m_pimpl->DoDrawEllipse(x, y, width, height); }
 
     void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
         { m_pimpl->DoDrawEllipse(x, y, width, height); }


@@ -874,49 +941,6 @@ public:
                     bool useMask = false)
         { m_pimpl->DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
 
                     bool useMask = false)
         { m_pimpl->DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
 

-    virtual void DrawScaledBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, wxCoord w, wxCoord h, bool useMask = false, int quality = wxIMAGE_QUALITY_NORMAL)
-        {
-            if (bmp.GetWidth() != w || bmp.GetHeight() != h)
-            {
-                if (quality != wxIMAGE_QUALITY_HIGH)
-                    quality = wxIMAGE_QUALITY_NORMAL;
-                wxImage tmpImg = bmp.ConvertToImage();
-                tmpImg.Rescale( w, h, quality );
-                wxBitmap scaledBmp(tmpImg);
-                m_pimpl->DoDrawBitmap(scaledBmp, x, y, useMask);
-            }
-            else
-                m_pimpl->DoDrawBitmap(bmp, x, y, useMask);
-        }
-    virtual void DrawScaledBitmap(const wxBitmap &bmp, const wxPoint& pt, const wxSize& sz, bool useMask = false, int quality = wxIMAGE_QUALITY_NORMAL)
-        {
-            if (bmp.GetWidth() != sz.x || bmp.GetHeight() != sz.y)
-            {
-                if (quality != wxIMAGE_QUALITY_HIGH)
-                    quality = wxIMAGE_QUALITY_NORMAL;
-                wxImage tmpImg = bmp.ConvertToImage();
-                tmpImg.Rescale( sz.x, sz.y, quality );
-                wxBitmap scaledBmp(tmpImg);
-                m_pimpl->DoDrawBitmap(scaledBmp, pt.x, pt.y, useMask);
-            }
-            else
-                m_pimpl->DoDrawBitmap(bmp, pt.x, pt.y, useMask);
-        }
-    virtual void DrawScaledBitmap(const wxBitmap &bmp, const wxRect& rect, bool useMask = false, int quality = wxIMAGE_QUALITY_NORMAL)
-        {
-            if (bmp.GetWidth() != rect.width || bmp.GetHeight() != rect.height)
-            {
-                if (quality != wxIMAGE_QUALITY_HIGH)
-                    quality = wxIMAGE_QUALITY_NORMAL;
-                wxImage tmpImg = bmp.ConvertToImage();
-                tmpImg.Rescale( rect.width, rect.height, quality );
-                wxBitmap scaledBmp(tmpImg);
-                m_pimpl->DoDrawBitmap(scaledBmp, rect.x, rect.y, useMask);
-            }
-            else
-                m_pimpl->DoDrawBitmap(bmp, rect.x, rect.y, useMask);
-        }
-

     void DrawText(const wxString& text, wxCoord x, wxCoord y)
         { m_pimpl->DoDrawText(text, x, y); }
     void DrawText(const wxString& text, const wxPoint& pt)
     void DrawText(const wxString& text, wxCoord x, wxCoord y)
         { m_pimpl->DoDrawText(text, x, y); }
     void DrawText(const wxString& text, const wxPoint& pt)


@@ -936,13 +960,12 @@ public:
                            const wxRect& rect,
                            int alignment = wxALIGN_LEFT | wxALIGN_TOP,
                            int indexAccel = -1,
                            const wxRect& rect,
                            int alignment = wxALIGN_LEFT | wxALIGN_TOP,
                            int indexAccel = -1,

-                           wxRect *rectBounding = NULL)
-        { m_pimpl->DrawLabel( text, image, rect, alignment, indexAccel, rectBounding ); }
+                           wxRect *rectBounding = NULL);

 
     void DrawLabel(const wxString& text, const wxRect& rect,
                    int alignment = wxALIGN_LEFT | wxALIGN_TOP,
                    int indexAccel = -1)
 
     void DrawLabel(const wxString& text, const wxRect& rect,
                    int alignment = wxALIGN_LEFT | wxALIGN_TOP,
                    int indexAccel = -1)

-        { m_pimpl->DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }
+        { DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }

 
     bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
               wxDC *source, wxCoord xsrc, wxCoord ysrc,
 
     bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
               wxDC *source, wxCoord xsrc, wxCoord ysrc,


@@ -984,15 +1007,13 @@ public:
     }
 
 #if wxUSE_SPLINES
     }
 
 #if wxUSE_SPLINES

-    // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)

     void DrawSpline(wxCoord x1, wxCoord y1,
                     wxCoord x2, wxCoord y2,
                     wxCoord x3, wxCoord y3)
     void DrawSpline(wxCoord x1, wxCoord y1,
                     wxCoord x2, wxCoord y2,
                     wxCoord x3, wxCoord y3)

-        { m_pimpl->DrawSpline(x1,y1,x2,y2,x3,y3); }
+        { m_pimpl->DoDrawSpline(x1,y1,x2,y2,x3,y3); }

     void DrawSpline(int n, wxPoint points[])
     void DrawSpline(int n, wxPoint points[])

-        { m_pimpl->DrawSpline(n,points); }
-
-    void DrawSpline(wxList *points) 
+        { m_pimpl->DoDrawSpline(n,points); }
+    void DrawSpline(const wxPointList *points) 

         { m_pimpl->DoDrawSpline(points); }
 #endif // wxUSE_SPLINES
 
         { m_pimpl->DoDrawSpline(points); }
 #endif // wxUSE_SPLINES
 


@@ -1015,71 +1036,55 @@ protected:
 
 private:
     DECLARE_ABSTRACT_CLASS(wxImplDC)
 
 private:
     DECLARE_ABSTRACT_CLASS(wxImplDC)

-}
-
-
-#else  // wxUSE_NEW_DC
+};

 
 
 
 

-class WXDLLIMPEXP_FWD_CORE wxDC;
-class WXDLLIMPEXP_FWD_CORE wxDCBase;
+//-----------------------------------------------------------------------------
+// wxWindowDC
+//-----------------------------------------------------------------------------

 
 

-class WXDLLEXPORT wxDrawObject
+class WXDLLIMPEXP_CORE wxWindowDC : public wxDC

 {
 public:
 {
 public:

+    wxWindowDC();
+    wxWindowDC( wxWindow *win );

 
 

-    wxDrawObject()
-        : m_isBBoxValid(false)
-        , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
-    { }
-
-    virtual ~wxDrawObject() { }
+private:
+    DECLARE_DYNAMIC_CLASS(wxWindowDC)
+};

 
 

-    virtual void Draw(wxDCBase&) const { }
+//-----------------------------------------------------------------------------
+// wxClientDC
+//-----------------------------------------------------------------------------

 
 

-    virtual void CalcBoundingBox(wxCoord x, wxCoord y)
-    {
-      if ( m_isBBoxValid )
-      {
-         if ( x < m_minX ) m_minX = x;
-         if ( y < m_minY ) m_minY = y;
-         if ( x > m_maxX ) m_maxX = x;
-         if ( y > m_maxY ) m_maxY = y;
-      }
-      else
-      {
-         m_isBBoxValid = true;
+class WXDLLIMPEXP_CORE wxClientDC : public wxDC
+{
+public:
+    wxClientDC();
+    wxClientDC( wxWindow *win );

 
 

-         m_minX = x;
-         m_minY = y;
-         m_maxX = x;
-         m_maxY = y;
-      }
-    }
+private:
+    DECLARE_DYNAMIC_CLASS(wxClientDC)
+};

 
 

-    void ResetBoundingBox()
-    {
-        m_isBBoxValid = false;
+//-----------------------------------------------------------------------------
+// wxPaintDC
+//-----------------------------------------------------------------------------

 
 

-        m_minX = m_maxX = m_minY = m_maxY = 0;
-    }
+class WXDLLIMPEXP_CORE wxPaintDC : public wxDC
+{
+public:
+    wxPaintDC();
+    wxPaintDC( wxWindow *win );

 
 

-    // Get the final bounding box of the PostScript or Metafile picture.
+private:
+    DECLARE_DYNAMIC_CLASS(wxPaintDC)
+};

 
 

-    wxCoord MinX() const { return m_minX; }
-    wxCoord MaxX() const { return m_maxX; }
-    wxCoord MinY() const { return m_minY; }
-    wxCoord MaxY() const { return m_maxY; }
+#else  // wxUSE_NEW_DC

 
 

-    //to define the type of object for derived objects
-    virtual int GetType()=0;

 
 

-protected:
-    //for boundingbox calculation
-    bool m_isBBoxValid:1;
-    //for boundingbox calculation
-    wxCoord m_minX, m_minY, m_maxX, m_maxY;
-};
+class WXDLLIMPEXP_FWD_CORE wxDC;

 
 // ---------------------------------------------------------------------------
 // global variables
 
 // ---------------------------------------------------------------------------
 // global variables


@@ -1105,6 +1110,8 @@ public:
         CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
     }
 
         CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
     }
 

+    wxDC *GetOwner() const { return (wxDC*) this; }
+    

     bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
                    int style = wxFLOOD_SURFACE)
         { return DoFloodFill(x, y, col, style); }
     bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
                    int style = wxFLOOD_SURFACE)
         { return DoFloodFill(x, y, col, style); }


@@ -1176,18 +1183,30 @@ public:
     void DrawLines(int n, wxPoint points[],
                    wxCoord xoffset = 0, wxCoord yoffset = 0)
         { DoDrawLines(n, points, xoffset, yoffset); }
     void DrawLines(int n, wxPoint points[],
                    wxCoord xoffset = 0, wxCoord yoffset = 0)
         { DoDrawLines(n, points, xoffset, yoffset); }

-    void DrawLines(const wxList *list,
+    void DrawLines(const wxPointList *list,

                    wxCoord xoffset = 0, wxCoord yoffset = 0);
 
                    wxCoord xoffset = 0, wxCoord yoffset = 0);
 

+#if WXWIN_COMPATIBILITY_2_8
+    wxDEPRECATED( void DrawLines(const wxList *list,
+                                 wxCoord xoffset = 0, wxCoord yoffset = 0) );
+#endif  // WXWIN_COMPATIBILITY_2_8
+
+

     void DrawPolygon(int n, wxPoint points[],
                      wxCoord xoffset = 0, wxCoord yoffset = 0,
                      int fillStyle = wxODDEVEN_RULE)
         { DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
 
     void DrawPolygon(int n, wxPoint points[],
                      wxCoord xoffset = 0, wxCoord yoffset = 0,
                      int fillStyle = wxODDEVEN_RULE)
         { DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
 

-    void DrawPolygon(const wxList *list,
+    void DrawPolygon(const wxPointList *list,

                      wxCoord xoffset = 0, wxCoord yoffset = 0,
                      int fillStyle = wxODDEVEN_RULE);
 
                      wxCoord xoffset = 0, wxCoord yoffset = 0,
                      int fillStyle = wxODDEVEN_RULE);
 

+#if WXWIN_COMPATIBILITY_2_8
+    wxDEPRECATED( void DrawPolygon(const wxList *list,
+                     wxCoord xoffset = 0, wxCoord yoffset = 0,
+                     int fillStyle = wxODDEVEN_RULE) );
+#endif  // WXWIN_COMPATIBILITY_2_8
+

     void DrawPolyPolygon(int n, int count[], wxPoint points[],
                          wxCoord xoffset = 0, wxCoord yoffset = 0,
                          int fillStyle = wxODDEVEN_RULE)
     void DrawPolyPolygon(int n, int count[], wxPoint points[],
                          wxCoord xoffset = 0, wxCoord yoffset = 0,
                          int fillStyle = wxODDEVEN_RULE)


@@ -1233,49 +1252,6 @@ public:
                     bool useMask = false)
         { DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
 
                     bool useMask = false)
         { DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
 

-    virtual void DrawScaledBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, wxCoord w, wxCoord h, bool useMask = false, int quality = wxIMAGE_QUALITY_NORMAL)
-        {
-            if (bmp.GetWidth() != w || bmp.GetHeight() != h)
-            {
-                if (quality != wxIMAGE_QUALITY_HIGH)
-                    quality = wxIMAGE_QUALITY_NORMAL;
-                wxImage tmpImg = bmp.ConvertToImage();
-                tmpImg.Rescale( w, h, quality );
-                wxBitmap scaledBmp(tmpImg);
-                DoDrawBitmap(scaledBmp, x, y, useMask);
-            }
-            else
-                DoDrawBitmap(bmp, x, y, useMask);
-        }
-    virtual void DrawScaledBitmap(const wxBitmap &bmp, const wxPoint& pt, const wxSize& sz, bool useMask = false, int quality = wxIMAGE_QUALITY_NORMAL)
-        {
-            if (bmp.GetWidth() != sz.x || bmp.GetHeight() != sz.y)
-            {
-                if (quality != wxIMAGE_QUALITY_HIGH)
-                    quality = wxIMAGE_QUALITY_NORMAL;
-                wxImage tmpImg = bmp.ConvertToImage();
-                tmpImg.Rescale( sz.x, sz.y, quality );
-                wxBitmap scaledBmp(tmpImg);
-                DoDrawBitmap(scaledBmp, pt.x, pt.y, useMask);
-            }
-            else
-                DoDrawBitmap(bmp, pt.x, pt.y, useMask);
-        }
-    virtual void DrawScaledBitmap(const wxBitmap &bmp, const wxRect& rect, bool useMask = false, int quality = wxIMAGE_QUALITY_NORMAL)
-        {
-            if (bmp.GetWidth() != rect.width || bmp.GetHeight() != rect.height)
-            {
-                if (quality != wxIMAGE_QUALITY_HIGH)
-                    quality = wxIMAGE_QUALITY_NORMAL;
-                wxImage tmpImg = bmp.ConvertToImage();
-                tmpImg.Rescale( rect.width, rect.height, quality );
-                wxBitmap scaledBmp(tmpImg);
-                DoDrawBitmap(scaledBmp, rect.x, rect.y, useMask);
-            }
-            else
-                DoDrawBitmap(bmp, rect.x, rect.y, useMask);
-        }
-

     void DrawText(const wxString& text, wxCoord x, wxCoord y)
         { DoDrawText(text, x, y); }
     void DrawText(const wxString& text, const wxPoint& pt)
     void DrawText(const wxString& text, wxCoord x, wxCoord y)
         { DoDrawText(text, x, y); }
     void DrawText(const wxString& text, const wxPoint& pt)


@@ -1342,13 +1318,17 @@ public:
     }
 
 #if wxUSE_SPLINES
     }
 
 #if wxUSE_SPLINES

-    // TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)

     void DrawSpline(wxCoord x1, wxCoord y1,
                     wxCoord x2, wxCoord y2,
                     wxCoord x3, wxCoord y3);
     void DrawSpline(int n, wxPoint points[]);
 
     void DrawSpline(wxCoord x1, wxCoord y1,
                     wxCoord x2, wxCoord y2,
                     wxCoord x3, wxCoord y3);
     void DrawSpline(int n, wxPoint points[]);
 

-    void DrawSpline(wxList *points) { DoDrawSpline(points); }
+    void DrawSpline(const wxPointList *points) { DoDrawSpline(points); }
+
+#if WXWIN_COMPATIBILITY_2_8
+    wxDEPRECATED( void DrawSpline(const wxList *points) );
+#endif  // WXWIN_COMPATIBILITY_2_8
+    

 #endif // wxUSE_SPLINES
 
     // Eventually we will have wxUSE_GENERIC_DRAWELLIPSE
 #endif // wxUSE_SPLINES
 
     // Eventually we will have wxUSE_GENERIC_DRAWELLIPSE


@@ -1389,11 +1369,11 @@ public:
      *  \param angle Rotating angle (counterclockwise, start at 3 o'clock, 360 is full circle).
      *  \param center Center of rotation.
      */
      *  \param angle Rotating angle (counterclockwise, start at 3 o'clock, 360 is full circle).
      *  \param center Center of rotation.
      */

-    void Rotate( wxList* points, double angle, wxPoint center = wxPoint(0,0) );
+    void Rotate( wxPointList* points, double angle, wxPoint center = wxPoint(0,0) );

 
     // used by DrawEllipticArcRot
     // Careful: wxList gets filled with points you have to delete later.
 
     // used by DrawEllipticArcRot
     // Careful: wxList gets filled with points you have to delete later.

-    void CalculateEllipticPoints( wxList* points,
+    void CalculateEllipticPoints( wxPointList* points,

                                   wxCoord xStart, wxCoord yStart,
                                   wxCoord w, wxCoord h,
                                   double sa, double ea );
                                   wxCoord xStart, wxCoord yStart,
                                   wxCoord w, wxCoord h,
                                   double sa, double ea );


@@ -1526,6 +1506,9 @@ public:
     // Resolution in Pixels per inch
     virtual wxSize GetPPI() const = 0;
 
     // Resolution in Pixels per inch
     virtual wxSize GetPPI() const = 0;
 

+    virtual int GetResolution()
+        { return -1; }
+        

     virtual bool Ok() const { return IsOk(); }
     virtual bool IsOk() const { return m_ok; }
 
     virtual bool Ok() const { return IsOk(); }
     virtual bool IsOk() const { return m_ok; }
 


@@ -1780,7 +1763,7 @@ protected:
     virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const;
 
 #if wxUSE_SPLINES
     virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const;
 
 #if wxUSE_SPLINES

-    virtual void DoDrawSpline(wxList *points);
+    virtual void DoDrawSpline(const wxPointList *points);

 #endif
 
 protected:
 #endif
 
 protected: