lyfz_repos/经典版源码/Others/ShowImg/ShowImg/ShowImgs.cpp

#include "StdAfx.h"
#include "ShowImgs.h"

CShowImgs::CShowImgs(void)
{
	m_nLoadType = Load_Thumbnail;
	m_nMaxLoadImg = 5;

	m_pShowDC = NULL;
	m_pAryOfImgPath = NULL;
	m_pAryOfThumbImgPath = NULL;

	m_pCurShowImg = NULL;
	m_pCurShowThumImg = NULL;

	m_nCurShowIndex = 0;

	// 获得屏幕的宽（像素值）;
	double fx = GetSystemMetrics(SM_CXSCREEN);
	// 获得屏幕的高（像素值）;
	double fy = GetSystemMetrics(SM_CYSCREEN);
}

CShowImgs::~CShowImgs(void)
{
#if NOUSECLASS
	// 释放原图;
	if ( m_pAryLoadImgPtr.GetSize() )
	{
		for (INT i = m_pAryLoadImgPtr.GetSize() -1 ; i >= 0; i--)
		{
			DELETEP(m_pAryLoadImgPtr.ElementAt(i))
			m_pAryLoadImgPtr.RemoveAt(i);
		}
	}

	// 释放缩略图;
	if ( m_pAryLoadThumbImgPtr.GetSize() )
	{
		for (INT i = m_pAryLoadThumbImgPtr.GetSize() -1 ; i >= 0; i--)
		{
			DELETEP(m_pAryLoadThumbImgPtr.ElementAt(i))
				m_pAryLoadThumbImgPtr.RemoveAt(i);
		}
	}

	// 释放图片路径索引;
	if ( m_AryLoadIndex.GetSize() )
	{
		m_AryLoadIndex.RemoveAll();
	}
#else
	if ( m_AryOfLoadedImg.GetSize() )
	{
		for ( INT i = m_AryOfLoadedImg.GetSize() -1; i >= 0; i-- )
		{
			DELETEP(m_AryOfLoadedImg.ElementAt(i))
			m_AryOfLoadedImg.RemoveAt(i);
		}
	}
#endif

	// 释放显示的图片;
	DELETEP(m_pCurShowImg)
	DELETEP(m_pCurShowThumImg)
}


//////////////////////////////////////////////////////////////////////////
BOOL CShowImgs::LoadImgFromFile(IN Image** pImg, LPCTSTR lpPath)
{
	if ( !PathFileExists(lpPath) )
		return FALSE;

	if ( *pImg )
		delete *pImg;

	*pImg  = NULL;

#ifdef UNICODE
	*pImg = Image::FromFile(lpPath);
#else
	BSTR strtmp = _bstr_t(lpPath);
	*pImg = Image::FromFile(strtmp);
	SysFreeString(strtmp);
#endif

	return (*pImg ? TRUE : FALSE);
}

BOOL CShowImgs::LoadImgFromBuffer(IN Image** pImg, IN BYTE* pBuffer, IN CONST INT& nBufLen)
{
	if ( pBuffer == NULL )
		return FALSE;

	if ( *pImg )
		delete *pImg;

	*pImg  = NULL;
	HGLOBAL hMemery = GlobalAlloc(GMEM_MOVEABLE, nBufLen);
	if ( hMemery == NULL )
		return FALSE;

	BYTE *pMem = (BYTE*)GlobalLock(hMemery);
	memcpy(pMem, pBuffer, nBufLen);

	IStream *pstream = NULL;
	CreateStreamOnHGlobal(hMemery, TRUE, &pstream);
	*pImg = Image::FromStream(pstream);
	GlobalUnlock(hMemery);
	pstream->Release();

	return (*pImg ? TRUE : FALSE);
}

// 先以只读方式从文件中读取二进制流出来，可以做到不独占文件;
BOOL CShowImgs::LoadImgFromBuffer(IN Image** pImg, LPCTSTR lpPath)
{
	if ( !PathFileExists(lpPath) )
		return FALSE;

	if ( *pImg )
		delete *pImg;
	*pImg  = NULL;

	CFile fp;
	CFileException e;
	BOOL bRet = FALSE;
	if ( fp.Open(lpPath, CFile::modeRead, &e))
	{
		DWORD dwLength = (DWORD)fp.GetLength();
		BYTE *pData = new BYTE[dwLength];

		fp.Read(pData,dwLength);
		fp.Close();

		bRet = LoadImgFromBuffer(pImg, pData, dwLength);

		if( pData )
			delete []pData;
	}

	return bRet;
}

//////////////////////////////////////////////////////////////////////////
BOOL CShowImgs::GetOrientation(IN Image *pImg)
{
	if (pImg == NULL) return FALSE;

	UINT totalBufferSize;
	UINT numProperties;
	pImg->GetPropertySize(&totalBufferSize, &numProperties);
	// Allocate the buffer that will receive the property items.
	PropertyItem* pAllItems = (PropertyItem*)malloc(totalBufferSize);
	// Fill the buffer.
	pImg->GetAllPropertyItems(totalBufferSize, numProperties, pAllItems);
	// Print the id data member of each property item.
	for (UINT j = 0; j < numProperties; ++j)
	{
		if (PropertyTagOrientation == pAllItems[j].id)
		{
			short* ptrLong = (short*)(pAllItems[j].value);
			int ret = (int)*ptrLong;
			free(pAllItems);
			return ret;
		}
	}
	free(pAllItems);

	return TRUE;
}

/************************************************************************/
/*
	函数:GetEncoderClsid
	描述:获取GDI+支持的图像格式编码器种类,以及所有种类编码器信息;
	参数:
		IN:  format 要获取的图像格式;
		OUT: pClsid 返回符合条件的图像编码器信息;
	返回:成功返回编码器索引,否则返回-1;
*/
/************************************************************************/
int CShowImgs::GetEncoderClsid(IN CONST WCHAR* format, OUT CLSID* pClsid)
{
	// CD+支持的图像编码器数量;
	UINT  numEncoders = 0;
	// 每个图像编码器以数组形式保存的大小;
	UINT  nSize = 0;

	ImageCodecInfo* pImageCodecInfo = NULL;

	// 获取GDI+支持的图像格式编码器种类数以及ImageCodecInfo数组的存放大小;
	GetImageEncodersSize(&numEncoders, &nSize);
	if (nSize == 0)
		return -1;

	// 为ImageCodecInfo数组分配足额空间;
	pImageCodecInfo = (ImageCodecInfo*)(malloc(nSize));
	if (pImageCodecInfo == NULL)
		return -1;

	// 获取所有的图像编码器信息;
	GetImageEncoders(numEncoders, nSize, pImageCodecInfo);

	// 查找符合的图像编码器的Clsid;
	for (UINT i = 0; i < numEncoders; ++i)
	{
		if (wcscmp(pImageCodecInfo[i].MimeType, format) == 0)
		{
			*pClsid = pImageCodecInfo[i].Clsid;
			free(pImageCodecInfo);
			return i;  // Success
		}
	}

	// 释放步骤3分配的内存;
	free(pImageCodecInfo);

	return -1;
}

/************************************************************************/
/*
	函数:ZoomImg
	描述:缩放到指定大小的区域中,返回缩放后的尺寸;
	参数:
		IN:		Imgrc			图像的大小;
		IN:		dwDisplayPix	图像要显示的区域的大小;
		OUT:	dwZoomPix		图像在显示区域内缩放后的尺寸;
	返回:

	注意:dwZoomPix的尺寸必须在dwDisplayPix内;
*/
/************************************************************************/
int CShowImgs::ZoomImg(IN CRect &Imgrc, IN CONST DWORD &dwDisplayPix, OUT DWORD &dwZoomPix)
{
	double fDisplayWidth = GET_XPIX(dwDisplayPix);
	double fDisplayHeight = GET_YPIX(dwDisplayPix);

	// 显示区域长宽比;
	double fDisplayAspectRatio = fDisplayWidth / fDisplayHeight;

	// 图片长宽比;
	double fImgAspectRatio = ((double)Imgrc.Width()) / ((double)Imgrc.Height());

	double fZoomWidth;
	double fZoomHeight;

	if (fDisplayAspectRatio > fImgAspectRatio)
	{
		fZoomWidth = fDisplayHeight*fImgAspectRatio;
		fZoomHeight = fDisplayHeight;
	}
	else
	{
		fZoomWidth = fDisplayWidth;
		fZoomHeight = fDisplayWidth / fImgAspectRatio;
	}

	dwZoomPix = SET_PIX((int)fZoomWidth, (int)fZoomHeight);

	//////////////////////////////////////////////////////////////////////////
	int nRetval = 0;
	if ((fDisplayWidth == Imgrc.Width()) && (fDisplayHeight == Imgrc.Height()))
	{
		nRetval = ZoomNull;
	}
	else if ((fDisplayWidth > Imgrc.Width()) && (fDisplayHeight > Imgrc.Height()))
	{
		nRetval = ZoomOut;
	}
	else
	{
		nRetval = ZoomIn;
	}

	return nRetval;
}

int CShowImgs::ZoomImg(IN CONST DWORD &dwImgPix, IN CONST DWORD &dwDisplayPix, OUT DWORD &dwZoomPix)
{
	double fDisplayWidth = GET_XPIX(dwDisplayPix);
	double fDisplayHeight = GET_YPIX(dwDisplayPix);

	// 显示区域长宽比;
	double fDisplayAspectRatio = fDisplayWidth / fDisplayHeight;

	// 图片长宽比;
	double fImgAspectRatio = ((double)GET_XPIX(dwImgPix)) / ((double)GET_YPIX(dwImgPix));

	double fZoomWidth;
	double fZoomHeight;

	if (fDisplayAspectRatio > fImgAspectRatio)
	{
		fZoomWidth = fDisplayHeight*fImgAspectRatio;
		fZoomHeight = fDisplayHeight;
	}
	else
	{
		fZoomWidth = fDisplayWidth;
		fZoomHeight = fDisplayWidth / fImgAspectRatio;
	}

	dwZoomPix = SET_PIX((int)fZoomWidth, (int)fZoomHeight);

	//////////////////////////////////////////////////////////////////////////
	int nRetval = 0;
	if ((fDisplayWidth == GET_XPIX(dwImgPix)) && (fDisplayHeight == GET_YPIX(dwImgPix)))
	{
		nRetval = ZoomNull;
	}
	else if ((fDisplayWidth > GET_XPIX(dwImgPix)) && (fDisplayHeight > GET_YPIX(dwImgPix)))
	{
		nRetval = ZoomOut;
	}
	else
	{
		nRetval = ZoomIn;
	}

	return nRetval;
}

/************************************************************************/
/*  函数：LoadImgByIndex[3/18/2016 IT];
/*  描述：根据图片路径索引来加载要显示在DC上的图片;
/*  参数：;
/*  	[IN] nIndex：图片路径的索引，默认-1，表示使用m_nCurShowIndex;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
void CShowImgs::LoadImgByIndex(IN CONST INT& nIndex /* = -1 */)
{
	if ( nIndex != -1 )
		m_nCurShowIndex = nIndex;

	if ( m_nCurShowIndex < 0 ){
		OutputDebugString(_T("要加载的图片已超出索引范围(负数)!\n"));
		return;
	}

	BOOL bHasLoad = FALSE;
	if ( m_nLoadType == Load_Original || m_nLoadType == Load_Thumbnail)
	{// 原图;
		if ( m_nCurShowIndex >= m_pAryOfImgPath->GetSize() ){
			OutputDebugString(_T("要加载的原图片已超出索引范围!\n"));
			return;
		}

		m_pCurShowImg = NULL;
		if ( IsLoadTheIndexImg(m_nCurShowIndex) != -1)
		{// 加载过该路径索引的图片;
			m_pCurShowImg = m_AryOfLoadedImg.ElementAt(m_nCurShowIndex)->GetImgPtr();
		}
		else 
		{// 未加载过该路径索引的图片;
			if ( !LoadImgFromFile(&m_pCurShowImg, m_pAryOfImgPath->ElementAt(m_nCurShowIndex)) ) 
			{// 从文件中加载失败,使用空白图片代替;
				Bitmap *pNULLBmp = new Bitmap(100, 100, PixelFormat24bppRGB);
				Graphics graph(pNULLBmp);
				graph.Clear(Color(255, 0, 0, 0));

				CPerImg *pPerImg = new CPerImg;
				pPerImg->SetImgPtr(pNULLBmp);
				pPerImg->SetIndex(m_nCurShowIndex);
				m_AryOfLoadedImg.Add(pPerImg);
			}
			else
			{// 从文件中加载成功;
				CPerImg *pPerImg = new CPerImg;
				pPerImg->SetIndex(m_nCurShowIndex);
				pPerImg->SetImgPtr(m_pCurShowImg);

				m_AryOfLoadedImg.Add(pPerImg);
			}
		}
	}
	else if ( m_nLoadType == Load_both )
	{// 同时加载原图和缩略图;
		if ( m_pAryOfImgPath->GetSize() != m_pAryOfThumbImgPath->GetSize() ){
			OutputDebugString(_T("要加载的原图和缩略图数量不等!\n"));
			return;
		}

		if ( m_nCurShowIndex >= m_pAryOfImgPath->GetSize() ){
			OutputDebugString(_T("要加载的图片已超出索引范围!\n"));
			return;
		}

		m_pCurShowImg = m_pCurShowThumImg = NULL;
		if ( IsLoadTheIndexImg(m_nCurShowIndex) != -1)
		{// 加载过该路径索引的图片;
			m_pCurShowImg = m_AryOfLoadedImg.ElementAt(m_nCurShowIndex)->GetImgPtr();
			m_pCurShowThumImg = m_AryOfLoadedImg.ElementAt(m_nCurShowIndex)->GetThumbImgPtr();
		}
		else 
		{// 未加载过该路径索引的图片;
			if ( !LoadImgFromFile(&m_pCurShowImg, m_pAryOfImgPath->ElementAt(m_nCurShowIndex)) ) 
			{// 从文件中加载失败,使用空白图片代替;
				Bitmap *pNULLBmp = new Bitmap(100, 100, PixelFormat24bppRGB);
				Graphics graph(pNULLBmp);
				graph.Clear(Color(255, 0, 0, 0));
				Bitmap *pNULLThumbBmp = new Bitmap(100, 100, PixelFormat24bppRGB);
				Graphics graphOfThumb(pNULLThumbBmp);
				graphOfThumb.Clear(Color(255, 0, 0, 0));

				CPerImg *pPerImg = new CPerImg;
				pPerImg->SetImgPtr(pNULLBmp);
				pPerImg->SetThumbImgPtr(pNULLThumbBmp);
				pPerImg->SetIndex(m_nCurShowIndex);
				m_AryOfLoadedImg.Add(pPerImg);
			}
			else
			{// 从文件中加载成功;
				if ( !LoadImgFromFile(&m_pCurShowThumImg, m_pAryOfThumbImgPath->ElementAt(m_nCurShowIndex)) )
				{// 从文件中加载失败,使用空白图片代替;
					Bitmap *pNULLBmp = new Bitmap(100, 100, PixelFormat24bppRGB);
					Graphics graph(pNULLBmp);
					graph.Clear(Color(255, 0, 0, 0));
					m_pCurShowThumImg = pNULLBmp;
				}

				CPerImg *pPerImg = new CPerImg;
				pPerImg->SetIndex(m_nCurShowIndex);
				pPerImg->SetImgPtr(m_pCurShowImg);
				pPerImg->SetThumbImgPtr(m_pCurShowThumImg);

				m_AryOfLoadedImg.Add(pPerImg);
			}
		}
	}
	else 
	{
		ATLTRACE("没有该类型的图片路径!\n");
	}
}

/************************************************************************/
/*  函数：[3/18/2016 IT];
/*  描述：;
/*  参数：;
/*  	[IN] ：;
/*  	[OUT] ：;
/*  	[IN/OUT] ：;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
void CShowImgs::ReleaseExtraImg()
{
	if ( m_AryOfLoadedImg.GetSize() > m_nMaxLoadImg )
	{
		for ( INT i = m_AryOfLoadedImg.GetSize() -1; i > m_nMaxLoadImg; i-- )
		{
			DELETEP(m_AryOfLoadedImg.ElementAt(i))
			m_AryOfLoadedImg.RemoveAt(i);
		}
	}
}

/************************************************************************/
/*  函数：IsLoadTheIndexImg[3/18/2016 IT];
/*  描述：指定路径索引的图片是否已加载过;
/*  参数：;
/*  	[IN] nIndex：要加载的图片路径索引，默认-1，表示使用m_nCurShowIndex;;
/*  返回：已加载返回路径索引, 否则返回-1;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
INT CShowImgs::IsLoadTheIndexImg(IN CONST INT& nIndex /* = -1 */)
{
	if ( nIndex != -1 )
		m_nCurShowIndex = nIndex;

	INT nIndexOfPath = -1;
#if NOUSECLASS
	for ( INT i = 0; i < m_AryLoadIndex.GetSize(); i++ ){
		if ( m_nCurShowIndex == m_AryLoadIndex.ElementAt(i) ){
			nIndexOfPath = i;
			break;
		}//if;
	}//for;
#else
	for ( INT i = 0; i < m_AryOfLoadedImg.GetSize(); i++ )
	{
		if ( m_nCurShowIndex == m_AryOfLoadedImg.ElementAt(i)->GetIndex() ){
			nIndexOfPath = i;
			break;
		}
	}
#endif
	return nIndexOfPath;
}