]> git.saurik.com Git - wxWidgets.git/blob - src/msw/bitmap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
removing dependancy on mac headers from public wx headers (eventually adding wx/mac...
[wxWidgets.git] / src / msw / bitmap.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: bitmap.cpp
3 // Purpose: wxBitmap
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "bitmap.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include <stdio.h>
33
34 #include "wx/list.h"
35 #include "wx/utils.h"
36 #include "wx/app.h"
37 #include "wx/palette.h"
38 #include "wx/dcmemory.h"
39 #include "wx/bitmap.h"
40 #include "wx/icon.h"
41 #endif
42
43 //#include "device.h"
44
45 #include "wx/msw/private.h"
46 #include "wx/log.h"
47
48 #if !defined(__WXMICROWIN__)
49 #include "wx/msw/dib.h"
50 #endif
51
52 #include "wx/image.h"
53 #include "wx/xpmdecod.h"
54
55 // missing from mingw32 header
56 #ifndef CLR_INVALID
57 #define CLR_INVALID ((COLORREF)-1)
58 #endif // no CLR_INVALID
59
60 // ----------------------------------------------------------------------------
61 // macros
62 // ----------------------------------------------------------------------------
63
64 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
65 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
66
67 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
68
69 // ============================================================================
70 // implementation
71 // ============================================================================
72
73 // ----------------------------------------------------------------------------
74 // wxBitmapRefData
75 // ----------------------------------------------------------------------------
76
77 wxBitmapRefData::wxBitmapRefData()
78 {
79 m_quality = 0;
80 m_selectedInto = NULL;
81 m_numColors = 0;
82 m_bitmapMask = NULL;
83 m_hBitmap = (WXHBITMAP) NULL;
84 }
85
86 void wxBitmapRefData::Free()
87 {
88 wxASSERT_MSG( !m_selectedInto,
89 wxT("deleting bitmap still selected into wxMemoryDC") );
90
91 if ( m_hBitmap)
92 {
93 // printf("About to delete bitmap %d\n", (int) (HBITMAP) m_hBitmap);
94 #if 1
95 if ( !::DeleteObject((HBITMAP)m_hBitmap) )
96 {
97 wxLogLastError(wxT("DeleteObject(hbitmap)"));
98 }
99 #endif
100 }
101
102 delete m_bitmapMask;
103 m_bitmapMask = NULL;
104 }
105
106 // ----------------------------------------------------------------------------
107 // wxBitmap creation
108 // ----------------------------------------------------------------------------
109
110 // this function should be called from all wxBitmap ctors
111 void wxBitmap::Init()
112 {
113 // m_refData = NULL; done in the base class ctor
114
115 }
116
117 #ifdef __WIN32__
118
119 bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
120 {
121 #ifndef __WXMICROWIN__
122 // it may be either HICON or HCURSOR
123 HICON hicon = (HICON)icon.GetHandle();
124
125 ICONINFO iconInfo;
126 if ( !::GetIconInfo(hicon, &iconInfo) )
127 {
128 wxLogLastError(wxT("GetIconInfo"));
129
130 return FALSE;
131 }
132
133 wxBitmapRefData *refData = new wxBitmapRefData;
134 m_refData = refData;
135
136 int w = icon.GetWidth(),
137 h = icon.GetHeight();
138
139 refData->m_width = w;
140 refData->m_height = h;
141 refData->m_depth = wxDisplayDepth();
142
143 refData->m_hBitmap = (WXHBITMAP)iconInfo.hbmColor;
144
145 // the mask returned by GetIconInfo() is inversed compared to the usual
146 // wxWin convention
147 refData->m_bitmapMask = new wxMask((WXHBITMAP)
148 wxInvertMask(iconInfo.hbmMask, w, h));
149
150
151 // delete the old one now as we don't need it any more
152 ::DeleteObject(iconInfo.hbmMask);
153
154 #if WXWIN_COMPATIBILITY_2
155 refData->m_ok = TRUE;
156 #endif // WXWIN_COMPATIBILITY_2
157
158 return TRUE;
159 #else
160 return FALSE;
161 #endif
162 }
163
164 #endif // Win32
165
166 bool wxBitmap::CopyFromCursor(const wxCursor& cursor)
167 {
168 UnRef();
169
170 if ( !cursor.Ok() )
171 return FALSE;
172
173 #ifdef __WIN16__
174 wxFAIL_MSG( _T("don't know how to convert cursor to bitmap") );
175
176 return FALSE;
177 #else
178 return CopyFromIconOrCursor(cursor);
179 #endif // Win16
180 }
181
182 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
183 {
184 UnRef();
185
186 if ( !icon.Ok() )
187 return FALSE;
188
189 // GetIconInfo() doesn't exist under Win16 and I don't know any other way
190 // to create a bitmap from icon there - but using this way we won't have
191 // the mask (FIXME)
192 #ifdef __WIN16__
193 int width = icon.GetWidth(),
194 height = icon.GetHeight();
195
196 // copy the icon to the bitmap
197 ScreenHDC hdcScreen;
198 HDC hdc = ::CreateCompatibleDC(hdcScreen);
199 HBITMAP hbitmap = ::CreateCompatibleBitmap(hdcScreen, width, height);
200 HBITMAP hbmpOld = (HBITMAP)::SelectObject(hdc, hbitmap);
201
202 ::DrawIcon(hdc, 0, 0, GetHiconOf(icon));
203
204 ::SelectObject(hdc, hbmpOld);
205 ::DeleteDC(hdc);
206
207 wxBitmapRefData *refData = new wxBitmapRefData;
208 m_refData = refData;
209
210 refData->m_width = width;
211 refData->m_height = height;
212 refData->m_depth = wxDisplayDepth();
213
214 refData->m_hBitmap = (WXHBITMAP)hbitmap;
215
216 #if WXWIN_COMPATIBILITY_2
217 refData->m_ok = TRUE;
218 #endif // WXWIN_COMPATIBILITY_2
219
220 return TRUE;
221 #else // Win32
222 return CopyFromIconOrCursor(icon);
223 #endif // Win16/Win32
224 }
225
226 wxBitmap::~wxBitmap()
227 {
228 }
229
230 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
231 {
232 Init();
233
234 #ifndef __WXMICROWIN__
235 wxBitmapRefData *refData = new wxBitmapRefData;
236 m_refData = refData;
237
238 refData->m_width = width;
239 refData->m_height = height;
240 refData->m_depth = depth;
241 refData->m_numColors = 0;
242 refData->m_selectedInto = NULL;
243
244 char *data;
245 if ( depth == 1 )
246 {
247 // we assume that it is in XBM format which is not quite the same as
248 // the format CreateBitmap() wants because the order of bytes in the
249 // line is inversed!
250 const size_t bytesPerLine = (width + 7) / 8;
251 const size_t padding = bytesPerLine % 2;
252 const size_t len = height * ( padding + bytesPerLine );
253 data = (char *)malloc(len);
254 const char *src = bits;
255 char *dst = data;
256
257 for ( int rows = 0; rows < height; rows++ )
258 {
259 for ( size_t cols = 0; cols < bytesPerLine; cols++ )
260 {
261 unsigned char val = *src++;
262 unsigned char reversed = 0;
263
264 for ( int bits = 0; bits < 8; bits++)
265 {
266 reversed <<= 1;
267 reversed |= (val & 0x01);
268 val >>= 1;
269 }
270 *dst++ = reversed;
271 }
272
273 if ( padding )
274 *dst++ = 0;
275 }
276 }
277 else
278 {
279 // bits should already be in Windows standard format
280 data = (char *)bits; // const_cast is harmless
281 }
282
283 HBITMAP hbmp = ::CreateBitmap(width, height, 1, depth, data);
284 if ( !hbmp )
285 {
286 wxLogLastError(wxT("CreateBitmap"));
287 }
288
289 if ( data != bits )
290 {
291 free(data);
292 }
293
294 SetHBITMAP((WXHBITMAP)hbmp);
295 #endif
296 }
297
298 // Create from XPM data
299 bool wxBitmap::CreateFromXpm(const char **data)
300 {
301 #if wxUSE_IMAGE && wxUSE_XPM
302 Init();
303
304 wxCHECK_MSG( data != NULL, FALSE, wxT("invalid bitmap data") )
305
306 wxXPMDecoder decoder;
307 wxImage img = decoder.ReadData(data);
308 wxCHECK_MSG( img.Ok(), FALSE, wxT("invalid bitmap data") )
309
310 *this = wxBitmap(img);
311 return TRUE;
312 #else
313 return FALSE;
314 #endif
315 }
316
317 wxBitmap::wxBitmap(int w, int h, int d)
318 {
319 Init();
320
321 (void)Create(w, h, d);
322 }
323
324 wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
325 {
326 Init();
327
328 (void)Create(data, type, width, height, depth);
329 }
330
331 wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
332 {
333 Init();
334
335 LoadFile(filename, (int)type);
336 }
337
338 bool wxBitmap::Create(int w, int h, int d)
339 {
340 UnRef();
341
342 m_refData = new wxBitmapRefData;
343
344 GetBitmapData()->m_width = w;
345 GetBitmapData()->m_height = h;
346 GetBitmapData()->m_depth = d;
347
348 HBITMAP hbmp;
349 #ifndef __WXMICROWIN__
350 if ( d > 0 )
351 {
352 hbmp = ::CreateBitmap(w, h, 1, d, NULL);
353 if ( !hbmp )
354 {
355 wxLogLastError(wxT("CreateBitmap"));
356 }
357 }
358 else
359 #endif
360 {
361 ScreenHDC dc;
362 hbmp = ::CreateCompatibleBitmap(dc, w, h);
363 if ( !hbmp )
364 {
365 wxLogLastError(wxT("CreateCompatibleBitmap"));
366 }
367
368 GetBitmapData()->m_depth = wxDisplayDepth();
369 }
370
371 SetHBITMAP((WXHBITMAP)hbmp);
372
373 #if WXWIN_COMPATIBILITY_2
374 GetBitmapData()->m_ok = hbmp != 0;
375 #endif // WXWIN_COMPATIBILITY_2
376 return Ok();
377 }
378
379 // ----------------------------------------------------------------------------
380 // wxImage to/from conversions
381 // ----------------------------------------------------------------------------
382
383 #if wxUSE_IMAGE
384
385 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
386 {
387 #ifdef __WXMICROWIN__
388
389 // Set this to 1 to experiment with mask code,
390 // which currently doesn't work
391 #define USE_MASKS 0
392
393 m_refData = new wxBitmapRefData();
394
395 // Initial attempt at a simple-minded implementation.
396 // The bitmap will always be created at the screen depth,
397 // so the 'depth' argument is ignored.
398
399 HDC hScreenDC = ::GetDC(NULL);
400 // printf("Screen planes = %d, bpp = %d\n", hScreenDC->psd->planes, hScreenDC->psd->bpp);
401 int screenDepth = ::GetDeviceCaps(hScreenDC, BITSPIXEL);
402
403 HBITMAP hBitmap = ::CreateCompatibleBitmap(hScreenDC, image.GetWidth(), image.GetHeight());
404 HBITMAP hMaskBitmap = NULL;
405 HBITMAP hOldMaskBitmap = NULL;
406 HDC hMaskDC = NULL;
407 unsigned char maskR = 0;
408 unsigned char maskG = 0;
409 unsigned char maskB = 0;
410
411 // printf("Created bitmap %d\n", (int) hBitmap);
412 if (hBitmap == NULL)
413 {
414 ::ReleaseDC(NULL, hScreenDC);
415 return FALSE;
416 }
417 HDC hMemDC = ::CreateCompatibleDC(hScreenDC);
418
419 HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap);
420 ::ReleaseDC(NULL, hScreenDC);
421
422 // created an mono-bitmap for the possible mask
423 bool hasMask = image.HasMask();
424
425 if ( hasMask )
426 {
427 #if USE_MASKS
428 // FIXME: we should be able to pass bpp = 1, but
429 // GdBlit can't handle a different depth
430 #if 0
431 hMaskBitmap = ::CreateBitmap( (WORD)image.GetWidth(), (WORD)image.GetHeight(), 1, 1, NULL );
432 #else
433 hMaskBitmap = ::CreateCompatibleBitmap( hMemDC, (WORD)image.GetWidth(), (WORD)image.GetHeight());
434 #endif
435 maskR = image.GetMaskRed();
436 maskG = image.GetMaskGreen();
437 maskB = image.GetMaskBlue();
438
439 if (!hMaskBitmap)
440 {
441 hasMask = FALSE;
442 }
443 else
444 {
445 hScreenDC = ::GetDC(NULL);
446 hMaskDC = ::CreateCompatibleDC(hScreenDC);
447 ::ReleaseDC(NULL, hScreenDC);
448
449 hOldMaskBitmap = ::SelectObject( hMaskDC, hMaskBitmap);
450 }
451 #else
452 hasMask = FALSE;
453 #endif
454 }
455
456 int i, j;
457 for (i = 0; i < image.GetWidth(); i++)
458 {
459 for (j = 0; j < image.GetHeight(); j++)
460 {
461 unsigned char red = image.GetRed(i, j);
462 unsigned char green = image.GetGreen(i, j);
463 unsigned char blue = image.GetBlue(i, j);
464
465 ::SetPixel(hMemDC, i, j, PALETTERGB(red, green, blue));
466
467 if (hasMask)
468 {
469 // scan the bitmap for the transparent colour and set the corresponding
470 // pixels in the mask to BLACK and the rest to WHITE
471 if (maskR == red && maskG == green && maskB == blue)
472 ::SetPixel(hMaskDC, i, j, PALETTERGB(0, 0, 0));
473 else
474 ::SetPixel(hMaskDC, i, j, PALETTERGB(255, 255, 255));
475 }
476 }
477 }
478
479 ::SelectObject(hMemDC, hOldBitmap);
480 ::DeleteDC(hMemDC);
481 if (hasMask)
482 {
483 ::SelectObject(hMaskDC, hOldMaskBitmap);
484 ::DeleteDC(hMaskDC);
485
486 ((wxBitmapRefData*)m_refData)->m_bitmapMask = new wxMask((WXHBITMAP) hMaskBitmap);
487 }
488
489 SetWidth(image.GetWidth());
490 SetHeight(image.GetHeight());
491 SetDepth(screenDepth);
492 SetHBITMAP( (WXHBITMAP) hBitmap );
493
494 #if wxUSE_PALETTE
495 // Copy the palette from the source image
496 SetPalette(image.GetPalette());
497 #endif // wxUSE_PALETTE
498
499 #if WXWIN_COMPATIBILITY_2
500 // check the wxBitmap object
501 GetBitmapData()->SetOk();
502 #endif // WXWIN_COMPATIBILITY_2
503
504 return TRUE;
505
506 #else
507 wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
508
509 m_refData = new wxBitmapRefData();
510
511 // sizeLimit is the MS upper limit for the DIB size
512 #ifdef WIN32
513 int sizeLimit = 1024*768*3;
514 #else
515 int sizeLimit = 0x7fff ;
516 #endif
517
518 // width and height of the device-dependent bitmap
519 int width = image.GetWidth();
520 int bmpHeight = image.GetHeight();
521
522 // calc the number of bytes per scanline and padding
523 int bytePerLine = width*3;
524 int sizeDWORD = sizeof( DWORD );
525 int lineBoundary = bytePerLine % sizeDWORD;
526 int padding = 0;
527 if( lineBoundary > 0 )
528 {
529 padding = sizeDWORD - lineBoundary;
530 bytePerLine += padding;
531 }
532 // calc the number of DIBs and heights of DIBs
533 int numDIB = 1;
534 int hRemain = 0;
535 int height = sizeLimit/bytePerLine;
536 if( height >= bmpHeight )
537 height = bmpHeight;
538 else
539 {
540 numDIB = bmpHeight / height;
541 hRemain = bmpHeight % height;
542 if( hRemain >0 ) numDIB++;
543 }
544
545 // set bitmap parameters
546 wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") );
547 SetWidth( width );
548 SetHeight( bmpHeight );
549 if (depth == -1) depth = wxDisplayDepth();
550 SetDepth( depth );
551
552 #if wxUSE_PALETTE
553 // Copy the palette from the source image
554 SetPalette(image.GetPalette());
555 #endif // wxUSE_PALETTE
556
557 // create a DIB header
558 int headersize = sizeof(BITMAPINFOHEADER);
559 BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
560 wxCHECK_MSG( lpDIBh, FALSE, wxT("could not allocate memory for DIB header") );
561 // Fill in the DIB header
562 lpDIBh->bmiHeader.biSize = headersize;
563 lpDIBh->bmiHeader.biWidth = (DWORD)width;
564 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
565 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
566 // the general formula for biSizeImage:
567 // ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
568 lpDIBh->bmiHeader.biPlanes = 1;
569 lpDIBh->bmiHeader.biBitCount = 24;
570 lpDIBh->bmiHeader.biCompression = BI_RGB;
571 lpDIBh->bmiHeader.biClrUsed = 0;
572 // These seem not really needed for our purpose here.
573 lpDIBh->bmiHeader.biClrImportant = 0;
574 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
575 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
576 // memory for DIB data
577 unsigned char *lpBits;
578 lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
579 if( !lpBits )
580 {
581 wxFAIL_MSG( wxT("could not allocate memory for DIB") );
582 free( lpDIBh );
583 return FALSE;
584 }
585
586 // create and set the device-dependent bitmap
587 HDC hdc = ::GetDC(NULL);
588 HDC memdc = ::CreateCompatibleDC( hdc );
589 HBITMAP hbitmap;
590 hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
591 ::SelectObject( memdc, hbitmap);
592
593 #if wxUSE_PALETTE
594 HPALETTE hOldPalette = 0;
595 if (image.GetPalette().Ok())
596 {
597 hOldPalette = ::SelectPalette(memdc, (HPALETTE) image.GetPalette().GetHPALETTE(), FALSE);
598 ::RealizePalette(memdc);
599 }
600 #endif // wxUSE_PALETTE
601
602 // copy image data into DIB data and then into DDB (in a loop)
603 unsigned char *data = image.GetData();
604 int i, j, n;
605 int origin = 0;
606 unsigned char *ptdata = data;
607 unsigned char *ptbits;
608
609 for( n=0; n<numDIB; n++ )
610 {
611 if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
612 {
613 // redefine height and size of the (possibly) last smaller DIB
614 // memory is not reallocated
615 height = hRemain;
616 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
617 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
618 }
619 ptbits = lpBits;
620
621 for( j=0; j<height; j++ )
622 {
623 for( i=0; i<width; i++ )
624 {
625 *(ptbits++) = *(ptdata+2);
626 *(ptbits++) = *(ptdata+1);
627 *(ptbits++) = *(ptdata );
628 ptdata += 3;
629 }
630 for( i=0; i< padding; i++ ) *(ptbits++) = 0;
631 }
632 ::StretchDIBits( memdc, 0, origin, width, height,\
633 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
634 origin += height;
635 // if numDIB = 1, lines below can also be used
636 // hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
637 // The above line is equivalent to the following two lines.
638 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
639 // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
640 // or the following lines
641 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
642 // HDC memdc = ::CreateCompatibleDC( hdc );
643 // ::SelectObject( memdc, hbitmap);
644 // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
645 // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
646 // ::SelectObject( memdc, 0 );
647 // ::DeleteDC( memdc );
648 }
649 SetHBITMAP( (WXHBITMAP) hbitmap );
650
651 #if wxUSE_PALETTE
652 if (hOldPalette)
653 SelectPalette(memdc, hOldPalette, FALSE);
654 #endif // wxUSE_PALETTE
655
656 // similarly, created an mono-bitmap for the possible mask
657 if( image.HasMask() )
658 {
659 hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
660 HGDIOBJ hbmpOld = ::SelectObject( memdc, hbitmap);
661 if( numDIB == 1 ) height = bmpHeight;
662 else height = sizeLimit/bytePerLine;
663 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
664 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
665 origin = 0;
666 unsigned char r = image.GetMaskRed();
667 unsigned char g = image.GetMaskGreen();
668 unsigned char b = image.GetMaskBlue();
669 unsigned char zero = 0, one = 255;
670 ptdata = data;
671 for( n=0; n<numDIB; n++ )
672 {
673 if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
674 {
675 // redefine height and size of the (possibly) last smaller DIB
676 // memory is not reallocated
677 height = hRemain;
678 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
679 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
680 }
681 ptbits = lpBits;
682 for( int j=0; j<height; j++ )
683 {
684 for(i=0; i<width; i++ )
685 {
686 // was causing a code gen bug in cw : if( ( cr !=r) || (cg!=g) || (cb!=b) )
687 unsigned char cr = (*(ptdata++)) ;
688 unsigned char cg = (*(ptdata++)) ;
689 unsigned char cb = (*(ptdata++)) ;
690
691 if( ( cr !=r) || (cg!=g) || (cb!=b) )
692 {
693 *(ptbits++) = one;
694 *(ptbits++) = one;
695 *(ptbits++) = one;
696 }
697 else
698 {
699 *(ptbits++) = zero;
700 *(ptbits++) = zero;
701 *(ptbits++) = zero;
702 }
703 }
704 for( i=0; i< padding; i++ ) *(ptbits++) = zero;
705 }
706 ::StretchDIBits( memdc, 0, origin, width, height,\
707 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
708 origin += height;
709 }
710 // create a wxMask object
711 wxMask *mask = new wxMask();
712 mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
713 SetMask( mask );
714 // It will be deleted when the wxBitmap object is deleted (as of 01/1999)
715 /* The following can also be used but is slow to run
716 wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
717 wxMask *mask = new wxMask( *this, colour );
718 SetMask( mask );
719 */
720
721 ::SelectObject( memdc, hbmpOld );
722 }
723
724 // free allocated resources
725 ::DeleteDC( memdc );
726 ::ReleaseDC(NULL, hdc);
727 free(lpDIBh);
728 free(lpBits);
729
730 #if WXWIN_COMPATIBILITY_2
731 // check the wxBitmap object
732 GetBitmapData()->SetOk();
733 #endif // WXWIN_COMPATIBILITY_2
734
735 return TRUE;
736 #endif
737 }
738
739 wxImage wxBitmap::ConvertToImage() const
740 {
741 #ifdef __WXMICROWIN__
742 // Initial attempt at a simple-minded implementation.
743 // The bitmap will always be created at the screen depth,
744 // so the 'depth' argument is ignored.
745 // TODO: transparency (create a mask image)
746
747 if (!Ok())
748 {
749 wxFAIL_MSG( wxT("bitmap is invalid") );
750 return wxNullImage;
751 }
752
753 wxImage image;
754
755 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
756
757 // create an wxImage object
758 int width = GetWidth();
759 int height = GetHeight();
760 image.Create( width, height );
761 unsigned char *data = image.GetData();
762 if( !data )
763 {
764 wxFAIL_MSG( wxT("could not allocate data for image") );
765 return wxNullImage;
766 }
767
768 HDC hScreenDC = ::GetDC(NULL);
769
770 HDC hMemDC = ::CreateCompatibleDC(hScreenDC);
771 ::ReleaseDC(NULL, hScreenDC);
772
773 HBITMAP hBitmap = (HBITMAP) GetHBITMAP();
774
775 HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap);
776
777 int i, j;
778 for (i = 0; i < GetWidth(); i++)
779 {
780 for (j = 0; j < GetHeight(); j++)
781 {
782 COLORREF color = ::GetPixel(hMemDC, i, j);
783 unsigned char red = GetRValue(color);
784 unsigned char green = GetGValue(color);
785 unsigned char blue = GetBValue(color);
786
787 image.SetRGB(i, j, red, green, blue);
788 }
789 }
790
791 ::SelectObject(hMemDC, hOldBitmap);
792 ::DeleteDC(hMemDC);
793
794 #if wxUSE_PALETTE
795 // Copy the palette from the source image
796 if (GetPalette())
797 image.SetPalette(* GetPalette());
798 #endif // wxUSE_PALETTE
799
800 return image;
801
802 #else // __MICROWIN__
803
804 wxImage image;
805
806 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
807
808 // create an wxImage object
809 int width = GetWidth();
810 int height = GetHeight();
811 image.Create( width, height );
812 unsigned char *data = image.GetData();
813 if( !data )
814 {
815 wxFAIL_MSG( wxT("could not allocate data for image") );
816 return wxNullImage;
817 }
818
819 // calc the number of bytes per scanline and padding in the DIB
820 int bytePerLine = width*3;
821 int sizeDWORD = sizeof( DWORD );
822 int lineBoundary = bytePerLine % sizeDWORD;
823 int padding = 0;
824 if( lineBoundary > 0 )
825 {
826 padding = sizeDWORD - lineBoundary;
827 bytePerLine += padding;
828 }
829
830 // create a DIB header
831 int headersize = sizeof(BITMAPINFOHEADER);
832 BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
833 if( !lpDIBh )
834 {
835 wxFAIL_MSG( wxT("could not allocate data for DIB header") );
836 free( data );
837 return wxNullImage;
838 }
839 // Fill in the DIB header
840 lpDIBh->bmiHeader.biSize = headersize;
841 lpDIBh->bmiHeader.biWidth = width;
842 lpDIBh->bmiHeader.biHeight = -height;
843 lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
844 lpDIBh->bmiHeader.biPlanes = 1;
845 lpDIBh->bmiHeader.biBitCount = 24;
846 lpDIBh->bmiHeader.biCompression = BI_RGB;
847 lpDIBh->bmiHeader.biClrUsed = 0;
848 // These seem not really needed for our purpose here.
849 lpDIBh->bmiHeader.biClrImportant = 0;
850 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
851 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
852 // memory for DIB data
853 unsigned char *lpBits;
854 lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
855 if( !lpBits )
856 {
857 wxFAIL_MSG( wxT("could not allocate data for DIB") );
858 free( data );
859 free( lpDIBh );
860 return wxNullImage;
861 }
862
863 // copy data from the device-dependent bitmap to the DIB
864 HDC hdc = ::GetDC(NULL);
865 HBITMAP hbitmap;
866 hbitmap = (HBITMAP) GetHBITMAP();
867 ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
868
869 // copy DIB data into the wxImage object
870 int i, j;
871 unsigned char *ptdata = data;
872 unsigned char *ptbits = lpBits;
873 for( i=0; i<height; i++ )
874 {
875 for( j=0; j<width; j++ )
876 {
877 *(ptdata++) = *(ptbits+2);
878 *(ptdata++) = *(ptbits+1);
879 *(ptdata++) = *(ptbits );
880 ptbits += 3;
881 }
882 ptbits += padding;
883 }
884
885 // similarly, set data according to the possible mask bitmap
886 if( GetMask() && GetMask()->GetMaskBitmap() )
887 {
888 hbitmap = (HBITMAP) GetMask()->GetMaskBitmap();
889 // memory DC created, color set, data copied, and memory DC deleted
890 HDC memdc = ::CreateCompatibleDC( hdc );
891 ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
892 ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
893 ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
894 ::DeleteDC( memdc );
895 // background color set to RGB(16,16,16) in consistent with wxGTK
896 unsigned char r=16, g=16, b=16;
897 ptdata = data;
898 ptbits = lpBits;
899 for( i=0; i<height; i++ )
900 {
901 for( j=0; j<width; j++ )
902 {
903 if( *ptbits != 0 )
904 ptdata += 3;
905 else
906 {
907 *(ptdata++) = r;
908 *(ptdata++) = g;
909 *(ptdata++) = b;
910 }
911 ptbits += 3;
912 }
913 ptbits += padding;
914 }
915 image.SetMaskColour( r, g, b );
916 image.SetMask( TRUE );
917 }
918 else
919 {
920 image.SetMask( FALSE );
921 }
922 // free allocated resources
923 ::ReleaseDC(NULL, hdc);
924 free(lpDIBh);
925 free(lpBits);
926
927 return image;
928 #endif
929 }
930
931 #endif // wxUSE_IMAGE
932
933 bool wxBitmap::LoadFile(const wxString& filename, long type)
934 {
935 UnRef();
936
937 wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
938
939 if ( handler )
940 {
941 m_refData = new wxBitmapRefData;
942
943 return handler->LoadFile(this, filename, type, -1, -1);
944 }
945 #if wxUSE_IMAGE
946 else
947 {
948 wxImage image;
949 if ( image.LoadFile( filename, type ) && image.Ok() )
950 {
951 *this = image.ConvertToBitmap();
952
953 return TRUE;
954 }
955 }
956 #endif // wxUSE_IMAGE
957
958 return FALSE;
959 }
960
961 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
962 {
963 UnRef();
964
965 wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
966
967 if ( !handler )
968 {
969 wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %d defined."), type);
970
971 return FALSE;
972 }
973
974 m_refData = new wxBitmapRefData;
975
976 return handler->Create(this, data, type, width, height, depth);
977 }
978
979 bool wxBitmap::SaveFile(const wxString& filename,
980 int type,
981 const wxPalette *palette)
982 {
983 wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
984
985 if ( handler )
986 {
987 return handler->SaveFile(this, filename, type, palette);
988 }
989 #if wxUSE_IMAGE
990 else
991 {
992 // FIXME what about palette? shouldn't we use it?
993 wxImage image( *this );
994 if ( image.Ok() )
995 {
996 return image.SaveFile(filename, type);
997 }
998 }
999 #endif // wxUSE_IMAGE
1000
1001 return FALSE;
1002 }
1003
1004 // ----------------------------------------------------------------------------
1005 // sub bitmap extraction
1006 // ----------------------------------------------------------------------------
1007
1008 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
1009 {
1010 #ifndef __WXMICROWIN__
1011 wxCHECK_MSG( Ok() &&
1012 (rect.x >= 0) && (rect.y >= 0) &&
1013 (rect.x+rect.width <= GetWidth()) &&
1014 (rect.y+rect.height <= GetHeight()),
1015 wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
1016
1017 wxBitmap ret( rect.width, rect.height, GetDepth() );
1018 wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
1019
1020 // copy bitmap data
1021 HDC dcSrc = ::CreateCompatibleDC(NULL);
1022 HDC dcDst = ::CreateCompatibleDC(NULL);
1023 SelectObject(dcSrc, (HBITMAP) GetHBITMAP());
1024 SelectObject(dcDst, (HBITMAP) ret.GetHBITMAP());
1025 BitBlt(dcDst, 0, 0, rect.width, rect.height, dcSrc, rect.x, rect.y, SRCCOPY);
1026
1027 // copy mask if there is one
1028 if (GetMask())
1029 {
1030 HBITMAP hbmpMask = ::CreateBitmap(rect.width, rect.height, 1, 1, 0);
1031
1032 SelectObject(dcSrc, (HBITMAP) GetMask()->GetMaskBitmap());
1033 SelectObject(dcDst, (HBITMAP) hbmpMask);
1034 BitBlt(dcDst, 0, 0, rect.width, rect.height, dcSrc, rect.x, rect.y, SRCCOPY);
1035
1036 wxMask *mask = new wxMask((WXHBITMAP) hbmpMask);
1037 ret.SetMask(mask);
1038 }
1039
1040 SelectObject(dcDst, NULL);
1041 SelectObject(dcSrc, NULL);
1042 DeleteDC(dcDst);
1043 DeleteDC(dcSrc);
1044
1045 return ret;
1046 #else
1047 return wxBitmap();
1048 #endif
1049 }
1050
1051 // ----------------------------------------------------------------------------
1052 // wxBitmap accessors
1053 // ----------------------------------------------------------------------------
1054
1055 void wxBitmap::SetQuality(int q)
1056 {
1057 EnsureHasData();
1058
1059 GetBitmapData()->m_quality = q;
1060 }
1061
1062 #if WXWIN_COMPATIBILITY_2
1063 void wxBitmap::SetOk(bool isOk)
1064 {
1065 EnsureHasData();
1066
1067 GetBitmapData()->m_ok = isOk;
1068 }
1069 #endif // WXWIN_COMPATIBILITY_2
1070
1071 #if wxUSE_PALETTE
1072
1073 void wxBitmap::SetPalette(const wxPalette& palette)
1074 {
1075 EnsureHasData();
1076
1077 GetBitmapData()->m_bitmapPalette = palette;
1078 }
1079
1080 #endif // wxUSE_PALETTE
1081
1082 void wxBitmap::SetMask(wxMask *mask)
1083 {
1084 EnsureHasData();
1085
1086 GetBitmapData()->m_bitmapMask = mask;
1087 }
1088
1089 // Creates a bitmap that matches the device context, from
1090 // an arbitray bitmap. At present, the original bitmap must have an
1091 // associated palette. TODO: use a default palette if no palette exists.
1092 // Contributed by Frederic Villeneuve <frederic.villeneuve@natinst.com>
1093 wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
1094 {
1095 #ifdef __WXMICROWIN__
1096 return *this;
1097 #else
1098 wxMemoryDC memDC;
1099 wxBitmap tmpBitmap(GetWidth(), GetHeight(), dc.GetDepth());
1100 HPALETTE hPal = (HPALETTE) NULL;
1101 LPBITMAPINFO lpDib;
1102 void *lpBits = (void*) NULL;
1103
1104 #if wxUSE_PALETTE
1105 if( GetPalette() && GetPalette()->Ok() )
1106 {
1107 tmpBitmap.SetPalette(*GetPalette());
1108 memDC.SelectObject(tmpBitmap);
1109 memDC.SetPalette(*GetPalette());
1110 hPal = (HPALETTE)GetPalette()->GetHPALETTE();
1111 }
1112 else
1113 {
1114 hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE);
1115 wxPalette palette;
1116 palette.SetHPALETTE( (WXHPALETTE)hPal );
1117 tmpBitmap.SetPalette( palette );
1118 memDC.SelectObject(tmpBitmap);
1119 memDC.SetPalette( palette );
1120 }
1121 #else // !wxUSE_PALETTE
1122 hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE);
1123 #endif // wxUSE_PALETTE/!wxUSE_PALETTE
1124
1125 // set the height negative because in a DIB the order of the lines is
1126 // reversed
1127 if ( !wxCreateDIB(GetWidth(), -GetHeight(), GetDepth(), hPal, &lpDib) )
1128 {
1129 return wxNullBitmap;
1130 }
1131
1132 lpBits = malloc(lpDib->bmiHeader.biSizeImage);
1133
1134 ::GetBitmapBits(GetHbitmap(), lpDib->bmiHeader.biSizeImage, lpBits);
1135
1136 ::SetDIBitsToDevice(GetHdcOf(memDC), 0, 0,
1137 GetWidth(), GetHeight(),
1138 0, 0, 0, GetHeight(),
1139 lpBits, lpDib, DIB_RGB_COLORS);
1140
1141 free(lpBits);
1142
1143 wxFreeDIB(lpDib);
1144
1145 return tmpBitmap;
1146 #endif
1147 }
1148
1149 // ----------------------------------------------------------------------------
1150 // wxMask
1151 // ----------------------------------------------------------------------------
1152
1153 wxMask::wxMask()
1154 {
1155 m_maskBitmap = 0;
1156 }
1157
1158 // Construct a mask from a bitmap and a colour indicating
1159 // the transparent area
1160 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
1161 {
1162 m_maskBitmap = 0;
1163 Create(bitmap, colour);
1164 }
1165
1166 // Construct a mask from a bitmap and a palette index indicating
1167 // the transparent area
1168 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
1169 {
1170 m_maskBitmap = 0;
1171 Create(bitmap, paletteIndex);
1172 }
1173
1174 // Construct a mask from a mono bitmap (copies the bitmap).
1175 wxMask::wxMask(const wxBitmap& bitmap)
1176 {
1177 m_maskBitmap = 0;
1178 Create(bitmap);
1179 }
1180
1181 wxMask::~wxMask()
1182 {
1183 if ( m_maskBitmap )
1184 ::DeleteObject((HBITMAP) m_maskBitmap);
1185 }
1186
1187 // Create a mask from a mono bitmap (copies the bitmap).
1188 bool wxMask::Create(const wxBitmap& bitmap)
1189 {
1190 #ifndef __WXMICROWIN__
1191 wxCHECK_MSG( bitmap.Ok() && bitmap.GetDepth() == 1, FALSE,
1192 _T("can't create mask from invalid or not monochrome bitmap") );
1193
1194 if ( m_maskBitmap )
1195 {
1196 ::DeleteObject((HBITMAP) m_maskBitmap);
1197 m_maskBitmap = 0;
1198 }
1199
1200 m_maskBitmap = (WXHBITMAP) CreateBitmap(
1201 bitmap.GetWidth(),
1202 bitmap.GetHeight(),
1203 1, 1, 0
1204 );
1205 HDC srcDC = CreateCompatibleDC(0);
1206 SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP());
1207 HDC destDC = CreateCompatibleDC(0);
1208 SelectObject(destDC, (HBITMAP) m_maskBitmap);
1209 BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY);
1210 SelectObject(srcDC, 0);
1211 DeleteDC(srcDC);
1212 SelectObject(destDC, 0);
1213 DeleteDC(destDC);
1214 return TRUE;
1215 #else
1216 return FALSE;
1217 #endif
1218 }
1219
1220 // Create a mask from a bitmap and a palette index indicating
1221 // the transparent area
1222 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
1223 {
1224 if ( m_maskBitmap )
1225 {
1226 ::DeleteObject((HBITMAP) m_maskBitmap);
1227 m_maskBitmap = 0;
1228 }
1229
1230 #if wxUSE_PALETTE
1231 if (bitmap.Ok() && bitmap.GetPalette()->Ok())
1232 {
1233 unsigned char red, green, blue;
1234 if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue))
1235 {
1236 wxColour transparentColour(red, green, blue);
1237 return Create(bitmap, transparentColour);
1238 }
1239 }
1240 #endif // wxUSE_PALETTE
1241
1242 return FALSE;
1243 }
1244
1245 // Create a mask from a bitmap and a colour indicating
1246 // the transparent area
1247 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
1248 {
1249 #ifndef __WXMICROWIN__
1250 wxCHECK_MSG( bitmap.Ok(), FALSE, _T("invalid bitmap in wxMask::Create") );
1251
1252 if ( m_maskBitmap )
1253 {
1254 ::DeleteObject((HBITMAP) m_maskBitmap);
1255 m_maskBitmap = 0;
1256 }
1257
1258 int width = bitmap.GetWidth(),
1259 height = bitmap.GetHeight();
1260
1261 // scan the bitmap for the transparent colour and set the corresponding
1262 // pixels in the mask to BLACK and the rest to WHITE
1263 COLORREF maskColour = RGB(colour.Red(), colour.Green(), colour.Blue());
1264 m_maskBitmap = (WXHBITMAP)::CreateBitmap(width, height, 1, 1, 0);
1265
1266 HDC srcDC = ::CreateCompatibleDC(NULL);
1267 HDC destDC = ::CreateCompatibleDC(NULL);
1268 if ( !srcDC || !destDC )
1269 {
1270 wxLogLastError(wxT("CreateCompatibleDC"));
1271 }
1272
1273 bool ok = TRUE;
1274
1275 // SelectObject() will fail
1276 wxASSERT_MSG( !bitmap.GetSelectedInto(),
1277 _T("bitmap can't be selected in another DC") );
1278
1279 HGDIOBJ hbmpSrcOld = ::SelectObject(srcDC, GetHbitmapOf(bitmap));
1280 if ( !hbmpSrcOld )
1281 {
1282 wxLogLastError(wxT("SelectObject"));
1283
1284 ok = FALSE;
1285 }
1286
1287 HGDIOBJ hbmpDstOld = ::SelectObject(destDC, (HBITMAP)m_maskBitmap);
1288 if ( !hbmpDstOld )
1289 {
1290 wxLogLastError(wxT("SelectObject"));
1291
1292 ok = FALSE;
1293 }
1294
1295 if ( ok )
1296 {
1297 // this will create a monochrome bitmap with 0 points for the pixels
1298 // which have the same value as the background colour and 1 for the
1299 // others
1300 ::SetBkColor(srcDC, maskColour);
1301 ::BitBlt(destDC, 0, 0, width, height, srcDC, 0, 0, NOTSRCCOPY);
1302 }
1303
1304 ::SelectObject(srcDC, hbmpSrcOld);
1305 ::DeleteDC(srcDC);
1306 ::SelectObject(destDC, hbmpDstOld);
1307 ::DeleteDC(destDC);
1308
1309 return ok;
1310 #else // __WXMICROWIN__
1311 return FALSE;
1312 #endif // __WXMICROWIN__/!__WXMICROWIN__
1313 }
1314
1315 // ----------------------------------------------------------------------------
1316 // wxBitmapHandler
1317 // ----------------------------------------------------------------------------
1318
1319 bool wxBitmapHandler::Create(wxGDIImage *image,
1320 void *data,
1321 long flags,
1322 int width, int height, int depth)
1323 {
1324 wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
1325
1326 return bitmap ? Create(bitmap, data, flags, width, height, depth) : FALSE;
1327 }
1328
1329 bool wxBitmapHandler::Load(wxGDIImage *image,
1330 const wxString& name,
1331 long flags,
1332 int width, int height)
1333 {
1334 wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
1335
1336 return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE;
1337 }
1338
1339 bool wxBitmapHandler::Save(wxGDIImage *image,
1340 const wxString& name,
1341 int type)
1342 {
1343 wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
1344
1345 return bitmap ? SaveFile(bitmap, name, type) : FALSE;
1346 }
1347
1348 bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
1349 void *WXUNUSED(data),
1350 long WXUNUSED(type),
1351 int WXUNUSED(width),
1352 int WXUNUSED(height),
1353 int WXUNUSED(depth))
1354 {
1355 return FALSE;
1356 }
1357
1358 bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
1359 const wxString& WXUNUSED(name),
1360 long WXUNUSED(type),
1361 int WXUNUSED(desiredWidth),
1362 int WXUNUSED(desiredHeight))
1363 {
1364 return FALSE;
1365 }
1366
1367 bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
1368 const wxString& WXUNUSED(name),
1369 int WXUNUSED(type),
1370 const wxPalette *WXUNUSED(palette))
1371 {
1372 return FALSE;
1373 }
1374
1375 // ----------------------------------------------------------------------------
1376 // DIB functions
1377 // ----------------------------------------------------------------------------
1378
1379 #ifndef __WXMICROWIN__
1380 bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
1381 HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
1382 {
1383 unsigned long i, headerSize;
1384 LPBITMAPINFO lpDIBheader = NULL;
1385 LPPALETTEENTRY lpPe = NULL;
1386
1387
1388 // Allocate space for a DIB header
1389 headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY)));
1390 lpDIBheader = (BITMAPINFO *) malloc(headerSize);
1391 lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER));
1392
1393 GetPaletteEntries(hPal, 0, 256, lpPe);
1394
1395 memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER));
1396
1397 // Fill in the static parts of the DIB header
1398 lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1399 lpDIBheader->bmiHeader.biWidth = xSize;
1400 lpDIBheader->bmiHeader.biHeight = ySize;
1401 lpDIBheader->bmiHeader.biPlanes = 1;
1402
1403 // this value must be 1, 4, 8 or 24 so PixelDepth can only be
1404 lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel);
1405 lpDIBheader->bmiHeader.biCompression = BI_RGB;
1406 lpDIBheader->bmiHeader.biSizeImage = xSize * abs(ySize) * bitsPerPixel >> 3;
1407 lpDIBheader->bmiHeader.biClrUsed = 256;
1408
1409
1410 // Initialize the DIB palette
1411 for (i = 0; i < 256; i++) {
1412 lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags;
1413 lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed;
1414 lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen;
1415 lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue;
1416 }
1417
1418 *lpDIBHeader = lpDIBheader;
1419
1420 return TRUE;
1421 }
1422
1423 void wxFreeDIB(LPBITMAPINFO lpDIBHeader)
1424 {
1425 free(lpDIBHeader);
1426 }
1427 #endif
1428
1429 // ----------------------------------------------------------------------------
1430 // other helper functions
1431 // ----------------------------------------------------------------------------
1432
1433 extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w, int h)
1434 {
1435 #ifndef __WXMICROWIN__
1436 wxCHECK_MSG( hbmpMask, 0, _T("invalid bitmap in wxInvertMask") );
1437
1438 // get width/height from the bitmap if not given
1439 if ( !w || !h )
1440 {
1441 BITMAP bm;
1442 ::GetObject(hbmpMask, sizeof(BITMAP), (LPVOID)&bm);
1443 w = bm.bmWidth;
1444 h = bm.bmHeight;
1445 }
1446
1447 HDC hdcSrc = ::CreateCompatibleDC(NULL);
1448 HDC hdcDst = ::CreateCompatibleDC(NULL);
1449 if ( !hdcSrc || !hdcDst )
1450 {
1451 wxLogLastError(wxT("CreateCompatibleDC"));
1452 }
1453
1454 HBITMAP hbmpInvMask = ::CreateBitmap(w, h, 1, 1, 0);
1455 if ( !hbmpInvMask )
1456 {
1457 wxLogLastError(wxT("CreateBitmap"));
1458 }
1459
1460 ::SelectObject(hdcSrc, hbmpMask);
1461 ::SelectObject(hdcDst, hbmpInvMask);
1462 if ( !::BitBlt(hdcDst, 0, 0, w, h,
1463 hdcSrc, 0, 0,
1464 NOTSRCCOPY) )
1465 {
1466 wxLogLastError(wxT("BitBlt"));
1467 }
1468
1469 ::DeleteDC(hdcSrc);
1470 ::DeleteDC(hdcDst);
1471
1472 return hbmpInvMask;
1473 #else
1474 return 0;
1475 #endif
1476 }
wxWidgets (Impactor)