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