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