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