Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bitmap and image updates

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4831 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster
1999-12-05 21:23:52 +00:00
parent fd72e0b5e2
commit 58b1642453
2 changed files with 193 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
include/wx/os2/bitmap.h
View File

@@ -16,6 +16,7 @@
#pragma interface "bitmap.h" #pragma interface "bitmap.h"
#endif #endif
#include "wx/os2/private.h"
#include "wx/os2/gdiimage.h" #include "wx/os2/gdiimage.h"
#include "wx/gdicmn.h" #include "wx/gdicmn.h"
#include "wx/palette.h" #include "wx/palette.h"
@@ -159,17 +160,17 @@ public:
{ return (wxBitmapRefData *)m_refData; } { return (wxBitmapRefData *)m_refData; }
inline int GetQuality() const inline int GetQuality() const
{ return (GetBitmapData() ? GetBitmapData()->m_quality : 0); } { return (GetBitmapData() ? GetBitmapData()->m_nQuality : 0); }
void SetQuality(int nQ); void SetQuality(int nQ);
wxPalette* GetPalette() const wxPalette* GetPalette() const
{ return (GetBitmapData() ? (& GetBitmapData()->m_bitmapPalette) : (wxPalette*) NULL); } { return (GetBitmapData() ? (& GetBitmapData()->m_vBitmapPalette) : (wxPalette*) NULL); }
void SetPalette(const wxPalette& rPalette); void SetPalette(const wxPalette& rPalette);
inline wxMask* GetMask() const inline wxMask* GetMask() const
{ return (GetBitmapData() ? GetBitmapData()->m_bitmapMask : (wxMask*) NULL); } { return (GetBitmapData() ? GetBitmapData()->m_pBitmapMask : (wxMask*) NULL); }
void SetMask(wxMask* pMask) ; void SetMask(wxMask* pMask) ;
@@ -194,17 +195,17 @@ public:
// Implementation // Implementation
public: public:
inline void SetHBITMAP(WXHBITMAP hHmp) inline void SetHBITMAP(WXHBITMAP hBmp)
{ SetHandle((WXHANDLE)bmp); } { SetHandle((WXHANDLE)hBmp); }
inline WXHBITMAP GetHBITMAP() const inline WXHBITMAP GetHBITMAP() const
{ return (WXHBITMAP)GetHandle(); } { return (WXHBITMAP)GetHandle(); }
inline void SetSelectedInto(wxDC* pDc) inline void SetSelectedInto(wxDC* pDc)
{ if (GetBitmapData()) GetBitmapData()->m_selectedInto = pDc; } { if (GetBitmapData()) GetBitmapData()->m_pSelectedInto = pDc; }
inline wxDC* GetSelectedInto() const inline wxDC* GetSelectedInto() const
{ return (GetBitmapData() ? GetBitmapData()->m_selectedInto : (wxDC*) NULL); } { return (GetBitmapData() ? GetBitmapData()->m_pSelectedInto : (wxDC*) NULL); }
// An OS/2 version that probably doesn't do anything like the msw version // An OS/2 version that probably doesn't do anything like the msw version
wxBitmap GetBitmapForDC(wxDC& rDc) const; wxBitmap GetBitmapForDC(wxDC& rDc) const;
@@ -327,9 +328,9 @@ public:
,int nDesiredWidth ,int nDesiredWidth
,int nDesiredHeight ,int nDesiredHeight
); );
virtual bool Save(wxGDIImage* pImage virtual bool Save( wxGDIImage* pImage
const wxString& rName ,const wxString& rName
int lType ,int lType
); );
private: private:
DECLARE_DYNAMIC_CLASS(wxBitmapHandler) DECLARE_DYNAMIC_CLASS(wxBitmapHandler)

332
src/os2/bitmap.cpp
View File

@@ -182,7 +182,7 @@ wxBitmap::wxBitmap(
vHeader.ulColorEncoding = 0; vHeader.ulColorEncoding = 0;
vHeader.ulIdentifier = 0; vHeader.ulIdentifier = 0;
hPs = ::GpiCreatePS(habMain, hdc, &vSize, GPIA_ASSOC | PU_PELS); hPs = ::GpiCreatePS(vHabMain, hdc, &vSize, GPIA_ASSOC | PU_PELS);
if (hPs == 0) if (hPs == 0)
{ {
wxLogLastError("GpiCreatePS Failure"); wxLogLastError("GpiCreatePS Failure");
@@ -410,7 +410,7 @@ bool wxBitmap::Create(
)); ));
} }
bool wxBitmap::SaveFile( bool wxBitmap::SaveFile(
const wxString& rFilename const wxString& rFilename
, int lType , int lType
, const wxPalette* pPalette , const wxPalette* pPalette
@@ -485,7 +485,7 @@ void wxBitmap::SetMask(
} }
// Will try something for OS/2 but not really sure how close // Will try something for OS/2 but not really sure how close
// to the msw intent this is. // to the msw intent this is.
wxBitmap wxBitmap::GetBitmapForDC( wxBitmap wxBitmap::GetBitmapForDC(
wxDC& rDc wxDC& rDc
) const ) const
@@ -506,9 +506,9 @@ wxBitmap wxBitmap::GetBitmapForDC(
// TODO: Set the points // TODO: Set the points
rDc.m_oldBitmap = (WXHBITMAP)::GpiSetBitMap(hPs, (HBITMAP)vTmpBitmap.GetHBITMAP()); rDc.m_oldBitmap = (WXHBITMAP)::GpiSetBitMap(hPs, (HBITMAP)vTmpBitmap.GetHBITMAP());
:GpiBitBlt(hPs, hMemoryPS, 4L, vPoint, &vSize, PU_PELS | GPI_ASSOC); :GpiBitBlt(hPs, hMemoryPS, 4L, vPoint, ROP_SRCCOPY | BBO_IGNORE);
return tmpBitmap; return(vTmpBitmap);
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -562,217 +562,249 @@ wxMask::~wxMask()
} }
// Create a mask from a mono bitmap (copies the bitmap). // 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;
DEVOPENSTRUCT vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
SIZEL vSize = {0, 0};
POINTL vPoint[4];
if (m_hMaskBitmap)
{ {
::DeleteObject((HBITMAP) m_maskBitmap); ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
m_maskBitmap = 0; m_hMaskBitmap = 0;
} }
if (!bitmap.Ok() || bitmap.GetDepth() != 1) if (!rBitmap.Ok() || rBitmap.GetDepth() != 1)
{ {
return FALSE; return(FALSE);
} }
m_maskBitmap = (WXHBITMAP) CreateBitmap( vHeader.cbFix = sizeof(vHeader);
bitmap.GetWidth(), vHeader.cx = (USHORT)rBitmap.GetWidth();
bitmap.GetHeight(), vHeader.cy = (USHORT)rBitmap.GetHeight();
1, 1, 0 vHeader.cPlanes = 1;
); vHeader.cBitCount = 1;
HDC srcDC = CreateCompatibleDC(0);
SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP()); m_hMaskBitmap = (WXHBITMAP) ::GpiCreateBitmap( m_hPs
HDC destDC = CreateCompatibleDC(0); ,&vHeader
SelectObject(destDC, (HBITMAP) m_maskBitmap); ,0L
BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY); ,NULL
SelectObject(srcDC, 0); ,NULL
DeleteDC(srcDC); );
SelectObject(destDC, 0);
DeleteDC(destDC); HPS srcPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
return TRUE; ::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 // Create a mask from a bitmap and a palette index indicating
// the transparent area // 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); ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
m_maskBitmap = 0; m_hMaskBitmap = 0;
} }
if (bitmap.Ok() && bitmap.GetPalette()->Ok()) if (rBitmap.Ok() && rBitmap.GetPalette()->Ok())
{ {
unsigned char red, green, blue; unsigned char red, green, blue;
if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue)) if (rBitmap.GetPalette()->GetRGB( nPaletteIndex
,&rRed
,&rGreen
,&rBlue
))
{ {
wxColour transparentColour(red, green, blue); wxColour vTransparentColour( rRed
return Create(bitmap, transparentColour); ,rGreen
,rBlue
);
return (Create( rBitmap
,vTransparentColour
));
} }
} }
return FALSE; return(FALSE);
} }
// Create a mask from a bitmap and a colour indicating // Create a mask from a bitmap and a colour indicating
// the transparent area // 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;
DEVOPENSTRUCT vDop = { NULL, "DISPLAY", NULL, NULL, NULL, NULL, NULL, NULL, NULL };
SIZEL vSize = {0, 0};
POINTL vPoint[4];
if (m_hMaskBitmap)
{ {
::DeleteObject((HBITMAP) m_maskBitmap); ::GpiDeleteBitmap((HBITMAP) m_hMaskBitmap);
m_maskBitmap = 0; m_hMaskBitmap = 0;
} }
if (!bitmap.Ok()) if (!rBitmap.Ok())
{ {
return FALSE; return(FALSE);
} }
// scan the bitmap for the transparent colour and set // scan the bitmap for the transparent colour and set
// the corresponding pixels in the mask to BLACK and // the corresponding pixels in the mask to BLACK and
// the rest to WHITE // the rest to WHITE
COLORREF maskColour = RGB(colour.Red(), colour.Green(), colour.Blue()); COLORREF vMaskColour = OS2RGB(rColour.Red(), rColour.Green(), rColour.Blue());
m_maskBitmap = (WXHBITMAP) ::CreateBitmap(
bitmap.GetWidth(), vHeader.cbFix = sizeof(vHeader);
bitmap.GetHeight(), vHeader.cx = (USHORT)rBitmap.GetWidth();
1, 1, 0 vHeader.cy = (USHORT)rBitmap.GetHeight();
vHeader.cPlanes = 1;
vHeader.cBitCount = 1;
m_hMaskBitmap = (WXHBITMAP) ::GpiCreateBitmap( m_hPs
,&vHeader
,0L
,NULL
,NULL
);
); );
HDC srcDC = ::CreateCompatibleDC(0); HPS srcPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
::SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP()); ::GpiSetBitmap(srcPS, (HBITMAP)rBitmap.GetHBITMAP());
HDC destDC = ::CreateCompatibleDC(0); HPS destPS = ::GpiCreatePS(vHabmain, m_hDc, &vSize, PU_PELS | GPIT_MICRO | GPIA_ASSOC);
::SelectObject(destDC, (HBITMAP) m_maskBitmap); ::GpiSetBitmap(srcPS, (HBITMAP)m_hMaskBitmap);
// this is not very efficient, but I can't think // this is not very efficient, but I can't think
// of a better way of doing it // 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); POINTL vPoint;
if (col == maskColour)
vPoint.x = w;
vPoint.y = h;
COLORREF col = ::GpiQueryPel(srcPS, w, h);
if (col == vMaskColour)
{ {
::SetPixel(destDC, w, h, RGB(0, 0, 0)); ::GpiSetColor(destPS, CLR_WHITE);
::GpiSetPel(destPS, &vPoint);
} }
else else
{ {
::SetPixel(destDC, w, h, RGB(255, 255, 255)); ::GpiSetColor(destPS, CLR_BLACK);
::GpiSetPel(destPS, &vPoint);
} }
} }
} }
::SelectObject(srcDC, 0); ::GpiDestroyPS(srcPS);
::DeleteDC(srcDC); ::GpiDestroyPS(destPS);
::SelectObject(destDC, 0); return(TRUE);
::DeleteDC(destDC);
return TRUE;
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxBitmapHandler // wxBitmapHandler
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
bool wxBitmapHandler::Create(wxGDIImage *image, bool wxBitmapHandler::Create(
void *data, wxGDIImage* pImage
long flags, , void* pData
int width, int height, int depth) , long lFlags
, int nWidth
, int nHeight
, int nDepth
)
{ {
wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); wxBitmap* pBitmap = wxDynamicCast( pImage
,wxBitmap
);
return bitmap ? Create(bitmap, data, width, height, depth) : FALSE; return(pBitmap ? Create( pBitmap
,pData
,nWidth
,nHeight
,nDepth
) : FALSE);
} }
bool wxBitmapHandler::Load(wxGDIImage *image, bool wxBitmapHandler::Load(
const wxString& name, wxGDIImage* pImage
long flags, , const wxString& rName
int width, int height) , long lFlags
, int nWidth
, int nHeight
)
{ {
wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); wxBitmap* bitmap = wxDynamicCast( pImage
,wxBitmap
);
return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE; return(pBitmap ? LoadFile( pBitmap
,rName
,lFlags
,nWidth
,nHeight
) : FALSE);
} }
bool wxBitmapHandler::Save(wxGDIImage *image, bool wxBitmapHandler::Save(
const wxString& name, wxGDIImage* pImage
int type) , const wxString& rName
, int lType
)
{ {
wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); wxBitmap* pBitmap = wxDynamicCast( pImage
,wxBitmap
);
return bitmap ? SaveFile(bitmap, name, type) : FALSE; return(pBitmap ? SaveFile( pBitmap
,rName
,lType
) : FALSE);
} }
bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), bool wxBitmapHandler::Create(
void *WXUNUSED(data), wxBitmap* WXUNUSED(pBitmap)
long WXUNUSED(type), , void* WXUNUSED(pData)
int WXUNUSED(width), , long WXUNUSED(lType)
int WXUNUSED(height), , int WXUNUSED(nWidth)
int WXUNUSED(depth)) , int WXUNUSED(nHeight)
, int WXUNUSED(nDepth)
)
{ {
return FALSE; return(FALSE);
} }
bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), bool wxBitmapHandler::LoadFile(
const wxString& WXUNUSED(name), wxBitmap* WXUNUSED(pBitmap)
long WXUNUSED(type), , const wxString& WXUNUSED(rName)
int WXUNUSED(desiredWidth), , long WXUNUSED(lType)
int WXUNUSED(desiredHeight)) , int WXUNUSED(nDesiredWidth)
, int WXUNUSED(nDesiredHeight)
)
{ {
return FALSE; return(FALSE(;
} }
bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), bool wxBitmapHandler::SaveFile(
const wxString& WXUNUSED(name), wxBitmap* WXUNUSED(pBitmap)
int WXUNUSED(type), , const wxString& WXUNUSED(rName)
const wxPalette *WXUNUSED(palette)) , int WXUNUSED(nType)
, const wxPalette* WXUNUSED(pPalette)
)
{ {
return FALSE; return(FALSE);
} }
// ----------------------------------------------------------------------------
// DIB functions
// ----------------------------------------------------------------------------
bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
{
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;
}
void wxFreeDIB(LPBITMAPINFO lpDIBHeader)
{
free(lpDIBHeader);
}