Removed USING_CONFIGURE define. As VZ pointed out, checking HAVE_CONFIG_H

[wxWidgets.git] / src / msw / dib.cpp

diff --git a/src/msw/dib.cpp b/src/msw/dib.cpp
index d86337576a86a2206a20122aece28253af39d405..54ccf8ab88cf35239c1b7119448fee8660c07a7c 100644 (file)
--- a/src/msw/dib.cpp
+++ b/src/msw/dib.cpp
@@ -26,7 +26,6 @@
  *******************************************************************************/
 
 // For compilers that support precompilation, includes "wx.h".
  *******************************************************************************/
 
 // For compilers that support precompilation, includes "wx.h".

-#define IN_WX_MAIN_CPP

 #include "wx/wxprec.h"
 
 #if defined(__BORLANDC__)
 #include "wx/wxprec.h"
 
 #if defined(__BORLANDC__)


@@ -36,18 +35,24 @@
 #ifndef WX_PRECOMP
 #include "wx/setup.h"
 #include "wx/defs.h"
 #ifndef WX_PRECOMP
 #include "wx/setup.h"
 #include "wx/defs.h"

+#include "wx/bitmap.h"

 #endif
 
 #include <windows.h>
 #include <stdio.h>
 #include <stdlib.h>
 #endif
 
 #include <windows.h>
 #include <stdio.h>
 #include <stdlib.h>

+
+#if !defined(__MWERKS__) && !defined(__SALFORDC__)

 #include <memory.h>
 #include <memory.h>

+#endif

 
 #include "wx/msw/dib.h"
 
 
 #include "wx/msw/dib.h"
 

+#ifndef __TWIN32__

 #ifdef __GNUWIN32__
 #include "wx/msw/gnuwin32/extra.h"
 #endif
 #ifdef __GNUWIN32__
 #include "wx/msw/gnuwin32/extra.h"
 #endif

+#endif

 
 #ifndef SEEK_CUR
 /* flags for _lseek */
 
 #ifndef SEEK_CUR
 /* flags for _lseek */


@@ -79,13 +84,13 @@
 DWORD PASCAL lread(int fh, VOID FAR *pv, DWORD ul);
 DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul);
 
 DWORD PASCAL lread(int fh, VOID FAR *pv, DWORD ul);
 DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul);
 

-BOOL            WriteDIB (LPSTR szFile,HANDLE hdib);
+BOOL            WriteDIB (LPTSTR szFile,HANDLE hdib);

 WORD            PaletteSize (VOID FAR * pv);
 WORD            DibNumColors (VOID FAR * pv);
 // HANDLE               DibFromBitmap (HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal);
 BOOL             PASCAL MakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *);
 HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER);
 WORD            PaletteSize (VOID FAR * pv);
 WORD            DibNumColors (VOID FAR * pv);
 // HANDLE               DibFromBitmap (HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal);
 BOOL             PASCAL MakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *);
 HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER);

-BOOL             ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette);
+BOOL             ReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette);

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


@@ -98,7 +103,7 @@ BOOL             ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette);
  *                                                                         *
  ****************************************************************************/
 
  *                                                                         *
  ****************************************************************************/
 

-BOOL WriteDIB(LPSTR szFile, HANDLE hdib)
+BOOL WriteDIB(LPTSTR szFile, HANDLE hdib)

 {
        BITMAPFILEHEADER        hdr;
        LPBITMAPINFOHEADER  lpbi;
 {
        BITMAPFILEHEADER        hdr;
        LPBITMAPINFOHEADER  lpbi;


@@ -108,7 +113,7 @@ BOOL WriteDIB(LPSTR szFile, HANDLE hdib)
        if (!hdib)
                return FALSE;
 
        if (!hdib)
                return FALSE;
 

-       fh = OpenFile(szFile, &of, OF_CREATE | OF_READWRITE);
+       fh = OpenFile(wxFNCONV(szFile), &of, OF_CREATE | OF_READWRITE);

        if (fh == -1)
                return FALSE;
 
        if (fh == -1)
                return FALSE;
 


@@ -122,7 +127,7 @@ BOOL WriteDIB(LPSTR szFile, HANDLE hdib)
        hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER);
        hdr.bfReserved1 = 0;
        hdr.bfReserved2 = 0;
        hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER);
        hdr.bfReserved1 = 0;
        hdr.bfReserved2 = 0;

-       hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize + 
+       hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize +

                 PaletteSize(lpbi);
 
     /* Write the file header */
                 PaletteSize(lpbi);
 
     /* Write the file header */


@@ -159,7 +164,7 @@ WORD PaletteSize(VOID FAR * pv)
 
        if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
                return NumColors * sizeof(RGBTRIPLE);
 
        if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
                return NumColors * sizeof(RGBTRIPLE);

-       else 
+       else

                return NumColors * sizeof(RGBQUAD);
 }
 
                return NumColors * sizeof(RGBQUAD);
 }
 


@@ -193,7 +198,7 @@ WORD DibNumColors(VOID FAR *pv)
                        return (WORD) lpbi->biClrUsed;
                bits = lpbi->biBitCount;
                }
                        return (WORD) lpbi->biClrUsed;
                bits = lpbi->biBitCount;
                }

-       else 
+       else

                bits = lpbc->bcBitCount;
 
        switch (bits) {
                bits = lpbc->bcBitCount;
 
        switch (bits) {


@@ -256,7 +261,7 @@ HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
 
        dwLen = bi.biSize + PaletteSize(&bi);
 
 
        dwLen = bi.biSize + PaletteSize(&bi);
 

-       hdc = GetDC(NULL);
+       hdc = GetDC((HWND) NULL);

        hpal = SelectPalette(hdc, hpal, FALSE);
        RealizePalette(hdc);
 
        hpal = SelectPalette(hdc, hpal, FALSE);
        RealizePalette(hdc);
 


@@ -324,7 +329,7 @@ HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
                GlobalUnlock(hdib);
                hdib = NULL;
                SelectPalette(hdc, hpal, FALSE);
                GlobalUnlock(hdib);
                hdib = NULL;
                SelectPalette(hdc, hpal, FALSE);

-               ReleaseDC(NULL, hdc);
+               ReleaseDC((HWND) NULL, hdc);

                return NULL;
                }
 
                return NULL;
                }
 


@@ -352,7 +357,7 @@ HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
 DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
 {
        DWORD     ulT = ul;
 DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
 {
        DWORD     ulT = ul;

-#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
+#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)

        BYTE *hp = (BYTE *) pv;
 #else
        BYTE huge *hp = (BYTE huge *) pv;
        BYTE *hp = (BYTE *) pv;
 #else
        BYTE huge *hp = (BYTE huge *) pv;


@@ -382,7 +387,7 @@ DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
 DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
 {
        DWORD     ulT = ul;
 DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
 {
        DWORD     ulT = ul;

-#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
+#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)

        BYTE *hp = (BYTE *) pv;
 #else
        BYTE huge *hp = (BYTE huge *) pv;
        BYTE *hp = (BYTE *) pv;
 #else
        BYTE huge *hp = (BYTE huge *) pv;


@@ -407,13 +412,13 @@ DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
  *               is loaded, the function also creates a bitmap and
  *               palette out of the DIB for a device-dependent form.
  *
  *               is loaded, the function also creates a bitmap and
  *               palette out of the DIB for a device-dependent form.
  *

- *  RETURNS    : TRUE  - DIB loaded and bitmap/palette created 
+ *  RETURNS    : TRUE  - DIB loaded and bitmap/palette created

  *                       The DIBINIT structure pointed to by pInfo is
  *                       filled with the appropriate handles.
  *              FALSE - otherwise
  *
  ****************************************************************************/
  *                       The DIBINIT structure pointed to by pInfo is
  *                       filled with the appropriate handles.
  *              FALSE - otherwise
  *
  ****************************************************************************/

-BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
+BOOL ReadDIB(LPTSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)

 {
     int fh;
     LPBITMAPINFOHEADER lpbi;
 {
     int fh;
     LPBITMAPINFOHEADER lpbi;


@@ -421,7 +426,7 @@ BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
     BITMAPFILEHEADER   bf;
     WORD               nNumColors;
     BOOL result = FALSE;
     BITMAPFILEHEADER   bf;
     WORD               nNumColors;
     BOOL result = FALSE;

-    char str[128];
+    wxChar str[128];

     WORD offBits;
     HDC hDC;
     BOOL bCoreHead = FALSE;
     WORD offBits;
     HDC hDC;
     BOOL bCoreHead = FALSE;


@@ -429,14 +434,14 @@ BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
 
     /* Open the file and get a handle to it's BITMAPINFO */
 
 
     /* Open the file and get a handle to it's BITMAPINFO */
 

-    fh = OpenFile (lpFileName, &of, OF_READ);
+    fh = OpenFile (wxFNCONV(lpFileName), &of, OF_READ);

     if (fh == -1) {
     if (fh == -1) {

-       wsprintf(str,"Can't open file '%ls'", (LPSTR)lpFileName);
-       MessageBox(NULL, str, "Error", MB_ICONSTOP | MB_OK);
+        wsprintf(str,_T("Can't open file '%s'"), lpFileName);
+       MessageBox(NULL, str, _T("Error"), MB_ICONSTOP | MB_OK);

        return (0);
     }
        return (0);
     }

-    
-    hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) + 
+
+    hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) +

                                        256 * sizeof(RGBQUAD)));
     if (!hDIB)
        return(0);
                                        256 * sizeof(RGBQUAD)));
     if (!hDIB)
        return(0);


@@ -474,7 +479,8 @@ BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
            goto ErrExit;
     }
 
            goto ErrExit;
     }
 

-    if (!(nNumColors = (WORD)lpbi->biClrUsed))
+    nNumColors = (WORD)lpbi->biClrUsed;
+    if ( nNumColors == 0 )

     {
        /* no color table for 24-bit, default size otherwise */
        if (lpbi->biBitCount != 24)
     {
        /* no color table for 24-bit, default size otherwise */
        if (lpbi->biBitCount != 24)


@@ -491,7 +497,7 @@ BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
                         * lpbi->biHeight;
     }
 
                         * lpbi->biHeight;
     }
 

-    /* get a proper-sized buffer for header, color table and bits */ 
+    /* get a proper-sized buffer for header, color table and bits */

     GlobalUnlock(hDIB);
     hDIB = GlobalReAlloc(hDIB, lpbi->biSize +
                                        nNumColors * sizeof(RGBQUAD) +
     GlobalUnlock(hDIB);
     hDIB = GlobalReAlloc(hDIB, lpbi->biSize +
                                        nNumColors * sizeof(RGBQUAD) +


@@ -573,7 +579,7 @@ ErrExit2:
  *               to be used for a device-dependent representation of
  *               of the image.
  *
  *               to be used for a device-dependent representation of
  *               of the image.
  *

- *  RETURNS    : TRUE  --> success. phPal and phBitmap are filled with 
+ *  RETURNS    : TRUE  --> success. phPal and phBitmap are filled with

  *                         appropriate handles.  Caller is responsible
  *                         for freeing objects.
  *               FALSE --> unable to create objects.  both pointer are
  *                         appropriate handles.  Caller is responsible
  *                         for freeing objects.
  *               FALSE --> unable to create objects.  both pointer are


@@ -595,15 +601,16 @@ BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
     lpInfo = (LPBITMAPINFOHEADER) GlobalLock(hDIB);
 #endif
 
     lpInfo = (LPBITMAPINFOHEADER) GlobalLock(hDIB);
 #endif
 

-    if ((hPalette = MakeDIBPalette(lpInfo)))
+    hPalette = MakeDIBPalette(lpInfo);
+    if ( hPalette )

     {
        // Need to realize palette for converting DIB to bitmap.
        hOldPal = SelectPalette(hDC, hPalette, TRUE);
        RealizePalette(hDC);
 
     {
        // Need to realize palette for converting DIB to bitmap.
        hOldPal = SelectPalette(hDC, hPalette, TRUE);
        RealizePalette(hDC);
 

-       lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize + 
+       lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize +

                (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
                (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);

-       hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits, 
+       hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits,

                                (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
 
        SelectPalette(hDC, hOldPal, TRUE);
                                (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
 
        SelectPalette(hDC, hOldPal, TRUE);


@@ -625,19 +632,22 @@ BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
  *                                                                         *
  *  FUNCTION   : MakeDIBPalette(lpInfo)                                            *
  *                                                                         *
  *                                                                         *
  *  FUNCTION   : MakeDIBPalette(lpInfo)                                            *
  *                                                                         *

- *  PURPOSE    : Given a BITMAPINFOHEADER, create a palette based on 
+ *  PURPOSE    : Given a BITMAPINFOHEADER, create a palette based on

  *              the color table.
  *              the color table.

- *              
+ *

  *                                                                         *
  *                                                                         *

- *  RETURNS    : non-zero - handle of a corresponding palette 
+ *  RETURNS    : non-zero - handle of a corresponding palette

  *              zero - unable to create palette
  *                                                                         *
  ****************************************************************************/
 HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
 {
  *              zero - unable to create palette
  *                                                                         *
  ****************************************************************************/
 HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
 {

+#ifdef __WXWINE__
+        return (FALSE);
+#else

     NPLOGPALETTE npPal;
     RGBQUAD far *lpRGB;
     NPLOGPALETTE npPal;
     RGBQUAD far *lpRGB;

-    HPALETTE hLogPal; 
+    HPALETTE hLogPal;

     WORD i;
 
     /* since biClrUsed field was filled during the loading of the DIB,
     WORD i;
 
     /* since biClrUsed field was filled during the loading of the DIB,


@@ -646,12 +656,11 @@ HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
     if (lpInfo->biClrUsed)
     {
 /*
     if (lpInfo->biClrUsed)
     {
 /*

-       npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) + 
+       npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +

                                (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
 */
                                (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
 */

-       npPal = (NPLOGPALETTE)malloc(sizeof(LOGPALETTE) + 
+       npPal = (NPLOGPALETTE)malloc(sizeof(LOGPALETTE) +

                                (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
                                (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));

-

         if (!npPal)
            return(FALSE);
 
         if (!npPal)
            return(FALSE);
 


@@ -673,7 +682,7 @@ HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
        hLogPal = CreatePalette((LPLOGPALETTE)npPal);
 //     LocalFree((HANDLE)npPal);
         free(npPal);
        hLogPal = CreatePalette((LPLOGPALETTE)npPal);
 //     LocalFree((HANDLE)npPal);
         free(npPal);

-        
+

        return(hLogPal);
     }
 
        return(hLogPal);
     }
 


@@ -683,9 +692,11 @@ HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
     */
     else
        return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
     */
     else
        return((HPALETTE) GetStockObject(DEFAULT_PALETTE));

+#endif
+

 }
 
 }
 

-bool wxLoadIntoBitmap(char *filename, wxBitmap *bitmap, wxColourMap **pal)
+bool wxLoadIntoBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette **pal)

 {
   HBITMAP hBitmap;
   HPALETTE hPalette;
 {
   HBITMAP hBitmap;
   HPALETTE hPalette;


@@ -702,7 +713,7 @@ bool wxLoadIntoBitmap(char *filename, wxBitmap *bitmap, wxColourMap **pal)
   {
     if (pal)
     {
   {
     if (pal)
     {

-      *pal = new wxColourMap;
+      *pal = new wxPalette;

       (*pal)->SetHPALETTE((WXHPALETTE) hPalette);
     }
     else
       (*pal)->SetHPALETTE((WXHPALETTE) hPalette);
     }
     else


@@ -726,7 +737,7 @@ bool wxLoadIntoBitmap(char *filename, wxBitmap *bitmap, wxColourMap **pal)
   else return FALSE;
 }
 
   else return FALSE;
 }
 

-wxBitmap *wxLoadBitmap(char *filename, wxColourMap **pal)
+wxBitmap *wxLoadBitmap(wxChar *filename, wxPalette **pal)

 {
   wxBitmap *bitmap = new wxBitmap;
   if (wxLoadIntoBitmap(filename, bitmap, pal))
 {
   wxBitmap *bitmap = new wxBitmap;
   if (wxLoadIntoBitmap(filename, bitmap, pal))


@@ -766,7 +777,7 @@ wxBitmap *wxLoadBitmap(char *filename, wxColourMap **pal)
 //
 // History:   Date      Reason
 //            11/07/91  Created
 //
 // History:   Date      Reason
 //            11/07/91  Created

-//             
+//

 //---------------------------------------------------------------------
 
 void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,
 //---------------------------------------------------------------------
 
 void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,


@@ -824,7 +835,7 @@ LPSTR FindDIBBits (LPSTR lpbi)
 //
 // History:   Date      Reason
 //             6/01/91  Created
 //
 // History:   Date      Reason
 //             6/01/91  Created

-//             
+//

 //---------------------------------------------------------------------
 
 HANDLE BitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
 //---------------------------------------------------------------------
 
 HANDLE BitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)


@@ -847,16 +858,16 @@ HANDLE BitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
    if (!GetObject (hBitmap, sizeof (Bitmap), (LPSTR) &Bitmap))
       return NULL;
 
    if (!GetObject (hBitmap, sizeof (Bitmap), (LPSTR) &Bitmap))
       return NULL;
 

-   InitBitmapInfoHeader (&bmInfoHdr, 
-                         Bitmap.bmWidth, 
-                         Bitmap.bmHeight, 
+   InitBitmapInfoHeader (&bmInfoHdr,
+                         Bitmap.bmWidth,
+                         Bitmap.bmHeight,

                          Bitmap.bmPlanes * Bitmap.bmBitsPixel);
 
 
       // Now allocate memory for the DIB.  Then, set the BITMAPINFOHEADER
       //  into this memory, and find out where the bitmap bits go.
 
                          Bitmap.bmPlanes * Bitmap.bmBitsPixel);
 
 
       // Now allocate memory for the DIB.  Then, set the BITMAPINFOHEADER
       //  into this memory, and find out where the bitmap bits go.
 

-   hDIB = GlobalAlloc (GHND, sizeof (BITMAPINFOHEADER) + 
+   hDIB = GlobalAlloc (GHND, sizeof (BITMAPINFOHEADER) +

              PaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);
 
    if (!hDIB)
              PaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);
 
    if (!hDIB)


@@ -889,12 +900,12 @@ HANDLE BitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
       //  it party on our bitmap.  It will fill in the color table,
       //  and bitmap bits of our global memory block.
 
       //  it party on our bitmap.  It will fill in the color table,
       //  and bitmap bits of our global memory block.
 

-   if (!GetDIBits (hMemDC, 
-                   hBitmap, 
-                   0, 
-                   Bitmap.bmHeight, 
-                   lpBits, 
-                   (LPBITMAPINFO) lpbmInfoHdr, 
+   if (!GetDIBits (hMemDC,
+                   hBitmap,
+                   0,
+                   Bitmap.bmHeight,
+                   lpBits,
+                   (LPBITMAPINFO) lpbmInfoHdr,

                    DIB_RGB_COLORS))
       {
       GlobalUnlock (hDIB);
                    DIB_RGB_COLORS))
       {
       GlobalUnlock (hDIB);


@@ -915,7 +926,7 @@ HANDLE BitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
    return hDIB;
 }
 
    return hDIB;
 }
 

-bool wxSaveBitmap(char *filename, wxBitmap *bitmap, wxColourMap *colourmap)
+bool wxSaveBitmap(wxChar *filename, wxBitmap *bitmap, wxPalette *colourmap)

 {
   HPALETTE hPalette = 0;
   if (colourmap)
 {
   HPALETTE hPalette = 0;
   if (colourmap)