Пример #1
0
void CVideoPane::OnPaint()
{
	CPaintDC dc(this); // device context for painting
	// TODO: Add your message handler code here
	// Do not call CDialog::OnPaint() for painting messages

	// 绘制标题栏
	if (NULL != m_pImgCaption)
	{
		// 设置坐标
		CRect rect;
		GetClientRect(rect);
		Gdiplus::Rect gRect(rect.left, rect.top, rect.right, CAPTION_HEIGHT);
		Gdiplus::ImageAttributes ImgAtt;
		ImgAtt.SetWrapMode(Gdiplus::WrapModeTileFlipXY); 
		Gdiplus::Graphics graphics(dc);
		graphics.DrawImage(m_pImgCaption, gRect, 0, 0, (INT)m_pImgCaption->GetWidth(), (INT)m_pImgCaption->GetHeight(), Gdiplus::UnitPixel, &ImgAtt);
	}

	// 标题栏文本
	CRect rect;
	GetClientRect(rect);
	rect.left += BTN_CLOSE_SPACE;
	rect.bottom = CAPTION_HEIGHT;
	dc.SetBkMode(CAPTION_FONT_BKCLR);
	dc.SetTextColor(CAPTION_FONT_COLOR);
	CFont font;
	font.CreateFont(CAPTION_FONT_SIZE, 0, 0, 0, FW_NORMAL, FALSE,FALSE,FALSE,0,0,0,0,0,CAPTION_FONT_NAME);
	dc.SelectObject(font);
	dc.DrawText(m_strCaptionText, -1, &rect, DT_SINGLELINE | DT_VCENTER);
}
Пример #2
0
// *************************************************************
//		GetImageAttributes()
// *************************************************************
Gdiplus::ImageAttributes* ImageHelper::GetImageAttributes(IImage* img)
{
	if (!img) return NULL;

	Gdiplus::ImageAttributes* attr = new Gdiplus::ImageAttributes();

	attr->SetWrapMode(Gdiplus::WrapModeTileFlipXY);

	VARIANT_BOOL useTransparency;
	img->get_UseTransparencyColor(&useTransparency);

	OLE_COLOR clr1, clr2;
	img->get_TransparencyColor(&clr1);
	img->get_TransparencyColor2(&clr2);

	SetTransparency(*attr, useTransparency ? true : false, clr1, clr2);

	Gdiplus::ColorMatrix m = GetColorMatrix(img);
	attr->SetColorMatrix(&m);

	Gdiplus::REAL gamma;	
	img->get_Gamma(&gamma);
	attr->SetGamma(gamma);

	return attr;
}
bool CInstallDesktopTipWnd::LoadBkgImage()
{
    HRSRC hRes = FindResource(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDR_PNG_NEW), _T("png"));
    if(hRes == NULL)
    {
        return false;
    }
    DWORD dwResSize = SizeofResource(AfxGetInstanceHandle(), hRes);
    if(dwResSize <= 0)
    {
        return false;
    }
    HGLOBAL hResData = LoadResource(AfxGetInstanceHandle(), hRes);
    if(hResData == NULL)
    {
        return false;
    }
    LPVOID lpResourceData = LockResource(hResData);
    HGLOBAL hResourceBuffer = GlobalAlloc(GMEM_MOVEABLE, dwResSize);
    LPVOID lpResourceBuffer = GlobalLock(hResourceBuffer); 
    CopyMemory(lpResourceBuffer, lpResourceData, dwResSize);
    IStream* piStream = NULL; 
    if(CreateStreamOnHGlobal(hResourceBuffer, FALSE, &piStream) == S_OK)
    {
        m_Image = Image::FromStream(piStream);
        piStream->Release();
    }
    GlobalUnlock(hResourceBuffer);
    GlobalFree(hResourceBuffer);
    FreeResource(hResData);

    ATLASSERT(m_Image);
    m_ImageWidth = m_Image->GetWidth();
    m_ImageHeight = m_Image->GetHeight();

    m_ImageMemBitmap = CreateDefaultDIBSection(m_ImageWidth, m_ImageHeight);
    m_ImageMemDC = ::CreateCompatibleDC(NULL);
    ::SelectObject(m_ImageMemDC, m_ImageMemBitmap);

    Gdiplus::Graphics memGraphics(m_ImageMemDC);
    memGraphics.SetCompositingMode(CompositingModeSourceOver);
    memGraphics.SetCompositingQuality(CompositingQualityHighSpeed);
    BitBlt(m_ImageMemDC, 0, 0, m_ImageWidth, m_ImageHeight, NULL, 0, 0, BLACKNESS);
    Gdiplus::ImageAttributes imAtt; 	
    imAtt.SetWrapMode(Gdiplus::WrapModeTileFlipXY);
    memGraphics.DrawImage(m_Image, Gdiplus::Rect(0, 0, m_ImageWidth, m_ImageHeight),
        0, 0, m_ImageWidth, m_ImageHeight, Gdiplus::UnitPixel, &imAtt, NULL, NULL);

    return true;
}
Пример #4
0
void CVideoStatic::SetBackGroudImage(const CPaintDC& dc)
{
	// ¼ÓÔر³¾°logoͼƬ
	if (NULL == m_pImage)
	{
		m_pImage = Gdiplus::Image::FromFile(m_strLogoPath);
		if (NULL == m_pImage)
		{
			LOG_RUN_ERROR("m_pImage is null.");
			return;
		}
		else
		{
			if (Gdiplus::Ok != m_pImage->GetLastStatus())
			{
				std::string strPath = eLTE_Tool::UnicodeToANSI(m_strLogoPath.GetString()).c_str();
				LOG_RUN_ERROR("Gdiplus::Image::FromFile failed. (%s)", strPath.c_str());
				m_pImage = NULL;
				return;
			}
		}
	}

	// ¾ÓÖÐλÖüÆËã
	CRect rect;
	GetClientRect(&rect);
	int iWidth = (int)m_pImage->GetWidth();
	int iHeight = (int)m_pImage->GetHeight();
	if ((double)rect.right/rect.bottom > (double)iWidth/iHeight)
	{
		iHeight = rect.bottom / 3;
		iWidth = iHeight * (int)m_pImage->GetWidth() / (int)m_pImage->GetHeight();
	}
	else
	{
		iWidth = rect.right / 3;
		iHeight = iWidth * (int)m_pImage->GetHeight() / (int)m_pImage->GetWidth();
	}

	int iLeft = (rect.right - iWidth) / 2;
	int iTop = (rect.bottom - iHeight) / 2;

	// »æÖÆͼƬ
	Gdiplus::Graphics graphics(dc);
	Gdiplus::Rect gRect(iLeft, iTop, iWidth, iHeight);
	Gdiplus::ImageAttributes ImgAtt;
	ImgAtt.SetWrapMode(Gdiplus::WrapModeTileFlipXY);
	graphics.DrawImage(m_pImage, gRect, 0, 0, (INT)m_pImage->GetWidth(), (INT)m_pImage->GetHeight(), Gdiplus::UnitPixel, &ImgAtt);
}
Пример #5
0
BOOL CBSObject::DrawPNG(HDC hDC, const RECT &rectDst, Gdiplus::Image* pImage, const RECT* prectImagePortion /*= NULL*/)
{
	BOOL bRet = FALSE;

    if (pImage > 0)
    {
        Gdiplus::Graphics graphics(hDC);

        Gdiplus::RectF cRectF(static_cast<Gdiplus::REAL>(rectDst.left), 
            static_cast<Gdiplus::REAL>(rectDst.top), 
            static_cast<Gdiplus::REAL>(rectDst.right - rectDst.left), 
            static_cast<Gdiplus::REAL>(rectDst.bottom - rectDst.top));
								
	    Gdiplus::ImageAttributes clImgAtt;
	    clImgAtt.SetWrapMode(Gdiplus::WrapModeTileFlipXY);

        if (NULL == prectImagePortion)
		{
			graphics.DrawImage(pImage, 
                cRectF, 
                static_cast<Gdiplus::REAL>(0), 
                static_cast<Gdiplus::REAL>(0),
                static_cast<Gdiplus::REAL>(pImage->GetWidth()), 
                static_cast<Gdiplus::REAL>(pImage->GetHeight()),
				Gdiplus::UnitPixel, 
                &clImgAtt); //
		}
		else
        {
			graphics.DrawImage(pImage, 
                cRectF, 
                static_cast<Gdiplus::REAL>(prectImagePortion->left), 
				static_cast<Gdiplus::REAL>(prectImagePortion->top), 
				static_cast<Gdiplus::REAL>(prectImagePortion->right - prectImagePortion->left), 
				static_cast<Gdiplus::REAL>(prectImagePortion->bottom - prectImagePortion->top), 
				Gdiplus::Unit::UnitPixel, 
				NULL, //&clImgAtt
				NULL, 
				NULL);
		}

        bRet = TRUE;
    }

	return bRet;
}
Пример #6
0
// *************************************************************
//		GetImageAttributes()
// *************************************************************
Gdiplus::ImageAttributes* ImageHelper::GetImageAttributes(float alpha, bool useTransparency, OLE_COLOR clr1, OLE_COLOR clr2)
{
	Gdiplus::ImageAttributes* attr = new Gdiplus::ImageAttributes();

	attr->SetWrapMode(Gdiplus::WrapModeTileFlipXY);

	Gdiplus::ColorMatrix matrix;

	ZeroMemory((void*)&matrix.m, 25 * sizeof(REAL));
	for (int i = 0; i < 5; i++) matrix.m[i][i] = 1.0f;

	matrix.m[3][3] = alpha;
	attr->SetColorMatrix(&matrix);

	SetTransparency(*attr, useTransparency, clr1, clr2);

	return attr;
}
Пример #7
0
Gdiplus::Bitmap* CSkinUnitODL::CreateImageData( INT nGroutX, INT nGroutY, INT nSrcWidth, INT nSrcHeight, Gdiplus::Color clBackground, CString strPicPath )
{
	//定义目标图片:代表宽度、高度,水泥槽宽度
	Gdiplus::Bitmap *img=new Gdiplus::Bitmap(nSrcWidth + nGroutX, nSrcHeight + nGroutY);
	//计算点的最大最小位置
	Gdiplus::Bitmap bmp(strPicPath);
	Gdiplus::Graphics buffer(img);//Gaphics对象引用内存画布   
	buffer.SetSmoothingMode(Gdiplus::SmoothingModeHighQuality);//SmoothingModeAntiAlias);
	buffer.ResetTransform();
	buffer.Clear(clBackground);
	{
		Gdiplus::ImageAttributes attImage;
		attImage.SetWrapMode(Gdiplus::WrapMode::WrapModeTile);

		Gdiplus::Rect rtDraw(nGroutX/2, nGroutY/2, nSrcWidth, nSrcHeight);
		//图片原始尺寸在bmp内,画到 x,y点, 需要原始图片的位置是 srcX, srcY, 目标图形区域大小是 srcWidth, srcHeight
		buffer.DrawImage(&bmp, rtDraw, 0, 0, bmp.GetWidth(), bmp.GetHeight(), Gdiplus::Unit::UnitPixel, &attImage);
	}

	return img;
}
Пример #8
0
BOOL CDuiImgX::StretchBlt(HDC hdc,int x,int y,int nWid,int nHei,int xSrc,int ySrc,int nWidSrc,int nHeiSrc,BYTE byAlpha/*=0xFF*/)
{
    if(IsEmpty()) return FALSE;
    Gdiplus::Graphics graphics(hdc);
	Gdiplus::ImageAttributes ImgAtt;
	ImgAtt.SetWrapMode(Gdiplus::WrapModeTileFlipXY);
    if(byAlpha!=0xFF)
    {
        Gdiplus::ColorMatrix ClrMatrix =
        {
            1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
            0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
            0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
            0.0f, 0.0f, 0.0f, float(byAlpha)/0xFF, 0.0f,
            0.0f, 0.0f, 0.0f, 0.0f, 1.0f
        };
        ImgAtt.SetColorMatrix(&ClrMatrix);
    }

    return S_OK==graphics.DrawImage(m_pImg,Gdiplus::Rect(x,y,nWid,nHei),xSrc,ySrc,nWidSrc,nHeiSrc,Gdiplus::UnitPixel,&ImgAtt);
}
Пример #9
0
    void CanvasGdiplus::TileImageInt(const Bitmap& bitmap,
        int src_x, int src_y, int dest_x, int dest_y, int w, int h)
    {
        if(!IntersectsClipRectInt(dest_x, dest_y, w, h))
        {
            return;
        }

        Gdiplus::Graphics* current = GetCurrentGraphics();
        if(!bitmap.IsNull())
        {
            Gdiplus::Bitmap* native_bitmap = bitmap.GetNativeBitmap();
            Gdiplus::ImageAttributes ia;
            ia.SetWrapMode(Gdiplus::WrapModeTile);
            Gdiplus::Rect rc_dest(dest_x, dest_y, w, h);
            current->DrawImage(native_bitmap,
                rc_dest, src_x, src_y,
                native_bitmap->GetWidth()-src_x,
                native_bitmap->GetHeight()-src_y,
                Gdiplus::UnitPixel, &ia);
        }
    }
Пример #10
0
	HBITMAP g_create_hbitmap_from_image(Gdiplus::Bitmap & bm, t_size & cx, t_size & cy, COLORREF cr_back, bool b_reflection)
	{
		HDC dc=NULL, dcc=NULL;
		dc = GetDC(NULL);
		dcc = CreateCompatibleDC(dc);
		//cy = bm.GetHeight();
		if (b_reflection)
			cy = cx;//(cy*11 -7) / 14;
		t_size ocx=cx,ocy=cy;

		t_size cx_source = bm.GetWidth(), cy_source = bm.GetHeight();


		double ar_source = (double)cx_source / (double)cy_source;
		double ar_dest = (double)ocx / (double)ocy;
		//unsigned cx = RECT_CX(rc), cy = RECT_CY(rc);

		if (ar_dest < ar_source)
			cy = (unsigned)floor((double)ocx / ar_source);
		else if (ar_dest > ar_source)
			cx = (unsigned)floor((double)ocy * ar_source);

		//cy = (unsigned)floor((double)ocx / ar_source);
		if ( (ocx - cx) % 2) cx++;

		t_size reflect_cy = b_reflection ? (cy*3)/11 : 0;
		HBITMAP bitmap = CreateCompatibleBitmap(dc, cx, cy + reflect_cy);
		HBITMAP bm_old = SelectBitmap(dcc, bitmap);

		unsigned err = 0;
		Gdiplus::Graphics graphics(dcc);
		err = graphics.GetLastStatus();
		graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHighQuality);
		graphics.SetInterpolationMode(Gdiplus::InterpolationModeHighQualityBicubic);

		Gdiplus::SolidBrush br(Gdiplus::Color(LOBYTE(LOWORD(cr_back)),HIBYTE(LOWORD(cr_back)),LOBYTE(HIWORD(cr_back)) ));
		graphics.FillRectangle(&br, 0, 0, cx, cy + reflect_cy);

		//if (cx_source>=2 && cy_source>=2)
		{
			{
#if 1
				Gdiplus::ImageAttributes imageAttributes;
				imageAttributes.SetWrapMode(Gdiplus::WrapModeTileFlipXY);
				Gdiplus::Rect destRect(0, 0, cx, cy);
				graphics.DrawImage(&bm, destRect, 0, 0, cx_source, cy_source, Gdiplus::UnitPixel, &imageAttributes);
#else
				if (cx_source == cx && cy_source == cy)
				{
					Gdiplus::Rect destRect(0, 0, cx, cy);
					graphics.SetInterpolationMode(Gdiplus::InterpolationModeNearestNeighbor);
					graphics.DrawImage(&bm, destRect, 0, 0, cx_source, cy_source, Gdiplus::UnitPixel);
					graphics.SetInterpolationMode(Gdiplus::InterpolationModeHighQualityBicubic);
				}
				else
				{
					Gdiplus::Rect destRect(-1, -1, cx+2, cy+2);
					//Gdiplus::Rect destRect(0, 0, cx, cy);
					graphics.DrawImage(&bm, destRect, 0, 0, cx_source, cy_source, Gdiplus::UnitPixel);
				}
#endif
			}

			{
				Gdiplus::Bitmap scaled(bitmap, NULL);
				t_size i;
				if (reflect_cy)
				{

					Gdiplus::Rect rectref(0, cy, cx, reflect_cy);
					Gdiplus::Color cr_end(255,LOBYTE(LOWORD(cr_back)),HIBYTE(LOWORD(cr_back)),LOBYTE(HIWORD(cr_back)));
					Gdiplus::Color cr_start(148,LOBYTE(LOWORD(cr_back)),HIBYTE(LOWORD(cr_back)),LOBYTE(HIWORD(cr_back)));
					//Gdiplus::Color cr_middle(100,255,255,255);
					Gdiplus::Rect destRect(0, cy, cx, reflect_cy);
					graphics.DrawImage(&scaled, destRect, 0, cy, cx, 0-reflect_cy, Gdiplus::UnitPixel);
					Gdiplus::LinearGradientBrush lgb(rectref, cr_start, cr_end, Gdiplus::LinearGradientModeVertical);
					graphics.FillRectangle(&lgb, rectref);
					//graphics.FillRectangle(&Gdiplus::SolidBrush(cr_middle), rectref);
					/*for (i=0; i<reflect_cy; i++)
					{
						Gdiplus::ImageAttributes attrib;
						Gdiplus::ColorMatrix mtrx = {0};
						mtrx.m[0][0] = 1;
						mtrx.m[1][1] = 1;
						mtrx.m[2][2] = 1;
						mtrx.m[3][3] = float(0.42) - (float(0.42)*(float(i)/float(reflect_cy)));
						mtrx.m[4][4] = 1;

						attrib.SetColorMatrix (&mtrx, Gdiplus::ColorMatrixFlagsDefault, Gdiplus::ColorAdjustTypeDefault);
						//Gdiplus::Rect sourceRect(0, cy-1-i, cx, cy-i);
						Gdiplus::Rect destRect(0, cy+i, cx, 1);
						graphics.DrawImage(&scaled, destRect, 0, cy-i-1, cx, 1, Gdiplus::UnitPixel, &attrib);
					}*/
				}
			}
			err = graphics.GetLastStatus();
		}
		//m_bitmap = pfc::rcnew_t<Gdiplus::CachedBitmap>(&bm, &_graphics);
		//err = m_bitmap->GetLastStatus();

		SelectBitmap(dcc, bm_old);

		DeleteDC(dcc);
		ReleaseDC(NULL, dc);

		return bitmap;
	}
Пример #11
0
BOOL CBSObject::DrawPNG(HDC hDC, const RECT &rectDst, const RECT* prectImagePortion, UINT Res, HINSTANCE hInst)
{
	BOOL bRet = FALSE;

    Gdiplus::Graphics graphics(hDC);

	HRSRC  hResource = ::FindResource(hInst,  MAKEINTRESOURCE(Res),  TEXT("PNG"));  
	if  (hResource > 0)
    {
	    DWORD  imageSize = ::SizeofResource(hInst, hResource);  
	    if  (imageSize > 0)
        {
            HGLOBAL hHandle = ::LoadResource(hInst,hResource);
            if (NULL != hHandle)
            {
                void* pResourceData = ::LockResource(hHandle);

                if  (pResourceData != NULL)  
                {
                    HGLOBAL hBuffer;
                    hBuffer = ::GlobalAlloc(GMEM_MOVEABLE, imageSize);  
                    if  (hBuffer)  
                    {  
                        void* pBuffer = ::GlobalLock(hBuffer);  
                        if  (pBuffer)  
                        {  
                            memcpy_s(pBuffer, imageSize, pResourceData, imageSize); //For stm0117
                            IStream*  pStream = NULL;  
                            if  (::CreateStreamOnHGlobal(hBuffer,  FALSE,  &pStream) == S_OK)  
                            {  
                                Gdiplus::Image cImage(pStream);
                                Gdiplus::RectF cRectF(static_cast<Gdiplus::REAL>(rectDst.left), 
                                    static_cast<Gdiplus::REAL>(rectDst.top), 
                                    static_cast<Gdiplus::REAL>(rectDst.right - rectDst.left), 
                                    static_cast<Gdiplus::REAL>(rectDst.bottom - rectDst.top));
                                Gdiplus::ImageAttributes clImgAtt;
								clImgAtt.SetWrapMode(Gdiplus::WrapModeTileFlipXY);
								if (NULL == prectImagePortion)
								{
									graphics.DrawImage(&cImage, 
                                        cRectF, 
                                        static_cast<Gdiplus::REAL>(0), 
                                        static_cast<Gdiplus::REAL>(0),
                                        static_cast<Gdiplus::REAL>(cImage.GetWidth()), 
                                        static_cast<Gdiplus::REAL>(cImage.GetHeight()),
										Gdiplus::UnitPixel, 
                                        &clImgAtt); //
								}
								else
                                {
									graphics.DrawImage(&cImage, 
                                        cRectF, 
                                        static_cast<Gdiplus::REAL>(prectImagePortion->left), 
										static_cast<Gdiplus::REAL>(prectImagePortion->top), 
										static_cast<Gdiplus::REAL>(prectImagePortion->right - prectImagePortion->left), 
										static_cast<Gdiplus::REAL>(prectImagePortion->bottom - prectImagePortion->top), 
										Gdiplus::Unit::UnitPixel, 
										NULL, 
										NULL, 
										NULL);
								}

                                pStream->Release();  
                                bRet = TRUE;
                            }  
                            ::GlobalUnlock(hBuffer);  
                        }  
                        ::GlobalFree(hBuffer);  
                        hBuffer  =  NULL;  
                    }
                }
            }
        }
    }

	return bRet;
}
Пример #12
0
HBITMAP g_load_png_gdiplus_throw(HDC dc, const char * fn, unsigned target_cx, unsigned target_cy)
{
	//FIXME m_gdiplus_initialised = (Gdiplus::Ok == Gdiplus::GdiplusStartup(&m_gdiplus_instance, &Gdiplus::GdiplusStartupInput(), NULL));
	pfc::string8 canPath;
	HBITMAP bm = 0;

	abort_callback_dummy p_abort;
	file::ptr p_file;
	filesystem::g_get_canonical_path(fn, canPath);
	filesystem::g_open_read(p_file, canPath, p_abort);
	t_size fsize = pfc::downcast_guarded<t_size>(p_file->get_size_ex(p_abort));
	pfc::array_staticsize_t<t_uint8> buffer(fsize);
	p_file->read(buffer.get_ptr(), fsize, p_abort);
	p_file.release();

	IStream *pStream = NULL;
	HGLOBAL gd = GlobalAlloc(GMEM_FIXED | GMEM_MOVEABLE, buffer.get_size());
	if (gd == NULL)
		throw exception_win32(GetLastError());
	void * p_data = GlobalLock(gd);
	if (p_data == NULL)
	{
		GlobalFree(gd);
		throw exception_win32(GetLastError());
	}

	memcpy(p_data, buffer.get_ptr(), buffer.get_size());
	GlobalUnlock(gd);

	HRESULT hr = CreateStreamOnHGlobal(gd, TRUE, &pStream);
	if (FAILED(hr))
	{
		GlobalFree(gd);
		throw exception_win32(hr);
	}

	Gdiplus::Bitmap pImage(pStream);

	CheckGdiplusStatus() << pImage.GetLastStatus();
	{
		Gdiplus::BitmapData bitmapData;
		//Gdiplus::Bitmap * ppImage = &pImage;
		if (target_cx != pfc_infinite || target_cy != pfc_infinite)
		{
			Gdiplus::Bitmap pBitmapResized(target_cx == pfc_infinite ? pImage.GetWidth() : target_cx, target_cy == pfc_infinite ? pImage.GetHeight() : target_cy, PixelFormat32bppARGB);
			CheckGdiplusStatus() << pBitmapResized.GetLastStatus();
			Gdiplus::Graphics pGraphics(&pBitmapResized);
			CheckGdiplusStatus() << pGraphics.GetLastStatus();
			CheckGdiplusStatus() << pGraphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHighQuality);
			CheckGdiplusStatus() << pGraphics.SetInterpolationMode(Gdiplus::InterpolationModeBicubic);
			Gdiplus::ImageAttributes imageAttributes;
			CheckGdiplusStatus() << imageAttributes.SetWrapMode(Gdiplus::WrapModeTileFlipXY);
			CheckGdiplusStatus() << pGraphics.DrawImage(&pImage, Gdiplus::Rect(0, 0, pBitmapResized.GetWidth(), pBitmapResized.GetHeight()), 0, 0, pImage.GetWidth(), pImage.GetHeight(), Gdiplus::UnitPixel, &imageAttributes);

			CheckGdiplusStatus() << pBitmapResized.LockBits(&Gdiplus::Rect(0, 0, pBitmapResized.GetWidth(), pBitmapResized.GetHeight()), Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, &bitmapData);
			bm = g_CreateHbitmapFromGdiplusBitmapData32bpp(bitmapData);
			CheckGdiplusStatus() << pBitmapResized.UnlockBits(&bitmapData);
		}
		else
		{
			CheckGdiplusStatus() << pImage.LockBits(&Gdiplus::Rect(0, 0, pImage.GetWidth(), pImage.GetHeight()), Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, &bitmapData);
			//assert bitmapData.Stride == bitmapData.Width
			bm = g_CreateHbitmapFromGdiplusBitmapData32bpp(bitmapData);
			CheckGdiplusStatus() << pImage.UnlockBits(&bitmapData);
		}
	}
	return bm;

}