]> git.saurik.com Git - wxWidgets.git/blob - src/os2/bitmap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
No more pixel junk when resizing windows that
[wxWidgets.git] / src / os2 / bitmap.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: bitmap.cpp
3 // Purpose: wxBitmap
4 // Author: David Webster
5 // Modified by:
6 // Created: 08/08/99
7 // RCS-ID: $Id$
8 // Copyright: (c) David Webster
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "bitmap.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifndef WX_PRECOMP
20 #include <stdio.h>
21
22 #include "wx/list.h"
23 #include "wx/utils.h"
24 #include "wx/app.h"
25 #include "wx/palette.h"
26 #include "wx/dcmemory.h"
27 #include "wx/bitmap.h"
28 #include "wx/icon.h"
29 #endif
30
31 #include "wx/os2/private.h"
32 #include "wx/log.h"
33
34 //#include "wx/msw/dib.h"
35 #include "wx/image.h"
36 #include "wx/xpmdecod.h"
37
38 // ----------------------------------------------------------------------------
39 // macros
40 // ----------------------------------------------------------------------------
41
42 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
43 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
44
45 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
46
47 // ============================================================================
48 // implementation
49 // ============================================================================
50
51 // ----------------------------------------------------------------------------
52 // wxBitmapRefData
53 // ----------------------------------------------------------------------------
54
55 wxBitmapRefData::wxBitmapRefData()
56 {
57 m_nQuality = 0;
58 m_pSelectedInto = NULL;
59 m_nNumColors = 0;
60 m_pBitmapMask = NULL;
61 m_hBitmap = (WXHBITMAP) NULL;
62 } // end of wxBitmapRefData::wxBitmapRefData
63
64 void wxBitmapRefData::Free()
65 {
66 wxASSERT_MSG( !m_pSelectedInto,
67 wxT("deleting bitmap still selected into wxMemoryDC") );
68
69 if (m_hBitmap)
70 {
71 if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) )
72 {
73 wxLogLastError("GpiDeleteBitmap(hbitmap)");
74 }
75 }
76
77 delete m_pBitmapMask;
78 m_pBitmapMask = NULL;
79 } // end of wxBitmapRefData::Free
80
81 // ----------------------------------------------------------------------------
82 // wxBitmap creation
83 // ----------------------------------------------------------------------------
84
85 // this function should be called from all wxBitmap ctors
86 void wxBitmap::Init()
87 {
88 // m_refData = NULL; done in the base class ctor
89
90 if (wxTheBitmapList)
91 wxTheBitmapList->AddBitmap(this);
92 } // end of wxBitmap::Init
93
94 bool wxBitmap::CopyFromIconOrCursor(
95 const wxGDIImage& rIcon
96 )
97 {
98 HPOINTER hIcon = (HPOINTER)rIcon.GetHandle();
99 POINTERINFO SIconInfo;
100
101 if (!::WinQueryPointerInfo(hIcon, &SIconInfo))
102 {
103 wxLogLastError(wxT("WinQueryPointerInfo"));
104 return FALSE;
105 }
106 wxBitmapRefData* pRefData = new wxBitmapRefData;
107
108 m_refData = pRefData;
109
110 int nWidth = rIcon.GetWidth();
111 int nHeight = rIcon.GetHeight();
112
113 pRefData->m_nWidth = nWidth;
114 pRefData->m_nHeight = nHeight;
115 pRefData->m_nDepth = wxDisplayDepth();
116
117 pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
118
119 //
120 // No mask in the Info struct in OS/2
121 //
122 return(TRUE);
123 } // end of wxBitmap::CopyFromIconOrCursor
124
125 bool wxBitmap::CopyFromCursor(
126 const wxCursor& rCursor
127 )
128 {
129 UnRef();
130
131 if (!rCursor.Ok())
132 return(FALSE);
133 return(CopyFromIconOrCursor(rCursor));
134 } // end of wxBitmap::CopyFromCursor
135
136 bool wxBitmap::CopyFromIcon(
137 const wxIcon& rIcon
138 )
139 {
140 UnRef();
141
142 if (!rIcon.Ok())
143 return(FALSE);
144
145 return CopyFromIconOrCursor(rIcon);
146 } // end of wxBitmap::CopyFromIcon
147
148 wxBitmap::~wxBitmap()
149 {
150 if (wxTheBitmapList)
151 wxTheBitmapList->DeleteObject(this);
152 } // end of wxBitmap::~wxBitmap
153
154 wxBitmap::wxBitmap(
155 const char zBits[]
156 , int nTheWidth
157 , int nTheHeight
158 , int nNoBits
159 )
160 {
161 Init();
162
163 wxBitmapRefData* pRefData = new wxBitmapRefData;
164 BITMAPINFOHEADER2 vHeader;
165 BITMAPINFO2 vInfo;
166 HDC hDc;
167 HPS hPs;
168 DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
169 SIZEL vSize = {0, 0};
170
171 wxASSERT(vHabmain != NULL);
172
173 hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
174
175 vHeader.cbFix = sizeof(vHeader);
176 vHeader.cx = (USHORT)nTheWidth;
177 vHeader.cy = (USHORT)nTheHeight;
178 vHeader.cPlanes = 1L;
179 vHeader.cBitCount = nNoBits;
180 vHeader.ulCompression = BCA_UNCOMP;
181 vHeader.cxResolution = 0;
182 vHeader.cyResolution = 0;
183 vHeader.cclrUsed = 0;
184 vHeader.cclrImportant = 0;
185 vHeader.usUnits = BRU_METRIC;
186 vHeader.usRecording = BRA_BOTTOMUP;
187 vHeader.usRendering = BRH_NOTHALFTONED;
188 vHeader.cSize1 = 0;
189 vHeader.cSize2 = 0;
190 vHeader.ulColorEncoding = 0;
191 vHeader.ulIdentifier = 0;
192
193 hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
194 if (hPs == 0)
195 {
196 wxLogLastError("GpiCreatePS Failure");
197 }
198
199 m_refData = pRefData;
200
201 pRefData->m_nWidth = nTheWidth;
202 pRefData->m_nHeight = nTheHeight;
203 pRefData->m_nDepth = nNoBits;
204 pRefData->m_nNumColors = 0;
205 pRefData->m_pSelectedInto = NULL;
206
207 HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
208 if (!hBmp)
209 {
210 wxLogLastError("CreateBitmap");
211 }
212 SetHBITMAP((WXHBITMAP)hBmp);
213 } // end of wxBitmap::wxBitmap
214
215 wxBitmap::wxBitmap(
216 int nW
217 , int nH
218 , int nD
219 )
220 {
221 Init();
222
223 (void)Create( nW
224 ,nH
225 ,nD
226 );
227 } // end of wxBitmap::wxBitmap
228
229 wxBitmap::wxBitmap(
230 void* pData
231 , long lType
232 , int nWidth
233 , int nHeight
234 , int nDepth
235 )
236 {
237 Init();
238
239 (void)Create( pData
240 ,lType
241 ,nWidth
242 ,nHeight
243 ,nDepth
244 );
245 } // end of wxBitmap::wxBitmap
246
247 wxBitmap::wxBitmap(
248 const wxString& rFilename
249 , long lType
250 )
251 {
252 Init();
253
254 LoadFile( rFilename
255 ,(int)lType
256 );
257 } // end of wxBitmap::wxBitmap
258
259 bool wxBitmap::Create(
260 int nW
261 , int nH
262 , int nD
263 )
264 {
265 HBITMAP hBmp;
266 BITMAPINFOHEADER2 vHeader;
267
268 wxASSERT(vHabmain != NULL);
269 UnRef();
270 m_refData = new wxBitmapRefData;
271 GetBitmapData()->m_nWidth = nW;
272 GetBitmapData()->m_nHeight = nH;
273 GetBitmapData()->m_nDepth = nD;
274
275 if (nD > 0)
276 {
277 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
278 SIZEL vSize = {0, 0};
279 HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
280 HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
281
282 memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
283 vHeader.cbFix = sizeof(BITMAPINFOHEADER2);
284 vHeader.cx = nW;
285 vHeader.cy = nH;
286 vHeader.cPlanes = 1;
287 vHeader.cBitCount = nD;
288
289 hBmp = ::GpiCreateBitmap( hPS
290 ,&vHeader
291 ,0L
292 ,NULL
293 ,NULL
294 );
295 ::GpiDestroyPS(hPS);
296 ::DevCloseDC(hDC);
297 }
298 else
299 {
300 HPS hPSScreen;
301 HDC hDCScreen;
302 LONG lBitCount;
303
304 hPSScreen = ::WinGetScreenPS(HWND_DESKTOP);
305 hDCScreen = ::GpiQueryDevice(hPSScreen);
306 ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
307
308 memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
309 vHeader.cbFix = sizeof(BITMAPINFOHEADER2);
310 vHeader.cx = nW;
311 vHeader.cy = nH;
312 vHeader.cPlanes = 1;
313 vHeader.cBitCount = lBitCount;
314
315 hBmp = ::GpiCreateBitmap( hPSScreen
316 ,&vHeader
317 ,0L
318 ,NULL
319 ,NULL
320 );
321
322 GetBitmapData()->m_nDepth = wxDisplayDepth();
323 ::WinReleasePS(hPSScreen);
324 }
325 SetHBITMAP((WXHBITMAP)hBmp);
326
327 #if WXWIN_COMPATIBILITY_2
328 GetBitmapData()->m_bOk = hBmp != 0;
329 #endif // WXWIN_COMPATIBILITY_2
330
331 return Ok();
332 } // end of wxBitmap::Create
333
334 bool wxBitmap::CreateFromXpm(
335 const char** ppData
336 )
337 {
338 #if wxUSE_IMAGE && wxUSE_XPM
339 Init();
340
341 wxCHECK_MSG(ppData != NULL, FALSE, wxT("invalid bitmap data"))
342
343 wxXPMDecoder vDecoder;
344 wxImage vImg = vDecoder.ReadData(ppData);
345
346 wxCHECK_MSG(vImg.Ok(), FALSE, wxT("invalid bitmap data"))
347
348 *this = wxBitmap(vImg);
349 return TRUE;
350 #else
351 return FALSE;
352 #endif
353 } // end of wxBitmap::CreateFromXpm
354
355 bool wxBitmap::LoadFile(
356 const wxString& rFilename
357 , long lType
358 )
359 {
360 HPS hPs = NULLHANDLE;
361
362 UnRef();
363
364 wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
365 ,wxBitmapHandler
366 );
367
368 if (pHandler)
369 {
370 m_refData = new wxBitmapRefData;
371
372 return(pHandler->LoadFile( this
373 ,rFilename
374 ,hPs
375 ,lType
376 , -1
377 , -1
378 ));
379 }
380 else
381 {
382 wxImage vImage;
383
384 if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() )
385 return(FALSE);
386
387 *this = vImage.ConvertToBitmap();
388
389 return(TRUE);
390 }
391 } // end of wxBitmap::LoadFile
392
393 bool wxBitmap::Create(
394 void* pData
395 , long lType
396 , int nWidth
397 , int nHeight
398 , int nDepth
399 )
400 {
401 UnRef();
402
403 wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
404 ,wxBitmapHandler
405 );
406
407 if (!pHandler)
408 {
409 wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
410 "type %d defined."), lType);
411
412 return(FALSE);
413 }
414
415 m_refData = new wxBitmapRefData;
416
417 return(pHandler->Create( this
418 ,pData
419 ,lType
420 ,nWidth
421 ,nHeight
422 ,nDepth
423 ));
424 } // end of wxBitmap::Create
425
426 bool wxBitmap::SaveFile(
427 const wxString& rFilename
428 , int lType
429 , const wxPalette* pPalette
430 )
431 {
432 wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
433 ,wxBitmapHandler
434 );
435
436 if (pHandler)
437 {
438 return pHandler->SaveFile( this
439 ,rFilename
440 ,lType
441 ,pPalette
442 );
443 }
444 else
445 {
446 // FIXME what about palette? shouldn't we use it?
447 wxImage vImage(*this);
448
449 if (!vImage.Ok())
450 return(FALSE);
451
452 return(vImage.SaveFile( rFilename
453 ,lType
454 ));
455 }
456 } // end of wxBitmap::SaveFile
457
458
459 // ----------------------------------------------------------------------------
460 // wxImage-wxBitmap convertion
461 // ----------------------------------------------------------------------------
462
463 bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
464 {
465 wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
466
467 // TODO:
468 /*
469 int sizeLimit = 1024*768*3;
470
471 // width and height of the device-dependent bitmap
472 int width = GetWidth();
473 int bmpHeight = GetHeight();
474
475 // calc the number of bytes per scanline and padding
476 int bytePerLine = width*3;
477 int sizeDWORD = sizeof( DWORD );
478 int lineBoundary = bytePerLine % sizeDWORD;
479 int padding = 0;
480 if( lineBoundary > 0 )
481 {
482 padding = sizeDWORD - lineBoundary;
483 bytePerLine += padding;
484 }
485 // calc the number of DIBs and heights of DIBs
486 int numDIB = 1;
487 int hRemain = 0;
488 int height = sizeLimit/bytePerLine;
489 if( height >= bmpHeight )
490 height = bmpHeight;
491 else
492 {
493 numDIB = bmpHeight / height;
494 hRemain = bmpHeight % height;
495 if( hRemain >0 ) numDIB++;
496 }
497
498 // set bitmap parameters
499 wxBitmap bitmap;
500 wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
501 bitmap.SetWidth( width );
502 bitmap.SetHeight( bmpHeight );
503 bitmap.SetDepth( wxDisplayDepth() );
504
505 // create a DIB header
506 int headersize = sizeof(BITMAPINFOHEADER);
507 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
508 wxCHECK_MSG( lpDIBh, bitmap, wxT("could not allocate memory for DIB header") );
509 // Fill in the DIB header
510 lpDIBh->bmiHeader.biSize = headersize;
511 lpDIBh->bmiHeader.biWidth = (DWORD)width;
512 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
513 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
514 // the general formula for biSizeImage:
515 // ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
516 lpDIBh->bmiHeader.biPlanes = 1;
517 lpDIBh->bmiHeader.biBitCount = 24;
518 lpDIBh->bmiHeader.biCompression = BI_RGB;
519 lpDIBh->bmiHeader.biClrUsed = 0;
520 // These seem not really needed for our purpose here.
521 lpDIBh->bmiHeader.biClrImportant = 0;
522 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
523 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
524 // memory for DIB data
525 unsigned char *lpBits;
526 lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
527 if( !lpBits )
528 {
529 wxFAIL_MSG( wxT("could not allocate memory for DIB") );
530 free( lpDIBh );
531 return bitmap;
532 }
533
534 // create and set the device-dependent bitmap
535 HDC hdc = ::GetDC(NULL);
536 HDC memdc = ::CreateCompatibleDC( hdc );
537 HBITMAP hbitmap;
538 hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
539 ::SelectObject( memdc, hbitmap);
540
541 // copy image data into DIB data and then into DDB (in a loop)
542 unsigned char *data = GetData();
543 int i, j, n;
544 int origin = 0;
545 unsigned char *ptdata = data;
546 unsigned char *ptbits;
547
548 for( n=0; n<numDIB; n++ )
549 {
550 if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
551 {
552 // redefine height and size of the (possibly) last smaller DIB
553 // memory is not reallocated
554 height = hRemain;
555 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
556 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
557 }
558 ptbits = lpBits;
559
560 for( j=0; j<height; j++ )
561 {
562 for( i=0; i<width; i++ )
563 {
564 *(ptbits++) = *(ptdata+2);
565 *(ptbits++) = *(ptdata+1);
566 *(ptbits++) = *(ptdata );
567 ptdata += 3;
568 }
569 for( i=0; i< padding; i++ ) *(ptbits++) = 0;
570 }
571 ::StretchDIBits( memdc, 0, origin, width, height,\
572 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
573 origin += height;
574 // if numDIB = 1, lines below can also be used
575 // hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
576 // The above line is equivalent to the following two lines.
577 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
578 // ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
579 // or the following lines
580 // hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
581 // HDC memdc = ::CreateCompatibleDC( hdc );
582 // ::SelectObject( memdc, hbitmap);
583 // ::SetDIBitsToDevice( memdc, 0, 0, width, height,
584 // 0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
585 // ::SelectObject( memdc, 0 );
586 // ::DeleteDC( memdc );
587 }
588 bitmap.SetHBITMAP( (WXHBITMAP) hbitmap );
589
590 // similarly, created an mono-bitmap for the possible mask
591 if( HasMask() )
592 {
593 hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
594 ::SelectObject( memdc, hbitmap);
595 if( numDIB == 1 ) height = bmpHeight;
596 else height = sizeLimit/bytePerLine;
597 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
598 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
599 origin = 0;
600 unsigned char r = GetMaskRed();
601 unsigned char g = GetMaskGreen();
602 unsigned char b = GetMaskBlue();
603 unsigned char zero = 0, one = 255;
604 ptdata = data;
605 for( n=0; n<numDIB; n++ )
606 {
607 if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
608 {
609 // redefine height and size of the (possibly) last smaller DIB
610 // memory is not reallocated
611 height = hRemain;
612 lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
613 lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
614 }
615 ptbits = lpBits;
616 for( int j=0; j<height; j++ )
617 {
618 for(i=0; i<width; i++ )
619 {
620 if( (*(ptdata++)!=r) | (*(ptdata++)!=g) | (*(ptdata++)!=b) )
621 {
622 *(ptbits++) = one;
623 *(ptbits++) = one;
624 *(ptbits++) = one;
625 }
626 else
627 {
628 *(ptbits++) = zero;
629 *(ptbits++) = zero;
630 *(ptbits++) = zero;
631 }
632 }
633 for( i=0; i< padding; i++ ) *(ptbits++) = zero;
634 }
635 ::StretchDIBits( memdc, 0, origin, width, height,\
636 0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
637 origin += height;
638 }
639 // create a wxMask object
640 wxMask *mask = new wxMask();
641 mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
642 bitmap.SetMask( mask );
643 }
644
645 // free allocated resources
646 ::SelectObject( memdc, 0 );
647 ::DeleteDC( memdc );
648 ::ReleaseDC(NULL, hdc);
649 free(lpDIBh);
650 free(lpBits);
651
652 // check the wxBitmap object
653 if( bitmap.GetHBITMAP() )
654 bitmap.SetOk( TRUE );
655 else
656 bitmap.SetOk( FALSE );
657 */
658
659 return TRUE;
660 }
661
662 wxImage wxBitmap::ConvertToImage() const
663 {
664 wxImage image;
665
666 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
667
668 // create an wxImage object
669 int width = GetWidth();
670 int height = GetHeight();
671 image.Create( width, height );
672 unsigned char *data = image.GetData();
673 if( !data )
674 {
675 wxFAIL_MSG( wxT("could not allocate data for image") );
676 return wxNullImage;
677 }
678
679 // calc the number of bytes per scanline and padding in the DIB
680 int bytePerLine = width*3;
681 int sizeDWORD = sizeof( DWORD );
682 int lineBoundary = bytePerLine % sizeDWORD;
683 int padding = 0;
684 if( lineBoundary > 0 )
685 {
686 padding = sizeDWORD - lineBoundary;
687 bytePerLine += padding;
688 }
689 // TODO:
690 /*
691 // create a DIB header
692 int headersize = sizeof(BITMAPINFOHEADER);
693 LPBITMAPINFO lpDIBh = (BITMAPINFO *) malloc( headersize );
694 if( !lpDIBh )
695 {
696 wxFAIL_MSG( wxT("could not allocate data for DIB header") );
697 free( data );
698 return;
699 }
700 // Fill in the DIB header
701 lpDIBh->bmiHeader.biSize = headersize;
702 lpDIBh->bmiHeader.biWidth = width;
703 lpDIBh->bmiHeader.biHeight = -height;
704 lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
705 lpDIBh->bmiHeader.biPlanes = 1;
706 lpDIBh->bmiHeader.biBitCount = 24;
707 lpDIBh->bmiHeader.biCompression = BI_RGB;
708 lpDIBh->bmiHeader.biClrUsed = 0;
709 // These seem not really needed for our purpose here.
710 lpDIBh->bmiHeader.biClrImportant = 0;
711 lpDIBh->bmiHeader.biXPelsPerMeter = 0;
712 lpDIBh->bmiHeader.biYPelsPerMeter = 0;
713 // memory for DIB data
714 unsigned char *lpBits;
715 lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
716 if( !lpBits )
717 {
718 wxFAIL_MSG( wxT("could not allocate data for DIB") );
719 free( data );
720 free( lpDIBh );
721 return;
722 }
723
724 // copy data from the device-dependent bitmap to the DIB
725 HDC hdc = ::GetDC(NULL);
726 HBITMAP hbitmap;
727 hbitmap = (HBITMAP) bitmap.GetHBITMAP();
728 ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
729
730 // copy DIB data into the wxImage object
731 int i, j;
732 unsigned char *ptdata = data;
733 unsigned char *ptbits = lpBits;
734 for( i=0; i<height; i++ )
735 {
736 for( j=0; j<width; j++ )
737 {
738 *(ptdata++) = *(ptbits+2);
739 *(ptdata++) = *(ptbits+1);
740 *(ptdata++) = *(ptbits );
741 ptbits += 3;
742 }
743 ptbits += padding;
744 }
745
746 // similarly, set data according to the possible mask bitmap
747 if( bitmap.GetMask() && bitmap.GetMask()->GetMaskBitmap() )
748 {
749 hbitmap = (HBITMAP) bitmap.GetMask()->GetMaskBitmap();
750 // memory DC created, color set, data copied, and memory DC deleted
751 HDC memdc = ::CreateCompatibleDC( hdc );
752 ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
753 ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
754 ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
755 ::DeleteDC( memdc );
756 // background color set to RGB(16,16,16) in consistent with wxGTK
757 unsigned char r=16, g=16, b=16;
758 ptdata = data;
759 ptbits = lpBits;
760 for( i=0; i<height; i++ )
761 {
762 for( j=0; j<width; j++ )
763 {
764 if( *ptbits != 0 )
765 ptdata += 3;
766 else
767 {
768 *(ptdata++) = r;
769 *(ptdata++) = g;
770 *(ptdata++) = b;
771 }
772 ptbits += 3;
773 }
774 ptbits += padding;
775 }
776 SetMaskColour( r, g, b );
777 SetMask( TRUE );
778 }
779 else
780 {
781 SetMask( FALSE );
782 }
783 // free allocated resources
784 ::ReleaseDC(NULL, hdc);
785 free(lpDIBh);
786 free(lpBits);
787 */
788
789 return image;
790 }
791
792
793 // ----------------------------------------------------------------------------
794 // sub bitmap extraction
795 // ----------------------------------------------------------------------------
796
797 wxBitmap wxBitmap::GetSubBitmap(
798 const wxRect& rRect
799 ) const
800 {
801 wxCHECK_MSG( Ok() &&
802 (rRect.x >= 0) && (rRect.y >= 0) &&
803 (rRect.x + rRect.width <= GetWidth()) &&
804 (rRect.y + rRect.height <= GetHeight()),
805 wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
806
807 wxBitmap vRet( rRect.width
808 ,rRect.height
809 ,GetDepth()
810 );
811 wxASSERT_MSG( vRet.Ok(), wxT("GetSubBitmap error") );
812
813
814 //
815 // Copy bitmap data
816 //
817 SIZEL vSize = {0, 0};
818 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
819 HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
820 HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
821 HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
822 HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
823 POINTL vPoint[4] = { rRect.x, rRect.y,
824 rRect.x + rRect.width, rRect.y + rRect.height,
825 0, 0, GetWidth(), GetHeight()
826 };
827
828 ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
829 ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
830 ::GpiBitBlt( hPSDst
831 ,hPSSrc
832 ,4L
833 ,vPoint
834 ,ROP_SRCCOPY
835 ,BBO_IGNORE
836 );
837
838 //
839 // Copy mask if there is one
840 //
841 if (GetMask())
842 {
843 BITMAPINFOHEADER2 vBmih;
844
845 memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
846 vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
847 vBmih.cx = rRect.width;
848 vBmih.cy = rRect.height;
849 vBmih.cPlanes = 1;
850 vBmih.cBitCount = 1;
851
852 HBITMAP hBmpMask = ::GpiCreateBitmap( hPSDst
853 ,&vBmih
854 ,0L
855 ,NULL
856 ,NULL
857 );
858
859 ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
860 ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
861
862 ::GpiSetBitmap(hPSSrc, (HBITMAP) GetMask()->GetMaskBitmap());
863 ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpMask);
864 ::GpiBitBlt( hPSDst
865 ,hPSSrc
866 ,4L
867 ,vPoint
868 ,ROP_SRCCOPY
869 ,BBO_IGNORE
870 );
871
872 wxMask* pMask = new wxMask((WXHBITMAP)hBmpMask);
873 vRet.SetMask(pMask);
874 }
875
876 ::GpiSetBitmap(hPSSrc, NULL);
877 ::GpiSetBitmap(hPSDst, NULL);
878 ::GpiDestroyPS(hPSSrc);
879 ::GpiDestroyPS(hPSDst);
880 ::DevCloseDC(hDCSrc);
881 ::DevCloseDC(hDCDst);
882 return vRet;
883 } // end of wxBitmap::GetSubBitmap
884
885 // ----------------------------------------------------------------------------
886 // wxBitmap accessors
887 // ----------------------------------------------------------------------------
888
889 void wxBitmap::SetQuality(
890 int nQ
891 )
892 {
893 EnsureHasData();
894
895 GetBitmapData()->m_nQuality = nQ;
896 } // end of wxBitmap::SetQuality
897
898 #if WXWIN_COMPATIBILITY_2
899 void wxBitmap::SetOk(
900 bool bOk
901 )
902 {
903 EnsureHasData();
904
905 GetBitmapData()->m_bOk = bOk;
906 } // end of wxBitmap::SetOk
907 #endif // WXWIN_COMPATIBILITY_2
908
909 void wxBitmap::SetPalette(
910 const wxPalette& rPalette
911 )
912 {
913 EnsureHasData();
914
915 GetBitmapData()->m_vBitmapPalette = rPalette;
916 } // end of wxBitmap::SetPalette
917
918 void wxBitmap::SetMask(
919 wxMask* pMask
920 )
921 {
922 EnsureHasData();
923
924 GetBitmapData()->m_pBitmapMask = pMask;
925 } // end of wxBitmap::SetMask
926
927 //
928 // Will try something for OS/2 but not really sure how close
929 // to the msw intent this is.
930 //
931 wxBitmap wxBitmap::GetBitmapForDC(
932 wxDC& rDc
933 ) const
934 {
935 wxMemoryDC vMemDC;
936 wxBitmap vTmpBitmap( this->GetWidth()
937 ,this->GetHeight()
938 ,rDc.GetDepth()
939 );
940 WXHBITMAP vOldBitmap;
941 HPS hMemoryPS;
942 HPS hPs;
943 POINTL vPoint[4];
944 SIZEL vSize = {0,0};
945
946 hMemoryPS = ::GpiCreatePS(vHabmain, (HDC)vMemDC.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
947 hPs = ::GpiCreatePS(vHabmain, (HDC)rDc.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
948
949 // TODO: Set the points
950
951 vOldBitmap = (WXHBITMAP)::GpiSetBitmap(hPs, (HBITMAP)vTmpBitmap.GetHBITMAP());
952 ::GpiBitBlt(hPs, hMemoryPS, 4L, vPoint, ROP_SRCCOPY, BBO_IGNORE);
953
954 return(vTmpBitmap);
955 } // end of wxBitmap::GetBitmapForDC
956
957 // ----------------------------------------------------------------------------
958 // wxMask
959 // ----------------------------------------------------------------------------
960
961 wxMask::wxMask()
962 {
963 m_hMaskBitmap = 0;
964 } // end of wxMask::wxMask
965
966 // Construct a mask from a bitmap and a colour indicating
967 // the transparent area
968 wxMask::wxMask(
969 const wxBitmap& rBitmap
970 , const wxColour& rColour
971 )
972 {
973 m_hMaskBitmap = 0;
974 Create( rBitmap
975 ,rColour
976 );
977 } // end of wxMask::wxMask
978
979 // Construct a mask from a bitmap and a palette index indicating
980 // the transparent area
981 wxMask::wxMask(
982 const wxBitmap& rBitmap
983 , int nPaletteIndex
984 )
985 {
986 m_hMaskBitmap = 0;
987 Create( rBitmap
988 ,nPaletteIndex
989 );
990 } // end of wxMask::wxMask
991
992 // Construct a mask from a mono bitmap (copies the bitmap).
993 wxMask::wxMask(
994 const wxBitmap& rBitmap
995 )
996 {
997 m_hMaskBitmap = 0;
998 Create(rBitmap);
999 } // end of wxMask::wxMask
1000
1001 wxMask::~wxMask()
1002 {
1003 if (m_hMaskBitmap)
1004 ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap);
1005 } // end of wxMask::~wxMask
1006
1007 // Create a mask from a mono bitmap (copies the bitmap).
1008 bool wxMask::Create(
1009 const wxBitmap& rBitmap
1010 )
1011 {
1012 BITMAPINFOHEADER2 vBmih;
1013 SIZEL vSize = {0, 0};
1014 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1015 HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1016 HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1017 HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1018 HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1019 POINTL vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(),
1020 0, 0, rBitmap.GetWidth(), rBitmap.GetHeight()
1021 };
1022
1023 if (m_hMaskBitmap)
1024 {
1025 ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1026 m_hMaskBitmap = 0;
1027 }
1028 if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
1029 {
1030 return(FALSE);
1031 }
1032
1033 memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1034 vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
1035 vBmih.cx = rBitmap.GetWidth();
1036 vBmih.cy = rBitmap.GetHeight();
1037 vBmih.cPlanes = 1;
1038 vBmih.cBitCount = 1;
1039
1040 m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
1041 ,&vBmih
1042 ,0L
1043 ,NULL
1044 ,NULL
1045 );
1046
1047 ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
1048 ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
1049 ::GpiBitBlt( hPSDst
1050 ,hPSSrc
1051 ,4L
1052 ,vPoint
1053 ,ROP_SRCCOPY
1054 ,BBO_IGNORE
1055 );
1056
1057 ::GpiDestroyPS(hPSSrc);
1058 ::GpiDestroyPS(hPSDst);
1059 ::DevCloseDC(hDCSrc);
1060 ::DevCloseDC(hDCDst);
1061 return(TRUE);
1062 } // end of wxMask::Create
1063
1064 // Create a mask from a bitmap and a palette index indicating
1065 // the transparent area
1066 bool wxMask::Create(
1067 const wxBitmap& rBitmap
1068 , int nPaletteIndex
1069 )
1070 {
1071 if (m_hMaskBitmap)
1072 {
1073 ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1074 m_hMaskBitmap = 0;
1075 }
1076 if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())
1077 {
1078 unsigned char cRed;
1079 unsigned char cGreen;
1080 unsigned char cBlue;
1081
1082 if (rBitmap.GetPalette()->GetRGB( nPaletteIndex
1083 ,&cRed
1084 ,&cGreen
1085 ,&cBlue
1086 ))
1087 {
1088 wxColour vTransparentColour( cRed
1089 ,cGreen
1090 ,cBlue
1091 );
1092
1093 return (Create( rBitmap
1094 ,vTransparentColour
1095 ));
1096 }
1097 }
1098 return(FALSE);
1099 } // end of wxMask::Create
1100
1101 // Create a mask from a bitmap and a colour indicating
1102 // the transparent area
1103 bool wxMask::Create(
1104 const wxBitmap& rBitmap
1105 , const wxColour& rColour
1106 )
1107 {
1108 bool bOk = TRUE;
1109 COLORREF vMaskColour = OS2RGB( rColour.Red()
1110 ,rColour.Green()
1111 ,rColour.Blue()
1112 );
1113 BITMAPINFOHEADER2 vBmih;
1114 SIZEL vSize = {0, 0};
1115 DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
1116 HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1117 HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1118 HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1119 HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1120 POINTL vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(),
1121 0, 0, rBitmap.GetWidth(), rBitmap.GetHeight()
1122 };
1123
1124 if (m_hMaskBitmap)
1125 {
1126 ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1127 m_hMaskBitmap = 0;
1128 }
1129 if (!rBitmap.Ok())
1130 {
1131 return(FALSE);
1132 }
1133
1134 //
1135 // Scan the bitmap for the transparent colour and set
1136 // the corresponding pixels in the mask to BLACK and
1137 // the rest to WHITE
1138 //
1139
1140 memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1141 vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
1142 vBmih.cx = rBitmap.GetWidth();
1143 vBmih.cy = rBitmap.GetHeight();
1144 vBmih.cPlanes = 1;
1145 vBmih.cBitCount = 1;
1146
1147 m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
1148 ,&vBmih
1149 ,0L
1150 ,NULL
1151 ,NULL
1152 );
1153
1154 ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
1155 ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
1156
1157 //
1158 // This is not very efficient, but I can't think
1159 // of a better way of doing it
1160 //
1161 for (int w = 0; w < rBitmap.GetWidth(); w++)
1162 {
1163 for (int h = 0; h < rBitmap.GetHeight(); h++)
1164 {
1165 POINTL vPt = {w, h};
1166 COLORREF vCol = (COLORREF)::GpiQueryPel(hPSSrc, &vPt);
1167 if (vCol == (COLORREF)CLR_NOINDEX)
1168 {
1169 //
1170 // Doesn't make sense to continue
1171 //
1172 bOk = FALSE;
1173 break;
1174 }
1175
1176 if (vCol == vMaskColour)
1177 {
1178 ::GpiSetColor(hPSDst, OS2RGB(0, 0, 0));
1179 ::GpiSetPel(hPSDst, &vPt);
1180 }
1181 else
1182 {
1183 ::GpiSetColor(hPSDst, OS2RGB(255, 255, 255));
1184 ::GpiSetPel(hPSDst, &vPt);
1185 }
1186 }
1187 }
1188 ::GpiSetBitmap(hPSSrc, NULL);
1189 ::GpiSetBitmap(hPSDst, NULL);
1190 ::GpiDestroyPS(hPSSrc);
1191 ::GpiDestroyPS(hPSDst);
1192 ::DevCloseDC(hDCSrc);
1193 ::DevCloseDC(hDCDst);
1194 return(TRUE);
1195 } // end of wxMask::Create
1196
1197 // ----------------------------------------------------------------------------
1198 // wxBitmapHandler
1199 // ----------------------------------------------------------------------------
1200
1201 bool wxBitmapHandler::Create(
1202 wxGDIImage* pImage
1203 , void* pData
1204 , long lFlags
1205 , int nWidth
1206 , int nHeight
1207 , int nDepth
1208 )
1209 {
1210 wxBitmap* pBitmap = wxDynamicCast( pImage
1211 ,wxBitmap
1212 );
1213
1214 return(pBitmap ? Create( pBitmap
1215 ,pData
1216 ,nWidth
1217 ,nHeight
1218 ,nDepth
1219 ) : FALSE);
1220 }
1221
1222 bool wxBitmapHandler::Load(
1223 wxGDIImage* pImage
1224 , const wxString& rName
1225 , HPS hPs
1226 , long lFlags
1227 , int nWidth
1228 , int nHeight
1229 )
1230 {
1231 wxBitmap* pBitmap = wxDynamicCast( pImage
1232 ,wxBitmap
1233 );
1234
1235 return(pBitmap ? LoadFile( pBitmap
1236 ,rName
1237 ,hPs
1238 ,lFlags
1239 ,nWidth
1240 ,nHeight
1241 ) : FALSE);
1242 }
1243
1244 bool wxBitmapHandler::Save(
1245 wxGDIImage* pImage
1246 , const wxString& rName
1247 , int lType
1248 )
1249 {
1250 wxBitmap* pBitmap = wxDynamicCast( pImage
1251 ,wxBitmap
1252 );
1253
1254 return(pBitmap ? SaveFile( pBitmap
1255 ,rName
1256 ,lType
1257 ) : FALSE);
1258 }
1259
1260 bool wxBitmapHandler::Create(
1261 wxBitmap* WXUNUSED(pBitmap)
1262 , void* WXUNUSED(pData)
1263 , long WXUNUSED(lType)
1264 , int WXUNUSED(nWidth)
1265 , int WXUNUSED(nHeight)
1266 , int WXUNUSED(nDepth)
1267 )
1268 {
1269 return(FALSE);
1270 }
1271
1272 bool wxBitmapHandler::LoadFile(
1273 wxBitmap* WXUNUSED(pBitmap)
1274 , const wxString& WXUNUSED(rName)
1275 , HPS WXUNUSED(hPs)
1276 , long WXUNUSED(lType)
1277 , int WXUNUSED(nDesiredWidth)
1278 , int WXUNUSED(nDesiredHeight)
1279 )
1280 {
1281 return(FALSE);
1282 }
1283
1284 bool wxBitmapHandler::SaveFile(
1285 wxBitmap* WXUNUSED(pBitmap)
1286 , const wxString& WXUNUSED(rName)
1287 , int WXUNUSED(nType)
1288 , const wxPalette* WXUNUSED(pPalette)
1289 )
1290 {
1291 return(FALSE);
1292 }
1293
1294 // ----------------------------------------------------------------------------
1295 // Utility functions
1296 // ----------------------------------------------------------------------------
1297 HBITMAP wxInvertMask(
1298 HBITMAP hBmpMask
1299 , int nWidth
1300 , int nHeight
1301 )
1302 {
1303 HBITMAP hBmpInvMask = 0;
1304
1305 wxCHECK_MSG( hBmpMask, 0, _T("invalid bitmap in wxInvertMask") );
1306
1307 //
1308 // Get width/height from the bitmap if not given
1309 //
1310 if (!nWidth || !nHeight)
1311 {
1312 BITMAPINFOHEADER2 vBmhdr;
1313
1314 ::GpiQueryBitmapInfoHeader( hBmpMask
1315 ,&vBmhdr
1316 );
1317 nWidth = (int)vBmhdr.cx;
1318 nHeight = (int)vBmhdr.cy;
1319 }
1320
1321 BITMAPINFOHEADER2 vBmih;
1322 SIZEL vSize = {0, 0};
1323 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1324 HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1325 HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1326 HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1327 HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1328 POINTL vPoint[4] = { 0 ,0, nWidth, nHeight,
1329 0, 0, nWidth, nHeight
1330 };
1331
1332 memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1333 vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
1334 vBmih.cx = nWidth;
1335 vBmih.cy = nHeight;
1336 vBmih.cPlanes = 1;
1337 vBmih.cBitCount = 1;
1338
1339 hBmpInvMask = ::GpiCreateBitmap( hPSDst
1340 ,&vBmih
1341 ,0L
1342 ,NULL
1343 ,NULL
1344 );
1345
1346 ::GpiSetBitmap(hPSSrc, (HBITMAP) hBmpMask);
1347 ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpInvMask);
1348
1349 ::GpiBitBlt( hPSDst
1350 ,hPSSrc
1351 ,4L
1352 ,vPoint
1353 ,ROP_SRCINVERT
1354 ,BBO_IGNORE
1355 );
1356
1357 ::GpiDestroyPS(hPSSrc);
1358 ::GpiDestroyPS(hPSDst);
1359 ::DevCloseDC(hDCSrc);
1360 ::DevCloseDC(hDCDst);
1361
1362 return hBmpInvMask;
1363 } // end of WxWinGdi_InvertMask
wxWidgets (Impactor)