include/wx/dcbuffer.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/dcbuffer.h
   3 // Purpose:     wxBufferedDC class
   4 // Author:      Ron Lee <ron@debian.org>
   5 // Modified by: Vadim Zeitlin (refactored, added bg preservation)
   6 // Created:     16/03/02
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Ron Lee
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_DCBUFFER_H_
  13 #define _WX_DCBUFFER_H_
  14
  15 #include "wx/dcmemory.h"
  16 #include "wx/dcclient.h"
  17 #include "wx/window.h"
  18
  19 // ----------------------------------------------------------------------------
  20 // Double buffering helper.
  21 // ----------------------------------------------------------------------------
  22
  23 // Assumes the buffer bitmap covers the entire scrolled window,
  24 // and prepares the window DC accordingly
  25 #define wxBUFFER_VIRTUAL_AREA       0x01
  26
  27 // Assumes the buffer bitmap only covers the client area;
  28 // does not prepare the window DC
  29 #define wxBUFFER_CLIENT_AREA        0x02
  30
  31 class wxBufferedDC : public wxMemoryDC
  32 {
  33 public:
  34     // Default ctor, must subsequently call Init for two stage construction.
  35     wxBufferedDC() : m_dc( 0 ), m_style(0)
  36     {
  37     }
  38
  39     // Construct a wxBufferedDC using a user supplied buffer.
  40     wxBufferedDC(wxDC *dc,
  41                  const wxBitmap &buffer = wxNullBitmap,
  42                  int style = wxBUFFER_CLIENT_AREA)
  43         : m_dc( dc ),
  44           m_buffer( buffer ),
  45           m_style(style)
  46     {
  47         UseBuffer();
  48     }
  49
  50     // Construct a wxBufferedDC with an internal buffer of 'area'
  51     // (where area is usually something like the size of the window
  52     // being buffered)
  53     wxBufferedDC(wxDC *dc, const wxSize &area, int style = wxBUFFER_CLIENT_AREA)
  54         : m_dc( dc ),
  55           m_buffer( area.GetWidth(), area.GetHeight() ),
  56           m_style(style)
  57
  58     {
  59         UseBuffer();
  60     }
  61
  62     // default copy ctor ok.
  63
  64     // The usually desired  action in the dtor is to blit the buffer.
  65     virtual ~wxBufferedDC()
  66     {
  67         if ( m_dc ) UnMask();
  68     }
  69
  70     // These reimplement the actions of the ctors for two stage creation, but
  71     // are not used by the ctors themselves to save a few cpu cycles.
  72     void Init(wxDC *dc,
  73               const wxBitmap &buffer=wxNullBitmap,
  74               int style = wxBUFFER_CLIENT_AREA)
  75     {
  76         wxASSERT_MSG( m_dc == 0 && m_buffer == wxNullBitmap,
  77                       _T("wxBufferedDC already initialised") );
  78         m_dc = dc;
  79         m_buffer = buffer;
  80         m_style = style;
  81         UseBuffer();
  82     }
  83
  84     void Init(wxDC *dc, const wxSize &area, int style = wxBUFFER_CLIENT_AREA)
  85     {
  86         Init(dc, wxBitmap(area.GetWidth(), area.GetHeight()), style);
  87     }
  88
  89     // Blits the buffer to the dc, and detaches the dc from the buffer (so it
  90     // can be effectively used once only).
  91     //
  92     // Usually called in the dtor or by the dtor of derived classes if the
  93     // BufferedDC must blit before the derived class (which may own the dc it's
  94     // blitting to) is destroyed.
  95     void UnMask()
  96     {
  97         wxASSERT_MSG( m_dc != 0,
  98                       _T("No underlying DC associated with wxBufferedDC (anymore)") );
  99
 100         wxCoord x=0, y=0;
 101
 102         if (m_style & wxBUFFER_CLIENT_AREA)
 103             GetDeviceOrigin(& x, & y);
 104
 105         m_dc->Blit( 0, 0,
 106                     m_buffer.GetWidth(), m_buffer.GetHeight(), this,
 107                     -x, -y );
 108         m_dc = NULL;
 109     }
 110
 111     // Set and get the style
 112     void SetStyle(int style) { m_style = style; }
 113     int GetStyle() const { return m_style; }
 114
 115 private:
 116     // check that the bitmap is valid and use it
 117     void UseBuffer()
 118     {
 119         if (!m_buffer.Ok())
 120         {
 121             wxCoord w, h;
 122             m_dc->GetSize(&w, &h);
 123             m_buffer = wxBitmap(w, h);
 124         }
 125
 126         SelectObject(m_buffer);
 127     }
 128
 129     // the underlying DC to which we copy everything drawn on this one in
 130     // UnMask()
 131     //
 132     // NB: Without the existence of a wxNullDC, this must be a pointer, else it
 133     //     could probably be a reference.
 134     wxDC *m_dc;
 135
 136     // the buffer (selected in this DC)
 137     wxBitmap m_buffer;
 138
 139     // the buffering style
 140     int m_style;
 141
 142     DECLARE_NO_COPY_CLASS(wxBufferedDC)
 143 };
 144
 145
 146 // ----------------------------------------------------------------------------
 147 // Double buffered PaintDC.
 148 // ----------------------------------------------------------------------------
 149
 150 // Creates a double buffered wxPaintDC, optionally allowing the
 151 // user to specify their own buffer to use.
 152 class wxBufferedPaintDC : public wxBufferedDC
 153 {
 154 public:
 155     // If no bitmap is supplied by the user, a temporary one will be created.
 156     wxBufferedPaintDC(wxWindow *window, const wxBitmap& buffer, int style = wxBUFFER_CLIENT_AREA)
 157         : m_paintdc(window)
 158     {
 159         // If we're buffering the virtual window, scale the paint DC as well
 160         if (style & wxBUFFER_VIRTUAL_AREA)
 161             window->PrepareDC( m_paintdc );
 162
 163         if( buffer != wxNullBitmap )
 164             Init(&m_paintdc, buffer, style);
 165         else
 166             Init(&m_paintdc, window->GetClientSize(), style);
 167     }
 168
 169     // If no bitmap is supplied by the user, a temporary one will be created.
 170     wxBufferedPaintDC(wxWindow *window, int style = wxBUFFER_CLIENT_AREA)
 171         : m_paintdc(window)
 172     {
 173         // If we're using the virtual window, scale the paint DC as well
 174         if (style & wxBUFFER_VIRTUAL_AREA)
 175             window->PrepareDC( m_paintdc );
 176
 177         Init(&m_paintdc, window->GetClientSize(), style);
 178     }
 179
 180     // default copy ctor ok.
 181
 182     virtual ~wxBufferedPaintDC()
 183     {
 184         // We must UnMask here, else by the time the base class
 185         // does it, the PaintDC will have already been destroyed.
 186         UnMask();
 187     }
 188
 189 private:
 190     wxPaintDC m_paintdc;
 191
 192     DECLARE_NO_COPY_CLASS(wxBufferedPaintDC)
 193 };
 194
 195 #endif  // _WX_DCBUFFER_H_
 196