resource_painter.cpp

// resource_painter.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/painters/resource_painter.hpp>
#include <crtdbg.h>


namespace win32 { namespace gui {

// ============================================================================================================= //
// res_info

namespace bg_wnd {

res_info::res_info(unsigned nResource, unsigned uType, int cx, int cy, unsigned fuLoad, HINSTANCE hInst)
     : pchResource_(MAKEINTRESOURCE(nResource)), uType_(uType), cx_(cx), cy_(cy), fuLoad_(fuLoad), hInst_(hInst)
{}

res_info::res_info(const char* pchResource, unsigned uType, int cx, int cy, unsigned fuLoad, HINSTANCE hInst) 
     : pchResource_(pchResource), uType_(uType), cx_(cx), cy_(cy), fuLoad_(fuLoad), hInst_(hInst)
{}

}    // namespace bg_wnd

// ============================================================================================================= //
// resource_painter

namespace detail {

resource_painter_base::resource_painter_base(param0 info) : hResource_(NULL), uType_(0)
{
     load_resource(info);
}
     
resource_painter_base::resource_painter_base(const resource_painter_base& p) : hResource_(NULL), uType_(0)
{
     *this = p;               // call operator= ;-)
}

resource_painter_base::~resource_painter_base()
{
     delete_resource();
}

const resource_painter_base& resource_painter_base::operator= (const resource_painter_base& p)
{
     if (this != &p) {
          delete_resource();
          
          // FIX
          // before: switch(uType_) -> assignment was wrong because uType_ is reset in delete_resource()
          switch (p.uType_) {
               case IMAGE_CURSOR:  hResource_ = CopyCursor((HCURSOR) p.hResource_); break;
               case IMAGE_ICON:    hResource_ = CopyIcon((HICON) p.hResource_); break;
               case IMAGE_BITMAP:  
                    // create dc's
                    SIZE size   = p.resource_size();                  
                    HDC hSrcDC  = CreateCompatibleDC(NULL);
                    HDC hDestDC = CreateCompatibleDC(NULL);
                    
                    // blit                  
                    HBITMAP hOldBmp = (HBITMAP) SelectObject(hSrcDC, p.hResource_);
                    hResource_  = CreateCompatibleBitmap(hDestDC, size.cx, size.cy);
                    SelectObject(hDestDC, hResource_);
                    BitBlt(hDestDC, 0, 0, size.cx, size.cy, hSrcDC, 0, 0, SRCCOPY);
                    
                    // clean up
                    SelectObject(hSrcDC, hOldBmp);
                    SelectObject(hDestDC, hOldBmp);
                    DeleteDC(hSrcDC);
                    DeleteDC(hDestDC);
                    
                    break;
          }
          uType_ = p.uType_;
     }
     return *this;
}

void resource_painter_base::delete_resource()
{
     switch (uType_) {
          case IMAGE_BITMAP: DeleteObject(hResource_); break;
          case IMAGE_CURSOR: DestroyCursor((HCURSOR) hResource_); break;
          case IMAGE_ICON:   DestroyIcon((HICON) hResource_); break;
          default: _ASSERTE(false); break;             // wrong type!
     }
     hResource_ = NULL;
     uType_ = 0;
}

void resource_painter_base::draw_resource(HDC hDC, int x, int y, int cx, int cy)
{    
     switch (uType_) {        
          case IMAGE_BITMAP: { 
               HDC hTmp = CreateCompatibleDC(hDC);
               HGDIOBJ hOld = SelectObject(hTmp, (HGDIOBJ) hResource_);
               BitBlt(hDC, x, y, cx, cy, hTmp, 0, 0, SRCCOPY);
               SelectObject(hTmp, hOld);
               DeleteDC(hTmp);
               break;    
          }

          case IMAGE_CURSOR:            
          case IMAGE_ICON: {
               SIZE size = resource_size();            
               DrawIconEx(hDC, x, y, (HICON) hResource_, size.cx, size.cy, 0, NULL, DI_NORMAL);
               break;
          }
     }
}

void resource_painter_base::load_resource(const bg_wnd::res_info& info)
{
     if (info.uType_ == IMAGE_BITMAP || info.uType_ == IMAGE_CURSOR || info.uType_ == IMAGE_ICON) { 
          delete_resource();       
          hResource_ = LoadImage(info.hInst_, info.pchResource_, info.uType_, info.cx_, info.cy_, info.fuLoad_);        
          uType_ = info.uType_;         
     }
     else {
          _ASSERTE(false);              // Type must be one of these: IMAGE_BITMAP, IMAGE_CURSOR or IMAGE_ICON
     }
}

SIZE resource_painter_base::resource_size() const
{
     HBITMAP hBitmap = NULL;
     switch (uType_) {        
          case IMAGE_BITMAP: hBitmap = (HBITMAP) hResource_; break;        

          case IMAGE_CURSOR:            
          case IMAGE_ICON: 
               ICONINFO info = { 0 };                            
               GetIconInfo((HICON) hResource_, &info);
               hBitmap = info.hbmColor ? info.hbmColor : info.hbmMask; 
               break;
     }    

     SIZE size = { 0, 0 };
     BITMAP bm = { 0 };
     if (GetObject(hBitmap, sizeof (BITMAP), &bm) != 0) {
          size.cx = bm.bmWidth;
          size.cy = bm.bmHeight;
     }
     return size;
}

}    // namespace detail

// ========================================================================================================= //

resource_painter::resource_painter(param0 info) : Base(info)
{}

resource_painter* resource_painter::clone() const
{
     return new resource_painter(*this);
}

void resource_painter::draw(HDC hDC, int cx, int cy)
{
     draw_resource(hDC, 0, 0, cx, cy);
}

// ========================================================================================================= //

tile_resource_painter::tile_resource_painter(param0 info) : Base(info)
{
     tile_size_.cx = 0;
     tile_size_.cy = 0;
}

tile_resource_painter::tile_resource_painter(param0 info, param1 tile_size) : Base(info), tile_size_(tile_size)
{}

tile_resource_painter* tile_resource_painter::clone() const
{
     return new tile_resource_painter(*this);
}

void tile_resource_painter::draw(HDC hDC, int cx, int cy)
{
     SIZE size = tile_size_;
     if (tile_size_.cx == 0 && tile_size_.cy == 0)
          size = resource_size();

     _ASSERTE(size.cx != 0 && size.cy != 0);                // infinite loop if one is 0
     for (int x = 0; x < cx; x += size.cx) {
          for (int y = 0; y < cy; y += size.cy) {      
               draw_resource(hDC, x, y, cx - x, cy - y);              
          }         
     }
}

void tile_resource_painter::tile_size(SIZE tile_size)
{    
     tile_size_ = tile_size;
}

SIZE tile_resource_painter::tile_size() const
{
     return tile_size_;
}


} }  // namespace win32::gui

---