doing WakeUp in osx_carbon differently for the main event as well

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

diff --git a/include/wx/dc.h b/include/wx/dc.h
index 2357fb12e5cbd68fef16683645860b20de8395c6..f6346888ace075c14a8262b786829996aba7e057 100644 (file)
--- a/include/wx/dc.h
+++ b/include/wx/dc.h
@@ -29,7 +29,8 @@
 #include "wx/dynarray.h"
 #include "wx/math.h"
 #include "wx/image.h"
 #include "wx/dynarray.h"
 #include "wx/math.h"
 #include "wx/image.h"

-#include "wx/cmndata.h"
+#include "wx/region.h"
+#include "wx/affinematrix2d.h"

 
 #define wxUSE_NEW_DC 1
 
 
 #define wxUSE_NEW_DC 1
 


@@ -61,7 +62,7 @@ enum wxRasterOperationMode
     wxNAND,        // (NOT src) OR (NOT dst)
     wxOR,          // src OR dst
     wxSET          // 1
     wxNAND,        // (NOT src) OR (NOT dst)
     wxOR,          // src OR dst
     wxSET          // 1

-#ifdef WXWIN_COMPATIBILITY_2_8
+#if WXWIN_COMPATIBILITY_2_8

     ,wxROP_BLACK = wxCLEAR,
     wxBLIT_BLACKNESS = wxCLEAR,
     wxROP_XORPEN = wxXOR,
     ,wxROP_BLACK = wxCLEAR,
     wxBLIT_BLACKNESS = wxCLEAR,
     wxROP_XORPEN = wxXOR,


@@ -104,21 +105,39 @@ enum wxFloodFillStyle
     wxFLOOD_BORDER
 };
 
     wxFLOOD_BORDER
 };
 

-//  Mapping modes (same values as used by Windows, don't change)
+//  Mapping modes

 enum wxMappingMode
 {
     wxMM_TEXT = 1,
 enum wxMappingMode
 {
     wxMM_TEXT = 1,

+    wxMM_METRIC,

     wxMM_LOMETRIC,
     wxMM_LOMETRIC,

-    wxMM_HIMETRIC,
-    wxMM_LOENGLISH,
-    wxMM_HIENGLISH,

     wxMM_TWIPS,
     wxMM_TWIPS,

-    wxMM_ISOTROPIC,
-    wxMM_ANISOTROPIC,
-    wxMM_POINTS,
-    wxMM_METRIC
+    wxMM_POINTS

 };
 
 };
 

+// Description of text characteristics.
+struct wxFontMetrics
+{
+    wxFontMetrics()
+    {
+        height =
+        ascent =
+        descent =
+        internalLeading =
+        externalLeading =
+        averageWidth = 0;
+    }
+
+    int height,             // Total character height.
+        ascent,             // Part of the height above the baseline.
+        descent,            // Part of the height below the baseline.
+        internalLeading,    // Intra-line spacing.
+        externalLeading,    // Inter-line spacing.
+        averageWidth;       // Average font width, a.k.a. "x-width".
+};
+
+#if WXWIN_COMPATIBILITY_2_8
+

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


@@ -126,8 +145,7 @@ enum wxMappingMode
 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)
     { }


@@ -180,6 +198,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


@@ -370,13 +390,25 @@ public:
     // logical functions
 
     virtual void SetLogicalFunction(wxRasterOperationMode function) = 0;
     // logical functions
 
     virtual void SetLogicalFunction(wxRasterOperationMode function) = 0;

-    virtual wxRasterOperationMode GetLogicalFunction() const 
+    virtual wxRasterOperationMode GetLogicalFunction() const

                                       { return m_logicalFunction; }
 
     // text measurement
 
     virtual wxCoord GetCharHeight() const = 0;
     virtual wxCoord GetCharWidth() const = 0;
                                       { return m_logicalFunction; }
 
     // text measurement
 
     virtual wxCoord GetCharHeight() const = 0;
     virtual wxCoord GetCharWidth() const = 0;

+
+    // The derived classes should really override DoGetFontMetrics() to return
+    // the correct values in the future but for now provide a default
+    // implementation in terms of DoGetTextExtent() to avoid breaking the
+    // compilation of all other ports as wxMSW is the only one to implement it.
+    virtual void DoGetFontMetrics(int *height,
+                                  int *ascent,
+                                  int *descent,
+                                  int *internalLeading,
+                                  int *externalLeading,
+                                  int *averageWidth) const;
+

     virtual void DoGetTextExtent(const wxString& string,
                                  wxCoord *x, wxCoord *y,
                                  wxCoord *descent = NULL,
     virtual void DoGetTextExtent(const wxString& string,
                                  wxCoord *x, wxCoord *y,
                                  wxCoord *descent = NULL,


@@ -459,6 +491,20 @@ public:
         if ( y ) *y = m_deviceOriginY;
     }
 
         if ( y ) *y = m_deviceOriginY;
     }
 

+#if wxUSE_DC_TRANSFORM_MATRIX
+    // Transform matrix support is not available in most ports right now
+    // (currently only wxMSW provides it) so do nothing in these methods by
+    // default.
+    virtual bool CanUseTransformMatrix() const
+        { return false; }
+    virtual bool SetTransformMatrix(const wxAffineMatrix2D& WXUNUSED(matrix))
+        { return false; }
+    virtual wxAffineMatrix2D GetTransformMatrix() const
+        { return wxAffineMatrix2D(); }
+    virtual void ResetTransformMatrix()
+        { }
+#endif // wxUSE_DC_TRANSFORM_MATRIX
+

     virtual void SetDeviceLocalOrigin( wxCoord x, wxCoord y );
 
     virtual void ComputeScaleAndOrigin();
     virtual void SetDeviceLocalOrigin( wxCoord x, wxCoord y );
 
     virtual void ComputeScaleAndOrigin();


@@ -466,6 +512,19 @@ public:
     // this needs to overidden if the axis is inverted
     virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
 
     // this needs to overidden if the axis is inverted
     virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
 

+#ifdef __WXMSW__
+    // Native Windows functions using the underlying HDC don't honour GDI+
+    // transformations which may be applied to it. Using this function we can
+    // transform the coordinates manually before passing them to such functions
+    // (as in e.g. wxRendererMSW code). It doesn't do anything if this is not a
+    // wxGCDC.
+    virtual wxRect MSWApplyGDIPlusTransform(const wxRect& r) const
+    {
+        return r;
+    }
+#endif // __WXMSW__
+
+

     // ---------------------------------------------------------
     // the actual drawing API
 
     // ---------------------------------------------------------
     // the actual drawing API
 


@@ -704,6 +763,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()


@@ -839,6 +901,15 @@ public:
     wxCoord GetCharWidth() const
         { return m_pimpl->GetCharWidth(); }
 
     wxCoord GetCharWidth() const
         { return m_pimpl->GetCharWidth(); }
 

+    wxFontMetrics GetFontMetrics() const
+    {
+        wxFontMetrics fm;
+        m_pimpl->DoGetFontMetrics(&fm.height, &fm.ascent, &fm.descent,
+                                  &fm.internalLeading, &fm.externalLeading,
+                                  &fm.averageWidth);
+        return fm;
+    }
+

     void GetTextExtent(const wxString& string,
                        wxCoord *x, wxCoord *y,
                        wxCoord *descent = NULL,
     void GetTextExtent(const wxString& string,
                        wxCoord *x, wxCoord *y,
                        wxCoord *descent = NULL,


@@ -958,20 +1029,25 @@ public:
     void SetAxisOrientation(bool xLeftRight, bool yBottomUp)
         { m_pimpl->SetAxisOrientation(xLeftRight, yBottomUp); }
 
     void SetAxisOrientation(bool xLeftRight, bool yBottomUp)
         { m_pimpl->SetAxisOrientation(xLeftRight, yBottomUp); }
 

+#if wxUSE_DC_TRANSFORM_MATRIX
+    bool CanUseTransformMatrix() const
+        { return m_pimpl->CanUseTransformMatrix(); }
+
+    bool SetTransformMatrix(const wxAffineMatrix2D &matrix)
+        { return m_pimpl->SetTransformMatrix(matrix); }
+
+    wxAffineMatrix2D GetTransformMatrix() const
+        { return m_pimpl->GetTransformMatrix(); }
+
+    void ResetTransformMatrix()
+        { m_pimpl->ResetTransformMatrix(); }
+#endif // wxUSE_DC_TRANSFORM_MATRIX
+

     // mostly internal
     void SetDeviceLocalOrigin( wxCoord x, wxCoord y )
         { m_pimpl->SetDeviceLocalOrigin( x, y ); }
 
 
     // mostly internal
     void SetDeviceLocalOrigin( wxCoord x, wxCoord 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
 
     // -----------------------------------------------
     // the actual drawing API
 


@@ -1140,7 +1216,7 @@ 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,

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

               wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
     {
         return m_pimpl->DoBlit(xdest, ydest, width, height,
               wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
     {
         return m_pimpl->DoBlit(xdest, ydest, width, height,


@@ -1148,7 +1224,7 @@ public:
     }
     bool Blit(const wxPoint& destPt, const wxSize& sz,
               wxDC *source, const wxPoint& srcPt,
     }
     bool Blit(const wxPoint& destPt, const wxSize& sz,
               wxDC *source, const wxPoint& srcPt,

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

               const wxPoint& srcPtMask = wxDefaultPosition)
     {
         return m_pimpl->DoBlit(destPt.x, destPt.y, sz.x, sz.y,
               const wxPoint& srcPtMask = wxDefaultPosition)
     {
         return m_pimpl->DoBlit(destPt.x, destPt.y, sz.x, sz.y,


@@ -1168,7 +1244,7 @@ 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,

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

                      const wxPoint& srcMaskPt = wxDefaultPosition)
     {
         return m_pimpl->DoStretchBlit(dstPt.x, dstPt.y, dstSize.x, dstSize.y,
                      const wxPoint& srcMaskPt = wxDefaultPosition)
     {
         return m_pimpl->DoStretchBlit(dstPt.x, dstPt.y, dstSize.x, dstSize.y,


@@ -1203,10 +1279,54 @@ public:
     wxDEPRECATED( void GetDeviceOrigin(long *x, long *y) const );
     wxDEPRECATED( void GetClippingBox(long *x, long *y, long *w, long *h) 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
 
 #ifdef __WXMSW__
 #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;
     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:
 #endif // __WXMSW__
 
 protected:


@@ -1217,7 +1337,7 @@ protected:
 
 private:
     DECLARE_ABSTRACT_CLASS(wxDC)
 
 private:
     DECLARE_ABSTRACT_CLASS(wxDC)

-    DECLARE_NO_COPY_CLASS(wxDC)
+    wxDECLARE_NO_COPY_CLASS(wxDC);

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


@@ -1237,13 +1357,13 @@ public:
 
     ~wxDCTextColourChanger()
     {
 
     ~wxDCTextColourChanger()
     {

-        if ( m_colFgOld.Ok() )
+        if ( m_colFgOld.IsOk() )

             m_dc.SetTextForeground(m_colFgOld);
     }
 
     void Set(const wxColour& col)
     {
             m_dc.SetTextForeground(m_colFgOld);
     }
 
     void Set(const wxColour& col)
     {

-        if ( !m_colFgOld.Ok() )
+        if ( !m_colFgOld.IsOk() )

             m_colFgOld = m_dc.GetTextForeground();
         m_dc.SetTextForeground(col);
     }
             m_colFgOld = m_dc.GetTextForeground();
         m_dc.SetTextForeground(col);
     }


@@ -1253,7 +1373,7 @@ private:
 
     wxColour m_colFgOld;
 
 
     wxColour m_colFgOld;
 

-    DECLARE_NO_COPY_CLASS(wxDCTextColourChanger)
+    wxDECLARE_NO_COPY_CLASS(wxDCTextColourChanger);

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


@@ -1271,7 +1391,7 @@ public:
 
     ~wxDCPenChanger()
     {
 
     ~wxDCPenChanger()
     {

-        if ( m_penOld.Ok() )
+        if ( m_penOld.IsOk() )

             m_dc.SetPen(m_penOld);
     }
 
             m_dc.SetPen(m_penOld);
     }
 


@@ -1280,7 +1400,7 @@ private:
 
     wxPen m_penOld;
 
 
     wxPen m_penOld;
 

-    DECLARE_NO_COPY_CLASS(wxDCPenChanger)
+    wxDECLARE_NO_COPY_CLASS(wxDCPenChanger);

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


@@ -1298,7 +1418,7 @@ public:
 
     ~wxDCBrushChanger()
     {
 
     ~wxDCBrushChanger()
     {

-        if ( m_brushOld.Ok() )
+        if ( m_brushOld.IsOk() )

             m_dc.SetBrush(m_brushOld);
     }
 
             m_dc.SetBrush(m_brushOld);
     }
 


@@ -1307,7 +1427,7 @@ private:
 
     wxBrush m_brushOld;
 
 
     wxBrush m_brushOld;
 

-    DECLARE_NO_COPY_CLASS(wxDCBrushChanger)
+    wxDECLARE_NO_COPY_CLASS(wxDCBrushChanger);

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


@@ -1330,7 +1450,7 @@ public:
 private:
     wxDC& m_dc;
 
 private:
     wxDC& m_dc;
 

-    DECLARE_NO_COPY_CLASS(wxDCClipper)
+    wxDECLARE_NO_COPY_CLASS(wxDCClipper);

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


@@ -1341,14 +1461,27 @@ private:
 class WXDLLIMPEXP_CORE wxDCFontChanger
 {
 public:
 class WXDLLIMPEXP_CORE wxDCFontChanger
 {
 public:

-    wxDCFontChanger(wxDC& dc, const wxFont& font) : m_dc(dc), m_fontOld(dc.GetFont())
+    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.IsOk() )
+            m_fontOld = m_dc.GetFont();

         m_dc.SetFont(font);
     }
 
     ~wxDCFontChanger()
     {
         m_dc.SetFont(font);
     }
 
     ~wxDCFontChanger()
     {

-        if ( m_fontOld.Ok() )
+        if ( m_fontOld.IsOk() )

             m_dc.SetFont(m_fontOld);
     }
 
             m_dc.SetFont(m_fontOld);
     }
 


@@ -1357,7 +1490,7 @@ private:
 
     wxFont m_fontOld;
 
 
     wxFont m_fontOld;
 

-    DECLARE_NO_COPY_CLASS(wxDCFontChanger)
+    wxDECLARE_NO_COPY_CLASS(wxDCFontChanger);

 };
 
 
 };