Pass wxRect/wxPoint arguments to wxDataViewCustomRenderer by reference.

[wxWidgets.git] / src / msw / dcclient.cpp

diff --git a/src/msw/dcclient.cpp b/src/msw/dcclient.cpp
index f3ffe0ebd39bb2ba403d182394934ff5e30b1209..bad81c1e72762e0ba45cd3d69a797aa56573060d 100644 (file)
--- a/src/msw/dcclient.cpp
+++ b/src/msw/dcclient.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        dcclient.cpp
+// Name:        src/msw/dcclient.cpp

 // Purpose:     wxClientDC class
 // Author:      Julian Smart
 // Modified by:
 // Purpose:     wxClientDC class
 // Author:      Julian Smart
 // Modified by:


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "dcclient.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -28,13 +24,16 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

-#include "wx/string.h"
-#include "wx/log.h"
-#include "wx/window.h"
+#include "wx/dcclient.h"
+#include "wx/msw/dcclient.h"

 
 

-#include "wx/msw/private.h"
+#ifndef WX_PRECOMP
+    #include "wx/string.h"
+    #include "wx/log.h"
+    #include "wx/window.h"
+#endif

 
 

-#include "wx/dcclient.h"
+#include "wx/msw/private.h"

 
 // ----------------------------------------------------------------------------
 // array/list types
 
 // ----------------------------------------------------------------------------
 // array/list types


@@ -42,7 +41,7 @@
 
 struct WXDLLEXPORT wxPaintDCInfo
 {
 
 struct WXDLLEXPORT wxPaintDCInfo
 {

-    wxPaintDCInfo(wxWindow *win, wxDC *dc)
+    wxPaintDCInfo(wxWindow *win, wxPaintDCImpl *dc)

     {
         hwnd = win->GetHWND();
         hdc = dc->GetHDC();
     {
         hwnd = win->GetHWND();
         hdc = dc->GetHDC();


@@ -56,93 +55,91 @@ struct WXDLLEXPORT wxPaintDCInfo
 
 #include "wx/arrimpl.cpp"
 
 
 #include "wx/arrimpl.cpp"
 

-WX_DEFINE_OBJARRAY(wxArrayDCInfo);
+WX_DEFINE_OBJARRAY(wxArrayDCInfo)

 
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
-IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
-IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
-IMPLEMENT_CLASS(wxPaintDCEx, wxPaintDC)
-

 // ----------------------------------------------------------------------------
 // global variables
 // ----------------------------------------------------------------------------
 
 static PAINTSTRUCT g_paintStruct;
 
 // ----------------------------------------------------------------------------
 // global variables
 // ----------------------------------------------------------------------------
 
 static PAINTSTRUCT g_paintStruct;
 

-#ifdef __WXDEBUG__
+#ifdef wxHAS_PAINT_DEBUG

     // a global variable which we check to verify that wxPaintDC are only
     // created in response to WM_PAINT message - doing this from elsewhere is a
     // common programming error among wxWidgets programmers and might lead to
     // very subtle and difficult to debug refresh/repaint bugs.
     int g_isPainting = 0;
     // a global variable which we check to verify that wxPaintDC are only
     // created in response to WM_PAINT message - doing this from elsewhere is a
     // common programming error among wxWidgets programmers and might lead to
     // very subtle and difficult to debug refresh/repaint bugs.
     int g_isPainting = 0;

-#endif // __WXDEBUG__
+#endif // wxHAS_PAINT_DEBUG

 
 // ===========================================================================
 // implementation
 // ===========================================================================
 
 // ----------------------------------------------------------------------------
 
 // ===========================================================================
 // implementation
 // ===========================================================================
 
 // ----------------------------------------------------------------------------

-// wxWindowDC
+// wxMSWWindowDCImpl

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-wxWindowDC::wxWindowDC()
+IMPLEMENT_ABSTRACT_CLASS(wxWindowDCImpl, wxMSWDCImpl)
+
+wxWindowDCImpl::wxWindowDCImpl( wxDC *owner ) :
+   wxMSWDCImpl( owner )

 {
 {

-    m_canvas = NULL;

 }
 
 }
 

-wxWindowDC::wxWindowDC(wxWindow *canvas)
+wxWindowDCImpl::wxWindowDCImpl( wxDC *owner, wxWindow *window ) :
+   wxMSWDCImpl( owner )

 {
 {

-    wxCHECK_RET( canvas, _T("invalid window in wxWindowDC") );
+    wxCHECK_RET( window, wxT("invalid window in wxWindowDCImpl") );

 
 

-    m_canvas = canvas;
-    m_hDC = (WXHDC) ::GetWindowDC(GetHwndOf(m_canvas));
+    m_window = window;
+    m_hDC = (WXHDC) ::GetWindowDC(GetHwndOf(m_window));

 
     // m_bOwnsDC was already set to false in the base class ctor, so the DC
     // will be released (and not deleted) in ~wxDC
     InitDC();
 }
 
 
     // m_bOwnsDC was already set to false in the base class ctor, so the DC
     // will be released (and not deleted) in ~wxDC
     InitDC();
 }
 

-void wxWindowDC::InitDC()
+void wxWindowDCImpl::InitDC()

 {
     // the background mode is only used for text background and is set in
     // DrawText() to OPAQUE as required, otherwise always TRANSPARENT,
     ::SetBkMode(GetHdc(), TRANSPARENT);
 
 {
     // the background mode is only used for text background and is set in
     // DrawText() to OPAQUE as required, otherwise always TRANSPARENT,
     ::SetBkMode(GetHdc(), TRANSPARENT);
 

-    // default bg colour is pne of the window
-    SetBackground(wxBrush(m_canvas->GetBackgroundColour(), wxSOLID));
-

     // since we are a window dc we need to grab the palette from the window
 #if wxUSE_PALETTE
     InitializePalette();
 #endif
 }
 
     // since we are a window dc we need to grab the palette from the window
 #if wxUSE_PALETTE
     InitializePalette();
 #endif
 }
 

-void wxWindowDC::DoGetSize(int *width, int *height) const
+void wxWindowDCImpl::DoGetSize(int *width, int *height) const

 {
 {

-    wxCHECK_RET( m_canvas, _T("wxWindowDC without a window?") );
+    wxCHECK_RET( m_window, wxT("wxWindowDCImpl without a window?") );

 
 

-    m_canvas->GetSize(width, height);
+    m_window->GetSize(width, height);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxClientDC
+// wxClientDCImpl

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-wxClientDC::wxClientDC()
+IMPLEMENT_ABSTRACT_CLASS(wxClientDCImpl, wxWindowDCImpl)
+
+wxClientDCImpl::wxClientDCImpl( wxDC *owner ) :
+   wxWindowDCImpl( owner )

 {
 {

-    m_canvas = NULL;

 }
 
 }
 

-wxClientDC::wxClientDC(wxWindow *canvas)
+wxClientDCImpl::wxClientDCImpl( wxDC *owner, wxWindow *window ) :
+   wxWindowDCImpl( owner )

 {
 {

-    wxCHECK_RET( canvas, _T("invalid window in wxClientDC") );
+    wxCHECK_RET( window, wxT("invalid window in wxClientDCImpl") );

 
 

-    m_canvas = canvas;
-    m_hDC = (WXHDC)::GetDC(GetHwndOf(m_canvas));
+    m_window = window;
+    m_hDC = (WXHDC)::GetDC(GetHwndOf(window));

 
     // m_bOwnsDC was already set to false in the base class ctor, so the DC
     // will be released (and not deleted) in ~wxDC
 
     // m_bOwnsDC was already set to false in the base class ctor, so the DC
     // will be released (and not deleted) in ~wxDC


@@ -150,9 +147,9 @@ wxClientDC::wxClientDC(wxWindow *canvas)
     InitDC();
 }
 
     InitDC();
 }
 

-void wxClientDC::InitDC()
+void wxClientDCImpl::InitDC()

 {
 {

-    wxWindowDC::InitDC();
+    wxWindowDCImpl::InitDC();

 
     // in wxUniv build we must manually do some DC adjustments usually
     // performed by Windows for us
 
     // in wxUniv build we must manually do some DC adjustments usually
     // performed by Windows for us


@@ -161,7 +158,7 @@ void wxClientDC::InitDC()
     // Windows CE because they're just another control there, not anything
     // special as usually under Windows
 #if defined(__WXUNIVERSAL__) || defined(__WXWINCE__)
     // Windows CE because they're just another control there, not anything
     // special as usually under Windows
 #if defined(__WXUNIVERSAL__) || defined(__WXWINCE__)

-    wxPoint ptOrigin = m_canvas->GetClientAreaOrigin();
+    wxPoint ptOrigin = m_window->GetClientAreaOrigin();

     if ( ptOrigin.x || ptOrigin.y )
     {
         // no need to shift DC origin if shift is null
     if ( ptOrigin.x || ptOrigin.y )
     {
         // no need to shift DC origin if shift is null


@@ -169,23 +166,24 @@ void wxClientDC::InitDC()
     }
 
     // clip the DC to avoid overwriting the non client area
     }
 
     // clip the DC to avoid overwriting the non client area

-    SetClippingRegion(wxPoint(), m_canvas->GetClientSize());
+    wxSize size = m_window->GetClientSize();
+    DoSetClippingRegion(0, 0, size.x, size.y);

 #endif // __WXUNIVERSAL__ || __WXWINCE__
 }
 
 #endif // __WXUNIVERSAL__ || __WXWINCE__
 }
 

-wxClientDC::~wxClientDC()
+wxClientDCImpl::~wxClientDCImpl()

 {
 }
 
 {
 }
 

-void wxClientDC::DoGetSize(int *width, int *height) const
+void wxClientDCImpl::DoGetSize(int *width, int *height) const

 {
 {

-    wxCHECK_RET( m_canvas, _T("wxClientDC without a window?") );
+    wxCHECK_RET( m_window, wxT("wxClientDCImpl without a window?") );

 
 

-    m_canvas->GetClientSize(width, height);
+    m_window->GetClientSize(width, height);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxPaintDC
+// wxPaintDCImpl

 // ----------------------------------------------------------------------------
 
 // VZ: initial implementation (by JACS) only remembered the last wxPaintDC
 // ----------------------------------------------------------------------------
 
 // VZ: initial implementation (by JACS) only remembered the last wxPaintDC


@@ -204,27 +202,30 @@ void wxClientDC::DoGetSize(int *width, int *height) const
 //     "wxPaintDC *" parameter to wxPaintEvent which should be used if it's
 //     !NULL instead of creating a new DC.
 
 //     "wxPaintDC *" parameter to wxPaintEvent which should be used if it's
 //     !NULL instead of creating a new DC.
 

-wxArrayDCInfo wxPaintDC::ms_cache;
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDCImpl, wxClientDCImpl)

 
 

-wxPaintDC::wxPaintDC()
+wxArrayDCInfo wxPaintDCImpl::ms_cache;
+
+wxPaintDCImpl::wxPaintDCImpl( wxDC *owner ) :
+   wxClientDCImpl( owner )

 {
 {

-    m_canvas = NULL;

 }
 
 }
 

-wxPaintDC::wxPaintDC(wxWindow *canvas)
+wxPaintDCImpl::wxPaintDCImpl( wxDC *owner, wxWindow *window ) :
+   wxClientDCImpl( owner )

 {
 {

-    wxCHECK_RET( canvas, wxT("NULL canvas in wxPaintDC ctor") );
+    wxCHECK_RET( window, wxT("NULL canvas in wxPaintDCImpl ctor") );

 
 

-#ifdef __WXDEBUG__
+#ifdef wxHAS_PAINT_DEBUG

     if ( g_isPainting <= 0 )
     {
     if ( g_isPainting <= 0 )
     {

-        wxFAIL_MSG( wxT("wxPaintDC may be created only in EVT_PAINT handler!") );
+        wxFAIL_MSG( wxT("wxPaintDCImpl may be created only in EVT_PAINT handler!") );

 
         return;
     }
 
         return;
     }

-#endif // __WXDEBUG__
+#endif // wxHAS_PAINT_DEBUG

 
 

-    m_canvas = canvas;
+    m_window = window;

 
     // do we have a DC for this window in the cache?
     wxPaintDCInfo *info = FindInCache();
 
     // do we have a DC for this window in the cache?
     wxPaintDCInfo *info = FindInCache();


@@ -235,18 +236,29 @@ wxPaintDC::wxPaintDC(wxWindow *canvas)
     }
     else // not in cache, create a new one
     {
     }
     else // not in cache, create a new one
     {

-        m_hDC = (WXHDC)::BeginPaint(GetHwndOf(m_canvas), &g_paintStruct);
+        // see comments in src/msw/window.cpp where this is defined
+        extern bool wxDidCreatePaintDC;
+
+        wxDidCreatePaintDC = true;
+
+        m_hDC = (WXHDC)::BeginPaint(GetHwndOf(m_window), &g_paintStruct);

         if (m_hDC)
         if (m_hDC)

-            ms_cache.Add(new wxPaintDCInfo(m_canvas, this));
+            ms_cache.Add(new wxPaintDCInfo(m_window, this));

     }
 
     }
 

-    // (re)set the DC parameters.

     // Note: at this point m_hDC can be NULL under MicroWindows, when dragging.
     // Note: at this point m_hDC can be NULL under MicroWindows, when dragging.

-    if (GetHDC())
-        InitDC();
+    if (!GetHDC())
+        return;
+
+    // (re)set the DC parameters.
+    InitDC();
+
+    // the HDC can have a clipping box (which we didn't set), make sure our
+    // DoGetClippingBox() checks for it
+    m_clipping = true;

 }
 
 }
 

-wxPaintDC::~wxPaintDC()
+wxPaintDCImpl::~wxPaintDCImpl()

 {
     if ( m_hDC )
     {
 {
     if ( m_hDC )
     {


@@ -257,9 +269,9 @@ wxPaintDC::~wxPaintDC()
 
         wxCHECK_RET( info, wxT("existing DC should have a cache entry") );
 
 
         wxCHECK_RET( info, wxT("existing DC should have a cache entry") );
 

-        if ( !--info->count )
+        if ( --info->count == 0 )

         {
         {

-            ::EndPaint(GetHwndOf(m_canvas), &g_paintStruct);
+            ::EndPaint(GetHwndOf(m_window), &g_paintStruct);

 
             ms_cache.RemoveAt(index);
 
 
             ms_cache.RemoveAt(index);
 


@@ -275,14 +287,14 @@ wxPaintDC::~wxPaintDC()
     }
 }
 
     }
 }
 

-wxPaintDCInfo *wxPaintDC::FindInCache(size_t *index) const
+wxPaintDCInfo *wxPaintDCImpl::FindInCache(size_t *index) const

 {
     wxPaintDCInfo *info = NULL;
     size_t nCache = ms_cache.GetCount();
     for ( size_t n = 0; n < nCache; n++ )
     {
         wxPaintDCInfo *info1 = &ms_cache[n];
 {
     wxPaintDCInfo *info = NULL;
     size_t nCache = ms_cache.GetCount();
     for ( size_t n = 0; n < nCache; n++ )
     {
         wxPaintDCInfo *info1 = &ms_cache[n];

-        if ( info1->hwnd == m_canvas->GetHWND() )
+        if ( info1->hwnd == m_window->GetHWND() )

         {
             info = info1;
             if ( index )
         {
             info = info1;
             if ( index )


@@ -295,7 +307,7 @@ wxPaintDCInfo *wxPaintDC::FindInCache(size_t *index) const
 }
 
 // find the entry for this DC in the cache (keyed by the window)
 }
 
 // find the entry for this DC in the cache (keyed by the window)

-WXHDC wxPaintDC::FindDCInCache(wxWindow* win)
+WXHDC wxPaintDCImpl::FindDCInCache(wxWindow* win)

 {
     size_t nCache = ms_cache.GetCount();
     for ( size_t n = 0; n < nCache; n++ )
 {
     size_t nCache = ms_cache.GetCount();
     for ( size_t n = 0; n < nCache; n++ )


@@ -313,48 +325,69 @@ WXHDC wxPaintDC::FindDCInCache(wxWindow* win)
  * wxPaintDCEx
  */
 
  * wxPaintDCEx
  */
 

-// TODO: don't duplicate wxPaintDC code here!!
+// TODO: don't duplicate wxPaintDCImpl code here!!

 
 

-wxPaintDCEx::wxPaintDCEx(wxWindow *canvas, WXHDC dc) : saveState(0)
+class wxPaintDCExImpl: public wxPaintDCImpl

 {
 {

-    wxCHECK_RET( dc, wxT("wxPaintDCEx requires an existing device context") );
+public:
+    wxPaintDCExImpl( wxDC *owner, wxWindow *window, WXHDC dc );
+    ~wxPaintDCExImpl();

 
 

-    m_canvas = canvas;
+    int m_saveState;
+};

 
 

-    wxPaintDCInfo *info = FindInCache();
-    if ( info )
-    {
-        m_hDC = info->hdc;
-        info->count++;
-    }
-    else // not in cache, create a new one
-    {
-        m_hDC = dc;
-        ms_cache.Add(new wxPaintDCInfo(m_canvas, this));
-        saveState = SaveDC((HDC) dc);
-    }
+
+IMPLEMENT_ABSTRACT_CLASS(wxPaintDCEx,wxPaintDC)
+
+wxPaintDCEx::wxPaintDCEx(wxWindow *window, WXHDC dc)
+           : wxPaintDC(new wxPaintDCExImpl(this, window, dc))
+{

 }
 
 }
 

-wxPaintDCEx::~wxPaintDCEx()
+wxPaintDCExImpl::wxPaintDCExImpl(wxDC *owner, wxWindow *window, WXHDC dc)
+               : wxPaintDCImpl( owner )

 {
 {

-    size_t index;
-    wxPaintDCInfo *info = FindInCache(&index);
+        wxCHECK_RET( dc, wxT("wxPaintDCEx requires an existing device context") );

 
 

-    wxCHECK_RET( info, wxT("existing DC should have a cache entry") );
+        m_saveState = 0;

 
 

-    if ( !--info->count )
-    {
-        RestoreDC((HDC) m_hDC, saveState);
-        ms_cache.RemoveAt(index);
+        m_window = window;

 
 

-        // Reduce the number of bogus reports of non-freed memory
-        // at app exit
-        if (ms_cache.IsEmpty())
-            ms_cache.Clear();
-    }
-    //else: cached DC entry is still in use
+        wxPaintDCInfo *info = FindInCache();
+        if ( info )
+        {
+           m_hDC = info->hdc;
+           info->count++;
+        }
+        else // not in cache, create a new one
+        {
+                m_hDC = dc;
+                ms_cache.Add(new wxPaintDCInfo(m_window, this));
+                m_saveState = SaveDC((HDC) dc);
+        }
+}

 
 

-    // prevent the base class dtor from ReleaseDC()ing it again
-    m_hDC = 0;
+wxPaintDCExImpl::~wxPaintDCExImpl()
+{
+        size_t index;
+        wxPaintDCInfo *info = FindInCache(&index);
+
+        wxCHECK_RET( info, wxT("existing DC should have a cache entry") );
+
+        if ( --info->count == 0 )
+        {
+                RestoreDC((HDC) m_hDC, m_saveState);
+                ms_cache.RemoveAt(index);
+
+                // Reduce the number of bogus reports of non-freed memory
+                // at app exit
+                if (ms_cache.IsEmpty())
+                        ms_cache.Clear();
+        }
+        //else: cached DC entry is still in use
+
+        // prevent the base class dtor from ReleaseDC()ing it again
+        m_hDC = 0;

 }
 
 }
 

+