IPicture

#pragma once


class CPicture
{
public:
    CPicture();
    virtual ~CPicture();

public:
    BOOL LoadPictureFromRes( UINT nPicID, LPCTSTR lpszResType );
    BOOL LoadPictureFromFile( LPCTSTR lpszFile );
    BOOL Draw( HDC hDC, LPCRECT lprcDest, LPCRECT lprcSrc = NULL );
    void Release();
    inline operator bool() const;
    BOOL GetSize( LPSIZE lpSize, HDC hDC );

protected:
    IPicture* m_pPic;
    OLE_XSIZE_HIMETRIC m_nWidth, m_nHeight;
};

#include "Picture.h"

CPicture::CPicture() : m_pPic( NULL )
{
}

CPicture::~CPicture()
{
    if ( m_pPic != NULL )
    {
        m_pPic->Release();
    }
}

CPicture::operator bool() const
{
    return m_pPic != NULL ? true : false;
}

void CPicture::Release()
{
    if ( m_pPic != NULL )
    {
        m_pPic->Release();
        m_pPic = NULL;
    }
}


BOOL CPicture::LoadPictureFromRes( UINT nPicID, LPCTSTR lpszResType )
{
    HINSTANCE hInst;
    HRSRC hRes;
    HGLOBAL hGlobal, hMem;
    LPVOID lpData, lpBuf;
    DWORD dwSize;
    HRESULT hr;
    IStream* pStm;

    if ( m_pPic )
    {
        m_pPic->Release();
        m_pPic = NULL;
    }

    hInst = ::GetModuleHandle( NULL );

    hRes = ::FindResource( hInst, MAKEINTRESOURCE( nPicID ), lpszResType );
    if ( hRes == NULL )
    {
        return NULL;
    }

    hGlobal = ::LoadResource( hInst, hRes );
    if ( hGlobal == NULL )
    {
        return NULL;
    }

    dwSize = ::SizeofResource( hInst, hRes );

    hMem = ::GlobalAlloc( GMEM_MOVEABLE, dwSize );
    if ( hMem == NULL )
    {
        ::FreeResource( hGlobal );
        return FALSE;
    }

    lpBuf = ::GlobalLock( hMem );
    lpData = ::LockResource( hGlobal );
    memcpy( lpBuf, lpData, dwSize );
    ::GlobalUnlock( hMem );

    //UnlockResource
    ::FreeResource( hGlobal );

    hr = ::CreateStreamOnHGlobal( hMem, TRUE, &pStm );
    if ( FAILED( hr ) )
    {
        ::GlobalFree( hMem );
        return FALSE;
    }

    hr = ::OleLoadPicture( pStm, dwSize, TRUE, IID_IPicture, ( LPVOID* )&m_pPic );
    if ( hr != S_OK )
    {
        //m_pPic = NULL;
        pStm->Release();
        return FALSE;
    }

    m_pPic->get_Width( &m_nWidth );
    m_pPic->get_Height( &m_nHeight );

    pStm->Release();
    return TRUE;
}

BOOL CPicture::LoadPictureFromFile( LPCTSTR lpszFile )
{
    BOOL bRet;
    HANDLE hFile;
    DWORD dwSize, dwSizeHigh, dwReads;
    HGLOBAL hMem;
    LPVOID lpBuf;
    HRESULT hr;
    IStream* pStm;

    if ( m_pPic )
    {
        m_pPic->Release();
        m_pPic = NULL;
    }

    hFile = ::CreateFile( lpszFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
    if ( hFile == INVALID_HANDLE_VALUE )
    {
        return FALSE;
    }

    dwSize = ::GetFileSize( hFile, &dwSizeHigh );
    if ( dwSize == INVALID_FILE_SIZE || dwSizeHigh != 0 )
    {
        ::CloseHandle( hFile );
        return FALSE;
    }

    hMem = ::GlobalAlloc( GMEM_MOVEABLE, dwSize );
    if ( hMem == NULL )
    {
        ::CloseHandle( hFile );
        return FALSE;
    }

    lpBuf = ::GlobalLock( hMem );

    bRet = ::ReadFile( hFile, lpBuf, dwSize, &dwReads, NULL );
    if ( !bRet || dwReads != dwReads )
    {
        ::CloseHandle( hFile );
        ::GlobalUnlock( hMem );
        ::GlobalFree( hMem );
        return FALSE;
    }

    ::CloseHandle( hFile );
    ::GlobalUnlock( hMem );

    hr = ::CreateStreamOnHGlobal( hMem, TRUE, &pStm );
    if ( FAILED( hr ) )
    {
        ::GlobalFree( hMem );
        return FALSE;
    }

    hr = ::OleLoadPicture( pStm, dwSize, TRUE, IID_IPicture, ( LPVOID* )&m_pPic );
    if ( hr != S_OK )
    {
        //m_pPic = NULL;
        pStm->Release();
        return FALSE;
    }

    m_pPic->get_Width( &m_nWidth );
    m_pPic->get_Height( &m_nHeight );

    pStm->Release();
    return TRUE;
}

BOOL CPicture::GetSize( LPSIZE lpSize, HDC hDC )
{
    int cxPerInch, cyPerInch;

    if ( lpSize == NULL || hDC == NULL )
    {
        return FALSE;
    }

    cxPerInch = ::GetDeviceCaps( hDC, LOGPIXELSX );
    cyPerInch = ::GetDeviceCaps( hDC, LOGPIXELSY );

    if ( cxPerInch == 0 || cyPerInch == 0 )
    {
        return FALSE;
    }

    lpSize->cx = ::MulDiv( m_nWidth, cxPerInch, HIMETRIC_INCH );
    lpSize->cy = ::MulDiv( m_nHeight, cyPerInch, HIMETRIC_INCH );

    return TRUE;
}


BOOL CPicture::Draw( HDC hDC, LPCRECT lprcDest, LPCRECT lprcSrc )
{
    POINT ptOri;
    SIZE szSize;
    int cxPerInch, cyPerInch;
    HRESULT hr;

    if ( hDC == NULL || lprcDest == NULL || m_pPic == NULL )
    {
        return FALSE;
    }

    if ( lprcSrc == NULL )
    {
        hr = m_pPic->Render( hDC, lprcDest->left, lprcDest->top, \
                             lprcDest->right - lprcDest->left, \
                             lprcDest->bottom - lprcDest->top, \
                             0, m_nHeight, m_nWidth, -m_nHeight, \
                             NULL );
    }
    else
    {
        cxPerInch = ::GetDeviceCaps( hDC, LOGPIXELSX );
        cyPerInch = ::GetDeviceCaps( hDC, LOGPIXELSY );

        if ( cxPerInch == 0 || cyPerInch == 0 )
        {
            return FALSE;
        }

        ptOri.x = ::MulDiv( lprcSrc->left, HIMETRIC_INCH, cxPerInch );
        ptOri.y = ::MulDiv( lprcSrc->top, HIMETRIC_INCH, cyPerInch );

        szSize.cx = ::MulDiv( lprcSrc->right - lprcSrc->left, HIMETRIC_INCH, cxPerInch );
        szSize.cy = ::MulDiv( lprcSrc->bottom - lprcSrc->top, HIMETRIC_INCH, cyPerInch );

        hr = m_pPic->Render( hDC, lprcDest->left, lprcDest->top, \
                             lprcDest->right - lprcDest->left, \
                             lprcDest->bottom - lprcDest->top, \
                             ptOri.x, m_nHeight - ptOri.y, szSize.cx, -szSize.cy, \
                             NULL );
    }

    return hr == S_OK ? TRUE : FALSE;
}