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


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