// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
+#ifdef __GNUG__
+ #pragma implementation "bitmap.h"
+#endif
+
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
// macros
// ----------------------------------------------------------------------------
-#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
-#endif
// ============================================================================
// implementation
m_refData = pRefData;
- refData->m_width = rIcon.GetWidth();
- refData->m_height = rIcon.GetHeight();
- refData->m_depth = wxDisplayDepth();
+ pRefData->m_nWidth = rIcon.GetWidth();
+ pRefData->m_nHeight = rIcon.GetHeight();
+ pRefData->m_nDepth = wxDisplayDepth();
- refData->m_hBitmap = (WXHBITMAP)rIcon.GetHandle();
+ pRefData->m_hBitmap = (WXHBITMAP)rIcon.GetHandle();
// no mask???
- refData->m_bitmapMask = new wxMask();
+ pRefData->m_pBitmapMask = new wxMask();
#if WXWIN_COMPATIBILITY_2
- refData->m_ok = TRUE;
+ pRefData->m_bOk = TRUE;
#endif // WXWIN_COMPATIBILITY_2
-
return(TRUE);
}
if (!rCursor.Ok())
return(FALSE);
- return CopyFromIconOrCursor(wxGDIImage)rCursor);
+ return(CopyFromIconOrCursor(rCursor));
}
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);
}
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};
- wxAssert(vHabmain != NULL);
+ wxASSERT(vHabmain != NULL);
hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
vHeader.ulColorEncoding = 0;
vHeader.ulIdentifier = 0;
- vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS);
- if (vhPs == 0)
+ hPs = ::GpiCreatePS(vHabmain, hDc, &vSize, GPIA_ASSOC | PU_PELS);
+ if (hPs == 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;
+ pRefData->m_nWidth = nTheWidth;
+ pRefData->m_nHeight = nTheHeight;
+ pRefData->m_nDepth = nNoBits;
+ pRefData->m_nNumColors = 0;
+ pRefData->m_pSelectedInto = NULL;
HBITMAP hBmp = ::GpiCreateBitmap(hPs, &vHeader, 0L, NULL, &vInfo);
- if ( !hbmp )
+ if (!hBmp)
{
wxLogLastError("CreateBitmap");
}
- SetHBITMAP((WXHBITMAP)hbmp);
+ SetHBITMAP((WXHBITMAP)hBmp);
}
// Create from XPM data
{
Init();
-F (void)Create( (void *)ppData
+ (void)Create( (void *)ppData
,wxBITMAP_TYPE_XPM_DATA
,0
,0
HBITMAP hBmp;
BITMAPINFOHEADER2 vHeader;
BITMAPINFO2 vInfo;
- HDC hDc;
- HPS hPs;
- DEVOPENSTRUCT vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+ HPS hpsScreen;
+ HDC hdcScreen;
+ DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
SIZEL vSize = {0, 0};
+ LONG lBitCount;
- wxAssert(vHabmain != NULL);
+ wxASSERT(vHabmain != NULL);
- hDc = ::DevOpenDC(vHabmain, OD_MEMORY, (PSZ)"*", 1L, (PDEVOPENDATA)&vDop, 0L);
+ hpsScreen = ::WinGetScreenPS(HWND_DESKTOP);
+ hdcScreen = ::GpiQueryDevice(hpsScreen);
+ ::DevQueryCaps(hdcScreen, CAPS_COLOR_BITCOUNT, 1L, &lBitCount);
vHeader.cbFix = sizeof(vHeader);
vHeader.cx = (USHORT)nW;
vHeader.cy = (USHORT)nH;
vHeader.cPlanes = (USHORT)nD;
- vHeader.cBitCount = 24;
+ vHeader.cBitCount = lBitCount;
vHeader.ulCompression = BCA_UNCOMP;
vHeader.cxResolution = 0;
vHeader.cyResolution = 0;
vHeader.ulColorEncoding = 0;
vHeader.ulIdentifier = 0;
- vhPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS);
- if (vhPs == 0)
- {
- wxLogLastError("GpiCreatePS Failure");
- }
-
-
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);
+ hBmp = ::GpiCreateBitmap(hpsScreen, &vHeader, 0L, NULL, &vInfo);
if (!hBmp)
{
wxLogLastError("CreateBitmap");
}
else
{
- ScreenHDC dc;
- hbmp = ::CreateCompatibleBitmap(dc, w, h);
- if ( !hbmp )
+ LONG lPlanes;
+
+ ::DevQueryCaps(hdcScreen, CAPS_COLOR_PLANES, 1L, &lPlanes);
+ hBmp = ::GpiCreateBitmap(hpsScreen, &vHeader, 0L, NULL, &vInfo);
+ if (!hBmp)
{
- wxLogLastError("CreateCompatibleBitmap");
+ wxLogLastError("CreateBitmap");
}
-
- GetBitmapData()->m_depth = wxDisplayDepth();
+ GetBitmapData()->m_nDepth = wxDisplayDepth();
}
-
- 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();
}
-bool wxBitmap::LoadFile(const wxString& filename, long type)
+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 = vImage.ConvertToBitmap();
+
+ return(TRUE);
}
}
-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
+ ));
}
-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(*this);
+
+ if (!vImage.Ok())
+ return(FALSE);
- return image.SaveFile( filename, type );
+ return(vImage.SaveFile( rFilename
+ ,lType
+ ));
}
}
// wxBitmap accessors
// ----------------------------------------------------------------------------
-void wxBitmap::SetQuality(int q)
+void wxBitmap::SetQuality(
+ int nQ
+)
{
EnsureHasData();
- GetBitmapData()->m_quality = q;
+ GetBitmapData()->m_nQuality = nQ;
}
#if WXWIN_COMPATIBILITY_2
-void wxBitmap::SetOk(bool isOk)
+void wxBitmap::SetOk(
+ bool bOk
+)
{
EnsureHasData();
- GetBitmapData()->m_ok = isOk;
+ GetBitmapData()->m_bOk = bOk;
}
#endif // WXWIN_COMPATIBILITY_2
-void wxBitmap::SetPalette(const wxPalette& palette)
+void wxBitmap::SetPalette(
+ const wxPalette& rPalette
+)
{
EnsureHasData();
- GetBitmapData()->m_bitmapPalette = palette;
+ GetBitmapData()->m_vBitmapPalette = rPalette;
}
-void wxBitmap::SetMask(wxMask *mask)
+void wxBitmap::SetMask(
+ wxMask* pMask
+)
{
EnsureHasData();
- GetBitmapData()->m_bitmapMask = mask;
+ GetBitmapData()->m_pBitmapMask = pMask;
}
-// 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 <frederic.villeneuve@natinst.com>
-wxBitmap wxBitmap::GetBitmapForDC(wxDC& dc) const
+// Will try something for OS/2 but not really sure how close
+// to the msw intent this is.
+wxBitmap wxBitmap::GetBitmapForDC(
+ wxDC& rDc
+) const
{
- wxMemoryDC memDC;
- wxBitmap tmpBitmap(this->GetWidth(), this->GetHeight(), dc.GetDepth());
- HPALETTE hPal = (HPALETTE) NULL;
- LPBITMAPINFO lpDib;
- void *lpBits = (void*) NULL;
-
- if( GetPalette() && GetPalette()->Ok() )
- {
- tmpBitmap.SetPalette(*GetPalette());
- memDC.SelectObject(tmpBitmap);
- memDC.SetPalette(*GetPalette());
- hPal = (HPALETTE)GetPalette()->GetHPALETTE();
- }
- else
- {
- hPal = (HPALETTE) ::GetStockObject(DEFAULT_PALETTE);
- wxPalette palette;
- palette.SetHPALETTE( (WXHPALETTE)hPal );
- tmpBitmap.SetPalette( palette );
- memDC.SelectObject(tmpBitmap);
- memDC.SetPalette( palette );
- }
-
- // set the height negative because in a DIB the order of the lines is
- // reversed
- if ( !wxCreateDIB(GetWidth(), -GetHeight(), GetDepth(), hPal, &lpDib) )
- {
- return wxNullBitmap;
- }
-
- lpBits = malloc(lpDib->bmiHeader.biSizeImage);
-
- ::GetBitmapBits(GetHbitmap(), lpDib->bmiHeader.biSizeImage, lpBits);
+ wxMemoryDC vMemDC;
+ wxBitmap vTmpBitmap( this->GetWidth()
+ ,this->GetHeight()
+ ,rDc.GetDepth()
+ );
+ WXHBITMAP vOldBitmap;
+ HPS hMemoryPS;
+ HPS hPs;
+ POINTL vPoint[4];
+ SIZEL vSize = {0,0};
- ::SetDIBitsToDevice(GetHdcOf(memDC), 0, 0,
- GetWidth(), GetHeight(),
- 0, 0, 0, GetHeight(),
- lpBits, lpDib, DIB_RGB_COLORS);
+ hMemoryPS = ::GpiCreatePS(vHabmain, (HDC)vMemDC.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
+ hPs = ::GpiCreatePS(vHabmain, (HDC)rDc.GetHDC(), &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
- free(lpBits);
+ // TODO: Set the points
- wxFreeDIB(lpDib);
+ vOldBitmap = (WXHBITMAP)::GpiSetBitmap(hPs, (HBITMAP)vTmpBitmap.GetHBITMAP());
+ ::GpiBitBlt(hPs, hMemoryPS, 4L, vPoint, ROP_SRCCOPY, BBO_IGNORE);
- return tmpBitmap;
+ return(vTmpBitmap);
}
// ----------------------------------------------------------------------------
wxMask::wxMask()
{
- m_maskBitmap = 0;
+ m_hMaskBitmap = 0;
}
// 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
+ );
}
// 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
+ );
}
// 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);
}
wxMask::~wxMask()
{
- if ( m_maskBitmap )
- ::DeleteObject((HBITMAP) m_maskBitmap);
+ if (m_hMaskBitmap)
+ ::GpiDeleteBitmap((HBITMAP)m_hMaskBitmap);
}
// 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 vHeader;
+ DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+ SIZEL vSize = {0, 0};
+ POINTL vPoint[4];
+
+ 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;
+ vHeader.cbFix = sizeof(vHeader);
+ vHeader.cx = (USHORT)rBitmap.GetWidth();
+ vHeader.cy = (USHORT)rBitmap.GetHeight();
+ vHeader.cPlanes = 1;
+ vHeader.cBitCount = 1;
+
+ m_hMaskBitmap = (WXHBITMAP) ::GpiCreateBitmap( m_hPs
+ ,&vHeader
+ ,0L
+ ,NULL
+ ,NULL
+ );
+
+ HPS srcPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
+ ::GpiSetBitmap(srcPS, (HBITMAP)rBitmap.GetHBITMAP());
+ HPS destPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
+ ::GpiSetBitmap(srcPS, (HBITMAP)m_hMaskBitmap);
+ // TODO: Set the point array
+ ::GpiBitBlt(destPS, srcPS, 4L, vPoint, ROP_SRCCOPY , BBO_IGNORE);
+
+ ::GpiDestroyPS(srcPS);
+ ::GpiDestroyPS(destPS);
+ return(TRUE);
}
// 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);
}
// 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 )
+ BITMAPINFOHEADER2 vHeader;
+ DEVOPENSTRUC vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+ SIZEL vSize = {0, 0};
+ POINTL vPoint[4];
+
+ 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
// 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);
+ COLORREF vMaskColour = OS2RGB(rColour.Red(), rColour.Green(), rColour.Blue());
+
+ vHeader.cbFix = sizeof(vHeader);
+ vHeader.cx = (USHORT)rBitmap.GetWidth();
+ vHeader.cy = (USHORT)rBitmap.GetHeight();
+ vHeader.cPlanes = 1;
+ vHeader.cBitCount = 1;
+
+ m_hMaskBitmap = (WXHBITMAP) ::GpiCreateBitmap( m_hPs
+ ,&vHeader
+ ,0L
+ ,NULL
+ ,NULL
+ );
+
+ HPS srcPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
+ ::GpiSetBitmap(srcPS, (HBITMAP)rBitmap.GetHBITMAP());
+ HPS destPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
+ ::GpiSetBitmap(srcPS, (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 vPoint;
+
+ vPoint.x = w;
+ vPoint.y = h;
+
+ COLORREF col = ::GpiQueryPel(srcPS, &vPoint);
+
+ if (col == vMaskColour)
{
- ::SetPixel(destDC, w, h, RGB(0, 0, 0));
+ ::GpiSetColor(destPS, CLR_WHITE);
+ ::GpiSetPel(destPS, &vPoint);
}
else
{
- ::SetPixel(destDC, w, h, RGB(255, 255, 255));
+ ::GpiSetColor(destPS, CLR_BLACK);
+ ::GpiSetPel(destPS, &vPoint);
}
}
}
- ::SelectObject(srcDC, 0);
- ::DeleteDC(srcDC);
- ::SelectObject(destDC, 0);
- ::DeleteDC(destDC);
- return TRUE;
+ ::GpiDestroyPS(srcPS);
+ ::GpiDestroyPS(destPS);
+ return(TRUE);
}
// ----------------------------------------------------------------------------
// wxBitmapHandler
// ----------------------------------------------------------------------------
-bool wxBitmapHandler::Create(wxGDIImage *image,
- void *data,
- long flags,
- int width, int height, int depth)
-{
- wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
-
- return bitmap ? Create(bitmap, data, width, height, depth) : FALSE;
-}
-
-bool wxBitmapHandler::Load(wxGDIImage *image,
- const wxString& name,
- long flags,
- int width, int height)
+bool wxBitmapHandler::Create(
+ wxGDIImage* pImage
+, void* pData
+, long lFlags
+, int nWidth
+, int nHeight
+, int nDepth
+)
{
- wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
+ wxBitmap* pBitmap = wxDynamicCast( pImage
+ ,wxBitmap
+ );
- return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE;
+ return(pBitmap ? Create( pBitmap
+ ,pData
+ ,nWidth
+ ,nHeight
+ ,nDepth
+ ) : FALSE);
}
-bool wxBitmapHandler::Save(wxGDIImage *image,
- const wxString& name,
- int type)
+bool wxBitmapHandler::Load(
+ wxGDIImage* pImage
+, const wxString& rName
+, HPS hPs
+, long lFlags
+, int nWidth
+, int nHeight
+)
{
- wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
+ wxBitmap* pBitmap = wxDynamicCast( pImage
+ ,wxBitmap
+ );
- return bitmap ? SaveFile(bitmap, name, type) : FALSE;
+ return(pBitmap ? LoadFile( pBitmap
+ ,rName
+ ,hPs
+ ,lFlags
+ ,nWidth
+ ,nHeight
+ ) : FALSE);
}
-bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
- void *WXUNUSED(data),
- long WXUNUSED(type),
- int WXUNUSED(width),
- int WXUNUSED(height),
- int WXUNUSED(depth))
+bool wxBitmapHandler::Save(
+ wxGDIImage* pImage
+, const wxString& rName
+, int lType
+)
{
- return FALSE;
-}
+ wxBitmap* pBitmap = wxDynamicCast( pImage
+ ,wxBitmap
+ );
-bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
- const wxString& WXUNUSED(name),
- long WXUNUSED(type),
- int WXUNUSED(desiredWidth),
- int WXUNUSED(desiredHeight))
-{
- return FALSE;
+ return(pBitmap ? SaveFile( pBitmap
+ ,rName
+ ,lType
+ ) : FALSE);
}
-bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
- const wxString& WXUNUSED(name),
- int WXUNUSED(type),
- const wxPalette *WXUNUSED(palette))
+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);
}
-// ----------------------------------------------------------------------------
-// DIB functions
-// ----------------------------------------------------------------------------
-
-bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
- HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
+bool wxBitmapHandler::LoadFile(
+ wxBitmap* WXUNUSED(pBitmap)
+, const wxString& WXUNUSED(rName)
+, HPS WXUNUSED(hPs)
+, long WXUNUSED(lType)
+, int WXUNUSED(nDesiredWidth)
+, int WXUNUSED(nDesiredHeight)
+)
{
- 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;
-
- // 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;
-
-
- // 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;
+ return(FALSE);
}
-void wxFreeDIB(LPBITMAPINFO lpDIBHeader)
+bool wxBitmapHandler::SaveFile(
+ wxBitmap* WXUNUSED(pBitmap)
+, const wxString& WXUNUSED(rName)
+, int WXUNUSED(nType)
+, const wxPalette* WXUNUSED(pPalette)
+)
{
- free(lpDIBHeader);
+ return(FALSE);
}
-
projects / wxWidgets.git / blobdiff