X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/d88de032d3009be88d0f0ba4a882784aa9493331..96c9f0f6775fb74e549789d714941e97a4407848:/src/os2/bitmap.cpp diff --git a/src/os2/bitmap.cpp b/src/os2/bitmap.cpp index 93ea059994..c7d256e0f7 100644 --- a/src/os2/bitmap.cpp +++ b/src/os2/bitmap.cpp @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: bitmap.cpp +// Name: src/os2/bitmap.cpp // Purpose: wxBitmap // Author: David Webster // Modified by: @@ -12,6 +12,8 @@ // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" +#include "wx/bitmap.h" + #ifndef WX_PRECOMP #include @@ -20,542 +22,1676 @@ #include "wx/app.h" #include "wx/palette.h" #include "wx/dcmemory.h" - #include "wx/bitmap.h" #include "wx/icon.h" + #include "wx/log.h" + #include "wx/image.h" #endif #include "wx/os2/private.h" -#include "wx/log.h" + +#include "wx/xpmdecod.h" // ---------------------------------------------------------------------------- // macros // ---------------------------------------------------------------------------- -#if !USE_SHARED_LIBRARIES IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) -#endif -wxBitmapRefData::wxBitmapRefData() -{ - m_ok = FALSE; - m_width = 0; - m_height = 0; - m_depth = 0; - m_quality = 0; - m_hBitmap = 0 ; - m_selectedInto = NULL; - m_numColors = 0; - m_bitmapMask = NULL; -} +IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) -wxBitmapRefData::~wxBitmapRefData() -{ - if (m_selectedInto) - { - wxChar buf[200]; - wxSprintf(buf, wxT("Bitmap was deleted without selecting out of wxMemoryDC %lX."), (unsigned long) m_selectedInto); - wxFatalError(buf); - } - if (m_hBitmap) - { -// TODO: DeleteObject((HBITMAP) m_hBitmap); - } - m_hBitmap = 0 ; - - if (m_bitmapMask) - delete m_bitmapMask; - m_bitmapMask = NULL; -} +// ============================================================================ +// implementation +// ============================================================================ -wxList wxBitmap::sm_handlers; +// ---------------------------------------------------------------------------- +// wxBitmapRefData +// ---------------------------------------------------------------------------- -wxBitmap::wxBitmap() +wxBitmapRefData::wxBitmapRefData() { - m_refData = NULL; - - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); -} - -wxBitmap::wxBitmap(const wxBitmap& bitmap) + m_nQuality = 0; + m_pSelectedInto = NULL; + m_nNumColors = 0; + m_pBitmapMask = NULL; + m_hBitmap = (WXHBITMAP) NULL; +} // end of wxBitmapRefData::wxBitmapRefData + +void wxBitmapRefData::Free() { -// TODO: -/* - wxIcon *icon = wxDynamicCast(&bitmap, wxIcon); - if ( icon ) + if ( m_pSelectedInto ) { - HDC hdc = ::CreateCompatibleDC(NULL); // screen DC - HBITMAP hbitmap = ::CreateCompatibleBitmap(hdc, - icon->GetWidth(), - icon->GetHeight()); - ::SelectObject(hdc, hbitmap); - ::DrawIcon(hdc, 0, 0, (HICON)icon->GetHICON()); - - ::DeleteDC(hdc); - - SetHBITMAP((WXHBITMAP)hbitmap); + wxLogLastError(wxT("GpiDeleteBitmap(hbitmap)")); } - else + if (m_hBitmap) + { + if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap)) + { + wxLogLastError(wxT("GpiDeleteBitmap(hbitmap)")); + } + } + if (m_pBitmapMask) { - Ref(bitmap); + delete m_pBitmapMask; + m_pBitmapMask = NULL; } +} // end of wxBitmapRefData::Free - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); -*/ -} +// ---------------------------------------------------------------------------- +// wxBitmap creation +// ---------------------------------------------------------------------------- -wxBitmap::~wxBitmap() +// this function should be called from all wxBitmap ctors +void wxBitmap::Init() { - if (wxTheBitmapList) - wxTheBitmapList->DeleteObject(this); -} + m_bIsMono = false; + // + // True for all bitmaps created from bits, wxImages, Xpms + // +} // end of wxBitmap::Init -bool wxBitmap::FreeResource(bool WXUNUSED(force)) +bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& rIcon) { - if ( !M_BITMAPDATA ) - return FALSE; - - if (M_BITMAPDATA->m_selectedInto) - { - wxChar buf[200]; - wxSprintf(buf, wxT("Bitmap %lX was deleted without selecting out of wxMemoryDC %lX."), (unsigned long) this, (unsigned long) M_BITMAPDATA->m_selectedInto); - wxFatalError(buf); - } - if (M_BITMAPDATA->m_hBitmap) - { -// TODO: DeleteObject((HBITMAP) M_BITMAPDATA->m_hBitmap); - } - M_BITMAPDATA->m_hBitmap = 0 ; - -/* - if (M_BITMAPDATA->m_bitmapPalette) - delete M_BITMAPDATA->m_bitmapPalette; + HPOINTER hIcon = (HPOINTER)rIcon.GetHandle(); + POINTERINFO SIconInfo; - M_BITMAPDATA->m_bitmapPalette = NULL ; -*/ + if (!::WinQueryPointerInfo(hIcon, &SIconInfo)) + { + wxLogLastError(wxT("WinQueryPointerInfo")); + return false; + } + wxBitmapRefData* pRefData = new wxBitmapRefData; - return TRUE; -} + m_refData = pRefData; + int nWidth = rIcon.GetWidth(); + int nHeight = rIcon.GetHeight(); -wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits) -{ - m_refData = new wxBitmapRefData; + pRefData->m_nWidth = nWidth; + pRefData->m_nHeight = nHeight; + pRefData->m_nDepth = wxDisplayDepth(); - M_BITMAPDATA->m_width = the_width ; - M_BITMAPDATA->m_height = the_height ; - M_BITMAPDATA->m_depth = no_bits ; - M_BITMAPDATA->m_numColors = 0; + pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor; - /* TODO: create the bitmap from data */ + wxMask* pMask = new wxMask(SIconInfo.hbmPointer); - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); -} + pMask->SetMaskBitmap(GetHBITMAP()); + SetMask(pMask); -// Create from XPM data -wxBitmap::wxBitmap(char **data, wxControl *WXUNUSED(anItem)) -{ - (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); -} + return true; +} // end of wxBitmap::CopyFromIconOrCursor -wxBitmap::wxBitmap(int w, int h, int d) +bool wxBitmap::CopyFromCursor( + const wxCursor& rCursor +) { - (void)Create(w, h, d); + UnRef(); - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); -} + if (!rCursor.Ok()) + return(false); + return(CopyFromIconOrCursor(rCursor)); +} // end of wxBitmap::CopyFromCursor -wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth) +bool wxBitmap::CopyFromIcon( + const wxIcon& rIcon +) { - (void) Create(data, type, width, height, depth); + UnRef(); - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); -} + if (!rIcon.Ok()) + return(false); + + return CopyFromIconOrCursor(rIcon); +} // end of wxBitmap::CopyFromIcon -wxBitmap::wxBitmap(const wxString& filename, long type) +wxBitmap::~wxBitmap() +{ +} // end of wxBitmap::~wxBitmap + +wxBitmap::wxBitmap( + const char zBits[] +, int nWidth +, int nHeight +, int nDepth +) { - LoadFile(filename, (int)type); + Init(); + + wxBitmapRefData* pRefData = new wxBitmapRefData; + BITMAPINFOHEADER2 vHeader; + BITMAPINFO2 vInfo; + HDC hDc; + HPS hPs; + DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL }; + SIZEL vSize = {0, 0}; + char* pzData; + + wxASSERT(vHabmain != NULL); + + m_refData = pRefData; + + 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, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS); + if (hPs == 0) + { + wxLogLastError(wxT("GpiCreatePS Failure")); + } - if ( wxTheBitmapList ) - wxTheBitmapList->AddBitmap(this); -} + 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 reversed! + // + 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 = (unsigned char)(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 + } -bool wxBitmap::Create(int w, int h, int d) + if (nDepth > 24) + nDepth = 24; // MAX supported in PM + memset(&vHeader, '\0', 16); + vHeader.cbFix = 16; + vHeader.cx = (USHORT)nWidth; + vHeader.cy = (USHORT)nHeight; + vHeader.cPlanes = 1L; + vHeader.cBitCount = (USHORT)nDepth; + vHeader.usReserved = 0; + + memset(&vInfo, '\0', 16); + vInfo.cbFix = 16; + vInfo.cx = (USHORT)nWidth; + vInfo.cy = (USHORT)nHeight; + vInfo.cPlanes = 1L; + vInfo.cBitCount = (USHORT)nDepth; + + HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo); + + if (!hBmp) + { + wxLogLastError(wxT("CreateBitmap")); + } + ::GpiDestroyPS(hPs); + ::DevCloseDC(hDc); + SetHBITMAP((WXHBITMAP)hBmp); +} // end of wxBitmap::wxBitmap + +wxBitmap::wxBitmap( + int nW +, int nH +, int nD +) { - UnRef(); + Init(); + (void)Create( nW + ,nH + ,nD + ); +} // end of wxBitmap::wxBitmap + +wxBitmap::wxBitmap( + void* pData +, long lType +, int nWidth +, int nHeight +, int nDepth +) +{ + Init(); + + (void)Create( pData + ,lType + ,nWidth + ,nHeight + ,nDepth + ); +} // end of wxBitmap::wxBitmap + +wxBitmap::wxBitmap( + int nId +, long lType +) +{ + Init(); + LoadFile( nId + ,(int)lType + ); + SetId(nId); +} // end of wxBitmap::wxBitmap + +bool wxBitmap::Create( + int nW +, int nH +, int nD +) +{ + HBITMAP hBmp; + BITMAPINFOHEADER2 vHeader; + wxASSERT(vHabmain != NULL); + UnRef(); m_refData = new wxBitmapRefData; + GetBitmapData()->m_nWidth = nW; + GetBitmapData()->m_nHeight = nH; + GetBitmapData()->m_nDepth = nD; + + // + // Xpms and bitmaps from other images can also be mono's, but only + // mono's need help changing their colors with MemDC changes + // + if (nD > 0) + { + 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); + + if (nD == 1) + m_bIsMono = true; + memset(&vHeader, '\0', 16); + vHeader.cbFix = 16; + vHeader.cx = nW; + vHeader.cy = nH; + vHeader.cPlanes = 1; + vHeader.cBitCount = 24; //nD; + + hBmp = ::GpiCreateBitmap( hPS + ,&vHeader + ,0L + ,NULL + ,NULL + ); + ::GpiDestroyPS(hPS); + ::DevCloseDC(hDC); + } + else + { + HPS hPSScreen; + HDC hDCScreen; + LONG lBitCount; + + hPSScreen = ::WinGetScreenPS(HWND_DESKTOP); + hDCScreen = ::GpiQueryDevice(hPSScreen); + ::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount); + + if (lBitCount > 24) + lBitCount = 24; + + memset(&vHeader, '\0', 16); + vHeader.cbFix = 16; + vHeader.cx = nW; + vHeader.cy = nH; + vHeader.cPlanes = 1; + vHeader.cBitCount = (USHORT)lBitCount; + + hBmp = ::GpiCreateBitmap( hPSScreen + ,&vHeader + ,0L + ,NULL + ,NULL + ); + + GetBitmapData()->m_nDepth = wxDisplayDepth(); + ::WinReleasePS(hPSScreen); + } + SetHBITMAP((WXHBITMAP)hBmp); - M_BITMAPDATA->m_width = w; - M_BITMAPDATA->m_height = h; - M_BITMAPDATA->m_depth = d; - - /* TODO: create new bitmap */ - - return M_BITMAPDATA->m_ok; -} + return Ok(); +} // end of wxBitmap::Create -bool wxBitmap::LoadFile(const wxString& filename, long type) +bool wxBitmap::CreateFromXpm( + const char** ppData +) { - UnRef(); +#if wxUSE_IMAGE && wxUSE_XPM + Init(); - m_refData = new wxBitmapRefData; - - wxBitmapHandler *handler = FindHandler(type); + wxCHECK_MSG(ppData != NULL, false, wxT("invalid bitmap data")); - if ( handler == NULL ) { - wxLogWarning("no bitmap handler for type %d defined.", type); + wxXPMDecoder vDecoder; + wxImage vImg = vDecoder.ReadData(ppData); - return FALSE; - } + wxCHECK_MSG(vImg.Ok(), false, wxT("invalid bitmap data")); - return handler->LoadFile(this, filename, type, -1, -1); -} + *this = wxBitmap(vImg); + return true; +#else + return false; +#endif +} // end of wxBitmap::CreateFromXpm -bool wxBitmap::Create(void *data, long type, int width, int height, int depth) +bool wxBitmap::LoadFile(const wxString& filename, long type) { UnRef(); - m_refData = new wxBitmapRefData; + wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); - wxBitmapHandler *handler = FindHandler(type); + if ( handler ) + { + m_refData = new wxBitmapRefData; - if ( handler == NULL ) { - wxLogWarning("no bitmap handler for type %d defined.", type); + return handler->LoadFile(this, filename, type, -1, -1); + } +#if wxUSE_IMAGE + else // no bitmap handler found + { + wxImage image; + if ( image.LoadFile( filename, type ) && image.Ok() ) + { + *this = wxBitmap(image); - return FALSE; + return true; + } } +#endif // wxUSE_IMAGE - return handler->Create(this, data, type, width, height, depth); + return false; } -bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette) +bool wxBitmap::LoadFile( + int nId +, long lType +) { - wxBitmapHandler *handler = FindHandler(type); - - if ( handler == NULL ) { - wxLogWarning("no bitmap handler for type %d defined.", type); - - return FALSE; - } + UnRef(); - return handler->SaveFile(this, filename, type, palette); -} + wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType) + ,wxBitmapHandler + ); -void wxBitmap::SetWidth(int w) -{ - if (!M_BITMAPDATA) + if (pHandler) + { m_refData = new wxBitmapRefData; - M_BITMAPDATA->m_width = w; -} - -void wxBitmap::SetHeight(int h) + return(pHandler->LoadFile( this + ,nId + ,lType + , -1 + , -1 + )); + } + else + { + return false; + } +} // end of wxBitmap::LoadFile + +bool wxBitmap::Create( + void* pData +, long lType +, int nWidth +, int nHeight +, int nDepth +) { - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_height = h; -} + UnRef(); -void wxBitmap::SetDepth(int d) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; + wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType) + ,wxBitmapHandler + ); - M_BITMAPDATA->m_depth = d; -} + if (!pHandler) + { + wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %ld defined."), lType); -void wxBitmap::SetQuality(int q) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; + return false; + } - M_BITMAPDATA->m_quality = q; -} + m_refData = new wxBitmapRefData; -void wxBitmap::SetOk(bool isOk) + return(pHandler->Create( this + ,pData + ,lType + ,nWidth + ,nHeight + ,nDepth + )); +} // end of wxBitmap::Create + +bool wxBitmap::SaveFile( + const wxString& rFilename +, int lType +, const wxPalette* pPalette +) { - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; + wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType) + ,wxBitmapHandler + ); - M_BITMAPDATA->m_ok = isOk; -} - -void wxBitmap::SetPalette(const wxPalette& palette) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; + if (pHandler) + { + return pHandler->SaveFile( this + ,rFilename + ,lType + ,pPalette + ); + } + else + { + // FIXME what about palette? shouldn't we use it? + wxImage vImage = ConvertToImage(); - M_BITMAPDATA->m_bitmapPalette = palette ; -} + if (!vImage.Ok()) + return false; -void wxBitmap::SetMask(wxMask *mask) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - - M_BITMAPDATA->m_bitmapMask = mask ; -} + return(vImage.SaveFile( rFilename + ,lType + )); + } +} // end of wxBitmap::SaveFile -void wxBitmap::SetHBITMAP(WXHBITMAP bmp) -{ - if (!M_BITMAPDATA) - m_refData = new wxBitmapRefData; - M_BITMAPDATA->m_hBitmap = bmp; -} +// ---------------------------------------------------------------------------- +// wxImage-wxBitmap conversion +// ---------------------------------------------------------------------------- -void wxBitmap::AddHandler(wxBitmapHandler *handler) +bool wxBitmap::CreateFromImage ( + const wxImage& rImage +, int nDepth +) { - sm_handlers.Append(handler); -} + 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; + } -void wxBitmap::InsertHandler(wxBitmapHandler *handler) -{ - sm_handlers.Insert(handler); -} + // + // Calc the number of DIBs and heights of DIBs + // + int nNumDIB = 1; + int nHRemain = 0; + int nHeight = nSizeLimit / nBytePerLine; -bool wxBitmap::RemoveHandler(const wxString& name) -{ - wxBitmapHandler *handler = FindHandler(name); - if ( handler ) + if (nHeight >= nBmpHeight) + nHeight = nBmpHeight; + else { - sm_handlers.DeleteObject(handler); - return TRUE; + nNumDIB = nBmpHeight / nHeight; + nHRemain = nBmpHeight % nHeight; + if (nHRemain > 0) + nNumDIB++; } + + // + // Set bitmap parameters + // + wxCHECK_MSG(rImage.Ok(), false, wxT("invalid image")); + SetWidth(nWidth); + SetHeight(nBmpHeight); + if (nDepth == 1) + m_bIsMono = true; else - return FALSE; -} + m_bIsMono = false; + 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; + BITMAPINFO2 vInfo; + + // + // Fill in the DIB header + // + memset(&vHeader, '\0', 16); + vHeader.cbFix = 16; + vHeader.cx = (ULONG)nWidth; + vHeader.cy = (ULONG)nHeight; + vHeader.cPlanes = 1L; + vHeader.cBitCount = 24; + + // + // Memory for DIB data + // + unsigned char* pucBits; + + pucBits = (unsigned char *)malloc(nBytePerLine * nHeight); + if(!pucBits) + { + wxFAIL_MSG(wxT("could not allocate memory for DIB")); + return false; + } + memset(pucBits, '\0', (nBytePerLine * nHeight)); + + // + // 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); + LONG lScans; + HDC hDCScreen = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE); + HPS hPSScreen; + HBITMAP hBmp; + HBITMAP hBmpOld; + + memset(&vInfo, '\0', 16); + vInfo.cbFix = 16; + vInfo.cx = (ULONG)nWidth; + vInfo.cy = (ULONG)nHeight; + vInfo.cPlanes = 1; + vInfo.cBitCount = 24; // Set to desired count going in + + hBmp = ::GpiCreateBitmap( hPS + ,&vHeader + ,0L + ,NULL + ,NULL + ); +#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; + + if ((hBmpOld = ::GpiSetBitmap(hPS, hBmp)) == HBM_ERROR) + { + ERRORID vError; + wxString sError; -wxBitmapHandler *wxBitmap::FindHandler(const wxString& name) -{ - wxNode *node = sm_handlers.First(); - while ( node ) + vError = ::WinGetLastError(vHabmain); + sError = wxPMErrorToStr(vError); + } + for (n = 0; n < nNumDIB; n++) { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if ( handler->GetName() == name ) - return handler; - node = node->Next(); + 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 + // in combination with setting the bits into the selected bitmap + // + if ((lScans = ::GpiSetBitmapBits( hPS + ,0 // Start at the bottom + ,(LONG)nHeight // One line per scan + ,(PBYTE)pucBits + ,&vInfo + )) == GPI_ALTERROR) + { + ERRORID vError; + wxString sError; + + vError = ::WinGetLastError(vHabmain); + sError = wxPMErrorToStr(vError); + } + hPSScreen = ::GpiCreatePS( vHabmain + ,hDCScreen + ,&vSize + ,PU_PELS | GPIA_ASSOC + ); + + POINTL vPoint[4] = { {0, nOrigin}, + {nWidth, nHeight}, + {0, 0}, {nWidth, nHeight} + }; + + + ::GpiBitBlt( hPSScreen + ,hPS + ,4 + ,vPoint + ,ROP_SRCCOPY + ,BBO_IGNORE + ); + ::GpiDestroyPS(hPSScreen); + 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()) + { + vHeader.cbFix = 16; + vHeader.cx = nWidth; + vHeader.cy = nHeight; + vHeader.cPlanes = 1; + vHeader.cBitCount = 24; + hBmp = ::GpiCreateBitmap( hPS + ,&vHeader + ,0L + ,NULL + ,NULL + ); + hBmpOld = ::GpiSetBitmap(hPS, hBmp); + if (nNumDIB == 1) + nHeight = nBmpHeight; + else + nHeight = nSizeLimit / nBytePerLine; + vHeader.cy = (DWORD)(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++) + { + unsigned char cRedImage = (*(ptdata++)) ; + unsigned char cGreenImage = (*(ptdata++)) ; + unsigned char cBlueImage = (*(ptdata++)) ; + + if ((cRedImage != cRed) || (cGreenImage != cGreen) || (cBlueImage != cBlue)) + { + *(ptbits++) = cOne; + *(ptbits++) = cOne; + *(ptbits++) = cOne; + } + else + { + *(ptbits++) = cZero; + *(ptbits++) = cZero; + *(ptbits++) = cZero; + } + } + for (i = 0; i < nPadding; i++) + *(ptbits++) = cZero; + } + lScans = ::GpiSetBitmapBits( hPS + ,0 // Start at the bottom + ,(LONG)nHeight // One line per scan + ,(PBYTE)pucBits + ,&vInfo + ); + hPSScreen = ::GpiCreatePS( vHabmain + ,hDCScreen + ,&vSize + ,PU_PELS | GPIA_ASSOC + ); + POINTL vPoint2[4] = { {0, nOrigin}, + {nWidth, nHeight}, + {0, 0}, {nWidth, nHeight} + }; + ::GpiBitBlt( hPSScreen + ,hPS + ,4 + ,vPoint2 + ,ROP_SRCCOPY + ,BBO_IGNORE + ); + ::GpiDestroyPS(hPSScreen); + nOrigin += nHeight; + } + + // + // Create a wxMask object + // + wxMask* pMask = new wxMask(); + + pMask->SetMaskBitmap((WXHBITMAP)hBmp); + SetMask(pMask); + hBmpOld = ::GpiSetBitmap(hPS, hBmpOld); } - return NULL; -} -wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType) + // + // Free allocated resources + // + ::GpiSetBitmap(hPS, NULLHANDLE); + ::GpiDestroyPS(hPS); + ::DevCloseDC(hDCScreen); + ::DevCloseDC(hDC); + free(pucBits); + return true; +} // end of wxBitmap::CreateFromImage + +wxImage wxBitmap::ConvertToImage() const { - wxNode *node = sm_handlers.First(); - while ( node ) + wxImage vImage; + wxDC* pDC; + + 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; + HPS hPSMem; + HBITMAP hBitmap; + HBITMAP hOldBitmap; + DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L}; + SIZEL vSizlPage = {0,0}; + HDC hDCMem = NULLHANDLE; + + vImage.Create( nWidth + ,nHeight + ); + pData = vImage.GetData(); + if(!pData) { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if ( handler->GetExtension() == extension && - (bitmapType == -1 || handler->GetType() == bitmapType) ) - return handler; - node = node->Next(); + wxFAIL_MSG( wxT("could not allocate data for image") ); + return wxNullImage; } - return NULL; -} + if(nLineBoundary > 0) + { + nPadding = nSizeDWORD - nLineBoundary; + nBytePerLine += nPadding; + } + wxDisplaySize( &nDevWidth + ,&nDevHeight + ); + // + // Create and fill a DIB header + // + memset(&vDIBh, '\0', 16); + vDIBh.cbFix = 16; + vDIBh.cx = nWidth; + vDIBh.cy = nHeight; + vDIBh.cPlanes = 1; + vDIBh.cBitCount = 24; + + memset(&vDIBInfo, '\0', 16); + vDIBInfo.cbFix = 16; + vDIBInfo.cx = nWidth; + vDIBInfo.cy = nHeight; + vDIBInfo.cPlanes = 1; + vDIBInfo.cBitCount = 24; + + lpBits = (unsigned char *)malloc(nBytePerLine * nHeight); + if (!lpBits) + { + wxFAIL_MSG(wxT("could not allocate data for DIB")); + free(pData); + return wxNullImage; + } + memset(lpBits, '\0', (nBytePerLine * nHeight)); + hBitmap = (HBITMAP)GetHBITMAP(); -wxBitmapHandler *wxBitmap::FindHandler(long bitmapType) -{ - wxNode *node = sm_handlers.First(); - while ( node ) + // + // May already be selected into a PS + // + if ((pDC = GetSelectedInto()) != NULL) { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - if (handler->GetType() == bitmapType) - return handler; - node = node->Next(); + hPSMem = pDC->GetHPS(); } - return NULL; -} + else + { + hDCMem = ::DevOpenDC( vHabmain + ,OD_MEMORY + ,"*" + ,5L + ,(PDEVOPENDATA)&vDop + ,NULLHANDLE + ); + hPSMem = ::GpiCreatePS( vHabmain + ,hDCMem + ,&vSizlPage + ,PU_PELS | GPIA_ASSOC + ); + } + if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR) + { + ERRORID vError; + wxString sError; -// 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 -{ - wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth()); -// TODO: -/* - wxMemoryDC memDC; - HPALETTE hPal = (HPALETTE) NULL; - LPBITMAPINFO lpDib; - void *lpBits = (void*) NULL; + vError = ::WinGetLastError(vHabmain); + sError = wxPMErrorToStr(vError); + } + // + // Copy data from the device-dependent bitmap to the DIB + // + if ((lScans = ::GpiQueryBitmapBits( hPSMem + ,0L + ,(LONG)nHeight + ,(PBYTE)lpBits + ,&vDIBInfo + )) == GPI_ALTERROR) + { + ERRORID vError; + wxString sError; - wxASSERT( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) ); + vError = ::WinGetLastError(vHabmain); + sError = wxPMErrorToStr(vError); + } - tmpBitmap.SetPalette(this->GetPalette()); - memDC.SelectObject(tmpBitmap); - memDC.SetPalette(this->GetPalette()); + // + // Copy DIB data into the wxImage object + // + int i; + int j; + unsigned char* ptdata = pData; + unsigned char* ptbits = lpBits; - hPal = (HPALETTE) this->GetPalette()->GetHPALETTE(); + for (i = 0; i < nHeight; i++) + { + for (j = 0; j < nWidth; j++) + { + *(ptdata++) = *(ptbits+2); + *(ptdata++) = *(ptbits+1); + *(ptdata++) = *(ptbits ); + ptbits += 3; + } + ptbits += nPadding; + } + if ((pDC = GetSelectedInto()) == NULL) + { + ::GpiSetBitmap(hPSMem, NULLHANDLE); + ::GpiDestroyPS(hPSMem); + ::DevCloseDC(hDCMem); + } - if( this->GetPalette() && this->GetPalette()->Ok() && (this->GetPalette()->GetHPALETTE() != 0) ) + // + // Similarly, set data according to the possible mask bitmap + // + if (GetMask() && GetMask()->GetMaskBitmap()) { - tmpBitmap.SetPalette(* this->GetPalette()); - memDC.SelectObject(tmpBitmap); - memDC.SetPalette(* this->GetPalette()); - hPal = (HPALETTE) this->GetPalette()->GetHPALETTE(); + hBitmap = (HBITMAP)GetMask()->GetMaskBitmap(); + + // + // Memory DC/PS created, color set, data copied, and memory DC/PS deleted + // + HDC hMemDC = ::DevOpenDC( vHabmain + ,OD_MEMORY + ,"*" + ,5L + ,(PDEVOPENDATA)&vDop + ,NULLHANDLE + ); + HPS hMemPS = ::GpiCreatePS( vHabmain + ,hMemDC + ,&vSizlPage + ,PU_PELS | GPIA_ASSOC + ); + ::GpiSetColor(hMemPS, OS2RGB(0, 0, 0)); + ::GpiSetBackColor(hMemPS, OS2RGB(255, 255, 255) ); + ::GpiSetBitmap(hMemPS, hBitmap); + ::GpiQueryBitmapBits( hPSMem + ,0L + ,(LONG)nHeight + ,(PBYTE)lpBits + ,&vDIBInfo + ); + ::GpiSetBitmap(hMemPS, NULLHANDLE); + ::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 - createDIB(this->GetWidth(), -this->GetHeight(), this->GetDepth(), hPal, &lpDib); + // + // Free allocated resources + // + free(lpBits); + return vImage; +} // end of wxBitmap::ConvertToImage - lpBits = malloc(lpDib->bmiHeader.biSizeImage); +// ---------------------------------------------------------------------------- +// sub bitmap extraction +// ---------------------------------------------------------------------------- - ::GetBitmapBits((HBITMAP)GetHBITMAP(), lpDib->bmiHeader.biSizeImage, lpBits); +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] = { {0, 0}, {rRect.width, rRect.height}, + {rRect.x, rRect.y}, + {rRect.x + rRect.width, rRect.y + rRect.height} + }; + + ::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()) + { + BITMAPINFOHEADER2 vBmih; + + memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2)); + vBmih.cbFix = sizeof(BITMAPINFOHEADER2); + vBmih.cx = rRect.width; + vBmih.cy = rRect.height; + vBmih.cPlanes = 1; + vBmih.cBitCount = 24; + + 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); + } - ::SetDIBitsToDevice((HDC) memDC.GetHDC(), 0, 0, this->GetWidth(), this->GetHeight(), - 0, 0, 0, this->GetHeight(), lpBits, lpDib, DIB_RGB_COLORS); + ::GpiSetBitmap(hPSSrc, NULL); + ::GpiSetBitmap(hPSDst, NULL); + ::GpiDestroyPS(hPSSrc); + ::GpiDestroyPS(hPSDst); + ::DevCloseDC(hDCSrc); + ::DevCloseDC(hDCDst); + return vRet; +} // end of wxBitmap::GetSubBitmap - free(lpBits); +// ---------------------------------------------------------------------------- +// wxBitmap accessors +// ---------------------------------------------------------------------------- - freeDIB(lpDib); -*/ - return (tmpBitmap); -} +void wxBitmap::SetQuality( + int nQ +) +{ + EnsureHasData(); -/* - * wxMask - */ + GetBitmapData()->m_nQuality = nQ; +} // end of wxBitmap::SetQuality + +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& WXUNUSED(rDc)) const +{ + return(*this); +} // end of wxBitmap::GetBitmapForDC + +// ---------------------------------------------------------------------------- +// wxMask +// ---------------------------------------------------------------------------- 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() { -// TODO: delete mask bitmap -} + 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 +) { -// TODO - return FALSE; -} + 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) + { + ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap); + m_hMaskBitmap = 0; + } + if (!rBitmap.Ok() || rBitmap.GetDepth() != 1) + { + return false; + } + + memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2)); + vBmih.cbFix = sizeof(BITMAPINFOHEADER2); + vBmih.cx = rBitmap.GetWidth(); + vBmih.cy = rBitmap.GetHeight(); + vBmih.cPlanes = 1; + vBmih.cBitCount = 24; + + 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 +) { -// TODO - return FALSE; -} + if (m_hMaskBitmap) + { + ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap); + m_hMaskBitmap = 0; + } + if (rBitmap.Ok() && rBitmap.GetPalette()->Ok()) + { + unsigned char cRed; + unsigned char cGreen; + unsigned char cBlue; + + if (rBitmap.GetPalette()->GetRGB( nPaletteIndex + ,&cRed + ,&cGreen + ,&cBlue + )) + { + wxColour vTransparentColour( cRed + ,cGreen + ,cBlue + ); + + return (Create( rBitmap + ,vTransparentColour + )); + } + } + 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 +) { -// TODO - return FALSE; -} + 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); + + if (m_hMaskBitmap) + { + ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap); + m_hMaskBitmap = 0; + } + if (!rBitmap.Ok()) + { + return false; + } -/* - * wxBitmapHandler - */ + // + // Scan the bitmap for the transparent colour and set + // the corresponding pixels in the mask to BLACK and + // the rest to WHITE + // + + 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 < rBitmap.GetWidth(); w++) + { + for (int h = 0; h < rBitmap.GetHeight(); h++) + { + 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) + { + ::GpiSetColor(hPSDst, OS2RGB(0, 0, 0)); + ::GpiSetPel(hPSDst, &vPt); + } + else + { + ::GpiSetColor(hPSDst, OS2RGB(255, 255, 255)); + ::GpiSetPel(hPSDst, &vPt); + } + } + } + ::GpiSetBitmap(hPSSrc, NULL); + ::GpiSetBitmap(hPSDst, NULL); + ::GpiDestroyPS(hPSSrc); + ::GpiDestroyPS(hPSDst); + ::DevCloseDC(hDCSrc); + ::DevCloseDC(hDCDst); + return true; +} // end of wxMask::Create -IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) +// ---------------------------------------------------------------------------- +// wxBitmapHandler +// ---------------------------------------------------------------------------- -bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth) +bool wxBitmapHandler::Create( wxGDIImage* pImage, + void* pData, + long WXUNUSED(lFlags), + int nWidth, + int nHeight, + int nDepth) { - return FALSE; + wxBitmap* pBitmap = wxDynamicCast( pImage + ,wxBitmap + ); + + return(pBitmap ? Create( pBitmap + ,pData + ,nWidth + ,nHeight + ,nDepth + ) : false); } -bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type, - int desiredWidth, int desiredHeight) +bool wxBitmapHandler::Load( + wxGDIImage* pImage +, int nId +, long lFlags +, int nWidth +, int nHeight +) { - return FALSE; + wxBitmap* pBitmap = wxDynamicCast( pImage + ,wxBitmap + ); + + return(pBitmap ? LoadFile( pBitmap + ,nId + ,lFlags + ,nWidth + ,nHeight + ) : false); } -bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette) +bool wxBitmapHandler::Save( + wxGDIImage* pImage +, const wxString& rName +, int lType +) { - return FALSE; + wxBitmap* pBitmap = wxDynamicCast( pImage + ,wxBitmap + ); + + return(pBitmap ? SaveFile( pBitmap + ,rName + ,lType + ) : false); } -/* - * Standard handlers - */ +bool wxBitmapHandler::Create( + wxBitmap* WXUNUSED(pBitmap) +, void* WXUNUSED(pData) +, long WXUNUSED(lType) +, int WXUNUSED(nWidth) +, int WXUNUSED(nHeight) +, int WXUNUSED(nDepth) +) +{ + return false; +} -/* TODO: bitmap handlers, a bit like this: -class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler +bool wxBitmapHandler::LoadFile( + wxBitmap* WXUNUSED(pBitmap) +, int WXUNUSED(nId) +, long WXUNUSED(lType) +, int WXUNUSED(nDesiredWidth) +, int WXUNUSED(nDesiredHeight) +) { - DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler) -public: - inline wxBMPResourceHandler() - { - m_name = "Windows bitmap resource"; - m_extension = ""; - m_type = wxBITMAP_TYPE_BMP_RESOURCE; - }; + return false; +} + +bool wxBitmapHandler::LoadFile( + wxBitmap* WXUNUSED(pBitmap) +, const wxString& WXUNUSED(rName) +, long WXUNUSED(lType) +, int WXUNUSED(nDesiredWidth) +, int WXUNUSED(nDesiredHeight) +) +{ + return false; +} - virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, - int desiredWidth, int desiredHeight); -}; -IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler) -*/ +bool wxBitmapHandler::SaveFile( + wxBitmap* WXUNUSED(pBitmap) +, const wxString& WXUNUSED(rName) +, int WXUNUSED(nType) +, const wxPalette* WXUNUSED(pPalette) +) +{ + return false; +} -void wxBitmap::CleanUpHandlers() +// ---------------------------------------------------------------------------- +// Utility functions +// ---------------------------------------------------------------------------- +HBITMAP wxInvertMask( + HBITMAP hBmpMask +, int nWidth +, int nHeight +) { - wxNode *node = sm_handlers.First(); - while ( node ) + HBITMAP hBmpInvMask = 0; + + wxCHECK_MSG( hBmpMask, 0, _T("invalid bitmap in wxInvertMask") ); + + // + // Get width/height from the bitmap if not given + // + if (!nWidth || !nHeight) { - wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); - wxNode *next = node->Next(); - delete handler; - delete node; - node = next; + BITMAPINFOHEADER2 vBmhdr; + + ::GpiQueryBitmapInfoHeader( hBmpMask + ,&vBmhdr + ); + nWidth = (int)vBmhdr.cx; + nHeight = (int)vBmhdr.cy; } -} -void wxBitmap::InitStandardHandlers() + 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', 16); + vBmih.cbFix = 16; + vBmih.cx = nWidth; + vBmih.cy = nHeight; + vBmih.cPlanes = 1; + vBmih.cBitCount = 24; + + 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 + +HBITMAP wxFlipBmp( HBITMAP hBmp, int nWidth, int nHeight ) { -/* TODO: initialize all standard bitmap or derive class handlers here. - AddHandler(new wxBMPResourceHandler); - AddHandler(new wxBMPFileHandler); - AddHandler(new wxXPMFileHandler); - AddHandler(new wxXPMDataHandler); - AddHandler(new wxICOResourceHandler); - AddHandler(new wxICOFileHandler); -*/ -} + wxCHECK_MSG( hBmp, 0, _T("invalid bitmap in wxFlipBmp") ); + + // + // Get width/height from the bitmap if not given + // + if (!nWidth || !nHeight) + { + BITMAPINFOHEADER2 vBmhdr; + + vBmhdr.cbFix = 16; + ::GpiQueryBitmapInfoHeader( hBmp, + &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, nHeight}, + {nWidth, 0}, + {0, 0}, + {nWidth, nHeight} }; + + memset(&vBmih, '\0', 16); + vBmih.cbFix = 16; + vBmih.cx = nWidth; + vBmih.cy = nHeight; + vBmih.cPlanes = 1; + vBmih.cBitCount = 24; + + HBITMAP hInvBmp = ::GpiCreateBitmap( hPSDst, + &vBmih, + 0L, + NULL, + NULL ); + + ::GpiSetBitmap(hPSSrc, (HBITMAP) hBmp); + ::GpiSetBitmap(hPSDst, (HBITMAP) hInvBmp); + + ::GpiBitBlt( hPSDst, + hPSSrc, + 4L, + vPoint, + ROP_SRCCOPY, + BBO_IGNORE ); + + ::GpiDestroyPS(hPSSrc); + ::GpiDestroyPS(hPSDst); + ::DevCloseDC(hDCSrc); + ::DevCloseDC(hDCDst); + + return hInvBmp; +} // end of wxFlipBmp