]> 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
survive delete within Notify
[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 if ( m_pSelectedInto )
67 {
68 wxLogLastError("GpiDeleteBitmap(hbitmap)");
69 }
70 if (m_hBitmap)
71 {
72 if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))
73 {
74 wxLogLastError("GpiDeleteBitmap(hbitmap)");
75 }
76 }
77
78 delete m_pBitmapMask;
79 m_pBitmapMask = NULL;
80 } // end of wxBitmapRefData::Free
81
82 // ----------------------------------------------------------------------------
83 // wxBitmap creation
84 // ----------------------------------------------------------------------------
85
86 // this function should be called from all wxBitmap ctors
87 void wxBitmap::Init()
88 {
89 m_bIsMono = FALSE;
90 //
91 // True for all bitmaps created from bits, wxImages, Xpms
92 //
93 } // end of wxBitmap::Init
94
95 bool wxBitmap::CopyFromIconOrCursor(
96 const wxGDIImage& rIcon
97 )
98 {
99 HPOINTER hIcon = (HPOINTER)rIcon.GetHandle();
100 POINTERINFO SIconInfo;
101
102 if (!::WinQueryPointerInfo(hIcon, &SIconInfo))
103 {
104 wxLogLastError(wxT("WinQueryPointerInfo"));
105 return FALSE;
106 }
107 wxBitmapRefData* pRefData = new wxBitmapRefData;
108
109 m_refData = pRefData;
110
111 int nWidth = rIcon.GetWidth();
112 int nHeight = rIcon.GetHeight();
113
114 pRefData->m_nWidth = nWidth;
115 pRefData->m_nHeight = nHeight;
116 pRefData->m_nDepth = wxDisplayDepth();
117
118 pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
119
120 wxMask* pMask = new wxMask(SIconInfo.hbmPointer);
121
122 pMask->SetMaskBitmap(GetHBITMAP());
123 SetMask(pMask);
124
125 return(TRUE);
126 } // end of wxBitmap::CopyFromIconOrCursor
127
128 bool wxBitmap::CopyFromCursor(
129 const wxCursor& rCursor
130 )
131 {
132 UnRef();
133
134 if (!rCursor.Ok())
135 return(FALSE);
136 return(CopyFromIconOrCursor(rCursor));
137 } // end of wxBitmap::CopyFromCursor
138
139 bool wxBitmap::CopyFromIcon(
140 const wxIcon& rIcon
141 )
142 {
143 UnRef();
144
145 if (!rIcon.Ok())
146 return(FALSE);
147
148 return CopyFromIconOrCursor(rIcon);
149 } // end of wxBitmap::CopyFromIcon
150
151 wxBitmap::~wxBitmap()
152 {
153 } // end of wxBitmap::~wxBitmap
154
155 wxBitmap::wxBitmap(
156 const char zBits[]
157 , int nWidth
158 , int nHeight
159 , int nDepth
160 )
161 {
162 Init();
163
164 wxBitmapRefData* pRefData = new wxBitmapRefData;
165 BITMAPINFOHEADER2 vHeader;
166 BITMAPINFO2 vInfo;
167 HDC hDc;
168 HPS hPs;
169 DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
170 SIZEL vSize = {0, 0};
171 char* pzData;
172
173 wxASSERT(vHabmain != NULL);
174
175 m_refData = pRefData;
176
177 pRefData->m_nWidth = nWidth;
178 pRefData->m_nHeight = nHeight;
179 pRefData->m_nDepth = nDepth;
180 pRefData->m_nNumColors = 0;
181 pRefData->m_pSelectedInto = NULL;
182
183 hDc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
184 hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
185 if (hPs == 0)
186 {
187 wxLogLastError("GpiCreatePS Failure");
188 }
189
190 if (nDepth == 1)
191 {
192 //
193 // We assume that it is in XBM format which is not quite the same as
194 // the format CreateBitmap() wants because the order of bytes in the
195 // line is inversed!
196 //
197 const size_t nBytesPerLine = (nWidth + 7) / 8;
198 const size_t nPadding = nBytesPerLine % 2;
199 const size_t nLen = nHeight * (nPadding + nBytesPerLine);
200 const char* pzSrc = zBits;
201 int nRows;
202 size_t nCols;
203
204 pzData = (char *)malloc(nLen);
205
206 char* pzDst = pzData;
207
208 for (nRows = 0; nRows < nHeight; nRows++)
209 {
210 for (nCols = 0; nCols < nBytesPerLine; nCols++)
211 {
212 unsigned char ucVal = *pzSrc++;
213 unsigned char ucReversed = 0;
214 int nBits;
215
216 for (nBits = 0; nBits < 8; nBits++)
217 {
218 ucReversed <<= 1;
219 ucReversed |= (ucVal & 0x01);
220 ucVal >>= 1;
221 }
222 *pzDst++ = ucReversed;
223 }
224 if (nPadding)
225 *pzDst++ = 0;
226 }
227 }
228 else
229 {
230 //
231 // Bits should already be in Windows standard format
232 //
233 pzData = (char *)zBits; // const_cast is harmless
234 }
235
236 if (nDepth > 24)
237 nDepth = 24; // MAX supported in PM
238 memset(&vHeader, '\0', 16);
239 vHeader.cbFix = 16;
240 vHeader.cx = (USHORT)nWidth;
241 vHeader.cy = (USHORT)nHeight;
242 vHeader.cPlanes = 1L;
243 vHeader.cBitCount = nDepth;
244 vHeader.usReserved = 0;
245
246 memset(&vInfo, '\0', 16);
247 vInfo.cbFix = 16;
248 vInfo.cx = (USHORT)nWidth;
249 vInfo.cy = (USHORT)nHeight;
250 vInfo.cPlanes = 1L;
251 vInfo.cBitCount = nDepth;
252
253 HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);
254
255 if (!hBmp)
256 {
257 wxLogLastError("CreateBitmap");
258 }
259 ::GpiDestroyPS(hPs);
260 ::DevCloseDC(hDc);
261 SetHBITMAP((WXHBITMAP)hBmp);
262 } // end of wxBitmap::wxBitmap
263
264 wxBitmap::wxBitmap(
265 int nW
266 , int nH
267 , int nD
268 )
269 {
270 Init();
271 (void)Create( nW
272 ,nH
273 ,nD
274 );
275 } // end of wxBitmap::wxBitmap
276
277 wxBitmap::wxBitmap(
278 void* pData
279 , long lType
280 , int nWidth
281 , int nHeight
282 , int nDepth
283 )
284 {
285 Init();
286
287 (void)Create( pData
288 ,lType
289 ,nWidth
290 ,nHeight
291 ,nDepth
292 );
293 } // end of wxBitmap::wxBitmap
294
295 wxBitmap::wxBitmap(
296 const wxString& rFilename
297 , long lType
298 )
299 {
300 Init();
301 LoadFile( rFilename
302 ,(int)lType
303 );
304 } // end of wxBitmap::wxBitmap
305
306 bool wxBitmap::Create(
307 int nW
308 , int nH
309 , int nD
310 )
311 {
312 HBITMAP hBmp;
313 BITMAPINFOHEADER2 vHeader;
314
315 wxASSERT(vHabmain != NULL);
316 UnRef();
317 m_refData = new wxBitmapRefData;
318 GetBitmapData()->m_nWidth = nW;
319 GetBitmapData()->m_nHeight = nH;
320 GetBitmapData()->m_nDepth = nD;
321
322 //
323 // Xpms and bitmaps from other images can also be mono's, but only
324 // mono's need help changing their colors with MemDC changes
325 //
326 if (nD > 0)
327 {
328 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
329 SIZEL vSize = {0, 0};
330 HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
331 HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
332
333 if (nD == 1)
334 m_bIsMono = TRUE;
335 memset(&vHeader, '\0', 16);
336 vHeader.cbFix = 16;
337 vHeader.cx = nW;
338 vHeader.cy = nH;
339 vHeader.cPlanes = 1;
340 vHeader.cBitCount = 24; //nD;
341
342 hBmp = ::GpiCreateBitmap( hPS
343 ,&vHeader
344 ,0L
345 ,NULL
346 ,NULL
347 );
348 ::GpiDestroyPS(hPS);
349 ::DevCloseDC(hDC);
350 }
351 else
352 {
353 HPS hPSScreen;
354 HDC hDCScreen;
355 LONG lBitCount;
356
357 hPSScreen = ::WinGetScreenPS(HWND_DESKTOP);
358 hDCScreen = ::GpiQueryDevice(hPSScreen);
359 ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
360
361 if (lBitCount > 24)
362 lBitCount = 24;
363
364 memset(&vHeader, '\0', 16);
365 vHeader.cbFix = 16;
366 vHeader.cx = nW;
367 vHeader.cy = nH;
368 vHeader.cPlanes = 1;
369 vHeader.cBitCount = lBitCount;
370
371 hBmp = ::GpiCreateBitmap( hPSScreen
372 ,&vHeader
373 ,0L
374 ,NULL
375 ,NULL
376 );
377
378 GetBitmapData()->m_nDepth = wxDisplayDepth();
379 ::WinReleasePS(hPSScreen);
380 }
381 SetHBITMAP((WXHBITMAP)hBmp);
382
383 #if WXWIN_COMPATIBILITY_2
384 GetBitmapData()->m_bOk = hBmp != 0;
385 #endif // WXWIN_COMPATIBILITY_2
386
387 return Ok();
388 } // end of wxBitmap::Create
389
390 bool wxBitmap::CreateFromXpm(
391 const char** ppData
392 )
393 {
394 #if wxUSE_IMAGE && wxUSE_XPM
395 Init();
396
397 wxCHECK_MSG(ppData != NULL, FALSE, wxT("invalid bitmap data"))
398
399 wxXPMDecoder vDecoder;
400 wxImage vImg = vDecoder.ReadData(ppData);
401
402 wxCHECK_MSG(vImg.Ok(), FALSE, wxT("invalid bitmap data"))
403
404 *this = wxBitmap(vImg);
405 return TRUE;
406 #else
407 return FALSE;
408 #endif
409 } // end of wxBitmap::CreateFromXpm
410
411 bool wxBitmap::LoadFile(
412 const wxString& rFilename
413 , long lType
414 )
415 {
416 HPS hPs = NULLHANDLE;
417
418 UnRef();
419
420 wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
421 ,wxBitmapHandler
422 );
423
424 if (pHandler)
425 {
426 m_refData = new wxBitmapRefData;
427
428 return(pHandler->LoadFile( this
429 ,rFilename
430 ,hPs
431 ,lType
432 , -1
433 , -1
434 ));
435 }
436 else
437 {
438 wxImage vImage;
439
440 if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() )
441 return(FALSE);
442
443 *this = wxBitmap(vImage);
444
445 return(TRUE);
446 }
447 } // end of wxBitmap::LoadFile
448
449 bool wxBitmap::Create(
450 void* pData
451 , long lType
452 , int nWidth
453 , int nHeight
454 , int nDepth
455 )
456 {
457 UnRef();
458
459 wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
460 ,wxBitmapHandler
461 );
462
463 if (!pHandler)
464 {
465 wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
466 "type %d defined."), lType);
467
468 return(FALSE);
469 }
470
471 m_refData = new wxBitmapRefData;
472
473 return(pHandler->Create( this
474 ,pData
475 ,lType
476 ,nWidth
477 ,nHeight
478 ,nDepth
479 ));
480 } // end of wxBitmap::Create
481
482 bool wxBitmap::SaveFile(
483 const wxString& rFilename
484 , int lType
485 , const wxPalette* pPalette
486 )
487 {
488 wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
489 ,wxBitmapHandler
490 );
491
492 if (pHandler)
493 {
494 return pHandler->SaveFile( this
495 ,rFilename
496 ,lType
497 ,pPalette
498 );
499 }
500 else
501 {
502 // FIXME what about palette? shouldn't we use it?
503 wxImage vImage = ConvertToImage();
504
505 if (!vImage.Ok())
506 return(FALSE);
507
508 return(vImage.SaveFile( rFilename
509 ,lType
510 ));
511 }
512 } // end of wxBitmap::SaveFile
513
514
515 // ----------------------------------------------------------------------------
516 // wxImage-wxBitmap convertion
517 // ----------------------------------------------------------------------------
518
519 bool wxBitmap::CreateFromImage (
520 const wxImage& rImage
521 , int nDepth
522 )
523 {
524 wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
525 m_refData = new wxBitmapRefData();
526
527 int nSizeLimit = 1024 * 768 * 3;
528 int nWidth = rImage.GetWidth();
529 int nBmpHeight = rImage.GetHeight();
530 int nBytePerLine = nWidth * 3;
531 int nSizeDWORD = sizeof(DWORD);
532 int nLineBoundary = nBytePerLine % nSizeDWORD;
533 int nPadding = 0;
534
535 if (nLineBoundary > 0)
536 {
537 nPadding = nSizeDWORD - nLineBoundary;
538 nBytePerLine += nPadding;
539 }
540
541 //
542 // Calc the number of DIBs and heights of DIBs
543 //
544 int nNumDIB = 1;
545 int nHRemain = 0;
546 int nHeight = nSizeLimit / nBytePerLine;
547
548 if (nHeight >= nBmpHeight)
549 nHeight = nBmpHeight;
550 else
551 {
552 nNumDIB = nBmpHeight / nHeight;
553 nHRemain = nBmpHeight % nHeight;
554 if (nHRemain > 0)
555 nNumDIB++;
556 }
557
558 //
559 // Set bitmap parameters
560 //
561 wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
562 SetWidth(nWidth);
563 SetHeight(nBmpHeight);
564 if (nDepth == 1)
565 m_bIsMono = TRUE;
566 else
567 m_bIsMono = FALSE;
568 if (nDepth == -1)
569 nDepth = wxDisplayDepth();
570 SetDepth(nDepth);
571
572 #if wxUSE_PALETTE
573 //
574 // Copy the palette from the source image
575 //
576 SetPalette(rImage.GetPalette());
577 #endif // wxUSE_PALETTE
578
579 //
580 // Create a DIB header
581 //
582 BITMAPINFOHEADER2 vHeader;
583 BITMAPINFO2 vInfo;
584
585 //
586 // Fill in the DIB header
587 //
588 memset(&vHeader, '\0', 16);
589 vHeader.cbFix = 16;
590 vHeader.cx = (ULONG)nWidth;
591 vHeader.cy = (ULONG)nHeight;
592 vHeader.cPlanes = 1L;
593 vHeader.cBitCount = 24;
594
595 //
596 // Memory for DIB data
597 //
598 unsigned char* pucBits;
599
600 pucBits = (unsigned char *)malloc(nBytePerLine * nHeight);
601 if(!pucBits)
602 {
603 wxFAIL_MSG(wxT("could not allocate memory for DIB"));
604 return FALSE;
605 }
606 memset(pucBits, '\0', (nBytePerLine * nHeight));
607
608 //
609 // Create and set the device-dependent bitmap
610 //
611 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
612 SIZEL vSize = {0, 0};
613 HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
614 HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
615 LONG lScans;
616 HDC hDCScreen = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
617 HPS hPSScreen;
618 HBITMAP hBmp;
619 HBITMAP hBmpOld;
620
621 memset(&vInfo, '\0', 16);
622 vInfo.cbFix = 16;
623 vInfo.cx = (ULONG)nWidth;
624 vInfo.cy = (ULONG)nHeight;
625 vInfo.cPlanes = 1;
626 vInfo.cBitCount = 24; // Set to desired count going in
627
628 hBmp = ::GpiCreateBitmap( hPS
629 ,&vHeader
630 ,0L
631 ,NULL
632 ,NULL
633 );
634 #if wxUSE_PALETTE
635 HPAL hOldPalette = NULLHANDLE;
636 if (rImage.GetPalette().Ok())
637 {
638 hOldPalette = ::GpiSelectPalette(hPS, (HPAL)rImage.GetPalette().GetHPALETTE());
639 }
640 #endif // wxUSE_PALETTE
641
642 //
643 // Copy image data into DIB data and then into DDB (in a loop)
644 //
645 unsigned char* pData = rImage.GetData();
646 int i;
647 int j;
648 int n;
649 int nOrigin = 0;
650 unsigned char* ptdata = pData;
651 unsigned char* ptbits;
652
653 if ((hBmpOld = ::GpiSetBitmap(hPS, hBmp)) == HBM_ERROR)
654 {
655 ERRORID vError;
656 wxString sError;
657
658 vError = ::WinGetLastError(vHabmain);
659 sError = wxPMErrorToStr(vError);
660 }
661 for (n = 0; n < nNumDIB; n++)
662 {
663 if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
664 {
665 //
666 // Redefine height and size of the (possibly) last smaller DIB
667 // memory is not reallocated
668 //
669 nHeight = nHRemain;
670 vHeader.cy = (DWORD)(nHeight);
671 vHeader.cbImage = nBytePerLine * nHeight;
672 }
673 ptbits = pucBits;
674 for (j = 0; j < nHeight; j++)
675 {
676 for (i = 0; i < nWidth; i++)
677 {
678 *(ptbits++) = *(ptdata + 2);
679 *(ptbits++) = *(ptdata + 1);
680 *(ptbits++) = *(ptdata);
681 ptdata += 3;
682 }
683 for (i = 0; i < nPadding; i++)
684 *(ptbits++) = 0;
685 }
686
687 //
688 // Have to do something similar to WIN32's StretchDIBits, use GpiBitBlt
689 // in combination with setting the bits into the selected bitmap
690 //
691 if ((lScans = ::GpiSetBitmapBits( hPS
692 ,0 // Start at the bottom
693 ,(LONG)nHeight // One line per scan
694 ,(PBYTE)pucBits
695 ,&vInfo
696 )) == GPI_ALTERROR)
697 {
698 ERRORID vError;
699 wxString sError;
700
701 vError = ::WinGetLastError(vHabmain);
702 sError = wxPMErrorToStr(vError);
703 }
704 hPSScreen = ::GpiCreatePS( vHabmain
705 ,hDCScreen
706 ,&vSize
707 ,PU_PELS | GPIA_ASSOC
708 );
709
710 POINTL vPoint[4] = { 0, nOrigin,
711 nWidth, nHeight,
712 0, 0, nWidth, nHeight
713 };
714
715
716 ::GpiBitBlt( hPSScreen
717 ,hPS
718 ,4
719 ,vPoint
720 ,ROP_SRCCOPY
721 ,BBO_IGNORE
722 );
723 ::GpiDestroyPS(hPSScreen);
724 nOrigin += nHeight;
725 }
726 SetHBITMAP((WXHBITMAP)hBmp);
727 #if wxUSE_PALETTE
728 if (hOldPalette)
729 ::GpiSelectPalette(hPS, hOldPalette);
730 #endif // wxUSE_PALETTE
731
732 //
733 // Similarly, created an mono-bitmap for the possible mask
734 //
735 if (rImage.HasMask())
736 {
737 vHeader.cbFix = 16;
738 vHeader.cx = nWidth;
739 vHeader.cy = nHeight;
740 vHeader.cPlanes = 1;
741 vHeader.cBitCount = 24;
742 hBmp = ::GpiCreateBitmap( hPS
743 ,&vHeader
744 ,0L
745 ,NULL
746 ,NULL
747 );
748 hBmpOld = ::GpiSetBitmap(hPS, hBmp);
749 if (nNumDIB == 1)
750 nHeight = nBmpHeight;
751 else
752 nHeight = nSizeLimit / nBytePerLine;
753 vHeader.cy = (DWORD)(nHeight);
754 nOrigin = 0;
755
756 unsigned char cRed = rImage.GetMaskRed();
757 unsigned char cGreen = rImage.GetMaskGreen();
758 unsigned char cBlue = rImage.GetMaskBlue();
759 unsigned char cZero = 0;
760 unsigned char cOne = 255;
761
762 ptdata = pData;
763 for (n = 0; n < nNumDIB; n++)
764 {
765 if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
766 {
767 //
768 // Redefine height and size of the (possibly) last smaller DIB
769 // memory is not reallocated
770 //
771 nHeight = nHRemain;
772 vHeader.cy = (DWORD)(nHeight);
773 vHeader.cbImage = nBytePerLine * nHeight;
774 }
775 ptbits = pucBits;
776 for (int j = 0; j < nHeight; j++)
777 {
778 for (i = 0; i < nWidth; i++)
779 {
780 unsigned char cRedImage = (*(ptdata++)) ;
781 unsigned char cGreenImage = (*(ptdata++)) ;
782 unsigned char cBlueImage = (*(ptdata++)) ;
783
784 if ((cRedImage != cRed) || (cGreenImage != cGreen) || (cBlueImage != cBlue))
785 {
786 *(ptbits++) = cOne;
787 *(ptbits++) = cOne;
788 *(ptbits++) = cOne;
789 }
790 else
791 {
792 *(ptbits++) = cZero;
793 *(ptbits++) = cZero;
794 *(ptbits++) = cZero;
795 }
796 }
797 for (i = 0; i < nPadding; i++)
798 *(ptbits++) = cZero;
799 }
800 lScans = ::GpiSetBitmapBits( hPS
801 ,0 // Start at the bottom
802 ,(LONG)nHeight // One line per scan
803 ,(PBYTE)pucBits
804 ,&vInfo
805 );
806 hPSScreen = ::GpiCreatePS( vHabmain
807 ,hDCScreen
808 ,&vSize
809 ,PU_PELS | GPIA_ASSOC
810 );
811 POINTL vPoint2[4] = { 0, nOrigin,
812 nWidth, nHeight,
813 0, 0, nWidth, nHeight
814 };
815 ::GpiBitBlt( hPSScreen
816 ,hPS
817 ,4
818 ,vPoint2
819 ,ROP_SRCCOPY
820 ,BBO_IGNORE
821 );
822 ::GpiDestroyPS(hPSScreen);
823 nOrigin += nHeight;
824 }
825
826 //
827 // Create a wxMask object
828 //
829 wxMask* pMask = new wxMask();
830
831 pMask->SetMaskBitmap((WXHBITMAP)hBmp);
832 SetMask(pMask);
833 hBmpOld = ::GpiSetBitmap(hPS, hBmpOld);
834 }
835
836 //
837 // Free allocated resources
838 //
839 ::GpiSetBitmap(hPS, NULLHANDLE);
840 ::GpiDestroyPS(hPS);
841 ::DevCloseDC(hDCScreen);
842 ::DevCloseDC(hDC);
843 free(pucBits);
844 return TRUE;
845 } // end of wxBitmap::CreateFromImage
846
847 wxImage wxBitmap::ConvertToImage() const
848 {
849 wxImage vImage;
850 wxDC* pDC;
851
852 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
853
854 //
855 // Create an wxImage object
856 //
857 int nWidth = GetWidth();
858 int nHeight = GetHeight();
859 int nDevWidth;
860 int nDevHeight;
861 int nBytePerLine = nWidth * 3;
862 int nSizeDWORD = sizeof(DWORD);
863 int nLineBoundary = nBytePerLine % nSizeDWORD;
864 int nPadding = 0;
865 unsigned char* pData;
866 unsigned char* lpBits;
867 long lScans;
868 BITMAPINFOHEADER2 vDIBh;
869 BITMAPINFO2 vDIBInfo;
870 HPS hPSMem;
871 HPS hPS;
872 HBITMAP hBitmap;
873 HBITMAP hOldBitmap;
874 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
875 SIZEL vSizlPage = {0,0};
876 HDC hDCMem;
877
878 vImage.Create( nWidth
879 ,nHeight
880 );
881 pData = vImage.GetData();
882 if(!pData)
883 {
884 wxFAIL_MSG( wxT("could not allocate data for image") );
885 return wxNullImage;
886 }
887 if(nLineBoundary > 0)
888 {
889 nPadding = nSizeDWORD - nLineBoundary;
890 nBytePerLine += nPadding;
891 }
892 wxDisplaySize( &nDevWidth
893 ,&nDevHeight
894 );
895 //
896 // Create and fill a DIB header
897 //
898 memset(&vDIBh, '\0', 16);
899 vDIBh.cbFix = 16;
900 vDIBh.cx = nWidth;
901 vDIBh.cy = nHeight;
902 vDIBh.cPlanes = 1;
903 vDIBh.cBitCount = 24;
904
905 memset(&vDIBInfo, '\0', 16);
906 vDIBInfo.cbFix = 16;
907 vDIBInfo.cx = nWidth;
908 vDIBInfo.cy = nHeight;
909 vDIBInfo.cPlanes = 1;
910 vDIBInfo.cBitCount = 24;
911
912 lpBits = (unsigned char *)malloc(nBytePerLine * nHeight);
913 if (!lpBits)
914 {
915 wxFAIL_MSG(wxT("could not allocate data for DIB"));
916 free(pData);
917 return wxNullImage;
918 }
919 memset(lpBits, '\0', (nBytePerLine * nHeight));
920 hBitmap = (HBITMAP)GetHBITMAP();
921
922 //
923 // May already be selected into a PS
924 //
925 if ((pDC = GetSelectedInto()) != NULL)
926 {
927 hPSMem = pDC->GetHPS();
928 }
929 else
930 {
931 hDCMem = ::DevOpenDC( vHabmain
932 ,OD_MEMORY
933 ,"*"
934 ,5L
935 ,(PDEVOPENDATA)&vDop
936 ,NULLHANDLE
937 );
938 hPSMem = ::GpiCreatePS( vHabmain
939 ,hDCMem
940 ,&vSizlPage
941 ,PU_PELS | GPIA_ASSOC
942 );
943 }
944 if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR)
945 {
946 ERRORID vError;
947 wxString sError;
948
949 vError = ::WinGetLastError(vHabmain);
950 sError = wxPMErrorToStr(vError);
951 }
952
953 //
954 // Copy data from the device-dependent bitmap to the DIB
955 //
956 if ((lScans = ::GpiQueryBitmapBits( hPSMem
957 ,0L
958 ,(LONG)nHeight
959 ,(PBYTE)lpBits
960 ,&vDIBInfo
961 )) == GPI_ALTERROR)
962 {
963 ERRORID vError;
964 wxString sError;
965
966 vError = ::WinGetLastError(vHabmain);
967 sError = wxPMErrorToStr(vError);
968 }
969
970 //
971 // Copy DIB data into the wxImage object
972 //
973 int i;
974 int j;
975 unsigned char* ptdata = pData;
976 unsigned char* ptbits = lpBits;
977
978 for (i = 0; i < nHeight; i++)
979 {
980 for (j = 0; j < nWidth; j++)
981 {
982 *(ptdata++) = *(ptbits+2);
983 *(ptdata++) = *(ptbits+1);
984 *(ptdata++) = *(ptbits );
985 ptbits += 3;
986 }
987 ptbits += nPadding;
988 }
989 if ((pDC = GetSelectedInto()) == NULL)
990 {
991 ::GpiSetBitmap(hPSMem, NULLHANDLE);
992 ::GpiDestroyPS(hPSMem);
993 ::DevCloseDC(hDCMem);
994 }
995
996 //
997 // Similarly, set data according to the possible mask bitmap
998 //
999 if (GetMask() && GetMask()->GetMaskBitmap())
1000 {
1001 hBitmap = (HBITMAP)GetMask()->GetMaskBitmap();
1002
1003 //
1004 // Memory DC/PS created, color set, data copied, and memory DC/PS deleted
1005 //
1006 HDC hMemDC = ::DevOpenDC( vHabmain
1007 ,OD_MEMORY
1008 ,"*"
1009 ,5L
1010 ,(PDEVOPENDATA)&vDop
1011 ,NULLHANDLE
1012 );
1013 HPS hMemPS = ::GpiCreatePS( vHabmain
1014 ,hMemDC
1015 ,&vSizlPage
1016 ,PU_PELS | GPIA_ASSOC
1017 );
1018 ::GpiSetColor(hMemPS, OS2RGB(0, 0, 0));
1019 ::GpiSetBackColor(hMemPS, OS2RGB(255, 255, 255) );
1020 ::GpiSetBitmap(hMemPS, hBitmap);
1021 ::GpiQueryBitmapBits( hPSMem
1022 ,0L
1023 ,(LONG)nHeight
1024 ,(PBYTE)lpBits
1025 ,&vDIBInfo
1026 );
1027 ::GpiSetBitmap(hMemPS, NULLHANDLE);
1028 ::GpiDestroyPS(hMemPS);
1029 ::DevCloseDC(hMemDC);
1030
1031 //
1032 // Background color set to RGB(16,16,16) in consistent with wxGTK
1033 //
1034 unsigned char ucRed = 16;
1035 unsigned char ucGreen = 16;
1036 unsigned char ucBlue = 16;
1037
1038 ptdata = pData;
1039 ptbits = lpBits;
1040 for (i = 0; i < nHeight; i++)
1041 {
1042 for (j = 0; j < nWidth; j++)
1043 {
1044 if (*ptbits != 0)
1045 ptdata += 3;
1046 else
1047 {
1048 *(ptdata++) = ucRed;
1049 *(ptdata++) = ucGreen;
1050 *(ptdata++) = ucBlue;
1051 }
1052 ptbits += 3;
1053 }
1054 ptbits += nPadding;
1055 }
1056 vImage.SetMaskColour( ucRed
1057 ,ucGreen
1058 ,ucBlue
1059 );
1060 vImage.SetMask(TRUE);
1061 }
1062 else
1063 {
1064 vImage.SetMask(FALSE);
1065 }
1066
1067 //
1068 // Free allocated resources
1069 //
1070 free(lpBits);
1071 return vImage;
1072 } // end of wxBitmap::ConvertToImage
1073
1074 // ----------------------------------------------------------------------------
1075 // sub bitmap extraction
1076 // ----------------------------------------------------------------------------
1077
1078 wxBitmap wxBitmap::GetSubBitmap(
1079 const wxRect& rRect
1080 ) const
1081 {
1082 wxCHECK_MSG( Ok() &&
1083 (rRect.x >= 0) && (rRect.y >= 0) &&
1084 (rRect.x + rRect.width <= GetWidth()) &&
1085 (rRect.y + rRect.height <= GetHeight()),
1086 wxNullBitmap, wxT("Invalid bitmap or bitmap region") );
1087
1088 wxBitmap vRet( rRect.width
1089 ,rRect.height
1090 ,GetDepth()
1091 );
1092 wxASSERT_MSG( vRet.Ok(), wxT("GetSubBitmap error") );
1093
1094
1095 //
1096 // Copy bitmap data
1097 //
1098 SIZEL vSize = {0, 0};
1099 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1100 HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1101 HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1102 HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1103 HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1104 POINTL vPoint[4] = { 0, 0, rRect.width, rRect.height,
1105 rRect.x, rRect.y,
1106 rRect.x + rRect.width, rRect.y + rRect.height
1107 };
1108
1109 ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
1110 ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
1111 ::GpiBitBlt( hPSDst
1112 ,hPSSrc
1113 ,4L
1114 ,vPoint
1115 ,ROP_SRCCOPY
1116 ,BBO_IGNORE
1117 );
1118
1119 //
1120 // Copy mask if there is one
1121 //
1122 if (GetMask())
1123 {
1124 BITMAPINFOHEADER2 vBmih;
1125
1126 memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1127 vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
1128 vBmih.cx = rRect.width;
1129 vBmih.cy = rRect.height;
1130 vBmih.cPlanes = 1;
1131 vBmih.cBitCount = 24;
1132
1133 HBITMAP hBmpMask = ::GpiCreateBitmap( hPSDst
1134 ,&vBmih
1135 ,0L
1136 ,NULL
1137 ,NULL
1138 );
1139
1140 ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP());
1141 ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP());
1142
1143 ::GpiSetBitmap(hPSSrc, (HBITMAP) GetMask()->GetMaskBitmap());
1144 ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpMask);
1145 ::GpiBitBlt( hPSDst
1146 ,hPSSrc
1147 ,4L
1148 ,vPoint
1149 ,ROP_SRCCOPY
1150 ,BBO_IGNORE
1151 );
1152
1153 wxMask* pMask = new wxMask((WXHBITMAP)hBmpMask);
1154 vRet.SetMask(pMask);
1155 }
1156
1157 ::GpiSetBitmap(hPSSrc, NULL);
1158 ::GpiSetBitmap(hPSDst, NULL);
1159 ::GpiDestroyPS(hPSSrc);
1160 ::GpiDestroyPS(hPSDst);
1161 ::DevCloseDC(hDCSrc);
1162 ::DevCloseDC(hDCDst);
1163 return vRet;
1164 } // end of wxBitmap::GetSubBitmap
1165
1166 // ----------------------------------------------------------------------------
1167 // wxBitmap accessors
1168 // ----------------------------------------------------------------------------
1169
1170 void wxBitmap::SetQuality(
1171 int nQ
1172 )
1173 {
1174 EnsureHasData();
1175
1176 GetBitmapData()->m_nQuality = nQ;
1177 } // end of wxBitmap::SetQuality
1178
1179 #if WXWIN_COMPATIBILITY_2
1180 void wxBitmap::SetOk(
1181 bool bOk
1182 )
1183 {
1184 EnsureHasData();
1185
1186 GetBitmapData()->m_bOk = bOk;
1187 } // end of wxBitmap::SetOk
1188 #endif // WXWIN_COMPATIBILITY_2
1189
1190 void wxBitmap::SetPalette(
1191 const wxPalette& rPalette
1192 )
1193 {
1194 EnsureHasData();
1195
1196 GetBitmapData()->m_vBitmapPalette = rPalette;
1197 } // end of wxBitmap::SetPalette
1198
1199 void wxBitmap::SetMask(
1200 wxMask* pMask
1201 )
1202 {
1203 EnsureHasData();
1204
1205 GetBitmapData()->m_pBitmapMask = pMask;
1206 } // end of wxBitmap::SetMask
1207
1208 wxBitmap wxBitmap::GetBitmapForDC(
1209 wxDC& rDc
1210 ) const
1211 {
1212 return(*this);
1213 } // end of wxBitmap::GetBitmapForDC
1214
1215 // ----------------------------------------------------------------------------
1216 // wxMask
1217 // ----------------------------------------------------------------------------
1218
1219 wxMask::wxMask()
1220 {
1221 m_hMaskBitmap = 0;
1222 } // end of wxMask::wxMask
1223
1224 // Construct a mask from a bitmap and a colour indicating
1225 // the transparent area
1226 wxMask::wxMask(
1227 const wxBitmap& rBitmap
1228 , const wxColour& rColour
1229 )
1230 {
1231 m_hMaskBitmap = 0;
1232 Create( rBitmap
1233 ,rColour
1234 );
1235 } // end of wxMask::wxMask
1236
1237 // Construct a mask from a bitmap and a palette index indicating
1238 // the transparent area
1239 wxMask::wxMask(
1240 const wxBitmap& rBitmap
1241 , int nPaletteIndex
1242 )
1243 {
1244 m_hMaskBitmap = 0;
1245 Create( rBitmap
1246 ,nPaletteIndex
1247 );
1248 } // end of wxMask::wxMask
1249
1250 // Construct a mask from a mono bitmap (copies the bitmap).
1251 wxMask::wxMask(
1252 const wxBitmap& rBitmap
1253 )
1254 {
1255 m_hMaskBitmap = 0;
1256 Create(rBitmap);
1257 } // end of wxMask::wxMask
1258
1259 wxMask::~wxMask()
1260 {
1261 if (m_hMaskBitmap)
1262 ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap);
1263 } // end of wxMask::~wxMask
1264
1265 // Create a mask from a mono bitmap (copies the bitmap).
1266 bool wxMask::Create(
1267 const wxBitmap& rBitmap
1268 )
1269 {
1270 BITMAPINFOHEADER2 vBmih;
1271 SIZEL vSize = {0, 0};
1272 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1273 HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1274 HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1275 HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1276 HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1277 POINTL vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(),
1278 0, 0, rBitmap.GetWidth(), rBitmap.GetHeight()
1279 };
1280
1281 if (m_hMaskBitmap)
1282 {
1283 ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1284 m_hMaskBitmap = 0;
1285 }
1286 if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
1287 {
1288 return(FALSE);
1289 }
1290
1291 memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1292 vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
1293 vBmih.cx = rBitmap.GetWidth();
1294 vBmih.cy = rBitmap.GetHeight();
1295 vBmih.cPlanes = 1;
1296 vBmih.cBitCount = 24;
1297
1298 m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
1299 ,&vBmih
1300 ,0L
1301 ,NULL
1302 ,NULL
1303 );
1304
1305 ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
1306 ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
1307 ::GpiBitBlt( hPSDst
1308 ,hPSSrc
1309 ,4L
1310 ,vPoint
1311 ,ROP_SRCCOPY
1312 ,BBO_IGNORE
1313 );
1314
1315 ::GpiDestroyPS(hPSSrc);
1316 ::GpiDestroyPS(hPSDst);
1317 ::DevCloseDC(hDCSrc);
1318 ::DevCloseDC(hDCDst);
1319 return(TRUE);
1320 } // end of wxMask::Create
1321
1322 // Create a mask from a bitmap and a palette index indicating
1323 // the transparent area
1324 bool wxMask::Create(
1325 const wxBitmap& rBitmap
1326 , int nPaletteIndex
1327 )
1328 {
1329 if (m_hMaskBitmap)
1330 {
1331 ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1332 m_hMaskBitmap = 0;
1333 }
1334 if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())
1335 {
1336 unsigned char cRed;
1337 unsigned char cGreen;
1338 unsigned char cBlue;
1339
1340 if (rBitmap.GetPalette()->GetRGB( nPaletteIndex
1341 ,&cRed
1342 ,&cGreen
1343 ,&cBlue
1344 ))
1345 {
1346 wxColour vTransparentColour( cRed
1347 ,cGreen
1348 ,cBlue
1349 );
1350
1351 return (Create( rBitmap
1352 ,vTransparentColour
1353 ));
1354 }
1355 }
1356 return(FALSE);
1357 } // end of wxMask::Create
1358
1359 // Create a mask from a bitmap and a colour indicating
1360 // the transparent area
1361 bool wxMask::Create(
1362 const wxBitmap& rBitmap
1363 , const wxColour& rColour
1364 )
1365 {
1366 bool bOk = TRUE;
1367 COLORREF vMaskColour = OS2RGB( rColour.Red()
1368 ,rColour.Green()
1369 ,rColour.Blue()
1370 );
1371 BITMAPINFOHEADER2 vBmih;
1372 SIZEL vSize = {0, 0};
1373 DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
1374 HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1375 HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1376 HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1377 HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1378 POINTL vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(),
1379 0, 0, rBitmap.GetWidth(), rBitmap.GetHeight()
1380 };
1381
1382 if (m_hMaskBitmap)
1383 {
1384 ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
1385 m_hMaskBitmap = 0;
1386 }
1387 if (!rBitmap.Ok())
1388 {
1389 return(FALSE);
1390 }
1391
1392 //
1393 // Scan the bitmap for the transparent colour and set
1394 // the corresponding pixels in the mask to BLACK and
1395 // the rest to WHITE
1396 //
1397
1398 memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
1399 vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
1400 vBmih.cx = rBitmap.GetWidth();
1401 vBmih.cy = rBitmap.GetHeight();
1402 vBmih.cPlanes = 1;
1403 vBmih.cBitCount = 1;
1404
1405 m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
1406 ,&vBmih
1407 ,0L
1408 ,NULL
1409 ,NULL
1410 );
1411
1412 ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP());
1413 ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap);
1414
1415 //
1416 // This is not very efficient, but I can't think
1417 // of a better way of doing it
1418 //
1419 for (int w = 0; w < rBitmap.GetWidth(); w++)
1420 {
1421 for (int h = 0; h < rBitmap.GetHeight(); h++)
1422 {
1423 POINTL vPt = {w, h};
1424 COLORREF vCol = (COLORREF)::GpiQueryPel(hPSSrc, &vPt);
1425 if (vCol == (COLORREF)CLR_NOINDEX)
1426 {
1427 //
1428 // Doesn't make sense to continue
1429 //
1430 bOk = FALSE;
1431 break;
1432 }
1433
1434 if (vCol == vMaskColour)
1435 {
1436 ::GpiSetColor(hPSDst, OS2RGB(0, 0, 0));
1437 ::GpiSetPel(hPSDst, &vPt);
1438 }
1439 else
1440 {
1441 ::GpiSetColor(hPSDst, OS2RGB(255, 255, 255));
1442 ::GpiSetPel(hPSDst, &vPt);
1443 }
1444 }
1445 }
1446 ::GpiSetBitmap(hPSSrc, NULL);
1447 ::GpiSetBitmap(hPSDst, NULL);
1448 ::GpiDestroyPS(hPSSrc);
1449 ::GpiDestroyPS(hPSDst);
1450 ::DevCloseDC(hDCSrc);
1451 ::DevCloseDC(hDCDst);
1452 return(TRUE);
1453 } // end of wxMask::Create
1454
1455 // ----------------------------------------------------------------------------
1456 // wxBitmapHandler
1457 // ----------------------------------------------------------------------------
1458
1459 bool wxBitmapHandler::Create(
1460 wxGDIImage* pImage
1461 , void* pData
1462 , long lFlags
1463 , int nWidth
1464 , int nHeight
1465 , int nDepth
1466 )
1467 {
1468 wxBitmap* pBitmap = wxDynamicCast( pImage
1469 ,wxBitmap
1470 );
1471
1472 return(pBitmap ? Create( pBitmap
1473 ,pData
1474 ,nWidth
1475 ,nHeight
1476 ,nDepth
1477 ) : FALSE);
1478 }
1479
1480 bool wxBitmapHandler::Load(
1481 wxGDIImage* pImage
1482 , const wxString& rName
1483 , HPS hPs
1484 , long lFlags
1485 , int nWidth
1486 , int nHeight
1487 )
1488 {
1489 wxBitmap* pBitmap = wxDynamicCast( pImage
1490 ,wxBitmap
1491 );
1492
1493 return(pBitmap ? LoadFile( pBitmap
1494 ,rName
1495 ,hPs
1496 ,lFlags
1497 ,nWidth
1498 ,nHeight
1499 ) : FALSE);
1500 }
1501
1502 bool wxBitmapHandler::Save(
1503 wxGDIImage* pImage
1504 , const wxString& rName
1505 , int lType
1506 )
1507 {
1508 wxBitmap* pBitmap = wxDynamicCast( pImage
1509 ,wxBitmap
1510 );
1511
1512 return(pBitmap ? SaveFile( pBitmap
1513 ,rName
1514 ,lType
1515 ) : FALSE);
1516 }
1517
1518 bool wxBitmapHandler::Create(
1519 wxBitmap* WXUNUSED(pBitmap)
1520 , void* WXUNUSED(pData)
1521 , long WXUNUSED(lType)
1522 , int WXUNUSED(nWidth)
1523 , int WXUNUSED(nHeight)
1524 , int WXUNUSED(nDepth)
1525 )
1526 {
1527 return(FALSE);
1528 }
1529
1530 bool wxBitmapHandler::LoadFile(
1531 wxBitmap* WXUNUSED(pBitmap)
1532 , const wxString& WXUNUSED(rName)
1533 , HPS WXUNUSED(hPs)
1534 , long WXUNUSED(lType)
1535 , int WXUNUSED(nDesiredWidth)
1536 , int WXUNUSED(nDesiredHeight)
1537 )
1538 {
1539 return(FALSE);
1540 }
1541
1542 bool wxBitmapHandler::SaveFile(
1543 wxBitmap* WXUNUSED(pBitmap)
1544 , const wxString& WXUNUSED(rName)
1545 , int WXUNUSED(nType)
1546 , const wxPalette* WXUNUSED(pPalette)
1547 )
1548 {
1549 return(FALSE);
1550 }
1551
1552 // ----------------------------------------------------------------------------
1553 // Utility functions
1554 // ----------------------------------------------------------------------------
1555 HBITMAP wxInvertMask(
1556 HBITMAP hBmpMask
1557 , int nWidth
1558 , int nHeight
1559 )
1560 {
1561 HBITMAP hBmpInvMask = 0;
1562
1563 wxCHECK_MSG( hBmpMask, 0, _T("invalid bitmap in wxInvertMask") );
1564
1565 //
1566 // Get width/height from the bitmap if not given
1567 //
1568 if (!nWidth || !nHeight)
1569 {
1570 BITMAPINFOHEADER2 vBmhdr;
1571
1572 ::GpiQueryBitmapInfoHeader( hBmpMask
1573 ,&vBmhdr
1574 );
1575 nWidth = (int)vBmhdr.cx;
1576 nHeight = (int)vBmhdr.cy;
1577 }
1578
1579 BITMAPINFOHEADER2 vBmih;
1580 SIZEL vSize = {0, 0};
1581 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
1582 HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1583 HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
1584 HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
1585 HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
1586 POINTL vPoint[4] = { 0 ,0, nWidth, nHeight,
1587 0, 0, nWidth, nHeight
1588 };
1589
1590 memset(&vBmih, '\0', 16);
1591 vBmih.cbFix = 16;
1592 vBmih.cx = nWidth;
1593 vBmih.cy = nHeight;
1594 vBmih.cPlanes = 1;
1595 vBmih.cBitCount = 24;
1596
1597 hBmpInvMask = ::GpiCreateBitmap( hPSDst
1598 ,&vBmih
1599 ,0L
1600 ,NULL
1601 ,NULL
1602 );
1603
1604 ::GpiSetBitmap(hPSSrc, (HBITMAP) hBmpMask);
1605 ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpInvMask);
1606
1607 ::GpiBitBlt( hPSDst
1608 ,hPSSrc
1609 ,4L
1610 ,vPoint
1611 ,ROP_SRCINVERT
1612 ,BBO_IGNORE
1613 );
1614
1615 ::GpiDestroyPS(hPSSrc);
1616 ::GpiDestroyPS(hPSDst);
1617 ::DevCloseDC(hDCSrc);
1618 ::DevCloseDC(hDCDst);
1619
1620 return hBmpInvMask;
1621 } // end of WxWinGdi_InvertMask
1622
wxWidgets (Impactor)