Clean up memory if have to exit early

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

diff --git a/src/msw/dib.cpp b/src/msw/dib.cpp
index ed29152759e35732ec46d39c20e227acef3f64f1..5267d9158767bfbe070775d178a966c53eb6c6f8 100644 (file)
--- a/src/msw/dib.cpp
+++ b/src/msw/dib.cpp
@@ -1,28 +1,28 @@
 /*******************************************************************************
 /*******************************************************************************

- *                                                                            *
- * MODULE      : DIB.CC                                                       *
- *                                                                            *
+ *                                                                               *
+ * MODULE        : DIB.CC                                                        *
+ *                                                                               *

  *  DESCRIPTION : Routines for dealing with Device Independent Bitmaps.        *
  *  DESCRIPTION : Routines for dealing with Device Independent Bitmaps.        *

- *                                                                            *
- *  FUNCTIONS  :                                                              *
- *                                                                            *
- *                ReadDIB()           - Reads a DIB                            *
- *                                                                            *
- *               WriteDIB()          - Writes a global handle in CF_DIB format*
- *                                     to a file.                             *
- *                                                                            *
- *               PaletteSize()       - Calculates the palette size in bytes   *
- *                                     of given DIB                           *
- *                                                                            *
- *               DibNumColors()      - Determines the number of colors in DIB *
- *                                                                            *
- *               DibFromBitmap()     - Creates a DIB repr. the DDB passed in. *
- *                                                                            *
- *                                                                            *
- *               lread()             - Private routine to read more than 64k  *
- *                                                                            *
- *               lwrite()            - Private routine to write more than 64k *
- *                                                                            *
+ *                                                                               *
+ *  FUNCTIONS        :                                                              *
+ *                                                                               *
+ *                wxReadDIB()           - Reads a DIB                            *
+ *                                                                               *
+ *                  WriteDIB()              - Writes a global handle in CF_DIB format*
+ *                                        to a file.                               *
+ *                                                                               *
+ *                  wxPaletteSize()       - Calculates the palette size in bytes   *
+ *                                        of given DIB                               *
+ *                                                                               *
+ *                  DibNumColors()      - Determines the number of colors in DIB *
+ *                                                                               *
+ *                  DibFromBitmap()     - Creates a DIB repr. the DDB passed in. *
+ *                                                                               *
+ *                                                                               *
+ *                  lread()              - Private routine to read more than 64k  *
+ *                                                                               *
+ *                  lwrite()              - Private routine to write more than 64k *
+ *                                                                               *

  *******************************************************************************/
 
 // For compilers that support precompilation, includes "wx.h".
  *******************************************************************************/
 
 // For compilers that support precompilation, includes "wx.h".


@@ -33,86 +33,85 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-#include "wx/setup.h"
-#include "wx/defs.h"

 #include "wx/bitmap.h"
 #include "wx/bitmap.h"

+#include "wx/log.h"
+#include "wx/intl.h"

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

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

 #include <memory.h>
 #endif
 
 #include "wx/msw/dib.h"
 
 #include <memory.h>
 #endif
 
 #include "wx/msw/dib.h"
 

-#ifdef __GNUWIN32__
-#include "wx/msw/gnuwin32/extra.h"
+#ifdef __GNUWIN32_OLD__
+    #include "wx/msw/gnuwin32/extra.h"

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

-#define        SEEK_CUR 1
-#define        SEEK_END 2
-#define        SEEK_SET 0
+#define        SEEK_CUR 1
+#define        SEEK_END 2
+#define        SEEK_SET 0

 #endif
 
 #endif
 

-#define MAXREAD  32768                          /* Number of bytes to be read during */
-                                                /* each read operation.                         */
+#define MAXREAD  32768                                 /* Number of bytes to be read during */
+                                                 /* each read operation.                         */

 
 /* Header signatutes for various resources */
 
 /* Header signatutes for various resources */

-#define BFT_ICON        0x4349  /* 'IC' */
-#define BFT_BITMAP 0x4d42       /* 'BM' */
-#define BFT_CURSOR 0x5450       /* 'PT' */
+#define BFT_ICON         0x4349         /* 'IC' */
+#define BFT_BITMAP 0x4d42         /* 'BM' */
+#define BFT_CURSOR 0x5450         /* 'PT(' */

 
 /* macro to determine if resource is a DIB */
 #define ISDIB(bft) ((bft) == BFT_BITMAP)
 
 /* Macro to align given value to the closest DWORD (unsigned long ) */
 
 /* macro to determine if resource is a DIB */
 #define ISDIB(bft) ((bft) == BFT_BITMAP)
 
 /* Macro to align given value to the closest DWORD (unsigned long ) */

-#define ALIGNULONG(i)  ((i+3)/4*4)
+#define ALIGNULONG(i)        ((i+3)/4*4)

 
 /* Macro to determine to round off the given value to the closest byte */
 
 /* Macro to determine to round off the given value to the closest byte */

-#define WIDTHBYTES(i)  ((i+31)/32*4)
+#define WIDTHBYTES(i)        ((i+31)/32*4)

 
 

-#define PALVERSION             0x300
-#define MAXPALETTE     256       /* max. # supported palette entries */
+#define PALVERSION                0x300
+#define MAXPALETTE        256          /* max. # supported palette entries */

 
 

-DWORD PASCAL lread(int fh, VOID FAR *pv, DWORD ul);
-DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul);
+static DWORD PASCAL lread(int fh, VOID FAR *pv, DWORD ul);
+static DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul);

 
 

-BOOL            WriteDIB (LPSTR 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);
-BOOL             ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette);
+static BOOL        WriteDIB (LPTSTR szFile,HANDLE hdib);
+WORD        wxPaletteSize (VOID FAR * pv); // This is non-static as some apps use it externally
+static WORD        DibNumColors (VOID FAR * pv);
+// HANDLE        DibFromBitmap (HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal);
+static BOOL PASCAL MakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *);

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

- *                                                                         *
- *  FUNCTION   : WriteDIB(LPSTR szFile,HANDLE hdib)                        *
- *                                                                         *
- *  PURPOSE    : Write a global handle in CF_DIB format to a file.         *
- *                                                                         *
- *  RETURNS    : TRUE  - if successful.                                    *
- *              FALSE - otherwise                                          *
- *                                                                         *
+ *                                                                            *
+ *  FUNCTION   : WriteDIB(LPSTR szFile,HANDLE hdib)                            *
+ *                                                                            *
+ *  PURPOSE    : Write a global handle in CF_DIB format to a file.            *
+ *                                                                            *
+ *  RETURNS    : TRUE  - if successful.                                     *
+ *                 FALSE - otherwise                                            *
+ *                                                                            *

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

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

 {
 {

-       BITMAPFILEHEADER        hdr;
-       LPBITMAPINFOHEADER  lpbi;
-       int                 fh;
-       OFSTRUCT            of;
+        BITMAPFILEHEADER        hdr;
+        LPBITMAPINFOHEADER  lpbi;
+        int                 fh;
+        OFSTRUCT            of;

 
 

-       if (!hdib)
-               return FALSE;
+        if (!hdib)
+                return FALSE;

 
 

-       fh = OpenFile(szFile, &of, OF_CREATE | OF_READWRITE);
-       if (fh == -1)
-               return FALSE;
+        fh = OpenFile(wxConvertWX2MB(szFile), &of, OF_CREATE | OF_READWRITE);
+        if (fh == -1)
+                return FALSE;

 
 #ifdef __WINDOWS_386__
         lpbi = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock(hdib));
 
 #ifdef __WINDOWS_386__
         lpbi = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock(hdib));


@@ -120,284 +119,284 @@ BOOL WriteDIB(LPSTR szFile, HANDLE hdib)
         lpbi = (LPBITMAPINFOHEADER) GlobalLock(hdib);
 #endif
     /* Fill in the fields of the file header */
         lpbi = (LPBITMAPINFOHEADER) GlobalLock(hdib);
 #endif
     /* Fill in the fields of the file header */

-       hdr.bfType = BFT_BITMAP;
-       hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER);
-       hdr.bfReserved1 = 0;
-       hdr.bfReserved2 = 0;
-       hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize + 
-                PaletteSize(lpbi);
+        hdr.bfType = BFT_BITMAP;
+        hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER);
+        hdr.bfReserved1 = 0;
+        hdr.bfReserved2 = 0;
+        hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize +
+                 wxPaletteSize(lpbi);

 
     /* Write the file header */
 
     /* Write the file header */

-       _lwrite(fh, (LPSTR) &hdr, sizeof(BITMAPFILEHEADER));
+        _lwrite(fh, (LPSTR) &hdr, sizeof(BITMAPFILEHEADER));

 
     /* Write the DIB header and the bits */
 
     /* Write the DIB header and the bits */

-       lwrite(fh, (LPSTR) lpbi, GlobalSize(hdib));
+        lwrite(fh, (LPSTR) lpbi, GlobalSize(hdib));

 
 

-       GlobalUnlock(hdib);
-       _lclose(fh);
-       return TRUE;
+        GlobalUnlock(hdib);
+        _lclose(fh);
+        return TRUE;

 }
 
 /****************************************************************************
 }
 
 /****************************************************************************

- *                                                                         *
- *  FUNCTION   :  PaletteSize(VOID FAR * pv)                               *
- *                                                                         *
+ *                                                                            *
+ *  FUNCTION   :  wxPaletteSize(VOID FAR * pv)                                    *
+ *                                                                            *

  *  PURPOSE    :  Calculates the palette size in bytes. If the info. block  *
  *  PURPOSE    :  Calculates the palette size in bytes. If the info. block  *

- *               is of the BITMAPCOREHEADER type, the number of colors is  *
- *               multiplied by 3 to give the palette size, otherwise the   *
- *               number of colors is multiplied by 4.                                                          *
- *                                                                         *
- *  RETURNS    :  Palette size in number of bytes.                         *
- *                                                                         *
+ *                  is of the BITMAPCOREHEADER type, the number of colors is  *
+ *                  multiplied by 3 to give the palette size, otherwise the   *
+ *                  number of colors is multiplied by 4.                                                                *
+ *                                                                            *
+ *  RETURNS    :  Palette size in number of bytes.                            *
+ *                                                                            *

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

-WORD PaletteSize(VOID FAR * pv)
+WORD wxPaletteSize(VOID FAR * pv)

 {
 {

-       LPBITMAPINFOHEADER lpbi;
-       WORD           NumColors;
+        LPBITMAPINFOHEADER lpbi;
+        WORD               NumColors;

 
 

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

 
 

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

 }
 
 /****************************************************************************
 }
 
 /****************************************************************************

- *                                                                         *
- *  FUNCTION   : DibNumColors(VOID FAR * pv)                               *
- *                                                                         *
+ *                                                                            *
+ *  FUNCTION   : DibNumColors(VOID FAR * pv)                                    *
+ *                                                                            *

  *  PURPOSE    : Determines the number of colors in the DIB by looking at   *
  *  PURPOSE    : Determines the number of colors in the DIB by looking at   *

- *              the BitCount filed in the info block.                      *
- *                                                                         *
- *  RETURNS    : The number of colors in the DIB.                          *
- *                                                                         *
+ *                 the BitCount filed in the info block.                            *
+ *                                                                            *
+ *  RETURNS    : The number of colors in the DIB.                            *
+ *                                                                            *

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

-WORD DibNumColors(VOID FAR *pv)
+static WORD DibNumColors(VOID FAR *pv)

 {
 {

-       int             bits;
-       BITMAPINFOHEADER        *lpbi;
-       BITMAPCOREHEADER        *lpbc;
+        int                 bits;
+        BITMAPINFOHEADER        *lpbi;
+        BITMAPCOREHEADER        *lpbc;

 
 

-       lpbi = ((BITMAPINFOHEADER*) pv);
-       lpbc = ((BITMAPCOREHEADER*) pv);
+        lpbi = ((BITMAPINFOHEADER*) pv);
+        lpbc = ((BITMAPCOREHEADER*) pv);

 
 

-    /* With the BITMAPINFO format headers, the size of the palette
-     * is in biClrUsed, whereas in the BITMAPCORE - style headers, it
-     * is dependent on the bits per pixel ( = 2 raised to the power of
-     * bits/pixel).
+    /*        With the BITMAPINFO format headers, the size of the palette
+     *        is in biClrUsed, whereas in the BITMAPCORE - style headers, it
+     *        is dependent on the bits per pixel ( = 2 raised to the power of
+     *        bits/pixel).

      */
      */

-       if (lpbi->biSize != sizeof(BITMAPCOREHEADER)) {
-               if (lpbi->biClrUsed != 0)
-                       return (WORD) lpbi->biClrUsed;
-               bits = lpbi->biBitCount;
-               }
-       else 
-               bits = lpbc->bcBitCount;
-
-       switch (bits) {
+        if (lpbi->biSize != sizeof(BITMAPCOREHEADER)) {
+                if (lpbi->biClrUsed != 0)
+                        return (WORD) lpbi->biClrUsed;
+                bits = lpbi->biBitCount;
+                }
+        else
+                bits = lpbc->bcBitCount;
+
+        switch (bits) {

   case 1:
   case 1:

-               return 2;
+                return 2;

   case 4:
   case 4:

-               return 16;
+                return 16;

   case 8:
   case 8:

-               return 256;
+                return 256;

   default:
   default:

-               /* A 24 bitcount DIB has no color table */
-               return 0;
-               }
+                /* A 24 bitcount DIB has no color table */
+                return 0;
+                }

 }
 
 /****************************************************************************
 }
 
 /****************************************************************************

- *                                                                         *
- *  FUNCTION   : DibFromBitmap()                                           *
- *                                                                         *
- *  PURPOSE    : Will create a global memory block in DIB format that      *
- *              represents the Device-dependent bitmap (DDB) passed in.    *
- *                                                                         *
- *  RETURNS    : A handle to the DIB                                       *
- *                                                                         *
+ *                                                                            *
+ *  FUNCTION   : DibFromBitmap()                                            *
+ *                                                                            *
+ *  PURPOSE    : Will create a global memory block in DIB format that            *
+ *                 represents the Device-dependent bitmap (DDB) passed in.    *
+ *                                                                            *
+ *  RETURNS    : A handle to the DIB                                            *
+ *                                                                            *

  ****************************************************************************/
 
 #if NOTHING
  ****************************************************************************/
 
 #if NOTHING

-HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
+static HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)

 {
 {

-       BITMAP               bm;
-       BITMAPINFOHEADER     bi;
-       BITMAPINFOHEADER FAR *lpbi;
-       DWORD                dwLen;
-       HANDLE               hdib;
-       HANDLE               h;
-       HDC                  hdc;
-
-       if (!hbm)
-               return NULL;
-
-       if (hpal == NULL)
-               hpal = GetStockObject(DEFAULT_PALETTE);
-
-       GetObject(hbm, sizeof (bm), (LPSTR) &bm);
-
-       if (biBits == 0)
-               biBits = bm.bmPlanes * bm.bmBitsPixel;
-
-       bi.biSize = sizeof(BITMAPINFOHEADER);
-       bi.biWidth = bm.bmWidth;
-       bi.biHeight = bm.bmHeight;
-       bi.biPlanes = 1;
-       bi.biBitCount = biBits;
-       bi.biCompression = biStyle;
-       bi.biSizeImage = 0;
-       bi.biXPelsPerMeter = 0;
-       bi.biYPelsPerMeter = 0;
-       bi.biClrUsed = 0;
-       bi.biClrImportant = 0;
-
-       dwLen = bi.biSize + PaletteSize(&bi);
-
-       hdc = GetDC(NULL);
-       hpal = SelectPalette(hdc, hpal, FALSE);
-       RealizePalette(hdc);
-
-       hdib = GlobalAlloc(GHND, dwLen);
-
-       if (!hdib) {
-               SelectPalette(hdc, hpal, FALSE);
-               ReleaseDC(NULL, hdc);
-               return NULL;
-               }
+        BITMAP               bm;
+        BITMAPINFOHEADER     bi;
+        BITMAPINFOHEADER FAR *lpbi;
+        DWORD                dwLen;
+        HANDLE               hdib;
+        HANDLE               h;
+        HDC                  hdc;
+
+        if (!hbm)
+                return NULL;
+
+        if (hpal == NULL)
+                hpal = GetStockObject(DEFAULT_PALETTE);
+
+        GetObject(hbm, sizeof (bm), (LPSTR) &bm);
+
+        if (biBits == 0)
+                biBits = bm.bmPlanes * bm.bmBitsPixel;
+
+        bi.biSize = sizeof(BITMAPINFOHEADER);
+        bi.biWidth = bm.bmWidth;
+        bi.biHeight = bm.bmHeight;
+        bi.biPlanes = 1;
+        bi.biBitCount = biBits;
+        bi.biCompression = biStyle;
+        bi.biSizeImage = 0;
+        bi.biXPelsPerMeter = 0;
+        bi.biYPelsPerMeter = 0;
+        bi.biClrUsed = 0;
+        bi.biClrImportant = 0;
+
+        dwLen = bi.biSize + wxPaletteSize(&bi);
+
+        hdc = GetDC((HWND) NULL);
+        hpal = SelectPalette(hdc, hpal, FALSE);
+        RealizePalette(hdc);
+
+        hdib = GlobalAlloc(GHND, dwLen);
+
+        if (!hdib) {
+                SelectPalette(hdc, hpal, FALSE);
+                ReleaseDC(NULL, hdc);
+                return NULL;
+                }

 
 #ifdef __WINDOWS_386__
 
 #ifdef __WINDOWS_386__

-       lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
+        lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));

 #else
 #else

-       lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
+        lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);

 #endif
 
 #endif
 

-       *lpbi = bi;
+        *lpbi = bi;

 
 

-    /* call GetDIBits with a NULL lpBits param, so it will calculate the
+    /*        call GetDIBits with a NULL lpBits param, so it will calculate the

      *  biSizeImage field for us
      */
      *  biSizeImage field for us
      */

-       GetDIBits(hdc, hbm, 0, (WORD) bi.biHeight,
-                NULL, (LPBITMAPINFO) lpbi, DIB_RGB_COLORS);
+        GetDIBits(hdc, hbm, 0, (WORD) bi.biHeight,
+                 NULL, (LPBITMAPINFO) lpbi, DIB_RGB_COLORS);

 
 

-       bi = *lpbi;
-       GlobalUnlock(hdib);
+        bi = *lpbi;
+        GlobalUnlock(hdib);

 
     /* If the driver did not fill in the biSizeImage field, make one up */
 
     /* If the driver did not fill in the biSizeImage field, make one up */

-       if (bi.biSizeImage == 0) {
-               bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
-
-               if (biStyle != BI_RGB)
-                       bi.biSizeImage = (bi.biSizeImage * 3) / 2;
-               }
-
-    /* realloc the buffer big enough to hold all the bits */
-       dwLen = bi.biSize + PaletteSize(&bi) + bi.biSizeImage;
-       if (h = GlobalReAlloc(hdib, dwLen, 0))
-               hdib = h;
-       else {
-               GlobalFree(hdib);
-               hdib = NULL;
-
-               SelectPalette(hdc, hpal, FALSE);
-               ReleaseDC(NULL, hdc);
-               return hdib;
-               }
-
-    /* call GetDIBits with a NON-NULL lpBits param, and actualy get the
+        if (bi.biSizeImage == 0) {
+                bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
+
+                if (biStyle != BI_RGB)
+                        bi.biSizeImage = (bi.biSizeImage * 3) / 2;
+                }
+
+    /*        realloc the buffer big enough to hold all the bits */
+        dwLen = bi.biSize + wxPaletteSize(&bi) + bi.biSizeImage;
+        if (h = GlobalReAlloc(hdib, dwLen, 0))
+                hdib = h;
+        else {
+                GlobalFree(hdib);
+                hdib = NULL;
+
+                SelectPalette(hdc, hpal, FALSE);
+                ReleaseDC(NULL, hdc);
+                return hdib;
+                }
+
+    /*        call GetDIBits with a NON-NULL lpBits param, and actualy get the

      *  bits this time
      */
 #ifdef __WINDOWS_386__
      *  bits this time
      */
 #ifdef __WINDOWS_386__

-       lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
+        lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));

 #else
 #else

-       lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
+        lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);

 #endif
 
 #endif
 

-       if (GetDIBits(hdc,
-                hbm,
-                0,
-                (WORD) bi.biHeight,
-                (LPSTR) lpbi + (WORD) lpbi->biSize + PaletteSize(lpbi),
-                (LPBITMAPINFO) lpbi, DIB_RGB_COLORS) == 0) {
-               GlobalUnlock(hdib);
-               hdib = NULL;
-               SelectPalette(hdc, hpal, FALSE);
-               ReleaseDC(NULL, hdc);
-               return NULL;
-               }
-
-       bi = *lpbi;
-       GlobalUnlock(hdib);
-
-       SelectPalette(hdc, hpal, FALSE);
-       ReleaseDC(NULL, hdc);
-       return hdib;
+        if (GetDIBits(hdc,
+                 hbm,
+                 0,
+                 (WORD) bi.biHeight,
+                 (LPSTR) lpbi + (WORD) lpbi->biSize + wxPaletteSize(lpbi),
+                 (LPBITMAPINFO) lpbi, DIB_RGB_COLORS) == 0) {
+                GlobalUnlock(hdib);
+                hdib = NULL;
+                SelectPalette(hdc, hpal, FALSE);
+                ReleaseDC((HWND) NULL, hdc);
+                return NULL;
+                }
+
+        bi = *lpbi;
+        GlobalUnlock(hdib);
+
+        SelectPalette(hdc, hpal, FALSE);
+        ReleaseDC(NULL, hdc);
+        return hdib;

 }
 #endif
 
  /************* PRIVATE ROUTINES TO READ/WRITE MORE THAN 64K ***************/
 /****************************************************************************
 }
 #endif
 
  /************* PRIVATE ROUTINES TO READ/WRITE MORE THAN 64K ***************/
 /****************************************************************************

- *                                                                         *
- *  FUNCTION   : lread(int fh, VOID FAR *pv, DWORD ul)                     *
- *                                                                         *
+ *                                                                            *
+ *  FUNCTION   : lread(int fh, VOID FAR *pv, DWORD ul)                            *
+ *                                                                            *

  *  PURPOSE    : Reads data in steps of 32k till all the data has been read.*
  *  PURPOSE    : Reads data in steps of 32k till all the data has been read.*

- *                                                                         *
- *  RETURNS    : 0 - If read did not proceed correctly.                    *
- *              number of bytes read otherwise.                            *
- *                                                                         *
+ *                                                                            *
+ *  RETURNS    : 0 - If read did not proceed correctly.                     *
+ *                 number of bytes read otherwise.                            *
+ *                                                                            *

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

-DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
+static DWORD PASCAL lread(int fh, void far *pv, DWORD ul)

 {
 {

-       DWORD     ulT = ul;
-#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
-       BYTE *hp = (BYTE *) pv;
+        DWORD     ulT = ul;
+#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)
+        BYTE *hp = (BYTE *) pv;

 #else
 #else

-       BYTE huge *hp = (BYTE huge *) pv;
+        BYTE huge *hp = (BYTE huge *) pv;

 #endif
 #endif

-       while (ul > (DWORD) MAXREAD) {
-               if (_lread(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
-                       return 0;
-               ul -= MAXREAD;
-               hp += MAXREAD;
-               }
-       if (_lread(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul)
-               return 0;
-       return ulT;
+        while (ul > (DWORD) MAXREAD) {
+                if (_lread(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
+                        return 0;
+                ul -= MAXREAD;
+                hp += MAXREAD;
+                }
+        if (_lread(fh, (LPSTR) hp, (WXUINT) ul) != (WXUINT) ul)
+                return 0;
+        return ulT;

 }
 
 /****************************************************************************
 }
 
 /****************************************************************************

- *                                                                         *
- *  FUNCTION   : lwrite(int fh, VOID FAR *pv, DWORD ul)                    *
- *                                                                         *
+ *                                                                            *
+ *  FUNCTION   : lwrite(int fh, VOID FAR *pv, DWORD ul)                     *
+ *                                                                            *

  *  PURPOSE    : Writes data in steps of 32k till all the data is written.  *
  *  PURPOSE    : Writes data in steps of 32k till all the data is written.  *

- *                                                                         *
- *  RETURNS    : 0 - If write did not proceed correctly.                   *
- *              number of bytes written otherwise.                         *
- *                                                                         *
+ *                                                                            *
+ *  RETURNS    : 0 - If write did not proceed correctly.                    *
+ *                 number of bytes written otherwise.                            *
+ *                                                                            *

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

-DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
+static DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)

 {
 {

-       DWORD     ulT = ul;
-#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
-       BYTE *hp = (BYTE *) pv;
+        DWORD     ulT = ul;
+#if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__) || defined(__WXWINE__)
+        BYTE *hp = (BYTE *) pv;

 #else
 #else

-       BYTE huge *hp = (BYTE huge *) pv;
+        BYTE huge *hp = (BYTE huge *) pv;

 #endif
 #endif

-       while (ul > MAXREAD) {
-               if (_lwrite(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
-                       return 0;
-               ul -= MAXREAD;
-               hp += MAXREAD;
-               }
-       if (_lwrite(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul)
-               return 0;
-       return ulT;
+        while (ul > MAXREAD) {
+                if (_lwrite(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
+                        return 0;
+                ul -= MAXREAD;
+                hp += MAXREAD;
+                }
+        if (_lwrite(fh, (LPSTR) hp, (WXUINT) ul) != (WXUINT) ul)
+                return 0;
+        return ulT;

 }
 
 /****************************************************************************
 }
 
 /****************************************************************************


@@ -405,25 +404,24 @@ DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
  *  FUNCTION   : ReadDIB(hWnd)
  *
  *  PURPOSE    : Reads a DIB from a file, obtains a handle to its
  *  FUNCTION   : ReadDIB(hWnd)
  *
  *  PURPOSE    : Reads a DIB from a file, obtains a handle to its

- *              BITMAPINFO struct. and loads the DIB.  Once the DIB
+ *                 BITMAPINFO struct. and loads the DIB.  Once the DIB

  *               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.
  *                       The DIBINIT structure pointed to by pInfo is
  *                       filled with the appropriate handles.

- *              FALSE - otherwise
+ *                 FALSE - otherwise

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

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

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

-    OFSTRUCT          of;
+    OFSTRUCT               of;

     BITMAPFILEHEADER   bf;
     BITMAPFILEHEADER   bf;

-    WORD               nNumColors;
+    WORD                nNumColors;

     BOOL result = FALSE;
     BOOL result = FALSE;

-    char str[128];

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


@@ -431,17 +429,16 @@ 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 (wxConvertWX2MB(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);
-       return (0);
+        wxLogError(_("Can't open file '%s'"), lpFileName);
+        return (0);

     }
     }

-    
-    hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) + 
-                                       256 * sizeof(RGBQUAD)));
+
+    hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) +
+                                            256 * sizeof(RGBQUAD)));

     if (!hDIB)
     if (!hDIB)

-       return(0);
+        return(0);

 
 #ifdef __WINDOWS_386__
     lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
 
 #ifdef __WINDOWS_386__
     lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));


@@ -451,56 +448,56 @@ BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
 
     /* read the BITMAPFILEHEADER */
     if (sizeof (bf) != _lread (fh, (LPSTR)&bf, sizeof (bf)))
 
     /* read the BITMAPFILEHEADER */
     if (sizeof (bf) != _lread (fh, (LPSTR)&bf, sizeof (bf)))

-       goto ErrExit;
+        goto ErrExit;

 
 

-    if (bf.bfType != 0x4d42)   /* 'BM' */
-       goto ErrExit;
+    if (bf.bfType != 0x4d42)        /* 'BM' */
+        goto ErrExit;

 
     if (sizeof(BITMAPCOREHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPCOREHEADER)))
 
     if (sizeof(BITMAPCOREHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPCOREHEADER)))

-       goto ErrExit;
+        goto ErrExit;

 
     if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
     {
 
     if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
     {

-       lpbi->biSize = sizeof(BITMAPINFOHEADER);
-       lpbi->biBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
-       lpbi->biPlanes = ((LPBITMAPCOREHEADER)lpbi)->bcPlanes;
-       lpbi->biHeight = ((LPBITMAPCOREHEADER)lpbi)->bcHeight;
-       lpbi->biWidth = ((LPBITMAPCOREHEADER)lpbi)->bcWidth;
-       bCoreHead = TRUE;
+        lpbi->biSize = sizeof(BITMAPINFOHEADER);
+        lpbi->biBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
+        lpbi->biPlanes = ((LPBITMAPCOREHEADER)lpbi)->bcPlanes;
+        lpbi->biHeight = ((LPBITMAPCOREHEADER)lpbi)->bcHeight;
+        lpbi->biWidth = ((LPBITMAPCOREHEADER)lpbi)->bcWidth;
+        bCoreHead = TRUE;

     }
     else
     {
     }
     else
     {

-       // get to the start of the header and read INFOHEADER
+            // get to the start of the header and read INFOHEADER

         _llseek(fh,sizeof(BITMAPFILEHEADER),SEEK_SET);
         _llseek(fh,sizeof(BITMAPFILEHEADER),SEEK_SET);

-       if (sizeof(BITMAPINFOHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER)))
-           goto ErrExit;
+        if (sizeof(BITMAPINFOHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER)))
+            goto ErrExit;

     }
 
     nNumColors = (WORD)lpbi->biClrUsed;
     if ( nNumColors == 0 )
     {
     }
 
     nNumColors = (WORD)lpbi->biClrUsed;
     if ( nNumColors == 0 )
     {

-       /* no color table for 24-bit, default size otherwise */
-       if (lpbi->biBitCount != 24)
-           nNumColors = 1 << lpbi->biBitCount; /* standard size table */
+        /* no color table for 24-bit, default size otherwise */
+        if (lpbi->biBitCount != 24)
+            nNumColors = 1 << lpbi->biBitCount;        /* standard size table */

     }
 
     }
 

-    /* fill in some default values if they are zero */
+    /*        fill in some default values if they are zero */

     if (lpbi->biClrUsed == 0)
     if (lpbi->biClrUsed == 0)

-       lpbi->biClrUsed = nNumColors;
+        lpbi->biClrUsed = nNumColors;

 
     if (lpbi->biSizeImage == 0)
     {
 
     if (lpbi->biSizeImage == 0)
     {

-       lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3)
-                        * lpbi->biHeight;
+        lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3)
+                         * 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 +
     GlobalUnlock(hDIB);
     hDIB = GlobalReAlloc(hDIB, lpbi->biSize +

-                                       nNumColors * sizeof(RGBQUAD) +
-                                       lpbi->biSizeImage, 0);
-    if (!hDIB) /* can't resize buffer for loading */
-       goto ErrExit2;
+                                            nNumColors * sizeof(RGBQUAD) +
+                                        lpbi->biSizeImage, 0);
+    if (!hDIB)        /* can't resize buffer for loading */
+        goto ErrExit2;

 
 #ifdef __WINDOWS_386__
     lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
 
 #ifdef __WINDOWS_386__
     lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));


@@ -510,28 +507,28 @@ BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
 
     /* read the color table */
     if (!bCoreHead)
 
     /* read the color table */
     if (!bCoreHead)

-       _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBQUAD));
+        _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBQUAD));

     else
     {
     else
     {

-       signed int i;
-       RGBQUAD FAR *pQuad;
-       RGBTRIPLE FAR *pTriple;
-
-       _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBTRIPLE));
-
-       pQuad = (RGBQUAD FAR *)((LPSTR)lpbi + lpbi->biSize);
-       pTriple = (RGBTRIPLE FAR *) pQuad;
-       for (i = nNumColors - 1; i >= 0; i--)
-       {
-           pQuad[i].rgbRed = pTriple[i].rgbtRed;
-           pQuad[i].rgbBlue = pTriple[i].rgbtBlue;
-           pQuad[i].rgbGreen = pTriple[i].rgbtGreen;
-           pQuad[i].rgbReserved = 0;
-       }
+        signed int i;
+        RGBQUAD FAR *pQuad;
+        RGBTRIPLE FAR *pTriple;
+
+        _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBTRIPLE));
+
+        pQuad = (RGBQUAD FAR *)((LPSTR)lpbi + lpbi->biSize);
+        pTriple = (RGBTRIPLE FAR *) pQuad;
+        for (i = nNumColors - 1; i >= 0; i--)
+        {
+            pQuad[i].rgbRed = pTriple[i].rgbtRed;
+            pQuad[i].rgbBlue = pTriple[i].rgbtBlue;
+            pQuad[i].rgbGreen = pTriple[i].rgbtGreen;
+            pQuad[i].rgbReserved = 0;
+        }

     }
 
     /* offset to the bits from start of DIB header */
     }
 
     /* offset to the bits from start of DIB header */

-    offBits = (WORD)lpbi->biSize + nNumColors * sizeof(RGBQUAD);
+    offBits = (WORD)(lpbi->biSize + nNumColors * sizeof(RGBQUAD));

 
     if (bf.bfOffBits != 0L)
     {
 
     if (bf.bfOffBits != 0L)
     {


@@ -540,28 +537,28 @@ BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
 
     if (lpbi->biSizeImage == lread(fh, (LPSTR)lpbi + offBits, lpbi->biSizeImage))
     {
 
     if (lpbi->biSizeImage == lread(fh, (LPSTR)lpbi + offBits, lpbi->biSizeImage))
     {

-       GlobalUnlock(hDIB);
-
-       hDC = GetDC(NULL);
-       if (!MakeBitmapAndPalette(hDC, hDIB, palette,
-                                       bitmap))
-       {
-           ReleaseDC(NULL,hDC);
-           goto ErrExit2;
-       }
-       else
-       {
-           ReleaseDC(NULL,hDC);
+        GlobalUnlock(hDIB);
+
+        hDC = GetDC(NULL);
+        if (!MakeBitmapAndPalette(hDC, hDIB, palette,
+                                        bitmap))
+        {
+            ReleaseDC(NULL,hDC);
+            goto ErrExit2;
+        }
+        else
+        {
+            ReleaseDC(NULL,hDC);

             GlobalFree(hDIB);
             GlobalFree(hDIB);

-           result = TRUE;
-       }
+            result = TRUE;
+        }

     }
     else
     {
 ErrExit:
     }
     else
     {
 ErrExit:

-       GlobalUnlock(hDIB);
+        GlobalUnlock(hDIB);

 ErrExit2:
 ErrExit2:

-       GlobalFree(hDIB);
+        GlobalFree(hDIB);

     }
 
     _lclose(fh);
     }
 
     _lclose(fh);


@@ -576,15 +573,15 @@ 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
  *                         not valid
  *
  ****************************************************************************/
  *                         appropriate handles.  Caller is responsible
  *                         for freeing objects.
  *               FALSE --> unable to create objects.  both pointer are
  *                         not valid
  *
  ****************************************************************************/

-BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
-                       HPALETTE * phPal, HBITMAP * phBitmap)
+static BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
+                        HPALETTE * phPal, HBITMAP * phBitmap)

 {
     LPBITMAPINFOHEADER lpInfo;
     BOOL result = FALSE;
 {
     LPBITMAPINFOHEADER lpInfo;
     BOOL result = FALSE;


@@ -598,50 +595,56 @@ BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
     lpInfo = (LPBITMAPINFOHEADER) GlobalLock(hDIB);
 #endif
 
     lpInfo = (LPBITMAPINFOHEADER) GlobalLock(hDIB);
 #endif
 

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

     if ( hPalette )
     {
     if ( hPalette )
     {

-       // Need to realize palette for converting DIB to bitmap.
-       hOldPal = SelectPalette(hDC, hPalette, TRUE);
-       RealizePalette(hDC);
-
-       lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize + 
-               (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
-       hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits, 
-                               (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
-
-       SelectPalette(hDC, hOldPal, TRUE);
-       RealizePalette(hDC);
-
-       if (!hBitmap)
-           DeleteObject(hPalette);
-       else
-       {
-           *phBitmap = hBitmap;
-           *phPal = hPalette;
-           result = TRUE;
-       }
+        // Need to realize palette for converting DIB to bitmap.
+        hOldPal = SelectPalette(hDC, hPalette, TRUE);
+        RealizePalette(hDC);
+
+        lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize +
+                (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
+        hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits,
+                                (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
+
+        SelectPalette(hDC, hOldPal, TRUE);
+        RealizePalette(hDC);
+
+        if (!hBitmap)
+            DeleteObject(hPalette);
+        else
+        {
+            *phBitmap = hBitmap;
+            *phPal = hPalette;
+            result = TRUE;
+        }

     }
     }

+
+       GlobalUnlock (hDIB);  // glt
+

     return(result);
 }
 
 /****************************************************************************
     return(result);
 }
 
 /****************************************************************************

- *                                                                         *
- *  FUNCTION   : MakeDIBPalette(lpInfo)                                            *
- *                                                                         *
- *  PURPOSE    : Given a BITMAPINFOHEADER, create a palette based on 
- *              the color table.
- *              
- *                                                                         *
- *  RETURNS    : non-zero - handle of a corresponding palette 
- *              zero - unable to create palette
- *                                                                         *
+ *                                                                            *
+ *  FUNCTION   : wxMakeDIBPalette(lpInfo)                                            *
+ *                                                                            *
+ *  PURPOSE    : Given a BITMAPINFOHEADER, create a palette based on
+ *                 the color table.
+ *
+ *                                                                            *
+ *  RETURNS    : non-zero - handle of a corresponding palette
+ *                 zero - unable to create palette
+ *                                                                            *

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

-HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
+HPALETTE wxMakeDIBPalette(LPBITMAPINFOHEADER lpInfo)

 {
 {

-    NPLOGPALETTE npPal;
+#ifdef __WXWINE__
+        return (FALSE);
+#else
+    LPLOGPALETTE npPal;

     RGBQUAD far *lpRGB;
     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,


@@ -650,35 +653,34 @@ HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
     if (lpInfo->biClrUsed)
     {
 /*
     if (lpInfo->biClrUsed)
     {
 /*

-       npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) + 
-                               (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
+        npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
+                                (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));

 */
 */

-       npPal = (NPLOGPALETTE)malloc(sizeof(LOGPALETTE) + 
-                               (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
-
+        npPal = (LPLOGPALETTE)malloc(sizeof(LOGPALETTE) +
+                                (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));

         if (!npPal)
         if (!npPal)

-           return(FALSE);
+            return NULL;

 
 

-       npPal->palVersion = 0x300;
-       npPal->palNumEntries = (WORD)lpInfo->biClrUsed;
+        npPal->palVersion = 0x300;
+        npPal->palNumEntries = (WORD)lpInfo->biClrUsed;

 
 

-       /* get pointer to the color table */
-       lpRGB = (RGBQUAD FAR *)((LPSTR)lpInfo + lpInfo->biSize);
+        /* get pointer to the color table */
+        lpRGB = (RGBQUAD FAR *)((LPSTR)lpInfo + lpInfo->biSize);

 
 

-       /* copy colors from the color table to the LogPalette structure */
-       for (i = 0; i < lpInfo->biClrUsed; i++, lpRGB++)
-       {
-           npPal->palPalEntry[i].peRed = lpRGB->rgbRed;
-           npPal->palPalEntry[i].peGreen = lpRGB->rgbGreen;
-           npPal->palPalEntry[i].peBlue = lpRGB->rgbBlue;
-           npPal->palPalEntry[i].peFlags = 0;
-       }
+        /* copy colors from the color table to the LogPalette structure */
+        for (i = 0; (DWORD)i < lpInfo->biClrUsed; i++, lpRGB++)
+        {
+            npPal->palPalEntry[i].peRed = lpRGB->rgbRed;
+            npPal->palPalEntry[i].peGreen = lpRGB->rgbGreen;
+            npPal->palPalEntry[i].peBlue = lpRGB->rgbBlue;
+            npPal->palPalEntry[i].peFlags = 0;
+        }

 
 

-       hLogPal = CreatePalette((LPLOGPALETTE)npPal);
-//     LocalFree((HANDLE)npPal);
+        hLogPal = CreatePalette((LPLOGPALETTE)npPal);
+//        LocalFree((HANDLE)npPal);

         free(npPal);
         free(npPal);

-        
-       return(hLogPal);
+
+        return(hLogPal);

     }
 
     /* 24-bit DIB with no color table.  return default palette.  Another
     }
 
     /* 24-bit DIB with no color table.  return default palette.  Another


@@ -686,30 +688,35 @@ HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
     ** some good color choices.
     */
     else
     ** some good color choices.
     */
     else

-       return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
+        return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
+#endif
+

 }
 
 }
 

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

 {
 {

-  HBITMAP hBitmap;
-  HPALETTE hPalette;
+  HBITMAP hBitmap = NULL;
+  HPALETTE hPalette = NULL;

 
 

-  bool success = (ReadDIB(filename, &hBitmap, &hPalette) != 0);
+  bool success = (wxReadDIB(filename, &hBitmap, &hPalette) != 0);

 
   if (!success)
   {
 
   if (!success)
   {

-    DeleteObject(hPalette);
+    if (hPalette)
+        DeleteObject(hPalette);

     return FALSE;
   }
 
   if (hPalette)
   {
     return FALSE;
   }
 
   if (hPalette)
   {

+#if wxUSE_PALETTE

     if (pal)
     {
       *pal = new wxPalette;
       (*pal)->SetHPALETTE((WXHPALETTE) hPalette);
     }
     else
     if (pal)
     {
       *pal = new wxPalette;
       (*pal)->SetHPALETTE((WXHPALETTE) hPalette);
     }
     else

+#endif // wxUSE_PALETTE

       DeleteObject(hPalette);
   }
   else if (pal)
       DeleteObject(hPalette);
   }
   else if (pal)


@@ -724,13 +731,15 @@ bool wxLoadIntoBitmap(char *filename, wxBitmap *bitmap, wxPalette **pal)
     bitmap->SetWidth(bm.bmWidth);
     bitmap->SetHeight(bm.bmHeight);
     bitmap->SetDepth(bm.bmPlanes * bm.bmBitsPixel);
     bitmap->SetWidth(bm.bmWidth);
     bitmap->SetHeight(bm.bmHeight);
     bitmap->SetDepth(bm.bmPlanes * bm.bmBitsPixel);

+#if WXWIN_COMPATIBILITY_2

     bitmap->SetOk(TRUE);
     bitmap->SetOk(TRUE);

+#endif // WXWIN_COMPATIBILITY_2

     return TRUE;
   }
   else return FALSE;
 }
 
     return TRUE;
   }
   else return FALSE;
 }
 

-wxBitmap *wxLoadBitmap(char *filename, wxPalette **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))


@@ -770,10 +779,10 @@ wxBitmap *wxLoadBitmap(char *filename, wxPalette **pal)
 //
 // History:   Date      Reason
 //            11/07/91  Created
 //
 // History:   Date      Reason
 //            11/07/91  Created

-//             
+//

 //---------------------------------------------------------------------
 
 //---------------------------------------------------------------------
 

-void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,
+static void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,

                                         DWORD dwWidth,
                                         DWORD dwHeight,
                                           int nBPP)
                                         DWORD dwWidth,
                                         DWORD dwHeight,
                                           int nBPP)


@@ -806,9 +815,9 @@ void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,
 
 
 
 
 
 

-LPSTR FindDIBBits (LPSTR lpbi)
+LPSTR wxFindDIBBits (LPSTR lpbi)

 {
 {

-   return (lpbi + *(LPDWORD)lpbi + PaletteSize (lpbi));
+   return (lpbi + *(LPDWORD)lpbi + wxPaletteSize (lpbi));

 }
 
 //---------------------------------------------------------------------
 }
 
 //---------------------------------------------------------------------


@@ -828,10 +837,10 @@ 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 wxBitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)

 {
    BITMAP             Bitmap;
    BITMAPINFOHEADER   bmInfoHdr;
 {
    BITMAP             Bitmap;
    BITMAPINFOHEADER   bmInfoHdr;


@@ -851,17 +860,17 @@ 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) + 
-             PaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);
+   hDIB = GlobalAlloc (GHND, sizeof (BITMAPINFOHEADER) +
+             wxPaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);

 
    if (!hDIB)
       return NULL;
 
    if (!hDIB)
       return NULL;


@@ -873,7 +882,7 @@ HANDLE BitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
 #endif
 
    *lpbmInfoHdr = bmInfoHdr;
 #endif
 
    *lpbmInfoHdr = bmInfoHdr;

-   lpBits       = FindDIBBits ((LPSTR) lpbmInfoHdr);
+   lpBits       = wxFindDIBBits ((LPSTR) lpbmInfoHdr);

 
 
       // Now, we need a DC to hold our bitmap.  If the app passed us
 
 
       // Now, we need a DC to hold our bitmap.  If the app passed us


@@ -893,12 +902,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);


@@ -919,13 +928,15 @@ HANDLE BitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
    return hDIB;
 }
 
    return hDIB;
 }
 

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

 {
   HPALETTE hPalette = 0;
 {
   HPALETTE hPalette = 0;

+#if wxUSE_PALETTE

   if (colourmap)
     hPalette = (HPALETTE) colourmap->GetHPALETTE();
   if (colourmap)
     hPalette = (HPALETTE) colourmap->GetHPALETTE();

+#endif // wxUSE_PALETTE

 
 

-  HANDLE dibHandle = BitmapToDIB((HBITMAP) bitmap->GetHBITMAP(), hPalette);
+  HANDLE dibHandle = wxBitmapToDIB((HBITMAP) bitmap->GetHBITMAP(), hPalette);

   if (dibHandle)
   {
     bool success = (WriteDIB(filename, dibHandle) != 0);
   if (dibHandle)
   {
     bool success = (WriteDIB(filename, dibHandle) != 0);


@@ -935,4 +946,3 @@ bool wxSaveBitmap(char *filename, wxBitmap *bitmap, wxPalette *colourmap)
   else return FALSE;
 }
 
   else return FALSE;
 }
 

-