bitmap and image updates

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

diff --git a/src/msw/dibutils.cpp b/src/msw/dibutils.cpp
index f592823605afdddd16eec07d5922d7b9fe481986..c52aa3bfaa50cae55107d21976b4d7c47a2af497 100644 (file)
--- a/src/msw/dibutils.cpp
+++ b/src/msw/dibutils.cpp
@@ -6,7 +6,7 @@
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Microsoft, Julian Smart and Markus Holzem
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Microsoft, Julian Smart and Markus Holzem

-// Licence:    wxWindows license
+// Licence:     wxWindows license

 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
 /////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__


@@ -21,21 +21,26 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-#include <stdio.h>

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

+#include "wx/string.h"

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

-#include <wx/msw/dibutils.h>
+
+#include "wx/msw/dibutils.h"
+
+#ifdef __WXWINE__
+  #include <module.h>
+#endif

 
 #if defined(__WIN32__)
 
 #if defined(__WIN32__)

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

     #include <memory.h>             // for _fmemcpy()
 #endif
     #include <memory.h>             // for _fmemcpy()
 #endif

-        #define _huge
+   #define _huge

 #ifndef hmemcpy
     #define hmemcpy memcpy
 #endif
 #ifndef hmemcpy
     #define hmemcpy memcpy
 #endif


@@ -43,20 +48,41 @@
 
 #define BFT_ICON   0x4349   /* 'IC' */
 #define BFT_BITMAP 0x4d42   /* 'BM' */
 
 #define BFT_ICON   0x4349   /* 'IC' */
 #define BFT_BITMAP 0x4d42   /* 'BM' */

-#define BFT_CURSOR 0x5450   /* 'PT' */
+#define BFT_CURSOR 0x5450   /* 'PT(' */

 
 

+#ifndef SEEK_CUR

 /* flags for _lseek */
 #define  SEEK_CUR 1
 #define  SEEK_END 2
 #define  SEEK_SET 0
 /* flags for _lseek */
 #define  SEEK_CUR 1
 #define  SEEK_END 2
 #define  SEEK_SET 0

+#endif
+
+/* Copied from PNGhandler for coompilation with MingW32, RR */
+
+#ifndef GlobalAllocPtr
+#define     GlobalPtrHandle(lp)         \
+                ((HGLOBAL)GlobalHandle(lp))
+
+#define     GlobalLockPtr(lp)                \
+                ((BOOL)GlobalLock(GlobalPtrHandle(lp)))
+#define     GlobalUnlockPtr(lp)      \
+                GlobalUnlock(GlobalPtrHandle(lp))
+
+#define     GlobalAllocPtr(flags, cb)        \
+                (GlobalLock(GlobalAlloc((flags), (cb))))
+#define     GlobalReAllocPtr(lp, cbNew, flags)       \
+                (GlobalUnlockPtr(lp), GlobalLock(GlobalReAlloc(GlobalPtrHandle(lp) , (cbNew), (flags))))
+#define     GlobalFreePtr(lp)                \
+                (GlobalUnlockPtr(lp), (BOOL)GlobalFree(GlobalPtrHandle(lp)))
+#endif

 
 
 /*
 
 
 /*

- *  Clear the System Palette so that we can ensure an identity palette 
+ *  Clear the System Palette so that we can ensure an identity palette

  *  mapping for fast performance.
  */
 
  *  mapping for fast performance.
  */
 

-void ClearSystemPalette(void)
+void wxClearSystemPalette(void)

 {
   //*** A dummy palette setup
   struct
 {
   //*** A dummy palette setup
   struct


@@ -76,29 +102,37 @@ void ClearSystemPalette(void)
   UINT nMapped = 0;
   BOOL bOK = FALSE;
   int  nOK = 0;
   UINT nMapped = 0;
   BOOL bOK = FALSE;
   int  nOK = 0;

-  
-  //*** Reset everything in the system palette to black
+
+  // *** Reset everything in the system palette to black

   for(Counter = 0; Counter < 256; Counter++)
   {
     Palette.aEntries[Counter].peRed = 0;
   for(Counter = 0; Counter < 256; Counter++)
   {
     Palette.aEntries[Counter].peRed = 0;

-        Palette.aEntries[Counter].peGreen = 0;
+   Palette.aEntries[Counter].peGreen = 0;

     Palette.aEntries[Counter].peBlue = 0;
     Palette.aEntries[Counter].peFlags = PC_NOCOLLAPSE;
   }
 
     Palette.aEntries[Counter].peBlue = 0;
     Palette.aEntries[Counter].peFlags = PC_NOCOLLAPSE;
   }
 

-  //*** Create, select, realize, deselect, and delete the palette
+  // *** Create, select, realize, deselect, and delete the palette
+#ifdef __WXWINE__
+  ScreenDC = GetDC((HWND)NULL);
+#else

   ScreenDC = GetDC(NULL);
   ScreenDC = GetDC(NULL);

+#endif

   ScreenPalette = CreatePalette((LOGPALETTE *)&Palette);
 
   if (ScreenPalette)
   {
   ScreenPalette = CreatePalette((LOGPALETTE *)&Palette);
 
   if (ScreenPalette)
   {

-        ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
-        nMapped = RealizePalette(ScreenDC);
+   ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
+   nMapped = RealizePalette(ScreenDC);

     ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
     bOK = DeleteObject(ScreenPalette);
   }
 
     ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
     bOK = DeleteObject(ScreenPalette);
   }
 

+#ifdef __WXWINE__
+  nOK = ReleaseDC((HWND)NULL, ScreenDC);
+#else

   nOK = ReleaseDC(NULL, ScreenDC);
   nOK = ReleaseDC(NULL, ScreenDC);

+#endif

 
   return;
 }
 
   return;
 }


@@ -112,106 +146,107 @@ void ClearSystemPalette(void)
  *   bits....
  */
 
  *   bits....
  */
 

-int DibWriteFile(LPSTR szFile, LPBITMAPINFOHEADER lpbi)
+int wxDibWriteFile(LPTSTR szFile, LPBITMAPINFOHEADER lpbi)

 {
 {

-        HFILE               fh;
-        OFSTRUCT            of;
+   HFILE               fh;
+   OFSTRUCT            of;

 
 

-        fh = OpenFile(szFile, &of, OF_WRITE | OF_CREATE);
+   fh = OpenFile(wxConvFile.cWX2MB(szFile), &of, OF_WRITE | OF_CREATE);

 
   if (!fh) {
 
   if (!fh) {

-//      printf("la regamos0");
-        return 0;
+//   printf("la regamos0");
+   return 0;

   }
 
   }
 

-  long size = DibSize(lpbi);
+  long size = wxDibSize(lpbi);

 
   // write file header
   BITMAPFILEHEADER bmf;
 
   // write file header
   BITMAPFILEHEADER bmf;

-  bmf.bfType = 'BM';
+  bmf.bfType = BFT_BITMAP;

   bmf.bfSize = sizeof(bmf) + size;
   bmf.bfReserved1 = 0;
   bmf.bfReserved2 = 0;
   bmf.bfSize = sizeof(bmf) + size;
   bmf.bfReserved1 = 0;
   bmf.bfReserved2 = 0;

-  bmf.bfOffBits = sizeof(bmf) + (char far*)(DibPtr(lpbi)) - (char far*)lpbi;
-#if defined( __WATCOMC__) || defined(_MSC_VER) || defined(__SC__)
-  if (_hwrite(fh, (LPCSTR)(&bmf), sizeof(bmf))<0 ||
-       _hwrite(fh, (LPCSTR)lpbi, size)<0) {
-         _lclose(fh);
-//      printf("la regamos1");
-         return 0;
-  }
-#else
-  if (_hwrite(fh, (LPBYTE)(&bmf), sizeof(bmf))<0 ||
-       _hwrite(fh, (LPBYTE)lpbi, size)<0) {
-         _lclose(fh);
-//      printf("la regamos1");
-         return 0;
-  }
+  bmf.bfOffBits = sizeof(bmf) + (char FAR*)(wxDibPtr(lpbi)) - (char FAR*)lpbi;
+#if 1 // defined( __WATCOMC__) || defined(__VISUALC__) || defined(__SC__) || defined(__SALFORDC__) || defined(__MWERKS__) || defined(wxUSE_NORLANDER_HEADERS)
+  #define HWRITE_2ND_ARG_TYPE   LPCSTR
+#else // don't know who needs this...
+  #define HWRITE_2ND_ARG_TYPE   LPBYTE

 #endif
 
 #endif
 

+  if ( _hwrite(fh, (HWRITE_2ND_ARG_TYPE)(&bmf), sizeof(bmf)) < 0 ||
+       _hwrite(fh, (HWRITE_2ND_ARG_TYPE)lpbi, size) < 0 )
+  {
+    _lclose(fh);
+    return 0;
+  }
+
+#undef HWRITE_2ND_ARG_TYPE
+

   _lclose(fh);
   return 1;
 }
 
   _lclose(fh);
   return 1;
 }
 

-PDIB DibOpenFile(LPSTR szFile)
+PDIB wxDibOpenFile(LPTSTR szFile)

 {
 {

-        HFILE               fh;
-        DWORD               dwLen;
-        DWORD               dwBits;
-        PDIB                pdib;
-        LPVOID              p;
-        OFSTRUCT            of;
+   HFILE               fh;
+   DWORD               dwLen;
+   DWORD               dwBits;
+   PDIB                pdib;
+   LPVOID              p;
+   OFSTRUCT            of;

 
 #if defined(WIN32) || defined(_WIN32)
 
 #if defined(WIN32) || defined(_WIN32)

-        #define GetCurrentInstance()    GetModuleHandle(NULL)
+   #define GetCurrentInstance()    GetModuleHandle(NULL)

 #else
 #else

-        #define GetCurrentInstance()    (HINSTANCE)SELECTOROF((LPVOID)&of)
+   #define GetCurrentInstance()    (HINSTANCE)SELECTOROF((LPVOID)&of)

 #endif
 
 #endif
 

-        fh = OpenFile(szFile, &of, OF_READ);
+   fh = OpenFile(wxConvFile.cWX2MB(szFile), &of, OF_READ);

 
 

-        if (fh == -1)
-        {
-                 HRSRC h;
+   if (fh == -1)
+   {
+      HRSRC h;

 
           // TODO: Unicode version
 #ifdef __WIN16__
 
           // TODO: Unicode version
 #ifdef __WIN16__

-                 h = FindResource(GetCurrentInstance(), szFile, RT_BITMAP);
+      h = FindResource(GetCurrentInstance(), szFile, RT_BITMAP);
+#elif wxUSE_UNICODE
+      h = FindResourceW(GetCurrentInstance(), szFile, RT_BITMAP);

 #else
 #else

-                 h = FindResourceA(GetCurrentInstance(), szFile, RT_BITMAP);
+      h = FindResourceA(GetCurrentInstance(), szFile, RT_BITMAP);

 #endif
 
 #if defined(__WIN32__)
 #endif
 
 #if defined(__WIN32__)

-                 //!!! can we call GlobalFree() on this? is it the right format.
-                 //!!! can we write to this resource?
-                 if (h)
-                               return (PDIB)LockResource(LoadResource(GetCurrentInstance(), h));
+      //!!! can we call GlobalFree() on this? is it the right format.
+      //!!! can we write to this resource?
+      if (h)
+        return (PDIB)LockResource(LoadResource(GetCurrentInstance(), h));

 #else
 #else

-                 if (h)
-                               fh = AccessResource(GetCurrentInstance(), h);
+      if (h)
+        fh = AccessResource(GetCurrentInstance(), h);

 #endif
 #endif

-        }
+   }

 
 

-        if (fh == -1)
-                 return NULL;
+   if (fh == -1)
+      return NULL;

 
 

-        pdib = DibReadBitmapInfo(fh);
+   pdib = wxDibReadBitmapInfo(fh);

 
 

-        if (!pdib)
-                 return NULL;
+   if (!pdib)
+      return NULL;

 
     /* How much memory do we need to hold the DIB */
 
     dwBits = pdib->biSizeImage;
 
     /* How much memory do we need to hold the DIB */
 
     dwBits = pdib->biSizeImage;

-    dwLen  = pdib->biSize + DibPaletteSize(pdib) + dwBits;
+    dwLen  = pdib->biSize + wxDibPaletteSize(pdib) + dwBits;

 
     /* Can we get more memory? */
 
 
     /* Can we get more memory? */
 

-        p = GlobalReAllocPtr(pdib,dwLen,0);
+   p = GlobalReAllocPtr(pdib,dwLen,0);

 
     if (!p)
     {
 
     if (!p)
     {

-                 GlobalFreePtr(pdib);
+      GlobalFreePtr(pdib);

         pdib = NULL;
     }
     else
         pdib = NULL;
     }
     else


@@ -221,8 +256,8 @@ PDIB DibOpenFile(LPSTR szFile)
 
     if (pdib)
     {
 
     if (pdib)
     {

-                 /* read in the bits */
-                 _hread(fh, (LPBYTE)pdib + (UINT)pdib->biSize + DibPaletteSize(pdib), dwBits);
+      /* read in the bits */
+      _hread(fh, (LPBYTE)pdib + (UINT)pdib->biSize + wxDibPaletteSize(pdib), dwBits);

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


@@ -239,10 +274,9 @@ PDIB DibOpenFile(LPSTR szFile)
  *  bitmap formats, but will always return a "new" BITMAPINFO.
  */
 
  *  bitmap formats, but will always return a "new" BITMAPINFO.
  */
 

-PDIB DibReadBitmapInfo(HFILE fh)
+PDIB wxDibReadBitmapInfo(HFILE fh)

 {
     DWORD     off;
 {
     DWORD     off;

-    HANDLE    hbi = NULL;

     int       size;
     int       i;
     int       nNumColors;
     int       size;
     int       i;
     int       nNumColors;


@@ -301,16 +335,16 @@ PDIB DibReadBitmapInfo(HFILE fh)
             break;
     }
 
             break;
     }
 

-    nNumColors = DibNumColors(&bi);
+    nNumColors = wxDibNumColors(&bi);

 
 #if 0
     if (bi.biSizeImage == 0)
         bi.biSizeImage = DibSizeImage(&bi);
 
     if (bi.biClrUsed == 0)
 
 #if 0
     if (bi.biSizeImage == 0)
         bi.biSizeImage = DibSizeImage(&bi);
 
     if (bi.biClrUsed == 0)

-        bi.biClrUsed = DibNumColors(&bi);
+        bi.biClrUsed = wxDibNumColors(&bi);

 #else
 #else

-    FixBitmapInfo(&bi);
+    wxFixBitmapInfo(&bi);

 #endif
 
     pdib = (PDIB)GlobalAllocPtr(GMEM_MOVEABLE,(LONG)bi.biSize + nNumColors * sizeof(RGBQUAD));
 #endif
 
     pdib = (PDIB)GlobalAllocPtr(GMEM_MOVEABLE,(LONG)bi.biSize + nNumColors * sizeof(RGBQUAD));


@@ -320,7 +354,7 @@ PDIB DibReadBitmapInfo(HFILE fh)
 
     *pdib = bi;
 
 
     *pdib = bi;
 

-    pRgb = DibColors(pdib);
+    pRgb = wxDibColors(pdib);

 
     if (nNumColors)
     {
 
     if (nNumColors)
     {


@@ -367,7 +401,7 @@ PDIB DibReadBitmapInfo(HFILE fh)
  *      in the passed palette
  */
 
  *      in the passed palette
  */
 

-BOOL DibSetUsage(PDIB pdib, HPALETTE hpal,UINT wUsage)
+BOOL wxDibSetUsage(PDIB pdib, HPALETTE hpal,UINT wUsage)

 {
     PALETTEENTRY       ape[256];
     RGBQUAD FAR *      pRgb;
 {
     PALETTEENTRY       ape[256];
     RGBQUAD FAR *      pRgb;


@@ -381,14 +415,14 @@ BOOL DibSetUsage(PDIB pdib, HPALETTE hpal,UINT wUsage)
     if (!pdib)
         return FALSE;
 
     if (!pdib)
         return FALSE;
 

-    nColors = DibNumColors(pdib);
-    
-    if (nColors == 3 && DibCompression(pdib) == BI_BITFIELDS)
+    nColors = wxDibNumColors(pdib);
+
+    if (nColors == 3 && wxDibCompression(pdib) == BI_BITFIELDS)

         nColors = 0;
 
     if (nColors > 0)
     {
         nColors = 0;
 
     if (nColors > 0)
     {

-        pRgb = DibColors(pdib);
+        pRgb = wxDibColors(pdib);

 
         switch (wUsage)
         {
 
         switch (wUsage)
         {


@@ -429,7 +463,7 @@ BOOL DibSetUsage(PDIB pdib, HPALETTE hpal,UINT wUsage)
  *  given number of bits per pixel
  */
 
  *  given number of bits per pixel
  */
 

-PDIB DibCreate(int bits, int dx, int dy)
+PDIB wxDibCreate(int bits, int dx, int dy)

 {
     LPBITMAPINFOHEADER lpbi ;
     DWORD       dwSizeImage;
 {
     LPBITMAPINFOHEADER lpbi ;
     DWORD       dwSizeImage;


@@ -468,7 +502,7 @@ PDIB DibCreate(int bits, int dx, int dy)
         *pdw++ = 0x00000000;    // 0000  black
         *pdw++ = 0x00800000;    // 0001  dark red
         *pdw++ = 0x00008000;    // 0010  dark green
         *pdw++ = 0x00000000;    // 0000  black
         *pdw++ = 0x00800000;    // 0001  dark red
         *pdw++ = 0x00008000;    // 0010  dark green

-                 *pdw++ = 0x00808000;    // 0011  mustard
+      *pdw++ = 0x00808000;    // 0011  mustard

         *pdw++ = 0x00000080;    // 0100  dark blue
         *pdw++ = 0x00800080;    // 0101  purple
         *pdw++ = 0x00008080;    // 0110  dark turquoise
         *pdw++ = 0x00000080;    // 0100  dark blue
         *pdw++ = 0x00800080;    // 0101  purple
         *pdw++ = 0x00008080;    // 0110  dark turquoise


@@ -476,7 +510,7 @@ PDIB DibCreate(int bits, int dx, int dy)
         *pdw++ = 0x00808080;    // 0111  dark gray
         *pdw++ = 0x00FF0000;    // 1001  red
         *pdw++ = 0x0000FF00;    // 1010  green
         *pdw++ = 0x00808080;    // 0111  dark gray
         *pdw++ = 0x00FF0000;    // 1001  red
         *pdw++ = 0x0000FF00;    // 1010  green

-                 *pdw++ = 0x00FFFF00;    // 1011  yellow
+      *pdw++ = 0x00FFFF00;    // 1011  yellow

         *pdw++ = 0x000000FF;    // 1100  blue
         *pdw++ = 0x00FF00FF;    // 1101  pink (magenta)
         *pdw++ = 0x0000FFFF;    // 1110  cyan
         *pdw++ = 0x000000FF;    // 1100  blue
         *pdw++ = 0x00FF00FF;    // 1101  pink (magenta)
         *pdw++ = 0x0000FFFF;    // 1110  cyan


@@ -581,71 +615,71 @@ static void hmemmove(BYTE _huge *d, BYTE _huge *s, LONG len)
  *  the colors of the given palette.
  */
 
  *  the colors of the given palette.
  */
 

-BOOL DibMapToPalette(PDIB pdib, HPALETTE hpal)
+BOOL wxDibMapToPalette(PDIB pdib, HPALETTE hpal)

 {
 {

-        LPBITMAPINFOHEADER  lpbi;
-        PALETTEENTRY        pe;
-        int                 n;
-        int                 nDibColors;
-        int                 nPalColors=0;
-        BYTE FAR *          lpBits;
-        RGBQUAD FAR *       lpRgb;
-        BYTE                xlat[256];
-        DWORD               SizeImage;
-
-        if (!hpal || !pdib)
-                 return FALSE;
-
-        lpbi   = (LPBITMAPINFOHEADER)pdib;
-        lpRgb  = DibColors(pdib);
-
-        GetObject(hpal,sizeof(int),(LPSTR)&nPalColors);
-        nDibColors = DibNumColors(pdib);
-
-        if ((SizeImage = lpbi->biSizeImage) == 0)
-                 SizeImage = DibSizeImage(lpbi);
-
-        //
-        //  build a xlat table. from the current DIB colors to the given
-        //  palette.
-        //
-        for (n=0; n<nDibColors; n++)
-                 xlat[n] = (BYTE)GetNearestPaletteIndex(hpal,RGB(lpRgb[n].rgbRed,lpRgb[n].rgbGreen,lpRgb[n].rgbBlue));
-
-        lpBits = (LPBYTE)DibPtr(lpbi);
-        lpbi->biClrUsed = nPalColors;
-
-        //
-        // re-size the DIB
-        //
-        if (nPalColors > nDibColors)
-        {
-                 GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
-                 hmemmove((BYTE _huge *)DibPtr(lpbi), (BYTE _huge *)lpBits, SizeImage);
-                 lpBits = (LPBYTE)DibPtr(lpbi);
-        }
-        else if (nPalColors < nDibColors)
-        {
-                 hmemcpy(DibPtr(lpbi), lpBits, SizeImage);
-                 GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
-                 lpBits = (LPBYTE)DibPtr(lpbi);
-        }
-
-        //
-        // translate the DIB bits
-        //
-        switch (lpbi->biCompression)
-        {
-                 case BI_RLE8:
-                               xlatRle8(lpBits, SizeImage, xlat);
-                               break;
-
-                 case BI_RLE4:
-                               xlatRle4(lpBits, SizeImage, xlat);
-                               break;
+   LPBITMAPINFOHEADER  lpbi;
+   PALETTEENTRY        pe;
+   int                 n;
+   int                 nDibColors;
+   int                 nPalColors=0;
+   BYTE FAR *          lpBits;
+   RGBQUAD FAR *       lpRgb;
+   BYTE                xlat[256];
+   DWORD               SizeImage;
+
+   if (!hpal || !pdib)
+      return FALSE;
+
+   lpbi   = (LPBITMAPINFOHEADER)pdib;
+   lpRgb  = wxDibColors(pdib);
+
+   GetObject(hpal,sizeof(int),(LPSTR)&nPalColors);
+   nDibColors = wxDibNumColors(pdib);
+
+   if ((SizeImage = lpbi->biSizeImage) == 0)
+      SizeImage = wxDibSizeImage(lpbi);
+
+   //
+   //  build a xlat table. from the current DIB colors to the given
+   //  palette.
+   //
+   for (n=0; n<nDibColors; n++)
+      xlat[n] = (BYTE)GetNearestPaletteIndex(hpal,RGB(lpRgb[n].rgbRed,lpRgb[n].rgbGreen,lpRgb[n].rgbBlue));
+
+   lpBits = (LPBYTE)wxDibPtr(lpbi);
+   lpbi->biClrUsed = nPalColors;
+
+   //
+   // re-size the DIB
+   //
+   if (nPalColors > nDibColors)
+   {
+      GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
+      hmemmove((BYTE _huge *)wxDibPtr(lpbi), (BYTE _huge *)lpBits, SizeImage);
+      lpBits = (LPBYTE)wxDibPtr(lpbi);
+   }
+   else if (nPalColors < nDibColors)
+   {
+      hmemcpy(wxDibPtr(lpbi), lpBits, SizeImage);
+      GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
+      lpBits = (LPBYTE)wxDibPtr(lpbi);
+   }
+
+   //
+   // translate the DIB bits
+   //
+   switch (lpbi->biCompression)
+   {
+      case BI_RLE8:
+        xlatRle8(lpBits, SizeImage, xlat);
+        break;
+
+      case BI_RLE4:
+        xlatRle4(lpBits, SizeImage, xlat);
+        break;

 
         case BI_RGB:
 
         case BI_RGB:

-                               if (lpbi->biBitCount == 8)
+        if (lpbi->biBitCount == 8)

                 xlatClut8(lpBits, SizeImage, xlat);
             else
                 xlatClut4(lpBits, SizeImage, xlat);
                 xlatClut8(lpBits, SizeImage, xlat);
             else
                 xlatClut4(lpBits, SizeImage, xlat);


@@ -660,37 +694,37 @@ BOOL DibMapToPalette(PDIB pdib, HPALETTE hpal)
         GetPaletteEntries(hpal,n,1,&pe);
 
         lpRgb[n].rgbRed      = pe.peRed;
         GetPaletteEntries(hpal,n,1,&pe);
 
         lpRgb[n].rgbRed      = pe.peRed;

-                 lpRgb[n].rgbGreen    = pe.peGreen;
-                 lpRgb[n].rgbBlue     = pe.peBlue;
-                 lpRgb[n].rgbReserved = (BYTE)0;
-        }
+      lpRgb[n].rgbGreen    = pe.peGreen;
+      lpRgb[n].rgbBlue     = pe.peBlue;
+      lpRgb[n].rgbReserved = (BYTE)0;
+   }

 
 

-        return TRUE;
+   return TRUE;

 }
 
 
 }
 
 

-HPALETTE MakePalette(const BITMAPINFO FAR* Info, UINT flags)
+HPALETTE wxMakePalette(const BITMAPINFO FAR* Info, UINT flags)

 {
   HPALETTE hPalette;
 {
   HPALETTE hPalette;

-  const RGBQUAD far* rgb = Info->bmiColors;
+  const RGBQUAD FAR* rgb = Info->bmiColors;

 
   WORD nColors = Info->bmiHeader.biClrUsed;
   if (nColors) {
 
   WORD nColors = Info->bmiHeader.biClrUsed;
   if (nColors) {

-        LOGPALETTE* logPal = (LOGPALETTE*)
-                new BYTE[sizeof(LOGPALETTE) + (nColors-1)*sizeof(PALETTEENTRY)];
-
-        logPal->palVersion  = 0x300; // Windows 3.0 version
-        logPal->palNumEntries = nColors;
-        for (short n = 0; n < nColors; n++) {
-               logPal->palPalEntry[n].peRed   = rgb[n].rgbRed;
-               logPal->palPalEntry[n].peGreen = rgb[n].rgbGreen;
-               logPal->palPalEntry[n].peBlue  = rgb[n].rgbBlue;
-               logPal->palPalEntry[n].peFlags = (BYTE)flags;
-        }
-        hPalette = ::CreatePalette(logPal);
-        delete logPal;
+   LOGPALETTE* logPal = (LOGPALETTE*)
+     new BYTE[sizeof(LOGPALETTE) + (nColors-1)*sizeof(PALETTEENTRY)];
+
+   logPal->palVersion  = 0x300; // Windows 3.0 version
+   logPal->palNumEntries = nColors;
+   for (WORD n = 0; n < nColors; n++) {
+    logPal->palPalEntry[n].peRed   = rgb[n].rgbRed;
+    logPal->palPalEntry[n].peGreen = rgb[n].rgbGreen;
+    logPal->palPalEntry[n].peBlue  = rgb[n].rgbBlue;
+    logPal->palPalEntry[n].peFlags = (BYTE)flags;
+   }
+   hPalette = ::CreatePalette(logPal);
+   delete logPal;

   } else
   } else

-        hPalette = 0;
+   hPalette = 0;

 
   return hPalette;
 }
 
   return hPalette;
 }