/////////////////////////////////////////////////////////////////////////////
-// Name: bitmap.cpp
+// Name: src/os2/bitmap.cpp
// Purpose: wxBitmap
// Author: David Webster
// Modified by:
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
- #pragma implementation "bitmap.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
+#include "wx/bitmap.h"
+
#ifndef WX_PRECOMP
#include <stdio.h>
#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/dc.h"
#include "wx/os2/private.h"
-#include "wx/log.h"
-//#include "wx/msw/dib.h"
-#include "wx/image.h"
#include "wx/xpmdecod.h"
// ----------------------------------------------------------------------------
m_pSelectedInto = NULL;
m_nNumColors = 0;
m_pBitmapMask = NULL;
- m_hBitmap = (WXHBITMAP) NULL;
+ m_hBitmap = (WXHBITMAP) NULL;
} // end of wxBitmapRefData::wxBitmapRefData
+wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData &tocopy)
+{
+ m_nQuality = tocopy.m_nQuality;
+ m_pSelectedInto = NULL; // don't copy this
+ m_nNumColors = tocopy.m_nNumColors;
+
+ // copy the mask
+ if (tocopy.m_pBitmapMask)
+ m_pBitmapMask = new wxMask(*tocopy.m_pBitmapMask);
+
+ m_hBitmap = wxCopyBmp(tocopy.m_hBitmap);
+}
+
void wxBitmapRefData::Free()
{
if ( m_pSelectedInto )
{
- wxLogLastError("GpiDeleteBitmap(hbitmap)");
+ wxLogLastError(wxT("GpiDeleteBitmap(hbitmap)"));
}
if (m_hBitmap)
{
if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))
{
- wxLogLastError("GpiDeleteBitmap(hbitmap)");
+ wxLogLastError(wxT("GpiDeleteBitmap(hbitmap)"));
}
}
-
- delete m_pBitmapMask;
- m_pBitmapMask = NULL;
+ wxDELETE(m_pBitmapMask);
} // end of wxBitmapRefData::Free
// ----------------------------------------------------------------------------
// wxBitmap creation
// ----------------------------------------------------------------------------
+wxGDIRefData* wxBitmap::CloneGDIRefData(const wxGDIRefData* data) const
+{
+ return new wxBitmapRefData(*static_cast<const wxBitmapRefData *>(data));
+}
+
// this function should be called from all wxBitmap ctors
void wxBitmap::Init()
{
+ m_bIsMono = false;
+ //
+ // True for all bitmaps created from bits, wxImages, Xpms
+ //
} // end of wxBitmap::Init
-bool wxBitmap::CopyFromIconOrCursor(
- const wxGDIImage& rIcon
-)
+bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& rIcon)
{
HPOINTER hIcon = (HPOINTER)rIcon.GetHandle();
POINTERINFO SIconInfo;
if (!::WinQueryPointerInfo(hIcon, &SIconInfo))
{
wxLogLastError(wxT("WinQueryPointerInfo"));
- return FALSE;
+ return false;
}
wxBitmapRefData* pRefData = new wxBitmapRefData;
pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
- //
- // No mask in the Info struct in OS/2
- //
- return(TRUE);
+ wxMask* pMask = new wxMask(SIconInfo.hbmPointer);
+
+ pMask->SetMaskBitmap(GetHBITMAP());
+ SetMask(pMask);
+
+ return true;
} // end of wxBitmap::CopyFromIconOrCursor
bool wxBitmap::CopyFromCursor(
{
UnRef();
- if (!rCursor.Ok())
- return(FALSE);
+ if (!rCursor.IsOk())
+ return(false);
return(CopyFromIconOrCursor(rCursor));
} // end of wxBitmap::CopyFromCursor
{
UnRef();
- if (!rIcon.Ok())
- return(FALSE);
+ if (!rIcon.IsOk())
+ return(false);
return CopyFromIconOrCursor(rIcon);
} // end of wxBitmap::CopyFromIcon
hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
if (hPs == 0)
{
- wxLogLastError("GpiCreatePS Failure");
+ wxLogLastError(wxT("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!
+ // line is reversed!
//
const size_t nBytesPerLine = (nWidth + 7) / 8;
const size_t nPadding = nBytesPerLine % 2;
{
for (nCols = 0; nCols < nBytesPerLine; nCols++)
{
- unsigned char ucVal = *pzSrc++;
- unsigned char ucReversed = 0;
- int nBits;
+ unsigned char ucVal = *pzSrc++;
+ unsigned char ucReversed = 0;
+ int nBits;
for (nBits = 0; nBits < 8; nBits++)
{
ucReversed <<= 1;
- ucReversed |= (ucVal & 0x01);
+ ucReversed = (unsigned char)(ucReversed | (ucVal & 0x01));
ucVal >>= 1;
}
*pzDst++ = ucReversed;
vHeader.cx = (USHORT)nWidth;
vHeader.cy = (USHORT)nHeight;
vHeader.cPlanes = 1L;
- vHeader.cBitCount = nDepth;
+ vHeader.cBitCount = (USHORT)nDepth;
vHeader.usReserved = 0;
memset(&vInfo, '\0', 16);
vInfo.cx = (USHORT)nWidth;
vInfo.cy = (USHORT)nHeight;
vInfo.cPlanes = 1L;
- vInfo.cBitCount = nDepth;
+ vInfo.cBitCount = (USHORT)nDepth;
HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, CBM_INIT, (PBYTE)pzData, &vInfo);
if (!hBmp)
{
- wxLogLastError("CreateBitmap");
+ wxLogLastError(wxT("CreateBitmap"));
}
::GpiDestroyPS(hPs);
::DevCloseDC(hDc);
} // end of wxBitmap::wxBitmap
wxBitmap::wxBitmap(
- int nW
-, int nH
-, int nD
-)
-{
- Init();
-
- (void)Create( nW
- ,nH
- ,nD
- );
-} // end of wxBitmap::wxBitmap
-
-wxBitmap::wxBitmap(
- void* pData
-, long lType
+ const void* pData
+, wxBitmapType lType
, int nWidth
, int nHeight
, int nDepth
} // end of wxBitmap::wxBitmap
wxBitmap::wxBitmap(
- const wxString& rFilename
-, long lType
+ int nId
+, wxBitmapType lType
)
{
Init();
-
- LoadFile( rFilename
- ,(int)lType
+ LoadFile( nId
+ ,lType
);
+ SetId(nId);
} // end of wxBitmap::wxBitmap
bool wxBitmap::Create(
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};
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 = nD;
+ vHeader.cBitCount = 24; //nD;
hBmp = ::GpiCreateBitmap( hPS
,&vHeader
vHeader.cx = nW;
vHeader.cy = nH;
vHeader.cPlanes = 1;
- vHeader.cBitCount = lBitCount;
+ vHeader.cBitCount = (USHORT)lBitCount;
hBmp = ::GpiCreateBitmap( hPSScreen
,&vHeader
}
SetHBITMAP((WXHBITMAP)hBmp);
-#if WXWIN_COMPATIBILITY_2
- GetBitmapData()->m_bOk = hBmp != 0;
-#endif // WXWIN_COMPATIBILITY_2
-
- return Ok();
+ return IsOk();
} // end of wxBitmap::Create
-bool wxBitmap::CreateFromXpm(
- const char** ppData
-)
+bool wxBitmap::LoadFile(const wxString& filename, wxBitmapType type)
{
-#if wxUSE_IMAGE && wxUSE_XPM
- Init();
+ UnRef();
- wxCHECK_MSG(ppData != NULL, FALSE, wxT("invalid bitmap data"))
+ wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler);
- wxXPMDecoder vDecoder;
- wxImage vImg = vDecoder.ReadData(ppData);
+ if ( handler )
+ {
+ m_refData = new wxBitmapRefData;
- wxCHECK_MSG(vImg.Ok(), FALSE, wxT("invalid bitmap data"))
+ return handler->LoadFile(this, filename, type, -1, -1);
+ }
+#if wxUSE_IMAGE
+ else // no bitmap handler found
+ {
+ wxImage image;
+ if ( image.LoadFile( filename, type ) && image.IsOk() )
+ {
+ *this = wxBitmap(image);
- *this = wxBitmap(vImg);
- return TRUE;
-#else
- return FALSE;
-#endif
-} // end of wxBitmap::CreateFromXpm
+ return true;
+ }
+ }
+#endif // wxUSE_IMAGE
+
+ return false;
+}
bool wxBitmap::LoadFile(
- const wxString& rFilename
-, long lType
+ int nId
+, wxBitmapType lType
)
{
- HPS hPs = NULLHANDLE;
-
UnRef();
wxBitmapHandler* pHandler = wxDynamicCast( FindHandler(lType)
m_refData = new wxBitmapRefData;
return(pHandler->LoadFile( this
- ,rFilename
- ,hPs
+ ,nId
,lType
, -1
, -1
}
else
{
- wxImage vImage;
-
- if (!vImage.LoadFile(rFilename, lType) || !vImage.Ok() )
- return(FALSE);
-
- *this = wxBitmap(vImage);
-
- return(TRUE);
+ return false;
}
} // end of wxBitmap::LoadFile
bool wxBitmap::Create(
- void* pData
-, long lType
+ const void* pData
+, wxBitmapType lType
, int nWidth
, int nHeight
, int nDepth
if (!pHandler)
{
- wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
- "type %d defined."), lType);
+ wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %ld defined."), lType);
- return(FALSE);
+ return false;
}
m_refData = new wxBitmapRefData;
bool wxBitmap::SaveFile(
const wxString& rFilename
-, int lType
+, wxBitmapType lType
, const wxPalette* pPalette
)
{
// FIXME what about palette? shouldn't we use it?
wxImage vImage = ConvertToImage();
- if (!vImage.Ok())
- return(FALSE);
+ if (!vImage.IsOk())
+ return false;
return(vImage.SaveFile( rFilename
,lType
// ----------------------------------------------------------------------------
-// wxImage-wxBitmap convertion
+// wxImage-wxBitmap conversion
// ----------------------------------------------------------------------------
bool wxBitmap::CreateFromImage (
, int nDepth
)
{
- wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
+ wxCHECK_MSG(rImage.IsOk(), false, wxT("invalid image"));
m_refData = new wxBitmapRefData();
-
int nSizeLimit = 1024 * 768 * 3;
int nWidth = rImage.GetWidth();
int nBmpHeight = rImage.GetHeight();
//
// Set bitmap parameters
//
- wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
+ wxCHECK_MSG(rImage.IsOk(), false, wxT("invalid image"));
SetWidth(nWidth);
SetHeight(nBmpHeight);
+ if (nDepth == 1)
+ m_bIsMono = true;
+ else
+ m_bIsMono = false;
if (nDepth == -1)
nDepth = wxDisplayDepth();
SetDepth(nDepth);
//
BITMAPINFOHEADER2 vHeader;
BITMAPINFO2 vInfo;
- LONG alFormats[24]; // Max formats OS/2 PM supports
- ULONG ulBitcount;
//
// Fill in the DIB header
if(!pucBits)
{
wxFAIL_MSG(wxT("could not allocate memory for DIB"));
- return FALSE;
+ return false;
}
+ memset(pucBits, '\0', (nBytePerLine * nHeight));
//
// Create and set the device-dependent bitmap
HBITMAP hBmp;
HBITMAP hBmpOld;
- ::GpiQueryDeviceBitmapFormats(hPS, 24, alFormats);
- ulBitcount = alFormats[1]; // the best one for the device
- if (ulBitcount > 24)
- ulBitcount = 24; // MAX bits supported by PM
memset(&vInfo, '\0', 16);
vInfo.cbFix = 16;
vInfo.cx = (ULONG)nWidth;
vInfo.cy = (ULONG)nHeight;
vInfo.cPlanes = 1;
- vInfo.cBitCount = ulBitcount;
+ vInfo.cBitCount = 24; // Set to desired count going in
hBmp = ::GpiCreateBitmap( hPS
,&vHeader
,NULL
,NULL
);
- hBmpOld = ::GpiSetBitmap(hPS, hBmp);
#if wxUSE_PALETTE
HPAL hOldPalette = NULLHANDLE;
- if (rImage.GetPalette().Ok())
+ if (rImage.GetPalette().IsOk())
{
hOldPalette = ::GpiSelectPalette(hPS, (HPAL)rImage.GetPalette().GetHPALETTE());
}
unsigned char* ptdata = pData;
unsigned char* ptbits;
+ if ((hBmpOld = ::GpiSetBitmap(hPS, hBmp)) == HBM_ERROR)
+ {
+ ERRORID vError;
+ wxString sError;
+
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ }
for (n = 0; n < nNumDIB; n++)
{
if (nNumDIB > 1 && n == nNumDIB - 1 && nHRemain > 0)
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
+ POINTL vPoint[4] = { {0, nOrigin},
+ {nWidth, nHeight},
+ {0, 0}, {nWidth, nHeight}
};
//
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))
+ unsigned char cRedImage = (*(ptdata++)) ;
+ unsigned char cGreenImage = (*(ptdata++)) ;
+ unsigned char cBlueImage = (*(ptdata++)) ;
+
+ if ((cRedImage != cRed) || (cGreenImage != cGreen) || (cBlueImage != cBlue))
{
*(ptbits++) = cOne;
*(ptbits++) = cOne;
,&vSize
,PU_PELS | GPIA_ASSOC
);
- POINTL vPoint2[4] = { 0, nOrigin,
- nWidth, nHeight,
- 0, 0, nWidth, nHeight
+ POINTL vPoint2[4] = { {0, nOrigin},
+ {nWidth, nHeight},
+ {0, 0}, {nWidth, nHeight}
};
::GpiBitBlt( hPSScreen
,hPS
::DevCloseDC(hDCScreen);
::DevCloseDC(hDC);
free(pucBits);
- return TRUE;
+ return true;
} // end of wxBitmap::CreateFromImage
wxImage wxBitmap::ConvertToImage() const
wxImage vImage;
wxDC* pDC;
- wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid bitmap") );
//
// Create an wxImage object
BITMAPINFOHEADER2 vDIBh;
BITMAPINFO2 vDIBInfo;
HPS hPSMem;
- HPS hPS;
HBITMAP hBitmap;
HBITMAP hOldBitmap;
DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
SIZEL vSizlPage = {0,0};
- HDC hDCMem;
- LONG alFormats[24]; // 24 is MAX formats supported
- ULONG ulBitcount;
-
- ::GpiQueryDeviceBitmapFormats(hPS, 24, alFormats);
- ulBitcount = alFormats[1]; // the best one
- if (ulBitcount > 24) // PM supports a max of 24
- ulBitcount = 24;
+ HDC hDCMem = NULLHANDLE;
+
vImage.Create( nWidth
,nHeight
);
vDIBInfo.cx = nWidth;
vDIBInfo.cy = nHeight;
vDIBInfo.cPlanes = 1;
- vDIBInfo.cBitCount = ulBitcount;
+ vDIBInfo.cBitCount = 24;
lpBits = (unsigned char *)malloc(nBytePerLine * nHeight);
if (!lpBits)
free(pData);
return wxNullImage;
}
+ memset(lpBits, '\0', (nBytePerLine * nHeight));
+ hBitmap = (HBITMAP)GetHBITMAP();
//
// May already be selected into a PS
//
- if ((pDC = GetSelectedInto()) != NULL)
+ pDC = GetSelectedInto();
+ const wxPMDCImpl *impl;
+ if (pDC != NULL &&
+ (impl = wxDynamicCast( pDC->GetImpl(), wxPMDCImpl )) != NULL)
{
- hPSMem = pDC->GetHPS();
+ hPSMem = impl->GetHPS();
}
else
{
,&vSizlPage
,PU_PELS | GPIA_ASSOC
);
- hBitmap = (HBITMAP)GetHBITMAP();
- if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR)
- {
- ERRORID vError;
- wxString sError;
+ }
+ if ((hOldBitmap = ::GpiSetBitmap(hPSMem, hBitmap)) == HBM_ERROR)
+ {
+ ERRORID vError;
+ wxString sError;
- vError = ::WinGetLastError(vHabmain);
- sError = wxPMErrorToStr(vError);
- }
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
}
//
,ucGreen
,ucBlue
);
- vImage.SetMask(TRUE);
+ vImage.SetMask(true);
}
else
{
- vImage.SetMask(FALSE);
+ vImage.SetMask(false);
}
//
const wxRect& rRect
) const
{
- wxCHECK_MSG( Ok() &&
+ wxCHECK_MSG( IsOk() &&
(rRect.x >= 0) && (rRect.y >= 0) &&
(rRect.x + rRect.width <= GetWidth()) &&
(rRect.y + rRect.height <= GetHeight()),
,rRect.height
,GetDepth()
);
- wxASSERT_MSG( vRet.Ok(), wxT("GetSubBitmap error") );
+ wxASSERT_MSG( vRet.IsOk(), wxT("GetSubBitmap error") );
//
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
+ 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());
vBmih.cx = rRect.width;
vBmih.cy = rRect.height;
vBmih.cPlanes = 1;
- vBmih.cBitCount = 1;
+ vBmih.cBitCount = 24;
HBITMAP hBmpMask = ::GpiCreateBitmap( hPSDst
,&vBmih
GetBitmapData()->m_nQuality = nQ;
} // end of wxBitmap::SetQuality
-#if WXWIN_COMPATIBILITY_2
-void wxBitmap::SetOk(
- bool bOk
-)
-{
- EnsureHasData();
-
- GetBitmapData()->m_bOk = bOk;
-} // end of wxBitmap::SetOk
-#endif // WXWIN_COMPATIBILITY_2
-
void wxBitmap::SetPalette(
const wxPalette& rPalette
)
GetBitmapData()->m_pBitmapMask = pMask;
} // end of wxBitmap::SetMask
-wxBitmap wxBitmap::GetBitmapForDC(
- wxDC& rDc
-) const
+wxBitmap wxBitmap::GetBitmapForDC(wxDC& WXUNUSED(rDc)) const
{
return(*this);
} // end of wxBitmap::GetBitmapForDC
m_hMaskBitmap = 0;
} // end of wxMask::wxMask
+wxMask::wxMask(const wxMask& tocopy)
+{
+ m_hMaskBitmap = wxCopyBmp(tocopy.m_hMaskBitmap);
+} // end of wxMask::wxMask
+
// Construct a mask from a bitmap and a colour indicating
// the transparent area
wxMask::wxMask(
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()
+ 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)
+ if (!rBitmap.IsOk() || rBitmap.GetDepth() != 1)
{
- return(FALSE);
+ return false;
}
memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
vBmih.cx = rBitmap.GetWidth();
vBmih.cy = rBitmap.GetHeight();
vBmih.cPlanes = 1;
- vBmih.cBitCount = 1;
+ vBmih.cBitCount = 24;
m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
,&vBmih
::GpiDestroyPS(hPSDst);
::DevCloseDC(hDCSrc);
::DevCloseDC(hDCDst);
- return(TRUE);
+ return true;
} // end of wxMask::Create
// Create a mask from a bitmap and a palette index indicating
::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
m_hMaskBitmap = 0;
}
- if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())
+ if (rBitmap.IsOk() && rBitmap.GetPalette()->IsOk())
{
unsigned char cRed;
unsigned char cGreen;
));
}
}
- return(FALSE);
+ return false;
} // end of wxMask::Create
// Create a mask from a bitmap and a colour indicating
, const wxColour& rColour
)
{
- bool bOk = TRUE;
+ bool bOk = true;
COLORREF vMaskColour = OS2RGB( rColour.Red()
,rColour.Green()
,rColour.Blue()
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())
+ if (!rBitmap.IsOk())
{
- return(FALSE);
+ return false;
}
//
//
// Doesn't make sense to continue
//
- bOk = FALSE;
+ bOk = false;
break;
}
::GpiDestroyPS(hPSDst);
::DevCloseDC(hDCSrc);
::DevCloseDC(hDCDst);
- return(TRUE);
+ return true;
} // end of wxMask::Create
// ----------------------------------------------------------------------------
// wxBitmapHandler
// ----------------------------------------------------------------------------
-bool wxBitmapHandler::Create(
- wxGDIImage* pImage
-, void* pData
-, long lFlags
-, int nWidth
-, int nHeight
-, int nDepth
-)
+bool wxBitmapHandler::Create( wxGDIImage* pImage,
+ const void* pData,
+ wxBitmapType lType,
+ int nWidth,
+ int nHeight,
+ int nDepth)
{
- wxBitmap* pBitmap = wxDynamicCast( pImage
- ,wxBitmap
- );
+ wxBitmap* pBitmap = wxDynamicCast( pImage
+ ,wxBitmap
+ );
return(pBitmap ? Create( pBitmap
,pData
+ ,lType
,nWidth
,nHeight
,nDepth
- ) : FALSE);
+ ) : false);
}
bool wxBitmapHandler::Load(
wxGDIImage* pImage
-, const wxString& rName
-, HPS hPs
-, long lFlags
+, int nId
+, wxBitmapType lFlags
, int nWidth
, int nHeight
)
);
return(pBitmap ? LoadFile( pBitmap
- ,rName
- ,hPs
+ ,nId
,lFlags
,nWidth
,nHeight
- ) : FALSE);
+ ) : false);
}
bool wxBitmapHandler::Save(
- wxGDIImage* pImage
+ const wxGDIImage* pImage
, const wxString& rName
-, int lType
-)
+, wxBitmapType lType
+) const
{
wxBitmap* pBitmap = wxDynamicCast( pImage
,wxBitmap
return(pBitmap ? SaveFile( pBitmap
,rName
,lType
- ) : FALSE);
+ ) : false);
}
bool wxBitmapHandler::Create(
wxBitmap* WXUNUSED(pBitmap)
-, void* WXUNUSED(pData)
-, long WXUNUSED(lType)
+, const void* WXUNUSED(pData)
+, wxBitmapType WXUNUSED(lType)
, int WXUNUSED(nWidth)
, int WXUNUSED(nHeight)
, int WXUNUSED(nDepth)
)
{
- return(FALSE);
+ return false;
+}
+
+bool wxBitmapHandler::LoadFile(
+ wxBitmap* WXUNUSED(pBitmap)
+, int WXUNUSED(nId)
+, wxBitmapType WXUNUSED(lType)
+, int WXUNUSED(nDesiredWidth)
+, int WXUNUSED(nDesiredHeight)
+)
+{
+ return false;
}
bool wxBitmapHandler::LoadFile(
wxBitmap* WXUNUSED(pBitmap)
, const wxString& WXUNUSED(rName)
-, HPS WXUNUSED(hPs)
-, long WXUNUSED(lType)
+, wxBitmapType WXUNUSED(lType)
, int WXUNUSED(nDesiredWidth)
, int WXUNUSED(nDesiredHeight)
)
{
- return(FALSE);
+ return false;
}
bool wxBitmapHandler::SaveFile(
wxBitmap* WXUNUSED(pBitmap)
, const wxString& WXUNUSED(rName)
-, int WXUNUSED(nType)
+, wxBitmapType WXUNUSED(nType)
, const wxPalette* WXUNUSED(pPalette)
-)
+) const
{
- return(FALSE);
+ return false;
}
// ----------------------------------------------------------------------------
{
HBITMAP hBmpInvMask = 0;
- wxCHECK_MSG( hBmpMask, 0, _T("invalid bitmap in wxInvertMask") );
+ wxCHECK_MSG( hBmpMask, 0, wxT("invalid bitmap in wxInvertMask") );
//
// Get width/height from the bitmap if not given
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
+ POINTL vPoint[4] = { {0 ,0}, {nWidth, nHeight},
+ {0, 0}, {nWidth, nHeight}
};
- memset(&vBmih, '\0', sizeof(BITMAPINFOHEADER2));
- vBmih.cbFix = sizeof(BITMAPINFOHEADER2);
+ memset(&vBmih, '\0', 16);
+ vBmih.cbFix = 16;
vBmih.cx = nWidth;
vBmih.cy = nHeight;
vBmih.cPlanes = 1;
- vBmih.cBitCount = 1;
+ vBmih.cBitCount = 24;
hBmpInvMask = ::GpiCreateBitmap( hPSDst
,&vBmih
return hBmpInvMask;
} // end of WxWinGdi_InvertMask
+HBITMAP wxCopyBmp( HBITMAP hBmp, bool flip, int nWidth, int nHeight )
+{
+ wxCHECK_MSG( hBmp, 0, wxT("invalid bitmap in wxCopyBmp") );
+
+ //
+ // 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} };
+ if (!flip)
+ {
+ vPoint[0].y = 0;
+ vPoint[1].y = 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
projects / wxWidgets.git / blobdiff