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