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

enable wxDIB for Windows CE

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@26603 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2004-04-04 12:57:36 +00:00
parent 35f512937b
commit be69f971c4
6 changed files with 255 additions and 417 deletions
Download Patch File Download Diff File Expand all files Collapse all files

437
src/msw/bitmap.cpp
View File

@@ -141,32 +141,44 @@ IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
// ----------------------------------------------------------------------------
// decide whether we should create a DIB or a DDB for the given parameters
static bool wxShouldCreateDIB(int w, int h, int d, WXHDC hdc)
{
#if wxUSE_WXDIB
// here is the logic:
//
// (a) if hdc is specified, the caller explicitly wants DDB
// (b) otherwise, create a DIB if depth >= 24 (we don't support 16bpp or
// less DIBs anyhow)
// (c) finally, create DIBs under Win9x even if the depth hasn't been
// explicitly specified but the current display depth is 24 or more
// and the image is "big", i.e. > 16Mb which is the theoretical limit
// for DDBs under Win9x
//
// consequences (all of which seem to make sense):
//
// (i) by default, DDBs are created (depth == -1 usually)
// (ii) DIBs can be created by explicitly specifying the depth
// (iii) using a DC always forces creating a DDB
return !hdc &&
(d >= 24 ||
(d == -1 &&
wxDIB::GetLineSize(w, wxDisplayDepth())*h > 16*1024*1024));
#else
return FALSE;
#endif
}
//
// NB: we always use DIBs under Windows CE as this is much simpler (even if
// also less efficient...) and we obviously can't use them if there is no
// DIB support compiled in at all
#ifdef __WXWINCE__
static inline bool wxShouldCreateDIB(int, int, int, WXHDC) { return true; }
#define ALWAYS_USE_DIB
#elif !wxUSE_WXDIB
// no sense in defining wxShouldCreateDIB() as we can't compile code
// executed if it is true, so we have to use #if's anyhow
#define NEVER_USE_DIB
#else // wxUSE_WXDIB && !__WXWINCE__
static inline bool wxShouldCreateDIB(int w, int h, int d, WXHDC hdc)
{
// here is the logic:
//
// (a) if hdc is specified, the caller explicitly wants DDB
// (b) otherwise, create a DIB if depth >= 24 (we don't support 16bpp
// or less DIBs anyhow)
// (c) finally, create DIBs under Win9x even if the depth hasn't been
// explicitly specified but the current display depth is 24 or
// more and the image is "big", i.e. > 16Mb which is the
// theoretical limit for DDBs under Win9x
//
// consequences (all of which seem to make sense):
//
// (i) by default, DDBs are created (depth == -1 usually)
// (ii) DIBs can be created by explicitly specifying the depth
// (iii) using a DC always forces creating a DDB
return !hdc &&
(d >= 24 ||
(d == -1 &&
wxDIB::GetLineSize(w, wxDisplayDepth())*h > 16*1024*1024));
}
#define SOMETIMES_USE_DIB
#endif // different DIB usage scenarious
// ----------------------------------------------------------------------------
// wxBitmapRefData
@@ -288,14 +300,19 @@ bool wxBitmap::CopyFromIcon(const wxIcon& icon)
return CopyFromIconOrCursor(icon);
}
#if wxUSE_WXDIB
#ifndef NEVER_USE_DIB
bool wxBitmap::CopyFromDIB(const wxDIB& dib)
{
wxCHECK_MSG( dib.IsOk(), FALSE, _T("invalid DIB in CopyFromDIB") );
#ifdef SOMETIMES_USE_DIB
HBITMAP hbitmap = dib.CreateDDB();
if ( !hbitmap )
return FALSE;
#else // ALWAYS_USE_DIB
HBITMAP hbitmap = ((wxDIB &)dib).Detach(); // const_cast
#endif // SOMETIMES_USE_DIB/ALWAYS_USE_DIB
UnRef();
@@ -320,7 +337,8 @@ bool wxBitmap::CopyFromDIB(const wxDIB& dib)
return TRUE;
}
#endif
#endif // NEVER_USE_DIB
wxBitmap::~wxBitmap()
{
@@ -464,9 +482,9 @@ bool wxBitmap::DoCreate(int w, int h, int d, WXHDC hdc)
GetBitmapData()->m_width = w;
GetBitmapData()->m_height = h;
HBITMAP hbmp;
HBITMAP hbmp wxDUMMY_INITIALIZE(0);
#if wxUSE_WXDIB
#ifndef NEVER_USE_DIB
if ( wxShouldCreateDIB(w, h, d, hdc) )
{
if ( d == -1 )
@@ -486,9 +504,9 @@ bool wxBitmap::DoCreate(int w, int h, int d, WXHDC hdc)
GetBitmapData()->m_depth = d;
}
else // create a DDB
#endif
#endif // NEVER_USE_DIB
{
#ifndef ALWAYS_USE_DIB
#ifndef __WXMICROWIN__
if ( d > 0 )
{
@@ -497,8 +515,10 @@ bool wxBitmap::DoCreate(int w, int h, int d, WXHDC hdc)
{
wxLogLastError(wxT("CreateBitmap"));
}
GetBitmapData()->m_depth = d;
}
else
else // d == 0, create bitmap compatible with the screen
#endif // !__WXMICROWIN__
{
ScreenHDC dc;
@@ -510,6 +530,7 @@ bool wxBitmap::DoCreate(int w, int h, int d, WXHDC hdc)
GetBitmapData()->m_depth = wxDisplayDepth();
}
#endif // !ALWAYS_USE_DIB
}
SetHBITMAP((WXHBITMAP)hbmp);
@@ -710,6 +731,8 @@ wxImage wxBitmap::ConvertToImage() const
// wxImage to/from conversions
// ----------------------------------------------------------------------------
#if wxUSE_WXDIB
bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
{
return CreateFromImage(image, depth, 0);
@@ -723,9 +746,8 @@ bool wxBitmap::CreateFromImage(const wxImage& image, const wxDC& dc)
return CreateFromImage(image, -1, dc.GetHDC());
}
bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc )
bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc)
{
#if wxUSE_WXDIB
wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") );
UnRef();
@@ -749,7 +771,7 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc )
// next either store DIB as is or create a DDB from it
HBITMAP hbitmap;
HBITMAP hbitmap wxDUMMY_INITIALIZE(0);
// are we going to use DIB?
//
@@ -762,12 +784,14 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc )
refData->m_isDIB = TRUE;
refData->m_depth = dib.GetDepth();
}
#ifndef ALWAYS_USE_DIB
else // we need to convert DIB to DDB
{
hbitmap = dib.CreateDDB((HDC)hdc);
refData->m_depth = depth == -1 ? wxDisplayDepth() : depth;
}
#endif // !ALWAYS_USE_DIB
// validate this object
SetHBITMAP((WXHBITMAP)hbitmap);
@@ -781,350 +805,27 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc )
}
return TRUE;
#else
// FIXME: wxWinCE doesn't support wxDIB yet
return FALSE;
#endif
}
wxImage wxBitmap::ConvertToImage() const
{
// FIXME: this is untested code for WinCE, and
// the mask is not yet handled.
// For tips, see:
// http://www.codeproject.com/bitmap/dibsection.asp?print=true
#ifdef __WXWINCE__
// the colour used as transparent one in wxImage and the one it is replaced
// with when it really occurs in the bitmap
static const int MASK_RED = 1;
static const int MASK_GREEN = 2;
static const int MASK_BLUE = 3;
static const int MASK_BLUE_REPLACEMENT = 2;
wxDIB dib(*this);
wxImage image;
wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
// create an wxImage object
int width = GetWidth();
int height = GetHeight();
image.Create( width, height );
unsigned char *data = image.GetData();
if( !data )
if ( dib.IsOk() )
{
wxFAIL_MSG( wxT("could not allocate data for image") );
return wxNullImage;
}
// calc the number of bytes per scanline and padding in the DIB
int bytePerLine = width*3;
int sizeDWORD = sizeof( DWORD );
int lineBoundary = bytePerLine % sizeDWORD;
int padding = 0;
if( lineBoundary > 0 )
{
padding = sizeDWORD - lineBoundary;
bytePerLine += padding;
}
// create a DIB header
int headersize = sizeof(BITMAPINFOHEADER);
BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
if( !lpDIBh )
{
wxFAIL_MSG( wxT("could not allocate data for DIB header") );
free( data );
return wxNullImage;
}
// Fill in the DIB header
lpDIBh->bmiHeader.biSize = headersize;
lpDIBh->bmiHeader.biWidth = width;
lpDIBh->bmiHeader.biHeight = -height;
lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
lpDIBh->bmiHeader.biPlanes = 1;
lpDIBh->bmiHeader.biBitCount = 24;
lpDIBh->bmiHeader.biCompression = BI_RGB;
lpDIBh->bmiHeader.biClrUsed = 0;
// These seem not really needed for our purpose here.
lpDIBh->bmiHeader.biClrImportant = 0;
lpDIBh->bmiHeader.biXPelsPerMeter = 0;
lpDIBh->bmiHeader.biYPelsPerMeter = 0;
// memory for DIB data is allocated by CreateDIBSection
void *lpBits = NULL;
// copy data from the device-dependent bitmap to the DIB
HDC hdc = ::GetDC(NULL);
HBITMAP hBitmap = (HBITMAP) GetHBITMAP();
HBITMAP hBitmapSection = ::CreateDIBSection( hdc, lpDIBh, DIB_RGB_COLORS, & lpBits, NULL, 0 );
if (!hBitmapSection)
{
wxFAIL_MSG( wxT("could not create a DIB section") );
return wxNullImage;
}
// Copy the image from the DDB to the DIBSection
// Need to copy the supplied bitmap onto the newly created DIBsection
HDC hMemDC = CreateCompatibleDC(hdc);
HDC hCopyDC = CreateCompatibleDC(hdc);
if (! hMemDC || ! hCopyDC)
{
wxFAIL_MSG( wxT("unable to create compatible DCs") );
return wxNullImage;
}
#if 0
if (m_hPal)
{
SelectPalette(hMemDC, m_hPal, FALSE); RealizePalette(hMemDC);
SelectPalette(hCopyDC, m_hPal, FALSE); RealizePalette(hCopyDC);
}
#endif
HBITMAP hOldMemBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
HBITMAP hOldCopyBitmap = (HBITMAP) SelectObject(hCopyDC, hBitmapSection);
BitBlt(hCopyDC, 0, 0, GetWidth(), GetHeight(), hMemDC, 0, 0, SRCCOPY);
SelectObject(hMemDC, hOldMemBitmap);
SelectObject(hCopyDC, hOldCopyBitmap);
DeleteDC(hMemDC);
DeleteDC(hCopyDC);
#if 0
if (m_hPal)
{
HGDIOBJ hObj = ::GetStockObject(DEFAULT_PALETTE);
SelectObject(hMemDC, hObj);
SelectObject(hCopyDC, hObj);
}
#endif
ReleaseDC(NULL, hdc);
// copy DIB data into the wxImage object
int i, j;
unsigned char *ptdata = data;
unsigned char *ptbits = (unsigned char*) lpBits;
for( i=0; i<height; i++ )
{
for( j=0; j<width; j++ )
image = dib.ConvertToImage();
if ( image.Ok() )
{
*(ptdata++) = *(ptbits+2);
*(ptdata++) = *(ptbits+1);
*(ptdata++) = *(ptbits );
ptbits += 3;
// TODO: set mask
}
ptbits += padding;
}
// TODO
#if 0
// similarly, set data according to the possible mask bitmap
if( GetMask() && GetMask()->GetMaskBitmap() )
{
hbitmap = (HBITMAP) GetMask()->GetMaskBitmap();
// memory DC created, color set, data copied, and memory DC deleted
HDC memdc = ::CreateCompatibleDC( hdc );
::SetTextColor( memdc, RGB( 0, 0, 0 ) );
::SetBkColor( memdc, RGB( 255, 255, 255 ) );
::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
::DeleteDC( memdc );
ptdata = data;
ptbits = lpBits;
for( i=0; i<height; i++ )
{
for( j=0; j<width; j++ )
{
// is this pixel transparent?
if ( *ptbits != 0 )
{
if ( (ptdata[0] == MASK_RED) &&
(ptdata[1] == MASK_GREEN) &&
(ptdata[2] == MASK_BLUE) )
{
// we have to fudge the colour a bit to prevent this
// pixel from appearing transparent
ptdata[2] = MASK_BLUE_REPLACEMENT;
}
ptdata += 3;
}
else // masked pixel
{
*(ptdata++) = MASK_RED;
*(ptdata++) = MASK_GREEN;
*(ptdata++) = MASK_BLUE;
}
ptbits += 3;
}
ptbits += padding;
}
image.SetMaskColour( MASK_RED, MASK_GREEN, MASK_BLUE );
image.SetMask( TRUE );
}
else
#endif
{
image.SetMask( FALSE );
}
// free allocated resources
::ReleaseDC(NULL, hdc);
free(lpDIBh);
// Delete the DIB section
::DeleteObject(hBitmapSection);
return image;
#else
// the colour used as transparent one in wxImage and the one it is replaced
// with when it really occurs in the bitmap
static const int MASK_RED = 1;
static const int MASK_GREEN = 2;
static const int MASK_BLUE = 3;
static const int MASK_BLUE_REPLACEMENT = 2;
wxImage image;
wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
// create an wxImage object
int width = GetWidth();
int height = GetHeight();
image.Create( width, height );
unsigned char *data = image.GetData();
if( !data )
{
wxFAIL_MSG( wxT("could not allocate data for image") );
return wxNullImage;
}
// calc the number of bytes per scanline and padding in the DIB
int bytePerLine = width*3;
int sizeDWORD = sizeof( DWORD );
int lineBoundary = bytePerLine % sizeDWORD;
int padding = 0;
if( lineBoundary > 0 )
{
padding = sizeDWORD - lineBoundary;
bytePerLine += padding;
}
// create a DIB header
int headersize = sizeof(BITMAPINFOHEADER);
BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
if( !lpDIBh )
{
wxFAIL_MSG( wxT("could not allocate data for DIB header") );
free( data );
return wxNullImage;
}
// Fill in the DIB header
lpDIBh->bmiHeader.biSize = headersize;
lpDIBh->bmiHeader.biWidth = width;
lpDIBh->bmiHeader.biHeight = -height;
lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
lpDIBh->bmiHeader.biPlanes = 1;
lpDIBh->bmiHeader.biBitCount = 24;
lpDIBh->bmiHeader.biCompression = BI_RGB;
lpDIBh->bmiHeader.biClrUsed = 0;
// These seem not really needed for our purpose here.
lpDIBh->bmiHeader.biClrImportant = 0;
lpDIBh->bmiHeader.biXPelsPerMeter = 0;
lpDIBh->bmiHeader.biYPelsPerMeter = 0;
// memory for DIB data
unsigned char *lpBits;
lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
if( !lpBits )
{
wxFAIL_MSG( wxT("could not allocate data for DIB") );
free( data );
free( lpDIBh );
return wxNullImage;
}
// copy data from the device-dependent bitmap to the DIB
HDC hdc = ::GetDC(NULL);
HBITMAP hbitmap;
hbitmap = (HBITMAP) GetHBITMAP();
::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
// copy DIB data into the wxImage object
int i, j;
unsigned char *ptdata = data;
unsigned char *ptbits = lpBits;
for( i=0; i<height; i++ )
{
for( j=0; j<width; j++ )
{
*(ptdata++) = *(ptbits+2);
*(ptdata++) = *(ptbits+1);
*(ptdata++) = *(ptbits );
ptbits += 3;
}
ptbits += padding;
}
// similarly, set data according to the possible mask bitmap
if( GetMask() && GetMask()->GetMaskBitmap() )
{
hbitmap = (HBITMAP) GetMask()->GetMaskBitmap();
// memory DC created, color set, data copied, and memory DC deleted
HDC memdc = ::CreateCompatibleDC( hdc );
::SetTextColor( memdc, RGB( 0, 0, 0 ) );
::SetBkColor( memdc, RGB( 255, 255, 255 ) );
::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
::DeleteDC( memdc );
ptdata = data;
ptbits = lpBits;
for( i=0; i<height; i++ )
{
for( j=0; j<width; j++ )
{
// is this pixel transparent?
if ( *ptbits != 0 )
{
if ( (ptdata[0] == MASK_RED) &&
(ptdata[1] == MASK_GREEN) &&
(ptdata[2] == MASK_BLUE) )
{
// we have to fudge the colour a bit to prevent this
// pixel from appearing transparent
ptdata[2] = MASK_BLUE_REPLACEMENT;
}
ptdata += 3;
}
else // masked pixel
{
*(ptdata++) = MASK_RED;
*(ptdata++) = MASK_GREEN;
*(ptdata++) = MASK_BLUE;
}
ptbits += 3;
}
ptbits += padding;
}
image.SetMaskColour( MASK_RED, MASK_GREEN, MASK_BLUE );
image.SetMask( TRUE );
}
else
{
image.SetMask( FALSE );
}
// free allocated resources
::ReleaseDC(NULL, hdc);
free(lpDIBh);
free(lpBits);
return image;
#endif
}
#endif // wxUSE_WXDIB
#endif // wxUSE_IMAGE
// ----------------------------------------------------------------------------
@@ -1144,7 +845,7 @@ bool wxBitmap::LoadFile(const wxString& filename, long type)
return handler->LoadFile(this, filename, type, -1, -1);
}
#if wxUSE_IMAGE
else
else // no bitmap handler found
{
wxImage image;
if ( image.LoadFile( filename, type ) && image.Ok() )
@@ -1188,7 +889,7 @@ bool wxBitmap::SaveFile(const wxString& filename,
return handler->SaveFile(this, filename, type, palette);
}
#if wxUSE_IMAGE
else
else // no bitmap handler found
{
// FIXME what about palette? shouldn't we use it?
wxImage image = ConvertToImage();