HRESULT BitmapUtil::MyCreateFromGdiplusBitmap( Gdiplus::Bitmap& bmSrc ) throw()
{
Gdiplus::PixelFormat eSrcPixelFormat = bmSrc.GetPixelFormat();
UINT nBPP = 32;
DWORD dwFlags = 0;
Gdiplus::PixelFormat eDestPixelFormat = PixelFormat32bppRGB;
if( eSrcPixelFormat&PixelFormatGDI )
{
nBPP = Gdiplus::GetPixelFormatSize( eSrcPixelFormat );
eDestPixelFormat = eSrcPixelFormat;
}
if( Gdiplus::IsAlphaPixelFormat( eSrcPixelFormat ) )
{
nBPP = 32;
dwFlags |= createAlphaChannel;
eDestPixelFormat = PixelFormat32bppARGB;
}
BOOL bSuccess = Create( bmSrc.GetWidth(), bmSrc.GetHeight(), nBPP, dwFlags );
if( !bSuccess )
{
return( E_FAIL );
}
Gdiplus::ColorPalette* pPalette = NULL;
if( Gdiplus::IsIndexedPixelFormat( eSrcPixelFormat ) )
{
UINT nPaletteSize = bmSrc.GetPaletteSize();
pPalette = static_cast< Gdiplus::ColorPalette* >( _alloca( nPaletteSize ) );
bmSrc.GetPalette( pPalette, nPaletteSize );
RGBQUAD argbPalette[256];
ATLASSERT( (pPalette->Count > 0) && (pPalette->Count <= 256) );
for( UINT iColor = 0; iColor < pPalette->Count; iColor++ )
{
Gdiplus::ARGB color = pPalette->Entries[iColor];
argbPalette[iColor].rgbRed = BYTE( color>>RED_SHIFT );
argbPalette[iColor].rgbGreen = BYTE( color>>GREEN_SHIFT );
argbPalette[iColor].rgbBlue = BYTE( color>>BLUE_SHIFT );
argbPalette[iColor].rgbReserved = 0;
}
SetColorTable( 0, pPalette->Count, argbPalette );
}
if( eDestPixelFormat == eSrcPixelFormat )
{
// The pixel formats are identical, so just memcpy the rows.
Gdiplus::BitmapData data;
Gdiplus::Rect rect( 0, 0, GetWidth(), GetHeight() );
bmSrc.LockBits( &rect, Gdiplus::ImageLockModeRead, eSrcPixelFormat, &data );
UINT nBytesPerRow = AtlAlignUp( nBPP*GetWidth(), 8 )/8;
BYTE* pbDestRow = static_cast< BYTE* >( GetBits() );
BYTE* pbSrcRow = static_cast< BYTE* >( data.Scan0 );
for( int y = 0; y < GetHeight(); y++ )
{
memcpy( pbDestRow, pbSrcRow, nBytesPerRow );
pbDestRow += GetPitch();
pbSrcRow += data.Stride;
}
bmSrc.UnlockBits( &data );
}
else
{
// Let GDI+ work its magic
Gdiplus::Bitmap bmDest( GetWidth(), GetHeight(), GetPitch(), eDestPixelFormat, static_cast< BYTE* >( GetBits() ) );
Gdiplus::Graphics gDest( &bmDest );
gDest.DrawImage( &bmSrc, 0, 0 );
}
return( S_OK );
}
void CXTPFlowGraphImage::ImageChanged()
{
CMDTARGET_RELEASE(m_pIcon);
if (!m_pImage || m_pImage->GetLastStatus() != Gdiplus::Ok)
{
SAFE_DELETE(m_pImage);
}
m_szImage = CSize(0, 0);
if (!m_pImage)
return;
m_szImage = CSize(m_pImage->GetWidth(), m_pImage->GetHeight());
Gdiplus::PixelFormat eSrcPixelFormat = m_pImage->GetPixelFormat();
UINT nBPP = 32;
Gdiplus::PixelFormat eDestPixelFormat = PixelFormat32bppRGB;
if( eSrcPixelFormat & PixelFormatGDI )
{
nBPP = Gdiplus::GetPixelFormatSize( eSrcPixelFormat );
eDestPixelFormat = eSrcPixelFormat;
}
BOOL bAlpha = FALSE;
if( Gdiplus::IsAlphaPixelFormat( eSrcPixelFormat ) )
{
nBPP = 32;
bAlpha = TRUE;
eDestPixelFormat = PixelFormat32bppARGB;
}
LPBYTE lpBits;
HBITMAP hBitmap = CXTPImageManager::Create32BPPDIBSection(0, m_szImage.cx, m_szImage.cy, &lpBits);
int nPitch = ( (((m_szImage.cx * nBPP)+31)/32)*4 );
if( eDestPixelFormat == eSrcPixelFormat && nBPP == 32)
{
// The pixel formats are identical, so just memcpy the rows.
Gdiplus::BitmapData data;
Gdiplus::Rect rect( 0, 0, m_szImage.cx, m_szImage.cy );
if(m_pImage->LockBits( &rect, Gdiplus::ImageLockModeRead, eSrcPixelFormat, &data )!=Gdiplus::Ok)
{
return;
}
size_t nBytesPerRow = XTPAlignUp( nBPP * m_szImage.cx, 8 )/8;
BYTE* pbDestRow = static_cast< BYTE* >( lpBits );
BYTE* pbSrcRow = static_cast< BYTE* >( data.Scan0 );
for( int y = 0; y < m_szImage.cy; y++ )
{
MEMCPY_S(pbDestRow, pbSrcRow, nBytesPerRow);
pbDestRow += nPitch;
pbSrcRow += data.Stride;
}
m_pImage->UnlockBits( &data );
}
else
{
// Let GDI+ work its magic
Gdiplus::Bitmap bmDest( m_szImage.cx, m_szImage.cy, nPitch, eDestPixelFormat, static_cast< BYTE* >( lpBits) );
Gdiplus::Graphics gDest( &bmDest );
gDest.DrawImage(m_pImage, 0, 0 );
}
CBitmap bmpIcons;
bmpIcons.Attach(hBitmap);
UINT nCommand[] = {0};
m_pParent->GetImageManager()->SetIcons(bmpIcons, nCommand, 1, m_szImage, xtpImageNormal, bAlpha);
m_pIcon = m_pParent->GetImageManager()->GetImage(nCommand[0], m_szImage.cx);
if (m_pIcon)
{
m_pIcon->InternalAddRef();
}
}
void Convert(
const char* pSrc,
const char* pDst,
RawImgFormat eImgFormat = Raw_RGB_Unknown
)
{
CInitGDIPlus initGDIPlus;
initGDIPlus.Init();
{
Gdiplus::Bitmap bmSrc( (CT2W)pSrc );
if( bmSrc.GetLastStatus() != Gdiplus::Ok )
{
throw "Load Image File Failed!";
}
m_nHeight = bmSrc.GetHeight();
m_nWidth = bmSrc.GetWidth();
Gdiplus::PixelFormat eSrcPixelFormat = bmSrc.GetPixelFormat();
if ( eSrcPixelFormat != PixelFormat24bppRGB &&
eSrcPixelFormat != PixelFormat32bppARGB )
{
throw "Unport Image Format!";
}
UINT nBPP = 32;
DWORD dwFlags = 0;
Gdiplus::PixelFormat eDestPixelFormat = PixelFormat32bppRGB;
if( eSrcPixelFormat&PixelFormatGDI )
{
nBPP = Gdiplus::GetPixelFormatSize( eSrcPixelFormat );
eDestPixelFormat = eSrcPixelFormat;
}
if( Gdiplus::IsAlphaPixelFormat( eSrcPixelFormat ) )
{
nBPP = 32;
dwFlags |= 0x01;//createAlphaChannel;
eDestPixelFormat = PixelFormat32bppARGB;
}
m_pDst = new BYTE[nBPP/8*m_nHeight*m_nWidth];
//BOOL bSuccess = Create( bmSrc.GetWidth(), bmSrc.GetHeight(), nBPP, dwFlags );
//if( !bSuccess )
//{
// return( E_FAIL );
//}
USES_ATL_SAFE_ALLOCA;
Gdiplus::ColorPalette* pPalette = NULL;
if( Gdiplus::IsIndexedPixelFormat( eSrcPixelFormat ) )
{
//assert(false);
throw "Unsuport Indexed Pixel!";
//UINT nPaletteSize = bmSrc.GetPaletteSize();
//pPalette = static_cast< Gdiplus::ColorPalette* >( _ATL_SAFE_ALLOCA(nPaletteSize, _ATL_SAFE_ALLOCA_DEF_THRESHOLD) );
//if( pPalette == NULL )
// return E_OUTOFMEMORY;
//bmSrc.GetPalette( pPalette, nPaletteSize );
//RGBQUAD argbPalette[256];
//ATLASSERT( (pPalette->Count > 0) && (pPalette->Count <= 256) );
//for( UINT iColor = 0; iColor < pPalette->Count; iColor++ )
//{
// Gdiplus::ARGB color = pPalette->Entries[iColor];
// argbPalette[iColor].rgbRed = (BYTE)( (color>>RED_SHIFT) & 0xff );
// argbPalette[iColor].rgbGreen = (BYTE)( (color>>GREEN_SHIFT) & 0xff );
// argbPalette[iColor].rgbBlue = (BYTE)( (color>>BLUE_SHIFT) & 0xff );
// argbPalette[iColor].rgbReserved = 0;
//}
//SetColorTable( 0, pPalette->Count, argbPalette );
}
if( eDestPixelFormat == eSrcPixelFormat )
{
// The pixel formats are identical, so just memcpy the rows.
Gdiplus::BitmapData data;
Gdiplus::Rect rect( 0, 0, bmSrc.GetWidth(), bmSrc.GetHeight() );
if(bmSrc.LockBits( &rect, Gdiplus::ImageLockModeRead, eSrcPixelFormat, &data )!=Gdiplus::Ok)
{
throw "bmSrc.LockBits E_OUTOFMEMORY";
//return E_OUTOFMEMORY;
}
size_t nBytesPerRow = AtlAlignUp( nBPP*bmSrc.GetWidth(), 8 )/8;
BYTE* pbDestRow = m_pDst;//static_cast< BYTE* >( GetBits() );
BYTE* pbSrcRow = static_cast< BYTE* >( data.Scan0 );
for( int y = 0; y < bmSrc.GetHeight(); y++ )
{
Checked::memcpy_s(pbDestRow, nBytesPerRow, pbSrcRow, nBytesPerRow);
pbDestRow += nBytesPerRow;//GetPitch();
pbSrcRow += data.Stride;
}
bmSrc.UnlockBits( &data );
}
else
{
size_t nBytesPerRow = AtlAlignUp( nBPP*bmSrc.GetWidth(), 8 )/8;
// Let GDI+ work its magic
Gdiplus::Bitmap bmDest(
bmSrc.GetWidth(),
bmSrc.GetHeight(),
nBytesPerRow, // GetPitch(),
eDestPixelFormat, m_pDst); //static_cast< BYTE* >( GetBits() ) );
Gdiplus::Graphics gDest( &bmDest );
gDest.DrawImage( &bmSrc, 0, 0 );
}
}
initGDIPlus.Unit();
};
