ipicture.cpp

// ipicture.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/ipicture.hpp>
#include <crtdbg.h>
#include <ocidl.h>                      // IPicture
#include <olectl.h>                     // OleLoadPicture
#include <shlwapi.h>


namespace win32 { namespace gui {
namespace bg_wnd {

ipicture::ipicture()
    : pPicture_(NULL)
{}

ipicture::ipicture(const ipicture& image) : pPicture_(image.pPicture_)
{
    if (pPicture_)
        pPicture_->AddRef();        
}

ipicture::~ipicture()
{
     release();    
}

const ipicture& ipicture::operator= (const ipicture& image)
{
    if (this != &image) {
        release();
        pPicture_ = image.pPicture_;
        if (pPicture_)
            pPicture_->AddRef();        
    }
    return *this;
}

void DPtoHIMETRIC(HDC hDC, int& cx, int& cy)
{
     const int HIMETRIC_INCH = 2540;

    // map against logical inch for non-constrained mapping modes
    int cxPerInch = GetDeviceCaps(hDC, LOGPIXELSX);
    int cyPerInch = GetDeviceCaps(hDC, LOGPIXELSY);
    
    _ASSERTE(cxPerInch != 0 && cyPerInch != 0);
    cx = MulDiv(cx, HIMETRIC_INCH, cxPerInch);
    cy = MulDiv(cy, HIMETRIC_INCH, cyPerInch);
}

void HIMETRICtoDP(HDC hDC, LPSIZE lpSize)
{    
    const int HIMETRIC_INCH = 2540;

    int nMapMode;
    if (hDC != NULL && (nMapMode = GetMapMode(hDC)) < MM_ISOTROPIC && nMapMode != MM_TEXT) {
        // when using a constrained map mode, map against physical inch
        SetMapMode(hDC, MM_HIMETRIC);
        POINT pt = { lpSize->cx, lpSize->cy };
        LPtoDP(hDC, &pt, 1);
        lpSize->cx = pt.x; lpSize->cy = pt.y;
        SetMapMode(hDC, nMapMode);
    }
    else {
        // map against logical inch for non-constrained mapping modes
        int cxPerInch = GetDeviceCaps(hDC, LOGPIXELSX);
        int cyPerInch = GetDeviceCaps(hDC, LOGPIXELSY);
        
        _ASSERTE(cxPerInch != 0 && cyPerInch != 0);
        lpSize->cx = MulDiv(lpSize->cx, cxPerInch, HIMETRIC_INCH);
        lpSize->cy = MulDiv(lpSize->cy, cyPerInch, HIMETRIC_INCH);
    }
}

bool ipicture::get_size(SIZE& size) const
{
    _ASSERTE(pPicture_);                                        // Bild muss bereits geladen worden sein!

    if (pPicture_) {
        
        OLE_XSIZE_HIMETRIC width;
        OLE_YSIZE_HIMETRIC height;
        if (pPicture_->get_Width(&width) == S_OK && pPicture_->get_Height(&height) == S_OK) {                        
            
            HDC hDC = GetWindowDC(NULL);            
            size.cx = width;
            size.cy = height;
            
            HIMETRICtoDP(hDC, &size);        
            ReleaseDC(NULL, hDC);

            return true;
        }
    }

    return false;
}

IPicture* ipicture::raw_picture() const
{
    return pPicture_;
}

bool ipicture::loaded() const
{
    return pPicture_ != NULL;
}

bool ipicture::draw(HDC hDC, int x, int y, int cx, int cy, int xSrc, int ySrc, int cxSrc, int cySrc)
{
     if (hDC && pPicture_) {
          // Pixel -> HIMETRIC          
          DPtoHIMETRIC(hDC, xSrc, ySrc);          
          DPtoHIMETRIC(hDC, cxSrc, cySrc);

          HRESULT hr = pPicture_->Render(hDC, 
                                                x, y, cx, cy, 
                                                xSrc, cySrc - ySrc, cxSrc, -cySrc, 
                                                NULL);                                   
          return hr == S_OK;            
     }
     return false;
}

bool ipicture::draw(HDC hDC, int x, int y, int cx, int cy, int xSrc, int ySrc)
{
     if (hDC && pPicture_) {
          SIZE size;
          get_size(size);

          return draw(hDC, 
                         x, y, cx, cy, 
                         xSrc, ySrc, size.cx, size.cy);
     }
    return false;
}

bool ipicture::draw(HDC hDC, int x, int y)
{
     if (hDC && pPicture_) {
          SIZE size;
        if (get_size(size))                       
               return draw(hDC, 
                              x, y, size.cx, size.cy, 
                              0, 0);
     }
     return false;
}

bool ipicture::draw(HDC hDC, POINT pt)
{    
    return draw(hDC, pt.x, pt.y);    
}

bool ipicture::draw_stretched(HDC hDC, const RECT& rc)
{
    _ASSERTE(hDC);                                // DC muss gültig sein
    _ASSERTE(pPicture_);                               // image muss bereits geladen worden sein!

    if (hDC && pPicture_) {
        SIZE size;
        if (get_size(size)) {

            OLE_XSIZE_HIMETRIC cxSrc;
            OLE_YSIZE_HIMETRIC cySrc;
            pPicture_->get_Width(&cxSrc);
            pPicture_->get_Height(&cySrc);

            if (pPicture_->Render(hDC, 
                                   rc.left, rc.top, 
                                   rc.right - rc.left, rc.bottom - rc.top,
                                   0, cySrc, cxSrc, -cySrc,
                                   NULL) == S_OK)
                return true;
        }
    }

    return false;
}

bool ipicture::load_from_file(const std::string& fileName)
{    
    using namespace std;
    
    IStream* pStream;
    HRESULT hr = SHCreateStreamOnFile(fileName.c_str(), STGM_READ | STGM_SHARE_EXCLUSIVE, &pStream);
    if (hr == S_OK) {
        IPicture* pOldPic = pPicture_;
                        
        // image laden        
        hr = OleLoadPicture(pStream, 0, FALSE, IID_IPicture, (void**) &pPicture_);
        pStream->Release();
        if (hr == S_OK) {
            if (pOldPic)
                pOldPic->Release();
            return true;
        }        
    }

    return false;
}

void ipicture::release()
{
     if (pPicture_)
        pPicture_->Release();
}

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

---