]> git.saurik.com Git - wxWidgets.git/blob - src/msw/dibutils.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Adjusted filelist.txt and wxUniv.dsp to use generic
[wxWidgets.git] / src / msw / dibutils.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: dibutils.cpp
3 // Purpose: Utilities for DIBs
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Microsoft, Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "dibutils.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #ifndef WX_PRECOMP
24 #include "wx/setup.h"
25 #include "wx/defs.h"
26 #include "wx/string.h"
27 #endif
28
29 #include <windows.h>
30 #include <windowsx.h>
31 #include <stdio.h>
32
33 #include "wx/msw/dibutils.h"
34
35 #ifdef __WXWINE__
36 /* Why module.h? No longer finds this header.
37 #include <module.h>
38 */
39 #endif
40
41 #if defined(__WIN32__)
42 #if !defined(__MWERKS__) && !defined(__SALFORDC__)
43 #include <memory.h> // for _fmemcpy()
44 #endif
45 #define _huge
46 #ifndef hmemcpy
47 #define hmemcpy memcpy
48 #endif
49 #endif
50
51 #define BFT_ICON 0x4349 /* 'IC' */
52 #define BFT_BITMAP 0x4d42 /* 'BM' */
53 #define BFT_CURSOR 0x5450 /* 'PT(' */
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 /* Copied from PNGhandler for coompilation with MingW32, RR */
63
64 #ifndef GlobalAllocPtr
65 #define GlobalPtrHandle(lp) \
66 ((HGLOBAL)GlobalHandle(lp))
67
68 #define GlobalLockPtr(lp) \
69 ((BOOL)GlobalLock(GlobalPtrHandle(lp)))
70 #define GlobalUnlockPtr(lp) \
71 GlobalUnlock(GlobalPtrHandle(lp))
72
73 #define GlobalAllocPtr(flags, cb) \
74 (GlobalLock(GlobalAlloc((flags), (cb))))
75 #define GlobalReAllocPtr(lp, cbNew, flags) \
76 (GlobalUnlockPtr(lp), GlobalLock(GlobalReAlloc(GlobalPtrHandle(lp) , (cbNew), (flags))))
77 #define GlobalFreePtr(lp) \
78 (GlobalUnlockPtr(lp), (BOOL)GlobalFree(GlobalPtrHandle(lp)))
79 #endif
80
81
82 /*
83 * Clear the System Palette so that we can ensure an identity palette
84 * mapping for fast performance.
85 */
86
87 void wxClearSystemPalette(void)
88 {
89 //*** A dummy palette setup
90 struct
91 {
92 WORD Version;
93 WORD NumberOfEntries;
94 PALETTEENTRY aEntries[256];
95 } Palette =
96 {
97 0x300,
98 256
99 };
100
101 HPALETTE ScreenPalette = 0;
102 HDC ScreenDC;
103 int Counter;
104 UINT nMapped = 0;
105 BOOL bOK = FALSE;
106 int nOK = 0;
107
108 // *** Reset everything in the system palette to black
109 for(Counter = 0; Counter < 256; Counter++)
110 {
111 Palette.aEntries[Counter].peRed = 0;
112 Palette.aEntries[Counter].peGreen = 0;
113 Palette.aEntries[Counter].peBlue = 0;
114 Palette.aEntries[Counter].peFlags = PC_NOCOLLAPSE;
115 }
116
117 // *** Create, select, realize, deselect, and delete the palette
118 #ifdef __WXWINE__
119 ScreenDC = GetDC((HWND)NULL);
120 #else
121 ScreenDC = GetDC(NULL);
122 #endif
123 ScreenPalette = CreatePalette((LOGPALETTE *)&Palette);
124
125 if (ScreenPalette)
126 {
127 ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
128 nMapped = RealizePalette(ScreenDC);
129 ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
130 bOK = DeleteObject(ScreenPalette);
131 }
132
133 #ifdef __WXWINE__
134 nOK = ReleaseDC((HWND)NULL, ScreenDC);
135 #else
136 nOK = ReleaseDC(NULL, ScreenDC);
137 #endif
138
139 return;
140 }
141
142
143 /*
144 * Open a DIB file and return a MEMORY DIB, a memory handle containing..
145 *
146 * BITMAP INFO bi
147 * palette data
148 * bits....
149 */
150
151 int wxDibWriteFile(LPTSTR szFile, LPBITMAPINFOHEADER lpbi)
152 {
153 HFILE fh;
154 OFSTRUCT of;
155
156 fh = OpenFile(wxConvFile.cWX2MB(szFile), &of, OF_WRITE | OF_CREATE);
157
158 if (!fh) {
159 // printf("la regamos0");
160 return 0;
161 }
162
163 long size = wxDibSize(lpbi);
164
165 // write file header
166 BITMAPFILEHEADER bmf;
167 bmf.bfType = BFT_BITMAP;
168 bmf.bfSize = sizeof(bmf) + size;
169 bmf.bfReserved1 = 0;
170 bmf.bfReserved2 = 0;
171 bmf.bfOffBits = sizeof(bmf) + (char FAR*)(wxDibPtr(lpbi)) - (char FAR*)lpbi;
172 #if 1 // defined( __WATCOMC__) || defined(__VISUALC__) || defined(__SC__) || defined(__SALFORDC__) || defined(__MWERKS__) || wxUSE_NORLANDER_HEADERS
173 #define HWRITE_2ND_ARG_TYPE LPCSTR
174 #else // don't know who needs this...
175 #define HWRITE_2ND_ARG_TYPE LPBYTE
176 #endif
177
178 if ( _hwrite(fh, (HWRITE_2ND_ARG_TYPE)(&bmf), sizeof(bmf)) < 0 ||
179 _hwrite(fh, (HWRITE_2ND_ARG_TYPE)lpbi, size) < 0 )
180 {
181 _lclose(fh);
182 return 0;
183 }
184
185 #undef HWRITE_2ND_ARG_TYPE
186
187 _lclose(fh);
188 return 1;
189 }
190
191 PDIB wxDibOpenFile(LPTSTR szFile)
192 {
193 HFILE fh;
194 DWORD dwLen;
195 DWORD dwBits;
196 PDIB pdib;
197 LPVOID p;
198 OFSTRUCT of;
199
200 #if defined(WIN32) || defined(_WIN32)
201 #define GetCurrentInstance() GetModuleHandle(NULL)
202 #else
203 #define GetCurrentInstance() (HINSTANCE)SELECTOROF((LPVOID)&of)
204 #endif
205
206 fh = OpenFile(wxConvFile.cWX2MB(szFile), &of, OF_READ);
207
208 if (fh == -1)
209 {
210 HRSRC h;
211
212 // TODO: Unicode version
213 #ifdef __WIN16__
214 h = FindResource(GetCurrentInstance(), szFile, RT_BITMAP);
215 #elif wxUSE_UNICODE
216 h = FindResourceW(GetCurrentInstance(), szFile, RT_BITMAP);
217 #else
218 h = FindResourceA(GetCurrentInstance(), szFile, RT_BITMAP);
219 #endif
220
221 #if defined(__WIN32__)
222 //!!! can we call GlobalFree() on this? is it the right format.
223 //!!! can we write to this resource?
224 if (h)
225 return (PDIB)LockResource(LoadResource(GetCurrentInstance(), h));
226 #else
227 if (h)
228 fh = AccessResource(GetCurrentInstance(), h);
229 #endif
230 }
231
232 if (fh == -1)
233 return NULL;
234
235 pdib = wxDibReadBitmapInfo(fh);
236
237 if (!pdib)
238 return NULL;
239
240 /* How much memory do we need to hold the DIB */
241
242 dwBits = pdib->biSizeImage;
243 dwLen = pdib->biSize + wxDibPaletteSize(pdib) + dwBits;
244
245 /* Can we get more memory? */
246
247 p = GlobalReAllocPtr(pdib,dwLen,0);
248
249 if (!p)
250 {
251 GlobalFreePtr(pdib);
252 pdib = NULL;
253 }
254 else
255 {
256 pdib = (PDIB)p;
257 }
258
259 if (pdib)
260 {
261 /* read in the bits */
262 _hread(fh, (LPBYTE)pdib + (UINT)pdib->biSize + wxDibPaletteSize(pdib), dwBits);
263 }
264
265 _lclose(fh);
266
267 return pdib;
268 }
269
270
271 /*
272 * ReadDibBitmapInfo()
273 *
274 * Will read a file in DIB format and return a global HANDLE to its
275 * BITMAPINFO. This function will work with both "old" and "new"
276 * bitmap formats, but will always return a "new" BITMAPINFO.
277 */
278
279 PDIB wxDibReadBitmapInfo(HFILE fh)
280 {
281 DWORD off;
282 int size;
283 int i;
284 int nNumColors;
285
286 RGBQUAD FAR *pRgb;
287 BITMAPINFOHEADER bi;
288 BITMAPCOREHEADER bc;
289 BITMAPFILEHEADER bf;
290 PDIB pdib;
291
292 if (fh == -1)
293 return NULL;
294
295 off = _llseek(fh,0L,SEEK_CUR);
296
297 if (sizeof(bf) != _lread(fh,(LPSTR)&bf,sizeof(bf)))
298 return NULL;
299
300 /*
301 * do we have a RC HEADER?
302 */
303 if (bf.bfType != BFT_BITMAP)
304 {
305 bf.bfOffBits = 0L;
306 _llseek(fh,off,SEEK_SET);
307 }
308
309 if (sizeof(bi) != _lread(fh,(LPSTR)&bi,sizeof(bi)))
310 return NULL;
311
312 /*
313 * what type of bitmap info is this?
314 */
315 switch (size = (int)bi.biSize)
316 {
317 default:
318 case sizeof(BITMAPINFOHEADER):
319 break;
320
321 case sizeof(BITMAPCOREHEADER):
322 bc = *(BITMAPCOREHEADER*)&bi;
323 bi.biSize = sizeof(BITMAPINFOHEADER);
324 bi.biWidth = (DWORD)bc.bcWidth;
325 bi.biHeight = (DWORD)bc.bcHeight;
326 bi.biPlanes = (WORD)bc.bcPlanes;
327 bi.biBitCount = (WORD)bc.bcBitCount;
328 bi.biCompression = BI_RGB;
329 bi.biSizeImage = 0;
330 bi.biXPelsPerMeter = 0;
331 bi.biYPelsPerMeter = 0;
332 bi.biClrUsed = 0;
333 bi.biClrImportant = 0;
334
335 _llseek(fh,(LONG)sizeof(BITMAPCOREHEADER)-sizeof(BITMAPINFOHEADER),SEEK_CUR);
336
337 break;
338 }
339
340 nNumColors = wxDibNumColors(&bi);
341
342 #if 0
343 if (bi.biSizeImage == 0)
344 bi.biSizeImage = DibSizeImage(&bi);
345
346 if (bi.biClrUsed == 0)
347 bi.biClrUsed = wxDibNumColors(&bi);
348 #else
349 wxFixBitmapInfo(&bi);
350 #endif
351
352 pdib = (PDIB)GlobalAllocPtr(GMEM_MOVEABLE,(LONG)bi.biSize + nNumColors * sizeof(RGBQUAD));
353
354 if (!pdib)
355 return NULL;
356
357 *pdib = bi;
358
359 pRgb = wxDibColors(pdib);
360
361 if (nNumColors)
362 {
363 if (size == sizeof(BITMAPCOREHEADER))
364 {
365 /*
366 * convert a old color table (3 byte entries) to a new
367 * color table (4 byte entries)
368 */
369 _lread(fh,(LPVOID)pRgb,nNumColors * sizeof(RGBTRIPLE));
370
371 for (i=nNumColors-1; i>=0; i--)
372 {
373 RGBQUAD rgb;
374
375 rgb.rgbRed = ((RGBTRIPLE FAR *)pRgb)[i].rgbtRed;
376 rgb.rgbBlue = ((RGBTRIPLE FAR *)pRgb)[i].rgbtBlue;
377 rgb.rgbGreen = ((RGBTRIPLE FAR *)pRgb)[i].rgbtGreen;
378 rgb.rgbReserved = (BYTE)0;
379
380 pRgb[i] = rgb;
381 }
382 }
383 else
384 {
385 _lread(fh,(LPVOID)pRgb,nNumColors * sizeof(RGBQUAD));
386 }
387 }
388
389 if (bf.bfOffBits != 0L)
390 _llseek(fh,off + bf.bfOffBits,SEEK_SET);
391
392 return pdib;
393 }
394
395 /*
396 * DibSetUsage(hdib,hpal,wUsage)
397 *
398 * Modifies the color table of the passed DIB for use with the wUsage
399 * parameter specifed.
400 *
401 * if wUsage is DIB_PAL_COLORS the DIB color table is set to 0-256
402 * if wUsage is DIB_RGB_COLORS the DIB color table is set to the RGB values
403 * in the passed palette
404 */
405
406 BOOL wxDibSetUsage(PDIB pdib, HPALETTE hpal,UINT wUsage)
407 {
408 PALETTEENTRY ape[256];
409 RGBQUAD FAR * pRgb;
410 WORD FAR * pw;
411 int nColors;
412 int n;
413
414 if (hpal == NULL)
415 hpal = (HPALETTE)GetStockObject(DEFAULT_PALETTE);
416
417 if (!pdib)
418 return FALSE;
419
420 nColors = wxDibNumColors(pdib);
421
422 if (nColors == 3 && wxDibCompression(pdib) == BI_BITFIELDS)
423 nColors = 0;
424
425 if (nColors > 0)
426 {
427 pRgb = wxDibColors(pdib);
428
429 switch (wUsage)
430 {
431 //
432 // Set the DIB color table to palette indexes
433 //
434 case DIB_PAL_COLORS:
435 for (pw = (WORD FAR*)pRgb,n=0; n<nColors; n++,pw++)
436 *pw = n;
437 break;
438
439 //
440 // Set the DIB color table to RGBQUADS
441 //
442 default:
443 case DIB_RGB_COLORS:
444 nColors = (nColors < 256) ? nColors: 256;
445
446 GetPaletteEntries(hpal,0,nColors,ape);
447
448 for (n=0; n<nColors; n++)
449 {
450 pRgb[n].rgbRed = ape[n].peRed;
451 pRgb[n].rgbGreen = ape[n].peGreen;
452 pRgb[n].rgbBlue = ape[n].peBlue;
453 pRgb[n].rgbReserved = 0;
454 }
455 break;
456 }
457 }
458 return TRUE;
459 }
460
461 /*
462 * DibCreate(bits, dx, dy)
463 *
464 * Creates a new packed DIB with the given dimensions and the
465 * given number of bits per pixel
466 */
467
468 PDIB wxDibCreate(int bits, int dx, int dy)
469 {
470 LPBITMAPINFOHEADER lpbi ;
471 DWORD dwSizeImage;
472 int i;
473 DWORD FAR *pdw;
474
475 dwSizeImage = dy*(DWORD)((dx*bits/8+3)&~3);
476
477 lpbi = (PDIB)GlobalAllocPtr(GHND,sizeof(BITMAPINFOHEADER)+dwSizeImage + 1024);
478
479 if (lpbi == NULL)
480 return NULL;
481
482 lpbi->biSize = sizeof(BITMAPINFOHEADER) ;
483 lpbi->biWidth = dx;
484 lpbi->biHeight = dy;
485 lpbi->biPlanes = 1;
486 lpbi->biBitCount = bits ;
487 lpbi->biCompression = BI_RGB ;
488 lpbi->biSizeImage = dwSizeImage;
489 lpbi->biXPelsPerMeter = 0 ;
490 lpbi->biYPelsPerMeter = 0 ;
491 lpbi->biClrUsed = 0 ;
492 lpbi->biClrImportant = 0 ;
493
494 if (bits == 4)
495 lpbi->biClrUsed = 16;
496
497 else if (bits == 8)
498 lpbi->biClrUsed = 256;
499
500 pdw = (DWORD FAR *)((LPBYTE)lpbi+(int)lpbi->biSize);
501
502 for (i=0; i<(int)lpbi->biClrUsed/16; i++)
503 {
504 *pdw++ = 0x00000000; // 0000 black
505 *pdw++ = 0x00800000; // 0001 dark red
506 *pdw++ = 0x00008000; // 0010 dark green
507 *pdw++ = 0x00808000; // 0011 mustard
508 *pdw++ = 0x00000080; // 0100 dark blue
509 *pdw++ = 0x00800080; // 0101 purple
510 *pdw++ = 0x00008080; // 0110 dark turquoise
511 *pdw++ = 0x00C0C0C0; // 1000 gray
512 *pdw++ = 0x00808080; // 0111 dark gray
513 *pdw++ = 0x00FF0000; // 1001 red
514 *pdw++ = 0x0000FF00; // 1010 green
515 *pdw++ = 0x00FFFF00; // 1011 yellow
516 *pdw++ = 0x000000FF; // 1100 blue
517 *pdw++ = 0x00FF00FF; // 1101 pink (magenta)
518 *pdw++ = 0x0000FFFF; // 1110 cyan
519 *pdw++ = 0x00FFFFFF; // 1111 white
520 }
521
522 return (PDIB)lpbi;
523 }
524
525 static void xlatClut8(BYTE FAR *pb, DWORD dwSize, BYTE FAR *xlat)
526 {
527 DWORD dw;
528
529 #ifdef __cplusplus
530 for (dw = 0; dw < dwSize; dw++, ((BYTE _huge *&)pb)++)
531 #else
532 for (dw = 0; dw < dwSize; dw++, ((BYTE _huge *)pb)++)
533 #endif
534 *pb = xlat[*pb];
535 }
536
537 static void xlatClut4(BYTE FAR *pb, DWORD dwSize, BYTE FAR *xlat)
538 {
539 DWORD dw;
540
541 #ifdef __cplusplus
542 for (dw = 0; dw < dwSize; dw++, ((BYTE _huge *&)pb)++)
543 #else
544 for (dw = 0; dw < dwSize; dw++, ((BYTE _huge *)pb)++)
545 #endif
546 *pb = (BYTE)(xlat[*pb & 0x0F] | (xlat[(*pb >> 4) & 0x0F] << 4));
547 }
548
549 #define RLE_ESCAPE 0
550 #define RLE_EOL 0
551 #define RLE_EOF 1
552 #define RLE_JMP 2
553
554 static void xlatRle8(BYTE FAR *pb, DWORD WXUNUSED(dwSize), BYTE FAR *xlat)
555 {
556 BYTE cnt;
557 BYTE b;
558 BYTE _huge *prle = pb;
559
560 for(;;)
561 {
562 cnt = *prle++;
563 b = *prle;
564
565 if (cnt == RLE_ESCAPE)
566 {
567 prle++;
568
569 switch (b)
570 {
571 case RLE_EOF:
572 return;
573
574 case RLE_EOL:
575 break;
576
577 case RLE_JMP:
578 prle++; // skip dX
579 prle++; // skip dY
580 break;
581
582 default:
583 cnt = b;
584 for (b=0; b<cnt; b++,prle++)
585 *prle = xlat[*prle];
586
587 if (cnt & 1)
588 prle++;
589
590 break;
591 }
592 }
593 else
594 {
595 *prle++ = xlat[b];
596 }
597 }
598 }
599
600 static void xlatRle4(BYTE FAR *WXUNUSED(pb), DWORD WXUNUSED(dwSize), BYTE FAR *WXUNUSED(xlat))
601 {
602 }
603
604 static void hmemmove(BYTE _huge *d, BYTE _huge *s, LONG len)
605 {
606 d += len-1;
607 s += len-1;
608
609 while (len--)
610 *d-- = *s--;
611 }
612
613 /*
614 * DibMapToPalette(pdib, hpal)
615 *
616 * Map the colors of the DIB, using GetNearestPaletteIndex, to
617 * the colors of the given palette.
618 */
619
620 BOOL wxDibMapToPalette(PDIB pdib, HPALETTE hpal)
621 {
622 LPBITMAPINFOHEADER lpbi;
623 PALETTEENTRY pe;
624 int n;
625 int nDibColors;
626 int nPalColors=0;
627 BYTE FAR * lpBits;
628 RGBQUAD FAR * lpRgb;
629 BYTE xlat[256];
630 DWORD SizeImage;
631
632 if (!hpal || !pdib)
633 return FALSE;
634
635 lpbi = (LPBITMAPINFOHEADER)pdib;
636 lpRgb = wxDibColors(pdib);
637
638 GetObject(hpal,sizeof(int),(LPSTR)&nPalColors);
639 nDibColors = wxDibNumColors(pdib);
640
641 if ((SizeImage = lpbi->biSizeImage) == 0)
642 SizeImage = wxDibSizeImage(lpbi);
643
644 //
645 // build a xlat table. from the current DIB colors to the given
646 // palette.
647 //
648 for (n=0; n<nDibColors; n++)
649 xlat[n] = (BYTE)GetNearestPaletteIndex(hpal,RGB(lpRgb[n].rgbRed,lpRgb[n].rgbGreen,lpRgb[n].rgbBlue));
650
651 lpBits = (LPBYTE)wxDibPtr(lpbi);
652 lpbi->biClrUsed = nPalColors;
653
654 //
655 // re-size the DIB
656 //
657 if (nPalColors > nDibColors)
658 {
659 GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
660 hmemmove((BYTE _huge *)wxDibPtr(lpbi), (BYTE _huge *)lpBits, SizeImage);
661 lpBits = (LPBYTE)wxDibPtr(lpbi);
662 }
663 else if (nPalColors < nDibColors)
664 {
665 hmemcpy(wxDibPtr(lpbi), lpBits, SizeImage);
666 GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
667 lpBits = (LPBYTE)wxDibPtr(lpbi);
668 }
669
670 //
671 // translate the DIB bits
672 //
673 switch (lpbi->biCompression)
674 {
675 case BI_RLE8:
676 xlatRle8(lpBits, SizeImage, xlat);
677 break;
678
679 case BI_RLE4:
680 xlatRle4(lpBits, SizeImage, xlat);
681 break;
682
683 case BI_RGB:
684 if (lpbi->biBitCount == 8)
685 xlatClut8(lpBits, SizeImage, xlat);
686 else
687 xlatClut4(lpBits, SizeImage, xlat);
688 break;
689 }
690
691 //
692 // Now copy the RGBs in the logical palette to the dib color table
693 //
694 for (n=0; n<nPalColors; n++)
695 {
696 GetPaletteEntries(hpal,n,1,&pe);
697
698 lpRgb[n].rgbRed = pe.peRed;
699 lpRgb[n].rgbGreen = pe.peGreen;
700 lpRgb[n].rgbBlue = pe.peBlue;
701 lpRgb[n].rgbReserved = (BYTE)0;
702 }
703
704 return TRUE;
705 }
706
707
708 HPALETTE wxMakePalette(const BITMAPINFO FAR* Info, UINT flags)
709 {
710 HPALETTE hPalette;
711 const RGBQUAD FAR* rgb = Info->bmiColors;
712
713 WORD nColors = (WORD)Info->bmiHeader.biClrUsed;
714 if (nColors) {
715 LOGPALETTE* logPal = (LOGPALETTE*)
716 new BYTE[sizeof(LOGPALETTE) + (nColors-1)*sizeof(PALETTEENTRY)];
717
718 logPal->palVersion = 0x300; // Windows 3.0 version
719 logPal->palNumEntries = nColors;
720 for (WORD n = 0; n < nColors; n++) {
721 logPal->palPalEntry[n].peRed = rgb[n].rgbRed;
722 logPal->palPalEntry[n].peGreen = rgb[n].rgbGreen;
723 logPal->palPalEntry[n].peBlue = rgb[n].rgbBlue;
724 logPal->palPalEntry[n].peFlags = (BYTE)flags;
725 }
726 hPalette = ::CreatePalette(logPal);
727 delete logPal;
728 } else
729 hPalette = 0;
730
731 return hPalette;
732 }
733
wxWidgets (Impactor)