图像处理VC源码1.0－CDib

 #if !defined(__DIB_H_)
#define __DIB_H_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
// Dib.h : header file
//

#include "DIBAPI.H"

////////////////////////////////////////////////////////////////////////////
// CDib
class CDib : public CObject
{                         
 DECLARE_SERIAL(CDib)

// Public member function
public:
 // constructor
 CDib();
 // create
 BOOL Create(DWORD dwWidth, DWORD dwHeight);
 BOOL Create(DWORD dwWidth, DWORD dwHeight, WORD wBitCount);
 BOOL Create(LPBYTE lpDIB);
 BOOL Create(LPBYTE lpDIB,  // DIB pointer
       WORD  wBitCount); // bits/pixel
 BOOL Create(HBITMAP hBitmap); // DIBSection
 BOOL Create(HBITMAP hBitmap,  // DIBSection
       WORD  wBitCount); // bits/pixel
 BOOL Create(HBITMAP hBitmap,  // Bitmap handle
       HPALETTE hPalette); // Palette handle
 BOOL Create(HBITMAP hBitmap,  // Bitmap handle
       HPALETTE hPalette, // Palette handle
       WORD  wBitCount); // bits/pixel
 BOOL Create(CRect rcScreen);
 BOOL Create(HWND hWnd, WORD fPrintArea);
 BOOL Create(HWND hWnd, CRect rcClientArea);
 // load/save
    BOOL Load(UINT uIDS, LPCTSTR lpszDibType);
    BOOL Load(LPCTSTR lpszDibRes, LPCTSTR lpszDibType);
    BOOL Load(LPCTSTR lpszDibFile);
    BOOL Save(LPCTSTR lpszDibFile);
 BOOL Read(CFile *pFile);
 BOOL Write(CFile *pFile);

 // clone
 CDib *  Clone();

 // deconstructor
 virtual ~CDib();
 // destroy
 void Destroy();

 // overlaying Serialize
 virtual void Serialize(CArchive &ar);
   
 // display
 BOOL Display(CDC * pDC, int xDest, int yDest, int nWidthDest, int nHeightDest,
        int xSrc, int ySrc, DWORD dwRop=SRCCOPY);
 BOOL Display(CDC * pDC, int xDest, int yDest, int nWidthDest, int nHeightDest,
        int xSrc, int ySrc, int nWidthSrc, int nHeightSrc, DWORD dwRop=SRCCOPY);
    BOOL Display(CDC* pDC, int x, int y, DWORD dwRop=SRCCOPY);
 BOOL Display(CDC* pDC, CRect rcDest, CRect rcSrc,DWORD dwRop=SRCCOPY);
 BOOL DisplayPalette(CDC* pDC, CRect rc);

 // DC for modify DIB
 CDC* BeginPaint(CDC *pDC);
 void EndPaint();

 // DDB and palette
 BOOL BuildBitmap();
 BOOL BuildPalette();

 // attributes
 BOOL IsEmpty();
 DWORD GetCompression();
    WORD GetBitCount();
    LONG GetWidth();
    LONG GetHeight();   
 LONG GetWidthBytes();
    WORD GetColorNumber();
 WORD GetPaletteSize();
    CBitmap*  GetBitmap();
 CPalette* GetPalette();
 HANDLE GetHandle();
 LPBYTE GetBitsPtr();
 COLORREF GetPixel(LONG x, LONG y);
 LONG    GetPixelOffset(LONG x, LONG y);

// private member function
private:
 BOOL UpdateInternal();

// public member data
public:
 HDIB  m_hDib;
 HBITMAP  m_hBitmap; // handle of DIBSection
 CPalette*  m_pPalette;
 CBitmap* m_pBitmap;

// private member data
private:
 // for drawing in DIB
 CDC *  m_pMemDC;
 CBitmap* m_pBitmapTmp;
 CPalette* m_pPaletteTmp;
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.

#endif // !defined(__DIB_H_)

================================================================================

// Dib.cpp : implementation file
//

#include "stdafx.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <windowsx.h>  // especially for GlobalAllocPtr

#include "Dib.h"

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

IMPLEMENT_SERIAL(CDib, CObject, 0)

////////////////////////////////////////////////////////////////////////////
CDib::CDib()
{
 m_hDib  = NULL;
 m_hBitmap   = NULL;
 m_pPalette  = NULL;
 m_pBitmap   = NULL;
}          
                                     
CDib::~CDib()
{
 Destroy();
 if (m_pBitmap != NULL)
 {
  delete m_pBitmap;
  m_pBitmap = NULL;
 }
 if (m_pPalette != NULL)
 {
  delete m_pPalette;
  m_pPalette = NULL;
 }
}

void CDib::Destroy()
{
 if (m_hDib != NULL)
 {
  DestroyDIB(m_hDib);
  m_hDib = NULL;
 }
}

BOOL CDib::Create(DWORD dwWidth, DWORD dwHeight)
{
 HDIB hDib = CreateDefaultDIB(dwWidth, dwHeight);
 if (! hDib)
  return FALSE;

 Destroy();
 m_hDib = hDib;
 return UpdateInternal();
}

BOOL CDib::Create(DWORD dwWidth, DWORD dwHeight, WORD wBitCount)
{
 HDIB hDib = CreateDIB(dwWidth, dwHeight, wBitCount);
 if (! hDib)
  return FALSE;

 Destroy();
 m_hDib = hDib;
 return UpdateInternal();
}

BOOL CDib::Create(LPBYTE lpDIB)
{
 if (lpDIB == NULL)
  return FALSE;
 
 DWORD dwSize = DIBlockSize(lpDIB);

    HDIB hDib  = GlobalAlloc(GHND, dwSize);
    // Check that DIB handle is valid
    if (! hDib)
        return FALSE;
 
    LPBYTE lpbi  = (LPBYTE)GlobalLock(hDib);
 if (! lpbi)
        return FALSE;
  
 CopyMemory(lpbi, lpDIB, dwSize);
 GlobalUnlock(hDib);

 Destroy();
 m_hDib = hDib;
 return UpdateInternal();
}

BOOL CDib::Create(LPBYTE lpDIB,
      WORD  wBitCount)  // bits/pixel
{
 if (lpDIB == NULL)
  return FALSE;
 if (! Create(lpDIB))
  return FALSE;

 WORD wBits = ((LPBITMAPINFOHEADER)lpDIB)->biBitCount;
 if (wBitCount == wBits)
  return TRUE;

 HDIB hNewDib = ConvertDIBFormat(m_hDib, wBitCount, NULL);
 if (! hNewDib)
  return FALSE;

 Destroy();
 m_hDib = hNewDib;
 return UpdateInternal();
}

BOOL CDib::Create(HBITMAP hBitmap)  // DIB Section
{
 if (! hBitmap)
        return FALSE;

 HDIB hDib = DIBSectionToDIB(hBitmap);
    if (! hDib)
        return FALSE;

 Destroy();
 m_hDib = hDib;
 return UpdateInternal();
}

BOOL CDib::Create(HBITMAP hBitmap,  // DIB Section
      WORD  wBitCount)  // bits/pixel
{
 HDIB hNewDib;

 if (! hBitmap)
        return FALSE;

 HDIB hDib = DIBSectionToDIB(hBitmap);
    if (! hDib)
        return FALSE;

 DIBSECTION ds;
 GetObject(hBitmap, sizeof(DIBSECTION), &ds);

 if (wBitCount == ds.dsBmih.biBitCount)
  hNewDib = hDib;
 else
 {
  hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL);
  // cleanup hDib
  GlobalFree(hDib);
 }
 if (! hNewDib)
  return FALSE;

 Destroy();
 m_hDib = hNewDib;
 return UpdateInternal();
}

BOOL CDib::Create(HBITMAP hBitmap,  // DDB bitmap
         HPALETTE hPalette) // DDB palette
{
 if (! hBitmap)
        return FALSE;

 HDIB hDib = BitmapToDIB(hBitmap, hPalette);
    if (! hDib)
        return FALSE;

 Destroy();
 m_hDib = hDib;
 return UpdateInternal();
}

BOOL CDib::Create(HBITMAP hBitmap,  // DDB bitmap
         HPALETTE hPalette, // DDB palette
      WORD  wBitCount)  // bits/pixel
{
 if (! hBitmap)
        return FALSE;

 HDIB hDib = BitmapToDIB(hBitmap, hPalette, wBitCount);
    if (! hDib)
        return FALSE;

 Destroy();
 m_hDib = hDib;
 return UpdateInternal();
}

BOOL CDib::Create(CRect rcScreen)
{
 HDIB hDib = CopyScreenToDIB(rcScreen);
    if (! hDib)
        return FALSE;

 Destroy();
 m_hDib = hDib;
 return UpdateInternal();
}

BOOL CDib::Create(HWND hWnd, WORD fPrintArea)
{
 HDIB hDib = CopyWindowToDIB(hWnd, fPrintArea);
    if (! hDib)
        return FALSE;

 Destroy();
 m_hDib = hDib;
 return UpdateInternal();
}

BOOL CDib::Create(HWND hWnd, CRect rcClientArea)
{
 HDIB hDib = CopyClientRectToDIB(hWnd, rcClientArea);
    if (! hDib)
        return FALSE;

 Destroy();
 m_hDib = hDib;
 return UpdateInternal();
}

void CDib::Serialize(CArchive& ar)
{
 CObject::Serialize(ar);
 ar.Flush();
 if (ar.IsStoring())
 {
  Write(ar.GetFile());
 }
    else
    {
     Read(ar.GetFile());
    }
}

BOOL CDib::Load(UINT uIDS, LPCSTR lpszDibType)
{                               
 LPCSTR lpszDibRes = MAKEINTRESOURCE(uIDS);

 return Load(lpszDibRes, lpszDibType);
}

BOOL CDib::Load(LPCSTR lpszDibRes, LPCSTR lpszDibType)
{                               
 HINSTANCE hInst = AfxGetInstanceHandle();
 HRSRC   hRes    = ::FindResource(hInst, lpszDibRes, lpszDibType);
 HGLOBAL hData   = ::LoadResource(hInst, hRes);

 // if resource ok?
 if (hRes == NULL || hData == NULL)
  return FALSE;

 // get resource buffer
 LPBYTE lpBuf = (LPBYTE)::LockResource(hData);
 // is DIB ?
 if (((LPBITMAPFILEHEADER)lpBuf)->bfType != DIB_HEADER_MARKER/*"BM"*/)
  return FALSE;

 // use this buffer to create CDib
 LPBYTE lpDIB = lpBuf + sizeof(BITMAPFILEHEADER);
 return Create(lpDIB);
}

BOOL CDib::Load(LPCSTR lpszDibFile)
{                               
 TRY
 {
  CFile file(lpszDibFile, CFile::modeRead|CFile::shareDenyNone);

  if (! Read(&file))
   return FALSE;
 }
 CATCH (CException, e)
 {
  return FALSE;
 }
 END_CATCH

 return TRUE;
}              

BOOL CDib::Save(LPCSTR lpszDibFile)
{
 TRY
 {
  CFile file(lpszDibFile, CFile::modeCreate|CFile::modeWrite);

  if (! Write(&file))
   return FALSE;
 }
 CATCH (CException, e)
 {
  return FALSE;
 }
 END_CATCH

 return TRUE;
}

BOOL CDib::Read(CFile *pFile)
{
 WaitCursorBegin();

 LPBITMAPINFOHEADER lpbi;
 DWORD dwSize;
 TRY
 {
  // read DIB file header
  BITMAPFILEHEADER bmfHdr;
  pFile->Read(&bmfHdr, sizeof(BITMAPFILEHEADER));
  // is DIB file?
  if (bmfHdr.bfType != DIB_HEADER_MARKER/*"BM"*/)
  {
   WaitCursorEnd();
   return FALSE;
  }
  DWORD dwLength = pFile->GetLength();
  if (bmfHdr.bfSize != dwLength)
   bmfHdr.bfSize = dwLength;

  // read DIB buffer
  dwSize = bmfHdr.bfSize - sizeof(BITMAPFILEHEADER);
  lpbi = (LPBITMAPINFOHEADER)GlobalAllocPtr(GHND, dwSize);
  DWORD dwCount = pFile->Read(lpbi, dwSize);
  // read ok?
  if (dwCount != dwSize)
  {
   GlobalFreePtr(lpbi);
   WaitCursorEnd();
   return FALSE;
  }

  // Check to see that it's a Windows DIB -- an OS/2 DIB would cause
  // strange problems with the rest of the DIB API since the fields
  // in the header are different and the color table entries are
  // smaller.
  //
  // If it's not a Windows DIB (e.g. if biSize is wrong), return NULL.
     if (lpbi->biSize != sizeof(BITMAPINFOHEADER))
  {
   GlobalFreePtr(lpbi);
   WaitCursorEnd();
   return FALSE;
  }
  
  // fill color num item
  int nNumColors = (UINT)lpbi->biClrUsed;
  if (nNumColors == 0)
  {
   // no color table for 24-bit, default size otherwise
         if (lpbi->biBitCount != 24)
          nNumColors = 1 << lpbi->biBitCount; // standard size table
  }
 
  // fill in some default values if they are zero
     if (lpbi->biClrUsed == 0)
      lpbi->biClrUsed = nNumColors;
  if (lpbi->biSizeImage == 0)
   lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3) * lpbi->biHeight;
  }
 CATCH (CException, e)
 {
  GlobalFreePtr(lpbi);
  WaitCursorEnd();
  return FALSE;
 }
 END_CATCH

 // create CDib with DIB buffer
 BOOL bSuccess = Create((LPBYTE)lpbi);
 GlobalFreePtr(lpbi);
 WaitCursorEnd();

 return bSuccess;
}

BOOL CDib::Write(CFile *pFile)
{
 WaitCursorBegin();

    BITMAPFILEHEADER    bmfHdr;     // Header for Bitmap file
    LPBITMAPINFOHEADER  lpBI;       // Pointer to DIB info structure
    DWORD               dwDIBSize;

 // Get a pointer to the DIB memory, the first of which contains
    // a BITMAPINFO structure
    lpBI = (LPBITMAPINFOHEADER)GlobalLock(m_hDib);
    if (!lpBI)
 {
  GlobalUnlock(m_hDib);
  WaitCursorEnd();
        return FALSE;
 }
 
    // Check to see if we're dealing with an OS/2 DIB.  If so, don't
    // save it because our functions aren't written to deal with these
    // DIBs.
    if (lpBI->biSize != sizeof(BITMAPINFOHEADER))
    {
        GlobalUnlock(m_hDib);
  WaitCursorEnd();
        return FALSE;
    }
 
    // Fill in the fields of the file header
 
    // Fill in file type (first 2 bytes must be "BM" for a bitmap)
 
    bmfHdr.bfType = DIB_HEADER_MARKER;  // "BM"
 
    // Calculating the size of the DIB is a bit tricky (if we want to
    // do it right).  The easiest way to do this is to call GlobalSize()
    // on our global handle, but since the size of our global memory may have
    // been padded a few bytes, we may end up writing out a few too
    // many bytes to the file (which may cause problems with some apps,
    // like HC 3.0).
    //
    // So, instead let's calculate the size manually.
    //
    // To do this, find size of header plus size of color table.  Since the
    // first DWORD in both BITMAPINFOHEADER and BITMAPCOREHEADER conains
    // the size of the structure, let's use this.
 
    // Partial Calculation
 
    dwDIBSize = *(LPDWORD)lpBI + PaletteSize((LPBYTE)lpBI);  
 
    // Now calculate the size of the image
 
    // It's an RLE bitmap, we can't calculate size, so trust the biSizeImage
    // field
 
    if ((lpBI->biCompression == BI_RLE8) || (lpBI->biCompression == BI_RLE4))
        dwDIBSize += lpBI->biSizeImage;
    else
    {
        DWORD dwBmBitsSize;  // Size of Bitmap Bits only
 
        // It's not RLE, so size is Width (DWORD aligned) * Height
 
        dwBmBitsSize = WIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount)) *
                lpBI->biHeight;
 
        dwDIBSize += dwBmBitsSize;
 
        // Now, since we have calculated the correct size, why don't we
        // fill in the biSizeImage field (this will fix any .BMP files which 
        // have this field incorrect).
 
        lpBI->biSizeImage = dwBmBitsSize;
    }
 
 
    // Calculate the file size by adding the DIB size to sizeof(BITMAPFILEHEADER)
                   
    bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
    bmfHdr.bfReserved1 = 0;
    bmfHdr.bfReserved2 = 0;
 
    // Now, calculate the offset the actual bitmap bits will be in
    // the file -- It's the Bitmap file header plus the DIB header,
    // plus the size of the color table.
    
    bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpBI->biSize +
            PaletteSize((LPBYTE)lpBI);
 
  TRY
 {
     // Write the file header
  pFile->Write(&bmfHdr, sizeof(BITMAPFILEHEADER));
  // write DIB buffer
  pFile->Write(lpBI, dwDIBSize);
 }
 CATCH (CException, e)
 {
        GlobalUnlock(m_hDib);
  WaitCursorEnd();
  return FALSE;
 }
 END_CATCH

 GlobalUnlock(m_hDib);
 WaitCursorEnd();
 
 return TRUE;
}

BOOL CDib::Display(CDC* pDC, int xDest, int yDest, int nWidthDest, int nHeightDest,
        int xSrc, int ySrc, DWORD dwRop)
{
 CDC MemDC;
 MemDC.CreateCompatibleDC(pDC);

 CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);

 CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
    pDC->RealizePalette();

 BOOL bSuccess = pDC->BitBlt( xDest, yDest,
       nWidthDest, nHeightDest,
          &MemDC,
       xSrc, ySrc,
       dwRop);

 MemDC.SelectObject(pOldBmp);
 pDC->SelectPalette(pOldPal, TRUE);

 return bSuccess;
}

BOOL CDib::Display(CDC * pDC, int xDest, int yDest, int nWidthDest, int nHeightDest,
       int xSrc, int ySrc, int nWidthSrc, int nHeightSrc, DWORD dwRop)
{
 CDC MemDC;
 MemDC.CreateCompatibleDC(pDC);

 CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);

 CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
    pDC->RealizePalette();

 BOOL bSuccess = pDC->StretchBlt( xDest, yDest,
        nWidthDest, nHeightDest,
              &MemDC,
        xSrc, ySrc,
        nWidthSrc, nHeightSrc,
        dwRop);

 MemDC.SelectObject(pOldBmp);
 pDC->SelectPalette(pOldPal, TRUE);

 return bSuccess;
}

BOOL CDib::Display(CDC * pDC, int x, int y, DWORD dwRop)
{
 CDC MemDC;
 MemDC.CreateCompatibleDC(pDC);

 CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);

 CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
    pDC->RealizePalette();

 BOOL bSuccess = pDC->BitBlt(x, y,
        GetWidth(), GetHeight(),
        &MemDC,
        0, 0,
        dwRop);

 MemDC.SelectObject(pOldBmp);
 pDC->SelectPalette(pOldPal, TRUE);

 return bSuccess;
}

BOOL CDib::Display(CDC* pDC, CRect rcDest, CRect rcSrc, DWORD dwRop)
{
 CDC MemDC;
 MemDC.CreateCompatibleDC(pDC);

 CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);

 CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
    pDC->RealizePalette();

 BOOL bSuccess = pDC->StretchBlt( rcDest.left, rcDest.top,
        rcDest.Width(), rcDest.Height(),
              &MemDC,
        rcSrc.left, rcSrc.top,
        rcSrc.Width(), rcSrc.Height(),
        dwRop);

 MemDC.SelectObject(pOldBmp);
 pDC->SelectPalette(pOldPal, TRUE);

 return bSuccess;
}

BOOL CDib::BuildBitmap()
{
 if (m_pBitmap != NULL)
 {
  delete m_pBitmap;
  m_pBitmap = NULL;
  m_hBitmap = NULL;
 }
 m_hBitmap = DIBToDIBSection(m_hDib);
 if (m_hBitmap == NULL)
  return FALSE;
 m_pBitmap = new CBitmap;
 m_pBitmap->Attach(m_hBitmap);

 return TRUE;
}

BOOL CDib::BuildPalette()
{
 if (m_pPalette != NULL)
 {
  delete m_pPalette;
  m_pPalette = NULL;
 }
 HPALETTE hPalette = CreateDIBPalette(m_hDib);
 if (hPalette == NULL)
  return FALSE;
 m_pPalette = new CPalette;
 m_pPalette->Attach(hPalette);

 return TRUE;
}

BOOL CDib::UpdateInternal()
{
 BuildPalette();
 return BuildBitmap();
}

CPalette* CDib::GetPalette()
{
 return m_pPalette;
}

CBitmap* CDib::GetBitmap()
{
 return m_pBitmap;
}

BOOL CDib::IsEmpty()
{
 if (m_hDib == NULL)
  return TRUE;

 if (! GlobalLock(m_hDib))
  return TRUE;

 GlobalUnlock(m_hDib);
 return FALSE;
}

DWORD CDib::GetCompression()
{
    LPBITMAPINFOHEADER lpBI = (LPBITMAPINFOHEADER)GlobalLock(m_hDib);
    if (!lpBI)
 {
  GlobalUnlock(m_hDib);
        return 0;
 }
 
 DWORD dwCompression = lpBI->biCompression;
 GlobalUnlock(m_hDib);

 return dwCompression;
}

WORD CDib::GetBitCount()
{
    LPBITMAPINFOHEADER lpBI = (LPBITMAPINFOHEADER)GlobalLock(m_hDib);
    if (!lpBI)
 {
  GlobalUnlock(m_hDib);
        return 0;
 }
 
 WORD wBitCount = lpBI->biBitCount;
 GlobalUnlock(m_hDib);

 return wBitCount;
}

LONG CDib::GetWidth()
{
 // get DIB buffer pointer
    LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib);
 if (! lpDIB)
 {
  GlobalUnlock(m_hDib);
  return 0;
 }

 LONG lWidth = (LONG)DIBWidth(lpDIB);
 GlobalUnlock(m_hDib);

 return lWidth;
}

LONG CDib::GetHeight()
{
 // get DIB buffer pointer
    LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib);
 if (! lpDIB)
 {
  GlobalUnlock(m_hDib);
  return 0;
 }

 LONG lHeight = (LONG)DIBHeight(lpDIB);
 GlobalUnlock(m_hDib);

 return lHeight;
}

LONG CDib::GetWidthBytes()
{
 return WIDTHBYTES((GetWidth())*((DWORD)GetBitCount()));
}

COLORREF CDib::GetPixel(LONG x, LONG y)
{
 COLORREF cColor;
 switch (GetBitCount())
 {
  case 1 : if (1<<(7-x%8) &
      *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)))
      cColor = RGB(255,255,255);
     else
      cColor = RGB(0,0,0);
     break;
  case 4 : 
    {
     PALETTEENTRY PaletteColors[16];
     m_pPalette->GetPaletteEntries(0, 16, PaletteColors);
     int nIndex = (*(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)) &
           (x%2 ? 0x0f : 0xf0)) >> (x%2 ? 0 : 4);
     cColor = RGB(PaletteColors[nIndex].peRed,
         PaletteColors[nIndex].peGreen,
         PaletteColors[nIndex].peBlue);
    }
     break;
  case 8 : 
    {
     PALETTEENTRY PaletteColors[256];
     m_pPalette->GetPaletteEntries(0, 256, PaletteColors);
     int nIndex = *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y));
     cColor = RGB(PaletteColors[nIndex].peRed,
         PaletteColors[nIndex].peGreen,
         PaletteColors[nIndex].peBlue);
    }
     break;
  default: cColor = RGB(*(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)),
         *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)+1),
         *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)+2));
     break;
 }
 return cColor;
}

LONG CDib::GetPixelOffset(LONG x, LONG y)
{
 return (GetHeight()-y-1)*GetWidthBytes()+x/(8/GetBitCount());
}

LPBYTE CDib::GetBitsPtr()
{
    LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib);
    if (! lpDIB)
 {
  GlobalUnlock(m_hDib);
  return NULL;
 }

 LPBYTE lpData = FindDIBBits(lpDIB);
 GlobalUnlock(m_hDib);

 return lpData;
}

HANDLE CDib::GetHandle()
{
 return m_hDib;
}

WORD CDib::GetColorNumber()
{
    LPBYTE lpBI = (LPBYTE)GlobalLock(m_hDib);
    if (! lpBI)
 {
  GlobalUnlock(m_hDib);
  return 0;
 }
 
 WORD wColors = DIBNumColors(lpBI);
 GlobalUnlock(m_hDib);

 return wColors;
}

WORD CDib::GetPaletteSize()
{
    LPBYTE lpBI = (LPBYTE)GlobalLock(m_hDib);
    if (! lpBI)
 {
  GlobalUnlock(m_hDib);
  return 0;
 }
 
 WORD wPalSize = PaletteSize(lpBI);
 GlobalUnlock(m_hDib);

 return wPalSize;
}

CDC* CDib::BeginPaint(CDC *pDC)
{
 m_pMemDC = new CDC;
 m_pMemDC->CreateCompatibleDC(pDC);
 m_pPaletteTmp = m_pMemDC->SelectPalette(m_pPalette, TRUE);
 m_pMemDC->RealizePalette();
 m_pBitmapTmp = (CBitmap *)m_pMemDC->SelectObject(m_pBitmap);
 return m_pMemDC;
}

void CDib::EndPaint()
{
 m_pMemDC->SelectObject(m_pBitmapTmp);
 m_pMemDC->SelectPalette(m_pPaletteTmp, TRUE);
 delete m_pMemDC;

 Create(m_hBitmap);
}

BOOL CDib::DisplayPalette(CDC* pDC, CRect rc)
{
 return ::DisplayPalette(pDC->GetSafeHdc(), &rc, (HPALETTE)m_pPalette->GetSafeHandle());
}

CDib * CDib::Clone()
{
 if (m_hDib == NULL)
  return NULL;

 HDIB hDIB = CopyHandle(m_hDib);
 if (hDIB == NULL)
  return NULL;

 CDib *pDib = new CDib;
 pDib->m_hDib = hDIB;
 pDib->BuildPalette();
 pDib->BuildBitmap();

 return pDib;
}