webimgview.cpp

快速处理基于 Web 的各种图象文件.zip

  {
	  *CByte = ~(*CByte);
	  CByte++;
  }
  
  GlobalUnlock(hNewDIB);  
  return hNewDIB;
}

/********************************************************************/
/***   GetDIBWidth: returns DIB's width                           ***/
/********************************************************************/
UINT CWebImgView::GetDIBWidth(HANDLE hsDIB)
{
  LPBITMAPINFOHEADER lpBI;       
  LPBITMAPINFO       lpBMI;      
  UINT               uWidth;  
  
  if (ExitingApp) return 0;
  if (!hsDIB) return 0;
  lpBMI = (LPBITMAPINFO) GlobalLock(hsDIB);  
  lpBI  = (LPBITMAPINFOHEADER) lpBMI;
  if (!lpBI) { GlobalUnlock(hsDIB); return 0;}

  uWidth = (UINT) lpBI->biWidth;  

  GlobalUnlock(hsDIB);  

  return uWidth;
}

/********************************************************************/
/***   GetDIBWidth: returns DIB's width                           ***/
/********************************************************************/
UINT CWebImgView::GetDIBStorageWidth(HANDLE hsDIB)
{
  LPBITMAPINFOHEADER lpBI;       
  LPBITMAPINFO       lpBMI;      
  UINT               uWidth;     
  
  if (ExitingApp) return 0;
  if (!hsDIB) return 0;
  lpBMI = (LPBITMAPINFO) GlobalLock(hsDIB);  
  lpBI  = (LPBITMAPINFOHEADER) lpBMI;
  if (!lpBI) { GlobalUnlock(hsDIB); return 0;}

  uWidth = (UINT) ((lpBI->biWidth + 3) & (~3));

  GlobalUnlock(hsDIB);  

  return uWidth;
}


/********************************************************************/
/***   GetDIBWidth: returns DIB's height                          ***/
/********************************************************************/
UINT CWebImgView::GetDIBHeight(HANDLE hsDIB)

{
  LPBITMAPINFOHEADER lpBI;       
  LPBITMAPINFO       lpBMI;      
  UINT               uHeight;    

  if (!hsDIB) return 0;
  lpBMI = (LPBITMAPINFO) GlobalLock(hsDIB);  
  lpBI  = (LPBITMAPINFOHEADER) lpBMI;
  if (!lpBI) { GlobalUnlock(hsDIB); return 0;}

  uHeight = (UINT) lpBI->biHeight;  

  GlobalUnlock(hsDIB);  

  return uHeight;
}

/********************************************************************/
/***   GetDIBBitPerPixel: Returns the bitdepth of the dib         ***/
/********************************************************************/
UINT CWebImgView::GetDIBBitPerPixel(HANDLE hsDIB)
{
  LPBITMAPINFOHEADER lpBI;       
  LPBITMAPINFO       lpBMI;      
  UINT               uBPP;       
  
  if (ExitingApp) return 0;
  if (!hsDIB) return 0;
  lpBMI = (LPBITMAPINFO) GlobalLock(hsDIB);  
  lpBI  = (LPBITMAPINFOHEADER) lpBMI;
  if (!lpBI) { GlobalUnlock(hsDIB); return 0;}

  uBPP = (UINT) lpBI->biBitCount;  

  GlobalUnlock(hsDIB);  

  return uBPP;
}

/********************************************************************/
/***   GetDIBBits: return the pointer to the pixels of the DIB    ***/
/********************************************************************/
BYTE * CWebImgView::GetDIBBits(LPBITMAPINFOHEADER lpBI)
{
  if (IsBadReadPtr(lpBI, sizeof(BITMAPINFOHEADER)))
    return NULL;          

  return (BYTE *) &(((LPBITMAPINFO) lpBI)->bmiColors[DibNumColors(lpBI)]);
}

/********************************************************************/
/***   CreateDIBPalette: Create a DIB Palette                     ***/
/********************************************************************/
HPALETTE CWebImgView::CreateDIBPalette(HANDLE hsDIB)
{
  LPBITMAPINFOHEADER lpBI;    
  LPBITMAPINFO       lpBMI;   
  LPLOGPALETTE       lpPal;   
  HANDLE             hPalDef; 
  HPALETTE           hPal;    
  UINT               uColors; 
  UINT               u;       
  BYTE               cRed;    
  BYTE               cGreen;  
  BYTE               cBlue;   

  if (ExitingApp) return NULL;
  if (!hsDIB) return NULL;  
  lpBMI = (LPBITMAPINFO) GlobalLock(hsDIB);  
  lpBI  = (LPBITMAPINFOHEADER) lpBMI;
  if (!lpBI) { GlobalUnlock(hsDIB); return NULL;}

  
  if (lpBI->biSize != sizeof(BITMAPINFOHEADER))
    {
     //MSGBOX("CreateDIBPalette: Invallid BITMAPINFOHEADER size!");
     GlobalUnlock(hsDIB);
     return NULL;
    }

  uColors = DibNumColors(lpBI);
  if (uColors)
    {
  
     hPalDef = GlobalAlloc(GHND, sizeof(LOGPALETTE) +
                                 uColors * sizeof(PALETTEENTRY));
     if (!hPalDef)
       {                          
        //MSGBOX("CreateDIBPalette: out of memory!");
        GlobalUnlock(hsDIB);
        return NULL;
       }
     lpPal = (LPLOGPALETTE) GlobalLock(hPalDef);
     lpPal->palNumEntries = uColors; 
     lpPal->palVersion    = 0x0300;  
     
     for (u = 0; u < uColors; u++)
       {
        lpPal->palPalEntry[u].peRed   = lpBMI->bmiColors[u].rgbRed;
        lpPal->palPalEntry[u].peGreen = lpBMI->bmiColors[u].rgbGreen;
        lpPal->palPalEntry[u].peBlue  = lpBMI->bmiColors[u].rgbBlue;
        lpPal->palPalEntry[u].peFlags = (BYTE) 0;
       }

//	 if (uColors == 2)
//	 {
//        lpPal->palPalEntry[1].peRed   = 255;
//        lpPal->palPalEntry[1].peGreen = 255;
//        lpPal->palPalEntry[1].peBlue  = 255;
//        lpPal->palPalEntry[1].peFlags = (BYTE) 0;
//	 }

     hPal = CreatePalette(lpPal);
     GlobalUnlock(hPalDef);  
     GlobalFree(hPalDef);    
     GlobalUnlock(hsDIB);
     return hPal;
    }
   else
    {
     if (lpBI->biBitCount == 24)
       {  
        uColors = 256;
        hPalDef = GlobalAlloc(GHND, sizeof(LOGPALETTE) +
                                    uColors * sizeof(PALETTEENTRY));
        if (!hPalDef)
          {
           //MSGBOX("CreateDIBPalette: out of memory!");
           GlobalUnlock(hsDIB);
           return NULL;
          }
        lpPal = (LPLOGPALETTE) GlobalLock(hPalDef);
        lpPal->palNumEntries = uColors; 
        lpPal->palVersion    = 0x0300;
        cRed   = (BYTE) 0;
        cGreen = (BYTE) 0;
        cBlue  = (BYTE) 0;
        for (u = 0; u < uColors; u++)
          {
           lpPal->palPalEntry[u].peRed   = cRed;
           lpPal->palPalEntry[u].peGreen = cGreen;
           lpPal->palPalEntry[u].peBlue  = cBlue;
           lpPal->palPalEntry[u].peFlags = (BYTE) 0;
           if (!(cRed += 32))
             if (!(cGreen += 32))
               cBlue += 64;
          }
        hPal = CreatePalette(lpPal);
        GlobalUnlock(hPalDef);  
        GlobalFree(hPalDef);    
	    GlobalUnlock(hsDIB);
        return hPal;
       }
      else
       return NULL;  
    }
}

/****************************************************************************/
/*  FUNCTION   : DibNumColors(VOID FAR * pv)                                */
/*  PURPOSE    : Determines the number of colors in the DIB by looking at   */
/*               the BitCount filed in the info block.                      */
/*  RETURNS    : The number of colors in the DIB.                           */
/****************************************************************************/
WORD CWebImgView::DibNumColors (VOID FAR * pv)
{
    INT                 bits;
    LPBITMAPINFOHEADER  lpbi;
    LPBITMAPCOREHEADER  lpbc;

    lpbi = ((LPBITMAPINFOHEADER)pv);
    lpbc = ((LPBITMAPCOREHEADER)pv);

    /*  With the BITMAPINFO format headers, the size of the palette
     *  is in biClrUsed, whereas in the BITMAPCORE - style headers, it
     *  is dependent on the bits per pixel ( = 2 raised to the power of
     *  bits/pixel).
     */
    if (lpbi->biSize != sizeof(BITMAPCOREHEADER)){
        if (lpbi->biClrUsed != 0)
            return (WORD)lpbi->biClrUsed;
        bits = lpbi->biBitCount;
    }
    else
        bits = lpbc->bcBitCount;

    switch (bits){
        case 1:
                return 2;
        case 4:
                return 16;
        case 8:
                return 256;
        default:
                /* A 24 bitcount DIB has no color table */
                return 0;
    }
}

/****************************************************************************/
/*  FUNCTION   :  PaletteSize(VOID FAR * pv)                                */
/*  PURPOSE    :  Calculates the palette size in bytes. If the info. block  */
/*                is of the BITMAPCOREHEADER type, the number of colors is  */
/*                multiplied by 3 to give the palette size, otherwise the   */
/*                number of colors is multiplied by 4.                      */                                  
/*  RETURNS    :  Palette size in number of bytes.                          */
/****************************************************************************/
WORD CWebImgView::PaletteSize (VOID FAR * pv)
{
    LPBITMAPINFOHEADER lpbi;
    WORD               NumColors;

    lpbi      = (LPBITMAPINFOHEADER)pv;
    NumColors = DibNumColors(lpbi);

    if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
        return (WORD)(NumColors * sizeof(RGBTRIPLE));
    else
        return (WORD)(NumColors * sizeof(RGBQUAD));
}


/********************************************************************/
/***                DrawDDB: Draw a DDDB to a HDC                 ***/
/********************************************************************/
BOOL CWebImgView::DrawDDB(HDC      hDC,
						  HBITMAP  hDDB,
                          HPALETTE hPal,
                          int      nX,
                          int      nY)
{
  HDC      hMemDC;    
  BITMAP   BM;        
  HPALETTE hOldPal1;  
  HPALETTE hOldPal2;  

  if (!hDDB)
    {
     return FALSE;
    }

  hMemDC = CreateCompatibleDC(hDC);
  if (!hMemDC)
    {                 
     return FALSE;
    }

  if (hPal)
    {  
     hOldPal1 = SelectPalette(hDC, hPal, FALSE);
     hOldPal2 = SelectPalette(hMemDC, hPal, FALSE);
     RealizePalette(hDC);
     RealizePalette(hMemDC);
    }

  GetObject(hDDB, sizeof(BITMAP), (LPSTR) &BM);

  SelectObject(hMemDC, hDDB);  
  BitBlt(hDC, nX, nY, BM.bmWidth, BM.bmHeight, hMemDC, 0, 0, SRCCOPY);

  if (hOldPal1)
    SelectPalette(hDC, hOldPal1, FALSE);
  if (hOldPal2)
    SelectPalette(hMemDC, hOldPal2, FALSE);
  DeleteDC(hMemDC);  

  return TRUE;
}

/********************************************************************/
/***   StretchDIB: Draws the dib STERCHED to a Device HDC            ***/
/********************************************************************/
BOOL CWebImgView::StretchDDB(HDC      hDC,
							 HANDLE   hDDB,
                             HPALETTE hPal,
                             int      nX,
                             int      nY,
                             UINT     uWidth,
                             UINT     uHeight)
{
  HDC      hMemDC;    
  BITMAP   BM;        
  HPALETTE hOldPal1;  
  HPALETTE hOldPal2;  

  if (!hDDB)
    {
     return FALSE;
    }

  hMemDC = CreateCompatibleDC(hDC);
  if (!hMemDC)
    {
     return FALSE;
    }

  if (hPal)
    {  
     hOldPal1 = SelectPalette(hDC, hPal, FALSE);
     hOldPal2 = SelectPalette(hMemDC, hPal, FALSE);
     RealizePalette(hDC);
     RealizePalette(hMemDC);
    }

  GetObject(hDDB, sizeof(BITMAP), (LPSTR) &BM);

  SetStretchBltMode(hDC, COLORONCOLOR);
  SelectObject(hMemDC, hDDB);  
  StretchBlt(hDC, nX, nY, uWidth, uHeight, hMemDC,
             0, 0, BM.bmWidth, BM.bmHeight, SRCCOPY);

  if (hOldPal1)
    SelectPalette(hDC, hOldPal1, FALSE);
  if (hOldPal2)
    SelectPalette(hMemDC, hOldPal2, FALSE);
  DeleteDC(hMemDC);  

  return TRUE;
}


/********************************************************************/
/***   DrawDIB: Draws the dib NOT stretched to a Device HDC       ***/
/********************************************************************/
BOOL CWebImgView::DrawDIB(HDC	  hDC,
					 	  HANDLE   hsDIB,
					 	  HPALETTE hPal,
					 	  int      nX,
					 	  int      nY)
{
  LPBITMAPINFOHEADER lpBI;     
  LPBITMAPINFO       lpBMI;    
  BYTE               *lpBits;   
  UINT               uWidth;   
  UINT               uHeight;  
  HPALETTE           hOldPal;  

  if (ExitingApp) return false;
  if (!hsDIB) return false;
  lpBMI = (LPBITMAPINFO) GlobalLock(hsDIB);  
  lpBI  = (LPBITMAPINFOHEADER) lpBMI;
  if (!lpBI) { GlobalUnlock(hsDIB); return false;}

  lpBits = GetDIBBits(lpBI);

  uWidth  = (UINT) lpBI->biWidth;
  uHeight = (UINT) lpBI->biHeight;

  if (hPal)
    {  
     hOldPal = SelectPalette(hDC, hPal, FALSE);
     RealizePalette(hDC);
    }

  SetDIBitsToDevice(hDC, 
	                nX, 
					nY, 
					uWidth, 
					uHeight, 
					0, 
					0, 
					0, 
					uHeight,
                    lpBits, 
					lpBMI, DIB_RGB_COLORS);

  if (hOldPal)
    SelectPalette(hDC, hOldPal, FALSE);
  GlobalUnlock(hsDIB);     

  return true;
}

/********************************************************************/
/***   StretchDIB: Draws the dib STRETCHED to a Device HDC        ***/
//*******************************************************************/