m_pSelectedInto = NULL;
m_nNumColors = 0;
m_pBitmapMask = NULL;
- m_hBitmap = (WXHBITMAP) NULL;
+ m_hBitmap = (WXHBITMAP) NULL;
} // end of wxBitmapRefData::wxBitmapRefData
void wxBitmapRefData::Free()
{
- wxASSERT_MSG( !m_pSelectedInto,
- wxT("deleting bitmap still selected into wxMemoryDC") );
-
+ if ( m_pSelectedInto )
+ {
+ wxLogLastError("GpiDeleteBitmap(hbitmap)");
+ }
if (m_hBitmap)
{
if (!::GpiDeleteBitmap((HBITMAP)m_hBitmap))
wxLogLastError("GpiDeleteBitmap(hbitmap)");
}
}
-
- delete m_pBitmapMask;
- m_pBitmapMask = NULL;
+ if (m_pBitmapMask)
+ {
+ delete m_pBitmapMask;
+ m_pBitmapMask = NULL;
+ }
} // end of wxBitmapRefData::Free
// ----------------------------------------------------------------------------
// 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(
pRefData->m_hBitmap = (WXHBITMAP)SIconInfo.hbmColor;
- //
- // No mask in the Info struct in OS/2
- //
+ wxMask* pMask = new wxMask(SIconInfo.hbmPointer);
+
+ pMask->SetMaskBitmap(GetHBITMAP());
+ SetMask(pMask);
+
return(TRUE);
} // end of wxBitmap::CopyFromIconOrCursor
pRefData->m_nNumColors = 0;
pRefData->m_pSelectedInto = NULL;
- hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
+ hDc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
if (hPs == 0)
{
pzData = (char *)zBits; // const_cast is harmless
}
- memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
- vHeader.cbFix = sizeof(vHeader);
+ 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 = nDepth;
vHeader.usReserved = 0;
- vHeader.ulCompression = BCA_UNCOMP;
- vHeader.usRecording = BRA_BOTTOMUP;
- vHeader.usRendering = BRH_NOTHALFTONED;
- vHeader.ulColorEncoding = BCE_RGB;
- vHeader.ulIdentifier = 0;
-
- memset(&vInfo, '\0', sizeof(BITMAPINFO2));
- vInfo.cbFix = sizeof(vInfo);
+
+ memset(&vInfo, '\0', 16);
+ vInfo.cbFix = 16;
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);
{
wxLogLastError("CreateBitmap");
}
- ::WinReleasePS(hPs);
+ ::GpiDestroyPS(hPs);
+ ::DevCloseDC(hDc);
SetHBITMAP((WXHBITMAP)hBmp);
} // end of wxBitmap::wxBitmap
)
{
Init();
-
(void)Create( nW
,nH
,nD
} // end of wxBitmap::wxBitmap
wxBitmap::wxBitmap(
- const wxString& rFilename
+ int nId
, long lType
)
{
Init();
-
- LoadFile( rFilename
+ LoadFile( nId
,(int)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);
- memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
- vHeader.cbFix = sizeof(BITMAPINFOHEADER2);
+ 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
hDCScreen = ::GpiQueryDevice(hPSScreen);
::DevQueryCaps(hDCScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
- memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
- vHeader.cbFix = sizeof(BITMAPINFOHEADER2);
+ if (lBitCount > 24)
+ lBitCount = 24;
+
+ memset(&vHeader, '\0', 16);
+ vHeader.cbFix = 16;
vHeader.cx = nW;
vHeader.cy = nH;
vHeader.cPlanes = 1;
}
SetHBITMAP((WXHBITMAP)hBmp);
-#if WXWIN_COMPATIBILITY_2
- GetBitmapData()->m_bOk = hBmp != 0;
-#endif // WXWIN_COMPATIBILITY_2
-
return Ok();
} // end of wxBitmap::Create
} // end of wxBitmap::CreateFromXpm
bool wxBitmap::LoadFile(
- const wxString& rFilename
+ int nId
, long 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
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);
}
// ----------------------------------------------------------------------------
-// wxImage-wxBitmap convertion
+// wxImage-wxBitmap conversion
// ----------------------------------------------------------------------------
bool wxBitmap::CreateFromImage (
)
{
wxCHECK_MSG(rImage.Ok(), FALSE, wxT("invalid image"));
+ m_refData = new wxBitmapRefData();
int nSizeLimit = 1024 * 768 * 3;
- int nWidth = GetWidth();
- int nBmpHeight = GetHeight();
+ int nWidth = rImage.GetWidth();
+ int nBmpHeight = rImage.GetHeight();
int nBytePerLine = nWidth * 3;
int nSizeDWORD = sizeof(DWORD);
int nLineBoundary = nBytePerLine % nSizeDWORD;
wxCHECK_MSG(rImage.Ok(), 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);
// Create a DIB header
//
BITMAPINFOHEADER2 vHeader;
+ BITMAPINFO2 vInfo;
//
// Fill in the DIB header
//
- memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
- vHeader.cbFix = sizeof(vHeader);
- vHeader.cx = (USHORT)nWidth;
- vHeader.cy = (USHORT)nHeight;
+ memset(&vHeader, '\0', 16);
+ vHeader.cbFix = 16;
+ vHeader.cx = (ULONG)nWidth;
+ vHeader.cy = (ULONG)nHeight;
vHeader.cPlanes = 1L;
vHeader.cBitCount = 24;
- vHeader.ulCompression = BCA_UNCOMP;
- vHeader.cbImage = nBytePerLine * nHeight;
- vHeader.cclrUsed = 0;
-
- //
- // 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;
//
// Memory for DIB data
//
unsigned char* pucBits;
- pucBits = (unsigned char *)malloc(vHeader.cbImage);
+ 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
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
);
- hBmpOld = ::GpiSetBitmap(hPS, hBmp);
#if wxUSE_PALETTE
HPAL hOldPalette = NULLHANDLE;
if (rImage.GetPalette().Ok())
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)
//
// Have to do something similar to WIN32's StretchDIBits, use GpiBitBlt
+ // in combination with setting the bits into the selected bitmap
//
- POINTL vPoint[4] = { 0, nOrigin,
- nWidth, nHeight,
- 0, 0, nWidth, nHeight
+ 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( hPS
+
+ ::GpiBitBlt( hPSScreen
,hPS
,4
,vPoint
,ROP_SRCCOPY
,BBO_IGNORE
);
+ ::GpiDestroyPS(hPSScreen);
nOrigin += nHeight;
}
SetHBITMAP((WXHBITMAP)hBmp);
//
if (rImage.HasMask())
{
- memset(&vHeader, '\0', sizeof(BITMAPINFOHEADER2));
- vHeader.cbFix = sizeof(BITMAPINFOHEADER2);
+ vHeader.cbFix = 16;
vHeader.cx = nWidth;
vHeader.cy = nHeight;
vHeader.cPlanes = 1;
- vHeader.cBitCount = 1;
+ vHeader.cBitCount = 24;
hBmp = ::GpiCreateBitmap( hPS
,&vHeader
,0L
else
nHeight = nSizeLimit / nBytePerLine;
vHeader.cy = (DWORD)(nHeight);
- vHeader.cbImage = nBytePerLine * nHeight;
nOrigin = 0;
unsigned char cRed = rImage.GetMaskRed();
{
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;
for (i = 0; i < nPadding; i++)
*(ptbits++) = cZero;
}
- POINTL vPoint[4] = { 0, nOrigin,
- nWidth, nHeight,
- 0, 0, nWidth, nHeight
- };
-
- ::GpiBitBlt( hPS
+ 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
- ,vPoint
+ ,vPoint2
,ROP_SRCCOPY
,BBO_IGNORE
- );
+ );
+ ::GpiDestroyPS(hPSScreen);
nOrigin += nHeight;
}
pMask->SetMaskBitmap((WXHBITMAP)hBmp);
SetMask(pMask);
- hBmpOld = ::GpiSetBitmap(hPS, hBmp);
+ hBmpOld = ::GpiSetBitmap(hPS, hBmpOld);
}
//
//
::GpiSetBitmap(hPS, NULLHANDLE);
::GpiDestroyPS(hPS);
+ ::DevCloseDC(hDCScreen);
::DevCloseDC(hDC);
free(pucBits);
return TRUE;
wxImage wxBitmap::ConvertToImage() const
{
wxImage vImage;
+ wxDC* pDC;
wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
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;
+ HBITMAP hOldBitmap;
+ DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+ SIZEL vSizlPage = {0,0};
+ HDC hDCMem;
vImage.Create( nWidth
,nHeight
//
// Create and fill a DIB header
//
- memset(&vDIBh, '\0', sizeof(BITMAPINFOHEADER2));
- vDIBh.cbFix = sizeof(BITMAPINFOHEADER2);
+ memset(&vDIBh, '\0', 16);
+ vDIBh.cbFix = 16;
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);
+ memset(&vDIBInfo, '\0', 16);
+ vDIBInfo.cbFix = 16;
+ vDIBInfo.cx = nWidth;
+ vDIBInfo.cy = nHeight;
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);
+
+ 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();
+
+ //
+ // May already be selected into a PS
+ //
+ if ((pDC = GetSelectedInto()) != NULL)
+ {
+ hPSMem = pDC->GetHPS();
+ }
+ 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;
+
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ }
//
// 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
- );
+ if ((lScans = ::GpiQueryBitmapBits( hPSMem
+ ,0L
+ ,(LONG)nHeight
+ ,(PBYTE)lpBits
+ ,&vDIBInfo
+ )) == GPI_ALTERROR)
+ {
+ ERRORID vError;
+ wxString sError;
+
+ vError = ::WinGetLastError(vHabmain);
+ sError = wxPMErrorToStr(vError);
+ }
//
// Copy DIB data into the wxImage object
}
ptbits += nPadding;
}
+ if ((pDC = GetSelectedInto()) == NULL)
+ {
+ ::GpiSetBitmap(hPSMem, NULLHANDLE);
+ ::GpiDestroyPS(hPSMem);
+ ::DevCloseDC(hDCMem);
+ }
//
// Similarly, set data according to the possible mask bitmap
//
// Memory DC/PS created, color set, data copied, and memory DC/PS deleted
//
- HDC hMemDC = ::DevOpenDC( vHabmain
- ,OD_MEMORY
- ,"*"
- ,4
- ,(PDEVOPENDATA)pszData
- ,NULLHANDLE
- );
+ HDC hMemDC = ::DevOpenDC( vHabmain
+ ,OD_MEMORY
+ ,"*"
+ ,5L
+ ,(PDEVOPENDATA)&vDop
+ ,NULLHANDLE
+ );
HPS hMemPS = ::GpiCreatePS( vHabmain
,hMemDC
,&vSizlPage
- ,PU_PELS | GPIA_ASSOC | GPIT_MICRO
+ ,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);
//
// Free allocated resources
//
- ::GpiDestroyPS(hPSMem);
- ::DevCloseDC(hDCMem);
free(lpBits);
return vImage;
} // end of wxBitmap::ConvertToImage
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()
+ 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
)
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)
vBmih.cx = rBitmap.GetWidth();
vBmih.cy = rBitmap.GetHeight();
vBmih.cPlanes = 1;
- vBmih.cBitCount = 1;
+ vBmih.cBitCount = 24;
m_hMaskBitmap = ::GpiCreateBitmap( hPSDst
,&vBmih
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)
{
bool wxBitmapHandler::Load(
wxGDIImage* pImage
-, const wxString& rName
-, HPS hPs
+, int nId
, long lFlags
, int nWidth
, int nHeight
);
return(pBitmap ? LoadFile( pBitmap
- ,rName
- ,hPs
+ ,nId
,lFlags
,nWidth
,nHeight
bool wxBitmapHandler::LoadFile(
wxBitmap* WXUNUSED(pBitmap)
-, const wxString& WXUNUSED(rName)
-, HPS WXUNUSED(hPs)
+, int WXUNUSED(nId)
, long WXUNUSED(lType)
, int WXUNUSED(nDesiredWidth)
, int WXUNUSED(nDesiredHeight)
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
projects / wxWidgets.git / blobdiff