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