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