src/msw/dib.cpp

   1 /*******************************************************************************
   2  *                                                                             *
   3  * MODULE       : DIB.CC                                                       *
   4  *                                                                             *
   5  *  DESCRIPTION : Routines for dealing with Device Independent Bitmaps.        *
   6  *                                                                             *
   7  *  FUNCTIONS   :                                                              *
   8  *                                                                             *
   9  *                ReadDIB()           - Reads a DIB                            *
  10  *                                                                             *
  11  *                WriteDIB()          - Writes a global handle in CF_DIB format*
  12  *                                      to a file.                             *
  13  *                                                                             *
  14  *                PaletteSize()       - Calculates the palette size in bytes   *
  15  *                                      of given DIB                           *
  16  *                                                                             *
  17  *                DibNumColors()      - Determines the number of colors in DIB *
  18  *                                                                             *
  19  *                DibFromBitmap()     - Creates a DIB repr. the DDB passed in. *
  20  *                                                                             *
  21  *                                                                             *
  22  *                lread()             - Private routine to read more than 64k  *
  23  *                                                                             *
  24  *                lwrite()            - Private routine to write more than 64k *
  25  *                                                                             *
  26  *******************************************************************************/
  27
  28 // For compilers that support precompilation, includes "wx.h".
  29 #include "wx/wxprec.h"
  30
  31 #if defined(__BORLANDC__)
  32 #pragma hdrstop
  33 #endif
  34
  35 #ifndef WX_PRECOMP
  36 #include "wx/setup.h"
  37 #include "wx/defs.h"
  38 #include "wx/bitmap.h"
  39 #endif
  40
  41 #include <windows.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44
  45 #if !defined(__MWERKS__) && !defined(__SALFORDC__)
  46 #include <memory.h>
  47 #endif
  48
  49 #include "wx/msw/dib.h"
  50
  51 #ifndef __TWIN32__
  52 #ifdef __GNUWIN32__
  53 #include "wx/msw/gnuwin32/extra.h"
  54 #endif
  55 #endif
  56
  57 #ifndef SEEK_CUR
  58 /* flags for _lseek */
  59 #define SEEK_CUR 1
  60 #define SEEK_END 2
  61 #define SEEK_SET 0
  62 #endif
  63
  64 #define MAXREAD  32768                           /* Number of bytes to be read during */
  65                                                  /* each read operation.                         */
  66
  67 /* Header signatutes for various resources */
  68 #define BFT_ICON         0x4349  /* 'IC' */
  69 #define BFT_BITMAP 0x4d42        /* 'BM' */
  70 #define BFT_CURSOR 0x5450        /* 'PT' */
  71
  72 /* macro to determine if resource is a DIB */
  73 #define ISDIB(bft) ((bft) == BFT_BITMAP)
  74
  75 /* Macro to align given value to the closest DWORD (unsigned long ) */
  76 #define ALIGNULONG(i)   ((i+3)/4*4)
  77
  78 /* Macro to determine to round off the given value to the closest byte */
  79 #define WIDTHBYTES(i)   ((i+31)/32*4)
  80
  81 #define PALVERSION              0x300
  82 #define MAXPALETTE      256       /* max. # supported palette entries */
  83
  84 DWORD PASCAL lread(int fh, VOID FAR *pv, DWORD ul);
  85 DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul);
  86
  87 BOOL             WriteDIB (LPSTR szFile,HANDLE hdib);
  88 WORD             PaletteSize (VOID FAR * pv);
  89 WORD             DibNumColors (VOID FAR * pv);
  90 // HANDLE                DibFromBitmap (HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal);
  91 BOOL             PASCAL MakeBitmapAndPalette(HDC,HANDLE,HPALETTE *,HBITMAP *);
  92 HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER);
  93 BOOL             ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette);
  94
  95 /****************************************************************************
  96  *                                                                          *
  97  *  FUNCTION   : WriteDIB(LPSTR szFile,HANDLE hdib)                         *
  98  *                                                                          *
  99  *  PURPOSE    : Write a global handle in CF_DIB format to a file.          *
 100  *                                                                          *
 101  *  RETURNS    : TRUE  - if successful.                                     *
 102  *               FALSE - otherwise                                          *
 103  *                                                                          *
 104  ****************************************************************************/
 105
 106 BOOL WriteDIB(LPSTR szFile, HANDLE hdib)
 107 {
 108         BITMAPFILEHEADER        hdr;
 109         LPBITMAPINFOHEADER  lpbi;
 110         int                 fh;
 111         OFSTRUCT            of;
 112
 113         if (!hdib)
 114                 return FALSE;
 115
 116         fh = OpenFile(szFile, &of, OF_CREATE | OF_READWRITE);
 117         if (fh == -1)
 118                 return FALSE;
 119
 120 #ifdef __WINDOWS_386__
 121         lpbi = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock(hdib));
 122 #else
 123         lpbi = (LPBITMAPINFOHEADER) GlobalLock(hdib);
 124 #endif
 125     /* Fill in the fields of the file header */
 126         hdr.bfType = BFT_BITMAP;
 127         hdr.bfSize = GlobalSize(hdib) + sizeof(BITMAPFILEHEADER);
 128         hdr.bfReserved1 = 0;
 129         hdr.bfReserved2 = 0;
 130         hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + lpbi->biSize +
 131                  PaletteSize(lpbi);
 132
 133     /* Write the file header */
 134         _lwrite(fh, (LPSTR) &hdr, sizeof(BITMAPFILEHEADER));
 135
 136     /* Write the DIB header and the bits */
 137         lwrite(fh, (LPSTR) lpbi, GlobalSize(hdib));
 138
 139         GlobalUnlock(hdib);
 140         _lclose(fh);
 141         return TRUE;
 142 }
 143
 144 /****************************************************************************
 145  *                                                                          *
 146  *  FUNCTION   :  PaletteSize(VOID FAR * pv)                                *
 147  *                                                                          *
 148  *  PURPOSE    :  Calculates the palette size in bytes. If the info. block  *
 149  *                is of the BITMAPCOREHEADER type, the number of colors is  *
 150  *                multiplied by 3 to give the palette size, otherwise the   *
 151  *                number of colors is multiplied by 4.                                                          *
 152  *                                                                          *
 153  *  RETURNS    :  Palette size in number of bytes.                          *
 154  *                                                                          *
 155  ****************************************************************************/
 156
 157 WORD PaletteSize(VOID FAR * pv)
 158 {
 159         LPBITMAPINFOHEADER lpbi;
 160         WORD           NumColors;
 161
 162         lpbi = (LPBITMAPINFOHEADER) pv;
 163         NumColors = DibNumColors(lpbi);
 164
 165         if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
 166                 return NumColors * sizeof(RGBTRIPLE);
 167         else
 168                 return NumColors * sizeof(RGBQUAD);
 169 }
 170
 171 /****************************************************************************
 172  *                                                                          *
 173  *  FUNCTION   : DibNumColors(VOID FAR * pv)                                *
 174  *                                                                          *
 175  *  PURPOSE    : Determines the number of colors in the DIB by looking at   *
 176  *               the BitCount filed in the info block.                      *
 177  *                                                                          *
 178  *  RETURNS    : The number of colors in the DIB.                           *
 179  *                                                                          *
 180  ****************************************************************************/
 181
 182 WORD DibNumColors(VOID FAR *pv)
 183 {
 184         int             bits;
 185         BITMAPINFOHEADER        *lpbi;
 186         BITMAPCOREHEADER        *lpbc;
 187
 188         lpbi = ((BITMAPINFOHEADER*) pv);
 189         lpbc = ((BITMAPCOREHEADER*) pv);
 190
 191     /*  With the BITMAPINFO format headers, the size of the palette
 192      *  is in biClrUsed, whereas in the BITMAPCORE - style headers, it
 193      *  is dependent on the bits per pixel ( = 2 raised to the power of
 194      *  bits/pixel).
 195      */
 196         if (lpbi->biSize != sizeof(BITMAPCOREHEADER)) {
 197                 if (lpbi->biClrUsed != 0)
 198                         return (WORD) lpbi->biClrUsed;
 199                 bits = lpbi->biBitCount;
 200                 }
 201         else
 202                 bits = lpbc->bcBitCount;
 203
 204         switch (bits) {
 205   case 1:
 206                 return 2;
 207   case 4:
 208                 return 16;
 209   case 8:
 210                 return 256;
 211   default:
 212                 /* A 24 bitcount DIB has no color table */
 213                 return 0;
 214                 }
 215 }
 216
 217 /****************************************************************************
 218  *                                                                          *
 219  *  FUNCTION   : DibFromBitmap()                                            *
 220  *                                                                          *
 221  *  PURPOSE    : Will create a global memory block in DIB format that       *
 222  *               represents the Device-dependent bitmap (DDB) passed in.    *
 223  *                                                                          *
 224  *  RETURNS    : A handle to the DIB                                        *
 225  *                                                                          *
 226  ****************************************************************************/
 227
 228 #if NOTHING
 229 HANDLE DibFromBitmap(HBITMAP hbm, DWORD biStyle, WORD biBits, HPALETTE hpal)
 230 {
 231         BITMAP               bm;
 232         BITMAPINFOHEADER     bi;
 233         BITMAPINFOHEADER FAR *lpbi;
 234         DWORD                dwLen;
 235         HANDLE               hdib;
 236         HANDLE               h;
 237         HDC                  hdc;
 238
 239         if (!hbm)
 240                 return NULL;
 241
 242         if (hpal == NULL)
 243                 hpal = GetStockObject(DEFAULT_PALETTE);
 244
 245         GetObject(hbm, sizeof (bm), (LPSTR) &bm);
 246
 247         if (biBits == 0)
 248                 biBits = bm.bmPlanes * bm.bmBitsPixel;
 249
 250         bi.biSize = sizeof(BITMAPINFOHEADER);
 251         bi.biWidth = bm.bmWidth;
 252         bi.biHeight = bm.bmHeight;
 253         bi.biPlanes = 1;
 254         bi.biBitCount = biBits;
 255         bi.biCompression = biStyle;
 256         bi.biSizeImage = 0;
 257         bi.biXPelsPerMeter = 0;
 258         bi.biYPelsPerMeter = 0;
 259         bi.biClrUsed = 0;
 260         bi.biClrImportant = 0;
 261
 262         dwLen = bi.biSize + PaletteSize(&bi);
 263
 264         hdc = GetDC((HWND) NULL);
 265         hpal = SelectPalette(hdc, hpal, FALSE);
 266         RealizePalette(hdc);
 267
 268         hdib = GlobalAlloc(GHND, dwLen);
 269
 270         if (!hdib) {
 271                 SelectPalette(hdc, hpal, FALSE);
 272                 ReleaseDC(NULL, hdc);
 273                 return NULL;
 274                 }
 275
 276 #ifdef __WINDOWS_386__
 277         lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
 278 #else
 279         lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
 280 #endif
 281
 282         *lpbi = bi;
 283
 284     /*  call GetDIBits with a NULL lpBits param, so it will calculate the
 285      *  biSizeImage field for us
 286      */
 287         GetDIBits(hdc, hbm, 0, (WORD) bi.biHeight,
 288                  NULL, (LPBITMAPINFO) lpbi, DIB_RGB_COLORS);
 289
 290         bi = *lpbi;
 291         GlobalUnlock(hdib);
 292
 293     /* If the driver did not fill in the biSizeImage field, make one up */
 294         if (bi.biSizeImage == 0) {
 295                 bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;
 296
 297                 if (biStyle != BI_RGB)
 298                         bi.biSizeImage = (bi.biSizeImage * 3) / 2;
 299                 }
 300
 301     /*  realloc the buffer big enough to hold all the bits */
 302         dwLen = bi.biSize + PaletteSize(&bi) + bi.biSizeImage;
 303         if (h = GlobalReAlloc(hdib, dwLen, 0))
 304                 hdib = h;
 305         else {
 306                 GlobalFree(hdib);
 307                 hdib = NULL;
 308
 309                 SelectPalette(hdc, hpal, FALSE);
 310                 ReleaseDC(NULL, hdc);
 311                 return hdib;
 312                 }
 313
 314     /*  call GetDIBits with a NON-NULL lpBits param, and actualy get the
 315      *  bits this time
 316      */
 317 #ifdef __WINDOWS_386__
 318         lpbi = (BITMAPINFOHEADER FAR *) MK_FP32(GlobalLock(hdib));
 319 #else
 320         lpbi = (BITMAPINFOHEADER FAR *) GlobalLock(hdib);
 321 #endif
 322
 323         if (GetDIBits(hdc,
 324                  hbm,
 325                  0,
 326                  (WORD) bi.biHeight,
 327                  (LPSTR) lpbi + (WORD) lpbi->biSize + PaletteSize(lpbi),
 328                  (LPBITMAPINFO) lpbi, DIB_RGB_COLORS) == 0) {
 329                 GlobalUnlock(hdib);
 330                 hdib = NULL;
 331                 SelectPalette(hdc, hpal, FALSE);
 332                 ReleaseDC((HWND) NULL, hdc);
 333                 return NULL;
 334                 }
 335
 336         bi = *lpbi;
 337         GlobalUnlock(hdib);
 338
 339         SelectPalette(hdc, hpal, FALSE);
 340         ReleaseDC(NULL, hdc);
 341         return hdib;
 342 }
 343 #endif
 344
 345  /************* PRIVATE ROUTINES TO READ/WRITE MORE THAN 64K ***************/
 346 /****************************************************************************
 347  *                                                                          *
 348  *  FUNCTION   : lread(int fh, VOID FAR *pv, DWORD ul)                      *
 349  *                                                                          *
 350  *  PURPOSE    : Reads data in steps of 32k till all the data has been read.*
 351  *                                                                          *
 352  *  RETURNS    : 0 - If read did not proceed correctly.                     *
 353  *               number of bytes read otherwise.                            *
 354  *                                                                          *
 355  ****************************************************************************/
 356
 357 DWORD PASCAL lread(int fh, void far *pv, DWORD ul)
 358 {
 359         DWORD     ulT = ul;
 360 #if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
 361         BYTE *hp = (BYTE *) pv;
 362 #else
 363         BYTE huge *hp = (BYTE huge *) pv;
 364 #endif
 365         while (ul > (DWORD) MAXREAD) {
 366                 if (_lread(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
 367                         return 0;
 368                 ul -= MAXREAD;
 369                 hp += MAXREAD;
 370                 }
 371         if (_lread(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul)
 372                 return 0;
 373         return ulT;
 374 }
 375
 376 /****************************************************************************
 377  *                                                                          *
 378  *  FUNCTION   : lwrite(int fh, VOID FAR *pv, DWORD ul)                     *
 379  *                                                                          *
 380  *  PURPOSE    : Writes data in steps of 32k till all the data is written.  *
 381  *                                                                          *
 382  *  RETURNS    : 0 - If write did not proceed correctly.                    *
 383  *               number of bytes written otherwise.                         *
 384  *                                                                          *
 385  ****************************************************************************/
 386
 387 DWORD PASCAL lwrite(int fh, VOID FAR *pv, DWORD ul)
 388 {
 389         DWORD     ulT = ul;
 390 #if defined(WINNT) || defined(__WIN32__) || defined(__WIN32__)
 391         BYTE *hp = (BYTE *) pv;
 392 #else
 393         BYTE huge *hp = (BYTE huge *) pv;
 394 #endif
 395         while (ul > MAXREAD) {
 396                 if (_lwrite(fh, (LPSTR) hp, (WORD) MAXREAD) != MAXREAD)
 397                         return 0;
 398                 ul -= MAXREAD;
 399                 hp += MAXREAD;
 400                 }
 401         if (_lwrite(fh, (LPSTR) hp, (WORD) ul) != (WORD) ul)
 402                 return 0;
 403         return ulT;
 404 }
 405
 406 /****************************************************************************
 407  *
 408  *  FUNCTION   : ReadDIB(hWnd)
 409  *
 410  *  PURPOSE    : Reads a DIB from a file, obtains a handle to its
 411  *               BITMAPINFO struct. and loads the DIB.  Once the DIB
 412  *               is loaded, the function also creates a bitmap and
 413  *               palette out of the DIB for a device-dependent form.
 414  *
 415  *  RETURNS    : TRUE  - DIB loaded and bitmap/palette created
 416  *                       The DIBINIT structure pointed to by pInfo is
 417  *                       filled with the appropriate handles.
 418  *               FALSE - otherwise
 419  *
 420  ****************************************************************************/
 421 BOOL ReadDIB(LPSTR lpFileName, HBITMAP *bitmap, HPALETTE *palette)
 422 {
 423     int fh;
 424     LPBITMAPINFOHEADER lpbi;
 425     OFSTRUCT           of;
 426     BITMAPFILEHEADER   bf;
 427     WORD                nNumColors;
 428     BOOL result = FALSE;
 429     char str[128];
 430     WORD offBits;
 431     HDC hDC;
 432     BOOL bCoreHead = FALSE;
 433     HANDLE hDIB = 0;
 434
 435     /* Open the file and get a handle to it's BITMAPINFO */
 436
 437     fh = OpenFile (lpFileName, &of, OF_READ);
 438     if (fh == -1) {
 439         wsprintf(str,"Can't open file '%ls'", (LPSTR)lpFileName);
 440         MessageBox(NULL, str, "Error", MB_ICONSTOP | MB_OK);
 441         return (0);
 442     }
 443
 444     hDIB = GlobalAlloc(GHND, (DWORD)(sizeof(BITMAPINFOHEADER) +
 445                                         256 * sizeof(RGBQUAD)));
 446     if (!hDIB)
 447         return(0);
 448
 449 #ifdef __WINDOWS_386__
 450     lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
 451 #else
 452     lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
 453 #endif
 454
 455     /* read the BITMAPFILEHEADER */
 456     if (sizeof (bf) != _lread (fh, (LPSTR)&bf, sizeof (bf)))
 457         goto ErrExit;
 458
 459     if (bf.bfType != 0x4d42)    /* 'BM' */
 460         goto ErrExit;
 461
 462     if (sizeof(BITMAPCOREHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPCOREHEADER)))
 463         goto ErrExit;
 464
 465     if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
 466     {
 467         lpbi->biSize = sizeof(BITMAPINFOHEADER);
 468         lpbi->biBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
 469         lpbi->biPlanes = ((LPBITMAPCOREHEADER)lpbi)->bcPlanes;
 470         lpbi->biHeight = ((LPBITMAPCOREHEADER)lpbi)->bcHeight;
 471         lpbi->biWidth = ((LPBITMAPCOREHEADER)lpbi)->bcWidth;
 472         bCoreHead = TRUE;
 473     }
 474     else
 475     {
 476         // get to the start of the header and read INFOHEADER
 477         _llseek(fh,sizeof(BITMAPFILEHEADER),SEEK_SET);
 478         if (sizeof(BITMAPINFOHEADER) != _lread (fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER)))
 479             goto ErrExit;
 480     }
 481
 482     nNumColors = (WORD)lpbi->biClrUsed;
 483     if ( nNumColors == 0 )
 484     {
 485         /* no color table for 24-bit, default size otherwise */
 486         if (lpbi->biBitCount != 24)
 487             nNumColors = 1 << lpbi->biBitCount; /* standard size table */
 488     }
 489
 490     /*  fill in some default values if they are zero */
 491     if (lpbi->biClrUsed == 0)
 492         lpbi->biClrUsed = nNumColors;
 493
 494     if (lpbi->biSizeImage == 0)
 495     {
 496         lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3)
 497                          * lpbi->biHeight;
 498     }
 499
 500     /* get a proper-sized buffer for header, color table and bits */
 501     GlobalUnlock(hDIB);
 502     hDIB = GlobalReAlloc(hDIB, lpbi->biSize +
 503                                         nNumColors * sizeof(RGBQUAD) +
 504                                         lpbi->biSizeImage, 0);
 505     if (!hDIB)  /* can't resize buffer for loading */
 506         goto ErrExit2;
 507
 508 #ifdef __WINDOWS_386__
 509     lpbi = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
 510 #else
 511     lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
 512 #endif
 513
 514     /* read the color table */
 515     if (!bCoreHead)
 516         _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBQUAD));
 517     else
 518     {
 519         signed int i;
 520         RGBQUAD FAR *pQuad;
 521         RGBTRIPLE FAR *pTriple;
 522
 523         _lread(fh, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBTRIPLE));
 524
 525         pQuad = (RGBQUAD FAR *)((LPSTR)lpbi + lpbi->biSize);
 526         pTriple = (RGBTRIPLE FAR *) pQuad;
 527         for (i = nNumColors - 1; i >= 0; i--)
 528         {
 529             pQuad[i].rgbRed = pTriple[i].rgbtRed;
 530             pQuad[i].rgbBlue = pTriple[i].rgbtBlue;
 531             pQuad[i].rgbGreen = pTriple[i].rgbtGreen;
 532             pQuad[i].rgbReserved = 0;
 533         }
 534     }
 535
 536     /* offset to the bits from start of DIB header */
 537     offBits = (WORD)lpbi->biSize + nNumColors * sizeof(RGBQUAD);
 538
 539     if (bf.bfOffBits != 0L)
 540     {
 541         _llseek(fh,bf.bfOffBits,SEEK_SET);
 542     }
 543
 544     if (lpbi->biSizeImage == lread(fh, (LPSTR)lpbi + offBits, lpbi->biSizeImage))
 545     {
 546         GlobalUnlock(hDIB);
 547
 548         hDC = GetDC(NULL);
 549         if (!MakeBitmapAndPalette(hDC, hDIB, palette,
 550                                         bitmap))
 551         {
 552             ReleaseDC(NULL,hDC);
 553             goto ErrExit2;
 554         }
 555         else
 556         {
 557             ReleaseDC(NULL,hDC);
 558             GlobalFree(hDIB);
 559             result = TRUE;
 560         }
 561     }
 562     else
 563     {
 564 ErrExit:
 565         GlobalUnlock(hDIB);
 566 ErrExit2:
 567         GlobalFree(hDIB);
 568     }
 569
 570     _lclose(fh);
 571     return(result);
 572 }
 573
 574 /****************************************************************************
 575  *
 576  *  FUNCTION   : MakeBitmapAndPalette
 577  *
 578  *  PURPOSE    : Given a DIB, creates a bitmap and corresponding palette
 579  *               to be used for a device-dependent representation of
 580  *               of the image.
 581  *
 582  *  RETURNS    : TRUE  --> success. phPal and phBitmap are filled with
 583  *                         appropriate handles.  Caller is responsible
 584  *                         for freeing objects.
 585  *               FALSE --> unable to create objects.  both pointer are
 586  *                         not valid
 587  *
 588  ****************************************************************************/
 589 BOOL PASCAL MakeBitmapAndPalette(HDC hDC, HANDLE hDIB,
 590                         HPALETTE * phPal, HBITMAP * phBitmap)
 591 {
 592     LPBITMAPINFOHEADER lpInfo;
 593     BOOL result = FALSE;
 594     HBITMAP hBitmap;
 595     HPALETTE hPalette, hOldPal;
 596     LPSTR lpBits;
 597
 598 #ifdef __WINDOWS_386__
 599     lpInfo = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock(hDIB));
 600 #else
 601     lpInfo = (LPBITMAPINFOHEADER) GlobalLock(hDIB);
 602 #endif
 603
 604     hPalette = MakeDIBPalette(lpInfo);
 605     if ( hPalette )
 606     {
 607         // Need to realize palette for converting DIB to bitmap.
 608         hOldPal = SelectPalette(hDC, hPalette, TRUE);
 609         RealizePalette(hDC);
 610
 611         lpBits = (LPSTR)lpInfo + (WORD)lpInfo->biSize +
 612                 (WORD)lpInfo->biClrUsed * sizeof(RGBQUAD);
 613         hBitmap = CreateDIBitmap(hDC, lpInfo, CBM_INIT, lpBits,
 614                                 (LPBITMAPINFO)lpInfo, DIB_RGB_COLORS);
 615
 616         SelectPalette(hDC, hOldPal, TRUE);
 617         RealizePalette(hDC);
 618
 619         if (!hBitmap)
 620             DeleteObject(hPalette);
 621         else
 622         {
 623             *phBitmap = hBitmap;
 624             *phPal = hPalette;
 625             result = TRUE;
 626         }
 627     }
 628     return(result);
 629 }
 630
 631 /****************************************************************************
 632  *                                                                          *
 633  *  FUNCTION   : MakeDIBPalette(lpInfo)                                     *
 634  *                                                                          *
 635  *  PURPOSE    : Given a BITMAPINFOHEADER, create a palette based on
 636  *               the color table.
 637  *
 638  *                                                                          *
 639  *  RETURNS    : non-zero - handle of a corresponding palette
 640  *               zero - unable to create palette
 641  *                                                                          *
 642  ****************************************************************************/
 643 HPALETTE MakeDIBPalette(LPBITMAPINFOHEADER lpInfo)
 644 {
 645     NPLOGPALETTE npPal;
 646     RGBQUAD far *lpRGB;
 647     HPALETTE hLogPal;
 648     WORD i;
 649
 650     /* since biClrUsed field was filled during the loading of the DIB,
 651     ** we know it contains the number of colors in the color table.
 652     */
 653     if (lpInfo->biClrUsed)
 654     {
 655 /*
 656         npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, sizeof(LOGPALETTE) +
 657                                 (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
 658 */
 659         npPal = (NPLOGPALETTE)malloc(sizeof(LOGPALETTE) +
 660                                 (WORD)lpInfo->biClrUsed * sizeof(PALETTEENTRY));
 661
 662         if (!npPal)
 663             return(FALSE);
 664
 665         npPal->palVersion = 0x300;
 666         npPal->palNumEntries = (WORD)lpInfo->biClrUsed;
 667
 668         /* get pointer to the color table */
 669         lpRGB = (RGBQUAD FAR *)((LPSTR)lpInfo + lpInfo->biSize);
 670
 671         /* copy colors from the color table to the LogPalette structure */
 672         for (i = 0; i < lpInfo->biClrUsed; i++, lpRGB++)
 673         {
 674             npPal->palPalEntry[i].peRed = lpRGB->rgbRed;
 675             npPal->palPalEntry[i].peGreen = lpRGB->rgbGreen;
 676             npPal->palPalEntry[i].peBlue = lpRGB->rgbBlue;
 677             npPal->palPalEntry[i].peFlags = 0;
 678         }
 679
 680         hLogPal = CreatePalette((LPLOGPALETTE)npPal);
 681 //      LocalFree((HANDLE)npPal);
 682         free(npPal);
 683
 684         return(hLogPal);
 685     }
 686
 687     /* 24-bit DIB with no color table.  return default palette.  Another
 688     ** option would be to create a 256 color "rainbow" palette to provide
 689     ** some good color choices.
 690     */
 691     else
 692         return((HPALETTE) GetStockObject(DEFAULT_PALETTE));
 693 }
 694
 695 bool wxLoadIntoBitmap(char *filename, wxBitmap *bitmap, wxPalette **pal)
 696 {
 697   HBITMAP hBitmap;
 698   HPALETTE hPalette;
 699
 700   bool success = (ReadDIB(filename, &hBitmap, &hPalette) != 0);
 701
 702   if (!success)
 703   {
 704     DeleteObject(hPalette);
 705     return FALSE;
 706   }
 707
 708   if (hPalette)
 709   {
 710     if (pal)
 711     {
 712       *pal = new wxPalette;
 713       (*pal)->SetHPALETTE((WXHPALETTE) hPalette);
 714     }
 715     else
 716       DeleteObject(hPalette);
 717   }
 718   else if (pal)
 719     *pal = NULL;
 720
 721   if (hBitmap)
 722   {
 723     BITMAP bm;
 724     GetObject(hBitmap, sizeof(bm), (LPSTR)&bm);
 725
 726     bitmap->SetHBITMAP((WXHBITMAP) hBitmap);
 727     bitmap->SetWidth(bm.bmWidth);
 728     bitmap->SetHeight(bm.bmHeight);
 729     bitmap->SetDepth(bm.bmPlanes * bm.bmBitsPixel);
 730     bitmap->SetOk(TRUE);
 731     return TRUE;
 732   }
 733   else return FALSE;
 734 }
 735
 736 wxBitmap *wxLoadBitmap(char *filename, wxPalette **pal)
 737 {
 738   wxBitmap *bitmap = new wxBitmap;
 739   if (wxLoadIntoBitmap(filename, bitmap, pal))
 740     return bitmap;
 741   else
 742   {
 743     delete bitmap;
 744     return NULL;
 745   }
 746 }
 747
 748 //---------------------------------------------------------------------
 749 //
 750 // Function:   InitBitmapInfoHeader
 751 //
 752 // Purpose:    Does a "standard" initialization of a BITMAPINFOHEADER,
 753 //             given the Width, Height, and Bits per Pixel for the
 754 //             DIB.
 755 //
 756 //             By standard, I mean that all the relevant fields are set
 757 //             to the specified values.  biSizeImage is computed, the
 758 //             biCompression field is set to "no compression," and all
 759 //             other fields are 0.
 760 //
 761 //             Note that DIBs only allow BitsPixel values of 1, 4, 8, or
 762 //             24.  This routine makes sure that one of these values is
 763 //             used (whichever is most appropriate for the specified
 764 //             nBPP).
 765 //
 766 // Parms:      lpBmInfoHdr == Far pointer to a BITMAPINFOHEADER structure
 767 //                            to be filled in.
 768 //             dwWidth     == Width of DIB (not in Win 3.0 & 3.1, high
 769 //                            word MUST be 0).
 770 //             dwHeight    == Height of DIB (not in Win 3.0 & 3.1, high
 771 //                            word MUST be 0).
 772 //             nBPP        == Bits per Pixel for the DIB.
 773 //
 774 // History:   Date      Reason
 775 //            11/07/91  Created
 776 //
 777 //---------------------------------------------------------------------
 778
 779 void InitBitmapInfoHeader (LPBITMAPINFOHEADER lpBmInfoHdr,
 780                                         DWORD dwWidth,
 781                                         DWORD dwHeight,
 782                                           int nBPP)
 783 {
 784 //   _fmemset (lpBmInfoHdr, 0, sizeof (BITMAPINFOHEADER));
 785    memset (lpBmInfoHdr, 0, sizeof (BITMAPINFOHEADER));
 786
 787    lpBmInfoHdr->biSize      = sizeof (BITMAPINFOHEADER);
 788    lpBmInfoHdr->biWidth     = dwWidth;
 789    lpBmInfoHdr->biHeight    = dwHeight;
 790    lpBmInfoHdr->biPlanes    = 1;
 791
 792    if (nBPP <= 1)
 793       nBPP = 1;
 794    else if (nBPP <= 4)
 795       nBPP = 4;
 796    else if (nBPP <= 8)
 797       nBPP = 8;
 798 /* Doesn't work
 799    else if (nBPP <= 16)
 800       nBPP = 16;
 801 */
 802    else
 803       nBPP = 24;
 804
 805    lpBmInfoHdr->biBitCount  = nBPP;
 806    lpBmInfoHdr->biSizeImage = WIDTHBYTES (dwWidth * nBPP) * dwHeight;
 807 }
 808
 809
 810
 811
 812 LPSTR FindDIBBits (LPSTR lpbi)
 813 {
 814    return (lpbi + *(LPDWORD)lpbi + PaletteSize (lpbi));
 815 }
 816
 817 //---------------------------------------------------------------------
 818 //
 819 // Function:   BitmapToDIB
 820 //
 821 // Purpose:    Given a device dependent bitmap and a palette, returns
 822 //             a handle to global memory with a DIB spec in it.  The
 823 //             DIB is rendered using the colors of the palette passed in.
 824 //
 825 //             Stolen almost verbatim from ShowDIB.
 826 //
 827 // Parms:      hBitmap == Handle to device dependent bitmap compatible
 828 //                        with default screen display device.
 829 //             hPal    == Palette to render the DDB with.  If it's NULL,
 830 //                        use the default palette.
 831 //
 832 // History:   Date      Reason
 833 //             6/01/91  Created
 834 //
 835 //---------------------------------------------------------------------
 836
 837 HANDLE BitmapToDIB (HBITMAP hBitmap, HPALETTE hPal)
 838 {
 839    BITMAP             Bitmap;
 840    BITMAPINFOHEADER   bmInfoHdr;
 841    LPBITMAPINFOHEADER lpbmInfoHdr;
 842    LPSTR              lpBits;
 843    HDC                hMemDC;
 844    HANDLE             hDIB;
 845    HPALETTE           hOldPal = NULL;
 846
 847       // Do some setup -- make sure the Bitmap passed in is valid,
 848       //  get info on the bitmap (like its height, width, etc.),
 849       //  then setup a BITMAPINFOHEADER.
 850
 851    if (!hBitmap)
 852       return NULL;
 853
 854    if (!GetObject (hBitmap, sizeof (Bitmap), (LPSTR) &Bitmap))
 855       return NULL;
 856
 857    InitBitmapInfoHeader (&bmInfoHdr,
 858                          Bitmap.bmWidth,
 859                          Bitmap.bmHeight,
 860                          Bitmap.bmPlanes * Bitmap.bmBitsPixel);
 861
 862
 863       // Now allocate memory for the DIB.  Then, set the BITMAPINFOHEADER
 864       //  into this memory, and find out where the bitmap bits go.
 865
 866    hDIB = GlobalAlloc (GHND, sizeof (BITMAPINFOHEADER) +
 867              PaletteSize ((LPSTR) &bmInfoHdr) + bmInfoHdr.biSizeImage);
 868
 869    if (!hDIB)
 870       return NULL;
 871
 872 #ifdef __WINDOWS_386__
 873    lpbmInfoHdr  = (LPBITMAPINFOHEADER) MK_FP32(GlobalLock (hDIB));
 874 #else
 875    lpbmInfoHdr  = (LPBITMAPINFOHEADER) GlobalLock (hDIB);
 876 #endif
 877
 878    *lpbmInfoHdr = bmInfoHdr;
 879    lpBits       = FindDIBBits ((LPSTR) lpbmInfoHdr);
 880
 881
 882       // Now, we need a DC to hold our bitmap.  If the app passed us
 883       //  a palette, it should be selected into the DC.
 884
 885    hMemDC       = GetDC (NULL);
 886
 887    if (hPal)
 888       {
 889       hOldPal = SelectPalette (hMemDC, hPal, FALSE);
 890       RealizePalette (hMemDC);
 891       }
 892
 893
 894
 895       // We're finally ready to get the DIB.  Call the driver and let
 896       //  it party on our bitmap.  It will fill in the color table,
 897       //  and bitmap bits of our global memory block.
 898
 899    if (!GetDIBits (hMemDC,
 900                    hBitmap,
 901                    0,
 902                    Bitmap.bmHeight,
 903                    lpBits,
 904                    (LPBITMAPINFO) lpbmInfoHdr,
 905                    DIB_RGB_COLORS))
 906       {
 907       GlobalUnlock (hDIB);
 908       GlobalFree (hDIB);
 909       hDIB = NULL;
 910       }
 911    else
 912       GlobalUnlock (hDIB);
 913
 914
 915       // Finally, clean up and return.
 916
 917    if (hOldPal)
 918       SelectPalette (hMemDC, hOldPal, FALSE);
 919
 920    ReleaseDC (NULL, hMemDC);
 921
 922    return hDIB;
 923 }
 924
 925 bool wxSaveBitmap(char *filename, wxBitmap *bitmap, wxPalette *colourmap)
 926 {
 927   HPALETTE hPalette = 0;
 928   if (colourmap)
 929     hPalette = (HPALETTE) colourmap->GetHPALETTE();
 930
 931   HANDLE dibHandle = BitmapToDIB((HBITMAP) bitmap->GetHBITMAP(), hPalette);
 932   if (dibHandle)
 933   {
 934     bool success = (WriteDIB(filename, dibHandle) != 0);
 935     GlobalFree(dibHandle);
 936     return success;
 937   }
 938   else return FALSE;
 939 }
 940
 941