Some wxComboCtrlBase member functions were enclosed within incorrect compatibility...

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

diff --git a/include/wx/dc.h b/include/wx/dc.h
index fefa92f50e64e69dc9ecae3ae2286832f1c07c2e..82f4848adf17d3b93427d37c88e2e7e574aaba12 100644 (file)
--- a/include/wx/dc.h
+++ b/include/wx/dc.h
@@ -1,7 +1,7 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/dc.h
 // Purpose:     wxDC class
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/dc.h
 // Purpose:     wxDC class

-// Author:      Vadim Zeitlin 
+// Author:      Vadim Zeitlin

 // Modified by:
 // Created:     05/25/99
 // RCS-ID:      $Id$
 // Modified by:
 // Created:     05/25/99
 // RCS-ID:      $Id$


@@ -42,6 +42,80 @@ class WXDLLIMPEXP_FWD_CORE wxMemoryDC;
 class WXDLLIMPEXP_FWD_CORE wxPrinterDC;
 class WXDLLIMPEXP_FWD_CORE wxPrintData;
 
 class WXDLLIMPEXP_FWD_CORE wxPrinterDC;
 class WXDLLIMPEXP_FWD_CORE wxPrintData;
 

+//  Logical ops
+enum wxRasterOperationMode
+{
+    wxCLEAR,       // 0
+    wxXOR,         // src XOR dst
+    wxINVERT,      // NOT dst
+    wxOR_REVERSE,  // src OR (NOT dst)
+    wxAND_REVERSE, // src AND (NOT dst)
+    wxCOPY,        // src
+    wxAND,         // src AND dst
+    wxAND_INVERT,  // (NOT src) AND dst
+    wxNO_OP,       // dst
+    wxNOR,         // (NOT src) AND (NOT dst)
+    wxEQUIV,       // (NOT src) XOR dst
+    wxSRC_INVERT,  // (NOT src)
+    wxOR_INVERT,   // (NOT src) OR dst
+    wxNAND,        // (NOT src) OR (NOT dst)
+    wxOR,          // src OR dst
+    wxSET          // 1
+#if WXWIN_COMPATIBILITY_2_8
+    ,wxROP_BLACK = wxCLEAR,
+    wxBLIT_BLACKNESS = wxCLEAR,
+    wxROP_XORPEN = wxXOR,
+    wxBLIT_SRCINVERT = wxXOR,
+    wxROP_NOT = wxINVERT,
+    wxBLIT_DSTINVERT = wxINVERT,
+    wxROP_MERGEPENNOT = wxOR_REVERSE,
+    wxBLIT_00DD0228 = wxOR_REVERSE,
+    wxROP_MASKPENNOT = wxAND_REVERSE,
+    wxBLIT_SRCERASE = wxAND_REVERSE,
+    wxROP_COPYPEN = wxCOPY,
+    wxBLIT_SRCCOPY = wxCOPY,
+    wxROP_MASKPEN = wxAND,
+    wxBLIT_SRCAND = wxAND,
+    wxROP_MASKNOTPEN = wxAND_INVERT,
+    wxBLIT_00220326 = wxAND_INVERT,
+    wxROP_NOP = wxNO_OP,
+    wxBLIT_00AA0029 = wxNO_OP,
+    wxROP_NOTMERGEPEN = wxNOR,
+    wxBLIT_NOTSRCERASE = wxNOR,
+    wxROP_NOTXORPEN = wxEQUIV,
+    wxBLIT_00990066 = wxEQUIV,
+    wxROP_NOTCOPYPEN = wxSRC_INVERT,
+    wxBLIT_NOTSCRCOPY = wxSRC_INVERT,
+    wxROP_MERGENOTPEN = wxOR_INVERT,
+    wxBLIT_MERGEPAINT = wxOR_INVERT,
+    wxROP_NOTMASKPEN = wxNAND,
+    wxBLIT_007700E6 = wxNAND,
+    wxROP_MERGEPEN = wxOR,
+    wxBLIT_SRCPAINT = wxOR,
+    wxROP_WHITE = wxSET,
+    wxBLIT_WHITENESS = wxSET
+#endif //WXWIN_COMPATIBILITY_2_8
+};
+
+//  Flood styles
+enum wxFloodFillStyle
+{
+    wxFLOOD_SURFACE = 1,
+    wxFLOOD_BORDER
+};
+
+//  Mapping modes
+enum wxMappingMode
+{
+    wxMM_TEXT = 1,
+    wxMM_METRIC,
+    wxMM_LOMETRIC,
+    wxMM_TWIPS,
+    wxMM_POINTS
+};
+
+#if WXWIN_COMPATIBILITY_2_8
+

 //-----------------------------------------------------------------------------
 // wxDrawObject helper class
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxDrawObject helper class
 //-----------------------------------------------------------------------------


@@ -49,8 +123,7 @@ class WXDLLIMPEXP_FWD_CORE wxPrintData;
 class WXDLLIMPEXP_CORE wxDrawObject
 {
 public:
 class WXDLLIMPEXP_CORE wxDrawObject
 {
 public:

-
-    wxDrawObject()
+    wxDEPRECATED_CONSTRUCTOR(wxDrawObject)()

         : m_isBBoxValid(false)
         , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
     { }
         : m_isBBoxValid(false)
         , m_minX(0), m_minY(0), m_maxX(0), m_maxY(0)
     { }


@@ -103,6 +176,8 @@ protected:
     wxCoord m_minX, m_minY, m_maxX, m_maxY;
 };
 
     wxCoord m_minX, m_minY, m_maxX, m_maxY;
 };
 

+#endif // WXWIN_COMPATIBILITY_2_8
+

 
 //-----------------------------------------------------------------------------
 // wxDCFactory
 
 //-----------------------------------------------------------------------------
 // wxDCFactory


@@ -292,8 +367,9 @@ public:
 
     // logical functions
 
 
     // logical functions
 

-    virtual void SetLogicalFunction(int function) = 0;
-    virtual int GetLogicalFunction() const { return m_logicalFunction; }
+    virtual void SetLogicalFunction(wxRasterOperationMode function) = 0;
+    virtual wxRasterOperationMode GetLogicalFunction() const
+                                      { return m_logicalFunction; }

 
     // text measurement
 
 
     // text measurement
 


@@ -350,8 +426,8 @@ public:
     virtual wxCoord LogicalToDeviceXRel(wxCoord x) const;
     virtual wxCoord LogicalToDeviceYRel(wxCoord y) const;
 
     virtual wxCoord LogicalToDeviceXRel(wxCoord x) const;
     virtual wxCoord LogicalToDeviceYRel(wxCoord y) const;
 

-    virtual void SetMapMode(int mode);
-    virtual int GetMapMode() const { return m_mappingMode; }
+    virtual void SetMapMode(wxMappingMode mode);
+    virtual wxMappingMode GetMapMode() const { return m_mappingMode; }

 
     virtual void SetUserScale(double x, double y);
     virtual void GetUserScale(double *x, double *y) const
 
     virtual void SetUserScale(double x, double y);
     virtual void GetUserScale(double *x, double *y) const


@@ -392,7 +468,7 @@ public:
     // the actual drawing API
 
     virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
     // the actual drawing API
 
     virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,

-                             int style = wxFLOOD_SURFACE) = 0;
+                             wxFloodFillStyle style = wxFLOOD_SURFACE) = 0;

 
     virtual void DoGradientFillLinear(const wxRect& rect,
                                       const wxColour& initialColour,
 
     virtual void DoGradientFillLinear(const wxRect& rect,
                                       const wxColour& initialColour,


@@ -438,7 +514,7 @@ public:
                         wxCoord width, wxCoord height,
                         wxDC *source,
                         wxCoord xsrc, wxCoord ysrc,
                         wxCoord width, wxCoord height,
                         wxDC *source,
                         wxCoord xsrc, wxCoord ysrc,

-                        int rop = wxCOPY,
+                        wxRasterOperationMode rop = wxCOPY,

                         bool useMask = false,
                         wxCoord xsrcMask = wxDefaultCoord,
                         wxCoord ysrcMask = wxDefaultCoord) = 0;
                         bool useMask = false,
                         wxCoord xsrcMask = wxDefaultCoord,
                         wxCoord ysrcMask = wxDefaultCoord) = 0;


@@ -448,7 +524,7 @@ public:
                                wxDC *source,
                                wxCoord xsrc, wxCoord ysrc,
                                wxCoord srcWidth, wxCoord srcHeight,
                                wxDC *source,
                                wxCoord xsrc, wxCoord ysrc,
                                wxCoord srcWidth, wxCoord srcHeight,

-                               int rop = wxCOPY,
+                               wxRasterOperationMode rop = wxCOPY,

                                bool useMask = false,
                                wxCoord xsrcMask = wxDefaultCoord,
                                wxCoord ysrcMask = wxDefaultCoord);
                                bool useMask = false,
                                wxCoord xsrcMask = wxDefaultCoord,
                                wxCoord ysrcMask = wxDefaultCoord);


@@ -463,14 +539,14 @@ public:
                            wxCoord xoffset, wxCoord yoffset );
 
     virtual void DoDrawPolygon(int n, wxPoint points[],
                            wxCoord xoffset, wxCoord yoffset );
 
     virtual void DoDrawPolygon(int n, wxPoint points[],

-                               wxCoord xoffset, wxCoord yoffset,
-                               int fillStyle = wxODDEVEN_RULE) = 0;
+                           wxCoord xoffset, wxCoord yoffset,
+                           wxPolygonFillMode fillStyle = wxODDEVEN_RULE) = 0;

     virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
                                wxCoord xoffset, wxCoord yoffset,
     virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
                                wxCoord xoffset, wxCoord yoffset,

-                               int fillStyle);
+                               wxPolygonFillMode fillStyle);

     void DrawPolygon(const wxPointList *list,
                      wxCoord xoffset, wxCoord yoffset,
     void DrawPolygon(const wxPointList *list,
                      wxCoord xoffset, wxCoord yoffset,

-                     int fillStyle );
+                     wxPolygonFillMode fillStyle );

 
 
 #if wxUSE_SPLINES
 
 
 #if wxUSE_SPLINES


@@ -497,10 +573,10 @@ public:
     // ---------------------------------------------------------
     // wxPrinterDC Impl API
 
     // ---------------------------------------------------------
     // wxPrinterDC Impl API
 

-    virtual wxRect GetPaperRect()
+    virtual wxRect GetPaperRect() const

         { int w = 0; int h = 0; DoGetSize( &w, &h ); return wxRect(0,0,w,h); }
 
         { int w = 0; int h = 0; DoGetSize( &w, &h ); return wxRect(0,0,w,h); }
 

-    virtual int GetResolution()
+    virtual int GetResolution() const

         { return -1; }
 
 private:
         { return -1; }
 
 private:


@@ -602,9 +678,9 @@ protected:
     wxCoord m_minX, m_minY, m_maxX, m_maxY;
     wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2;
 
     wxCoord m_minX, m_minY, m_maxX, m_maxY;
     wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2;
 

-    int m_logicalFunction;
+    wxRasterOperationMode m_logicalFunction;

     int m_backgroundMode;
     int m_backgroundMode;

-    int m_mappingMode;
+    wxMappingMode m_mappingMode;

 
     wxPen             m_pen;
     wxBrush           m_brush;
 
     wxPen             m_pen;
     wxBrush           m_brush;


@@ -626,6 +702,9 @@ private:
 class WXDLLIMPEXP_CORE wxDC : public wxObject
 {
 public:
 class WXDLLIMPEXP_CORE wxDC : public wxObject
 {
 public:

+    // copy attributes (font, colours and writing direction) from another DC
+    void CopyAttributes(const wxDC& dc);
+

     virtual ~wxDC() { delete m_pimpl; }
 
     wxDCImpl *GetImpl()
     virtual ~wxDC() { delete m_pimpl; }
 
     wxDCImpl *GetImpl()


@@ -667,7 +746,7 @@ public:
     wxSize GetPPI() const
         { return m_pimpl->GetPPI(); }
 
     wxSize GetPPI() const
         { return m_pimpl->GetPPI(); }
 

-    virtual int GetResolution()
+    virtual int GetResolution() const

         { return m_pimpl->GetResolution(); }
 
     // Right-To-Left (RTL) modes
         { return m_pimpl->GetResolution(); }
 
     // Right-To-Left (RTL) modes


@@ -749,9 +828,9 @@ public:
 
     // logical functions
 
 
     // logical functions
 

-    void SetLogicalFunction(int function)
+    void SetLogicalFunction(wxRasterOperationMode function)

         { m_pimpl->SetLogicalFunction(function); }
         { m_pimpl->SetLogicalFunction(function); }

-    int GetLogicalFunction() const
+    wxRasterOperationMode GetLogicalFunction() const

         { return m_pimpl->GetLogicalFunction(); }
 
     // text measurement
         { return m_pimpl->GetLogicalFunction(); }
 
     // text measurement


@@ -848,9 +927,9 @@ public:
     wxCoord LogicalToDeviceYRel(wxCoord y) const
         { return m_pimpl->LogicalToDeviceYRel(y); }
 
     wxCoord LogicalToDeviceYRel(wxCoord y) const
         { return m_pimpl->LogicalToDeviceYRel(y); }
 

-    void SetMapMode(int mode)
+    void SetMapMode(wxMappingMode mode)

         { m_pimpl->SetMapMode(mode); }
         { m_pimpl->SetMapMode(mode); }

-    int GetMapMode() const
+    wxMappingMode GetMapMode() const

         { return m_pimpl->GetMapMode(); }
 
     void SetUserScale(double x, double y)
         { return m_pimpl->GetMapMode(); }
 
     void SetUserScale(double x, double y)


@@ -885,23 +964,14 @@ public:
         { m_pimpl->SetDeviceLocalOrigin( x, y ); }
 
 
         { m_pimpl->SetDeviceLocalOrigin( x, y ); }
 
 

-    // draw generic object
-
-    void DrawObject(wxDrawObject* drawobject)
-    {
-        drawobject->Draw(*this);
-        CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
-        CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
-    }
-

     // -----------------------------------------------
     // the actual drawing API
 
     bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
     // -----------------------------------------------
     // the actual drawing API
 
     bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,

-                   int style = wxFLOOD_SURFACE)
+                   wxFloodFillStyle style = wxFLOOD_SURFACE)

         { return m_pimpl->DoFloodFill(x, y, col, style); }
     bool FloodFill(const wxPoint& pt, const wxColour& col,
         { return m_pimpl->DoFloodFill(x, y, col, style); }
     bool FloodFill(const wxPoint& pt, const wxColour& col,

-                   int style = wxFLOOD_SURFACE)
+                   wxFloodFillStyle style = wxFLOOD_SURFACE)

         { return m_pimpl->DoFloodFill(pt.x, pt.y, col, style); }
 
     // fill the area specified by rect with a radial gradient, starting from
         { return m_pimpl->DoFloodFill(pt.x, pt.y, col, style); }
 
     // fill the area specified by rect with a radial gradient, starting from


@@ -978,20 +1048,20 @@ public:
 
     void DrawPolygon(int n, wxPoint points[],
                      wxCoord xoffset = 0, wxCoord yoffset = 0,
 
     void DrawPolygon(int n, wxPoint points[],
                      wxCoord xoffset = 0, wxCoord yoffset = 0,

-                     int fillStyle = wxODDEVEN_RULE)
+                     wxPolygonFillMode fillStyle = wxODDEVEN_RULE)

         { m_pimpl->DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
     void DrawPolygon(const wxPointList *list,
                      wxCoord xoffset = 0, wxCoord yoffset = 0,
         { m_pimpl->DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
     void DrawPolygon(const wxPointList *list,
                      wxCoord xoffset = 0, wxCoord yoffset = 0,

-                     int fillStyle = wxODDEVEN_RULE)
+                     wxPolygonFillMode fillStyle = wxODDEVEN_RULE)

         { m_pimpl->DrawPolygon( list, xoffset, yoffset, fillStyle ); }
     void DrawPolyPolygon(int n, int count[], wxPoint points[],
                          wxCoord xoffset = 0, wxCoord yoffset = 0,
         { 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)
+                         wxPolygonFillMode 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,
         { 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) );
+                     wxPolygonFillMode fillStyle = wxODDEVEN_RULE) );

 #endif  // WXWIN_COMPATIBILITY_2_8
 
     void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 #endif  // WXWIN_COMPATIBILITY_2_8
 
     void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)


@@ -1062,14 +1132,16 @@ public:
 
     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,

-              int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
+              wxRasterOperationMode rop = wxCOPY, bool useMask = false,
+              wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)

     {
         return m_pimpl->DoBlit(xdest, ydest, width, height,
                       source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
     }
     bool Blit(const wxPoint& destPt, const wxSize& sz,
               wxDC *source, const wxPoint& srcPt,
     {
         return m_pimpl->DoBlit(xdest, ydest, width, height,
                       source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
     }
     bool Blit(const wxPoint& destPt, const wxSize& sz,
               wxDC *source, const wxPoint& srcPt,

-              int rop = wxCOPY, bool useMask = false, const wxPoint& srcPtMask = wxDefaultPosition)
+              wxRasterOperationMode rop = wxCOPY, bool useMask = false,
+              const wxPoint& srcPtMask = wxDefaultPosition)

     {
         return m_pimpl->DoBlit(destPt.x, destPt.y, sz.x, sz.y,
                       source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);
     {
         return m_pimpl->DoBlit(destPt.x, destPt.y, sz.x, sz.y,
                       source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);


@@ -1080,7 +1152,7 @@ public:
                      wxDC *source,
                      wxCoord srcX, wxCoord srcY,
                      wxCoord srcWidth, wxCoord srcHeight,
                      wxDC *source,
                      wxCoord srcX, wxCoord srcY,
                      wxCoord srcWidth, wxCoord srcHeight,

-                     int rop = wxCOPY, bool useMask = false,
+                     wxRasterOperationMode rop = wxCOPY, bool useMask = false,

                      wxCoord srcMaskX = wxDefaultCoord, wxCoord srcMaskY = wxDefaultCoord)
     {
         return m_pimpl->DoStretchBlit(dstX, dstY, dstWidth, dstHeight,
                      wxCoord srcMaskX = wxDefaultCoord, wxCoord srcMaskY = wxDefaultCoord)
     {
         return m_pimpl->DoStretchBlit(dstX, dstY, dstWidth, dstHeight,


@@ -1088,7 +1160,8 @@ public:
     }
     bool StretchBlit(const wxPoint& dstPt, const wxSize& dstSize,
                      wxDC *source, const wxPoint& srcPt, const wxSize& srcSize,
     }
     bool StretchBlit(const wxPoint& dstPt, const wxSize& dstSize,
                      wxDC *source, const wxPoint& srcPt, const wxSize& srcSize,

-                     int rop = wxCOPY, bool useMask = false, const wxPoint& srcMaskPt = wxDefaultPosition)
+                     wxRasterOperationMode rop = wxCOPY, bool useMask = false,
+                     const wxPoint& srcMaskPt = wxDefaultPosition)

     {
         return m_pimpl->DoStretchBlit(dstPt.x, dstPt.y, dstSize.x, dstSize.y,
                       source, srcPt.x, srcPt.y, srcSize.x, srcSize.y, rop, useMask, srcMaskPt.x, srcMaskPt.y);
     {
         return m_pimpl->DoStretchBlit(dstPt.x, dstPt.y, dstSize.x, dstSize.y,
                       source, srcPt.x, srcPt.y, srcSize.x, srcSize.y, rop, useMask, srcMaskPt.x, srcMaskPt.y);


@@ -1121,8 +1194,56 @@ public:
     wxDEPRECATED( void GetLogicalOrigin(long *x, long *y) const );
     wxDEPRECATED( void GetDeviceOrigin(long *x, long *y) const );
     wxDEPRECATED( void GetClippingBox(long *x, long *y, long *w, long *h) const );
     wxDEPRECATED( void GetLogicalOrigin(long *x, long *y) const );
     wxDEPRECATED( void GetDeviceOrigin(long *x, long *y) const );
     wxDEPRECATED( void GetClippingBox(long *x, long *y, long *w, long *h) const );

+
+    wxDEPRECATED( void DrawObject(wxDrawObject* drawobject) );

 #endif  // WXWIN_COMPATIBILITY_2_8
 
 #endif  // WXWIN_COMPATIBILITY_2_8
 

+#ifdef __WXMSW__
+    // GetHDC() is the simplest way to retrieve an HDC From a wxDC but only
+    // works if this wxDC is GDI-based and fails for GDI+ contexts (and
+    // anything else without HDC, e.g. wxPostScriptDC)
+    WXHDC GetHDC() const;
+
+    // don't use these methods manually, use GetTempHDC() instead
+    virtual WXHDC AcquireHDC() { return GetHDC(); }
+    virtual void ReleaseHDC(WXHDC WXUNUSED(hdc)) { }
+
+    // helper class holding the result of GetTempHDC() with std::auto_ptr<>-like
+    // semantics, i.e. it is moved when copied
+    class TempHDC
+    {
+    public:
+        TempHDC(wxDC& dc)
+            : m_dc(dc),
+              m_hdc(dc.AcquireHDC())
+        {
+        }
+
+        TempHDC(const TempHDC& thdc)
+            : m_dc(thdc.m_dc),
+              m_hdc(thdc.m_hdc)
+        {
+            const_cast<TempHDC&>(thdc).m_hdc = 0;
+        }
+
+        ~TempHDC()
+        {
+            if ( m_hdc )
+                m_dc.ReleaseHDC(m_hdc);
+        }
+
+        WXHDC GetHDC() const { return m_hdc; }
+
+    private:
+        wxDC& m_dc;
+        WXHDC m_hdc;
+
+        wxDECLARE_NO_ASSIGN_CLASS(TempHDC);
+    };
+
+    // GetTempHDC() also works for wxGCDC (but still not for wxPostScriptDC &c)
+    TempHDC GetTempHDC() { return TempHDC(*this); }
+#endif // __WXMSW__

 
 protected:
     // ctor takes ownership of the pointer
 
 protected:
     // ctor takes ownership of the pointer


@@ -1132,7 +1253,7 @@ protected:
 
 private:
     DECLARE_ABSTRACT_CLASS(wxDC)
 
 private:
     DECLARE_ABSTRACT_CLASS(wxDC)

-    DECLARE_NO_COPY_CLASS(wxDC)
+    wxDECLARE_NO_COPY_CLASS(wxDC);

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


@@ -1168,7 +1289,7 @@ private:
 
     wxColour m_colFgOld;
 
 
     wxColour m_colFgOld;
 

-    DECLARE_NO_COPY_CLASS(wxDCTextColourChanger)
+    wxDECLARE_NO_COPY_CLASS(wxDCTextColourChanger);

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


@@ -1195,7 +1316,7 @@ private:
 
     wxPen m_penOld;
 
 
     wxPen m_penOld;
 

-    DECLARE_NO_COPY_CLASS(wxDCPenChanger)
+    wxDECLARE_NO_COPY_CLASS(wxDCPenChanger);

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


@@ -1222,7 +1343,7 @@ private:
 
     wxBrush m_brushOld;
 
 
     wxBrush m_brushOld;
 

-    DECLARE_NO_COPY_CLASS(wxDCBrushChanger)
+    wxDECLARE_NO_COPY_CLASS(wxDCBrushChanger);

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


@@ -1245,7 +1366,48 @@ public:
 private:
     wxDC& m_dc;
 
 private:
     wxDC& m_dc;
 

-    DECLARE_NO_COPY_CLASS(wxDCClipper)
+    wxDECLARE_NO_COPY_CLASS(wxDCClipper);

 };
 
 };
 

+// ----------------------------------------------------------------------------
+// helper class: you can use it to temporarily change the DC font and
+// restore it automatically when the object goes out of scope
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_CORE wxDCFontChanger
+{
+public:
+    wxDCFontChanger(wxDC& dc)
+        : m_dc(dc), m_fontOld()
+    {
+    }
+
+    wxDCFontChanger(wxDC& dc, const wxFont& font)
+        : m_dc(dc), m_fontOld(dc.GetFont())
+    {
+        m_dc.SetFont(font);
+    }
+
+    void Set(const wxFont& font)
+    {
+        if ( !m_fontOld.Ok() )
+            m_fontOld = m_dc.GetFont();
+        m_dc.SetFont(font);
+    }
+
+    ~wxDCFontChanger()
+    {
+        if ( m_fontOld.Ok() )
+            m_dc.SetFont(m_fontOld);
+    }
+
+private:
+    wxDC& m_dc;
+
+    wxFont m_fontOld;
+
+    wxDECLARE_NO_COPY_CLASS(wxDCFontChanger);
+};
+
+

 #endif // _WX_DC_H_BASE_
 #endif // _WX_DC_H_BASE_