windows-xp/Source/XPSP1/NT/multimedia/dshow/mfvideo/msmfcnt/cbitmap.cpp

/*************************************************************************/
/* Copyright (C) 1999 Microsoft Corporation                              */
/* File: CBitmap.cpp                                                     */
/* Description: Bitmap control which supports drawing bitmaps for        */
/*              buttons, images, etc.               phillu 11/16/99      */
/*************************************************************************/

#include "stdafx.h"
#include "CBitmap.h"

// automatically generated list of bmp names and corresponding rect's.
#include "bmplist.h"

// initialization of static variables
HBITMAP CBitmap::m_hMosaicBMP = NULL;
HBITMAP CBitmap::m_hMosaicBMPOld = NULL;
HPALETTE CBitmap::m_hMosaicPAL = NULL;
HPALETTE CBitmap::m_hMosaicPALOld = NULL;
HDC CBitmap::m_hMosaicDC = NULL;
bool CBitmap::m_fLoadMosaic = true;
long CBitmap::m_cBitsPerPixel = 0;
long CBitmap::m_cxScreen = 0;
long CBitmap::m_cyScreen = 0;

// seems we need a DIB section for palettte handeling, but the Millenium one acts up
#if 1
#define DIB_FLAG LR_CREATEDIBSECTION
#else
#define DIB_FLAG 0
#endif

//#define USE_LOADIMAGE LoadImage does not seem to work on palette base devices

#define DIB_HEADER_MARKER   ((WORD) ('M' << 8) | 'B')

/*************************************************************************/
/* Function: Init                                                        */
/*************************************************************************/
void CBitmap::Init(){

    m_hBitmap = NULL;
    m_hBitmapOld = NULL;
    m_hSrcDC = NULL;
    m_hPal = NULL;
    m_hPalOld = NULL;
    m_hMemDC = NULL;
    m_hMemBMP = NULL;
    m_hMemBMPOld = NULL;
    m_hMemPALOld = NULL;
    m_iMemDCWidth = 0;
    m_iMemDCHeight = 0;
    m_blitType = DISABLE;
    m_stretchType = NORMAL;
    m_fLoadPalette = false;
    ::SetRect(&m_rc, 0, 0, 0, 0);

    m_bUseMosaicBitmap = FALSE;
    m_hInstanceRes = NULL;
}/* end of function Init */

bool CBitmap::IsEmpty()
{
    return (m_rc.top == m_rc.bottom && m_rc.left == m_rc.right);
}

/*************************************************************************/
/* Function: CleanUp                                                     */
/* Description: Destroys the objects.                                    */
/*************************************************************************/
void CBitmap::CleanUp() {

    try {
        // cleanup the background image resources
        if (m_hBitmap){
        
            ::DeleteObject(m_hBitmap);
            m_hBitmap = NULL;
        }/* end of if statement */
    }
    catch(...){
         ATLASSERT(FALSE);
    }

    try {

        if (m_hSrcDC && !m_bUseMosaicBitmap){
        
            ::DeleteDC(m_hSrcDC);
            m_hSrcDC = NULL;
        }/* end of if statement */
    }
    catch(...){
         ATLASSERT(FALSE);
    }

    try {
        // cleanup the palette if applicable
        if (m_hPal){
    
            ::DeleteObject(m_hPal);
            m_hPal = NULL;
        }/* end of if statement */

    }
    catch(...){
        ATLASSERT(FALSE);
    }

    try {

        DeleteMemDC();
    }
    catch(...){
        ATLASSERT(FALSE);
    }

    bool fLoadPalette = m_fLoadPalette;
    Init();
    m_fLoadPalette = fLoadPalette;
}/* end of function Cleanup */


// this function is to clean up the mosaic bitmap
// after all objects are destroyed.

void CBitmap::FinalRelease()
{
    try {
        if (m_hMosaicBMP){
        
            ::DeleteObject(m_hMosaicBMP);
            m_hMosaicBMP = NULL;
        }/* end of if statement */
    }
    catch(...){
         ATLASSERT(FALSE);
    }

    try {
        if (m_hMosaicDC){
        
            ::DeleteDC(m_hMosaicDC);
            m_hMosaicDC = NULL;
        }
    }
    catch(...){
         ATLASSERT(FALSE);
    }

    try {
        if (m_hMosaicPAL){
        
            ::DeleteObject(m_hMosaicPAL);
            m_hMosaicPAL = NULL;
        }
    }
    catch(...){
         ATLASSERT(FALSE);
    }

    return;
}

/*************************************************************/
/* Name: CreateMemDC
/* Description: Create a Mem DC
/*************************************************************/
BOOL CBitmap::CreateMemDC(HDC hDC, LPRECT lpDCRect)
{
    LONG lWidth = RECTWIDTH(lpDCRect);
    LONG lHeight = RECTHEIGHT(lpDCRect);

    // clean up the old DC before we make a new one
    DeleteMemDC();

    m_hMemDC = ::CreateCompatibleDC(hDC);
    
    if(m_hMemDC == NULL)
    {
        return(FALSE);
    }
    
    m_iMemDCWidth  = lWidth;
    m_iMemDCHeight = lHeight;
    
    m_hMemBMP = ::CreateCompatibleBitmap(hDC, m_iMemDCWidth, m_iMemDCHeight);
    
    if(m_hMemBMP == NULL)
    {
        ::DeleteDC(m_hMemDC);
        return(FALSE);
    }
    
    m_hMemBMPOld = (HBITMAP)::SelectObject(m_hMemDC, m_hMemBMP);

    HPALETTE hPal = GetPal();
    SelectRelizePalette(m_hMemDC, hPal, &m_hMemPALOld);
    
    // stretch and blit the src DC onto the Mem DC

    return TRUE;
}

/*************************************************************/
/* Function: SelectRelizePalette                             */
/* Description: Selects and relizes palette into a dc.       */
/*************************************************************/
HRESULT CBitmap::SelectRelizePalette(HDC hdc, HPALETTE hPal, HPALETTE* hPalOld){

    if(NULL == hdc){

        return (E_INVALIDARG);
    }/* end of if statement */

    if(NULL == hPal){

        return (E_INVALIDARG);
    }/* end of if statement */

    if((::GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) == RC_PALETTE){

        HPALETTE hPalTmp = ::SelectPalette(hdc, hPal, FALSE);
        if (hPalOld) {
            *hPalOld = hPalTmp;
        }

        ::RealizePalette(hdc);    
    }/* end of if statement */

    return S_OK;
}/* end of function SelectRelizePalette */

/*************************************************************/
/* Name: DeleteMosaicDC
/* Description: 
/*************************************************************/
void CBitmap::DeleteMosaicDC(){
    try {
        
        if (m_hMosaicDC){
            if (m_hMosaicBMPOld)
                ::SelectObject(m_hMosaicDC, m_hMosaicBMPOld);

            if (m_hMosaicPALOld)
                ::SelectPalette(m_hMosaicDC, m_hMosaicPALOld, FALSE);
        }/* end of if statement */
        
        if (m_hMosaicBMP){
            
            ::DeleteObject(m_hMosaicBMP);
            m_hMosaicBMP = NULL;
        }/* end of if statement */

        if (m_hMosaicDC){

            ::DeleteDC(m_hMosaicDC);
            m_hMosaicDC = NULL;
        }/* end of if statement */
    }

    catch(...){
         ATLASSERT(FALSE);
    }
}

/*************************************************************/
/* Name: OnDispChange
/* Description: 
/*************************************************************/
void CBitmap::OnDispChange(long cBitsPerPixel, long cxScreen, long cyScreen){
    try {
        
        if (cBitsPerPixel != m_cBitsPerPixel ||
            cxScreen != m_cxScreen ||
            cyScreen != m_cyScreen ) {

            m_cBitsPerPixel = cBitsPerPixel;
            m_cxScreen = cxScreen;
            m_cyScreen = cyScreen;

            DeleteMosaicDC();
        }

        if (m_bUseMosaicBitmap){
            
            m_hSrcDC = NULL;
        }
        
        else {
            if (m_hSrcDC) { 
                if (NULL != m_hBitmapOld) 
                    ::SelectObject(m_hSrcDC, m_hBitmapOld);
                
                if (NULL != m_hPalOld) 
                    ::SelectPalette(m_hSrcDC, m_hPalOld, FALSE);                
            }/* end of if statement */
            
            if (m_hBitmap) {
                ::DeleteObject(m_hBitmap);
                m_hBitmap = NULL;
            }/* end of if statement */

            if (m_hSrcDC) { 

                ::DeleteDC(m_hSrcDC);
                m_hSrcDC = NULL;
                
            }/* end of if statement */
        } /* end of if statement */

        DeleteMemDC();
    }
    
    catch(...){
        ATLASSERT(FALSE);
    }
}
    
/*************************************************************/
/* Name: DeleteMemDC
/* Description: 
/*************************************************************/
BOOL CBitmap::DeleteMemDC(){
    if (m_hMemDC) {

        if (m_hMemBMPOld) 
            ::SelectObject(m_hMemDC, m_hMemBMPOld);        

        if (m_hMemPALOld) 
            ::SelectPalette(m_hMemDC, m_hMemPALOld, FALSE);
    } /* end of if statement */

    if (m_hMemBMP) {
        ::DeleteObject(m_hMemBMP);
        m_hMemBMP = NULL;
    } /* end of if statement */
    
    if (m_hMemDC) {

        ::DeleteDC(m_hMemDC);
        m_hMemDC = NULL;
    } /* end of if statement */

    m_iMemDCWidth  = 0;
    m_iMemDCHeight = 0;

    return TRUE;
}/* end of function DeleteMemDC */


/*************************************************************************

This is a special stretching method for stretching the backgound bitmap
of container. The goal is to enlarge the bitmap without stretching, so as
to maintain the border width of the container. This is accomplished
by replicating portions of the bitmap on the 4 sides.

************************************************************************/

BOOL CBitmap::CustomContainerStretch(HDC hDC, RECT* lpRect)
{
    LONG lSectionWidth = (min(RECTWIDTH(lpRect), RECTWIDTH(&m_rc)) + 1)/2;
    LONG lSectionHeight = (min(RECTHEIGHT(lpRect), RECTHEIGHT(&m_rc)) + 1)/2;

    // copy upper left quadrant
    ::BitBlt(hDC,
        lpRect->left,
        lpRect->top,
        lSectionWidth,
        lSectionHeight,
        m_hSrcDC,
        m_rc.left,
        m_rc.top,
        SRCCOPY);

    // copy upper right quadrant
    ::BitBlt(hDC,
        lpRect->right - lSectionWidth,
        lpRect->top,
        lSectionWidth,
        lSectionHeight,
        m_hSrcDC,
        m_rc.right - lSectionWidth,
        m_rc.top,
        SRCCOPY);

    // copy lower left quadrant
    ::BitBlt(hDC,
        lpRect->left,
        lpRect->bottom - lSectionHeight,
        lSectionWidth,
        lSectionHeight,
        m_hSrcDC,
        m_rc.left,
        m_rc.bottom - lSectionHeight,
        SRCCOPY);

    // copy lower right quadrant
    ::BitBlt(hDC,
        lpRect->right - lSectionWidth,
        lpRect->bottom - lSectionHeight,
        lSectionWidth,
        lSectionHeight,
        m_hSrcDC,
        m_rc.right - lSectionWidth,
        m_rc.bottom - lSectionHeight,
        SRCCOPY);

    // fill in the middle section

    LONG lGapWidth = RECTWIDTH(lpRect) - 2*lSectionWidth;
    LONG lGapHeight = RECTHEIGHT(lpRect) - 2*lSectionHeight;
    LONG lHorizFillStart = lpRect->left + lSectionWidth;
    LONG lVertFillStart = lpRect->top + lSectionHeight;

    // define a chunk of bitmap that can be used to fill the gap
    const LONG lSrcXOffset = 60;
    const LONG lSrcYOffset = 60;
    const LONG lMaxHorizontalFill = RECTWIDTH(&m_rc) - 2*lSrcXOffset;
    const LONG lMaxVerticalFill = RECTHEIGHT(&m_rc) - 3*lSrcYOffset; // twice room at bottom
    
    while (lGapWidth > 0)
    {
        // upper middle section

        LONG lFillWidth = min(lGapWidth, lMaxHorizontalFill);

        ::BitBlt(hDC,
            lHorizFillStart,
            lpRect->top,
            lFillWidth,
            lSectionHeight,
            m_hSrcDC,
            m_rc.left + lSrcXOffset,
            m_rc.top,
            SRCCOPY);

        // bottom middle section

        ::BitBlt(hDC,
            lHorizFillStart,
            lpRect->bottom - lSectionHeight,
            lFillWidth,
            lSectionHeight,
            m_hSrcDC,
            m_rc.left + lSrcXOffset,
            m_rc.bottom - lSectionHeight,
            SRCCOPY);

        lGapWidth -= lFillWidth;
        lHorizFillStart += lFillWidth;
    }

    while (lGapHeight > 0)
    {
        // left middle section

        LONG lFillHeight = min(lGapHeight, lMaxVerticalFill);

        ::BitBlt(hDC,
            lpRect->left,
            lVertFillStart,
            lSectionWidth,
            lFillHeight,
            m_hSrcDC,
            m_rc.left,
            m_rc.top + lSrcYOffset,
            SRCCOPY);

        // right middle section

        ::BitBlt(hDC,
            lpRect->right - lSectionWidth,
            lVertFillStart,
            lSectionWidth,
            lFillHeight,
            m_hSrcDC,
            m_rc.right - lSectionWidth,
            m_rc.top + lSrcYOffset,
            SRCCOPY);

        lGapHeight -= lFillHeight;
        lVertFillStart += lFillHeight;
    }

    return TRUE;
}/* end of function SpecialStretch */

/*************************************************************************

This stretching methods maintains the aspect ratio of the original bitmap.
The unoccupied portion of the dest DC will be filled with BackColor.

**************************************************************************/

BOOL CBitmap::StretchKeepAspectRatio(HDC hDC, LPRECT lpRect)
{
    BOOL bSuccess = TRUE;
    LONG lWidth = RECTWIDTH(lpRect);
    LONG lHeight = RECTHEIGHT(lpRect);
    LONG lWidthSrc = RECTWIDTH(&m_rc);
    LONG lHeightSrc = RECTHEIGHT(&m_rc);

    HBRUSH hbrBack = (HBRUSH)::GetStockObject(BLACK_BRUSH);            

    if(NULL == hbrBack){

        return(FALSE);
    }/* end of if statement */

    ::FillRect(hDC, lpRect, hbrBack);
    ::DeleteObject(hbrBack);

    if (lWidth*lHeightSrc < lHeight*lWidthSrc)
    {
        LONG lStretchHeight = (LONG)((float)lHeightSrc*lWidth/lWidthSrc + 0.5f);
        LONG lGapHeight = (lHeight - lStretchHeight)/2;

        bSuccess = ::StretchBlt(hDC,
            lpRect->left,                 // DestX
            lpRect->top + lGapHeight,     // DestY
            lWidth,                       // nDestWidth
            lStretchHeight,               // nDestHeight
            m_hSrcDC,
            m_rc.left,                      // SrcX
            m_rc.top,                       // SrcY
            lWidthSrc,                      // nSrcWidth
            lHeightSrc,                     // nSrcHeight
            SRCCOPY                         
            );
    }
    else
    {
        LONG lStretchWidth = (LONG)((float)lWidthSrc*lHeight/lHeightSrc + 0.5f);
        LONG lGapWidth = (lWidth - lStretchWidth)/2;

        bSuccess = ::StretchBlt(hDC,
            lpRect->left + lGapWidth,     // DestX
            lpRect->top,                  // DestY
            lStretchWidth,                // nDestWidth
            lHeight,                      // nDestHeight
            m_hSrcDC,
            m_rc.left,                      // SrcX
            m_rc.top,                       // SrcY
            lWidthSrc,                      // nSrcWidth
            lHeightSrc,                     // nSrcHeight
            SRCCOPY                         
            );
    }

    return bSuccess;
}

/*************************************************************************
    This is the entry point to stretch paint the bitmap

    m_stretchType indicates the type of stretching method to use:

        NORMAL = 0   :           normal stretching
        CUSTOM_CONTAINER = 1   : special stretching method for container
        MAINTAIN_ASPECT_RATIO =2 : stretching while maintaing aspect ratio

**************************************************************************/

BOOL CBitmap::StretchPaint(HDC hDC, LPRECT lpRect, COLORREF clrTrans)
{
    BOOL bSuccess = TRUE;

    LONG lWidth = RECTWIDTH(lpRect);
    LONG lHeight = RECTHEIGHT(lpRect);
    LONG lWidthSrc = RECTWIDTH(&m_rc);
    LONG lHeightSrc = RECTHEIGHT(&m_rc);

    // special case, src and dest rects are the same, just copy it
    if (lWidth == lWidthSrc && lHeight == lHeightSrc)
    {
        bSuccess = ::BitBlt(hDC,
            lpRect->left,             // DestX
            lpRect->top,              // DestY
            lWidth,                   // nDestWidth
            lHeight,                  // nDestHeight
            m_hSrcDC,
            m_rc.left,                      // SrcX
            m_rc.top,                       // SrcY
            SRCCOPY                         
            );
    }
    else if (m_stretchType == CUSTOM_CONTAINER)
    {
        bSuccess = CustomContainerStretch(hDC, lpRect);
    }
    else if (m_stretchType == MAINTAIN_ASPECT_RATIO)
    {
        bSuccess = StretchKeepAspectRatio(hDC, lpRect);
    }
    else // normal stretch
    {
#if 1
        // to ensure the transparent color is maintained, we first
        // fill the DC with the transparent color, and then do a
        // TransparentBlit. The resulting bitmap can be used for
        // transparent blting again.

        HBRUSH hbrTrans = ::CreateSolidBrush(clrTrans);

        if(NULL == hbrTrans){

            bSuccess = FALSE;
            return(bSuccess);
        }/* end of if statement */

        ::FillRect(hDC, lpRect, hbrTrans);
        ::DeleteObject(hbrTrans);
#endif
        bSuccess = ::TransparentBlt(hDC,
            lpRect->left,                 // DestX
            lpRect->top,                  // DestY
            lWidth,                       // nDestWidth
            lHeight,                      // nDestHeight
            m_hSrcDC,
            m_rc.left,                      // SrcX
            m_rc.top,                       // SrcY
            lWidthSrc,                      // nSrcWidth
            lHeightSrc,                     // nSrcHeight
            clrTrans
            );
    }

    return bSuccess;
}

/*******************************************************************
   Create the Src DC if it has not been done so before.

   If the current object uses the mosaic, the src DC is just a copy
   of the mosaic DC.
********************************************************************/
BOOL CBitmap::CreateSrcDC(HDC hDC)
{
    // Src DC is already created from a previous call

    if (m_hSrcDC != NULL)
    {
        return TRUE;
    }

    if (m_bUseMosaicBitmap)
    {
        if (m_hMosaicDC == NULL)
        {
            if (m_hMosaicBMP == NULL)
            {

                HRESULT hr = InitilizeMosaic(m_hInstanceRes);
                if (FAILED(hr) || m_hMosaicBMP == NULL)                
                    return FALSE;
            }

            m_hMosaicDC = ::CreateCompatibleDC(hDC);

            if(NULL == m_hMosaicDC){

                return(FALSE);
            }/* end of if statement */

            m_hMosaicBMPOld = (HBITMAP)::SelectObject(m_hMosaicDC, m_hMosaicBMP);

            HPALETTE hPal = GetPal();

            SelectRelizePalette(m_hMosaicDC, hPal, &m_hMosaicPALOld);
        }

        m_hSrcDC = m_hMosaicDC;
    }
    else
    {
        if (m_hBitmap == NULL){
            HRESULT hr = LoadImageFromRes(m_strFileName, m_hInstanceRes);
            if (FAILED(hr) || m_hBitmap == NULL)
                return FALSE;
        }/* end of if statement */

        m_hSrcDC = ::CreateCompatibleDC(hDC);

        if(NULL == m_hSrcDC){

            return FALSE;
        }/* end of if statement */

        m_hBitmapOld = (HBITMAP)::SelectObject(m_hSrcDC, m_hBitmap);

        HPALETTE hPal = GetPal();
        SelectRelizePalette(m_hSrcDC, hPal, &m_hPalOld);
    }

    if (m_hSrcDC == NULL)
    {
        return FALSE;
    }

    return TRUE;
}

/*************************************************************************
  GetTransparentColor()
**************************************************************************/
COLORREF CBitmap::GetTransparentColor()
{
    // retrieve transparent color according to type, default is magenta
    COLORREF clrTrans = RGB(255, 0, 255);
   
    if(TRANSPARENT_TOP_LEFT == m_blitType ||
        TOP_LEFT_WITH_BACKCOLOR == m_blitType ||
        TOP_LEFT_WINDOW_REGION == m_blitType )
    {
        clrTrans = ::GetPixel(m_hSrcDC, m_rc.left, m_rc.top);
    }
    else if(TRANSPARENT_BOTTOM_RIGHT  == m_blitType ||
        BOTTOM_RIGHT_WITH_BACKCOLOR == m_blitType ||
        BOTTOM_RIGHT_WINDOW_REGION == m_blitType )
    {
        clrTrans = ::GetPixel(m_hSrcDC, m_rc.right-1, m_rc.bottom-1);
    }
#if 0
    // in case we are pallete capable device find the color in our palette
    HPALETTE hPal = GetPal();

    if(hPal){
        HWND hwnd = ::GetDesktopWindow();
        HDC hdc = ::GetWindowDC(hwnd);

        if((::GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) == RC_PALETTE){
            
            UINT clrTmp = GetNearestPaletteIndex(hPal, clrTrans);

            if(CLR_INVALID != clrTmp){

                clrTrans = PALETTEINDEX(clrTmp);
            }/* end of if statement */
        }/* end of if statement */

        ::ReleaseDC(hwnd, hdc);
    }/* end of if statement */
#endif
    return clrTrans;
}


/*************************************************************************

  PaintTransparentDIB is the main function call to draw the bitmap control.

  Before PaintTransparentDIB is called, the bitmap should have been loaded by
  PutImage(). Also the blitType and stretchType should have been set during 
  the PutImage call.

  Input parameters:

  hDC is the DC to paint the bitmap to

  lpDCWRect is the rect of the entire control window. We should privide that
     for buttons as well as container.

  lpDCRect is the current rect to paint to. For container, it could be a sub
     region of the lpDCWRect. For buttons, it is probably the same as
     the lpDCWRect. (However this function does not rely on this assumption.)

  Important data structures:

  m_hSrcDC is the DC that contains the original bitmap (unstretched).
  If the current object uses the mosaic bitmap, m_hSrcDC is just a copy
  of the m_hMosaicDC while m_rc keeps the location of the bitmap within
  the mosaic.

  m_hMemDC caches a copy of the bitmap that is stretched to the window size.
  This is used for quickly refreshing display if only portion of the screen 
  needs to be painted.

 ************************************************************************/

BOOL CBitmap::PaintTransparentDIB(HDC hDC,
                                 LPRECT lpDCWRect,
                                 LPRECT lpDCRect)
{
    BOOL bSuccess = TRUE;

    // create the src DC if we are first time here.
    // But we should already have the bitmap in memory

    if (!CreateSrcDC(hDC))
    {
        return FALSE;
    }

    // Color in the bitmap that indicates transparent pixel
    COLORREF clrTrans = GetTransparentColor();

    // check if we already have the stretched bitmap cached in mem DC
    // if not, create the MemDC and paint the stretched bitmap in it

    LONG lWidth = RECTWIDTH(lpDCWRect);
    LONG lHeight = RECTHEIGHT(lpDCWRect);
    RECT rc = {0, 0, lWidth, lHeight};

    if (!m_hMemDC || lWidth != m_iMemDCWidth || lHeight != m_iMemDCHeight)
    {
        if (!CreateMemDC(hDC, &rc))
        {
            return FALSE;
        }

        if (!StretchPaint(m_hMemDC, &rc, clrTrans))
        {
            return FALSE;
        }
    }

    // blit MemDC to screen DC with transparency.
    // Only the required DC Rect is painted (it could be a subregion of DCWRect)

    LONG lPaintWidth = RECTWIDTH(lpDCRect);
    LONG lPaintHeight = RECTHEIGHT(lpDCRect);

    if (m_blitType != DISABLE)
    {
        bSuccess = ::TransparentBlt(hDC, 
            lpDCRect->left,             // DestX
            lpDCRect->top,              // DestY
            lPaintWidth,                // nDestWidth
            lPaintHeight,               // nDestHeight
            m_hMemDC,
            lpDCRect->left - lpDCWRect->left, // SrcX
            lpDCRect->top - lpDCWRect->top,   // SrcY
            lPaintWidth,                   // nSrcWidth
            lPaintHeight,                  // nSrcHeight
            clrTrans                       // transparent color
        );
    }
    else  // disabled, no transparency
    {
        bSuccess = ::BitBlt(hDC,
            lpDCRect->left,             // DestX
            lpDCRect->top,              // DestY
            lPaintWidth,                // nDestWidth
            lPaintHeight,               // nDestHeight
            m_hMemDC,
            lpDCRect->left - lpDCWRect->left, // SrcX
            lpDCRect->top - lpDCWRect->top,   // SrcY
            SRCCOPY
        );
    }

    return bSuccess;
}


/*************************************************************************

  PutImage()

    If bFromMosaic is FALSE, it loads a bitmap from either a disk BMP file
    or from a BITMAP resource (depending on if hRes is NULL or not).

    If bFromMosaic is TRUE, it records a rect region of a mosaic bitmap as
    the bitmap for the current object. The mosaic bitmap itself can be loaded
    from a disk BMP file or from a BITMAP resource (depending on if hRes is
    NULL or not). But this mosaic bitmap is loaded only once for all the 
    objects that are sharing the mosaic. Loading from file or resource must
    be consistent among all those objects.

    The resource tag name or file name of the mosaic bitmap is currently
    hard coded (as IDR_MOSAIC_BMP or mosaicbm.bmp).

    This call also record the blit type and stretch type which indicate how 
    the bitmap is to be painted.

    blitType: 		
        DISABLE = 0   :                  Disabled, no transparency
		TRANSPARENT_TOP_LEFT = 1:        use clr of top left pix as transparent color
		TRANSPARENT_BOTTOM_RIGHT = 2:    use clr of bottom right as transparent color
		TOP_LEFT_WINDOW_REGION = 3:      currently treated as the same as 1 
		BOTTOM_RIGHT_WINDOW_REGION = 4:  currently treated as the same as 2
		TOP_LEFT_WITH_BACKCOLOR = 5:     currently treated as the same as 1
		BOTTOM_RIGHT_WITH_BACKCOLOR = 6: currently treated as the same as 2

    stretchType:
        NORMAL = 0   :           normal stretching
        CUSTOM_CONTAINER = 1   : special stretching method for container
        MAINTAIN_ASPECT_RATIO :  stretching while maintaing aspect ratio


*************************************************************************/
HRESULT CBitmap::PutImage(BSTR strFilename, HINSTANCE hRes, 
                          BOOL bFromMosaic, // the bitmap is in Mosaic bitmap
                          TransparentBlitType blitType,
                          StretchType stretchType
                          )
{
	USES_CONVERSION;
    HRESULT hr = S_OK;

    CleanUp();

    // save the blit and stretch types

    m_blitType = blitType;
    m_stretchType = stretchType;
    m_bUseMosaicBitmap = bFromMosaic;
    m_strFileName = strFilename;
    m_hInstanceRes = hRes;

    // initialize the mosaic file
    HRESULT hrTmp = InitilizeMosaic(hRes);

    if(FAILED(hrTmp)){

        // try to load up the file as a normal file or resource since mosaic load failed
        m_bUseMosaicBitmap = FALSE;
    }/* end of if statement */

    if (!LookupBitmapRect(OLE2T(strFilename), &m_rc))
    {
        // load individual bitmap from resource or file

        m_bUseMosaicBitmap = FALSE;
    }

    if (!m_bUseMosaicBitmap) {
        hr = LoadImageFromRes(m_strFileName, m_hInstanceRes);
    }

    return hr;
}/* end of function PutImage */

/*************************************************************/
/* Name: LoadImageFromRes
/* Description: 
/*************************************************************/
HRESULT CBitmap::LoadImageFromRes(BSTR strFileName, HINSTANCE hRes) {
    
	USES_CONVERSION;
    HRESULT hr = S_OK;
    BITMAP bm;

    TCHAR* strTmpFileName = TEXT("");
    strTmpFileName = OLE2T(strFileName);

    m_hBitmap = (HBITMAP)LoadImage(hRes, strTmpFileName, IMAGE_BITMAP, 0, 0,
        DIB_FLAG | LR_DEFAULTSIZE | (hRes?0:LR_LOADFROMFILE));
    
    if(NULL == m_hBitmap)
    {
        hr = HRESULT_FROM_WIN32(::GetLastError());
        return hr;
    }
    
    ::GetObject(m_hBitmap, sizeof(BITMAP), (LPVOID) &bm);
    ::SetRect(&m_rc, 0, 0, bm.bmWidth, bm.bmHeight);

    return hr;
}/* end of function LoadImageFromRes */

/************************************************************************/
/* Function: InitilizeMosaic                                            */
/* Description: Trys to load up the mosaic bitmap, which contains a     */
/* collection of bitmaps.                                               */
/************************************************************************/
HRESULT CBitmap::InitilizeMosaic(HINSTANCE hRes){

    HRESULT hr = S_OK;

    TCHAR* strTmpFileName = TEXT("");

    // use a rectangular region of Mosaic bitmap
    // make sure the mosaic only loads once for all the objects    
    
    if (m_hMosaicBMP == NULL){

        if(!m_fLoadMosaic){

            hr = E_FAIL; // we already failed before to load the mosaic file do not
                         //try it again
            return(hr);
        }/* end of if statement */

        if (hRes)
        {
            // load mosaic bitmap
            strTmpFileName = TEXT("IDR_MOSAIC_BMP");

            hr = LoadPalette(strTmpFileName, hRes, &m_hMosaicPAL);

            if(FAILED(hr)){
                
                m_fLoadMosaic = false; 
                return(hr);
            }/* end of if statement */

            m_hMosaicBMP = (HBITMAP)LoadImage(hRes, strTmpFileName, IMAGE_BITMAP, 0, 0, 
                                                DIB_FLAG| LR_DEFAULTSIZE);
        }
        else
        {
            strTmpFileName = TEXT("mosaicbm.bmp");

            hr = LoadPalette(strTmpFileName, hRes, &m_hMosaicPAL);

            if(FAILED(hr)){
                
                m_fLoadMosaic = false; 
                return(hr);
            }/* end of if statement */

            m_hMosaicBMP = (HBITMAP)LoadImage(hRes, strTmpFileName, IMAGE_BITMAP, 0, 0, 
                                                DIB_FLAG| LR_LOADFROMFILE);
        }

        if(NULL == m_hMosaicBMP)
        {
            hr = HRESULT_FROM_WIN32(::GetLastError());
            m_fLoadMosaic = false; // do not attempt to reload the mosaic file
            return hr;
        }
    }/* end of if statement */

    return(hr);
}/* function InitilizeMosaic */



/************************************************************************/
/* Function: LoadPalette                                                */
/* Description: Loads a palette from a bitmap.                          */
/************************************************************************/
HRESULT CBitmap::LoadPalette(TCHAR* strFilename, HINSTANCE hRes){

    return(LoadPalette(strFilename, hRes, &m_hPal));
}/* end of function LoadPalette */

/************************************************************************/
/* Function: LoadPalette                                                */
/* Description: Loads a palette from a bitmap.                          */
/************************************************************************/
HRESULT CBitmap::LoadPalette(TCHAR* strFilename, HINSTANCE hInst, HPALETTE *phPal){
     
     HRESULT hr = S_OK;

     if(NULL == phPal){

         hr = E_POINTER;
         return(hr);
     }/* end of if statement */

     if (*phPal){
    
        ::DeleteObject(*phPal);
        *phPal = NULL;
     }/* end of if statement */

#ifdef USE_LOADIMAGE

     BITMAP  bm;

     // Use LoadImage() to get the image loaded into a DIBSection
     HBITMAP hBitmap = (HBITMAP) ::LoadImage( hInst,  strFilename, IMAGE_BITMAP, 0, 0,
                 LR_CREATEDIBSECTION| LR_DEFAULTSIZE | (hInst?LR_DEFAULTCOLOR:LR_LOADFROMFILE) );

     if( hBitmap == NULL ){

          hr = HRESULT_FROM_WIN32(::GetLastError());
          return hr;
     }/* end of if statement */

     // Get the color depth of the DIBSection
     ::GetObject(hBitmap, sizeof(BITMAP), &bm );
     // If the DIBSection is 256 color or less, it has a color table
     if( ( bm.bmBitsPixel * bm.bmPlanes ) <= 8 ){

       HDC           hMemDC;
       HBITMAP       hOldBitmap;
       RGBQUAD       rgb[256];
       LPLOGPALETTE  pLogPal;
       WORD          i;

       // Create a memory DC and select the DIBSection into it
       hMemDC = ::CreateCompatibleDC( NULL );
       hOldBitmap = (HBITMAP)::SelectObject( hMemDC, hBitmap );
       // Get the DIBSection's color table
       UINT ulNumEntries =::GetDIBColorTable( hMemDC, 0, 256, rgb );
       // Create a palette from the color table
       LPLOGPALETTE  pLogPal = (LPLOGPALETTE) new BYTE[( sizeof(LOGPALETTE) + (ncolors*sizeof(PALETTEENTRY)))];
       //pLogPal = (LPLOGPALETTE) malloc( sizeof(LOGPALETTE) + (ulNumEntries*sizeof(PALETTEENTRY)) );

       if(NULL == pLogPal){

           return(E_OUTOFMEMORY);
       }/* end of if statement */

       pLogPal->palVersion = 0x300;
       pLogPal->palNumEntries = (WORD) ulNumEntries;
       for(i=0;i<ulNumEntries;i++){

         pLogPal->palPalEntry[i].peRed = rgb[i].rgbRed;
         pLogPal->palPalEntry[i].peGreen = rgb[i].rgbGreen;
         pLogPal->palPalEntry[i].peBlue = rgb[i].rgbBlue;
         pLogPal->palPalEntry[i].peFlags = 0; /* PC_RESERVED */ /* 0 */
       }/* end of for loop */

       *phPal = ::CreatePalette( pLogPal );

       if( *phPal == NULL ){

          hr = HRESULT_FROM_WIN32(::GetLastError());          
       }/* end of if statement */

       // Clean up
       delete[] pLogPal;
       ::SelectObject( hMemDC, hOldBitmap );
       ::DeleteObject(hBitmap);
       ::DeleteDC( hMemDC );
     }
     else   // It has no color table, so use a halftone palette
     {
        hr = S_FALSE;
     }/* end of if statement */
#else
    // use our internal load image so we do not duplicate the code
     LoadImage(hInst, strFilename, IMAGE_BITMAP, 0, 0, (hInst?LR_DEFAULTCOLOR:LR_LOADFROMFILE), phPal);

     if(NULL == *phPal){
         
         hr = E_FAIL;
     }/* end of if statement */       
                              
#endif
     return(hr);
}/* end of function LoadPalette */

/************************************************************************

    Lookup the rectangle coordinates of a bitmap which is subregion of 
    the mosaic. The list of coordinates and associated names are compiled
    at the same time as the mosaic bitmap.

*************************************************************************/

BOOL CBitmap::LookupBitmapRect(LPTSTR szName, LPRECT rect)
{
	USES_CONVERSION;
    char *strIDR = T2A(szName);

    BmpRectRef *p = gBmpRectList;
    while (p->strIDR)
    {
        if (strcmp(p->strIDR, strIDR) == 0)
        {
            *rect = p->rect;
            return TRUE;
        }

        p++;
    }

    return FALSE;
}

/*************************************************************************/
/* Function: LoadImage                                                   */
/* Description: Either uses our load image or the OS LoadImage           */
/*************************************************************************/
HANDLE CBitmap::LoadImage(HINSTANCE hInst, LPCTSTR lpszName, UINT uType,
                          int cxDesired, int cyDesired, UINT fuLoad,
                          HPALETTE *phPal){

    HANDLE hBitmap = NULL;
    HGLOBAL hBmpFile = NULL;
    HANDLE  hFile = NULL;
    BYTE* lpCurrent = NULL;
    BYTE* lpDelete = NULL;
        
    try {
    #ifdef USE_LOADIMAGE
        hBitmap = ::LoadImage(hInst, lpszName, uType, cxDesired, cyDesired,
                                                fuLoad);                                             
    #else
        bool fPaletteOnly = false;

        if(NULL != phPal){

            fPaletteOnly = true;
            *phPal = NULL;
        }/* end of if statement */

        UINT ncolors = 0;
        DWORD dwBitsSize = 0;
        DWORD dwOffset = 0;
        
        if(fuLoad & LR_LOADFROMFILE){

            hFile =  ::CreateFile(
	        lpszName,    // pointer to name of the file
	        GENERIC_READ,   // access (read-write) mode
	        FILE_SHARE_READ,    // share mode
	        NULL,   // pointer to security descriptor
	        OPEN_EXISTING,  // how to create
	        FILE_ATTRIBUTE_NORMAL,  // file attributes
	        NULL    // handle to file with attributes to copy
            );

            if(hFile == INVALID_HANDLE_VALUE){
                #if _DEBUG
                if(!fPaletteOnly){
    
                    TCHAR strBuffer[MAX_PATH + 25];
                    wsprintf(strBuffer, TEXT("Failed to download %s"), lpszName);
                    ::MessageBox(::GetFocus(), strBuffer, TEXT("Error"), MB_OK);
                }/* end of if statement */
                #endif
                throw (NULL);
            }/* end of if statement */

            dwBitsSize = GetFileSize(hFile,NULL);

            if(0 >= dwBitsSize){

                ATLASSERT(FALSE);
                throw (NULL);
            }/* end of if statement */

            BITMAPFILEHEADER bmfHeader;
            DWORD nBytesRead;

            if(! ReadFile(hFile, (LPSTR)&bmfHeader, sizeof(bmfHeader), &nBytesRead, NULL)){

                ATLASSERT(FALSE);
                throw (NULL);
            }/* end of if statement */

            if(sizeof(bmfHeader) != nBytesRead){

                ATLASSERT(FALSE);
                throw (NULL);
            }/* end of if statement */
    
            if (bmfHeader.bfType != DIB_HEADER_MARKER){

                ATLASSERT(FALSE);
                throw (NULL);
            }/* end of if statement */

            dwBitsSize -= sizeof(BITMAPFILEHEADER);

            lpCurrent = lpDelete = new BYTE[dwBitsSize];
            
            if(NULL == lpDelete){

                ATLASSERT(FALSE);
                throw(NULL);
            }/* end of if stament */
          
            if(!ReadFile(hFile, (LPSTR)lpCurrent, dwBitsSize, &nBytesRead, NULL)){
                
                ATLASSERT(FALSE);
                throw (NULL);
            }/* end of if statement */

            if(nBytesRead != dwBitsSize){

                ATLASSERT(FALSE);
                throw (NULL);
            }/* end of if statement */

            ::CloseHandle(hFile);
            hFile = NULL;
        }        
        else {
            // loading from resources
    
            // Find the Bitmap
            HRSRC hRes = ::FindResource(hInst, lpszName, RT_BITMAP);
            if (!hRes){

                ATLASSERT(FALSE);
                throw (NULL);
            }/* end of if statement */

            // Load the BMP from the resource file.
            hBmpFile = ::LoadResource(hInst, hRes);
            if ((!hBmpFile)){
            
                ATLASSERT(FALSE);
                throw (NULL);
            }/* end of if statement */
        
            dwBitsSize = ::SizeofResource(hInst, hRes);

            // copy out the appropriate info from the bitmap
            lpCurrent = (BYTE *)::LockResource(hBmpFile);
        }/* end of if statement */

                                
        // The BITMAPFILEHEADER is striped for us, so we just start with a BITMAPINFOHEADER
        BITMAPINFOHEADER* lpbmih = (BITMAPINFOHEADER *)lpCurrent;
        lpCurrent += sizeof(BITMAPINFOHEADER);
        dwOffset = sizeof(BITMAPINFOHEADER);

        // Compute some usefull information from the bitmap
        if (lpbmih->biPlanes != 1){

            ATLASSERT(FALSE);
            throw (NULL);
        }/* end of if statement */

        if (    lpbmih->biBitCount != 1
            &&  lpbmih->biBitCount != 4
            &&  lpbmih->biBitCount != 8
            &&  lpbmih->biBitCount != 16
            &&  lpbmih->biBitCount != 24
            &&  lpbmih->biBitCount != 32){

            ATLASSERT(FALSE);
            throw (NULL);
        }/* end of if statement */
    
        if (lpbmih->biBitCount <= 8){

            ncolors = 1 << lpbmih->biBitCount;

            if (lpbmih->biClrUsed > 0 && lpbmih->biClrUsed < ncolors){

                ncolors = lpbmih->biClrUsed;
            }/* end of if statement */
        }/* end of if statemet */

        RGBQUAD* lprgb = NULL;
        //HPALETTE m_hPal = NULL;

        if (ncolors){

            bool fLoadPalette = m_fLoadPalette || fPaletteOnly;

            if(fLoadPalette){
            
               WORD          i;       
               LPLOGPALETTE  pLogPal = (LPLOGPALETTE) new BYTE[( sizeof(LOGPALETTE) + (ncolors*sizeof(PALETTEENTRY)))];

               if(NULL == pLogPal){

                   ATLASSERT(FALSE);
                   throw (NULL);
               }/* end of if statement */

               pLogPal->palVersion = 0x300;
               pLogPal->palNumEntries = (WORD) ncolors;

               lprgb = (RGBQUAD *)lpCurrent;

               for(i=0;i<ncolors;i++){

                 pLogPal->palPalEntry[i].peRed = lprgb[i].rgbRed;
                 pLogPal->palPalEntry[i].peGreen = lprgb[i].rgbGreen;
                 pLogPal->palPalEntry[i].peBlue = lprgb[i].rgbBlue;
                 pLogPal->palPalEntry[i].peFlags = 0; /* PC_RESERVED */ /* 0 */
               }/* end of for loop */

               if(!fPaletteOnly){

                    m_hPal = ::CreatePalette( pLogPal );
               }
               else {

                    *phPal = ::CreatePalette( pLogPal );
               }/* end of if statement */

               // Clean up
               delete[] pLogPal;               
            }/* end of if statement */

            // here is the place to load up palette more eficiently                
            lpCurrent += ncolors * sizeof(RGBQUAD);
            dwOffset += ncolors * sizeof(RGBQUAD);
        }/* end of if statement */

        if(!fPaletteOnly){

            BYTE* pBits = NULL;

            typedef struct tagBITMAPINFOMAX {
                BITMAPINFOHEADER    bmiHeader;
                RGBQUAD             bmiColors[256];
            } BITMAPINFOMAX;


            BITMAPINFOMAX bmi; // temporary bitmap info header so we can modify it a bit
            ::CopyMemory(&bmi, lpbmih, sizeof(BITMAPINFOHEADER) + ncolors * sizeof(RGBQUAD));

            DWORD dwCompression = lpbmih->biCompression;

            bmi.bmiHeader.biCompression = BI_RGB; // DIB Section does not like RLE
            //bmi.bmiHeader.biBitCount = 32; 

            // update to DIB_RGB_COLORS or DIB_PAL_COLORS Colors            
            HDC hdcScreen = ::GetDC(NULL);

            hBitmap = ::CreateDIBSection(hdcScreen, (BITMAPINFO*)&bmi, DIB_RGB_COLORS, (LPVOID*) &pBits, NULL, 0);                       
            //hBitmap = ::CreateDIBSection(hdc, (BITMAPINFO*)lpbmih, DIB_RGB_COLORS, (LPVOID*) &pBits, NULL, 0);                       

            if(hBitmap){

                // now use the orginal bmih
                ::SetDIBits(hdcScreen, (HBITMAP) hBitmap, 0, lpbmih->biHeight, lpCurrent, (BITMAPINFO*)lpbmih, DIB_RGB_COLORS);
            }
            else {

                DWORD dwError =::GetLastError();
                ::ReleaseDC(NULL, hdcScreen);
                ATLASSERT(FALSE);
                throw (NULL);
            }/* end of if statement */

            ::ReleaseDC(NULL, hdcScreen);

        }/* end of if statement */

        
        
        if(lpDelete){

            delete[] lpDelete; // cleanup the bits if we had to allocate them
            lpDelete = NULL;
        }/* end of if statement */

        if(hBmpFile){

            UnlockResource(hBmpFile);
            ::FreeResource(hBmpFile);
            hBmpFile = NULL;
        }/* end of if statement */
    }/* end of try statement */
       
#endif
    catch(...){

        if(hBmpFile){

            UnlockResource(hBmpFile);
            ::FreeResource(hBmpFile);
        }/* end of if statement */

        if(hFile){

            ::CloseHandle(hFile);
            hFile = NULL;
        }/* end of if statement */

        if(lpDelete){

            delete[] lpDelete; // cleanup the bits if we had to allocate them
            lpDelete = NULL;
        }/* end of if statement */
            
        hBitmap = NULL;
    }/* end of catch statement */

    return(hBitmap);
}/* end of function LoadImage */