开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
DibUtil.cpp
资源名称：gloop.zip　[点击查看]
上传用户：shxiangxiu
上传日期：2007-01-03
资源大小：1101k
文件大小：93k
源码类别：

OpenGL

开发平台：

Visual C++

DibUtil.cpp：源码内容
  1. ////////////////////////////////////////////////////////////////////////////
  2. // DibUtil.cpp : Defines the global Device Independent Bitmap (dib) functions
  3. //    for the application.
  4. //
  5. // glOOP (OpenGL Object Oriented Programming library)
  6. // Copyright (c) Craig Fahrnbach 1997, 1998
  7. //
  8. // OpenGL is a registered trademark of Silicon Graphics
  9. //
  10. //
  11. // This program is provided for educational and personal use only and
  12. // is provided without guarantee or warrantee expressed or implied.
  13. //
  14. // Commercial use is strickly prohibited without written permission
  15. // from ImageWare Development.
  16. //
  17. // This program is -not- in the public domain.
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "glOOP.h"
  23. #include "DibUtil.h"
  26. /******************************************************************************
  27.  *                                                                            *
  28.  *  FUNCTION   :CountBits(DWORD dw)                                           *
  29.  *                                                                            *
  30.  *  PURPOSE    :Count the number of set bits in a given DWORD                 * 
  31.  *                                                                            *
  32.  *  *NOTE:     :Used only in CreateBIPalette() for extracting RGB values      *
  33.  *              from 16 and 32bpp DIBS                                        *
  34.  *                                                                            *
  35.  *****************************************************************************/
  36. BYTE  CountBits(DWORD dw)
  37. {
  38.   int i, Count = 0;
  40.   for (i=0; i<sizeof(DWORD) * 8; i++)
  41.     Count += (((1 << i) & dw) != 0);
  43.   return Count;
  46. }
  48. /******************************************************************************
  49.  *                                                                            *
  50.  *  FUNCTION   :CountBits(DWORD dw)                                           *
  51.  *                                                                            *
  52.  *  PURPOSE    :Count the number of set bits in a given DWORD                 * 
  53.  *                                                                            *
  54.  *  *NOTE:     :Used only in CreateBIPalette() for extracting RGB values      *
  55.  *              from 16 and 32bpp DIBS                                        *
  56.  *                                                                            *
  57.  *****************************************************************************/
  58. BYTE RightmostBit(DWORD dw)
  59. {
  60.   int i;
  62.   for (i=0; i<sizeof(DWORD) * 8; i++)
  63.     if (((1 << i) & dw) != 0)
  64.       return i;
  66.   return (BYTE)-1; // No bits are set
  68. }
  70. /******************************************************************************
  71.  *                                                                            *
  72.  *  FUNCTION   :LeftmostBit(DWORD dw)                                         *
  73.  *                                                                            *
  74.  *  PURPOSE    :Returns the position of the leftmost set bit in a DWORD       * 
  75.  *                                                                            *
  76.  *  *NOTE:     :Used only in CreateBIPalette() for extracting RGB values      *
  77.  *              from 16 and 32bpp DIBS                                        *
  78.  *                                                                            *
  79.  *****************************************************************************/
  80. BYTE LeftmostBit(DWORD dw)
  81. {
  82.   int i;
  84.   for (i=(sizeof(DWORD) * 8)-1; i >= 0; i--)
  85.     if (((1 << i) & dw) != 0)
  86.       return i;
  88.   return (BYTE)-1; // No bits are set
  89. }
  92. /******************************************************************************
  93.  *                                                                            *
  94.  *  FUNCTION   :ValidMask(DWORD dw)                                           *
  95.  *                                                                            *
  96.  *  PURPOSE    :Determines if a given DWORD is valid as a color mask for      * 
  97.  *              16 or 32bpp DIBS (are all the set bits contiguous)            *
  98.  *                                                                            *
  99.  *  *NOTE:     :Used only in CreateBIPalette()                                *
  100.  *                                                                            *
  101.  *****************************************************************************/
  102. BOOL ValidMask(DWORD dw)
  103. {
  104.   int iStart, iStop, i;
  105.   
  106.   iStart = LeftmostBit(dw);
  107.   iStop  = RightmostBit(dw);
  109.   if (iStart == iStop)
  110.     return TRUE;
  112.   for (i=iStart; i>=iStop; i--) 
  113.      if (((1 << i) & dw) == 0)
  114.        return FALSE;
  116.   return TRUE;
  117. }
  119. /******************************************************************************
  120.  *                                                                            *
  121.  * FUNCTION   : GlobalFreeDIB(HGLOBAL hDIB)                                  *
  122.  *                                                                            *
  123.  * PURPOSE    : Free the specified global memory object and invalidate       *
  124.  *  its handle.                                                  *
  125.  *                                                                            *
  126.  * RETURNS    : If the function succeeds, the return value is NULL.          *
  127.  *  If the function fails, the return value is equal to the      *
  128.  *  handle of the global memory object. To get extended error    *
  129.  *  information, call GetLastError.                              *
  130.  *                                                                            *
  131.  *****************************************************************************/
  132. HGLOBAL GlobalFreeDIB(HGLOBAL hDIB)
  133. {
  134.    LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER)hDIB;
  136.    if (!lpbi->biClrImportant)
  137.      return GlobalFree(hDIB);
  139.    if (GlobalFlags((HGLOBAL)lpbi->biClrImportant) == GMEM_INVALID_HANDLE) {
  140.     SetLastError(0);
  141.     return GlobalFree(hDIB);
  142.   } else
  143.     return GlobalFree((HANDLE)lpbi->biClrImportant); 
  144. }
  146. /******************************************************************************
  147.  *                                                                            *
  148.  *  FUNCTION   :OpenDIB(LPSTR szFilename)                                     *
  149.  *                                                                            *
  150.  *  PURPOSE    :Open a DIB file and create a memory DIB -- a memory handle    *
  151.  *              containing BITMAPINFO, palette data and the bits.             * 
  152.  *                                                                            *
  153.  *  RETURNS    :A handle to the DIB.                                          *
  154.  *                                                                            *
  155.  *****************************************************************************/
  157. HANDLE OpenDIB(LPSTR szFilename)
  158. {
  159.     HFILE               hFile;
  160.     BITMAPINFOHEADER    bih;
  161.     LPBITMAPINFOHEADER  lpbih;
  162.     DWORD               dwLen = 0;
  163.     DWORD               dwBits;
  164.     HANDLE              hDIB;
  165.     HANDLE              hMem;
  166.     OFSTRUCT            of;
  168.     /* Open the file and read the DIB information */
  169.     hFile = OpenFile(szFilename, &of, (UINT)OF_READ);
  170.     if (hFile == HFILE_ERROR)
  171. {
  172. if(the3dEngine.m_bDisplayErrorMessages)
  173. {
  174. LPVOID lpMsgBuf;
  175. char buf[128];
  177. FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  178.   NULL,
  179.   GetLastError(),
  180.   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
  181.   (LPTSTR) &lpMsgBuf,
  182.   0,
  183.   NULL);
  185. // Display the string.
  186. sprintf(buf, "Error reading file '%s'.nn Error: %sn", szFilename, lpMsgBuf);
  187. MessageBox( NULL, buf, "OpenDIB File Error!", MB_OK|MB_ICONINFORMATION );
  189. // Free the buffer.
  190. LocalFree( lpMsgBuf );
  191. }
  192.     
  193. return NULL;
  194. }
  196.     hDIB = ReadDIBBitmapInfo(hFile);
  197.     if (!hDIB)
  198.         return NULL;
  199.     DIBInfo(hDIB, &bih);
  201.     /* Calculate the memory needed to hold the DIB */
  202.     dwBits = bih.biSizeImage;
  203.     dwLen  = bih.biSize + (DWORD)ColorTableSize (&bih) + dwBits;
  205.     /* Try to increase the size of the bitmap info. buffer to hold the DIB */
  206.     hMem = GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE);
  208.     if (!hMem){
  209.         GlobalFreeDIB(hDIB);
  210.         hDIB = NULL;
  211.     }
  212.     else
  213.         hDIB = hMem;
  215.     /* Read in the bits */
  216.     if (hDIB){
  217.         lpbih = (LPBITMAPINFOHEADER)hDIB;
  218.         _hread(hFile, (LPSTR)lpbih + (WORD)lpbih->biSize + ColorTableSize(lpbih), dwBits);
  219.     }
  220.     _lclose(hFile);
  222.     return hDIB;
  223. }
  225. /******************************************************************************
  226.  *                                                                            *
  227.  *  FUNCTION   : WriteDIB(LPSTR szFilename, HANDLE hDIB)                      *
  228.  *                                                                            *
  229.  *  PURPOSE    : Write a global handle in CF_DIB format to a file.            *
  230.  *                                                                            *
  231.  *  RETURNS    : TRUE  - if successful.                                       *
  232.  *               FALSE - otherwise                                            *
  233.  *                                                                            *
  234.  *****************************************************************************/
  236. BOOL WriteDIB(LPSTR szFilename, HANDLE hDIB)
  237. {
  238.     BITMAPFILEHEADER    bmfhdr;
  239.     LPBITMAPINFOHEADER  lpbih;
  240.     HFILE               hFile;
  241.     OFSTRUCT            of;
  243.     if (!hDIB)
  244.         return FALSE;
  246.     hFile = OpenFile(szFilename, &of, (UINT)OF_CREATE|OF_READWRITE);
  247.     if (hFile == HFILE_ERROR)
  248.         return FALSE;
  250.     lpbih = (LPBITMAPINFOHEADER)hDIB;
  252.     /* Fill in the fields of the file header */
  253.     bmfhdr.bfType          = BFT_BITMAP;
  254.     bmfhdr.bfSize          = GlobalSize (hDIB) + SIZEOF_BITMAPFILEHEADER_PACKED;
  255.     bmfhdr.bfReserved1     = 0;
  256.     bmfhdr.bfReserved2     = 0;
  257.     bmfhdr.bfOffBits       = (DWORD)(SIZEOF_BITMAPFILEHEADER_PACKED + 
  258.                                   lpbih->biSize + ColorTableSize(lpbih));
  260.     WritePackedFileHeader(hFile, &bmfhdr);
  262.     /* Write the DIB header and the bits */
  263.     _hwrite (hFile, (LPSTR)lpbih, GlobalSize (hDIB));
  265.     _lclose(hFile);
  266.  
  267.     return TRUE;
  268. }
  270. /******************************************************************************
  271.  *                                                                            *
  272.  *  FUNCTION  : WriteDIBEx(LPSTR szFilename, HANDLE hDIB,                     *
  273.  *                         WORD wBPP, DWORD dwComp)                           *                           
  274.  *                                                                            *
  275.  *  PURPOSE   : Write a global handle in CF_DIB format to a file with a       *
  276.  *              specified pixel depth and compression format                  *
  277.  *                                                                            *
  278.  *  RETURNS   : TRUE  - if successful.                                        *
  279.  *              FALSE - otherwise                                             *
  280.  *                                                                            *
  281.  *****************************************************************************/
  283. BOOL WriteDIBEx(LPSTR szFilename, HANDLE hDIB, WORD wBPP, DWORD dwComp)
  284. {
  285.     BITMAPINFOHEADER bih;
  286.     HANDLE hNewDIB;
  287.     BOOL bReturn;
  289.     DIBInfo(hDIB, &bih);
  291.     if (((bih.biBitCount == wBPP) && (dwComp == bih.biCompression)) || ((wBPP == 0) && (dwComp == 0)))
  292.        return WriteDIB(szFilename, hDIB);
  294.     hNewDIB = CopyDIB(hDIB);
  296. //    StartWait();
  297.     
  298.     hDIB = ChangeDIBFormat(hNewDIB, wBPP, dwComp);
  299.     if (hDIB) {
  300.       bReturn = WriteDIB(szFilename, hDIB);
  301.       GlobalFreeDIB(hDIB);
  302.     } else {
  303.       bReturn = FALSE;
  304.       GlobalFreeDIB(hNewDIB);
  305.     }
  307. //    EndWait();
  308.      
  309.     return bReturn;
  310.  }
  312. /******************************************************************************
  313.  *                                                                            *
  314.  *  FUNCTION   : DIBInfo(HANDLE hbi, LPBITMAPINFOHEADER lpbih)                *
  315.  *                                                                            *
  316.  *  PURPOSE    : Retrieves the DIB info associated with a CF_DIB              *
  317.  *               format memory block.                                         *
  318.  *                                                                            *
  319.  *  RETURNS    : TRUE  - if successful.                                       *
  320.  *               FALSE - otherwise                                            *
  321.  *                                                                            *
  322.  *****************************************************************************/
  323. BOOL DIBInfo(HANDLE hbi, LPBITMAPINFOHEADER lpbih)
  324. {
  325.     if (hbi){
  326.       *lpbih = *(LPBITMAPINFOHEADER)hbi;
  328.       /* fill in the default fields */
  329.       if (NEW_DIB_FORMAT(lpbih)) {
  330.         if (lpbih->biSizeImage == 0L)
  331.           lpbih->biSizeImage = WIDTHBYTES(lpbih->biWidth*lpbih->biBitCount) * lpbih->biHeight;
  333.         if (lpbih->biClrUsed == 0L)
  334.           lpbih->biClrUsed = DIBNumColors (lpbih);
  335.       }
  337.       return TRUE;
  338.     }
  339.     return FALSE;
  340. }
  343. /******************************************************************************
  344.  *                                                                            *
  345.  *  FUNCTION   : CreateBIPalette(LPBITMAPINFOHEADER lpbih)                    *
  346.  *                                                                            *
  347.  *  PURPOSE    : Given a Pointer to a BITMAPINFO struct will create a         *
  348.  *               a GDI palette object from the color table.                   *
  349.  *                                                                            *
  350.  *  RETURNS    : A handle to the palette.                                     *
  351.  *                                                                            *
  352.  *****************************************************************************/
  353.               
  354. HPALETTE CreateBIPalette(LPBITMAPINFOHEADER lpbih)
  355. {
  356.     HPALETTE       hPal = NULL;
  357.     WORD           nNumColors;
  358.     LPRGBQUAD      lprgbq;
  360.     if (!lpbih)
  361.         return NULL;
  363.     if (!NEW_DIB_FORMAT(lpbih))  // Return if we dont have a BITMAPINFOHEADER
  364.         return NULL;
  366.     /* Get a pointer to the color table and the number of colors in it */
  367.     lprgbq = (LPRGBQUAD)((LPSTR)lpbih + (WORD)lpbih->biSize);
  368.     /* Adjust pointer for cases where BITFIELDS bitmaps might contain an optimal palette */
  369.     if (lpbih->biCompression == BI_BITFIELDS)
  370.       lprgbq = (LPRGBQUAD)((LPDWORD)lprgbq + 3); 
  371.     nNumColors = DIBNumColors(lpbih);
  372. lpbih->biClrUsed = nNumColors;
  374.     if (nNumColors)   /* Create a palette from the entries in the DIBs color table */
  375.         hPal = CreatePaletteFromRGBQUAD(lprgbq, nNumColors);
  376.     else 
  377.         {
  378.           HDC hDC = GetDC(NULL);
  379.           hPal = CreateHalftonePalette(hDC);
  380.           ReleaseDC(NULL, hDC);
  381.         } ;
  382.   
  383.     return hPal;
  384. }
  386. /******************************************************************************
  387.  *                                                                            *
  388.  *  FUNCTION   : ReadDIBBitmapInfo(int hFile)                                 *
  389.  *                                                                            *
  390.  *  PURPOSE    : Will read a file in DIB format and return a global HANDLE    *
  391.  *               to it's BITMAPINFO.  This function will work with both       *
  392.  *               "old" (BITMAPCOREHEADER) and "new" (BITMAPINFOHEADER)        *
  393.  *               bitmap formats, but will always return a "new" BITMAPINFO    *
  394.  *                                                                            *
  395.  *  RETURNS    : A handle to the BITMAPINFO of the DIB in the file.           *
  396.  *                                                                            *
  397.  *****************************************************************************/
  398. HANDLE ReadDIBBitmapInfo(INT hFile)
  399. {
  400.     DWORD              dwOffset;
  401.     HANDLE             hbi = NULL;
  402.     INT                size;
  403.     INT                i;
  404.     WORD               nNumColors;
  405.     LPRGBQUAD          lprgbq;
  406.     BITMAPINFOHEADER   bih;
  407.     BITMAPCOREHEADER   bch;
  408.     LPBITMAPINFOHEADER lpbih;
  409.     BITMAPFILEHEADER   bf;
  410.     DWORD              dwDWMasks= 0;
  411.     DWORD              dwWidth = 0;
  412.     DWORD              dwHeight = 0;
  413.     WORD               wPlanes, wBitCount;
  415.     if (hFile == HFILE_ERROR)
  416.         return NULL;
  418.     /* Read the bitmap file header */
  419.     ReadPackedFileHeader(hFile, &bf, &dwOffset);
  421.     /* Do we have a RC HEADER? */
  422.     if (!ISDIB (bf.bfType)) {    
  423.       bf.bfOffBits = 0L;               
  424.         _llseek(hFile, dwOffset, (UINT)SEEK_SET); /* seek back to beginning of file */
  425.     }
  427.     if (sizeof(bih) != _hread(hFile, (LPSTR)&bih, (UINT)sizeof(bih)))
  428.       return FALSE;
  430.     nNumColors = DIBNumColors (&bih);
  432.     /* Check the nature (BITMAPINFO or BITMAPCORE) of the info. block
  433.      * and extract the field information accordingly. If a BITMAPCOREHEADER, 
  434.      * transfer it's field information to a BITMAPINFOHEADER-style block
  435.      */
  436.     switch (size = (INT)bih.biSize){
  437.         case sizeof (BITMAPINFOHEADER):
  438.             break;
  440.         case sizeof (BITMAPCOREHEADER):
  442.             bch = *(LPBITMAPCOREHEADER)&bih;
  444.             dwWidth   = (DWORD)bch.bcWidth;
  445.             dwHeight  = (DWORD)bch.bcHeight;
  446.             wPlanes   = bch.bcPlanes;
  447.             wBitCount = bch.bcBitCount;
  449.             bih.biSize           = sizeof(BITMAPINFOHEADER);
  450.             bih.biWidth          = dwWidth;
  451.             bih.biHeight         = dwHeight;
  452.             bih.biPlanes         = wPlanes;
  453.             bih.biBitCount       = wBitCount;
  454.             bih.biCompression    = BI_RGB;
  455.             bih.biSizeImage      = 0;
  456.             bih.biXPelsPerMeter  = 0;
  457.             bih.biYPelsPerMeter  = 0;
  458.             bih.biClrUsed        = nNumColors;
  459.             bih.biClrImportant   = nNumColors;
  461.             _llseek(hFile, (LONG)sizeof (BITMAPCOREHEADER) - sizeof (BITMAPINFOHEADER), (UINT)SEEK_CUR);
  462.             break;
  464.         default:
  465.             /* Not a DIB! */
  466.             return NULL;
  467.     }
  469.     /*  Fill in some default values if they are zero */
  470.     if (bih.biSizeImage == 0){
  471.         bih.biSizeImage = WIDTHBYTES((DWORD)bih.biWidth * bih.biBitCount) * bih.biHeight;
  472.     }
  473.     if (bih.biClrUsed == 0)
  474.         bih.biClrUsed = DIBNumColors(&bih);
  476.     /* Allocate for the BITMAPINFO structure and the color table. */
  477.     if ((bih.biBitCount == 16) || (bih.biBitCount == 32))
  478.       dwDWMasks = sizeof(DWORD) * 3;
  479.     hbi = GlobalAlloc (GPTR, (LONG)bih.biSize + nNumColors * sizeof(RGBQUAD) + dwDWMasks);
  480.     if (!hbi)
  481.         return NULL;
  482.     lpbih = (LPBITMAPINFOHEADER)hbi;
  483.     *lpbih = bih;
  485.     /* Get a pointer to the color table */
  486.     lprgbq = (LPRGBQUAD)((LPSTR)lpbih + bih.biSize);
  487.     if (nNumColors){
  488.         if (size == sizeof(BITMAPCOREHEADER)){
  489.             /* Convert a old color table (3 byte RGBTRIPLEs) to a new
  490.              * color table (4 byte RGBQUADs)
  491.              */
  492.             _hread(hFile, (LPSTR)lprgbq, (UINT)nNumColors * sizeof(RGBTRIPLE));
  494.             for (i = nNumColors - 1; i >= 0; i--){
  495.                 RGBQUAD rgbq;
  497.                 rgbq.rgbRed      = ((RGBTRIPLE*)lprgbq)[i].rgbtRed;
  498.                 rgbq.rgbBlue     = ((RGBTRIPLE*)lprgbq)[i].rgbtBlue;
  499.                 rgbq.rgbGreen    = ((RGBTRIPLE*)lprgbq)[i].rgbtGreen;
  500.                 rgbq.rgbReserved = (BYTE)0;
  502.                 lprgbq[i] = rgbq;
  503.             }
  504.         }
  505.         else
  506.             _hread(hFile, (LPSTR)lprgbq, (UINT)nNumColors * sizeof(RGBQUAD));
  507.     } else
  508.         if (dwDWMasks)
  509.            _hread(hFile, (LPSTR)lprgbq, dwDWMasks);
  511.     if (bf.bfOffBits != 0L){
  512.         _llseek(hFile, dwOffset + bf.bfOffBits, (UINT)SEEK_SET);
  513.         }
  514.     
  515.     return hbi;
  516. }
  519. /******************************************************************************
  520.  *                                                                            *
  521.  *  FUNCTION   :  ColorTableSize(LPVOID lpv)                                  *
  522.  *                                                                            *
  523.  *  PURPOSE    :  Calculates the palette size in bytes. If the info. block    *
  524.  *                is of the BITMAPCOREHEADER type, the number of colors is    *
  525.  *                multiplied by 3 to give the palette size, otherwise the     *
  526.  *                number of colors is multiplied by 4.                        *
  527.  *                                                                            *
  528.  *  RETURNS    :  Color table size in number of bytes.                        *
  529.  *                                                                            *
  530.  *****************************************************************************/
  531. WORD ColorTableSize(LPVOID lpv)
  532. {
  533.     LPBITMAPINFOHEADER lpbih = (LPBITMAPINFOHEADER)lpv;
  534.     
  535.     if (NEW_DIB_FORMAT(lpbih))
  536.     {
  537.       if (((LPBITMAPINFOHEADER)(lpbih))->biCompression == BI_BITFIELDS)
  538.          /* Remember that 16/32bpp dibs can still have a color table */
  539.          return (sizeof(DWORD) * 3) + (DIBNumColors (lpbih) * sizeof (RGBQUAD));
  540.       else
  541.          return (DIBNumColors (lpbih) * sizeof (RGBQUAD));
  542.     }
  543.     else
  544.       return (DIBNumColors (lpbih) * sizeof (RGBTRIPLE));
  545. }
  548. /******************************************************************************
  549.  *                                                                            *
  550.  *  FUNCTION   : DIBNumColors(LPVOID lpv)                                     *
  551.  *                                                                            *
  552.  *  PURPOSE    : Determines the number of colors in the DIB by looking at     *
  553.  *               the BitCount and ClrUsed fields in the info block.           *
  554.  *                                                                            *
  555.  *  RETURNS    : The number of colors in the DIB. With DIBS with more than    *
  556.  *               8-bits-per-pixel that have a color table table included,     *
  557.  *               then the return value will be the number of colors in the    *
  558.  *               color table rather than the number of colors in the DIB.     *
  559.  *                                                                            *
  560.  *                                                                            *
  561.  *****************************************************************************/
  562. WORD DIBNumColors(LPVOID lpv)
  563. {
  564.     INT                 bits;
  565.     LPBITMAPINFOHEADER  lpbih = (LPBITMAPINFOHEADER)lpv;
  566.     LPBITMAPCOREHEADER  lpbch = (LPBITMAPCOREHEADER)lpv;
  568.     /*  With the BITMAPINFO format headers, the size of the palette
  569.      *  is in biClrUsed, whereas in the BITMAPCORE - style headers, it
  570.      *  is dependent on the bits per pixel ( = 2 raised to the power of
  571.      *  bits/pixel).
  572.      */
  573.     if (NEW_DIB_FORMAT(lpbih)) {
  574.       if (lpbih->biClrUsed != 0)
  575.         return (WORD)lpbih->biClrUsed;
  576.       bits = lpbih->biBitCount;
  577.     }
  578.     else
  579.       bits = lpbch->bcBitCount;
  581.     if (bits > 8) 
  582.       return 0; /* Since biClrUsed is 0, we dont have a an optimal palette */
  583.     else
  584.       return (1 << bits); 
  585. }
  588. /******************************************************************************
  589.  *                                                                            *
  590.  *  FUNCTION   : DIBFromBitmap()                                              *
  591.  *                                                                            *
  592.  *  PURPOSE    : Will create a global memory block in DIB format that         *
  593.  *               represents the Device-dependent bitmap (DDB) passed in.      *
  594.  *                                                                            *
  595.  *  RETURNS    : A handle to the DIB                                          *
  596.  *                                                                            *
  597.  *****************************************************************************/
  598. HANDLE DIBFromBitmap(HBITMAP hBitmap, DWORD biStyle, WORD biBits, HPALETTE hPal)
  599. {
  600.     BITMAP               Bitmap;
  601.     BITMAPINFOHEADER     bih;
  602.     LPBITMAPINFOHEADER   lpbih;
  603.     DWORD                dwLen;
  604.     HANDLE               hDIB;
  605.     HANDLE               hMem;
  606.     HDC                  hDC;
  608.     if (!hBitmap)
  609.         return NULL;
  611.     if (hPal == NULL)
  612.         hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);
  614.     GetObject(hBitmap, sizeof(Bitmap), (LPSTR)&Bitmap);
  616.     if (biBits == 0)
  617.         biBits =  Bitmap.bmPlanes * Bitmap.bmBitsPixel;
  619.     bih.biSize            = sizeof(BITMAPINFOHEADER);
  620.     bih.biWidth           = Bitmap.bmWidth;
  621.     bih.biHeight          = Bitmap.bmHeight;
  622.     bih.biPlanes          = 1;
  623.     bih.biBitCount        = biBits;
  624.     bih.biCompression     = biStyle;
  625.     bih.biSizeImage       = 0;
  626.     bih.biXPelsPerMeter   = 0;
  627.     bih.biYPelsPerMeter   = 0;
  628.     bih.biClrUsed         = 0;
  629.     bih.biClrImportant    = 0;
  631.     dwLen  = bih.biSize + ColorTableSize(&bih);
  633.     hDC = GetDC(NULL);
  634.     hPal = SelectPalette(hDC, hPal, FALSE);
  635.     RealizePalette(hDC);
  637.     hDIB = GlobalAlloc(GPTR, dwLen);
  639.     if (!hDIB) {
  640.         SelectPalette(hDC, hPal, FALSE);
  641.         ReleaseDC(NULL, hDC);
  642.         return NULL;
  643.     }
  645.     lpbih = (LPBITMAPINFOHEADER)hDIB;
  647.     *lpbih = bih;
  649.     /*  call GetDIBits with a NULL lpBits param, so it will calculate the
  650.      *  biSizeImage field for us
  651.      */
  652.     GetDIBits(hDC, 
  653.               hBitmap, 
  654.               (UINT)0, 
  655.               (UINT)bih.biHeight, 
  656.               (LPVOID)NULL, 
  657.               (LPBITMAPINFO)lpbih, 
  658.               DIB_RGB_COLORS);
  660.     bih = *lpbih;
  662.     /* If the driver did not fill in the biSizeImage field, make one up */
  663.     if (bih.biSizeImage == 0){
  664.         bih.biSizeImage = WIDTHBYTES((DWORD)Bitmap.bmWidth * biBits) * Bitmap.bmHeight;
  666.         if (biStyle != BI_RGB)
  667.             bih.biSizeImage = (bih.biSizeImage * 3) / 2;
  668.     }
  670.     /*  realloc the buffer big enough to hold all the bits */
  671.     dwLen = bih.biSize + ColorTableSize(&bih) + bih.biSizeImage;
  672.     if (hMem = GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE))
  673.         hDIB = hMem;
  674.     else {
  675.         GlobalFreeDIB(hDIB);
  676.         hDIB = NULL;
  678.         SelectPalette(hDC, hPal, FALSE);
  679.         ReleaseDC(NULL, hDC);
  680.         return hDIB;
  681.     }
  683.     /*  call GetDIBits with a NON-NULL lpBits param, and actualy get the
  684.      *  bits this time
  685.      */
  686.     lpbih = (LPBITMAPINFOHEADER)hDIB;
  688.     if (!GetDIBits(hDC, 
  689.                    hBitmap, 
  690.                    (UINT)0, 
  691.                    (UINT)bih.biHeight, 
  692.                    (LPBYTE)lpbih + (WORD)lpbih->biSize + ColorTableSize(lpbih), 
  693.                    (LPBITMAPINFO)lpbih, 
  694.                    DIB_RGB_COLORS)) {
  695.          hDIB = NULL;
  696.          SelectPalette(hDC, hPal, FALSE);
  697.          ReleaseDC(NULL, hDC);
  698.          return NULL;
  699.     }
  701.     bih = *lpbih;
  703.     SelectPalette(hDC, hPal, FALSE);
  704.     ReleaseDC(NULL, hDC);
  706.     return hDIB;
  707. }
  710. /******************************************************************************
  711.  *                                                                            *
  712.  *  FUNCTION   : BitmapFromDIB(HANDLE hDIB, HPALETTE hPal)                    *
  713.  *                                                                            *
  714.  *  PURPOSE    : Will create a DDB (Device Dependent Bitmap) given a global   *
  715.  *               handle to a memory block in CF_DIB format                    *
  716.  *                                                                            *
  717.  *  RETURNS    : A handle to the DDB.                                         *
  718.  *                                                                            *
  719.  *****************************************************************************/
  720. HBITMAP BitmapFromDIB(HANDLE hDIB, HPALETTE hPal)
  721. {
  722.     LPBITMAPINFOHEADER  lpbih;
  723.     HPALETTE            hPalOld;
  724.     HDC                 hDC;
  725.     HBITMAP             hBitmap;  
  727. //    StartWait();
  729.     if (!hDIB)
  730.         return NULL;
  732.     lpbih = (LPBITMAPINFOHEADER)hDIB;
  734.     if (!lpbih)
  735.         return NULL;
  737.     hDC = GetDC(NULL);
  739.     if (hPal){
  740.         hPalOld = SelectPalette(hDC, hPal, FALSE);
  741.         RealizePalette(hDC);     // GDI Bug...????
  742.     }                              
  743.    
  744.     hBitmap = CreateDIBitmap(hDC, 
  745.                 lpbih, 
  746.                 CBM_INIT, 
  747.                 (LPSTR)lpbih + lpbih->biSize + ColorTableSize(lpbih), 
  748.                 (LPBITMAPINFO)lpbih, 
  749.                 DIB_RGB_COLORS ); 
  751.     if (hPal)
  752.         SelectPalette(hDC, hPalOld, FALSE);
  754.     ReleaseDC(NULL, hDC);
  756. //    EndWait();
  758.     return hBitmap;
  759. }
  762. /******************************************************************************
  763.  *                                                                            *
  764.  *  FUNCTION   : DrawBitmap(HDC hDC, int x, int y,                            *
  765.  *                          HBITMAP hBitmap, DWORD dwROP)                     * 
  766.  *                                                                            *
  767.  *  PURPOSE    : Draws bitmap <hBitmap> at the specifed position in DC <hDC>  *
  768.  *                                                                            *
  769.  *  RETURNS    : Return value of BitBlt()                                     *
  770.  *                                                                            *
  771.  *****************************************************************************/
  772. BOOL DrawBitmap(HDC hDC, INT x, INT y, HBITMAP hBitmap, DWORD dwROP)
  773. {
  774.     HDC       hDCBits;
  775.     BITMAP    Bitmap;
  776.     BOOL      bResult;
  778.     if (!hDC || !hBitmap)
  779.         return FALSE;
  781.     hDCBits = CreateCompatibleDC(hDC);
  782.     GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&Bitmap);
  783.     SelectObject(hDCBits, hBitmap);
  784.     bResult = BitBlt(hDC, x, y, Bitmap.bmWidth, Bitmap.bmHeight, hDCBits, 0, 0, dwROP);
  785.     DeleteDC(hDCBits);
  787.     return bResult;
  788. }
  791. /******************************************************************************
  792.  *                                                                            *
  793.  *  FUNCTION   : DIBBlt( HDC hDC,                                             *
  794.  *                       int x0, int y0,                                      *
  795.  *                       int dx, int dy,                                      *
  796.  *                       HANDLE hDIB,                                         *
  797.  *                       int x1, int y1,                                      *
  798.  *                       LONG dwROP)                                          *
  799.  *                                                                            *
  800.  *  PURPOSE    : Draws a bitmap in CF_DIB format, using SetDIBits to device.  *
  801.  *               taking the same parameters as BitBlt().                      *
  802.  *                                                                            *
  803.  *  RETURNS    : TRUE  - if function succeeds.                                *
  804.  *               FALSE - otherwise.                                           *
  805.  *                                                                            *
  806.  ******************************************************************************/
  807. BOOL DIBBlt (HDC hDC,     INT x0, INT y0, INT dx, INT dy, 
  808.   HANDLE hDIB, INT x1, INT y1, LONG  dwROP)
  809. {
  810.     LPBITMAPINFOHEADER   lpbih;
  811.     LPSTR                pBuf;
  813.     if (!hDIB)
  814.         return PatBlt(hDC, x0, y0, dx, dy, dwROP);
  816.     lpbih = (LPBITMAPINFOHEADER)hDIB;
  818.     if (!lpbih)
  819.         return FALSE;
  821.     pBuf = (LPSTR)lpbih + (WORD)lpbih->biSize + ColorTableSize(lpbih);
  822.     SetDIBitsToDevice (hDC, x0, y0, dx, dy, 
  823.                        x1, y1, 
  824.                        x1, 
  825.                        dy, 
  826.                        pBuf, (LPBITMAPINFO)lpbih, 
  827.                        DIB_RGB_COLORS );
  829.     return TRUE;
  830. }
  832. /******************************************************************************
  833.  *                                                                            *
  834.  *  FUNCTION   : StretchDIBBlt( HDC hDC,                                      *
  835.  *                              int x, int y,                                 *
  836.  *                              int dx, int dy,                               *
  837.  *                              HANDLE hDIB,                                  *
  838.  *                              int x0, int y0,                               *
  839.  *                              int dx0, int dy0,                             *
  840.  *                              LONG dwROP)                                   *
  841.  *                                                                            *
  842.  *  PURPOSE    : Draws a bitmap in CF_DIB format, using StretchDIBits()       *
  843.  *               taking the same parameters as StretchBlt().                  *
  844.  *                                                                            *
  845.  *  RETURNS    : TRUE  - if function succeeds.                                *
  846.  *               FALSE - otherwise.                                           *
  847.  *                                                                            *
  848.  ******************************************************************************/
  849. BOOL StretchDIBBlt (HDC hDC,     INT x,  INT y,  INT dx,  INT dy, 
  850. HANDLE hDIB, INT x0, INT y0, INT dx0, INT dy0, LONG dwROP)
  852. {
  853.     LPBITMAPINFOHEADER lpbih;
  854.     LPSTR        pBuf;
  855.     BOOL         bResult;
  857.     if (!hDIB)
  858.         return PatBlt(hDC, x, y, dx, dy, dwROP);
  860.     lpbih = (LPBITMAPINFOHEADER)hDIB;
  862.     if (!lpbih)
  863.         return FALSE;
  865.     pBuf = (LPSTR)lpbih + (WORD)lpbih->biSize + ColorTableSize(lpbih);
  866.     
  867.     bResult = StretchDIBits (hDC, x,  y,  dx,  dy, 
  868.                                   x0, y0, dx0, dy0, 
  869.                              pBuf, (LPBITMAPINFO)lpbih, 
  870.                              DIB_RGB_COLORS, dwROP);
  872.     return bResult;
  873. }
  875. /******************************************************************************
  876.  *                                                                            *
  877.  *  FUNCTION   : ReadPackedFileHeader(HFILE hFile, LPBITMAPFILEHEADER pbf)    *
  878.  *                                                                            *
  879.  *  PURPOSE    : read file header (which is packed) and convert into          *
  880.  *               unpacked BITMAPFILEHEADER strucutre                          *
  881.  *                                                                            *
  882.  *  RETURNS    : VOID                                                         *
  883.  *                                                                            *
  884.  *****************************************************************************/
  885. VOID ReadPackedFileHeader(HFILE hFile, LPBITMAPFILEHEADER lpbmfhdr, LPDWORD lpdwOffset)
  886. {
  887.     *lpdwOffset = _llseek(hFile, 0L, (UINT) SEEK_CUR);
  888.     _hread(hFile, (LPSTR) &lpbmfhdr->bfType, sizeof(WORD)); /* read in bfType*/            
  889.     _hread(hFile, (LPSTR) &lpbmfhdr->bfSize, sizeof(DWORD) * 3); /* read in last 3 dwords*/
  890. }
  891.   
  892. /******************************************************************************
  893.  *                                                                            *
  894.  *  FUNCTION   : WritePackedFileHeader(HFILE hFile, LPBITMAPFILEHEADER pbf)   *
  895.  *                                                                            *
  896.  *  PURPOSE    : write header structure (which NOT packed) and write          *
  897.  *               it out in PACKED format                                      *
  898.  *                                                                            *
  899.  *  RETURNS    : VOID                                                         *
  900.  *                                                                            *
  901.  *****************************************************************************/
  902. VOID WritePackedFileHeader(HFILE hFile, LPBITMAPFILEHEADER lpbmfhdr)
  903. {                                                       
  904.     _hwrite(hFile, (LPSTR)&lpbmfhdr->bfType, (UINT)sizeof (WORD)); 
  906.     /* pass over extra word and write next 3 DWORDS! */
  907.     _hwrite(hFile, (LPSTR)&lpbmfhdr->bfSize, sizeof(DWORD) * 3);   
  908. }
  910. /******************************************************************************
  911.  *                                                                            *
  912.  * HANDLE ConvertRGBDIB(HANDLE hSrcDIB, DWORD dwDstComp, WORD wDstBPP)        *
  913.  *                                                                            *
  914.  * Parameter:                                                                 *
  915.  *                                                                            *
  916.  * HDIB             - handle to packed-DIB in memory                          *
  917.  * WORD             - desired bits per pixel                                  *
  918.  * DWORD            - desired compression format                              *
  919.  *                                                                            *
  920.  * Return Value:                                                              *
  921.  *                                                                            *
  922.  * HDIB             - handle to the new DIB if successful, else NULL          *
  923.  *                                                                            *
  924.  * Description:                                                               *
  925.  *                                                                            *
  926.  * This function will create a new DIB with the specified BPP format using an *
  927.  * existing DIB as the source of the bits.  The conversion method will keep   *
  928.  * as much of the color information as possible. Both source and destination  *
  929.  * must be at least 16 bits-per-pixel.                                        *
  930.  *                                                                            *
  931.  * *Notes:                                                                    *
  932.  *    The source DIB is never destroyed                                       *
  933.  *    This function is not exposed and it is only called by ChangeDIBFormat() *
  934.  *    The function will return NULL if it fails                               *
  935.  *                                                                            *
  936.  *****************************************************************************/
  937. HANDLE ConvertRGBDIB(HANDLE hSrcDIB, DWORD dwDstComp, WORD wDstBPP)
  938. {
  939.     HDC hDC = GetDC(NULL);
  940.     HDC hSrcMemDC = CreateCompatibleDC(NULL);
  941.     HDC hDstMemDC = CreateCompatibleDC(NULL);
  942.     HBITMAP hSrcBmp = NULL, hDstBmp = NULL;
  943.     HANDLE hDstDIB = NULL;
  944.   LPBITMAPINFOHEADER biSrcPtr, biDstPtr;
  945.     LPRGBQUAD rgbqSrcPtr, rgbqDstPtr; 
  946.     RGBTRIPLE *bmSrcPtr, *bmDstPtr;
  947.     LPVOID pSrcDisp, pDstDisp;                                
  949.     __try {
  950.         /* This method of conversion only works with > 8bpp format DIBs */
  951.         if ((wDstBPP < 16) || (GetDIBBitCount(hSrcDIB) < 16))
  952.           RAISE_AN_EXCEPTION();
  954.         /* Initialize pointers for the source DIB */
  955.         if (!GetDIBPointers(hSrcDIB, (LPVOID*)&biSrcPtr, (LPVOID*)&rgbqSrcPtr, (LPVOID*)&bmSrcPtr))
  956.           RAISE_AN_EXCEPTION();
  958.         /* Create destination DIB and initialize pointers for it */
  959.         hDstDIB = CreateRGBDIB(biSrcPtr->biWidth, biSrcPtr->biHeight, wDstBPP, dwDstComp);
  960.         if (!GetDIBPointers(hDstDIB, (LPVOID*)&biDstPtr, (LPVOID*)&rgbqDstPtr, (LPVOID*)&bmDstPtr))
  961.           RAISE_AN_EXCEPTION();
  962.     
  963.      /* Create and load source DIB into source bitmap */
  964.      hSrcBmp = CreateDIBSection(hDC, (LPBITMAPINFO)biSrcPtr, 0, &pSrcDisp, NULL, 0);
  965.         if (!SelectObject(hSrcMemDC, hSrcBmp))
  966.           RAISE_AN_EXCEPTION();
  967.      CopyMemory(pSrcDisp, bmSrcPtr, biSrcPtr->biSizeImage);
  969.         /* Create destination bitmap */
  970.         hDstBmp = CreateDIBSection(hDC, (LPBITMAPINFO)biDstPtr, 0, &pDstDisp, NULL, 0);
  971.         if (!SelectObject(hDstMemDC, hDstBmp))
  972.           RAISE_AN_EXCEPTION();
  974.         /* Make GDI do the conversion between the different BPP formats */
  975.         BitBlt(hDstMemDC, 0, 0, biSrcPtr->biWidth, biSrcPtr->biHeight,
  976.                hSrcMemDC, 0, 0, SRCCOPY);
  977.         GdiFlush();
  978.           
  979.         /* Copy the converted data to our destination DIB */
  980.         CopyMemory(bmDstPtr, pDstDisp, biDstPtr->biSizeImage);
  981.     } __except (EXCEPTION_EXECUTE_HANDLER) {
  983.         /* Something got hosed, make sure we deallocate our destination DIB */
  984.         if (hDstDIB) {
  985.           GlobalFreeDIB(hDstDIB);
  986.           hDstDIB = NULL;
  987.         }                
  988.     }
  990.     /* Clean up the mess we made */
  991.     if (hDC) ReleaseDC(NULL, hDC);
  992.     if (hSrcMemDC) DeleteDC(hSrcMemDC);
  993.     if (hDstMemDC) DeleteDC(hDstMemDC);
  994.     if (hSrcBmp) DeleteObject(hSrcBmp);
  995.     if (hDstBmp) DeleteObject(hDstBmp);
  997.     return hDstDIB;          
  998. }
  1000. /******************************************************************************
  1001.  *                                                                            *
  1002.  * HANDLE ChangeDIBFormat(HANDLE hDIB, WORD wBPP, DWORD dwComp)               *
  1003.  *                                                                            *
  1004.  * Parameter:                                                                 *
  1005.  *                                                                            *
  1006.  * HDIB             - handle to packed-DIB in memory                          *
  1007.  * WORD             - desired bits per pixel                                  *
  1008.  * DWORD            - desired compression format                              *
  1009.  *                                                                            *
  1010.  * Return Value:                                                              *
  1011.  *                                                                            *
  1012.  * HDIB             - handle to the new DIB if successful, else NULL          *
  1013.  *                                                                            *
  1014.  * Description:                                                               *
  1015.  *                                                                            *
  1016.  * This function will convert the bits per pixel and/or the compression       *
  1017.  * format of the specified DIB. Note: If the conversion was unsuccessful,     *
  1018.  * we return NULL. The original DIB is left alone. Don't use code like the    *
  1019.  * following:                                                                 *
  1020.  *                                                                            *
  1021.  *    hMyDIB = ChangeDIBFormat(hMyDIB, 8, BI_RLE4);                           *
  1022.  *                                                                            *
  1023.  * The conversion will fail, but hMyDIB will now be NULL and the original     *
  1024.  * DIB will now hang around in memory. We could have returned the old         *
  1025.  * DIB, but we wanted to allow the programmer to check whether this           *
  1026.  * conversion succeeded or failed.                                            *
  1027.  *                                                                            *
  1028.  *****************************************************************************/
  1029. HANDLE ChangeDIBFormat(HANDLE hDIB, WORD wBPP, DWORD dwComp)
  1030. {
  1031.    HBITMAP            hBitmap;              // Handle to bitmap
  1032.    LPBITMAPINFOHEADER lpbih;                // Pointer to bitmap info
  1033.    HANDLE             hNewDIB = NULL;       // Handle to new DIB
  1034.    HPALETTE           hPal;                 // Handle to palette, prev pal
  1035.    WORD               wOldBPP, wNewBPP;     // DIB bits per pixel, new bpp
  1036.    DWORD              dwOldComp, dwNewComp; // DIB compression, new compression
  1037.     
  1038.    /* Check for a valid DIB handle */
  1039.    if (!hDIB)
  1040.       return NULL;
  1041.    
  1042.    /* Get the old DIB's bits per pixel and compression format */
  1043.    lpbih = (LPBITMAPINFOHEADER)hDIB;
  1044.    wOldBPP = lpbih->biBitCount;
  1045.    dwOldComp = lpbih->biCompression;
  1047.    /* Validate wBPP and dwComp
  1048.     * They must match correctly (i.e., BI_RLE4 and 4 BPP or
  1049.     * BI_RLE8 and 8BPP, etc.) or we return failure */
  1050.    if (wBPP == 0) {
  1051.       wNewBPP = wOldBPP;
  1052.       if ((dwComp == BI_RLE4 && wNewBPP == 4) ||
  1053.           (dwComp == BI_RLE8 && wNewBPP == 8) ||
  1054.           (dwComp == BI_RGB))
  1055.         dwNewComp = dwComp;
  1056.       else
  1057.         return NULL;
  1058.       }
  1059.    else if (wBPP == 1 && dwComp == BI_RGB) {
  1060.       wNewBPP = wBPP;
  1061.       dwNewComp = BI_RGB;
  1062.       }
  1063.    else if (wBPP == 4) {
  1064.       wNewBPP = wBPP;
  1065.       if (dwComp == BI_RGB || dwComp == BI_RLE4)
  1066.         dwNewComp = dwComp;
  1067.       else
  1068.         return NULL;
  1069.       }
  1070.    else if (wBPP == 8) {
  1071.       wNewBPP = wBPP;
  1072.       if (dwComp == BI_RGB || dwComp == BI_RLE8)
  1073.         dwNewComp = dwComp;
  1074.       else
  1075.         return NULL;
  1076.       }
  1077.    else if (wBPP == 24 && dwComp == BI_RGB) {
  1078.       wNewBPP = wBPP;
  1079.       dwNewComp = BI_RGB;
  1080.       }
  1081.    else if (((wBPP == 16) || (wBPP == 32)) && 
  1082.             ((dwComp == BI_BITFIELDS) || (dwComp == BI_RGB))) {
  1083.         wNewBPP = wBPP;
  1084.         dwNewComp = dwComp;
  1085.       }
  1086.    else
  1087.         return NULL;
  1088.    
  1089.    if ((wOldBPP > 8) && (wNewBPP > 8)) 
  1090.      /* Keep as much color info as possible */
  1091.      hNewDIB = ConvertRGBDIB(hDIB, dwNewComp, wNewBPP);
  1093.    if (!hNewDIB) {
  1094.        /* Save the old DIB's palette */
  1095.        hPal = CreateDIBPalette(hDIB);  
  1096.        if (!hPal)
  1097.           return NULL;
  1098.    
  1099.        /* Convert old DIB to a bitmap */
  1100.        hBitmap = BitmapFromDIB(hDIB, hPal);
  1102.        /* Convert Bitmap into a DIB with the new compression and BPP  */
  1103.        hNewDIB = DIBFromBitmap(hBitmap, dwNewComp, wNewBPP, hPal);
  1104.        
  1105.        DeleteObject(hBitmap);
  1106.        DeleteObject(hPal);
  1107.    }
  1109.    if (hNewDIB)
  1110.          GlobalFreeDIB(hDIB);
  1112.    return hNewDIB;
  1113. }
  1115. /******************************************************************************
  1116.  *                                                                            *
  1117.  * BOOL ChangeDIBPalette(HANDLE hDIB, HPALETTE hPal)                          *
  1118.  *                                                                            *
  1119.  * Parameter:                                                                 *
  1120.  *                                                                            *
  1121.  * HDIB             - handle to packed-DIB in memory                          *
  1122.  * HPALETTE         - the new palette for the DIB                             *
  1123.  *                                                                            *
  1124.  * Return Value:                                                              *
  1125.  *                                                                            *
  1126.  * BOOL             - returns success or failure status                       *
  1127.  *                                                                            *
  1128.  * Description:                                                               *
  1129.  *                                                                            *
  1130.  * This function will remap the colors in the given DIB so that they          *
  1131.  * reference the colors in the new palette - note that this is not the same   *
  1132.  * changing the DIBs color table since we are forcing the bits to be          *
  1133.  * remapped to new values in addition to changing the color table.            *
  1134.  *                                                                            *
  1135.  *****************************************************************************/
  1136. BOOL ChangeDIBPalette(HANDLE hDIB, HPALETTE hPal)
  1137. {
  1138.    HDC                hDC;      
  1139.    HBITMAP            hBitmap;  
  1140.    LPBITMAPINFOHEADER lpbih;      // Pointer to bitmap info
  1141.    HPALETTE           hOldPal;   // Handle to palette, prev pal
  1142.       
  1143.    /* Check for a valid DIB/Palette handle */
  1144.    if (!hDIB || !hPal)
  1145.       return FALSE;
  1147.    /* Convert old DIB to a bitmap */
  1148.    hBitmap = BitmapFromDIB(hDIB, hPal);
  1150.    /* Make sure it worked */
  1151.    if (!hBitmap) 
  1152.       return FALSE;
  1154.    /* Get a pointer to the DIB header */
  1155.    lpbih = (LPBITMAPINFOHEADER)hDIB;
  1157.    /* Get a DC and select/realize our palette in it */
  1158.    hDC  = GetDC(NULL);
  1159.    hOldPal = SelectPalette(hDC, hPal, FALSE);
  1160.    RealizePalette(hDC);
  1162.    /* Call GetDIBits and get the new DIB bits */
  1163.    if (!GetDIBits(hDC, 
  1164.                   hBitmap, 
  1165.                   (UINT)0, 
  1166.                   (UINT)lpbih->biHeight, 
  1167.                   (LPBYTE)lpbih + (WORD)lpbih->biSize + ColorTableSize((LPSTR)lpbih), 
  1168.                   (LPBITMAPINFO)lpbih, 
  1169.                   DIB_RGB_COLORS)) 
  1170.       return FALSE;
  1172.    /* Clean up and return */
  1173.    SelectPalette(hDC, hOldPal, TRUE);
  1174.    RealizePalette(hDC);
  1175.    ReleaseDC(NULL, hDC);
  1177.    DeleteObject(hBitmap);
  1179.    return TRUE;
  1180. }
  1182. /******************************************************************************
  1183.  *                                                                            *
  1184.  * HANDLE CopyDIB(HANDLE hDIBSrc)                                             *
  1185.  *                                                                            *
  1186.  * Parameter:                                                                 *
  1187.  *                                                                            *
  1188.  * HANDLE           - The handle to the DIB you want to make a copy of.       *
  1189.  *                                                                            *
  1190.  * Return Value:                                                              *
  1191.  *                                                                            *
  1192.  * HANDLE           - A copy of the DIB passed as a parameter                 *  
  1193.  *                                                                            *
  1194.  *****************************************************************************/
  1195. HANDLE CopyDIB(HANDLE hDIBSrc)
  1196. {
  1197.   HANDLE hDIBDst = NULL;
  1198.   DWORD dwSize = GlobalSize(hDIBSrc);
  1199.     
  1200.   if (!hDIBSrc) 
  1201.     return NULL;
  1202.   
  1203.   hDIBDst = GlobalAlloc(GPTR, dwSize);
  1204.   if (!hDIBDst) 
  1205.     return NULL;
  1206.     
  1207.   CopyMemory(hDIBDst, hDIBSrc, dwSize); 
  1209.   return (hDIBDst);
  1210. }
  1212. /****************************************************************************
  1213.  *                                                                          *
  1214.  *  FUNCTION   : CopyBitmap (HBITMAP hBitmap)                               *
  1215.  *                                                                          *
  1216.  *  PURPOSE    : Copies the given bitmap to another.                        *
  1217.  *                                                                          *
  1218.  *  RETURNS    : A handle to the new bitmap.                                *
  1219.  *                                                                          *
  1220.  ****************************************************************************/
  1221. HBITMAP CopyBitmap (HBITMAP hBitmap)
  1222. {
  1223.     BITMAP  Bitmap;
  1224.     RECT    rect;
  1226.     if (!hBitmap)
  1227.          return NULL;
  1229.     GetObject (hBitmap, sizeof(BITMAP), (LPSTR)&Bitmap);
  1230.     rect.left   = 0;
  1231.     rect.top    = 0;
  1232.     rect.right  = Bitmap.bmWidth;
  1233.     rect.bottom = Bitmap.bmHeight;
  1235.     return CropBitmap (hBitmap, &rect);
  1236. }
  1238. /****************************************************************************
  1239.  *                                                                          *
  1240.  *  FUNCTION   :  CropBitmap (HBITMAP hBitmap, LPRECT lpRect)               *
  1241.  *                                                                          *
  1242.  *  PURPOSE    :  Crops a bitmap to a new size specified by the lpRect      *
  1243.  *                parameter.                                                *
  1244.  *                                                                          *
  1245.  *  RETURNS    :  A handle to the new bitmap.                               *
  1246.  *                                                                          *
  1247.  ****************************************************************************/
  1248. HBITMAP CropBitmap (HBITMAP hBitmap, LPRECT lpRect)
  1249. {
  1250.     HDC     hMemDCsrc;
  1251.     HDC     hMemDCdst;
  1252.     HDC     hDC;
  1253.     HBITMAP hNewBm;
  1254.     BITMAP  Bitmap;
  1255.     INT     dx, dy;
  1257.     if (!hBitmap)
  1258.          return NULL;
  1260.     hDC = GetDC (NULL);
  1261.     hMemDCsrc = CreateCompatibleDC (hDC);
  1262.     hMemDCdst = CreateCompatibleDC (hDC);
  1264.     GetObject (hBitmap, sizeof(BITMAP), (LPSTR)&Bitmap);
  1265.     dx = lpRect->right  - lpRect->left;
  1266.     dy = lpRect->bottom - lpRect->top;
  1268.     /*hNewBm = +++CreateBitmap - Not Recommended(use CreateDIBitmap)+++ (dx, dy, Bitmap.BitmapPlanes, Bitmap.BitmapBitsPixel, NULL);*/
  1269.     hNewBm = CreateBitmap(dx, dy, Bitmap.bmPlanes, Bitmap.bmBitsPixel, NULL);
  1270.     if (hNewBm) {
  1271.         SelectObject (hMemDCsrc, hBitmap);
  1272.         SelectObject (hMemDCdst, hNewBm);
  1274.         BitBlt (hMemDCdst, 
  1275.                 0, 
  1276.                 0, 
  1277.                 dx, 
  1278.                 dy, 
  1279.                 hMemDCsrc, 
  1280.                 lpRect->left, 
  1281.                 lpRect->top, 
  1282.                 SRCCOPY);
  1283.     }
  1285.     ReleaseDC (NULL, hDC);
  1286.     DeleteDC (hMemDCsrc);
  1287.     DeleteDC (hMemDCdst);
  1289.     return hNewBm;
  1290. }
  1292. /******************************************************************************
  1293.  *                                                                            *
  1294.  * BOOL CopyDIBData(HANDLE hDIBDst, HANDLE hDIBSrc)                           *
  1295.  *                                                                            *
  1296.  * Parameter:                                                                 *
  1297.  *                                                                            *
  1298.  * HANDLE           - The handle to the DIB you want to copy to.              *
  1299.  * HANDLE           - The handle to the DIB you want to copy from.            *
  1300.  *                                                                            *
  1301.  * Return Value:                                                              *
  1302.  *                                                                            *
  1303.  * HANDLE           - Success or failure of the function                      *  
  1304.  *                                                                            *
  1305.  *  Replaces the contents of the destination DIB with the contents of the     *
  1306.  *  source DIB.  This will fail if the initial sizes of the DIBS are          * 
  1307.  *  not equal.                                                                *
  1308.  *                                                                            *
  1309.  *****************************************************************************/
  1310. BOOL CopyDIBData(HANDLE hDIBDst, HANDLE hDIBSrc)
  1311. {
  1312.   DWORD dwDstSize = GlobalSize(hDIBDst);
  1313.   DWORD dwSrcSize = GlobalSize(hDIBSrc);
  1314.   
  1315.   if (dwDstSize != dwDstSize)
  1316.     return FALSE;
  1318.   CopyMemory(hDIBDst, hDIBSrc, dwDstSize); 
  1320.   return (TRUE);
  1321. }
  1323. /******************************************************************************
  1324.  *                                                                            *
  1325.  * HANDLE GetDIBFromClipboard(HWND hWnd)                                      *
  1326.  *                                                                            *
  1327.  * Parameter:                                                                 *
  1328.  *                                                                            *
  1329.  * HWND             - The handle of the window that will own the clipboard    *
  1330.  *                                                                            *
  1331.  * Return Value:                                                              *
  1332.  *                                                                            *
  1333.  * HANDLE           - Handle to the DIB that was on the Clipboard             *  
  1334.  *                                                                            *
  1335.  *****************************************************************************/
  1336. HANDLE GetDIBFromClipboard(HWND hWnd)
  1337. {   
  1338.   HANDLE hData;
  1339.   HANDLE hDIB;
  1341.   if (OpenClipboard(hWnd)) {
  1342.     hData = GetClipboardData(CF_DIB);
  1343. if (hData == NULL) {
  1344.    hData = GetClipboardData(CF_BITMAP);
  1345. if (hData != NULL) {
  1346.   HPALETTE hPal, hClipPal = (HPALETTE)GetClipboardData(CF_PALETTE);
  1347.   
  1348.   hPal = CopyPalette(hClipPal);
  1349.   hDIB = DIBFromBitmap((HBITMAP)hData, BI_RGB, 8, hPal);
  1350.           DeleteObject(hPal);
  1351. } else
  1352.   return NULL;
  1353. } else 
  1354. hDIB = CopyDIB(hData);
  1355.  
  1356. CloseClipboard();
  1357.   } else
  1358. return NULL;
  1360.   return hDIB;
  1361. }
  1363. /******************************************************************************
  1364.  *                                                                            *
  1365.  * BOOL GetDIBResolution(HANDLE hDIB, LONG *iXRes, LONG *iYRes)               *
  1366.  *                                                                            *
  1367.  * Parameter:                                                                 *
  1368.  *                                                                            *
  1369.  * HANDLE           - The handle to the DIB you want get the resolution of    *
  1370.  * LONG*            - Pointer to x resolution                                 *
  1371.  * LONG*            - Pointer to y resolution                                 *
  1372.  *                                                                            *
  1373.  * Return Value:                                                              *
  1374.  *                                                                            *
  1375.  * HANDLE           - Success or failure of the function                      *  
  1376.  *                                                                            *
  1377.  *  Reads the width and the height of a DIB from the BITMAPINFOHEADER and     *
  1378.  *  returns the values.                                                       *
  1379.  *                                                                            *
  1380.  *****************************************************************************/
  1381. BOOL GetDIBResolution(HANDLE hDIB, LONG *iXRes, LONG *iYRes)
  1382. {
  1383.   if (!hDIB) return FALSE;
  1384.   
  1385.   *iXRes = ((LPBITMAPINFOHEADER)hDIB)->biWidth;
  1386.   *iYRes = ((LPBITMAPINFOHEADER)hDIB)->biHeight;
  1388.   return TRUE;
  1389. }
  1391. /******************************************************************************
  1392.  *                                                                            *
  1393.  * DWORD GetDIBColorUsed(HANDLE hDIB)                                         *
  1394.  *                                                                            *
  1395.  * Parameter:                                                                 *
  1396.  *                                                                            *
  1397.  * HANDLE           - The handle to the DIB you want to check                 *
  1398.  *                                                                            *
  1399.  * Return Value:                                                              *
  1400.  *                                                                            *
  1401.  * DWORD            - Number of colors used by the DIB                        *  
  1402.  *                                                                            *
  1403.  *  Reads and returns the number of colors used from the BITMAPINFOHEADER     *
  1404.  *                                                                            *
  1405.  *****************************************************************************/
  1406. DWORD GetDIBColorUsed(HANDLE hDIB)
  1407. {
  1408.   DWORD dwClrUsed;
  1410.   if (!hDIB) 
  1411.     return 0;
  1412.   
  1413.   dwClrUsed = ((LPBITMAPINFOHEADER)hDIB)->biClrUsed;
  1415.   return dwClrUsed;
  1416. }
  1418. /******************************************************************************
  1419.  *                                                                            *
  1420.  * DWORD GetDIBCopmression(HANDLE hDIB)                                       *
  1421.  *                                                                            *
  1422.  * Parameter:                                                                 *
  1423.  *                                                                            *
  1424.  * HANDLE           - The handle to the DIB you want to check                 *
  1425.  *                                                                            *
  1426.  * Return Value:                                                              *
  1427.  *                                                                            *
  1428.  * DWORD            - The compression type for the given DIB                  *  
  1429.  *                                                                            *
  1430.  *****************************************************************************/
  1431. DWORD GetDIBCompression(HANDLE hDIB)
  1432. {
  1433.   DWORD dwComp;
  1435.   if (!hDIB) 
  1436.     return 0;
  1437.   
  1438.   dwComp = ((LPBITMAPINFOHEADER)hDIB)->biCompression;
  1440.   return dwComp;
  1441. }
  1443. /******************************************************************************
  1444.  *                                                                            *
  1445.  * DWORD GetDIBBitcount(HANDLE hDIB)                                          *
  1446.  *                                                                            *
  1447.  * Parameter:                                                                 *
  1448.  *                                                                            *
  1449.  * HANDLE           - The handle to the DIB you want to check                 *
  1450.  *                                                                            *
  1451.  * Return Value:                                                              *
  1452.  *                                                                            *
  1453.  * DWORD            - The number of bits per pixel for given DIB              *  
  1454.  *                                                                            *
  1455.  *****************************************************************************/
  1456. WORD GetDIBBitCount(HANDLE hDIB)
  1457. {
  1458.   WORD wBitCount;
  1460.   if (!hDIB) 
  1461.     return 0;
  1462.   
  1463.   wBitCount = ((LPBITMAPINFOHEADER)hDIB)->biBitCount;
  1465.   return wBitCount;
  1466. }
  1467. /******************************************************************************
  1468.  *                                                                            *
  1469.  *  FUNCTION   : CreateDIBPalette(HANDLE hbi)                                 *
  1470.  *                                                                            *
  1471.  *  PURPOSE    : Given a Global HANDLE to a BITMAPINFO Struct will create a   *
  1472.  *               GDI palette object from the color table. (BITMAPINFOHEADER   *
  1473.  *               format DIBs only)                                            *
  1474.  *                                                                            *
  1475.  *  RETURNS    : A handle to the palette.                                     *
  1476.  *                                                                            *
  1477.  *****************************************************************************/
  1478. HPALETTE CreateDIBPalette (HANDLE hbi)
  1479. {
  1480.     HPALETTE hPal;
  1482.     if (!hbi)
  1483.         return NULL;
  1485.     hPal = CreateBIPalette((LPBITMAPINFOHEADER)hbi);
  1487.     return hPal;
  1488. }
  1491. /******************************************************************************
  1492.  *                                                                            *
  1493.  *  FUNCTION   : CreateDIBPaletteEx(HANDLE hbi, BYTE bFlags)                  *
  1494.  *                                                                            *
  1495.  *  PURPOSE    : Given a Global HANDLE to a BITMAPINFO Struct will create a   *
  1496.  *               GDI palette object from the color table. (BITMAPINFOHEADER   *
  1497.  *               format DIBs only)  In addition, you can specify the palette  *
  1498.  *               palette flags for the palette entries.                       *
  1499.  *                                                                            *
  1500.  *  RETURNS    : A handle to the palette.                                     *
  1501.  *                                                                            *
  1502.  *****************************************************************************/
  1503. HPALETTE CreateDIBPaletteEx(HANDLE hDIB, BYTE bFlags)
  1504. {
  1505.     HPALETTE hPal, hNewPal;
  1507.     if (!hDIB)
  1508.         return NULL;
  1510.     hPal = CreateDIBPalette(hDIB);
  1511.     hNewPal = CopyPaletteEx(hPal, bFlags);
  1512.     DeleteObject(hPal);
  1513.        
  1514.     return hNewPal;
  1515. }
  1517. /******************************************************************************
  1518.  *                                                                            *
  1519.  *  FUNCTION   : GetDIBPointers(HANDLE hDIB, LPVOID *biPtr,                   *
  1520.  *                                     LPVOID *rgbqPtr, LPVOID *bmPtr)        *
  1521.  *                                                                            *
  1522.  *  PURPOSE    : Given a handle to a DIB in CF_DIB format, this function will *
  1523.  *               retrieve pointers for the bitmap info, color table, and bits *
  1524.  *                                                                            *
  1525.  *****************************************************************************/
  1526. BOOL GetDIBPointers(HANDLE hDIB, LPVOID *biPtr, LPVOID *rgbqPtr, LPVOID *bmPtr)
  1527. {  
  1528.    LPBITMAPINFO pbi;
  1529.    
  1530.    pbi = (LPBITMAPINFO)hDIB;  
  1531.    
  1532.    if (!pbi)
  1533.      return FALSE;
  1535.    *biPtr   = (LPVOID)pbi;
  1536.    
  1537.    *rgbqPtr = (LPVOID)((LPSTR)pbi + (WORD)((LPBITMAPINFOHEADER)pbi)->biSize);
  1538.    if (((LPBITMAPINFOHEADER)pbi)->biCompression == BI_BITFIELDS)
  1539.       rgbqPtr = (LPVOID*)((LPDWORD)rgbqPtr + 3); 
  1541.    *bmPtr   = (LPBYTE)pbi + (WORD)pbi->bmiHeader.biSize + ColorTableSize(pbi); 
  1543.    return TRUE;
  1544. }
  1546. /******************************************************************************
  1547.  *                                                                            *
  1548.  *  FUNCTION   : HANDLE CreateRGBDIB(DWORD dwWidth, DWORD dwHeight,           *
  1549.  *                                    WORD wBPP, DWORD dwComp);               *
  1550.  *                                                                            *
  1551.  *  PURPOSE    : Returns a handle to a RGB DIB (no color table) with the      *
  1552.  *               specified width, height, bits per pixel, and compression.    *
  1553.  *                                                                            *
  1554.  *****************************************************************************/
  1555. HANDLE CreateRGBDIB(DWORD dwWidth, DWORD dwHeight, WORD wBPP, DWORD dwComp)
  1556. {
  1557.    HANDLE hDIB;
  1558.    LPBITMAPINFOHEADER lpbih;
  1559.    DWORD dwSize;
  1560.    LPDWORD lpMasks;
  1561.    
  1562.    /* We cant support compression so check to see if that's what is being asked for */
  1563.    if ((dwComp == BI_RLE8) || (dwComp == BI_RLE4)) return NULL;
  1565.    /* Allocate enough memory to hold the DIB */
  1566.    switch (wBPP) {
  1567.      case  8: dwSize = ((DWORD)BYTESPERLINE(dwWidth, 8) * dwHeight) + sizeof(RGBQUAD) * 256; break;
  1568.      case 16: dwSize = ((dwWidth + (dwWidth & 1)) << 1) * dwHeight; break;
  1569.      case 24: dwSize = (DWORD)BYTESPERLINE(dwWidth, 24) * dwHeight; break;
  1570.      case 32: dwSize = ((dwWidth * dwHeight) << 2); break;
  1571.      default: return NULL;
  1572.    }                                               
  1573.    
  1574.    if (dwComp == BI_BITFIELDS) /* Add in space for DWORD masks */
  1575.      hDIB = GlobalAlloc(GPTR, (DWORD)sizeof(BITMAPINFOHEADER) + (sizeof(DWORD) * 3) + dwSize);
  1576.    else
  1577.      hDIB = GlobalAlloc(GPTR, (DWORD)sizeof(BITMAPINFOHEADER) + dwSize);
  1579.    if (!hDIB)
  1580.      return NULL;
  1581.    
  1582.    lpbih = (LPBITMAPINFOHEADER)hDIB;
  1583.    lpbih->biSize         = sizeof(BITMAPINFOHEADER);
  1584.    lpbih->biWidth        = dwWidth;
  1585.    lpbih->biHeight       = dwHeight;
  1586.    lpbih->biPlanes       = 1;
  1587.    lpbih->biBitCount     = wBPP;
  1588.    lpbih->biCompression  = dwComp;    
  1589.    lpbih->biSizeImage    = ((DWORD)BYTESPERLINE(dwWidth, wBPP) * dwHeight); 
  1591.    lpMasks = (LPDWORD)((LPSTR)lpbih + (WORD)lpbih->biSize);
  1592.    
  1593.    if (dwComp == BI_BITFIELDS) 
  1594.        if (wBPP == 16) {
  1595.          lpMasks[0] = MAKE565WORD(0xff, 0, 0);
  1596.          lpMasks[1] = MAKE565WORD(0, 0xff, 0);
  1597.          lpMasks[2] = MAKE565WORD(0, 0, 0xff);
  1598.        } else if (wBPP == 32) {
  1599.            lpMasks[0] = 0xff0000;
  1600.            lpMasks[1] = 0x00ff00;
  1601.            lpMasks[2] = 0x0000ff;
  1602.          }
  1603.       
  1604.    return hDIB;
  1605. }
  1608. /******************************************************************************
  1609.  *                                                                            *
  1610.  * PalEntriesOnDevice()                                                       *
  1611.  *                                                                            *
  1612.  * Parameter:                                                                 *
  1613.  *                                                                            *
  1614.  * HDC hDC          - device context                                          *
  1615.  *                                                                            *
  1616.  * Return Value:                                                              *
  1617.  *                                                                            *
  1618.  * int              - number of palette entries on device                     *
  1619.  *                                                                            *
  1620.  * Description:                                                               *
  1621.  *                                                                            *
  1622.  * This function gets the number of palette entries on the specified device   *
  1623.  *                                                                            *
  1624.  * History:   Date      Author               Reason                           *
  1625.  *            6/01/91   Garrett McAuliffe    Created                          *
  1626.  *            9/15/91   Patrick Schreiber    Added header and comments        *
  1627.  *                                                                            *
  1628.  *****************************************************************************/   
  1629. int PalEntriesOnDevice(HDC hDC)                                      
  1630. {                                                                        
  1631.    int nColors;  // number of colors                                     
  1633.    /*  Find out the number of palette entries on this
  1634.     *  device.
  1635.     */
  1637.    nColors = GetDeviceCaps(hDC, SIZEPALETTE);
  1639.    /*  For non-palette devices, we'll use the # of system
  1640.     *  colors for our palette size.
  1641.     */
  1642.    if (!nColors)
  1643.       nColors = GetDeviceCaps(hDC, NUMCOLORS);   
  1645.    return nColors;
  1646. }
  1648. /******************************************************************************
  1649.  *                                                                            *
  1650.  * HPALETTE CreatePaletteFromRGBQUAD(LPRGBQUAD rgbqPalette, WORD wEntries)    *
  1651.  *                                                                            *
  1652.  * Parameter:                                                                 *
  1653.  *                                                                            *
  1654.  * LPRGBQUAD        - pointer to RGBQUADs                                     *
  1655.  * WORD             - the number of RGBQUADs we are pointing to               *
  1656.  *                                                                            *
  1657.  * Return Value:                                                              *
  1658.  *                                                                            *
  1659.  * HPALETTE         - returns a handle to a palette or NULL if it failes      *
  1660.  *                                                                            *
  1661.  * Description:                                                               *
  1662.  *                                                                            *
  1663.  * This function will build a valid HPALETTE when given an array of RGBQUADs  *
  1664.  *                                                                            *
  1665.  *****************************************************************************/
  1666. HPALETTE CreatePaletteFromRGBQUAD(LPRGBQUAD rgbqPalette, WORD wEntries)
  1667. { 
  1668.     HPALETTE hPal;
  1669.     LPLOGPALETTE lplgPal;
  1670.     PALETTEENTRY pe[256];
  1671.     int i;
  1673.     lplgPal = (LPLOGPALETTE)GlobalAlloc(GPTR, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * wEntries); 
  1674.     if (!lplgPal)
  1675.       return NULL;
  1677.     lplgPal->palVersion = PALVERSION;
  1678.     lplgPal->palNumEntries = wEntries;
  1680.     for (i=0; i<wEntries; i++) {
  1681.       lplgPal->palPalEntry[i].peRed   = rgbqPalette[i].rgbRed;
  1682.       lplgPal->palPalEntry[i].peGreen = rgbqPalette[i].rgbGreen;
  1683.       lplgPal->palPalEntry[i].peBlue  = rgbqPalette[i].rgbBlue;
  1684.       lplgPal->palPalEntry[i].peFlags = 0;
  1685.     }
  1687.     CopyMemory(pe, lplgPal->palPalEntry, wEntries * sizeof(PALETTEENTRY));
  1689.     hPal = CreatePalette(lplgPal);
  1690.     GlobalFree(lplgPal);
  1692.     return hPal;
  1693. }
  1695. /******************************************************************************
  1696.  *                                                                            *
  1697.  * WORD CreateRGBQUADFromPalette(LPRGBQUAD rgbqPalette, HPALETTE hPal);       *
  1698.  *                                                                            *
  1699.  * Parameter:                                                                 *
  1700.  *                                                                            *
  1701.  * LPRGBQUAD        - pointer to RGBQUADs                                     *
  1702.  * HPALETTE         - HANDLE of Palette                                       *
  1703.  *                                                                            *
  1704.  * Return Value:                                                              *
  1705.  *                                                                            *
  1706.  * WORD             - returns the number of palette entries copied into the   *
  1707.  *                    LPRGBQUAD array                                         *
  1708.  *                                                                            *
  1709.  * Description:                                                               *
  1710.  *                                                                            *
  1711.  * This function will fill an array of RGBQUAD from given a palette handle    *
  1712.  *                                                                            *
  1713.  *****************************************************************************/
  1714. WORD CreateRGBQUADFromPalette(LPRGBQUAD rgbqPalette, HPALETTE hPal)
  1715. { 
  1716.     int i;
  1717.     WORD wEntries;
  1718.   
  1719.     GetObject(hPal, sizeof(wEntries), &wEntries);
  1721.     GetPaletteEntries(hPal, 0, wEntries, (LPPALETTEENTRY)rgbqPalette);
  1723.     for (i=0; i<wEntries; i++) {
  1724.       rgbqPalette[i].rgbReserved = rgbqPalette[i].rgbRed;
  1725.       rgbqPalette[i].rgbRed   = rgbqPalette[i].rgbBlue;
  1726.       rgbqPalette[i].rgbBlue  = rgbqPalette[i].rgbReserved;
  1727.       rgbqPalette[i].rgbReserved = 0;
  1728.     }
  1730.     return wEntries;
  1731. }
  1733. /******************************************************************************  
  1734.  *                                                                            *  
  1735.  * GetSystemPalette()                                                         *  
  1736.  *                                                                            *  
  1737.  * Parameters:                                                                *  
  1738.  *                                                                            *  
  1739.  * None                                                                       *  
  1740.  *                                                                            *  
  1741.  * Return Value:                                                              *  
  1742.  *                                                                            *  
  1743.  * HPALETTE  - handle to a copy of the current system palette          *  
  1744.  *                                                                            *  
  1745.  * Description:                                                               *  
  1746.  *                                                                            *  
  1747.  * This function returns a handle to a palette which represents the system    *  
  1748.  * palette.  The system RGB values are copied into our logical palette        *  
  1749.  * using the GetSystemPaletteEntries function.                                *  
  1750.  *                                                                            *  
  1751.  * History:                                                                   *  
  1752.  *                                                                            *  
  1753.  *    Date      Author               Reason                                   *
  1754.  *    6/01/91   Garrett McAuliffe    Created                                  *
  1755.  *    9/15/91   Patrick Schreiber    Added header and comments                *
  1756.  *    12/20/91  Mark Bader           Added GetSystemPaletteEntries call       *
  1757.  *                                                                            *
  1758.  *****************************************************************************/  
  1759. HPALETTE GetSystemPalette()
  1760. {
  1761.    HDC hDC;                // handle to a DC
  1762.    static HPALETTE hPal = NULL;   // handle to a palette
  1763.    HANDLE hLogPal;         // handle to a logical palette
  1764.    LPLOGPALETTE lpLogPal;  // pointer to a logical palette
  1765.    int nColors;            // number of colors
  1767.    /* Find out how many palette entries we want. */
  1769.    hDC = GetDC(NULL);
  1770.    if (!hDC)
  1771.       return NULL;
  1772.   
  1773.    if (!(GetDeviceCaps(hDC, RASTERCAPS) & RC_PALETTE)) {
  1774.      ReleaseDC(NULL, hDC);
  1775.      return NULL;
  1776.    }
  1778.    nColors = PalEntriesOnDevice(hDC);   // Number of palette entries
  1780.    /* Allocate room for the palette */
  1781.    hLogPal = GlobalAlloc(GPTR, sizeof(LOGPALETTE) + nColors * sizeof(PALETTEENTRY));
  1783.    /* if we didn't get a logical palette, return NULL */
  1784.    if (!hLogPal)
  1785.       return NULL;
  1787.    /* get a pointer to the logical palette */
  1788.    lpLogPal = (LPLOGPALETTE)hLogPal;
  1790.    /* set some important fields */
  1791.    lpLogPal->palVersion = PALVERSION;
  1792.    lpLogPal->palNumEntries = nColors;
  1794.    /* Copy the current system palette into our logical palette */
  1796.    GetSystemPaletteEntries(hDC, 0, nColors, 
  1797.                            (LPPALETTEENTRY)(lpLogPal->palPalEntry));
  1799.    /*  Go ahead and create the palette.  Once it's created, 
  1800.     *  we no longer need the LOGPALETTE, so free it.
  1801.     */
  1803.    hPal = CreatePalette(lpLogPal);
  1805.    /* clean up */
  1806.    GlobalFree(hLogPal);
  1807.    ReleaseDC(NULL, hDC);
  1809.    return hPal;
  1810. }
  1813. /******************************************************************************
  1814.  *                                                                            *
  1815.  * HPALETTE CreateNewPalette()   *
  1816.  *                                                                            *
  1817.  * Parameter:                                                               *
  1818.  *                                                                            *
  1819.  * HDC - Handle to a Device Context   *
  1820.  *                                                                            *
  1821.  * Return Value:                                                              *
  1822.  *                                                                            *
  1823.  * HPALETTE         - Returns a handle to a palette or NULL if it   *
  1824.  *                    fails.                                                  *
  1825.  *                                                                            *
  1826.  * Description:                                                               *
  1827.  *                                                                            *
  1828.  * This function will build a palette with a spectrum of colors.  It is       *
  1829.  * useful when you want to display a number of DIBs each with a different     *
  1830.  * palette yet still have an a good selection of colors for the DIBs to map   *
  1831.  * to.                                                                        *
  1832.  *                                                                            *
  1833.  *****************************************************************************/
  1834. HPALETTE CreateNewPalette(HDC hDC)
  1835. {
  1836. PIXELFORMATDESCRIPTOR pfd; // Pixel Format Descriptor
  1837. LOGPALETTE *pPal; // Pointer to memory for logical palette
  1838. HPALETTE hPal; // Handle to our palette
  1839. int nPixelFormat; // Pixel format index
  1840. int nColors; // Number of entries in palette
  1841. int i; // Counting variable
  1842. BYTE RedRange,GreenRange,BlueRange;
  1843. // Range for each color entry (7,7,and 3)
  1845. // Get the pixel format index and retrieve the pixel format description
  1846. nPixelFormat = GetPixelFormat(hDC);
  1847. DescribePixelFormat(hDC, nPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
  1849. // Does this pixel format require a palette?  If not, do not create a
  1850. // palette and just return NULL
  1851. if(!(pfd.dwFlags & PFD_NEED_PALETTE))
  1852. return NULL;
  1854. // Number of entries in palette.  8 bits yeilds 256 entries
  1855. nColors = 1 << pfd.cColorBits;
  1857. // Allocate space for a logical palette structure plus all the palette entries
  1858. pPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +nColors*sizeof(PALETTEENTRY));
  1860. // Fill in palette header 
  1861. pPal->palVersion = 0x300; // Windows 3.0
  1862. pPal->palNumEntries = nColors; // table size
  1864. // Build mask of all 1's.  This creates a number represented by having
  1865. // the low order x bits set, where x = pfd.cRedBits, pfd.cGreenBits, and
  1866. // pfd.cBlueBits.  
  1867. RedRange = (1 << pfd.cRedBits) -1;
  1868. GreenRange = (1 << pfd.cGreenBits) - 1;
  1869. BlueRange = (1 << pfd.cBlueBits) -1;
  1871. // Loop through all the palette entries
  1872. for(i = 0; i < nColors; i++)
  1873. {
  1874. // Fill in the 8-bit equivalents for each component
  1875. pPal->palPalEntry[i].peRed = (i >> pfd.cRedShift) & RedRange;
  1876. pPal->palPalEntry[i].peRed = (unsigned char)(
  1877. (double) pPal->palPalEntry[i].peRed * 255.0 / RedRange);
  1879. pPal->palPalEntry[i].peGreen = (i >> pfd.cGreenShift) & GreenRange;
  1880. pPal->palPalEntry[i].peGreen = (unsigned char)(
  1881. (double)pPal->palPalEntry[i].peGreen * 255.0 / GreenRange);
  1883. pPal->palPalEntry[i].peBlue = (i >> pfd.cBlueShift) & BlueRange;
  1884. pPal->palPalEntry[i].peBlue = (unsigned char)(
  1885. (double)pPal->palPalEntry[i].peBlue * 255.0 / BlueRange);
  1887. pPal->palPalEntry[i].peFlags = (unsigned char) NULL;
  1888. }
  1890. // Create the palette
  1891. hPal = CreatePalette(pPal);
  1893. // Go ahead and select and realize the palette for this device context
  1894. // SelectPalette(hDC,(HPALETTE)hPalette,FALSE);
  1895. // RealizePalette(hDC);
  1897. // Free the memory used for the logical palette structure
  1898. free(pPal);
  1900. return hPal; // Return the handle to this palette
  1901. }
  1904. /******************************************************************************
  1905.  *                                                                            *
  1906.  * HPALETTE CreateSpectrumPalette2()                                          *
  1907.  *                                                                            *
  1908.  * Parameter:                                                                 *
  1909.  *                                                                            *
  1910.  * (none)                                                                     *
  1911.  *                                                                            *
  1912.  * Return Value:                                                              *
  1913.  *                                                                            *
  1914.  * HPALETTE         - Returns a handle to a spectrum palette or NULL if it    *
  1915.  *                    fails.                                                  *
  1916.  *                                                                            *
  1917.  * Description:                                                               *
  1918.  *                                                                            *
  1919.  * This function will build a palette with a spectrum of colors.  It is       *
  1920.  * useful when you want to display a number of DIBs each with a different     *
  1921.  * palette yet still have an a good selection of colors for the DIBs to map   *
  1922.  * to.                                                                        *
  1923.  *                                                                            *
  1924.  *****************************************************************************/
  1925. HPALETTE CreateSpectrumPalette2() 
  1926. {                 
  1927.     HPALETTE hPal;
  1928.     LPLOGPALETTE lplgPal;
  1929.     BYTE red, green, blue;
  1930.     int i; 
  1931.     
  1932.     lplgPal = (LPLOGPALETTE)GlobalAlloc(GPTR, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * MAXPALETTE); 
  1933.     if (!lplgPal)
  1934.       return NULL;
  1935.     
  1936.     lplgPal->palVersion = PALVERSION;
  1937.     lplgPal->palNumEntries = MAXPALETTE;
  1938.      
  1939.     red = green = blue = 0;
  1940.     for (i = 0; i < MAXPALETTE; i++) {
  1941.         lplgPal->palPalEntry[i].peRed   = red;
  1942.         lplgPal->palPalEntry[i].peGreen = green;
  1943.         lplgPal->palPalEntry[i].peBlue  = blue;
  1944.         lplgPal->palPalEntry[i].peFlags = (BYTE)0;
  1946.         if (!(red += 32))
  1947.             if (!(green += 32))
  1948.                 blue += 64;
  1949.     }
  1951.     hPal = CreatePalette(lplgPal);
  1952.     GlobalFree(lplgPal);
  1954.     return hPal;
  1955. }
  1957. /******************************************************************************
  1958.  *                                                                            *
  1959.  * HANDLE CopyPalette(HPALETTE hPal)                                          *
  1960.  *                                                                            *
  1961.  * Parameter:                                                                 *
  1962.  *                                                                            *
  1963.  * HPALETTE         - The handle to the palette you want to make a copy of.   *
  1964.  *                                                                            *
  1965.  * Return Value:                                                              *
  1966.  *                                                                            *
  1967.  * HPALETTE         - A copy of the palette passed as a parameter             *  
  1968.  *                                                                            *
  1969.  *****************************************************************************/
  1970. HPALETTE CopyPalette(HPALETTE hPal)
  1971. {
  1972.   HPALETTE hPalNew; 
  1973.   LPLOGPALETTE lplgPal;
  1974.   WORD iNumEntries;
  1975.   
  1976.   GetObject(hPal, sizeof(iNumEntries), &iNumEntries);
  1977.     
  1978.   lplgPal = (LPLOGPALETTE)GlobalAlloc(GPTR, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * iNumEntries); 
  1979.   if (!lplgPal)
  1980.     return NULL;
  1982.   lplgPal->palVersion = PALVERSION;
  1983.   lplgPal->palNumEntries = GetPaletteEntries(hPal, 0, iNumEntries, lplgPal->palPalEntry);
  1984.   
  1985.   hPalNew = CreatePalette(lplgPal);
  1986.   GlobalFree(lplgPal);
  1988.   return (hPalNew);
  1989. }
  1991. /******************************************************************************
  1992.  *                                                                            *
  1993.  *  FUNCTION   : CopyPaletteEx(HPALETTE hPal, BYTE bFlags)                    *
  1994.  *                                                                            *
  1995.  *  PURPOSE    : Given a handle to a palette, this function return a copy of  *
  1996.  *               the palette with all of the flags set to a the specified     *
  1997.  *               value.               *
  1998.  *                                                                            *
  1999.  *  RETURNS    : A handle to the palette.                                     *
  2000.  *                                                                            *
  2001.  *****************************************************************************/
  2002. HPALETTE CopyPaletteEx(HPALETTE hPal, BYTE bFlag)
  2003. {
  2004.    int i;
  2005.    WORD wNumColors;
  2006.    PALETTEENTRY pe[MAXPALETTE];
  2007.    HPALETTE hNewPal;
  2009.    if (!hPal || !GetObject(hPal, sizeof(wNumColors), &wNumColors))
  2010.      return NULL;
  2011.    
  2012.    hNewPal = CopyPalette(hPal);
  2013.    GetPaletteEntries(hNewPal, 0, wNumColors, (LPPALETTEENTRY)&pe);
  2015.    for (i=0; i<(int)wNumColors; i++) 
  2016.       pe[i].peFlags = bFlag;
  2017.    
  2018.    SetPaletteEntries(hNewPal, 0, wNumColors, (LPPALETTEENTRY)&pe);
  2020.    return hNewPal;
  2021. }
  2024. /******************************************************************************
  2025.  *                                                                            *
  2026.  *  HPALETTE CreateIdentityPalette(LPRGBQUAD lprgbq, int nColors)             *
  2027.  *                                                                            *
  2028.  * LPRGBQUAD        - pointer to RGBQUADs                                     *
  2029.  * int              - the number of RGBQUADs we are pointing to               *
  2030.  *                                                                            *
  2031.  * Return Value:                                                              *
  2032.  *                                                                            *
  2033.  * HPALETTE         - returns a handle to an identity palette or NULL if it   *
  2034.  *                    fails                                                   *
  2035.  *                                                                            *
  2036.  * *Note: This code was originally taken from the WinG online docs            *
  2037.  *****************************************************************************/
  2038. HPALETTE CreateIdentityPalette(LPRGBQUAD lprgbq, int nColors)
  2039. {
  2040. int i;
  2041. struct {
  2042. WORD Version;
  2043. WORD NumberOfEntries;
  2044. PALETTEENTRY aEntries[MAXPALETTE];
  2045. } Palette =
  2046. {
  2047. 0x300, 
  2048. MAXPALETTE
  2049. };
  2051. //*** Just use the screen DC where we need it
  2052. HDC hDC = GetDC(NULL);
  2054. //*** For SYSPAL_NOSTATIC, just copy the color table into
  2055. //*** a PALETTEENTRY array and replace the first and last entries
  2056. //*** with black and white
  2057. if (GetSystemPaletteUse(hDC) == SYSPAL_NOSTATIC)
  2059. {
  2060. //*** Fill in the palette with the given values, marking each
  2061. //*** as PC_NOCOLLAPSE
  2062. for(i = 0; i < nColors; i++)
  2063. {
  2064. Palette.aEntries[i].peRed = lprgbq[i].rgbRed;
  2065. Palette.aEntries[i].peGreen = lprgbq[i].rgbGreen;
  2066. Palette.aEntries[i].peBlue = lprgbq[i].rgbBlue;
  2067. Palette.aEntries[i].peFlags = PC_NOCOLLAPSE;
  2068. }
  2070. //*** Mark any unused entries PC_NOCOLLAPSE
  2071. for (; i < MAXPALETTE; ++i)
  2072. Palette.aEntries[i].peFlags = PC_NOCOLLAPSE;
  2074. //*** Make sure the last entry is white
  2075. //*** This may replace an entry in the array!
  2076. Palette.aEntries[255].peRed = 255;
  2077. Palette.aEntries[255].peGreen = 255;
  2078. Palette.aEntries[255].peBlue = 255;
  2079. Palette.aEntries[255].peFlags = 0;
  2081. //*** And the first is black
  2082. //*** This may replace an entry in the array!
  2083. Palette.aEntries[0].peRed = 0;
  2084. Palette.aEntries[0].peGreen = 0;
  2085. Palette.aEntries[0].peBlue = 0;
  2086. Palette.aEntries[0].peFlags = 0;
  2088. }
  2089. else
  2090. //*** For SYSPAL_STATIC, get the twenty static colors into
  2091. //*** the array, then fill in the empty spaces with the
  2092. //*** given color table
  2093. {
  2094. int nStaticColors;
  2095. int nUsableColors;
  2097. //*** Get the static colors from the system palette
  2098. nStaticColors = GetDeviceCaps(hDC, NUMCOLORS);
  2099. GetSystemPaletteEntries(hDC, 0, MAXPALETTE, Palette.aEntries);
  2101. //*** Set the peFlags of the lower static colors to zero
  2102. nStaticColors = nStaticColors / 2;
  2104. for (i=0; i<nStaticColors; i++)
  2105. Palette.aEntries[i].peFlags = 0;
  2107. //*** Fill in the entries from the given color table
  2108. nUsableColors = nColors - nStaticColors;   
  2109. for (; i<nUsableColors; i++)
  2110. {
  2111. Palette.aEntries[i].peRed = lprgbq[i].rgbRed;
  2112. Palette.aEntries[i].peGreen = lprgbq[i].rgbGreen;
  2113. Palette.aEntries[i].peBlue = lprgbq[i].rgbBlue;
  2114. Palette.aEntries[i].peFlags = PC_NOCOLLAPSE;
  2115. }
  2117. //*** Mark any empty entries as PC_NOCOLLAPSE
  2118.         for (; i<MAXPALETTE - nStaticColors; i++)
  2119. Palette.aEntries[i].peFlags = PC_NOCOLLAPSE;
  2121. //*** Set the peFlags of the upper static colors to zero
  2122. for (i = MAXPALETTE - nStaticColors; i<MAXPALETTE; i++)
  2123. Palette.aEntries[i].peFlags = 0;
  2124. }
  2126. //*** Remember to release the DC!
  2127. ReleaseDC(NULL, hDC);
  2129. //*** Return the palette
  2130. return CreatePalette((LPLOGPALETTE)&Palette);
  2131. }
  2133. /******************************************************************************
  2134.  *                                                                            *
  2135.  *  void ClearSystemPalette(void)                                             *
  2136.  *                                                                            *
  2137.  * Purpose:  Clears the system palette by realizing an all black palette.     *
  2138.  *           This will ensure that palette-managed applications executed      *
  2139.  *           before your application will not affect the identity mapping of  *
  2140.  *           your palette.                                                    * 
  2141.  *                                                                            *
  2142.  *                                                                            *
  2143.  * *Note: This code was originally taken from the WinG online docs            *
  2144.  *****************************************************************************/
  2145. void ClearSystemPalette(void)
  2146. {
  2147. //*** A dummy palette setup
  2148. struct
  2149. {
  2150. WORD Version;
  2151. WORD NumberOfEntries;
  2152. PALETTEENTRY aEntries[MAXPALETTE];
  2153. } Palette =
  2154. {
  2155. 0x300, 
  2156. MAXPALETTE
  2157. };
  2159. HPALETTE ScreenPalette = 0;
  2160. HDC ScreenDC;
  2161. int Counter;
  2163. //*** Reset everything in the system palette to black
  2164. for (Counter = 0; Counter < MAXPALETTE; Counter++)
  2165. {
  2166. Palette.aEntries[Counter].peRed = 0;
  2167. Palette.aEntries[Counter].peGreen = 0;
  2168. Palette.aEntries[Counter].peBlue = 0;
  2169. Palette.aEntries[Counter].peFlags = PC_NOCOLLAPSE;
  2170. }
  2172. //*** Create, select, realize, deselect, and delete the palette
  2173. ScreenDC = GetDC(NULL);
  2174. ScreenPalette = CreatePalette((LPLOGPALETTE)&Palette);
  2175. if (ScreenPalette)
  2176. {
  2177. ScreenPalette = SelectPalette(ScreenDC, ScreenPalette, FALSE);
  2178. RealizePalette(ScreenDC);
  2179. ScreenPalette = SelectPalette(ScreenDC, ScreenPalette, FALSE);
  2180. DeleteObject(ScreenPalette);
  2181. }
  2182. ReleaseDC(NULL, ScreenDC);
  2183. }