src/msw/dcclient.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dcclient.cpp
   3 // Purpose:     wxClientDC class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/string.h"
  28 #include "wx/log.h"
  29 #include "wx/window.h"
  30
  31 #include "wx/msw/private.h"
  32
  33 #include "wx/dcclient.h"
  34
  35 // ----------------------------------------------------------------------------
  36 // array/list types
  37 // ----------------------------------------------------------------------------
  38
  39 struct WXDLLEXPORT wxPaintDCInfo
  40 {
  41     wxPaintDCInfo(wxWindow *win, wxDC *dc)
  42     {
  43         hwnd = win->GetHWND();
  44         hdc = dc->GetHDC();
  45         count = 1;
  46     }
  47
  48     WXHWND    hwnd;       // window for this DC
  49     WXHDC     hdc;        // the DC handle
  50     size_t    count;      // usage count
  51 };
  52
  53 #include "wx/arrimpl.cpp"
  54
  55 WX_DEFINE_OBJARRAY(wxArrayDCInfo);
  56
  57 // ----------------------------------------------------------------------------
  58 // macros
  59 // ----------------------------------------------------------------------------
  60
  61 IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
  62 IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
  63 IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
  64 IMPLEMENT_CLASS(wxPaintDCEx, wxPaintDC)
  65
  66 // ----------------------------------------------------------------------------
  67 // global variables
  68 // ----------------------------------------------------------------------------
  69
  70 static PAINTSTRUCT g_paintStruct;
  71
  72 #ifdef __WXDEBUG__
  73     // a global variable which we check to verify that wxPaintDC are only
  74     // created in response to WM_PAINT message - doing this from elsewhere is a
  75     // common programming error among wxWidgets programmers and might lead to
  76     // very subtle and difficult to debug refresh/repaint bugs.
  77     int g_isPainting = 0;
  78 #endif // __WXDEBUG__
  79
  80 // ===========================================================================
  81 // implementation
  82 // ===========================================================================
  83
  84 // ----------------------------------------------------------------------------
  85 // wxWindowDC
  86 // ----------------------------------------------------------------------------
  87
  88 wxWindowDC::wxWindowDC()
  89 {
  90     m_canvas = NULL;
  91 }
  92
  93 wxWindowDC::wxWindowDC(wxWindow *canvas)
  94 {
  95     wxCHECK_RET( canvas, _T("invalid window in wxWindowDC") );
  96
  97     m_canvas = canvas;
  98     m_hDC = (WXHDC) ::GetWindowDC(GetHwndOf(m_canvas));
  99
 100     // m_bOwnsDC was already set to false in the base class ctor, so the DC
 101     // will be released (and not deleted) in ~wxDC
 102     InitDC();
 103 }
 104
 105 void wxWindowDC::InitDC()
 106 {
 107     // the background mode is only used for text background and is set in
 108     // DrawText() to OPAQUE as required, otherwise always TRANSPARENT,
 109     ::SetBkMode(GetHdc(), TRANSPARENT);
 110
 111     // default bg colour is pne of the window
 112     SetBackground(wxBrush(m_canvas->GetBackgroundColour(), wxSOLID));
 113
 114     // since we are a window dc we need to grab the palette from the window
 115 #if wxUSE_PALETTE
 116     InitializePalette();
 117 #endif
 118 }
 119
 120 void wxWindowDC::DoGetSize(int *width, int *height) const
 121 {
 122     wxCHECK_RET( m_canvas, _T("wxWindowDC without a window?") );
 123
 124     m_canvas->GetSize(width, height);
 125 }
 126
 127 // ----------------------------------------------------------------------------
 128 // wxClientDC
 129 // ----------------------------------------------------------------------------
 130
 131 wxClientDC::wxClientDC()
 132 {
 133     m_canvas = NULL;
 134 }
 135
 136 wxClientDC::wxClientDC(wxWindow *canvas)
 137 {
 138     wxCHECK_RET( canvas, _T("invalid window in wxClientDC") );
 139
 140     m_canvas = canvas;
 141     m_hDC = (WXHDC)::GetDC(GetHwndOf(m_canvas));
 142
 143     // m_bOwnsDC was already set to false in the base class ctor, so the DC
 144     // will be released (and not deleted) in ~wxDC
 145
 146     InitDC();
 147 }
 148
 149 void wxClientDC::InitDC()
 150 {
 151     wxWindowDC::InitDC();
 152
 153     // in wxUniv build we must manually do some DC adjustments usually
 154     // performed by Windows for us
 155     //
 156     // we also need to take the menu/toolbar manually into account under
 157     // Windows CE because they're just another control there, not anything
 158     // special as usually under Windows
 159 #if defined(__WXUNIVERSAL__) || defined(__WXWINCE__)
 160     wxPoint ptOrigin = m_canvas->GetClientAreaOrigin();
 161     if ( ptOrigin.x || ptOrigin.y )
 162     {
 163         // no need to shift DC origin if shift is null
 164         SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
 165     }
 166
 167     // clip the DC to avoid overwriting the non client area
 168     SetClippingRegion(wxPoint(0,0), m_canvas->GetClientSize());
 169 #endif // __WXUNIVERSAL__ || __WXWINCE__
 170 }
 171
 172 wxClientDC::~wxClientDC()
 173 {
 174 }
 175
 176 void wxClientDC::DoGetSize(int *width, int *height) const
 177 {
 178     wxCHECK_RET( m_canvas, _T("wxClientDC without a window?") );
 179
 180     m_canvas->GetClientSize(width, height);
 181 }
 182
 183 // ----------------------------------------------------------------------------
 184 // wxPaintDC
 185 // ----------------------------------------------------------------------------
 186
 187 // VZ: initial implementation (by JACS) only remembered the last wxPaintDC
 188 //     created and tried to reuse it - this was supposed to take care of a
 189 //     situation when a derived class OnPaint() calls base class OnPaint()
 190 //     because in this case ::BeginPaint() shouldn't be called second time.
 191 //
 192 //     I'm not sure how useful this is, however we must remember the HWND
 193 //     associated with the last HDC as well - otherwise we may (and will!) try
 194 //     to reuse the HDC for another HWND which is a nice recipe for disaster.
 195 //
 196 //     So we store a list of windows for which we already have the DC and not
 197 //     just one single hDC. This seems to work, but I'm really not sure about
 198 //     the usefullness of the whole idea - IMHO it's much better to not call
 199 //     base class OnPaint() at all, or, if we really want to allow it, add a
 200 //     "wxPaintDC *" parameter to wxPaintEvent which should be used if it's
 201 //     !NULL instead of creating a new DC.
 202
 203 wxArrayDCInfo wxPaintDC::ms_cache;
 204
 205 wxPaintDC::wxPaintDC()
 206 {
 207     m_canvas = NULL;
 208 }
 209
 210 wxPaintDC::wxPaintDC(wxWindow *canvas)
 211 {
 212     wxCHECK_RET( canvas, wxT("NULL canvas in wxPaintDC ctor") );
 213
 214 #ifdef __WXDEBUG__
 215     if ( g_isPainting <= 0 )
 216     {
 217         wxFAIL_MSG( wxT("wxPaintDC may be created only in EVT_PAINT handler!") );
 218
 219         return;
 220     }
 221 #endif // __WXDEBUG__
 222
 223     m_canvas = canvas;
 224
 225     // do we have a DC for this window in the cache?
 226     wxPaintDCInfo *info = FindInCache();
 227     if ( info )
 228     {
 229         m_hDC = info->hdc;
 230         info->count++;
 231     }
 232     else // not in cache, create a new one
 233     {
 234         m_hDC = (WXHDC)::BeginPaint(GetHwndOf(m_canvas), &g_paintStruct);
 235         if (m_hDC)
 236             ms_cache.Add(new wxPaintDCInfo(m_canvas, this));
 237     }
 238
 239     // (re)set the DC parameters.
 240     // Note: at this point m_hDC can be NULL under MicroWindows, when dragging.
 241     if (GetHDC())
 242         InitDC();
 243 }
 244
 245 wxPaintDC::~wxPaintDC()
 246 {
 247     if ( m_hDC )
 248     {
 249         SelectOldObjects(m_hDC);
 250
 251         size_t index;
 252         wxPaintDCInfo *info = FindInCache(&index);
 253
 254         wxCHECK_RET( info, wxT("existing DC should have a cache entry") );
 255
 256         if ( !--info->count )
 257         {
 258             ::EndPaint(GetHwndOf(m_canvas), &g_paintStruct);
 259
 260             ms_cache.RemoveAt(index);
 261
 262             // Reduce the number of bogus reports of non-freed memory
 263             // at app exit
 264             if (ms_cache.IsEmpty())
 265                 ms_cache.Clear();
 266         }
 267         //else: cached DC entry is still in use
 268
 269         // prevent the base class dtor from ReleaseDC()ing it again
 270         m_hDC = 0;
 271     }
 272 }
 273
 274 wxPaintDCInfo *wxPaintDC::FindInCache(size_t *index) const
 275 {
 276     wxPaintDCInfo *info = NULL;
 277     size_t nCache = ms_cache.GetCount();
 278     for ( size_t n = 0; n < nCache; n++ )
 279     {
 280         wxPaintDCInfo *info1 = &ms_cache[n];
 281         if ( info1->hwnd == m_canvas->GetHWND() )
 282         {
 283             info = info1;
 284             if ( index )
 285                 *index = n;
 286             break;
 287         }
 288     }
 289
 290     return info;
 291 }
 292
 293 // find the entry for this DC in the cache (keyed by the window)
 294 WXHDC wxPaintDC::FindDCInCache(wxWindow* win)
 295 {
 296     size_t nCache = ms_cache.GetCount();
 297     for ( size_t n = 0; n < nCache; n++ )
 298     {
 299         wxPaintDCInfo *info = &ms_cache[n];
 300         if ( info->hwnd == win->GetHWND() )
 301         {
 302             return info->hdc;
 303         }
 304     }
 305     return 0;
 306 }
 307
 308 /*
 309  * wxPaintDCEx
 310  */
 311
 312 // TODO: don't duplicate wxPaintDC code here!!
 313
 314 wxPaintDCEx::wxPaintDCEx(wxWindow *canvas, WXHDC dc) : saveState(0)
 315 {
 316     wxCHECK_RET( dc, wxT("wxPaintDCEx requires an existing device context") );
 317
 318     m_canvas = canvas;
 319
 320     wxPaintDCInfo *info = FindInCache();
 321     if ( info )
 322     {
 323         m_hDC = info->hdc;
 324         info->count++;
 325     }
 326     else // not in cache, create a new one
 327     {
 328         m_hDC = dc;
 329         ms_cache.Add(new wxPaintDCInfo(m_canvas, this));
 330         saveState = SaveDC((HDC) dc);
 331     }
 332 }
 333
 334 wxPaintDCEx::~wxPaintDCEx()
 335 {
 336     size_t index;
 337     wxPaintDCInfo *info = FindInCache(&index);
 338
 339     wxCHECK_RET( info, wxT("existing DC should have a cache entry") );
 340
 341     if ( !--info->count )
 342     {
 343         RestoreDC((HDC) m_hDC, saveState);
 344         ms_cache.RemoveAt(index);
 345
 346         // Reduce the number of bogus reports of non-freed memory
 347         // at app exit
 348         if (ms_cache.IsEmpty())
 349             ms_cache.Clear();
 350     }
 351     //else: cached DC entry is still in use
 352
 353     // prevent the base class dtor from ReleaseDC()ing it again
 354     m_hDC = 0;
 355 }
 356