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