]> git.saurik.com Git - wxWidgets.git/blob - src/os2/bitmap.cpp
projects / wxWidgets.git / blob
? search:


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