// PCDMPicture.cpp : Implementation of CPCDMPicture

#include "stdafx.h"
#include "PCDMUI.h"
#include "PCDMPicture.h"

/////////////////////////////////////////////////////////////////////////////
// CPCDMPicture


STDMETHODIMP CPCDMPicture::Load(BSTR Path, LONG ResourceID)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())

// <BOOK_ADDON STEP6 Chapter 10.1.4> ***********************************
	if (!m_hBitmap)	DeleteObject(m_hBitmap);
	if (!m_lpSrcDIB) free(m_lpSrcDIB);
	if (lstrlen(Path)==0)
		m_hBitmap=LoadBitmap(_Module.m_hInst,MAKEINTRESOURCE(ResourceID));
	else
	{
		switch (ResourceID)
		{
			case 0:	
#ifdef UNDER_CE
				m_hBitmap=SHLoadDIBitmap(Path);
#else
				m_lpSrcDIB=ReadBMPFile(Path,0);
#endif
			  break;
			case -1:
				m_hBitmap=LoadBitmap(_Module.m_hInst,Path);
			  break;
			default:
				m_lpSrcDIB=ReadBMPFile(Path,ResourceID);
			  break;
		}
	}
// </BOOK_ADDON STEP6 Chapter 10.1.4> ***********************************
	return S_OK;
}

LPBYTE CPCDMPicture::ReadBMPFile(LPCTSTR szFileName, DWORD Offset)
{
HANDLE            hFile;
BITMAPFILEHEADER  bfh;
DWORD            	dwBytes;
LPBYTE            lpDIB = NULL, lpTemp = NULL;
WORD              wPaletteSize = 0;
DWORD            	dwBitsSize = 0;

    // Open the file
    if( (hFile=CreateFile( szFileName, GENERIC_READ, 0, NULL,
						  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))
		== INVALID_HANDLE_VALUE )
        return NULL; 
    if( SetFilePointer( hFile, Offset, NULL, FILE_BEGIN ) == 0xffffffff )		
    {
        CloseHandle( hFile );
        return NULL;
    }
    // Read the header
    if((! ReadFile(hFile,&bfh,sizeof(BITMAPFILEHEADER),&dwBytes, NULL)) 
		|| ( dwBytes != sizeof( BITMAPFILEHEADER ) ) )
    {
        CloseHandle( hFile );
        return NULL;
    }
    // Does it look like a BMP file?
    if((bfh.bfType != 0x4d42) || (bfh.bfReserved1!=0) || (bfh.bfReserved2!=0) )
    {
        CloseHandle( hFile );
        return NULL;
    }
    // Allocate memory for DIB
    if( (lpDIB = (LPBYTE) malloc( sizeof( BITMAPINFO ))) == NULL )
    {
        CloseHandle( hFile );
        return NULL;
    }
    // Read in the BITMAPINFOHEADER
    if( (!ReadFile(hFile,lpDIB,sizeof(BITMAPINFOHEADER),&dwBytes,NULL))
		 || (dwBytes!=sizeof(BITMAPINFOHEADER)) )
    {
        CloseHandle( hFile );
        free( lpDIB );
        return NULL;
    }
    if( ((LPBITMAPINFOHEADER)lpDIB)->biSize != 
		sizeof( BITMAPINFOHEADER ) )
    {
        CloseHandle( hFile );
        free( lpDIB );
        return NULL;
    }
    wPaletteSize = PaletteSize((LPSTR)lpDIB);
    dwBitsSize = ((LPBITMAPINFOHEADER)lpDIB)->biHeight * 
				 BytesPerLine((LPBITMAPINFOHEADER)lpDIB);
    // realloc to account for the total size of the DIB
    if( (lpTemp = (LPBYTE)realloc(lpDIB, sizeof( BITMAPINFOHEADER ) + 
		wPaletteSize + dwBitsSize )) == NULL)
    {
        CloseHandle( hFile );
        free( lpDIB );
        return NULL;
    }
    lpDIB = lpTemp;
    // If there is a color table, read it
    if( wPaletteSize != 0 )
    {
        if( (!ReadFile( hFile, ((LPBITMAPINFO)lpDIB)->bmiColors,
			wPaletteSize, &dwBytes, NULL )) 
			|| (dwBytes!=wPaletteSize) )
        {
            CloseHandle( hFile );
            free( lpDIB );
            return NULL;
        }
    }
    if( bfh.bfOffBits != 0 )
    {
        if( SetFilePointer( hFile, bfh.bfOffBits+Offset, NULL, 
			FILE_BEGIN ) == 0xffffffff )
        {
            CloseHandle( hFile );
            free( lpDIB );
            return NULL;
        }
    }
    // Read the image bits
    if( (!ReadFile( hFile, FindDIBBits((LPSTR)lpDIB), dwBitsSize,
		 &dwBytes, NULL )) || (dwBytes!=dwBitsSize) )
    {
        CloseHandle( hFile );
        free( lpDIB );
        return NULL;
    }
    // clean up
    CloseHandle( hFile );
    return lpDIB;
}

LPSTR CPCDMPicture::FindDIBBits( LPSTR lpbi )
{
   return ( lpbi + *(LPDWORD)lpbi + PaletteSize( lpbi ) );
}

WORD CPCDMPicture::DIBNumColors( LPSTR lpbi )
{
    WORD wBitCount;
    DWORD dwClrUsed;

    dwClrUsed = ((LPBITMAPINFOHEADER) lpbi)->biClrUsed;

    if (dwClrUsed)
        return (WORD) dwClrUsed;

    wBitCount = ((LPBITMAPINFOHEADER) lpbi)->biBitCount;

    switch (wBitCount)
    {
        case 1: return 2;
        case 2: return 4;
		case 4: return 16;
        case 8:	return 256;
        default:return 0;
    }
    return 0;
}

WORD CPCDMPicture::PaletteSize( LPSTR lpbi )
{
    return ( DIBNumColors( lpbi ) * sizeof( RGBQUAD ) );
}

DWORD CPCDMPicture::BytesPerLine( LPBITMAPINFOHEADER lpBMIH )
{
    return WIDTHBYTES(lpBMIH->biWidth * lpBMIH->biPlanes 
    * lpBMIH->biBitCount);
}