/////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 1996-2002 Microsoft Corporation
//
//  Module Name:
//      Bitmap.cpp
//
//  Abstract:
//      Implementation of the CMyBitmap class.
//
//  Author:
//      David Potter (davidp)   June 12, 1996
//
//  Revision History:
//
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Bitmap.h"
#include "TraceTag.h"
#include "ExcOper.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// Global Variables
/////////////////////////////////////////////////////////////////////////////

#ifdef _DEBUG
CTraceTag g_tagBitmap(_T("Bitmap"), _T("Bitmap"));
CTraceTag g_tagLoadBitmapResource(_T("Bitmap"), _T("LoadBitmapResource"));
#endif

/////////////////////////////////////////////////////////////////////////////
// CMyBitmap
/////////////////////////////////////////////////////////////////////////////

// Array used for restoring the System Palette when a using a Custom Palette Bitmap.
PALETTEENTRY CMyBitmap::s_rgpeSavedSystemPalette[nMaxSavedSystemPaletteEntries];

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::CMyBitmap
//
//  Routine Description:
//      Default constructor.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//  Exceptions Thrown:
//      None.
//--
/////////////////////////////////////////////////////////////////////////////
CMyBitmap::CMyBitmap(void)
{
    m_hinst = NULL;

    m_pbiNormal = NULL;
    m_pbiHighlighted = NULL;
    m_pbBitmap = NULL;
    m_hPalette = NULL;
    m_nSavedSystemPalette = 0;
    SetCustomPalette(FALSE);

}  //*** CMyBitmap::CMyBitmap()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::~CMyBitmap
//
//  Routine Description:
//      Destructor.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//  Exceptions Thrown:
//      None.
//--
/////////////////////////////////////////////////////////////////////////////
CMyBitmap::~CMyBitmap(void)
{
    delete [] (PBYTE) PbiNormal();
    delete [] (PBYTE) PbiHighlighted();
    delete [] (PBYTE) PbBitmap();

    // If we saved the System Palette Entries, we have a Palette, and the
    // number of colors for the Palette() is enough to restore the System
    // Palette entries...
    if (m_nSavedSystemPalette
            && (HPalette() != NULL)
            && (NColors() >= m_nSavedSystemPalette))
    {
        HDC         hdcScreen;
        UINT        nRestoredEntries;
        HPALETTE    hOldPalette;

        Trace(g_tagBitmap, _T("Restoring Screen Palette HPalette()=0x%x..."), HPalette());
        Trace(g_tagBitmap, _T("Restoring Screen Palette Entries=%d"), m_nSavedSystemPalette);

        // Restore the System Palette Entries
        nRestoredEntries = ::SetPaletteEntries(HPalette(), 0, m_nSavedSystemPalette, s_rgpeSavedSystemPalette);

        Trace(g_tagBitmap, _T("Restored Screen Palette Entries=%d"), nRestoredEntries);

        // Get the Screen's HDC
        hdcScreen = ::GetDC(NULL);

        // Select the Palette into the Screen's HDC
        hOldPalette = ::SelectPalette(hdcScreen, HPalette(), FALSE);

        // Unrealize the Palette to insure all the colors are forced into the System Palette
        ::UnrealizeObject(HPalette());

        // Force the local Palette's colors into the System Palette.
        ::RealizePalette(hdcScreen);

        // Release the Screen's HDC
        ::ReleaseDC(NULL, hdcScreen);

        // Invalidate the Screen completely so all windows are redrawn.
        ::InvalidateRect(NULL, NULL, TRUE);
    }

    // Destroy the Handle to the locally created Custom Palette.
    if (HPalette() != NULL)
        ::DeleteObject(HPalette());

}  //*** CMyBitmap::~CMyBitmap()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::Load
//
//  Purpose:
//      Loads a bitmap from the resource into memory.
//
//  Arguments:
//      idBitmap    id of the resource to load
//
//  Return Value:
//      None.
//
//  Exceptions Thrown:
//      Any exceptions thrown by LoadBitmapResource, CreatePallette,
//      CreatePALColorMapping, or new.
//--
/////////////////////////////////////////////////////////////////////////////
void CMyBitmap::Load(ID idBitmap)
{
    // Load the Bitmap Header Information, Color Mapping Information, and the Bitmap Image.
    LoadBitmapResource(
                idBitmap,
                Hinst(),
                MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL)
                );

    ASSERT(PbiNormal() != NULL);
    ASSERT(PbBitmap() != NULL);

    // Start by initializing some internal variables...
    m_dx = PbiNormal()->bmiHeader.biWidth;
    m_dy = PbiNormal()->bmiHeader.biHeight;

    ASSERT(PbiHighlighted() == NULL);

    if (BCustomPalette())
    {
        Trace(g_tagBitmap, _T("Load() - Creating Logical Palette"));

        // Save the System Palette Entries for use in the Destructor.
        SaveSystemPalette();

        // Create a Global HPalette() for use in the Paint() routine.
        CreatePalette();

        // Re-create the PbiNormal() for DIB_PAL_COLORS in the Paint() routine.
        CreatePALColorMapping();

    }  // if:  using a custom pallette
    else
    {
        // Create and Initialize the PbiHighlighted() for 16 color bitmaps.
        ASSERT(NColors() <= 16);

        Trace(g_tagBitmap, _T("Load() - Allocating PbiHighlighted()"));

        m_pbiHighlighted = (BITMAPINFO *) new BYTE[CbBitmapInfo()];
        if (m_pbiHighlighted != NULL)
        {
            ::CopyMemory(PbiHighlighted(), PbiNormal(), CbBitmapInfo());
        } // if: bitmapinfo allocated successfully

    }  // else:  not using a custom pallette

}  //*** CMyBitmap::Load()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::LoadBitmapResource
//
//  Purpose:
//      Load a bitmap resource into the CMyBitmap class.  This includes loading (a) bitmap
//      header information, (b) color mapping table, and (c) the actual bitmap.
//
//  Arguments:
//      idbBitmap   Resource id of the bitmap to load.
//      hinst       Handle to the Module Instance
//      langid      Language specific resource (possibly different bitmaps for localized strings [Japanese, etc.])
//
//  Return Value:
//      None.
//
//  Exceptions Thrown:
//      GetLastError from FindResourceEx, LoadResource, LockResource, 
//      Any exceptions thrown by new.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CMyBitmap::LoadBitmapResource(ID idbBitmap, HINSTANCE hinst, LANGID langid)
{
    HRSRC               hrsrc = NULL;
    HGLOBAL             hglbl = NULL;
    LPBITMAPINFO        pBitmapInfo = NULL;
    LPBITMAPINFOHEADER  pBitmapInfoHeader = NULL;
    LPRGBQUAD           pRgbQuad = NULL;
    CB                  cbBitmapData;
    BYTE *              pbImageBits;

    Trace(g_tagLoadBitmapResource, _T("LoadBitmapResource(%d) - Entering"), idbBitmap);

    ASSERT(idbBitmap != NULL);

    if (hinst == NULL)
        hinst = AfxGetApp()->m_hInstance;

    // We need to find the bitmap data which includes (a) header info, (b) color, and (c) the bitmap.
    hrsrc = ::FindResourceEx(hinst, RT_BITMAP, MAKEINTRESOURCE(idbBitmap), langid);
    if (hrsrc == NULL)
    {
        DWORD   dwError = ::GetLastError();
        CString strError;

        if (dwError == ERROR_RESOURCE_NAME_NOT_FOUND)
            strError.Format(_T("Bitmap Resource %d Not Found.  NT Error %d Loading Bitmap [Lang=%d, SubLang=%d]"),
                    idbBitmap, dwError, PRIMARYLANGID(langid), SUBLANGID(langid));
        else
            strError.Format(_T("NT Error %d Attempting to Load Bitmap Resource %d [Lang=%d, SubLang=%d]"),
                    dwError, idbBitmap, PRIMARYLANGID(langid), SUBLANGID(langid));
        Trace(g_tagAlways, _T("LoadBitmapResource() - Error '%s'"), strError);
        ThrowStaticException(dwError);
    }  // if:  error finding the resource

    hglbl = ::LoadResource(hinst, hrsrc);
    if (hglbl == NULL)
        ThrowStaticException(::GetLastError());

    pBitmapInfo = (LPBITMAPINFO) ::LockResource(hglbl);
    if (pBitmapInfo == NULL)
        ThrowStaticException(::GetLastError());

    cbBitmapData = ::SizeofResource(hinst, hrsrc);
    ASSERT(cbBitmapData != 0);

    Trace(g_tagLoadBitmapResource, _T("Bitmap Location = 0x%x"), pBitmapInfo);
    Trace(g_tagLoadBitmapResource, _T("Bitmap Data Size = %d bytes"), cbBitmapData);

    pBitmapInfoHeader = (LPBITMAPINFOHEADER) &pBitmapInfo->bmiHeader;
    ASSERT(pBitmapInfoHeader != NULL);
    Trace(g_tagLoadBitmapResource, _T("Bitmap Info Header = 0x%x"), pBitmapInfoHeader);

    ASSERT(pBitmapInfoHeader->biSize == sizeof(BITMAPINFOHEADER));

    Trace(g_tagLoadBitmapResource, _T("biSize=%d"), pBitmapInfoHeader->biSize);
    Trace(g_tagLoadBitmapResource, _T("biWidth=%d"), pBitmapInfoHeader->biWidth);       // Width in Pixels
    Trace(g_tagLoadBitmapResource, _T("biHeight=%d"), pBitmapInfoHeader->biHeight); // Height in Pixels
    Trace(g_tagLoadBitmapResource, _T("biPlanes=%d"), pBitmapInfoHeader->biPlanes);
    Trace(g_tagLoadBitmapResource, _T("biBitCount=%d"), pBitmapInfoHeader->biBitCount);
    Trace(g_tagLoadBitmapResource, _T("biCompression=%d"), pBitmapInfoHeader->biCompression);
    Trace(g_tagLoadBitmapResource, _T("biSizeImage=%d"), pBitmapInfoHeader->biSizeImage);
    Trace(g_tagLoadBitmapResource, _T("biXPelsPerMeter=%d"), pBitmapInfoHeader->biXPelsPerMeter);
    Trace(g_tagLoadBitmapResource, _T("biYPelsPerMeter=%d"), pBitmapInfoHeader->biYPelsPerMeter);
    Trace(g_tagLoadBitmapResource, _T("biClrUsed=%d"), pBitmapInfoHeader->biClrUsed);
    Trace(g_tagLoadBitmapResource, _T("biClrImportant=%d"), pBitmapInfoHeader->biClrImportant);

    pRgbQuad = (LPRGBQUAD) &pBitmapInfo->bmiColors;
    ASSERT(pRgbQuad != NULL);
    Trace(g_tagLoadBitmapResource, _T("Bitmap Rgb Quad = 0x%x"), pRgbQuad);

    m_nColors = NColorsFromBitCount(pBitmapInfoHeader->biBitCount);
    m_cbColorTable = m_nColors * sizeof(RGBQUAD);
    m_cbBitmapInfo = sizeof(BITMAPINFOHEADER) + CbColorTable();

    Trace(g_tagLoadBitmapResource, _T("NColors()=%d"), NColors());
    Trace(g_tagLoadBitmapResource, _T("CbColorTable()=%d"), CbColorTable());
    Trace(g_tagLoadBitmapResource, _T("CbBitmapInfo()=%d"), CbBitmapInfo());

    ASSERT(PbiNormal() == NULL);

    // Allocate the Normal Bitmap Information
    m_pbiNormal = (LPBITMAPINFO) new BYTE[CbBitmapInfo()];
    if (m_pbiNormal == NULL)
    {
        return;
    } // if: error allocating the bitmapinfo structure

    // Fill PbiNormal() with the Loaded Resource (a) Bitmap Information and Color Mapping Table.
    ::CopyMemory(PbiNormal(), pBitmapInfo, CbBitmapInfo());

    m_cbImageSize = pBitmapInfoHeader->biSizeImage;
    if ((m_cbImageSize == 0) && (pBitmapInfoHeader->biCompression == BI_RGB))
        m_cbImageSize = cbBitmapData - CbBitmapInfo();

    Trace(g_tagLoadBitmapResource, _T("Allocating Bitmap of size CbImageSize()=%d"), CbImageSize());

    ASSERT(cbBitmapData == CbBitmapInfo() + CbImageSize());
    ASSERT(PbBitmap() == NULL);

    // Allocate memory for the Bitmap Image
    m_pbBitmap = new BYTE[CbImageSize()];
    if (m_pbBitmap == NULL)
    {
        return;
    } // if: error allocating the bitmap image

    pbImageBits = (BYTE *) pBitmapInfo + CbBitmapInfo();

    Trace(g_tagLoadBitmapResource, _T("Bitmap Location pbImageBits=0x%x"), pbImageBits);

    // Copy the Image Bits into the allocated memory.
    ::CopyMemory(PbBitmap(), pbImageBits, CbImageSize());

}  //*** CMyBitmap::LoadBitmapResource()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::NColorsFromBitCount
//
//  Purpose:
//      Compute the number of colors given the number of bits to represent color.
//
//  Arguments:
//      nBitCount       The number of bits used for color representation.
//
//  Return Value:
//      nColors         Number of colors represented with nBitCount bits.
//
//--
/////////////////////////////////////////////////////////////////////////////
int CMyBitmap::NColorsFromBitCount(int nBitCount) const
{
    int         nColors;

    switch (nBitCount)
    {
        default:
            nColors = 0;
            break;

        case 1:
            nColors = 2;
            break;

        case 4:
            nColors = 16;
            break;

        case 8:
            nColors = 256;
            break;
    }

    return nColors;

}  //*** CMyBitmap::NColorsFromBitCount()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::SaveSystemPalette
//
//  Purpose:
//      To save the System Palette Colors for use when a Custom Palette overwrites
//      the System Palette entries.  The Saved System Palette (s_rgpeSavedSystemPalette)
//      is used in the CMyBitmap's destructor.
//
//  Arguments:
//      None.
//
//  Return Values:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CMyBitmap::SaveSystemPalette(void)
{
    HDC         hdcScreen;
    int         nPaletteEntries;
    int         nSavedEntries;

    // Get the Screen's HDC
    hdcScreen = ::GetDC(NULL);
    if (hdcScreen == NULL)
    {
        return;
    } // if: couldn't get the screen DC

    // Can only save the System Palette Colors when the Device's RC_PALETTE bit is set.
    if (::GetDeviceCaps(hdcScreen, RASTERCAPS) & RC_PALETTE)
    {
        // Get the Number of System Palette Entries
        nPaletteEntries = ::GetDeviceCaps(hdcScreen, SIZEPALETTE);

        Trace(g_tagBitmap, _T("SaveSystemPalette() - nPaletteEntries=%d"), nPaletteEntries);

        if ((nPaletteEntries > 0)
                && (nPaletteEntries <= nMaxSavedSystemPaletteEntries))
        {
            // Get the Current System Palette Entries
            nSavedEntries = ::GetSystemPaletteEntries(hdcScreen, 0, nPaletteEntries, s_rgpeSavedSystemPalette);

            // Set the number of Saved System Palette Entries list for use in OnDestroy().
            if (nSavedEntries == nPaletteEntries)
            {
                Trace(g_tagBitmap, _T("SaveSystemPalette() - Saved System Palette Entries=%d"), nPaletteEntries);
                m_nSavedSystemPalette = nPaletteEntries;
            }
        }
    }

    // Release the Screen's HDC
    ::ReleaseDC(NULL, hdcScreen);

}  //*** CMyBitmap::SaveSystemPalette()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::CreatePalette
//
//  Purpose:
//      Create a logical palette from the color mapping table embedded in the
//      bitmap resource.
//
//  Arguments:
//      None.
//
//  Return Values:
//      None.
//
//  Exceptions Thrown:
//      GetLastError from CreatePalette.
//      Any exceptions thrown by new.
//--
/////////////////////////////////////////////////////////////////////////////
void CMyBitmap::CreatePalette(void)
{
    LPLOGPALETTE        pLogicalPalette = NULL;
    CB                  cbLogicalPalette;
    int                 nColor;
    LPPALETTEENTRY      pPaletteEntry;

    Trace(g_tagBitmap, _T("CreatePalette() - Entering"));

    try
    {
        // Compute the size of the logical palette.
        cbLogicalPalette = sizeof(LOGPALETTE) + (NColors() * sizeof(PALETTEENTRY));

        Trace(g_tagBitmap, _T("CreatePalette() - cbLogicalPalette=%d"), cbLogicalPalette);

        // Allocate the Logical Palette Memory
        pLogicalPalette = (LPLOGPALETTE) new BYTE[cbLogicalPalette];
        if (pLogicalPalette == NULL)
        {
            ThrowStaticException(GetLastError());
            return;
        } // if: error allocating the Logical Palette Memory

        ASSERT(pLogicalPalette != NULL);
        ASSERT(PbiNormal() != NULL);

        pLogicalPalette->palVersion = 0x300;            // Windows 3.0
        pLogicalPalette->palNumEntries = (WORD) NColors();

        // Fill the Logical Palette's Color Information
        for (nColor=0; nColor<NColors(); nColor++)
        {
            pPaletteEntry = &(pLogicalPalette->palPalEntry[nColor]);

            pPaletteEntry->peRed = PbiNormal()->bmiColors[nColor].rgbRed;
            pPaletteEntry->peGreen = PbiNormal()->bmiColors[nColor].rgbGreen;
            pPaletteEntry->peBlue = PbiNormal()->bmiColors[nColor].rgbBlue;
            pPaletteEntry->peFlags = 0;
        }

        // Create the NT Palette for use in the Paint Routine.
        m_hPalette = ::CreatePalette(pLogicalPalette);
        if (m_hPalette == NULL)
        {
            ThrowStaticException(::GetLastError());
        }

        ASSERT(HPalette() != NULL);

        delete [] (PBYTE) pLogicalPalette;
    }  // try
    catch (CException *)
    {
        delete [] (PBYTE) pLogicalPalette;
        throw;
    }  // catch:  anything

}  //*** CMyBitmap::CreatePalette()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::CreatePALColorMapping
//
//  Purpose:
//      Given BITMAPINFO in PbiNormal(), recreate the PbiNormal() into a
//      DIB_PAL_COLORS format.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//  Exceptions Thrown:
//      Any exceptions thrown by new.
//--
/////////////////////////////////////////////////////////////////////////////
void CMyBitmap::CreatePALColorMapping(void)
{
    LPBITMAPINFO            pNewBitmapInfo = NULL;
    CB                      cbNewBitmapInfo;
    CB                      cbNewBitmapHeaderInfo;
    BYTE *                  pbColorTable;
    WORD                    wColor;

    ASSERT(PbiNormal() != NULL);
    ASSERT(PbiNormal()->bmiHeader.biSize == sizeof(BITMAPINFOHEADER));
//  ASSERT(PbiNormal()->bmiHeader.biClrUsed == (UINT) NColors());

    try
    {
        Trace(g_tagBitmap, _T("CreatePALColorMapping() - Entering"));

        cbNewBitmapHeaderInfo = sizeof(BITMAPINFOHEADER);

        Trace(g_tagBitmap, _T("CreatePALColorMapping() - cbNewBitmapHeaderInfo=%d"), cbNewBitmapHeaderInfo);

        // New Bitmap Info is the Info Header plus the Color mapping information.
        cbNewBitmapInfo = cbNewBitmapHeaderInfo + (NColors() * sizeof(WORD));

        Trace(g_tagBitmap, _T("CreatePALColorMapping() - cbNewBitmapInfo=%d"), cbNewBitmapInfo);

        // Allocate the New Bitmap Information
        pNewBitmapInfo = (LPBITMAPINFO) new BYTE[cbNewBitmapInfo];

        ASSERT(pNewBitmapInfo != NULL);
        if (pNewBitmapInfo == NULL)
        {
            ThrowStaticException(GetLastError());
            return;
        } // if: error allocating the new bitmapinfo structure

        Trace(g_tagBitmap, _T("CreatePALColorMapping() - New Bitmap Info Location=0x%x"), pNewBitmapInfo);

        // Copy the Header Information to the allocated memory.
        ::CopyMemory(pNewBitmapInfo, PbiNormal(), cbNewBitmapHeaderInfo);

        // Create the Color Lookup Table.
        pbColorTable = (BYTE *) (pNewBitmapInfo) + cbNewBitmapHeaderInfo;

        ASSERT(pbColorTable + (NColors() * sizeof(WORD)) == (BYTE *) (pNewBitmapInfo) + cbNewBitmapInfo);

        Trace(g_tagBitmap, _T("CreatePALColorMapping() - Filling %d Color Table at Location 0x%x"), NColors(), pbColorTable);

        // Fill the PAL Color Lookup Table
        for (wColor = 0 ; wColor < NColors() ; wColor++)
        {
            ::CopyMemory(pbColorTable, &wColor, sizeof(WORD));
            pbColorTable += sizeof(WORD);
        }

        delete [] (PBYTE) PbiNormal();
        m_pbiNormal = pNewBitmapInfo;
        m_cbBitmapInfo = cbNewBitmapInfo;
        pNewBitmapInfo = NULL;
    }  // try
    catch (CException *)
    {
        delete [] pNewBitmapInfo;
        throw;
    }  // catch:  anything

}  //*** CMyBitmap::CreatePALColorMapping()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::Paint
//
//  Purpose:
//      Paints a sub-bitmap
//
//  Parameters:
//      hdc         HDC to paint
//      prect       Where to position the bitmap:
//                      Only the upperleft corner is used
//      bHighlighted    Used to select the color map to use.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CMyBitmap::Paint(HDC hdc, RECT * prect, BOOL bHighlighted)
{
    LPBITMAPINFO            pBitmapInfo;
    UINT                    nColorUse;
    HPALETTE                hOldPalette = NULL;

    ASSERT(hdc != NULL);
    ASSERT(prect != NULL);

    Trace(g_tagBitmap, _T("bHighlighted = %d"), bHighlighted);

#ifdef _DEBUG
    {
        int             nPlanes;
        int             nBitsPerPixel;
        int             nBitCount;

        nPlanes = ::GetDeviceCaps(hdc, PLANES);
        nBitsPerPixel = ::GetDeviceCaps(hdc, BITSPIXEL);
        nBitCount = nPlanes * nBitsPerPixel;

        Trace(g_tagBitmap, _T("Paint() - nPlanes=%d"), nPlanes);
        Trace(g_tagBitmap, _T("Paint() - nBitsPerPixel=%d"), nBitsPerPixel);
        Trace(g_tagBitmap, _T("Paint() - nBitCount=%u"), nBitCount);
    }
#endif

    try
    {
        if (BCustomPalette())
        {
            ASSERT(PbiNormal() != NULL);
            ASSERT(HPalette() != NULL);

            // Select the Custom Palette into the HDC about to be drawn...
            hOldPalette = ::SelectPalette(hdc, HPalette(), FALSE);              // FALSE causes the current Screen Palette to be Overwritten
            if (hOldPalette == NULL)
                ThrowStaticException(::GetLastError());

            // Force the Palette colors into the System Palette
            if (::RealizePalette(hdc) == GDI_ERROR)
                ThrowStaticException(::GetLastError());

            pBitmapInfo = PbiNormal();
            nColorUse = DIB_PAL_COLORS;

#ifdef NEVER
            pBitmapInfo = PbiNormal();
            nColorUse = DIB_RGB_COLORS;
#endif
        }  // if:  using a custom palette
        else
        {
            ASSERT(NColors() <= 16);
            ASSERT(PbiNormal() != NULL);
            ASSERT(PbiHighlighted() != NULL);
            pBitmapInfo = (bHighlighted ? PbiHighlighted() : PbiNormal());
            nColorUse = DIB_RGB_COLORS;
        }  // else:  not using a custom palette

        ::SetDIBitsToDevice(
                    hdc,
                    (int) prect->left,                      // X coordinate on screen.
                    (int) prect->top,                       // Y coordinate on screen.
                    (DWORD) Dx(),                           // cx to paint
                    (DWORD) Dy(),                           // cy to paint
                                                            // Note: (0,0) of the DIB is lower-left corner!?!
                    0,                                      // In pbi, xLeft to paint
                    0,                                      // In pbi, yLower to paint
                    0,                                      // Start scan line
                    Dy(),                                   // Number of scan lines
                    PbBitmap(),                             // The buffer description
                    pBitmapInfo,                            // Bitmap Information
                    nColorUse                               // DIB_RGB_COLORS or DIB_PAL_COLORS
                    );
    }  // try
    catch (CException * pe)
    {
        pe->ReportError();
        pe->Delete();
    }  // catch:  CException

}  //*** CMyBitmap::Paint()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::LoadColors
//
//  Purpose:
//      Loads the color maps based on the system settings
//
//  Arguments:
//      pnColorNormal & pnColorHighlighted
//          Arrays of 16 elements:
//              -1          Do not remap this color
//              COLOR_xxx   Remap this color to the system color.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CMyBitmap::LoadColors(int * pnColorNormal, int * pnColorHighlighted)
{
    LoadColors(pnColorNormal, PbiNormal());
    LoadColors(pnColorHighlighted, PbiHighlighted());

}  //*** CMyBitmap::LoadColors(pnColorNormal, pnColorHighlighted)

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::LoadColors
//
//  Purpose:
//      Similar to above LoadColors except only the PbiNormal() colors are altered.
//
//  Arguments:
//      pnColorNormal       Array of color mapping table.
//
//  Returns:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CMyBitmap::LoadColors(int * pnColorNormal)
{
    LoadColors(pnColorNormal, PbiNormal());

}  //*** CMyBitmap::LoadColors(pnColorNormal)

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CMyBitmap::LoadColors
//
//  Purpose:
//      Loads one color map based on the system settings
//
//  Arguments:
//      pnColor
//          Arrays of 16 elements:
//              -1          Do not remap this color
//              COLOR_xxx   Remap this color to the system color.
//      pbi
//      BITMAPINFO structure to adjust
//
//--
/////////////////////////////////////////////////////////////////////////////
void CMyBitmap::LoadColors(int * pnColor, BITMAPINFO * pbi)
{
    int         inColor;
    COLORREF    cr;

    ASSERT(pbi != NULL);
    ASSERT(pbi->bmiHeader.biBitCount <= 4);
    ASSERT(NColors() <= 16);
    ASSERT(BCustomPalette() == FALSE);

    for (inColor = 0; inColor < 16; inColor++)
    {
        if (pnColor[inColor] == -1)
            continue;

        cr = GetSysColor(pnColor[inColor]);
        pbi->bmiColors[inColor].rgbRed = GetRValue(cr);
        pbi->bmiColors[inColor].rgbGreen = GetGValue(cr);
        pbi->bmiColors[inColor].rgbBlue = GetBValue(cr);
    }

}  //*** CMyBitmap::LoadColors(pnColor, pbi)