X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3b9e3455225b670d30ee0fb67f8821ada9640f6d..19e30148e18cc99296b26503c155e5cef59045f4:/src/os2/bitmap.cpp diff --git a/src/os2/bitmap.cpp b/src/os2/bitmap.cpp index 872a468db5..53a1a01dc9 100644 --- a/src/os2/bitmap.cpp +++ b/src/os2/bitmap.cpp @@ -9,6 +9,10 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// +#ifdef __GNUG__ + #pragma implementation "bitmap.h" +#endif + // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -29,17 +33,16 @@ //#include "wx/msw/dib.h" #include "wx/image.h" +#include "wx/xpmdecod.h" // ---------------------------------------------------------------------------- // macros // ---------------------------------------------------------------------------- -#if !USE_SHARED_LIBRARIES IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) -#endif // ============================================================================ // implementation @@ -55,7 +58,8 @@ wxBitmapRefData::wxBitmapRefData() m_pSelectedInto = NULL; m_nNumColors = 0; m_pBitmapMask = NULL; -} + m_hBitmap = (WXHBITMAP) NULL; +} // end of wxBitmapRefData::wxBitmapRefData void wxBitmapRefData::Free() { @@ -64,7 +68,7 @@ void wxBitmapRefData::Free() if (m_hBitmap) { - if ( !::GpiDeleteBitmap((HBITMAP)m_hBitmap) ) + if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap)) { wxLogLastError("GpiDeleteBitmap(hbitmap)"); } @@ -72,7 +76,7 @@ void wxBitmapRefData::Free() delete m_pBitmapMask; m_pBitmapMask = NULL; -} +} // end of wxBitmapRefData::Free // ---------------------------------------------------------------------------- // wxBitmap creation @@ -81,34 +85,38 @@ void wxBitmapRefData::Free() // this function should be called from all wxBitmap ctors void wxBitmap::Init() { - // m_refData = NULL; done in the base class ctor - - if (wxTheBitmapList) - wxTheBitmapList->AddBitmap(this); -} +} // end of wxBitmap::Init bool wxBitmap::CopyFromIconOrCursor( const wxGDIImage& rIcon ) { + HPOINTER hIcon = (HPOINTER)rIcon.GetHandle(); + POINTERINFO SIconInfo; + + if (!::WinQueryPointerInfo(hIcon, &SIconInfo)) + { + wxLogLastError(wxT("WinQueryPointerInfo")); + return FALSE; + } wxBitmapRefData* pRefData = new wxBitmapRefData; m_refData = pRefData; - refData->m_width = rIcon.GetWidth(); - refData->m_height = rIcon.GetHeight(); - refData->m_depth = wxDisplayDepth(); + int nWidth = rIcon.GetWidth(); + int nHeight = rIcon.GetHeight(); - refData->m_hBitmap = (WXHBITMAP)rIcon.GetHandle(); - // no mask??? - refData->m_bitmapMask = new wxMask(); + pRefData->m_nWidth = nWidth; + pRefData->m_nHeight = nHeight; + pRefData->m_nDepth = wxDisplayDepth(); -#if WXWIN_COMPATIBILITY_2 - refData->m_ok = TRUE; -#endif // WXWIN_COMPATIBILITY_2 + pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor; + // + // No mask in the Info struct in OS/2 + // return(TRUE); -} +} // end of wxBitmap::CopyFromIconOrCursor bool wxBitmap::CopyFromCursor( const wxCursor& rCursor @@ -118,8 +126,8 @@ bool wxBitmap::CopyFromCursor( if (!rCursor.Ok()) return(FALSE); - return CopyFromIconOrCursor(wxGDIImage)rCursor); -} + return(CopyFromIconOrCursor(rCursor)); +} // end of wxBitmap::CopyFromCursor bool wxBitmap::CopyFromIcon( const wxIcon& rIcon @@ -130,24 +138,18 @@ bool wxBitmap::CopyFromIcon( if (!rIcon.Ok()) return(FALSE); -#if WXWIN_COMPATIBILITY_2 - refData->m_ok = TRUE; -#endif // WXWIN_COMPATIBILITY_2 - - return CopyFromIconOrCursor(icon); -} + return CopyFromIconOrCursor(rIcon); +} // end of wxBitmap::CopyFromIcon wxBitmap::~wxBitmap() { - if (wxTheBitmapList) - wxTheBitmapList->DeleteObject(this); -} +} // end of wxBitmap::~wxBitmap wxBitmap::wxBitmap( const char zBits[] -, int nTheWidth -, int nTheHeight -, int nNoBits +, int nWidth +, int nHeight +, int nDepth ) { Init(); @@ -157,67 +159,108 @@ wxBitmap::wxBitmap( BITMAPINFO2 vInfo; HDC hDc; HPS hPs; - DEVOPENSTRUCT vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL }; + DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL }; SIZEL vSize = {0, 0}; + char* pzData; + + wxASSERT(vHabmain != NULL); + + m_refData = pRefData; - wxAssert(vHabmain != NULL); + pRefData->m_nWidth = nWidth; + pRefData->m_nHeight = nHeight; + pRefData->m_nDepth = nDepth; + pRefData->m_nNumColors = 0; + pRefData->m_pSelectedInto = NULL; hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L); + hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS); + if (hPs == 0) + { + wxLogLastError("GpiCreatePS Failure"); + } + + if (nDepth == 1) + { + // + // We assume that it is in XBM format which is not quite the same as + // the format CreateBitmap() wants because the order of bytes in the + // line is inversed! + // + const size_t nBytesPerLine = (nWidth + 7) / 8; + const size_t nPadding = nBytesPerLine % 2; + const size_t nLen = nHeight * (nPadding + nBytesPerLine); + const char* pzSrc = zBits; + int nRows; + size_t nCols; + + pzData = (char *)malloc(nLen); + + char* pzDst = pzData; + + for (nRows = 0; nRows < nHeight; nRows++) + { + for (nCols = 0; nCols < nBytesPerLine; nCols++) + { + unsigned char ucVal = *pzSrc++; + unsigned char ucReversed = 0; + int nBits; + + for (nBits = 0; nBits < 8; nBits++) + { + ucReversed <<= 1; + ucReversed |= (ucVal & 0x01); + ucVal >>= 1; + } + *pzDst++ = ucReversed; + } + if (nPadding) + *pzDst++ = 0; + } + } + else + { + // + // Bits should already be in Windows standard format + // + pzData = (char *)zBits; // const_cast is harmless + } + memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2)); vHeader.cbFix = sizeof(vHeader); - vHeader.cx = (USHORT)nTheWidth; - vHeader.cy = (USHORT)nTheHeight; + vHeader.cx = (USHORT)nWidth; + vHeader.cy = (USHORT)nHeight; vHeader.cPlanes = 1L; - vHeader.cBitCount = nNoBits; + vHeader.cBitCount = nDepth; + vHeader.usReserved = 0; vHeader.ulCompression = BCA_UNCOMP; - vHeader.cxResolution = 0; - vHeader.cyResolution = 0; - vHeader.cclrUsed = 0; - vHeader.cclrImportant = 0; - vHeader.usUnits = BRU_METRIC; vHeader.usRecording = BRA_BOTTOMUP; vHeader.usRendering = BRH_NOTHALFTONED; - vHeader.cSize1 = 0; - vHeader.cSize2 = 0; - vHeader.ulColorEncoding = 0; + vHeader.ulColorEncoding = BCE_RGB; vHeader.ulIdentifier = 0; - vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS); - if (vhPs == 0) - { - wxLogLastError("GpiCreatePS Failure"); - } - - m_refData = pRefData; - - refData->m_width = nTheWidth; - refData->m_height = nTheHeight; - refData->m_depth = nNoBits; - refData->m_numColors = 0; - refData->m_selectedInto = NULL; - - HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo); - if ( !hbmp ) + memset(&vInfo, '\0', sizeof(BITMAPINFO2)); + vInfo.cbFix = sizeof(vInfo); + vInfo.cx = (USHORT)nWidth; + vInfo.cy = (USHORT)nHeight; + vInfo.cPlanes = 1L; + vInfo.cBitCount = nDepth; + vInfo.usReserved = 0; + vInfo.ulCompression = BCA_UNCOMP; + vInfo.usRecording = BRA_BOTTOMUP; + vInfo.usRendering = BRH_NOTHALFTONED; + vInfo.ulColorEncoding = BCE_RGB; + vInfo.ulIdentifier = 0; + + HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo); + + if (!hBmp) { wxLogLastError("CreateBitmap"); } - SetHBITMAP((WXHBITMAP)hbmp); -} - -// Create from XPM data -wxBitmap::wxBitmap( - char** ppData -, wxControl* WXUNUSED(pAnItem)) -{ - Init(); - -F (void)Create( (void *)ppData - ,wxBITMAP_TYPE_XPM_DATA - ,0 - ,0 - ,0 - ); -} + ::WinReleasePS(hPs); + SetHBITMAP((WXHBITMAP)hBmp); +} // end of wxBitmap::wxBitmap wxBitmap::wxBitmap( int nW @@ -231,7 +274,7 @@ wxBitmap::wxBitmap( ,nH ,nD ); -} +} // end of wxBitmap::wxBitmap wxBitmap::wxBitmap( void* pData @@ -249,7 +292,7 @@ wxBitmap::wxBitmap( ,nHeight ,nDepth ); -} +} // end of wxBitmap::wxBitmap wxBitmap::wxBitmap( const wxString& rFilename @@ -261,7 +304,7 @@ wxBitmap::wxBitmap( LoadFile( rFilename ,(int)lType ); -} +} // end of wxBitmap::wxBitmap bool wxBitmap::Create( int nW @@ -271,224 +314,831 @@ bool wxBitmap::Create( { HBITMAP hBmp; BITMAPINFOHEADER2 vHeader; - BITMAPINFO2 vInfo; - HDC hDc; - HPS hPs; - DEVOPENSTRUCT vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL }; - SIZEL vSize = {0, 0}; - - wxAssert(vHabmain != NULL); - - hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L); - - vHeader.cbFix = sizeof(vHeader); - vHeader.cx = (USHORT)nW; - vHeader.cy = (USHORT)nH; - vHeader.cPlanes = (USHORT)nD; - vHeader.cBitCount = 24; - vHeader.ulCompression = BCA_UNCOMP; - vHeader.cxResolution = 0; - vHeader.cyResolution = 0; - vHeader.cclrUsed = 0; - vHeader.cclrImportant = 0; - vHeader.usUnits = BRU_METRIC; - vHeader.usRecording = BRA_BOTTOMUP; - vHeader.usRendering = BRH_NOTHALFTONED; - vHeader.cSize1 = 0; - vHeader.cSize2 = 0; - vHeader.ulColorEncoding = 0; - vHeader.ulIdentifier = 0; - - vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS); - if (vhPs == 0) - { - wxLogLastError("GpiCreatePS Failure"); - } - + wxASSERT(vHabmain != NULL); UnRef(); m_refData = new wxBitmapRefData; - - GetBitmapData()->m_width = nW; - GetBitmapData()->m_height = nH; - GetBitmapData()->m_depth = nD; + GetBitmapData()->m_nWidth = nW; + GetBitmapData()->m_nHeight = nH; + GetBitmapData()->m_nDepth = nD; if (nD > 0) { - hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo); - if (!hBmp) - { - wxLogLastError("CreateBitmap"); - } + DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L}; + SIZEL vSize = {0, 0}; + HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC); + + memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2)); + vHeader.cbFix = sizeof(BITMAPINFOHEADER2); + vHeader.cx = nW; + vHeader.cy = nH; + vHeader.cPlanes = 1; + vHeader.cBitCount = nD; + + hBmp = ::GpiCreateBitmap( hPS + ,&vHeader + ,0L + ,NULL + ,NULL + ); + ::GpiDestroyPS(hPS); + ::DevCloseDC(hDC); } else { - ScreenHDC dc; - hbmp = ::CreateCompatibleBitmap(dc, w, h); - if ( !hbmp ) - { - wxLogLastError("CreateCompatibleBitmap"); - } - - GetBitmapData()->m_depth = wxDisplayDepth(); + HPS hPSScreen; + HDC hDCScreen; + LONG lBitCount; + + hPSScreen = ::WinGetScreenPS(HWND_DESKTOP); + hDCScreen = ::GpiQueryDevice(hPSScreen); + ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount); + + memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2)); + vHeader.cbFix = sizeof(BITMAPINFOHEADER2); + vHeader.cx = nW; + vHeader.cy = nH; + vHeader.cPlanes = 1; + vHeader.cBitCount = lBitCount; + + hBmp = ::GpiCreateBitmap( hPSScreen + ,&vHeader + ,0L + ,NULL + ,NULL + ); + + GetBitmapData()->m_nDepth = wxDisplayDepth(); + ::WinReleasePS(hPSScreen); } - - SetHBITMAP((WXHBITMAP)hbmp); + SetHBITMAP((WXHBITMAP)hBmp); #if WXWIN_COMPATIBILITY_2 - GetBitmapData()->m_ok = hbmp != 0; + GetBitmapData()->m_bOk = hBmp != 0; #endif // WXWIN_COMPATIBILITY_2 return Ok(); -} +} // end of wxBitmap::Create -bool wxBitmap::LoadFile(const wxString& filename, long type) +bool wxBitmap::CreateFromXpm( + const char** ppData +) { +#if wxUSE_IMAGE && wxUSE_XPM + Init(); + + wxCHECK_MSG(ppData != NULL, FALSE, wxT("invalid bitmap data")) + + wxXPMDecoder vDecoder; + wxImage vImg = vDecoder.ReadData(ppData); + + wxCHECK_MSG(vImg.Ok(), FALSE, wxT("invalid bitmap data")) + + *this = wxBitmap(vImg); + return TRUE; +#else + return FALSE; +#endif +} // end of wxBitmap::CreateFromXpm + +bool wxBitmap::LoadFile( + const wxString& rFilename +, long lType +) +{ + HPS hPs = NULLHANDLE; + UnRef(); - wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); + wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType) + ,wxBitmapHandler + ); - if ( handler ) + if (pHandler) { m_refData = new wxBitmapRefData; - return handler->LoadFile(this, filename, type, -1, -1); + return(pHandler->LoadFile( this + ,rFilename + ,hPs + ,lType + , -1 + , -1 + )); } else { - wxImage image; - if ( !image.LoadFile( filename, type ) || !image.Ok() ) - return FALSE; + wxImage vImage; - *this = image.ConvertToBitmap(); + if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() ) + return(FALSE); - return TRUE; + *this = wxBitmap(vImage); + + return(TRUE); } -} +} // end of wxBitmap::LoadFile -bool wxBitmap::Create(void *data, long type, int width, int height, int depth) +bool wxBitmap::Create( + void* pData +, long lType +, int nWidth +, int nHeight +, int nDepth +) { UnRef(); - wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); + wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType) + ,wxBitmapHandler + ); - if ( !handler ) + if (!pHandler) { wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for " - "type %d defined."), type); + "type %d defined."), lType); - return FALSE; + return(FALSE); } m_refData = new wxBitmapRefData; - return handler->Create(this, data, type, width, height, depth); -} + return(pHandler->Create( this + ,pData + ,lType + ,nWidth + ,nHeight + ,nDepth + )); +} // end of wxBitmap::Create -bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette) +bool wxBitmap::SaveFile( + const wxString& rFilename +, int lType +, const wxPalette* pPalette +) { - wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); + wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType) + ,wxBitmapHandler + ); - if ( handler ) + if (pHandler) { - return handler->SaveFile(this, filename, type, palette); + return pHandler->SaveFile( this + ,rFilename + ,lType + ,pPalette + ); } else { // FIXME what about palette? shouldn't we use it? - wxImage image( *this ); - if (!image.Ok()) - return FALSE; + wxImage vImage = ConvertToImage(); + + if (!vImage.Ok()) + return(FALSE); - return image.SaveFile( filename, type ); + return(vImage.SaveFile( rFilename + ,lType + )); } -} +} // end of wxBitmap::SaveFile + // ---------------------------------------------------------------------------- -// wxBitmap accessors +// wxImage-wxBitmap convertion // ---------------------------------------------------------------------------- -void wxBitmap::SetQuality(int q) +bool wxBitmap::CreateFromImage ( + const wxImage& rImage +, int nDepth +) { - EnsureHasData(); + wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image")); + m_refData = new wxBitmapRefData(); + + int nSizeLimit = 1024 * 768 * 3; + int nWidth = rImage.GetWidth(); + int nBmpHeight = rImage.GetHeight(); + int nBytePerLine = nWidth * 3; + int nSizeDWORD = sizeof(DWORD); + int nLineBoundary = nBytePerLine % nSizeDWORD; + int nPadding = 0; + + if (nLineBoundary > 0) + { + nPadding = nSizeDWORD - nLineBoundary; + nBytePerLine += nPadding; + } - GetBitmapData()->m_quality = q; -} + // + // Calc the number of DIBs and heights of DIBs + // + int nNumDIB = 1; + int nHRemain = 0; + int nHeight = nSizeLimit / nBytePerLine; -#if WXWIN_COMPATIBILITY_2 -void wxBitmap::SetOk(bool isOk) -{ - EnsureHasData(); + if (nHeight >= nBmpHeight) + nHeight = nBmpHeight; + else + { + nNumDIB = nBmpHeight / nHeight; + nHRemain = nBmpHeight % nHeight; + if (nHRemain > 0) + nNumDIB++; + } - GetBitmapData()->m_ok = isOk; -} -#endif // WXWIN_COMPATIBILITY_2 + // + // Set bitmap parameters + // + wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image")); + SetWidth(nWidth); + SetHeight(nBmpHeight); + if (nDepth == -1) + nDepth = wxDisplayDepth(); + SetDepth(nDepth); + +#if wxUSE_PALETTE + // + // Copy the palette from the source image + // + SetPalette(rImage.GetPalette()); +#endif // wxUSE_PALETTE + + // + // Create a DIB header + // + BITMAPINFOHEADER2 vHeader; -void wxBitmap::SetPalette(const wxPalette& palette) -{ - EnsureHasData(); + // + // Fill in the DIB header + // + memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2)); + vHeader.cbFix = sizeof(vHeader); + vHeader.cx = (USHORT)nWidth; + vHeader.cy = (USHORT)nHeight; + vHeader.cPlanes = 1L; + vHeader.cBitCount = 24; + vHeader.ulCompression = BCA_UNCOMP; + vHeader.cbImage = nBytePerLine * nHeight; + vHeader.cclrUsed = 0; - GetBitmapData()->m_bitmapPalette = palette; -} + // + // These seem not really needed for our purpose here. + // + vHeader.cxResolution = 0; + vHeader.cyResolution = 0; + vHeader.cclrImportant = 0; + vHeader.usUnits = BRU_METRIC; + vHeader.usReserved = 0; + vHeader.cSize1 = 0; + vHeader.cSize2 = 0; + vHeader.usRecording = BRA_BOTTOMUP; + vHeader.usRendering = BRH_NOTHALFTONED; + vHeader.ulColorEncoding = BCE_RGB; + vHeader.ulIdentifier = 0; -void wxBitmap::SetMask(wxMask *mask) -{ - EnsureHasData(); + // + // Memory for DIB data + // + unsigned char* pucBits; - GetBitmapData()->m_bitmapMask = mask; -} + pucBits = (unsigned char *)malloc(vHeader.cbImage); + if(!pucBits) + { + wxFAIL_MSG(wxT("could not allocate memory for DIB")); + return FALSE; + } -// Creates a bitmap that matches the device context, from -// an arbitray bitmap. At present, the original bitmap must have an -// associated palette. TODO: use a default palette if no palette exists. -// Contributed by Frederic Villeneuve -wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const + // + // Create and set the device-dependent bitmap + // + DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L}; + SIZEL vSize = {0, 0}; + HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC); + HBITMAP hBmp; + HBITMAP hBmpOld; + + hBmp = ::GpiCreateBitmap( hPS + ,&vHeader + ,0L + ,NULL + ,NULL + ); + hBmpOld = ::GpiSetBitmap(hPS, hBmp); +#if wxUSE_PALETTE + HPAL hOldPalette = NULLHANDLE; + if (rImage.GetPalette().Ok()) + { + hOldPalette = ::GpiSelectPalette(hPS, (HPAL)rImage.GetPalette().GetHPALETTE()); + } +#endif // wxUSE_PALETTE + + // + // Copy image data into DIB data and then into DDB (in a loop) + // + unsigned char* pData = rImage.GetData(); + int i; + int j; + int n; + int nOrigin = 0; + unsigned char* ptdata = pData; + unsigned char* ptbits; + + for (n = 0; n < nNumDIB; n++) + { + if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0) + { + // + // Redefine height and size of the (possibly) last smaller DIB + // memory is not reallocated + // + nHeight = nHRemain; + vHeader.cy = (DWORD)(nHeight); + vHeader.cbImage = nBytePerLine * nHeight; + } + ptbits = pucBits; + for (j = 0; j < nHeight; j++) + { + for (i = 0; i < nWidth; i++) + { + *(ptbits++) = *(ptdata + 2); + *(ptbits++) = *(ptdata + 1); + *(ptbits++) = *(ptdata); + ptdata += 3; + } + for (i = 0; i < nPadding; i++) + *(ptbits++) = 0; + } + + // + // Have to do something similar to WIN32's StretchDIBits, use GpiBitBlt + // + POINTL vPoint[4] = { 0, nOrigin, + nWidth, nHeight, + 0, 0, nWidth, nHeight + }; + + ::GpiBitBlt( hPS + ,hPS + ,4 + ,vPoint + ,ROP_SRCCOPY + ,BBO_IGNORE + ); + nOrigin += nHeight; + } + SetHBITMAP((WXHBITMAP)hBmp); +#if wxUSE_PALETTE + if (hOldPalette) + ::GpiSelectPalette(hPS, hOldPalette); +#endif // wxUSE_PALETTE + + // + // Similarly, created an mono-bitmap for the possible mask + // + if (rImage.HasMask()) + { + memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2)); + vHeader.cbFix = sizeof(BITMAPINFOHEADER2); + vHeader.cx = nWidth; + vHeader.cy = nHeight; + vHeader.cPlanes = 1; + vHeader.cBitCount = 1; + hBmp = ::GpiCreateBitmap( hPS + ,&vHeader + ,0L + ,NULL + ,NULL + ); + hBmpOld = ::GpiSetBitmap(hPS, hBmp); + if (nNumDIB == 1) + nHeight = nBmpHeight; + else + nHeight = nSizeLimit / nBytePerLine; + vHeader.cy = (DWORD)(nHeight); + vHeader.cbImage = nBytePerLine * nHeight; + nOrigin = 0; + + unsigned char cRed = rImage.GetMaskRed(); + unsigned char cGreen = rImage.GetMaskGreen(); + unsigned char cBlue = rImage.GetMaskBlue(); + unsigned char cZero = 0; + unsigned char cOne = 255; + + ptdata = pData; + for (n = 0; n < nNumDIB; n++) + { + if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0) + { + // + // Redefine height and size of the (possibly) last smaller DIB + // memory is not reallocated + // + nHeight = nHRemain; + vHeader.cy = (DWORD)(nHeight); + vHeader.cbImage = nBytePerLine * nHeight; + } + ptbits = pucBits; + for (int j = 0; j < nHeight; j++) + { + for (i = 0; i < nWidth; i++) + { + if ((*(ptdata++) != cRed) || (*(ptdata++) != cGreen) || (*(ptdata++) != cBlue)) + { + *(ptbits++) = cOne; + *(ptbits++) = cOne; + *(ptbits++) = cOne; + } + else + { + *(ptbits++) = cZero; + *(ptbits++) = cZero; + *(ptbits++) = cZero; + } + } + for (i = 0; i < nPadding; i++) + *(ptbits++) = cZero; + } + POINTL vPoint[4] = { 0, nOrigin, + nWidth, nHeight, + 0, 0, nWidth, nHeight + }; + + ::GpiBitBlt( hPS + ,hPS + ,4 + ,vPoint + ,ROP_SRCCOPY + ,BBO_IGNORE + ); + nOrigin += nHeight; + } + + // + // Create a wxMask object + // + wxMask* pMask = new wxMask(); + + pMask->SetMaskBitmap((WXHBITMAP)hBmp); + SetMask(pMask); + hBmpOld = ::GpiSetBitmap(hPS, hBmp); + } + + // + // Free allocated resources + // + ::GpiSetBitmap(hPS, NULLHANDLE); + ::GpiDestroyPS(hPS); + ::DevCloseDC(hDC); + free(pucBits); + return TRUE; +} // end of wxBitmap::CreateFromImage + +wxImage wxBitmap::ConvertToImage() const { - wxMemoryDC memDC; - wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth()); - HPALETTE hPal = (HPALETTE) NULL; - LPBITMAPINFO lpDib; - void *lpBits = (void*) NULL; + wxImage vImage; + + wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") ); + + // + // Create an wxImage object + // + int nWidth = GetWidth(); + int nHeight = GetHeight(); + int nDevWidth; + int nDevHeight; + int nBytePerLine = nWidth * 3; + int nSizeDWORD = sizeof(DWORD); + int nLineBoundary = nBytePerLine % nSizeDWORD; + int nPadding = 0; + unsigned char* pData; + unsigned char* lpBits; + long lScans; + BITMAPINFOHEADER2 vDIBh; + BITMAPINFO2 vDIBInfo; + HDC hDCMem; + PSZ pszData[4] = { "Display", NULL, NULL, NULL }; + HPS hPSMem; + HPS hPS; + SIZEL vSizlPage = {0,0}; + HBITMAP hBitmap; + + vImage.Create( nWidth + ,nHeight + ); + pData = vImage.GetData(); + if(!pData) + { + wxFAIL_MSG( wxT("could not allocate data for image") ); + return wxNullImage; + } + if(nLineBoundary > 0) + { + nPadding = nSizeDWORD - nLineBoundary; + nBytePerLine += nPadding; + } + wxDisplaySize( &nDevWidth + ,&nDevHeight + ); + // + // Create and fill a DIB header + // + memset(&vDIBh, '\0', sizeof(BITMAPINFOHEADER2)); + vDIBh.cbFix = sizeof(BITMAPINFOHEADER2); + vDIBh.cx = nWidth; + vDIBh.cy = nHeight; + vDIBh.cPlanes = 1; + vDIBh.cbImage = nBytePerLine * nHeight; + vDIBh.cBitCount = 24; + + memset(&vDIBInfo, '\0', sizeof(BITMAPINFO2)); + vDIBInfo.cbFix = sizeof(BITMAPINFO2); + vDIBInfo.cPlanes = 1; + vDIBInfo.cBitCount = 24; + vDIBInfo.ulCompression = BCA_UNCOMP; + vDIBInfo.usReserved = 0; + vDIBInfo.usRecording = BRA_BOTTOMUP; + vDIBInfo.usRendering = BRH_NOTHALFTONED; + vDIBInfo.ulColorEncoding = BCE_RGB; + vDIBInfo.ulIdentifier = 0; + + lpBits = (unsigned char *)malloc(vDIBh.cbImage); + if (!lpBits) + { + wxFAIL_MSG(wxT("could not allocate data for DIB")); + free(pData); + return wxNullImage; + } - if( GetPalette() && GetPalette()->Ok() ) + // + // Copy data from the device-dependent bitmap to the DIB + // + hDCMem = ::DevOpenDC( vHabmain + ,OD_MEMORY + ,"*" + ,4 + ,(PDEVOPENDATA)pszData + ,NULLHANDLE + ); + hPSMem = ::GpiCreatePS( vHabmain + ,hDCMem + ,&vSizlPage + ,PU_PELS | GPIA_ASSOC | GPIT_MICRO + ); + hBitmap = ::GpiCreateBitmap( hPSMem + ,&vDIBh + ,0L + ,NULL + ,NULL + ); + lScans = ::GpiQueryBitmapBits( hPSMem + ,0L + ,(LONG)nHeight + ,(PBYTE)lpBits + ,&vDIBInfo + ); + + // + // Copy DIB data into the wxImage object + // + int i; + int j; + unsigned char* ptdata = pData; + unsigned char* ptbits = lpBits; + + for (i = 0; i < nHeight; i++) { - tmpBitmap.SetPalette(*GetPalette()); - memDC.SelectObject(tmpBitmap); - memDC.SetPalette(*GetPalette()); - hPal = (HPALETTE)GetPalette()->GetHPALETTE(); + for (j = 0; j < nWidth; j++) + { + *(ptdata++) = *(ptbits+2); + *(ptdata++) = *(ptbits+1); + *(ptdata++) = *(ptbits ); + ptbits += 3; + } + ptbits += nPadding; + } + + // + // Similarly, set data according to the possible mask bitmap + // + if (GetMask() && GetMask()->GetMaskBitmap()) + { + hBitmap = (HBITMAP)GetMask()->GetMaskBitmap(); + + // + // Memory DC/PS created, color set, data copied, and memory DC/PS deleted + // + HDC hMemDC = ::DevOpenDC( vHabmain + ,OD_MEMORY + ,"*" + ,4 + ,(PDEVOPENDATA)pszData + ,NULLHANDLE + ); + HPS hMemPS = ::GpiCreatePS( vHabmain + ,hMemDC + ,&vSizlPage + ,PU_PELS | GPIA_ASSOC | GPIT_MICRO + ); + ::GpiSetColor(hMemPS, OS2RGB(0, 0, 0)); + ::GpiSetBackColor(hMemPS, OS2RGB(255, 255, 255) ); + ::GpiQueryBitmapBits( hPSMem + ,0L + ,(LONG)nHeight + ,(PBYTE)lpBits + ,&vDIBInfo + ); + ::GpiDestroyPS(hMemPS); + ::DevCloseDC(hMemDC); + + // + // Background color set to RGB(16,16,16) in consistent with wxGTK + // + unsigned char ucRed = 16; + unsigned char ucGreen = 16; + unsigned char ucBlue = 16; + + ptdata = pData; + ptbits = lpBits; + for (i = 0; i < nHeight; i++) + { + for (j = 0; j < nWidth; j++) + { + if (*ptbits != 0) + ptdata += 3; + else + { + *(ptdata++) = ucRed; + *(ptdata++) = ucGreen; + *(ptdata++) = ucBlue; + } + ptbits += 3; + } + ptbits += nPadding; + } + vImage.SetMaskColour( ucRed + ,ucGreen + ,ucBlue + ); + vImage.SetMask(TRUE); } else { - hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE); - wxPalette palette; - palette.SetHPALETTE( (WXHPALETTE)hPal ); - tmpBitmap.SetPalette( palette ); - memDC.SelectObject(tmpBitmap); - memDC.SetPalette( palette ); + vImage.SetMask(FALSE); } - // set the height negative because in a DIB the order of the lines is - // reversed - if ( !wxCreateDIB(GetWidth(), -GetHeight(), GetDepth(), hPal, &lpDib) ) + // + // Free allocated resources + // + ::GpiDestroyPS(hPSMem); + ::DevCloseDC(hDCMem); + free(lpBits); + return vImage; +} // end of wxBitmap::ConvertToImage + +// ---------------------------------------------------------------------------- +// sub bitmap extraction +// ---------------------------------------------------------------------------- + +wxBitmap wxBitmap::GetSubBitmap( + const wxRect& rRect +) const +{ + wxCHECK_MSG( Ok() && + (rRect.x >= 0) && (rRect.y >= 0) && + (rRect.x + rRect.width <= GetWidth()) && + (rRect.y + rRect.height <= GetHeight()), + wxNullBitmap, wxT("Invalid bitmap or bitmap region") ); + + wxBitmap vRet( rRect.width + ,rRect.height + ,GetDepth() + ); + wxASSERT_MSG( vRet.Ok(), wxT("GetSubBitmap error") ); + + + // + // Copy bitmap data + // + SIZEL vSize = {0, 0}; + DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L}; + HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC); + HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC); + POINTL vPoint[4] = { rRect.x, rRect.y, + rRect.x + rRect.width, rRect.y + rRect.height, + 0, 0, GetWidth(), GetHeight() + }; + + ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP()); + ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP()); + ::GpiBitBlt( hPSDst + ,hPSSrc + ,4L + ,vPoint + ,ROP_SRCCOPY + ,BBO_IGNORE + ); + + // + // Copy mask if there is one + // + if (GetMask()) { - return wxNullBitmap; + BITMAPINFOHEADER2 vBmih; + + memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2)); + vBmih.cbFix = sizeof(BITMAPINFOHEADER2); + vBmih.cx = rRect.width; + vBmih.cy = rRect.height; + vBmih.cPlanes = 1; + vBmih.cBitCount = 1; + + HBITMAP hBmpMask = ::GpiCreateBitmap( hPSDst + ,&vBmih + ,0L + ,NULL + ,NULL + ); + + ::GpiSetBitmap(hPSSrc, (HBITMAP) GetHBITMAP()); + ::GpiSetBitmap(hPSDst, (HBITMAP) vRet.GetHBITMAP()); + + ::GpiSetBitmap(hPSSrc, (HBITMAP) GetMask()->GetMaskBitmap()); + ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpMask); + ::GpiBitBlt( hPSDst + ,hPSSrc + ,4L + ,vPoint + ,ROP_SRCCOPY + ,BBO_IGNORE + ); + + wxMask* pMask = new wxMask((WXHBITMAP)hBmpMask); + vRet.SetMask(pMask); } - lpBits = malloc(lpDib->bmiHeader.biSizeImage); + ::GpiSetBitmap(hPSSrc, NULL); + ::GpiSetBitmap(hPSDst, NULL); + ::GpiDestroyPS(hPSSrc); + ::GpiDestroyPS(hPSDst); + ::DevCloseDC(hDCSrc); + ::DevCloseDC(hDCDst); + return vRet; +} // end of wxBitmap::GetSubBitmap - ::GetBitmapBits(GetHbitmap(), lpDib->bmiHeader.biSizeImage, lpBits); +// ---------------------------------------------------------------------------- +// wxBitmap accessors +// ---------------------------------------------------------------------------- - ::SetDIBitsToDevice(GetHdcOf(memDC), 0, 0, - GetWidth(), GetHeight(), - 0, 0, 0, GetHeight(), - lpBits, lpDib, DIB_RGB_COLORS); +void wxBitmap::SetQuality( + int nQ +) +{ + EnsureHasData(); - free(lpBits); + GetBitmapData()->m_nQuality = nQ; +} // end of wxBitmap::SetQuality - wxFreeDIB(lpDib); +#if WXWIN_COMPATIBILITY_2 +void wxBitmap::SetOk( + bool bOk +) +{ + EnsureHasData(); - return tmpBitmap; -} + GetBitmapData()->m_bOk = bOk; +} // end of wxBitmap::SetOk +#endif // WXWIN_COMPATIBILITY_2 + +void wxBitmap::SetPalette( + const wxPalette& rPalette +) +{ + EnsureHasData(); + + GetBitmapData()->m_vBitmapPalette = rPalette; +} // end of wxBitmap::SetPalette + +void wxBitmap::SetMask( + wxMask* pMask +) +{ + EnsureHasData(); + + GetBitmapData()->m_pBitmapMask = pMask; +} // end of wxBitmap::SetMask + +wxBitmap wxBitmap::GetBitmapForDC( + wxDC& rDc +) const +{ + return(*this); +} // end of wxBitmap::GetBitmapForDC // ---------------------------------------------------------------------------- // wxMask @@ -496,250 +1146,405 @@ wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const wxMask::wxMask() { - m_maskBitmap = 0; -} + m_hMaskBitmap = 0; +} // end of wxMask::wxMask // Construct a mask from a bitmap and a colour indicating // the transparent area -wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour) +wxMask::wxMask( + const wxBitmap& rBitmap +, const wxColour& rColour +) { - m_maskBitmap = 0; - Create(bitmap, colour); -} + m_hMaskBitmap = 0; + Create( rBitmap + ,rColour + ); +} // end of wxMask::wxMask // Construct a mask from a bitmap and a palette index indicating // the transparent area -wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex) +wxMask::wxMask( + const wxBitmap& rBitmap +, int nPaletteIndex +) { - m_maskBitmap = 0; - Create(bitmap, paletteIndex); -} + m_hMaskBitmap = 0; + Create( rBitmap + ,nPaletteIndex + ); +} // end of wxMask::wxMask // Construct a mask from a mono bitmap (copies the bitmap). -wxMask::wxMask(const wxBitmap& bitmap) +wxMask::wxMask( + const wxBitmap& rBitmap +) { - m_maskBitmap = 0; - Create(bitmap); -} + m_hMaskBitmap = 0; + Create(rBitmap); +} // end of wxMask::wxMask wxMask::~wxMask() { - if ( m_maskBitmap ) - ::DeleteObject((HBITMAP) m_maskBitmap); -} + if (m_hMaskBitmap) + ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap); +} // end of wxMask::~wxMask // Create a mask from a mono bitmap (copies the bitmap). -bool wxMask::Create(const wxBitmap& bitmap) +bool wxMask::Create( + const wxBitmap& rBitmap +) { - if ( m_maskBitmap ) + BITMAPINFOHEADER2 vBmih; + SIZEL vSize = {0, 0}; + DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L}; + HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC); + HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC); + POINTL vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(), + 0, 0, rBitmap.GetWidth(), rBitmap.GetHeight() + }; + + if (m_hMaskBitmap) { - ::DeleteObject((HBITMAP) m_maskBitmap); - m_maskBitmap = 0; + ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap); + m_hMaskBitmap = 0; } - if (!bitmap.Ok() || bitmap.GetDepth() != 1) + if (!rBitmap.Ok() || rBitmap.GetDepth() != 1) { - return FALSE; + return(FALSE); } - m_maskBitmap = (WXHBITMAP) CreateBitmap( - bitmap.GetWidth(), - bitmap.GetHeight(), - 1, 1, 0 - ); - HDC srcDC = CreateCompatibleDC(0); - SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP()); - HDC destDC = CreateCompatibleDC(0); - SelectObject(destDC, (HBITMAP) m_maskBitmap); - BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY); - SelectObject(srcDC, 0); - DeleteDC(srcDC); - SelectObject(destDC, 0); - DeleteDC(destDC); - return TRUE; -} + + memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2)); + vBmih.cbFix = sizeof(BITMAPINFOHEADER2); + vBmih.cx = rBitmap.GetWidth(); + vBmih.cy = rBitmap.GetHeight(); + vBmih.cPlanes = 1; + vBmih.cBitCount = 1; + + m_hMaskBitmap = ::GpiCreateBitmap( hPSDst + ,&vBmih + ,0L + ,NULL + ,NULL + ); + + ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP()); + ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap); + ::GpiBitBlt( hPSDst + ,hPSSrc + ,4L + ,vPoint + ,ROP_SRCCOPY + ,BBO_IGNORE + ); + + ::GpiDestroyPS(hPSSrc); + ::GpiDestroyPS(hPSDst); + ::DevCloseDC(hDCSrc); + ::DevCloseDC(hDCDst); + return(TRUE); +} // end of wxMask::Create // Create a mask from a bitmap and a palette index indicating // the transparent area -bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex) +bool wxMask::Create( + const wxBitmap& rBitmap +, int nPaletteIndex +) { - if ( m_maskBitmap ) + if (m_hMaskBitmap) { - ::DeleteObject((HBITMAP) m_maskBitmap); - m_maskBitmap = 0; + ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap); + m_hMaskBitmap = 0; } - if (bitmap.Ok() && bitmap.GetPalette()->Ok()) + if (rBitmap.Ok() && rBitmap.GetPalette()->Ok()) { - unsigned char red, green, blue; - if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue)) + unsigned char cRed; + unsigned char cGreen; + unsigned char cBlue; + + if (rBitmap.GetPalette()->GetRGB( nPaletteIndex + ,&cRed + ,&cGreen + ,&cBlue + )) { - wxColour transparentColour(red, green, blue); - return Create(bitmap, transparentColour); + wxColour vTransparentColour( cRed + ,cGreen + ,cBlue + ); + + return (Create( rBitmap + ,vTransparentColour + )); } } - return FALSE; -} + return(FALSE); +} // end of wxMask::Create // Create a mask from a bitmap and a colour indicating // the transparent area -bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour) +bool wxMask::Create( + const wxBitmap& rBitmap +, const wxColour& rColour +) { - if ( m_maskBitmap ) + bool bOk = TRUE; + COLORREF vMaskColour = OS2RGB( rColour.Red() + ,rColour.Green() + ,rColour.Blue() + ); + BITMAPINFOHEADER2 vBmih; + SIZEL vSize = {0, 0}; + DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL }; + HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC); + HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC); + POINTL vPoint[4] = { 0 ,0, rBitmap.GetWidth(), rBitmap.GetHeight(), + 0, 0, rBitmap.GetWidth(), rBitmap.GetHeight() + }; + + if (m_hMaskBitmap) { - ::DeleteObject((HBITMAP) m_maskBitmap); - m_maskBitmap = 0; + ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap); + m_hMaskBitmap = 0; } - if (!bitmap.Ok()) + if (!rBitmap.Ok()) { - return FALSE; + return(FALSE); } - // scan the bitmap for the transparent colour and set + // + // Scan the bitmap for the transparent colour and set // the corresponding pixels in the mask to BLACK and // the rest to WHITE - COLORREF maskColour = RGB(colour.Red(), colour.Green(), colour.Blue()); - m_maskBitmap = (WXHBITMAP) ::CreateBitmap( - bitmap.GetWidth(), - bitmap.GetHeight(), - 1, 1, 0 - ); - HDC srcDC = ::CreateCompatibleDC(0); - ::SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP()); - HDC destDC = ::CreateCompatibleDC(0); - ::SelectObject(destDC, (HBITMAP) m_maskBitmap); - - // this is not very efficient, but I can't think + // + + memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2)); + vBmih.cbFix = sizeof(BITMAPINFOHEADER2); + vBmih.cx = rBitmap.GetWidth(); + vBmih.cy = rBitmap.GetHeight(); + vBmih.cPlanes = 1; + vBmih.cBitCount = 1; + + m_hMaskBitmap = ::GpiCreateBitmap( hPSDst + ,&vBmih + ,0L + ,NULL + ,NULL + ); + + ::GpiSetBitmap(hPSSrc, (HBITMAP) rBitmap.GetHBITMAP()); + ::GpiSetBitmap(hPSDst, (HBITMAP) m_hMaskBitmap); + + // + // This is not very efficient, but I can't think // of a better way of doing it - for (int w = 0; w < bitmap.GetWidth(); w++) + // + for (int w = 0; w < rBitmap.GetWidth(); w++) { - for (int h = 0; h < bitmap.GetHeight(); h++) + for (int h = 0; h < rBitmap.GetHeight(); h++) { - COLORREF col = GetPixel(srcDC, w, h); - if (col == maskColour) + POINTL vPt = {w, h}; + COLORREF vCol = (COLORREF)::GpiQueryPel(hPSSrc, &vPt); + if (vCol == (COLORREF)CLR_NOINDEX) + { + // + // Doesn't make sense to continue + // + bOk = FALSE; + break; + } + + if (vCol == vMaskColour) { - ::SetPixel(destDC, w, h, RGB(0, 0, 0)); + ::GpiSetColor(hPSDst, OS2RGB(0, 0, 0)); + ::GpiSetPel(hPSDst, &vPt); } else { - ::SetPixel(destDC, w, h, RGB(255, 255, 255)); + ::GpiSetColor(hPSDst, OS2RGB(255, 255, 255)); + ::GpiSetPel(hPSDst, &vPt); } } } - ::SelectObject(srcDC, 0); - ::DeleteDC(srcDC); - ::SelectObject(destDC, 0); - ::DeleteDC(destDC); - return TRUE; -} + ::GpiSetBitmap(hPSSrc, NULL); + ::GpiSetBitmap(hPSDst, NULL); + ::GpiDestroyPS(hPSSrc); + ::GpiDestroyPS(hPSDst); + ::DevCloseDC(hDCSrc); + ::DevCloseDC(hDCDst); + return(TRUE); +} // end of wxMask::Create // ---------------------------------------------------------------------------- // wxBitmapHandler // ---------------------------------------------------------------------------- -bool wxBitmapHandler::Create(wxGDIImage *image, - void *data, - long flags, - int width, int height, int depth) +bool wxBitmapHandler::Create( + wxGDIImage* pImage +, void* pData +, long lFlags +, int nWidth +, int nHeight +, int nDepth +) { - wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); - - return bitmap ? Create(bitmap, data, width, height, depth) : FALSE; + wxBitmap* pBitmap = wxDynamicCast( pImage + ,wxBitmap + ); + + return(pBitmap ? Create( pBitmap + ,pData + ,nWidth + ,nHeight + ,nDepth + ) : FALSE); } -bool wxBitmapHandler::Load(wxGDIImage *image, - const wxString& name, - long flags, - int width, int height) +bool wxBitmapHandler::Load( + wxGDIImage* pImage +, const wxString& rName +, HPS hPs +, long lFlags +, int nWidth +, int nHeight +) { - wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); - - return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE; + wxBitmap* pBitmap = wxDynamicCast( pImage + ,wxBitmap + ); + + return(pBitmap ? LoadFile( pBitmap + ,rName + ,hPs + ,lFlags + ,nWidth + ,nHeight + ) : FALSE); } -bool wxBitmapHandler::Save(wxGDIImage *image, - const wxString& name, - int type) +bool wxBitmapHandler::Save( + wxGDIImage* pImage +, const wxString& rName +, int lType +) { - wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); - - return bitmap ? SaveFile(bitmap, name, type) : FALSE; + wxBitmap* pBitmap = wxDynamicCast( pImage + ,wxBitmap + ); + + return(pBitmap ? SaveFile( pBitmap + ,rName + ,lType + ) : FALSE); } -bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), - void *WXUNUSED(data), - long WXUNUSED(type), - int WXUNUSED(width), - int WXUNUSED(height), - int WXUNUSED(depth)) +bool wxBitmapHandler::Create( + wxBitmap* WXUNUSED(pBitmap) +, void* WXUNUSED(pData) +, long WXUNUSED(lType) +, int WXUNUSED(nWidth) +, int WXUNUSED(nHeight) +, int WXUNUSED(nDepth) +) { - return FALSE; + return(FALSE); } -bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), - const wxString& WXUNUSED(name), - long WXUNUSED(type), - int WXUNUSED(desiredWidth), - int WXUNUSED(desiredHeight)) +bool wxBitmapHandler::LoadFile( + wxBitmap* WXUNUSED(pBitmap) +, const wxString& WXUNUSED(rName) +, HPS WXUNUSED(hPs) +, long WXUNUSED(lType) +, int WXUNUSED(nDesiredWidth) +, int WXUNUSED(nDesiredHeight) +) { - return FALSE; + return(FALSE); } -bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), - const wxString& WXUNUSED(name), - int WXUNUSED(type), - const wxPalette *WXUNUSED(palette)) +bool wxBitmapHandler::SaveFile( + wxBitmap* WXUNUSED(pBitmap) +, const wxString& WXUNUSED(rName) +, int WXUNUSED(nType) +, const wxPalette* WXUNUSED(pPalette) +) { - return FALSE; + return(FALSE); } // ---------------------------------------------------------------------------- -// DIB functions +// Utility functions // ---------------------------------------------------------------------------- - -bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel, - HPALETTE hPal, LPBITMAPINFO* lpDIBHeader) +HBITMAP wxInvertMask( + HBITMAP hBmpMask +, int nWidth +, int nHeight +) { - unsigned long i, headerSize; - LPBITMAPINFO lpDIBheader = NULL; - LPPALETTEENTRY lpPe = NULL; - - - // Allocate space for a DIB header - headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY))); - lpDIBheader = (BITMAPINFO *) malloc(headerSize); - lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER)); - - GetPaletteEntries(hPal, 0, 256, lpPe); - - memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER)); - - // Fill in the static parts of the DIB header - lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); - lpDIBheader->bmiHeader.biWidth = xSize; - lpDIBheader->bmiHeader.biHeight = ySize; - lpDIBheader->bmiHeader.biPlanes = 1; + HBITMAP hBmpInvMask = 0; - // this value must be 1, 4, 8 or 24 so PixelDepth can only be - lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel); - lpDIBheader->bmiHeader.biCompression = BI_RGB; - lpDIBheader->bmiHeader.biSizeImage = xSize * abs(ySize) * bitsPerPixel >> 3; - lpDIBheader->bmiHeader.biClrUsed = 256; + wxCHECK_MSG( hBmpMask, 0, _T("invalid bitmap in wxInvertMask") ); + // + // Get width/height from the bitmap if not given + // + if (!nWidth || !nHeight) + { + BITMAPINFOHEADER2 vBmhdr; - // Initialize the DIB palette - for (i = 0; i < 256; i++) { - lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags; - lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed; - lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen; - lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue; - } - - *lpDIBHeader = lpDIBheader; - - return TRUE; -} - -void wxFreeDIB(LPBITMAPINFO lpDIBHeader) -{ - free(lpDIBHeader); -} + ::GpiQueryBitmapInfoHeader( hBmpMask + ,&vBmhdr + ); + nWidth = (int)vBmhdr.cx; + nHeight = (int)vBmhdr.cy; + } + BITMAPINFOHEADER2 vBmih; + SIZEL vSize = {0, 0}; + DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L}; + HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC); + HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC); + POINTL vPoint[4] = { 0 ,0, nWidth, nHeight, + 0, 0, nWidth, nHeight + }; + + memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2)); + vBmih.cbFix = sizeof(BITMAPINFOHEADER2); + vBmih.cx = nWidth; + vBmih.cy = nHeight; + vBmih.cPlanes = 1; + vBmih.cBitCount = 1; + + hBmpInvMask = ::GpiCreateBitmap( hPSDst + ,&vBmih + ,0L + ,NULL + ,NULL + ); + + ::GpiSetBitmap(hPSSrc, (HBITMAP) hBmpMask); + ::GpiSetBitmap(hPSDst, (HBITMAP) hBmpInvMask); + + ::GpiBitBlt( hPSDst + ,hPSSrc + ,4L + ,vPoint + ,ROP_SRCINVERT + ,BBO_IGNORE + ); + + ::GpiDestroyPS(hPSSrc); + ::GpiDestroyPS(hPSDst); + ::DevCloseDC(hDCSrc); + ::DevCloseDC(hDCDst); + + return hBmpInvMask; +} // end of WxWinGdi_InvertMask