getscreeninfo.cpp

软件源代码,共享。有2个文件

#include ".\getscreeninfo.h"
#include <windows.h>
#include <tchar.h>
#include "..\VipShellInfo\Lzw.h"

void LZW_Decode(BYTE* lzwBuf, BYTE* pOldScreenBuf)
{
	FCLzw lzw;
	lzw.LZW_Decode(lzwBuf, pOldScreenBuf);
}


CGetScreenInfo::CGetScreenInfo(void)
{
	m_ScreenData.pScreenData = NULL;
	m_ScreenDataLzw.pScreenData = NULL;
	m_ScreenData.dwBufLen = 0;
	m_ScreenDataLzw.dwBufLen = 0;
	m_dwBitCount = 8;
	m_bIsLock = false;
	m_pHash = new WORD [LZW_MAX_HASH_SIZE] ;
	m_hBitmap = NULL;
	m_dwScreenX = 0;
	m_dwScreenY = 0;
}

CGetScreenInfo::~CGetScreenInfo(void)
{
	if(m_hBitmap != NULL)
		DeleteObject(m_hBitmap);
	delete m_pHash;
	if(m_ScreenData.pScreenData != NULL)
		delete m_ScreenData.pScreenData;
	if(m_ScreenDataLzw.pScreenData != NULL)
		delete m_ScreenDataLzw.pScreenData;

}
DWORD CGetScreenInfo::GetBitCount()
{
	return m_dwBitCount;
}
void CGetScreenInfo::SetBitCount(DWORD dwBitCount)
{
	m_dwBitCount = dwBitCount;
}

void CGetScreenInfo::LockData(bool bLock)
{
	m_bIsLock = bLock;
}

void CGetScreenInfo::GetDataSource(BYTE** pBuff, DWORD* pdwLen, BYTE** pBuffLzw, DWORD* pdwLenLzw)
{
	LockData();
	DWORD dwRLzwLen = 0;
	if(pBuff)
		*pBuff = m_ScreenData.pScreenData;
	if(pdwLen)
		*pdwLen = m_ScreenData.dwBufLen;
	if(pBuffLzw)
	{
		if(m_ScreenData.dwBufLen > m_ScreenDataLzw.dwBufLen)
		{
			if(m_ScreenDataLzw.pScreenData != NULL)
				delete m_ScreenDataLzw.pScreenData;
			m_ScreenDataLzw.pScreenData = new BYTE[m_ScreenData.dwBufLen];
			if( !m_ScreenDataLzw.pScreenData )
			{
				m_ScreenDataLzw.dwBufLen = 0;
				return ;
			}
		}
		m_ScreenDataLzw.dwBufLen = m_ScreenData.dwBufLen;
		//压缩
		FCLzw lzw;
		memset(m_ScreenDataLzw.pScreenData, 0, m_ScreenData.dwBufLen);
		dwRLzwLen =  lzw.LZW_Encode(m_ScreenData.pScreenData, m_ScreenData.dwBufLen, m_ScreenDataLzw.pScreenData, m_pHash);
		*pBuffLzw = m_ScreenDataLzw.pScreenData;
	}
	if(pdwLenLzw)
			*pdwLenLzw = dwRLzwLen;
}


bool CGetScreenInfo::_BitmapToData(HBITMAP hBitmap, WORD nwBitCount)
{
	if(m_bIsLock)
		return false;
	HDC hDC;
	//当前分辨率下每象素所占字节数
	int iBits;
	//位图中每象素所占字节数
	WORD wBitCount;
	//定义调色板大小， 位图中像素字节大小 ，位图文件大小 ， 写入文件字节数
	DWORD dwPaletteSize=0, dwBmBitsSize=0, dwDIBSize=0, dwWritten=0;
	//位图属性结构
	BITMAP Bitmap;
	//位图文件头结构
	BITMAPFILEHEADER bmfHdr;
	//位图信息头结构
	BITMAPINFOHEADER bi;
	//指向位图信息头结构
	LPBITMAPINFOHEADER lpbi;
	//定义文件，分配内存句柄，调色板句柄
	HANDLE  /*hDib,*/ hPal,hOldPal=NULL;

	//计算位图文件每个像素所占字节数
//	hDC = CreateDC(_T("DISPLAY"), NULL, NULL, NULL);
	hDC = GetDC(GetDesktopWindow());
	iBits = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES);
//	DeleteDC(hDC);
	ReleaseDC(GetDesktopWindow(), hDC);
	if (iBits <= 1)
		wBitCount = 1;
	else if (iBits <= 4)
		wBitCount = 4;
	else if (iBits <= 8)
		wBitCount = 8;
	else
		wBitCount = 24;
	wBitCount = nwBitCount;
	if (wBitCount <= 8) 
		dwPaletteSize = (1 <<  wBitCount) *  sizeof(RGBQUAD);

	GetObject(hBitmap, sizeof(Bitmap), (LPSTR)&Bitmap);
	bi.biSize = sizeof(BITMAPINFOHEADER);
	bi.biWidth = Bitmap.bmWidth;
	bi.biHeight = Bitmap.bmHeight;
	bi.biPlanes = 1;
	bi.biBitCount = wBitCount;
	bi.biCompression = BI_RGB;
	bi.biSizeImage = 0;
	bi.biXPelsPerMeter = 0;
	bi.biYPelsPerMeter = 0;
	bi.biClrImportant = 0;
	bi.biClrUsed = 0;
	//	     dwBmBitsSize=          Bitmap.bmWidthBytes*Bitmap.bmHeight;
	dwBmBitsSize= ((Bitmap.bmWidth * wBitCount + 31) / 32) * 4 * Bitmap.bmHeight;
	//为位图内容分配内存 
	dwDIBSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwPaletteSize + dwBmBitsSize;
	if(m_ScreenData.dwBufLen < dwDIBSize)
	{
		if(m_ScreenData.pScreenData != NULL)
			delete m_ScreenData.pScreenData;
		m_ScreenData.pScreenData = new BYTE[dwDIBSize];
		
		if( !m_ScreenData.pScreenData )
		{
			m_ScreenData.dwBufLen = 0;
			return false;
		}
		m_ScreenData.dwBufLen = dwDIBSize ;

	}
	lpbi = (LPBITMAPINFOHEADER)(m_ScreenData.pScreenData + sizeof(BITMAPFILEHEADER));
	*lpbi = bi;
	// 处理调色板  
	hPal = GetStockObject(DEFAULT_PALETTE);
	if (hPal)
	{ 
		hDC = GetDC(NULL);
		hOldPal = SelectPalette(hDC, (HPALETTE)hPal, FALSE);
		RealizePalette(hDC);
	}

	GetDIBits(hDC, hBitmap, 0, (UINT) Bitmap.bmHeight, (LPSTR)lpbi + sizeof(BITMAPINFOHEADER) 
		+dwPaletteSize, (BITMAPINFO *)lpbi, DIB_RGB_COLORS);
	//恢复调色板
	if (hOldPal)
	{
		SelectPalette(hDC, (HPALETTE)hOldPal, TRUE);
		RealizePalette(hDC);
		ReleaseDC(NULL, hDC);
	}

	// 设置位图文件头 
	bmfHdr.bfType = 0x4D42; // "BM"
	bmfHdr.bfSize = dwDIBSize;
	bmfHdr.bfReserved1 = 0;
	bmfHdr.bfReserved2 = 0;
	bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER) + dwPaletteSize;

	memcpy(m_ScreenData.pScreenData, &bmfHdr, sizeof(BITMAPFILEHEADER));


	return true;
}
HBITMAP CGetScreenInfo::__CreateCompatibleBitmap(HDC hdc, DWORD nWidth, DWORD nHeight)
{
	if( m_dwScreenX != nWidth || nHeight != m_dwScreenY)
	{
		if(!m_hBitmap)
			DeleteObject(m_hBitmap);
		m_hBitmap = CreateCompatibleBitmap(hdc, nWidth, nHeight);
		m_dwScreenX = nWidth;
		m_dwScreenY = nHeight;
	}
	return m_hBitmap;
}
HBITMAP CGetScreenInfo::CopyScreenToBitmap(LPRECT lpRect)
{
//	DeleteObject(m_hBitmap);
	HICON hIcon = GetCursor();
	HDC       hScrDC, hMemDC;      
	// 屏幕和内存设备描述表
	HBITMAP    hBitmap, hOldBitmap;   
	// 位图句柄
	int       nX, nY, nX2, nY2;      
	// 选定区域坐标
	int       nWidth, nHeight;      
	// 位图宽度和高度
	int       xScrn, yScrn;         
	// 屏幕分辨率

	// 确保选定区域不为空矩形
	if (IsRectEmpty(lpRect))
		return NULL;
	//为屏幕创建设备描述表
//	hScrDC = CreateDC(_T("DISPLAY"), NULL, NULL, NULL);
	hScrDC = GetDC(GetDesktopWindow());
	//为屏幕设备描述表创建兼容的内存设备描述表
	hMemDC = CreateCompatibleDC(hScrDC);
	// 获得选定区域坐标
	nX = lpRect->left;
	nY = lpRect->top;
	nX2 = lpRect->right;
	nY2 = lpRect->bottom;
	// 获得屏幕分辨率
	xScrn = GetDeviceCaps(hScrDC, HORZRES);
	yScrn = GetDeviceCaps(hScrDC, VERTRES);
	//确保选定区域是可见的
	if (nX < 0)
		nX = 0;
	if (nY < 0)
		nY = 0;
	if (nX2 > xScrn)
		nX2 = xScrn;
	if (nY2 > yScrn)
		nY2 = yScrn;
	nWidth = nX2 - nX;
	nHeight = nY2 - nY;
	// 创建一个与屏幕设备描述表兼容的位图
	hBitmap = __CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
	// 把新位图选到内存设备描述表中
	hOldBitmap =(struct HBITMAP__ *) SelectObject(hMemDC, hBitmap);
	// 把屏幕设备描述表拷贝到内存设备描述表中
	BitBlt(hMemDC, 0, 0, nWidth, nHeight,
		hScrDC, nX, nY, SRCCOPY);
//	POINT ptMouse;
//	GetCursorPos(&ptMouse);
	
//	DrawIcon(hMemDC, ptMouse.x, ptMouse.y, hIcon);
	//得到屏幕位图的句柄
	hBitmap =(struct HBITMAP__ *) SelectObject(hMemDC, hOldBitmap);
	//清除 
//	DeleteDC(hScrDC);
	ReleaseDC(GetDesktopWindow(), hScrDC);
	DeleteDC(hMemDC);
	// 返回位图句柄

//	m_hBitmap = hBitmap;
	return hBitmap;
}

bool CGetScreenInfo::CopyScreenToData(LPRECT lpRect)
{
	if(!m_bIsLock)
	{
		HBITMAP hBitmap;
		hBitmap =  CopyScreenToBitmap(lpRect);
		if(hBitmap)
		{
			WORD dwBitCount = (WORD)GetBitCount();
			_BitmapToData(hBitmap, dwBitCount);
		//	DeleteObject(hBitmap);
			return true;
		}
		else
			return false;
	}
	return false;
}



COLORREF CGetColor::GetPixel(int nXPos, int nYPos)
{
	COLORREF cr = {0};
	RECT rcScreen;
	rcScreen.left = nXPos;
	rcScreen.top = nYPos;
	rcScreen.right = nXPos + 1;
	rcScreen.bottom = nYPos + 1;
	if(CopyScreenToData(&rcScreen))
	{
		BYTE* pData;
		DWORD dwLen;
		GetDataSource(&pData, &dwLen);
		DWORD dwBitCount = GetBitCount();
		DWORD dwPaletteSize = 0;
		if (dwBitCount <= 8) 
			dwPaletteSize = (1 <<  dwBitCount) *  sizeof(RGBQUAD);
		BITMAPFILEHEADER bmpFileHred;
		BITMAPINFOHEADER bi;
		memcpy(&bmpFileHred, pData, sizeof(BITMAPFILEHEADER));
		memcpy(&bi, pData + sizeof(BITMAPFILEHEADER), sizeof(BITMAPINFOHEADER));
		
		if(dwBitCount == 8)
		{
			DWORD DataSizePerLine = ((bi.biWidth * dwBitCount + 31) / 32) * 4;
			BYTE* pColor = pData +  sizeof(BITMAPFILEHEADER) +  sizeof(BITMAPINFOHEADER) + dwPaletteSize + DataSizePerLine * ( bi.biHeight - 1) + 0;
			BYTE bColor; memcpy(&bColor, pColor, sizeof(BYTE));
			int nColor = (int)bColor;
			RGBQUAD rgb;
			memcpy(&rgb, pData +  sizeof(BITMAPFILEHEADER) +  sizeof(BITMAPINFOHEADER) + (sizeof(RGBQUAD)*nColor) , sizeof(RGBQUAD));
			cr = RGB(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
		}
		if(dwBitCount == 24)
		{
			DWORD DataSizePerLine = ((bi.biWidth * dwBitCount + 31) / 32) * 4;
			BYTE* pColor = pData +  sizeof(BITMAPFILEHEADER) +  sizeof(BITMAPINFOHEADER) + 0 + DataSizePerLine * ( bi.biHeight - 1) + 0;
		//	BYTE bColor; memcpy(&bColor, pColor, sizeof(BYTE));
		//	int nColor = (int)bColor;
			RGBQUAD rgb;
			memcpy(&rgb, pColor , sizeof(RGBQUAD));
			cr = RGB(rgb.rgbRed, rgb.rgbGreen, rgb.rgbBlue);
		}
		LockData(false);
	}
	return cr;
}