memory_dc.cpp

// memory_dc.cpp

// Copyright (C) 2004 Steven Weiß (steven11@gmx.de)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.


#include <background_wnd/detail/memory_dc.hpp>
#include <crtdbg.h>


namespace win32 { namespace gui {
namespace bg_wnd {

memory_dc::memory_dc(void) : hMemDC_(NULL), hOldBitmap_(NULL)
{}

memory_dc::~memory_dc(void)
{
     delete_dc();
}

void memory_dc::create_dc(HDC hDC, int cx, int cy)
{        
     delete_dc();
     _ASSERTE(hMemDC_ == NULL);                   // DC must be NULL

    HBITMAP hBitmap = CreateCompatibleBitmap(hDC, cx, cy);    
    _ASSERTE(hBitmap);                            // Bitmap must be valid

    hMemDC_ = CreateCompatibleDC(hDC);            
    _ASSERTE(hMemDC_);                            // DC must be valid
    hOldBitmap_ = (HBITMAP) SelectObject(hMemDC_, (HGDIOBJ) hBitmap);
    
     // Fill background
     COLORREF cr = GetBkColor(hDC);
     SetBkColor(hMemDC_, cr);
    HBRUSH hbr = CreateSolidBrush(cr);
     RECT rc = { 0, 0, cx, cy };
    FillRect(hMemDC_, &rc, hbr);        
    DeleteObject((HGDIOBJ) hbr);    
}

void memory_dc::delete_dc()
{
    if (hMemDC_ && hOldBitmap_) {
        HGDIOBJ hBmp = SelectObject(hMemDC_, (HGDIOBJ) hOldBitmap_);
        DeleteObject(hBmp);
        DeleteDC(hMemDC_);
        hMemDC_ = NULL;
        hOldBitmap_ = NULL;
    }
}  

memory_dc::operator HDC()
{
     return hMemDC_;
}
     
void memory_dc::size(int cx, int cy)
{
     if (hMemDC_) {
          if (cx == 0 || cy == 0) {
               _ASSERTE(false);                   // invalid size
               return;
          }
     
          memory_dc tempDC;
          tempDC.create_dc(*this, cx, cy);
          bitblt(tempDC, 0, 0, cx, cy, 0, 0, SRCCOPY);
          swap(tempDC);        
    }
}

SIZE memory_dc::size() const
{
     SIZE size = { 0 };
     if (hMemDC_) {
        BITMAP bm;
        HGDIOBJ hBmp = GetCurrentObject(hMemDC_, OBJ_BITMAP);        
          if (GetObject(hBmp, sizeof(BITMAP), (void*) &bm) != NULL) {
               size.cx = bm.bmWidth;
               size.cy = bm.bmHeight;
          }
     }
     return size;
}

bool memory_dc::bitblt(HDC hDest, int x, int y, int cx, int cy, int xSrc, int ySrc, DWORD dwRop)
{
     _ASSERTE(hMemDC_);                      // DC must be valid for this operation
     return BitBlt(hDest, x, y, cx, cy, hMemDC_, xSrc, ySrc, dwRop) != FALSE;
}

void memory_dc::swap(memory_dc& dc)
{
     HDC hDC         = dc.hMemDC_;
     HBITMAP hBmp = dc.hOldBitmap_;
     dc.hMemDC_        = hMemDC_;
     dc.hOldBitmap_ = hOldBitmap_;
     hMemDC_        = hDC;
     hOldBitmap_ = hBmp;
}

}    // namespace bg_wnd
} }  // namespace win32::gui

---