enbitmap.cpp

强大易用的邮件收发客户端

		bmpi.biSize = sizeof(bmpi);
		GetDIBits(dcSrc, (HBITMAP)*this, 0, 0, NULL, (BITMAPINFO*)&bmpi, DIB_RGB_COLORS);		

		int nSize = bmpi.biHeight * ((bmpi.biWidth * 4 + 3) & ~3);

		// get source bitmap data
		BYTE* pData = new BYTE[nSize];
		GetDIBits(dcSrc, (HBITMAP)*this, 0, bmpi.biHeight, pData, (BITMAPINFO*)&bmpi, DIB_RGB_COLORS);

		// create new bitmap
		BYTE* pDest = NULL;
		HBITMAP hBmp = CreateDIBSection(dcSrc, (BITMAPINFO*)&bmpi, DIB_RGB_COLORS, (void**)&pDest, NULL, 0);
		if (hBmp)
		{
			DeleteObject();
			Attach(hBmp);
			memcpy(pDest, pData, nSize);
			delete[] pData;
			return TRUE;
		}
		delete[] pData;
		// if failed, work with simple
	}
	
	int R = GetRValue(bk);
	int G = GetGValue(bk);
	int B = GetBValue(bk);

	CAlpher alpha;
	alpha.SetBkColor(R, G, B);
	
	BITMAP BM;
	if (!::GetObject(GetSafeHandle(), sizeof(BM), &BM) || BM.bmBitsPixel!=32)
		alpha.UseCompatMode();
	
	ProcessImage(&alpha);
	return FALSE;
}

BOOL CEnBitmap::MakeDisabled(COLORREF bk, int nSize)
{
	int R = GetRValue(bk);
	int G = GetGValue(bk);
	int B = GetBValue(bk);

	CImageHigh high(0.2f);
	high.SetBkColor(R, G, B);
	CImageGrayer gray;
	gray.SetBkColor(R, G, B);

	C32BIPArray aProcessors;
	aProcessors.Add(&gray);
	for (int i=0; i<1; i++)
		aProcessors.Add(&high);
 
	CImageShadow shadow(RGB(255, 255, 255), nSize);
	shadow.SetBkColor(R, G, B);
	aProcessors.Add(&shadow);

	return ProcessImage(aProcessors);
}
BOOL CEnBitmap::MakeDisabled32(COLORREF bk, int nSize)
{
	int R = GetRValue(bk);
	int G = GetGValue(bk);
	int B = GetBValue(bk);

	CImageHigh high(0.2f);
	high.SetBkColor(R, G, B);
	CImageGrayer gray;
	gray.SetBkColor(R, G, B);

	C32BIPArray aProcessors;
	aProcessors.Add(&gray);
	//for (int i=0; i<1; i++)
	//	aProcessors.Add(&high);

	CImageAlpha al(0.7);
	al.SetBkColor(R, G, B);
	aProcessors.Add(&al);
 
	CImageShadow shadow(RGB(255, 255, 255), nSize);
	shadow.SetBkColor(R, G, B);
	//aProcessors.Add(&shadow);

	return ProcessImage(aProcessors);
}

BOOL CEnBitmap::MakeNotActive(COLORREF bk)
{
	int R = GetRValue(bk);
	int G = GetGValue(bk);
	int B = GetBValue(bk);

	C32BIPArray aProcessors;

	/*
	CImageHigh high(-0.02f);	// darker
	high.SetBkColor(R, G, B);
	aProcessors.Add(&high);
	aProcessors.Add(&high);
	*/

	CImageHigh high2(0.025f);	// darker
	high2.SetBkColor(R, G, B);
	aProcessors.Add(&high2);
	aProcessors.Add(&high2);

	return ProcessImage(aProcessors);
}

CImageAlpha::CImageAlpha(double dL)
{
	m_dAlpha = dL;
}
BOOL CImageAlpha::ProcessPixels(RGBX* pSrcPixels, CSize sizeSrc, RGBX* pDestPixels, CSize )
{
	RGBX btn(GetSysColor(COLOR_BTNFACE));
	
	for (int nX = 0; nX < sizeSrc.cx; nX++)
	{
		for (int nY = 0; nY < sizeSrc.cy; nY++)
		{
			RGBX* pRGBSrc = &pSrcPixels[nY * sizeSrc.cx + nX];
			RGBX* pRGBDest = &pDestPixels[nY * sizeSrc.cx + nX];
			*pRGBDest = *pRGBSrc;
			if (!IsBkColor(pRGBSrc))
			{
				pRGBDest->btBlue = btn.btBlue + (pRGBSrc->btBlue - btn.btBlue)*m_dAlpha;
				pRGBDest->btRed = btn.btRed+ (pRGBSrc->btRed- btn.btRed)*m_dAlpha;
				pRGBDest->btGreen = btn.btGreen+ (pRGBSrc->btGreen - btn.btGreen)*m_dAlpha;
			}
		}
	}

	return TRUE;
}

BOOL CAlpher::ProcessPixels(RGBX* pSrcPixels, CSize sizeSrc, RGBX* pDestPixels, CSize )
{
	RGBX xB;
	if (m_bCompat)	// no alpha info -> just use first pixel as background
		xB = pSrcPixels[0];

	for (int nX = 0; nX < sizeSrc.cx; nX++)
	{
		for (int nY = 0; nY < sizeSrc.cy; nY++)
		{
			RGBX* pRGBSrc = &pSrcPixels[nY * sizeSrc.cx + nX];
			RGBX* pRGBDest = &pDestPixels[nY * sizeSrc.cx + nX];
			if (m_bCompat)
			{
				if (pRGBSrc->Equals(xB))
				{
					pRGBDest->btRed = m_nRed;
					pRGBDest->btGreen = m_nGreen;
					pRGBDest->btBlue = m_nBlue;
				}
				else
					*pRGBDest = *pRGBSrc;
				continue;
			}
			int nA = pRGBSrc->btAlpha;
			if (nA == 0)	// just back
			{
				pRGBDest->btRed = m_nRed;
				pRGBDest->btGreen = m_nGreen;
				pRGBDest->btBlue = m_nBlue;
			}
			else if (nA == 255)	// just src
				*pRGBDest = *pRGBSrc;
			else
			{
				pRGBDest->btRed = (pRGBSrc->btRed*nA+m_nRed*(255-nA))/255;
				pRGBDest->btGreen = (pRGBSrc->btGreen*nA+m_nGreen*(255-nA))/255;
				pRGBDest->btBlue = (pRGBSrc->btBlue*nA+m_nBlue*(255-nA))/255;
			}
			pRGBDest->btAlpha = 0;
		}
	}

	return TRUE;
}

BOOL CImageGrayer::ProcessPixels(RGBX* pSrcPixels, CSize sizeSrc, RGBX* pDestPixels, CSize )
{
	for (int nX = 0; nX < sizeSrc.cx; nX++)
	{
		for (int nY = 0; nY < sizeSrc.cy; nY++)
		{
			RGBX* pRGBSrc = &pSrcPixels[nY * sizeSrc.cx + nX];
			RGBX* pRGBDest = &pDestPixels[nY * sizeSrc.cx + nX];
			if (IsBkColor(pRGBSrc))
				*pRGBDest = *pRGBSrc;
			else
			{
				*pRGBDest = pRGBSrc->Gray();
				pRGBDest->btAlpha = pRGBSrc->btAlpha;
			}
		}
	}

	return TRUE;
}

CImageHigh::CImageHigh(float nL)
{
	m_fLumDecr = nL;
}

BOOL CImageHigh::ProcessPixels(RGBX* pSrcPixels, CSize sizeSrc, RGBX* pDestPixels, CSize )
{
	CColor cnv;

	for (int nX = 0; nX < sizeSrc.cx; nX++)
	{
		for (int nY = 0; nY < sizeSrc.cy; nY++)
		{
			RGBX* pRGBSrc = &pSrcPixels[nY * sizeSrc.cx + nX];
			RGBX* pRGBDest = &pDestPixels[nY * sizeSrc.cx + nX];
			if (IsBkColor(pRGBSrc))
				*pRGBDest = *pRGBSrc;
			else
			{
				cnv.SetRGB(pRGBSrc->btRed, pRGBSrc->btGreen, pRGBSrc->btBlue);
				float L = cnv.GetLuminance();

				if (m_fLumDecr>0 && L<1.0)
				{
					L = min(1, L+m_fLumDecr);
					cnv.SetLuminance(L);
				}
				else if (m_fLumDecr<0 && L>0)
				{
					L = max(0, L+m_fLumDecr);
					cnv.SetLuminance(L);
				}
			
				pRGBDest->btRed = (BYTE)cnv.GetRed();
				pRGBDest->btBlue= (BYTE)cnv.GetBlue();
				pRGBDest->btGreen = (BYTE)cnv.GetGreen();
				pRGBDest->btAlpha = pRGBSrc->btAlpha;
			}
		}
	}

	return TRUE;
}

BOOL CImageOffs::ProcessPixels(RGBX* pSrcPixels, CSize sizeSrc, RGBX* pDestPixels, CSize )
{
	COLORREF crBk = RGB(m_nRed, m_nGreen, m_nBlue);
	for (int nX = 0; nX < sizeSrc.cx; nX++)
	{
		for (int nY = 0; nY < sizeSrc.cy; nY++)
		{
			RGBX* pRGBDest = &pDestPixels[nY * sizeSrc.cx + nX];
			if (nY == (sizeSrc.cy-1))
			{
				*pRGBDest = crBk;
			}
			else
			{
				RGBX* pRGBSrc = &pSrcPixels[(nY+1) * sizeSrc.cx + nX];
				*pRGBDest = *pRGBSrc;
			}
		}
	}

	return TRUE;
}

BOOL CImageShadow::ProcessPixels(RGBX* pSrcPixels, CSize sizeSrc, RGBX* pDestPixels, CSize )
{
	for (int nX = 0; nX < sizeSrc.cx; nX++)
	{
		for (int nY = 0; nY < sizeSrc.cy; nY++)
		{
			RGBX* pRGBSrc = &pSrcPixels[nY * sizeSrc.cx + nX];
			RGBX* pRGBDest = &pDestPixels[nY * sizeSrc.cx + nX];
			if (IsBkColor(pRGBSrc))
			{
				if ((m_nSize==0 || (nX%m_nSize)>0) && 
					nY>0 && 
					!IsBkColor(&pSrcPixels[(nY-1) * sizeSrc.cx + nX-1]))
				{
					//pDestPixels[(nY-1) * sizeSrc.cx + nX-1] = GetSysColor(COLOR_3DSHADOW);
					*pRGBDest = m_clr;
				}
				else
					*pRGBDest = *pRGBSrc;
			}
			else
				*pRGBDest = *pRGBSrc;
		}
	}

	return TRUE;
}
struct Fileheader
 { unsigned short Type;          // signature - 'BM'
   unsigned  long Size;          // file size in bytes
   unsigned short Reserved1;     // 0
   unsigned short Reserved2;     // 0
   unsigned long  OffBits;       // offset to bitmap
   unsigned long  StructSize;    // size of this struct (40)
   unsigned long  Width;         // bmap width in pixels
   unsigned long  Height;        // bmap height in pixels
   unsigned short Planes;        // num planes - always 1
   unsigned short BitCount;      // bits per pixel
   unsigned long  Compression;   // compression flag
   unsigned long  SizeImage;     // image size in bytes
   long           XPelsPerMeter; // horz resolution
   long           YPelsPerMeter; // vert resolution
   unsigned long  ClrUsed;       // 0 -> color table size
   unsigned long  ClrImportant;  // important color count
};
int CEnBitmap::GetFileData(LPCTSTR sFile, BITMAP* pData)
{
	CFile file;
	try
	{
		if (!file.Open(sFile, CFile::modeRead, NULL))
			return FALSE;
		Fileheader fh;
		ZeroMemory(&fh, sizeof(fh));
		if (file.Read(&fh, sizeof(fh))!=sizeof(fh))
			return FALSE;
		file.Close();
		if (fh.Type != 0x4D42)
			return FALSE;
		pData->bmType = 0;
		pData->bmWidth = fh.Width;
		pData->bmHeight = fh.Height;
		pData->bmWidthBytes = 0;
		pData->bmPlanes = fh.Planes;
		pData->bmBitsPixel = fh.BitCount;
		pData->bmBits = 0;
	}
	catch(...)
	{
		return FALSE;
	}
	return TRUE;
}