/*
本源码由TC简单软件科技有限公司开源,功能可以自由修改、发布、
长沙简单软件科技有限公司对于源码不做后期维护,,请大家在使用过程中遵循开源协议
*/

#include "StdAfx.h"
#include "DXBind.h"
#include "windows.h"
#include "TSRuntime.h"
#include "TSHookFuntion.h"
#include "TsMessage.h"
#include "D3dx9tex.h"
#include "MapFile.h"
#include "CreateGif/Quantizer.h"
#include "CreateGif/GSKCreateGIF.h"
#include "TSMyUser32DllFuntion.h"
#include <imm.h>	
#include <cmath>
#include "TSVIPHookFuntion.h"
#pragma comment(lib,"imm32.lib")

//DLL所在的位置
extern TCHAR gDLLFolder[MAX_PATH + 1];

extern myIsWindow  my_IsWindow;
extern myGetWindowThreadProcessId my_GetWindowThreadProcessId;

//ZwWriteVirtualMemory
DWORD ZwWriteVirtualMemoryRet = 0;
DWORD ZwWriteVirtualMemoryEax = 0;
__declspec(naked) NTSTATUS WINAPI My_ZwWriteVirtualMemory(IN HANDLE               ProcessHandle,
	IN PVOID                BaseAddress,
	IN PVOID                Buffer,
	IN ULONG                NumberOfBytesToWrite,
	OUT PULONG              NumberOfBytesWritten OPTIONAL)
{
	_asm
	{
		mov eax, ZwWriteVirtualMemoryEax;
		push ZwWriteVirtualMemoryRet;
		ret;
	}
}

DWORD MyGetWindowThreadProcessIdRet = 0;
__declspec(naked) DWORD WINAPI MyGetWindowThreadProcessId(HWND hWnd, LPDWORD lpdwProcessId)
{
	_asm
	{
		mov edi, edi
		push ebp
		mov ebp, esp
		jmp MyGetWindowThreadProcessIdRet;
	}
}

extern DWORD ZwWriteVirtualMemoryRet;
extern DWORD ZwWriteVirtualMemoryEax;
__declspec(naked) NTSTATUS WINAPI My_ZwProtectVirtualMemory(IN HANDLE ProcessHandle,
	IN PVOID* BaseAddress,
	IN SIZE_T* NumberOfBytesToProtect,
	IN ULONG    NewAccessProtection,
	OUT PULONG  OldAccessProtection)
{
	_asm
	{
		//mov eax,0x4d ;//WIN7X64 偏移
		mov eax, Ntdll_ProtectVirtualEax;
		push Ntdll_ProtectVirtual;
		ret;
	}
}

extern DWORD ZwOpenProcessRet;
extern DWORD ZwOpenProcessEax;
__declspec(naked) NTSTATUS WINAPI MyZwOpenProcess(
	__out PHANDLE  ProcessHandle,
	__in ACCESS_MASK  DesiredAccess,
	__in POBJECT_ATTRIBUTES  ObjectAttributes,
	__in_opt PCLIENT_ID  ClientId
)
{
	_asm
	{
		mov eax, ZwOpenProcessEax;
		jmp ZwOpenProcessRet;
	}
}

HANDLE MyOpenProcess(int proid)
{
	HANDLE ProcessHandle = (HANDLE)0;
	OBJECT_ATTRIBUTES ObjectAttribute = { sizeof(OBJECT_ATTRIBUTES), 0,NULL,NULL };
	ObjectAttribute.Attributes = 0;
	CLIENT_ID ClientIds;
	ClientIds.UniqueProcess = (HANDLE)proid;
	ClientIds.UniqueThread = (HANDLE)0;
	MyZwOpenProcess(&ProcessHandle, PROCESS_ALL_ACCESS, &ObjectAttribute, &ClientIds);
	ProcessHandle;

	return ProcessHandle;
}

typedef NTSTATUS(__stdcall* ZwUnmapViewOfSection)(IN HANDLE  ProcessHandle, IN PVOID  BaseAddress);
ZwUnmapViewOfSection Zw_UnmapViewOfSection = NULL;


bool DXBind::Inject201()//201,203绑定
{
	//原理是在USER32InternalCallWinProc这个位置下钩子,执行定义好的汇编指令,加载我们的DLL
	bool success = false;
	DWORD InternalCallWinProc_Addr = 0;
	DWORD InternalCallWinProc_AddrRet = 0;
	InternalCallWinProc_Addr = (DWORD)::GetModuleHandle(L"user32.dll");
	if (winver == 1)//WinXP
		InternalCallWinProc_Addr += USER32InternalCallWinProcXPoffse;
	else if (winver == 2)//Win2003
		InternalCallWinProc_Addr += USER32InternalCallWinProcWin2003offse;
	else if (winver == 4 && TSRuntime::IsWin7X64)//WIN7X64
		InternalCallWinProc_Addr += USER32InternalCallProcWin7x64offse;
	else if (winver == 4)//WIN7X86
		InternalCallWinProc_Addr += USER32InternalCallProcWin7offse;
	else if (winver == 5 && TSRuntime::IsWin8X64)//WIN8X64
		InternalCallWinProc_Addr += USER32InternalCallProcWin8x64offse;
	else if (winver == 5)//WIN8X86
		InternalCallWinProc_Addr += USER32InternalCallProcWin8offse;

	PVOID pInternalCallProcAddr = (PVOID)InternalCallWinProc_Addr;

	InternalCallWinProc_AddrRet = InternalCallWinProc_Addr + 5;
	TSRuntime::EnablePrivilege(L"SeDebugPrivilege", true);
	HANDLE hprocess = NULL;
	DWORD dwwrite = 0;
	hprocess = MyOpenProcess(nPid);

	if (hprocess == NULL)
		return success;

	if (CallCodelen > 0)//先验证申请地址在当前进程是否存在
	{
		MEMORY_BASIC_INFORMATION   mbi;
		VirtualQueryEx(hprocess, Alloaddr, &mbi, sizeof(MEMORY_BASIC_INFORMATION));
		if (mbi.Protect != PAGE_EXECUTE_READWRITE)//说明已经不是原来的地址,需要重新申请地址
		{
			CallCodelen = 0;
			memset(CallCode, 0, 0x50);
		}

	}

	if (CallCodelen == 0)
	{
		//MessageBoxA(NULL,"MyOpenProcess-success","TS",NULL);
		LPVOID dlladdr = NULL;
		dlladdr = ::VirtualAllocEx(hprocess, NULL, wcslen(gDLLFolder) * sizeof(wchar_t) + 1, MEM_COMMIT, PAGE_EXECUTE_READWRITE);//申请地址存储DLL路径
		if (dlladdr)
		{
			//TSRuntime::add_log("VirtualAllocEx:dlladdr:%x,CallCode;%x",dlladdr,&CallCode[0]);
			//MessageBoxA(NULL,"VirtualAllocEx-dlladdr-success","TS",NULL);
			My_ZwWriteVirtualMemory(hprocess, dlladdr, gDLLFolder, wcslen(gDLLFolder) * sizeof(wchar_t), &dwwrite);
			Alloaddr = ::VirtualAllocEx(hprocess, NULL, 0x50, MEM_COMMIT, PAGE_EXECUTE_READWRITE);//申请地址存储,远程CALL的机器码
			//TSRuntime::add_log("VirtualAllocEx:Alloaddr:%x,dwwrite;%x",Alloaddr,dwwrite);
			if (dwwrite != 0 && Alloaddr)
			{
				//MessageBoxA(NULL,"VirtualAllocEx-Alloaddr-success","TS",NULL);
				dwwrite = 0;
				char Asmcalladdr[MAX_PATH] = { 0 };
				DWORD Loadlibaryaddr = 0;
				Loadlibaryaddr = (DWORD)TSRuntime::GetRemoteProcAddress(L"Kernel32.dll", "LoadLibraryW", nPid);
				if (Loadlibaryaddr != 0)
				{
					CMgAsmBase tsasm;//需要要汇编指令改为机器码
					CMgAsmBase::t_asmmodel  am;
					char erro[MAX_PATH] = { 0 };
					char asmstr[MAX_PATH] = { 0 };
					//MessageBoxA(NULL,"Loadlibaryaddr-success","TS",NULL);
					sprintf(Asmcalladdr, "call %x", Loadlibaryaddr);
					int l = 0, len = 0;

					l = tsasm.Assemble("pushad", NULL, &am, 0, 0, erro);
					memcpy(&CallCode[len], am.code, l);
					len += l;

					sprintf(asmstr, "push 0x%x", (DWORD)dlladdr);
					l = tsasm.Assemble(asmstr, ((DWORD)Alloaddr + len), &am, 0, 0, erro);
					//TSRuntime::add_log("VirtualAllocEx:l:%d,CallCode;%x,am.length:%d,len:%d",l,&CallCode[0],am.length,len);
					memcpy(&CallCode[len], am.code, l);
					len += l;

					l = tsasm.Assemble(Asmcalladdr, ((DWORD)Alloaddr + len), &am, 0, 0, erro);
					memcpy(&CallCode[len], am.code, l);
					len += l;

					l = tsasm.Assemble("popad", NULL, &am, 0, 0, erro);
					memcpy(&CallCode[len], am.code, l);
					len += l;

					l = tsasm.Assemble("push EBP", NULL, &am, 0, 0, erro);
					memcpy(&CallCode[len], am.code, l);
					len += l;

					l = tsasm.Assemble("Mov EBP,ESP", NULL, &am, 0, 0, erro);
					memcpy(&CallCode[len], am.code, l);
					len += l;

					l = tsasm.Assemble("push ESI", NULL, &am, 0, 0, erro);
					memcpy(&CallCode[len], am.code, l);
					len += l;

					l = tsasm.Assemble("push EDI", NULL, &am, 0, 0, erro);
					memcpy(&CallCode[len], am.code, l);
					len += l;

					memset(Asmcalladdr, 0, MAX_PATH);
					sprintf(Asmcalladdr, "jmp %x", InternalCallWinProc_AddrRet);
					l = tsasm.Assemble(Asmcalladdr, ((DWORD)Alloaddr + len), &am, 0, 0, erro);
					memcpy(&CallCode[len], am.code, l);
					len += l;

					l = tsasm.Assemble("ret", NULL, &am, 0, 0, erro);
					memcpy(&CallCode[len], am.code, l);
					len += l;
					My_ZwWriteVirtualMemory(hprocess, Alloaddr, CallCode, len, &dwwrite);
					CallCodelen = dwwrite;
				}

			}
			//::VirtualFreeEx(hprocess,dlladdr,0,MEM_RELEASE);
		}
	}
	if (CallCodelen > 0)
	{
		//MessageBoxA(NULL,"CallCodelen>0","TS",NULL);
		//准备下钩子注入
		DWORD dwback;
		DWORD length = 5;
		BYTE jmp[5] = { 0 };
		jmp[0] = 0xe9;
		dwwrite = 0;
		*(DWORD*)(jmp + 1) = (DWORD)Alloaddr - InternalCallWinProc_Addr - 5;
		wchar_t temp[MAX_PATH] = { 0 };
		MEMORY_BASIC_INFORMATION   mbi;
		VirtualQueryEx(hprocess, pInternalCallProcAddr, &mbi, sizeof(MEMORY_BASIC_INFORMATION));
		if (mbi.Protect != PAGE_EXECUTE_READWRITE)
			My_ZwProtectVirtualMemory(hprocess, &pInternalCallProcAddr, &length, PAGE_EXECUTE_READWRITE, &dwback);

		//bool iswrite=::WriteProcessMemory(hprocess,Addr,jmp,5,&dwwrite);
		//if(!iswrite||dwwrite==0)
		//TSRuntime::add_log("Addr:%x,InternalCallWinProc_Addr:%x",pInternalCallProcAddr,InternalCallWinProc_Addr);
		My_ZwWriteVirtualMemory(hprocess, (void*)InternalCallWinProc_Addr, jmp, 5, &dwwrite);
		if (dwwrite > 0)
		{
			wchar_t pszEventName[MAX_PATH] = { 0 };
			::wsprintf(pszEventName, L"%s%d", TS_BIND201_NAME, nPid);
			//char eer[50]={0};
			//sprintf(eer,"InternalCallWinProc_Addr:%x,dwwrite:%d",InternalCallWinProc_Addr,dwwrite);
			//MessageBoxA(NULL,"My_ZwWriteVirtualMemory-unsuccess",eer,NULL);
			HANDLE hEvent = NULL;
			for (int i = 0; i < 3000; i++)
			{
				hEvent = ::OpenEvent(EVENT_ALL_ACCESS, FALSE, pszEventName);
				if (hEvent)
				{
					//MessageBoxA(NULL,"My_ZwWriteVirtualMemory-success","TS",NULL);
					success = true;
					break;
				}
				Sleep(1);
			}
			//My_ZwWriteVirtualMemory(hprocess,(void*)InternalCallWinProc_Addr,ori,5,&dwwrite);
			SetEvent(hEvent);
			//My_ZwProtectVirtualMemory(hprocess,&pInternalCallProcAddr, (DWORD*)5, dwback, &dwback);
		}
	}
	CloseHandle(hprocess);

	return success;
}


DXBind::DXBind(void)
{
	nPid = 0;
	KeyDownsleep = 50;//键盘单击默认延时
	MouseClicksleep = 40;//鼠标单击默认延时
	WindowsKeyMouseClicksleep = 10;// Windows模式键盘\鼠标单击延时
	NormalClicksleep = 30;//前台点击默认延时
	NormalKeysleep = 30;
	m_parenthwnd = 0;
	m_isBind = false;
	m_eventMsg = NULL;
	BindMode = -1;
	mSetHook = NULL;
	pData = NULL;
	m_hwnd = 0;
	IsNpProtect = false;
	CallCodelen = 0;
	Alloaddr = NULL;
	memset(ColorDataInfo, 0, sizeof(ColorDataInfo));
	memset(CallCode, 0, 0x50);
	memset(m_Retstr, 0, MAX_PATH * 100);
	memset(m_SetPath, 0, MAX_PATH);
	memset(Colors, 0, MAX_PATH);
	memset(m_colorOffR, 0, MAX_PATH);
	memset(m_colorOffG, 0, MAX_PATH);
	memset(m_colorOffB, 0, MAX_PATH);
	memset(MyDictCount, 0, 20 * sizeof(pMyDictInfo));  //存储当前所有字库,默认最大字库个数为20个
	memset(nMaxStrHight, 0, 20);	//记录每个字库中,最高的字高.
	memset(nMyDictCountsize, 0, 20 * sizeof(DWORD));   //记录每个字库的数量
	NowUsingDictIndex = -1;//记录当前正在使用字库的下标
	isdxpic = false;
	char code[MAX_PATH] = { 0 };
	std::string pszMachineCode;
	USES_CONVERSION;
	wcscpy(TSRuntime::MachineCode, A2W(pszMachineCode.c_str()));
	Isgraphicprotect = false;
	if (Zw_UnmapViewOfSection == NULL)
		Zw_UnmapViewOfSection = (ZwUnmapViewOfSection)::GetProcAddress(::GetModuleHandle(L"ntdll.dll"), "ZwUnmapViewOfSection");
	pWndBmpBuffer = NULL;
	pWndBmpStrxy = NULL;
	pBuffer = NULL;
	IsTSEnableRealMouse = false;
	IsTSEnableRealKeypad = false;
	mousedelay = 0;
	mousestep = 0;
	LastMouseMoveX = 0;
	LastMouseMoveY = 0;
	GDI_dwExStyle = 0;
	m_keyMode |= KEY_NORMAL;//默认赋值为前台模式，可以在绑定前操作键鼠
	m_mouseMode |= MOUSE_NORMAL;//默认赋值为前台模式，可以在绑定前操作键鼠
}

DXBind::~DXBind(void)
{

}

bool DXBind::UnBind()
{
	//::EnableWindow(m_mousekeyhwnd,true);
	//DWORD nPid=0;
	////GetWindowThreadProcessId(m_hwnd,&nPid); //获取注入窗口的进程ID
	if (pWndBmpStrxy || pWndBmpBuffer)
	{
		for (int i = 0; i < 2000; i++)
		{
			delete[] pWndBmpStrxy[i];
			delete[] pWndBmpBuffer[i];
			pWndBmpBuffer[i] = NULL;
			pWndBmpStrxy[i] = NULL;
		}
		delete[]  pWndBmpStrxy;
		delete[] pWndBmpBuffer;
		pWndBmpStrxy = NULL;
		pWndBmpBuffer = NULL;
	}
	if (pBuffer)
	{
		delete[] pBuffer;
		pBuffer = NULL;
	}
	m_hwnd = 0;
	m_parenthwnd = 0;
	m_isBind = false;
	IsTSEnableRealMouse = false;
	IsTSEnableRealKeypad = false;
	if (nPid)
	{
		char pszBinWindow_SetWindowHook[MAX_PATH] = { 0 };
		sprintf(pszBinWindow_SetWindowHook, "%s%d", TS_BINDWINDOW_SETWINDOWHOOK, nPid);
		HANDLE hbindprop = GetPropA(m_hwnd, pszBinWindow_SetWindowHook);

		char pszBinWindow_IME[MAX_PATH] = { 0 };
		sprintf(pszBinWindow_IME, "%s%d", TS_BINDWINDOW_IME, nPid);
		HANDLE hbindIMEprop = GetPropA(m_hwnd, pszBinWindow_IME);

		char pszBinWindow_IME101[MAX_PATH] = { 0 };
		sprintf(pszBinWindow_IME101, "%s%d", TS_BINDWINDOW_IME101, nPid);
		HANDLE hbindIMEprop101 = GetPropA(m_hwnd, pszBinWindow_IME101);

		char pszBinWindow_GDIWINDOW[MAX_PATH] = { 0 };
		sprintf(pszBinWindow_GDIWINDOW, "%s%d", TS_BINDWINDOW_GDIWINDOW, nPid);
		HANDLE hbindGdiWindow = GetPropA(m_hwnd, pszBinWindow_GDIWINDOW);
		if (hbindGdiWindow == NULL)
			hbindGdiWindow = GetPropA(m_parenthwnd, pszBinWindow_GDIWINDOW);

		if (hbindprop)
		{
			RemovePropA(m_hwnd, pszBinWindow_SetWindowHook);  //删除绑定窗口标识
		}
		else if (hbindIMEprop)
			RemovePropA(m_hwnd, pszBinWindow_IME);  //删除绑定窗口标识
		else if (hbindIMEprop101)
			RemovePropA(m_hwnd, pszBinWindow_IME101);  //删除绑定窗口标识
		else if (hbindGdiWindow)
			RemovePropA(m_hwnd, pszBinWindow_GDIWINDOW);  //删除绑定窗口标识
		else if (hbindGdiWindow == NULL)
		{
			//::GetWindowThreadProcessId(m_parenthwnd,&nPid); //获取注入窗口的进程ID
			char pszBinWindow_GDIWINDOW[MAX_PATH] = { 0 };
			sprintf(pszBinWindow_GDIWINDOW, "%s%d", TS_BINDWINDOW_GDIWINDOW, nPid);
			RemovePropA(m_parenthwnd, pszBinWindow_GDIWINDOW);  //删除绑定窗口标识
		}

	}
	else
		return false;


	//GDI释放
	//if(TSRuntime::m_displayMode&DISPLAY_GDI)
	if ((m_displayMode & DISPLAY_GDI) == DISPLAY_GDI || (m_displayMode & DISPLAY_DX2) == DISPLAY_DX2)
	{
		////卸载GDI
		//::SetWindowLong(m_hwnd, GWL_EXSTYLE, TSRuntime::m_dwExStyle);
		//DWORD dwExStyle=::GetWindowLong((HWND)m_hwnd,GWL_EXSTYLE);
		//if(dwExStyle>=0x80100)
		//	dwExStyle=dwExStyle-0x80100;
		//::SetWindowLong(m_hwnd, GWL_EXSTYLE, dwExStyle);
		if (GDI_dwExStyle == 0)
			GDI_dwExStyle = 0x100;
		::SetWindowLong(m_hwnd, GWL_EXSTYLE, GDI_dwExStyle);
		if (m_parenthwnd != NULL)
		{
			::SetWindowLong(m_parenthwnd, GWL_EXSTYLE, GDI_dwExStyle);
			//dwExStyle=::GetWindowLong((HWND)m_parenthwnd,GWL_EXSTYLE);
			//if(dwExStyle>=0x80100)
			//	dwExStyle=dwExStyle-0x80100;
			//::SetWindowLong(m_parenthwnd, GWL_EXSTYLE, dwExStyle);
		}
		//::UpdateWindow(m_hwnd);
		::RedrawWindow(m_hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN | RDW_FRAME);
		////卸载GDI
	}

	if (BindMode == BIND_WINHOOK)	 //
	{
		//::MessageBox(0,L"SetHook解绑",L"TS",0);
		// 调用SetHook函数   ,卸载钩子
		HINSTANCE hlibrary = NULL;
		hlibrary = LoadLibrary(gDLLFolder);
		if (hlibrary)
		{
			//	mSetHook=(MySetWindowHook)GetProcAddress(hlibrary,"CBFunB");
			if (mSetHook)
			{
				//::MessageBox(0,L"SetHook解绑",L"TS",0);
				// 调用SetHook函数
				DWORD dwProcessId = 0;
				DWORD dwThreadId = GetWindowThreadProcessId(m_hwnd, &dwProcessId);
				bool isunhook = false;
				if (dwThreadId != 0)
				{
					isunhook = mSetHook(FALSE, dwThreadId);
				}
			}
			FreeLibrary(hlibrary);
		}
	}
	if (BindMode == BIND_201)
	{
		wchar_t* name = wcsrchr(gDLLFolder, '\\');
		if (name)
		{
			name++;
			wchar_t dllname[MAX_PATH] = { 0 };
			wcscpy(dllname, name);
			HMODULE RemodeDLLMode = TSRuntime::GetRemoteModuleBase(dllname, nPid);
			if (RemodeDLLMode != NULL)
			{
				TSRuntime::EnablePrivilege(L"SeDebugPrivilege", true);
				HANDLE hprocess = NULL;
				hprocess = MyOpenProcess(nPid);
				Zw_UnmapViewOfSection(hprocess, RemodeDLLMode);
				CloseHandle(hprocess);
			}
		}

	}
	m_hwnd = 0;
	if (pData)
	{
		pData->ispichook = false;
		pData->reset();
	}
	return true;
}

bool DXBind::bind(HWND wnd, DWORD keyMod, DWORD mouseMod, DWORD disMod, BIND_MODE bindMode)
{
	bool bret = false;
	//判断窗口是否有效
	if (my_IsWindow)
	{
		if (wnd == 0 || ::my_IsWindow(wnd) == false)
		{
			MessageBox(NULL, L"无效窗口句柄", L"TS", NULL);
			return false;
		}
	}
	else
	{
		if (wnd == 0 || ::IsWindow(wnd) == false)
		{
			MessageBox(NULL, L"无效窗口句柄", L"TS", NULL);
			return false;
		}
	}
	//记录被绑定的窗口的句柄
	m_hwnd = wnd;

	//得到共享内存的名称
	char pszMapName[MAX_PATH] = { 0 };
	if (my_GetWindowThreadProcessId)
		my_GetWindowThreadProcessId(wnd, &nPid); //获取注入窗口的进程ID
	else
		::GetWindowThreadProcessId(wnd, &nPid); //获取注入窗口的进程ID
	if (nPid == 0)
	{
		if (MyGetWindowThreadProcessIdRet == 0)
		{
			DWORD addr = (DWORD)GetProcAddress(GetModuleHandle(L"user32.dll"), "GetWindowThreadProcessId");
			MyGetWindowThreadProcessIdRet = addr + 5;
		}
		MyGetWindowThreadProcessId(wnd, &nPid);
		if (nPid == 0)
		{
			MessageBox(NULL, L"无效窗口句柄", L"TS", NULL);
			return false;
		}
	}
	//MessageBox(NULL,L"MyGetWindowThreadProcessId!",L"TS",NULL);
	SendMsg(TS_UNBIND);
	sprintf(pszMapName, "%s%d", TS_MAPVIEW_NAME, nPid);

	char pszBinWindow_SetWindowHook[MAX_PATH] = { 0 };
	sprintf(pszBinWindow_SetWindowHook, "%s%d", TS_BINDWINDOW_SETWINDOWHOOK, nPid);
	HANDLE hbindprop = GetPropA(m_hwnd, pszBinWindow_SetWindowHook);

	char pszBinWindow_IME[MAX_PATH] = { 0 };
	sprintf(pszBinWindow_IME, "%s%d", TS_BINDWINDOW_IME, nPid);
	HANDLE hbindIMEprop = GetPropA(m_hwnd, pszBinWindow_IME);

	char pszBinWindow_IME101[MAX_PATH] = { 0 };
	sprintf(pszBinWindow_IME101, "%s%d", TS_BINDWINDOW_IME101, nPid);
	HANDLE hbindIMEprop101 = GetPropA(m_hwnd, pszBinWindow_IME101);

	if (hbindprop && m_isBind)
		return false;

	if (hbindIMEprop101 || hbindIMEprop)   //如果绑定标识符还在说明已经窗口已经绑定
	{
		//MessageBox(NULL,L"卸载DLL!",L"TS",NULL);
		SendMessage(wnd, TS_UNBIND, 0, 0);
		Sleep(100);
		if (hbindIMEprop)
			RemovePropA(wnd, pszBinWindow_IME);
		else if (hbindIMEprop101)
			RemovePropA(wnd, pszBinWindow_IME101);
	}

	//MessageBox(NULL,L"申请指定长度的共享内存空间!-start",L"TS",NULL);
	//申请指定长度的共享内存空间
	CShareMemory* sm = new CShareMemory(pszMapName, sizeof(CMessageData), TRUE);
	//取得指向共享内存的指针
	pData = (CMessageData*)sm->GetBuffer();

	if (pData != NULL)
	{

		//MessageBox(NULL,L"reset!-start",L"TS",NULL);
		pData->reset();
		//MessageBox(NULL,L"reset!-end",L"TS",NULL);
		//TSRuntime::add_log( "TS_GETSCREENDATA:%x",pData->ColorDataInfo);
	}
	else
		return false;

	pData->InjectHwnd = TSRuntime::GetProcessMainWnd(GetCurrentProcessId());	//自身窗口句柄
	pData->isBind = true;
	pData->m_hwnd = wnd;

	if (m_mouseMode & MOUSE_API)
		pData->ismousehook = true;
	if (m_keyMode & KEY_API)
		pData->iskeyboardhook = true;
	if (m_displayMode & DISPLAY_DX_3D)
		pData->ispichook = true;
	if (TSRuntime::IsNpProtect)
	{
		pData->IsNpProtect = true;
		IsNpProtect = true;
	}
	if (m_displayMode & DISPLAY_DX_3D)//如果是DX图色绑定
		pData->isgraphicprotect = Isgraphicprotect;

	if (wcslen(TSRuntime::SetPicPwdString) > 0)
		wcscpy(pData->SetPicPwdString, TSRuntime::SetPicPwdString);

	pData->Isdxkmprotect = Isdxkmprotect;
	pData->Isdxantiapi = Isdxantiapi;

	TSRuntime::hookHwnd = wnd;
	winver = TSRuntime::InitialWindowsVersion();
	if (TSRuntime::IsStartProtect)
	{
		//BYTE winver=TSRuntime::InitialWindowsVersion();
		//if(winver!=4)//不是Win7
		{
			//MessageBox(NULL,L"HookandUnhookAPI-start",L"HookandUnhookAPI",NULL);
			TSRuntime::IsVirtualProtectEx = true;	//如果开了盾!使用驱动模式远程修改游戏页保护属性
			HookandUnhookAPI(0);//如果开了盾!使用驱动模式远程修改游戏页保护属性	
		}
	}

	//SetWindowHook注入
	if (bindMode == BIND_WINHOOK)
	{
		if (!SetWindowHookExInject(wnd))
		{
			//MessageBoxA(NULL,"SetWindowHook注入失败","TS",NULL);
			return false;
		}
		SetPropA(wnd, pszBinWindow_SetWindowHook, (HANDLE)1);   //设置绑定标识符
	}
	//输入法注入
	else if (bindMode == BIND_IME || bindMode == BIND_IME101)
	{

		if (bindMode == BIND_IME)
		{
			pData->InjectType = BIND_IME;
			SetPropA(wnd, pszBinWindow_IME, (HANDLE)1);   //设置绑定标识符
		}

		else if (bindMode == BIND_IME101)
		{
			pData->InjectType = BIND_IME101;
			SetPropA(wnd, pszBinWindow_IME101, (HANDLE)1);   //设置绑定标识符
		}

		//MessageBox(NULL,L"输入法注入!-start",L"TS",NULL);
		char pszEventName[MAX_PATH] = { 0 };
		::sprintf(pszEventName, "%s%d", TS_EVENT_IMEHOOK, nPid);
		HANDLE hEvent = OpenEventA(EVENT_ALL_ACCESS, FALSE, pszEventName);
		if (hEvent == NULL)
		{
			if (!IMEInject(wnd))
			{
				if (hbindIMEprop)
					RemovePropA(m_hwnd, pszBinWindow_IME);  //删除绑定窗口标识
				else if (hbindIMEprop101)
					RemovePropA(m_hwnd, pszBinWindow_IME101);  //删除绑定窗口标识
				return false;
			}
		}
		//else
		//   TSRuntime::add_log( "SetEvent");
	}
	else if (bindMode == BIND_201 || bindMode == BIND_203)
	{
		pData->InjectType = bindMode;
		bool bret = Inject201();
		if (!bret)
			return false;
	}
	else
	{
		return   false;//未知注入模式
	}

	//MessageBox(NULL,L"输入法注入!-end",L"TS",NULL);
	for (int i = 0; i < 300; i++)
	{
		if (pData->isInject)	 ////等待已经绑定窗口标识		TS_BINDWINDOW_NAME
			break;
		::Sleep(20);
	}

	//这里判断DLL是否已经注入,如果成功再做下面的绑定操作
	if (!pData->isInject)
	{
		//MessageBox(NULL,L"绑定失败!",L"TS",NULL);
		return false;
	}

	if (wcslen(m_SetPath) > 1)
	{
		memset(pData->setpath, 0, MAX_PATH);
		wcscpy(pData->setpath, m_SetPath);
		SendMsg(TS_SETPATH);
	}
	if (NowUsingDictIndex != -1)
	{
		//如果已经注入成功,者需拷贝一份字库信息到共享内存
		pData->NowUsingDictIndex = NowUsingDictIndex;
		pData->MyDictCount[NowUsingDictIndex] = MyDictCount[NowUsingDictIndex];
		pData->nMyDictCountsize[NowUsingDictIndex] = nMyDictCountsize[NowUsingDictIndex];
		pData->nMaxStrHight[NowUsingDictIndex] = nMaxStrHight[NowUsingDictIndex];
		//return SendMsg(TS_SETDICT,(WPARAM)GetCurrentProcessId());	//发送消息通知切换字库
	}
	//TSRuntime::add_log( "pData->isgraphicprotect:%d,Isgraphicprotect;%d",pData->isgraphicprotect,Isgraphicprotect);
	//Sleep(50);
	SendMsg(TS_BIND, (WPARAM)wnd, (LPARAM)IsNpProtect);

	m_isBind = true;

	return true;

}

bool DXBind::SetWindowHookExInject(HWND wnd)
{
	bool bInstall = true;
	BOOL bRet = false;

	HINSTANCE hlibrary = NULL;
	hlibrary = LoadLibrary(gDLLFolder);
	if (hlibrary)
	{
		mSetHook = (MySetWindowHook)GetProcAddress(hlibrary, "CBFunB");
		if (mSetHook)
		{
			// 调用SetHook函数
			DWORD dwProcessId = 0;
			DWORD dwThreadId = GetWindowThreadProcessId(wnd, &dwProcessId);
			if (dwThreadId != 0)
				bRet = mSetHook(bInstall, dwThreadId);
			SendMessage(wnd, WM_PAINT, 0, 0);	//WH_CALLWNDPROC消息需要,有SendMessage消息后才可以绑定成功,所以模拟SendMessage发送一个消息
		}
		FreeLibrary(hlibrary);
	}
	return bRet;
}

VOID GetInstallIMEValue(wchar_t* keyvaule)
{
	TCHAR ValueInfo[MAX_PATH] = { 0 };
	TCHAR achValue[MAX_PATH] = { 0 };
	DWORD ValueSize = MAX_PATH;
	DWORD cType;
	HKEY hKey;
	//打开注册表项
	if (RegOpenKey(HKEY_CURRENT_USER, L"Keyboard Layout\\Preload", &hKey) == ERROR_SUCCESS)
	{
		for (int i = 1; i < 100; i++)   //用户安装的输入法最大数假设为100 
		{
			swprintf(achValue, L"%d", i);
			if (RegQueryValueEx(hKey, achValue, NULL, &cType, (LPBYTE)ValueInfo, &ValueSize) == ERROR_SUCCESS)
			{
				wcscpy(keyvaule, ValueInfo);
			}
			else
				break;

		}
	}
}

bool DXBind::IMEInject(HWND wnd)
{
	//注入DLL,方便DLL注入启动线程
	{
		wchar_t tempPath[MAX_PATH] = { 0 };
		wchar_t tempIME[MAX_PATH] = { 0 };
		wchar_t IMEpath[MAX_PATH] = { 0 };
		GetTempPath(MAX_PATH, tempPath);
		::GetSystemDirectory(tempPath, MAX_PATH);
		wchar_t IMEWOW64Path[MAX_PATH] = { 0 };
		wchar_t sys32Path[MAX_PATH] = { 0 };
		if (TSRuntime::IsWin8X64)//WIN8X64下安装路径有变,必须安装在SysWOW64目录下
		{
			wcscpy(IMEWOW64Path, tempPath);
			wcscpy(sys32Path, tempPath);
			wchar_t* syspath = wcsrchr(IMEWOW64Path, '\\');
			int syslen = wcslen(syspath);
			memset(syspath, 0, syslen);
			swprintf(IMEWOW64Path, L"%s\\SysWOW64\\TSimedll.ime", IMEWOW64Path);
			//MessageBox(NULL,tempPath,syspath,NULL);
		}
		::wsprintf(tempIME, L"%s\\TSimedllcode.ime", tempPath);//MessageBoxA(NULL,"TS_BINDWINDOW_NAME","IME",NULL);   
		::wsprintf(IMEpath, L"%s\\TSimedll.ime", tempPath);//MessageBoxA(NULL,"TS_BINDWINDOW_NAME","IME",NULL);
		HINSTANCE globalModuleHandle = ::GetModuleHandle(gDLLFolder);
		HRSRC hRsc = FindResource(globalModuleHandle, MAKEINTRESOURCE(IDR_IME1), L"IME");
		HGLOBAL hglobal = LoadResource(globalModuleHandle, hRsc);
		VOID* lock = LockResource(hglobal);
		DWORD size = SizeofResource(globalModuleHandle, hRsc);
		char* pmen = (char*)malloc(size);
		WriteProcessMemory(GetCurrentProcess(), (void*)pmen, lock, size, NULL);
		HANDLE Filepath;
		Filepath = CreateFile(tempIME, GENERIC_WRITE, NULL, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		DWORD nwrite;
		//TSRuntime::add_log("Filepath:%d,tempIME:%s,GetLastError:%d",Filepath,tempIME,::GetLastError());	
		WriteFile(Filepath, (void*)pmen, size, &nwrite, NULL);
		CloseHandle(Filepath);

		int rbl = 1;
		if (rbl)//解密成功
		{
			if (TSRuntime::IsWin8X64)
				::CopyFile(IMEpath, IMEWOW64Path, false);
			//MessageBox(NULL,IMEpath,L"TS",NULL);
			DeleteFile(tempIME);

			////////注入前动态修改输入法DLL的导入表
			//USES_CONVERSION;
			//wchar_t sysdll[MAX_PATH]={0};
			//::wsprintf(sysdll,L"%s\\TSPlug.dll",tempPath);
			//CopyFile(gDLLFolder,sysdll,FALSE);
			//HookIMEdllIAT(W2A(IMEpath),W2A(sysdll));
			////////注入前动态修改输入法DLL的导入表
			//输入法注入

			SystemParametersInfo(SPI_GETDEFAULTINPUTLANG, 0, &SysIME, 0);  //得到系统默认输入法设置
			MSetUpIME = ImmInstallIME(IMEpath, L"天使输入法");                            //TSRuntime::add_log("ImmInstallIME错误信息:%d",::GetLastError());
			//if(TSRuntime::IsWin8X64==false)
			bool setdef = SystemParametersInfo(SPI_SETDEFAULTINPUTLANG, 0, &MSetUpIME, SPIF_SENDWININICHANGE);   //将指定输入法设置为系统默认输入法，应用程序一打开就加载
			if (MSetUpIME > 0)
			{
				//DLL注入
				int ret = ::SendMessage(wnd, WM_INPUTLANGCHANGEREQUEST, (WPARAM)TRUE, (LPARAM)MSetUpIME); //后台激活输入法,注入Dll
				//if(!ret)
				//	MessageBox(NULL,L"IME失败",L"TS",NULL);
				//::PostMessage(wnd,WM_INPUTLANGCHANGEREQUEST,(WPARAM )TRUE,(LPARAM )MSetUpIME);
				////做清理工作
				DWORD IMEkey = (DWORD)MSetUpIME;//记录当前输入法的键值,方便后面在注册表中删除
				TCHAR keyvaule[10] = { 0 };
				swprintf(keyvaule, L"%x", IMEkey);//格式化为字符串,因为值大于了整形值的最大范围
				//卸载输入法
				SystemParametersInfo(SPI_SETDEFAULTINPUTLANG, 0, &SysIME, 0);	//还原系统默认输入法设置
				UnloadKeyboardLayout(MSetUpIME);
				//注册表中删除输入法
				TCHAR achValue[MAX_PATH] = { 0 };
				TCHAR ValueInfo[MAX_PATH] = { 0 };
				DWORD ValueSize = MAX_PATH;
				DWORD cType;
				HKEY hKey;
				//打开注册表项
				if (RegOpenKey(HKEY_CURRENT_USER, L"Keyboard Layout\\Preload", &hKey) == ERROR_SUCCESS)
				{
					for (int i = 1; i < 100; i++)   //用户安装的输入法最大数假设为100 
					{
						swprintf(achValue, L"%d", i);
						if (RegQueryValueEx(hKey, achValue, NULL, &cType, (LPBYTE)ValueInfo, &ValueSize) == ERROR_SUCCESS)
						{
							if (wcsicmp(keyvaule, ValueInfo) == 0)//如果匹配到是我们安装的输入法,删除掉
							{
								RegDeleteValue(hKey, achValue);
								break;
							}
						}
						else
							break;
					}
				}
			}
			else
			{
				//wchar_t err[MAX_PATH]={0};
				//swprintf(err,L"输入法安装失败:GetLastError:%d",GetLastError());
				//::MessageBox(0,err,L"TS",0);
				return false;
			}
			DeleteFile(IMEpath);
		}
	}
	return true;
}

bool DXBind::DownCpu(DWORD sleeptime)
{
	bool bret = false;
	if (!pData->ispichook)
		return 0;//如果PIC钩子HOOK失败,直接返回失败
	if (sleeptime > 100)
		sleeptime = 100;
	else if (sleeptime < 0)
		sleeptime = 0;

	bret = SendMsg(TS_DOWNCPU, sleeptime);
	return bret;
}

bool DXBind::CmpColor(LONG x, LONG y, BSTR sColor, DOUBLE sim)
{
	bool bret = 1;	//颜色匹配返回0,颜色不匹配1

	if (wcslen(sColor) > MAX_PATH)//传进要比较的颜色值字符串太长返回失败
		return 1;

	DWORD nret = GetColor(x, y, TSRuntime::RetStr);

	if (nret == 0)	//如果取色失败,返回失败
		return 1;

	//处理多个色偏
	int col = 0, ncolors;
	wchar_t colorBuffer[MAX_PATH][16];//存储多个字符串
	for (int i = 0; i < MAX_PATH; i++)
	{
		memset(colorBuffer[i], 0, 16);
	}

	short nstr = 0;//要查找色偏的个数  ,最多支持(MAX_PATH)个色偏
	while (*sColor)
	{
		if (*sColor != L'|')
		{
			if (col > 13)
				return 1;
			colorBuffer[nstr][col++] = *sColor;
			sColor++;
			continue;
		}
		else
		{
			if (col < 1)
			{
				sColor++;
				continue;
			}
			nstr++;
			col = 0;
			sColor++;
		}
	}
	if (col >= 1)
		nstr++;

	ncolors = nstr;//记录下色偏个数

	//int t=::GetTickCount();
	for (int i = 0; i < nstr; i++)
	{
		WCHAR colorR[4] = { 0 };//字的颜色
		WCHAR colorG[4] = { 0 };//字的颜色
		WCHAR colorB[4] = { 0 };//字的颜色

		WCHAR coloroffR[4] = { 0 };//偏色
		WCHAR coloroffG[4] = { 0 };//偏色
		WCHAR coloroffB[4] = { 0 };//偏色
		int count = 0;
		int colorL = 0;

		while (colorBuffer[i][colorL] != L'-')
		{
			if (count > 6)	//判断是否是非法颜色值
				break;
			if (count < 2)
				colorR[count] = colorBuffer[i][colorL++];
			else if (count > 1 && count < 4)
				colorG[count - 2] = colorBuffer[i][colorL++];
			else if (count > 3)
				colorB[count - 4] = colorBuffer[i][colorL++];
			count++;

		}
		//将传入的RGB转换为BGR
		WCHAR colorBGR[16] = { 0 };//字的颜色
		swprintf(colorBGR, L"%s%s%s", colorR, colorG, colorB);
		count = 0;
		colorL++;

		while (colorBuffer[colorL] != L'\0')
		{
			if (count >= 6) //判断是否是非法色偏值
				break;
			if (count < 2)
				coloroffR[count] = colorBuffer[i][colorL++];
			else if (count > 1 && count < 4)
				coloroffG[count - 2] = colorBuffer[i][colorL++];
			else if (count > 3)
				coloroffB[count - 4] = colorBuffer[i][colorL++];
			count++;
		}

		//将传入的RGB转换为BGR
		WCHAR coloroffBGR[16] = { 0 };//偏色
		swprintf(coloroffBGR, L"%s%s%s", coloroffB, coloroffG, coloroffR);

		Colors[i] = wcstol(colorBGR, NULL, 16);//整形颜色值
		DWORD strColoroff = wcstol(coloroffBGR, NULL, 16);//整形偏色值
		m_colorOffR[i] = GetRValue(strColoroff);
		m_colorOffG[i] = GetGValue(strColoroff);
		m_colorOffB[i] = GetBValue(strColoroff);
	}
	//处理多个色偏

	BYTE simColor = 0;
	if (sim == 0.5)
		simColor = 49;
	else if (sim == 0.6)
		simColor = 38;
	else if (sim == 0.7)
		simColor = 29;
	else if (sim == 0.8)
		simColor = 18;
	else if (sim == 0.9)
		simColor = 9;
	else if (sim == 0.4)
		simColor = 58;
	else if (sim == 0.3)
		simColor = 67;
	else if (sim == 0.2)
		simColor = 76;
	else if (sim == 0.1)
		simColor = 85;
	/////////////////////////////////////
	DWORD loadColor = wcstol(TSRuntime::RetStr, NULL, 16);//整形颜色值
	BYTE loadR = GetRValue(loadColor);
	BYTE loadG = GetGValue(loadColor);
	BYTE loadB = GetBValue(loadColor);

	for (int i = 0; i < ncolors; i++)
	{
		BYTE cmpR = GetRValue(Colors[i]);
		BYTE cmpG = GetGValue(Colors[i]);
		BYTE cmpB = GetBValue(Colors[i]);

		if (abs(loadR - cmpR) <= (m_colorOffR[i] + simColor) && abs(loadG - cmpG) <= (m_colorOffG[i] + simColor) && abs(loadB - cmpB) <= (m_colorOffB[i] + simColor))
		{
			return 0;//匹配成功返回0
		}
	}


	return bret;
}

int DXBind::GetColor(LONG x, LONG y, BSTR sColor)
{
	int ret = 0;

	RECT clientrc;
	::GetClientRect(m_hwnd, &clientrc);
	if (x >= clientrc.right || y >= clientrc.bottom)
	{
		return 0;
	}

	MyFindPictureClass  fpic;
	fpic.m_displayMode = m_displayMode;
	fpic.m_parenthwnd = m_parenthwnd;
	fpic.pWndBmpBuffer = pWndBmpBuffer;
	fpic.pBuffer = pBuffer;
	fpic.m_hwnd = m_hwnd;
	int color = 0;
	// if(TSRuntime::m_displayMode&DISPLAY_GDI)
	if ((m_displayMode & DISPLAY_GDI) == DISPLAY_GDI || (m_displayMode & DISPLAY_NORMAL) == DISPLAY_NORMAL || (m_displayMode & DISPLAY_DX2) == DISPLAY_DX2 || (m_displayMode & DISPLAY_GDI2) == DISPLAY_GDI2)
	{
		long x1, y1;
		ret = fpic.processColor(0, m_hwnd,
			color,
			x,
			y,
			0,
			0,
			0,
			0,
			x1, y1, NULL);
		int r = 0, g = 0, b = 0;
		r = GetRValue(color);
		g = GetGValue(color);
		b = GetBValue(color);
		memset(TSRuntime::RetStr, 0, MAX_PATH);
		if (r >= 0x10 && g >= 0x10 && b >= 0x10)
			swprintf(TSRuntime::RetStr, L"%x%x%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (r < 0x10 && g < 0x10 && b < 0x10)
			swprintf(TSRuntime::RetStr, L"0%x0%x0%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (r < 0x10 && g < 0x10)
			swprintf(TSRuntime::RetStr, L"0%x0%x%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (r < 0x10 && b < 0x10)
			swprintf(TSRuntime::RetStr, L"0%x%x0%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (g < 0x10 && b < 0x10)
			swprintf(TSRuntime::RetStr, L"%x0%x0%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (r < 0x10)
			swprintf(TSRuntime::RetStr, L"0%x%x%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (g < 0x10)
			swprintf(TSRuntime::RetStr, L"%x0%x%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (b < 0x10)
			swprintf(TSRuntime::RetStr, L"%x%x0%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出

	}
	else if (m_displayMode & DISPLAY_DX_3D)
	{
		if (!pData->ispichook)
			return 0;//如果PIC钩子HOOK失败,直接返回失败
		fpic.m_parenthwnd = 0;
		ST_TSFINDPIC getdata;
		getdata.left = x;
		getdata.top = y;
		getdata.right = 0;
		getdata.bottom = 0;
		getdata.ret = -1;
		pData->type = TS_GETSCREENDATA;
		::memcpy(pData->pmsg, &getdata, sizeof(ST_TSFINDPIC));
		wchar_t pszEventName[MAX_PATH] = { 0 };

		::wsprintf(pszEventName, L"%s%d", TS_EVENT_NAME, nPid);
		HANDLE picEvent = ::OpenEvent(EVENT_ALL_ACCESS, FALSE, pszEventName);
		if (picEvent)
		{
			::WaitForSingleObject(picEvent, 10000);
			::CloseHandle(picEvent);
		}
		else
		{
			picEvent = ::CreateEvent(NULL, TRUE, FALSE, pszEventName);
			::WaitForSingleObject(picEvent, 3000);
			::CloseHandle(picEvent);
		}
		DWORD(*Data)[2000] = (DWORD(*)[2000])pData->ColorDataInfo;

		long x1, y1;
		ret = fpic.processColor(0, m_hwnd,
			color,
			x,
			y,
			0,
			0,
			0,
			0,
			x1, y1, Data, NULL, NULL);
		memset(TSRuntime::RetStr, 0, MAX_PATH);
		int r = 0, g = 0, b = 0;
		r = GetRValue(color);
		g = GetGValue(color);
		b = GetBValue(color);

		if (r >= 0x10 && g >= 0x10 && b >= 0x10)
			swprintf(TSRuntime::RetStr, L"%x%x%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (r < 0x10 && g < 0x10 && b < 0x10)
			swprintf(TSRuntime::RetStr, L"0%x0%x0%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (r < 0x10 && g < 0x10)
			swprintf(TSRuntime::RetStr, L"0%x0%x%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (r < 0x10 && b < 0x10)
			swprintf(TSRuntime::RetStr, L"0%x%x0%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (g < 0x10 && b < 0x10)
			swprintf(TSRuntime::RetStr, L"%x0%x0%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (r < 0x10)
			swprintf(TSRuntime::RetStr, L"0%x%x%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (g < 0x10)
			swprintf(TSRuntime::RetStr, L"%x0%x%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
		else if (b < 0x10)
			swprintf(TSRuntime::RetStr, L"%x%x0%x", r, g, b);//将传入的BGR颜色值转换为RGB进行输出
	}
	return ret;
}

int DXBind::Ocr(LONG x1, LONG y1, LONG x2, LONG y2, wchar_t* color, DOUBLE sim, int type)
{
	int ret = 0;

	if (wcslen(color) > MAX_PATH)
		return ret;
	wchar_t coloroffer[MAX_PATH] = { 0 };
	swprintf(coloroffer, L"%s", color);

	RECT clientrc;
	::GetClientRect(m_hwnd, &clientrc);
	if (x1 >= clientrc.right || y1 >= clientrc.bottom)
	{
		return 0;
	}

	MyFindPictureClass  fpic;
	fpic.m_displayMode = m_displayMode;
	fpic.m_parenthwnd = m_parenthwnd;
	fpic.pWndBmpBuffer = pWndBmpBuffer;
	fpic.pWndBmpStrxy = pWndBmpStrxy;
	fpic.pBuffer = pBuffer;
	//if(TSRuntime::m_displayMode&DISPLAY_GDI)
	if ((m_displayMode & DISPLAY_GDI) == DISPLAY_GDI || (m_displayMode & DISPLAY_NORMAL) == DISPLAY_NORMAL || (m_displayMode & DISPLAY_DX2) == DISPLAY_DX2 || (m_displayMode & DISPLAY_GDI2) == DISPLAY_GDI2)
	{
		TSRuntime::NowUsingDictIndex = NowUsingDictIndex;
		TSRuntime::nMyDictCountsize[TSRuntime::NowUsingDictIndex] = nMyDictCountsize[NowUsingDictIndex];
		TSRuntime::nMaxStrHight[TSRuntime::NowUsingDictIndex] = nMaxStrHight[NowUsingDictIndex];
		TSRuntime::MyDictCount[TSRuntime::NowUsingDictIndex] = MyDictCount[NowUsingDictIndex];
		if (pData)
		{
			memset(pData->RetString, 0, MAX_PATH * 100);
			ret = fpic.ocr(0, m_hwnd,
				x1,
				y1,
				x2,
				y2,
				coloroffer,
				sim,
				pData->RetString, MyDictCount, nMyDictCountsize, NowUsingDictIndex, NULL, type);
		}
		else
		{
			memset(m_Retstr, 0, MAX_PATH * 100);
			ret = fpic.ocr(0, m_hwnd,
				x1,
				y1,
				x2,
				y2,
				coloroffer,
				sim,
				m_Retstr, MyDictCount, nMyDictCountsize, NowUsingDictIndex, NULL, type);
		}


	}
	else if (m_displayMode & DISPLAY_DX_3D)
	{
		if (!pData->ispichook)
			return 0;//如果PIC钩子HOOK失败,直接返回失败

		fpic.m_hwnd = m_hwnd;
		fpic.m_parenthwnd = 0;
		ST_TSFINDPIC getdata;
		getdata.left = x1;
		getdata.top = y1;
		getdata.right = x2;
		getdata.bottom = y2;
		getdata.ret = -1;
		pData->type = TS_GETSCREENDATA;
		::memcpy(pData->pmsg, &getdata, sizeof(ST_TSFINDPIC));
		wchar_t pszEventName[MAX_PATH] = { 0 };

		::wsprintf(pszEventName, L"%s%d", TS_EVENT_NAME, nPid);
		HANDLE picEvent = ::OpenEvent(EVENT_ALL_ACCESS, FALSE, pszEventName);
		if (picEvent)
		{
			::WaitForSingleObject(picEvent, 10000);
			::CloseHandle(picEvent);
		}
		else
		{
			picEvent = ::CreateEvent(NULL, TRUE, FALSE, pszEventName);
			::WaitForSingleObject(picEvent, 3000);
			::CloseHandle(picEvent);
		}
		DWORD(*Data)[2000] = (DWORD(*)[2000])pData->ColorDataInfo;

		memset(pData->RetString, 0, MAX_PATH * 100);
		ret = fpic.ocr(0, m_hwnd,
			x1,
			y1,
			x2,
			y2,
			coloroffer,
			sim,
			pData->RetString, MyDictCount, nMyDictCountsize, NowUsingDictIndex, Data, type);
		//ST_TSFINDPIC pic;
		//pic.left=x1;
		//pic.top=y1;
		//pic.right=x2;
		//pic.bottom=y2;
		//wcscpy(pic.color_format,coloroffer);
		//pic.simi=sim;
		//if(type==0)
		//	pData->type=TS_OCR;
		//else if(type==1)
		//	pData->type=TS_OCREX;

		//::memcpy(pData->pmsg,&pic,sizeof(ST_TSFINDPIC));
		//wchar_t pszEventName[MAX_PATH]={0}; 

		////DWORD nPid=0;
		////GetWindowThreadProcessId(m_hwnd,&nPid); //获取注入窗口的进程ID
		//::wsprintf(pszEventName,L"%s%d",TS_EVENT_NAME,nPid);
		//HANDLE picEvent=::CreateEvent(NULL,TRUE,FALSE,pszEventName);
		//::WaitForSingleObject(picEvent,INFINITE);
		//::CloseHandle(picEvent);
	}
	return ret;
}

int DXBind::findColor(LONG x1, LONG y1, LONG x2, LONG y2, int color, DOUBLE sim, LONG dir, LONG& intX, LONG& intY, wchar_t* colorstr, wchar_t* retstring, wchar_t* MultiColor)
{
	int ret = 0;

	if (wcslen(colorstr) >= MAX_PATH - 1)
		return ret;

	RECT clientrc;
	::GetClientRect(m_hwnd, &clientrc);
	if (x1 >= clientrc.right || y1 >= clientrc.bottom)
	{
		intX = -1;
		intY = -1;
		return -1;
	}

	MyFindPictureClass  fpic;
	fpic.m_displayMode = m_displayMode;
	fpic.m_parenthwnd = m_parenthwnd;
	fpic.pWndBmpBuffer = pWndBmpBuffer;
	fpic.pBuffer = pBuffer;
	//if(TSRuntime::m_displayMode&DISPLAY_GDI)
	if ((m_displayMode & DISPLAY_GDI) == DISPLAY_GDI || (m_displayMode & DISPLAY_NORMAL) == DISPLAY_NORMAL || (m_displayMode & DISPLAY_DX2) == DISPLAY_DX2 || (m_displayMode & DISPLAY_GDI2) == DISPLAY_GDI2)
	{
		ret = fpic.processColor(0, m_hwnd,
			color,
			x1,
			y1,
			x2,
			y2,
			sim,
			dir,
			intX, intY, NULL, colorstr, retstring, MultiColor);
	}
	else if (m_displayMode & DISPLAY_DX_3D)
	{
		if (!pData->ispichook)
			return 0;//如果PIC钩子HOOK失败,直接返回失败

		fpic.m_hwnd = m_hwnd;
		fpic.m_parenthwnd = 0;
		ST_TSFINDPIC getdata;
		getdata.left = x1;
		getdata.top = y1;
		getdata.right = x2;
		getdata.bottom = y2;
		getdata.ret = -1;
		pData->type = TS_GETSCREENDATA;
		::memcpy(pData->pmsg, &getdata, sizeof(ST_TSFINDPIC));
		wchar_t pszEventName[MAX_PATH] = { 0 };

		::wsprintf(pszEventName, L"%s%d", TS_EVENT_NAME, nPid);
		HANDLE picEvent = ::OpenEvent(EVENT_ALL_ACCESS, FALSE, pszEventName);
		if (picEvent)
		{
			::WaitForSingleObject(picEvent, 10000);
			::CloseHandle(picEvent);
		}
		else
		{
			picEvent = ::CreateEvent(NULL, TRUE, FALSE, pszEventName);
			::WaitForSingleObject(picEvent, 3000);
			::CloseHandle(picEvent);
		}
		DWORD(*Data)[2000] = (DWORD(*)[2000])pData->ColorDataInfo;


		ret = fpic.processColor(0, m_hwnd,
			color,
			x1,
			y1,
			x2,
			y2,
			sim,
			dir,
			intX, intY, Data, colorstr, retstring, MultiColor);
		//ST_TSFINDPIC pic;
		//pic.left=x1;
		//pic.top=y1;
		//pic.right=x2;
		//pic.bottom=y2;
		//pic.colorOffset=color;
		//wcscpy(pic.color_format,colorstr);
		//pic.simi=sim;
		//pic.dir=dir;
		//pic.x=-1;
		//pic.y=-1;
		//pic.ret=-1;
		//if(retstring==NULL)
		//	pData->type=TS_FINDCOLOR;
		//else
		//	pData->type=TS_FINDCOLOREX;

		//::memcpy(pData->pmsg,&pic,sizeof(ST_TSFINDPIC));
		//wchar_t pszEventName[MAX_PATH]={0}; 

		////DWORD nPid=0;
		////GetWindowThreadProcessId(m_hwnd,&nPid); //获取注入窗口的进程ID
		//::wsprintf(pszEventName,L"%s%d",TS_EVENT_NAME,nPid);
		//HANDLE picEvent=::CreateEvent(NULL,TRUE,FALSE,pszEventName);
		//::WaitForSingleObject(picEvent,3000);
		//::CloseHandle(picEvent);
		//ST_TSFINDPIC *pPic=(ST_TSFINDPIC *)pData->pmsg;
		//intX=pPic->x;
		//intY=pPic->y;
		//ret=pPic->ret;
		//if(retstring!=NULL)
		//	wcscpy(retstring,pData->RetString);
	}
	return ret;
}

bool DXBind::TSUseDict(int index)
{
	MyFindPictureClass fpic;
	BOOL isuse = fpic.MyUseDict(index, MyDictCount, NowUsingDictIndex);
	//判断是否已经注入,者需拷贝一份字库信息到共享内存
	if (pData && isuse)
	{
		pData->MyDictCount[TSRuntime::NowUsingDictIndex] = MyDictCount[NowUsingDictIndex];
		pData->nMyDictCountsize[TSRuntime::NowUsingDictIndex] = nMyDictCountsize[NowUsingDictIndex];
		pData->nMaxStrHight[TSRuntime::NowUsingDictIndex] = nMaxStrHight[NowUsingDictIndex];
		pData->NowUsingDictIndex = NowUsingDictIndex;
		return SendMessage(m_hwnd, TS_USEDICT, (WPARAM)GetCurrentProcessId(), 0);	//发送消息通知切换字库
	}
	return isuse;

}

bool DXBind::TSSetDict(int index, wchar_t* filepath)
{
	MyFindPictureClass fpic;
	wchar_t path[MAX_PATH] = { 0 };
	wchar_t* findpath = wcsstr(filepath, L":");
	if (wcslen(m_SetPath) > 1 && findpath == NULL)
	{
		swprintf(path, L"%s\\%s", m_SetPath, filepath);
	}
	else
	{
		swprintf(path, L"%s", filepath);
	}
	BOOL isuse = fpic.MySetDict(index, path, MyDictCount, nMyDictCountsize, NowUsingDictIndex);
	//判断是否已经注入,者需拷贝一份字库信息到共享内存
	if (pData != NULL && isuse)
	{
		if (m_displayMode & DISPLAY_DX_3D)
		{

			pData->MyDictCount[NowUsingDictIndex] = MyDictCount[NowUsingDictIndex];
			pData->nMyDictCountsize[NowUsingDictIndex] = nMyDictCountsize[NowUsingDictIndex];
			pData->nMaxStrHight[NowUsingDictIndex] = TSRuntime::nMaxStrHight[NowUsingDictIndex];
			pData->NowUsingDictIndex = NowUsingDictIndex;

			return SendMessage(m_hwnd, TS_SETDICT, (WPARAM)GetCurrentProcessId(), 0);	//发送消息通知切换字库
		}

	}

	return isuse;

}

bool DXBind::TSSetpath(wchar_t* path)
{

	memset(m_SetPath, 0, MAX_PATH);
	wcscpy(m_SetPath, path);
	if (pData)
	{
		memset(pData->setpath, 0, MAX_PATH);
		wcscpy(pData->setpath, path);
		return SendMessage(m_hwnd, TS_SETPATH, 0, 0);
	}
}

bool DXBind::TSGetScreenData(LONG x1, LONG y1, LONG x2, LONG y2)
{
	bool nret = FALSE;

	RECT clientrc;
	::GetClientRect(m_hwnd, &clientrc);
	if (x1 >= clientrc.right || y1 >= clientrc.bottom)
		return 0;

	memset(ColorDataInfo, 0, sizeof(ColorDataInfo));
	if ((m_displayMode & DISPLAY_GDI) == DISPLAY_GDI || (m_displayMode & DISPLAY_NORMAL) == DISPLAY_NORMAL || (m_displayMode & DISPLAY_DX2) == DISPLAY_DX2 || (m_displayMode & DISPLAY_GDI2) == DISPLAY_GDI2)
	{
		int m_Left = 0, m_Top = 0, m_Right = 0, m_bottom = 0;
		int left = x1, right = x2, top = y1, bottom = y2;
		int scrennwide;
		int scrennheight;
		HDC hDC;
		if (m_displayMode & DISPLAY_NORMAL)
		{
			hDC = CreateDC(L"DISPLAY", NULL, NULL, NULL);
			//////确保选定区域是可见的
			if (m_parenthwnd != ::GetDesktopWindow() && m_parenthwnd != 0)
			{
				//::MessageBoxA(NULL,"GetDesktopWindow","GetDesktopWindow",NULL);
				RECT rec;
				::GetWindowRect(m_parenthwnd, &rec);
				int xc = ::GetSystemMetrics(SM_CYCAPTION);
				int cx = ::GetSystemMetrics(SM_CXFRAME);
				int cy = ::GetSystemMetrics(SM_CYFRAME);
				m_Left = rec.left + cx;
				m_Top = rec.top + xc + cy;
				m_Right = rec.right;
				m_bottom = rec.bottom;
				scrennwide = ::GetSystemMetrics(SM_CXSCREEN);
				scrennheight = ::GetSystemMetrics(SM_CYSCREEN);

				if (m_Left < 0)
				{
					if ((left + m_Left) <= 0)
						left = 0;//越界
					else
						left = m_Left + left;
				}
				else
					left = m_Left + left;

				if (m_Top >= 0)
					top = m_Top + top;

				if (m_Right >= scrennwide)
				{
					if ((right + m_Left) > scrennwide)
						right = scrennwide - 1;
					else
						right = right + m_Left;
				}
				else
					right = right + m_Left;

				if (m_bottom >= scrennheight)
				{
					if ((bottom + m_Top) >= scrennheight)
						bottom = scrennheight - 1;
					else
						bottom = bottom + m_Top;
				}
				else
					bottom = bottom + m_Top;

				x1 = left;
				y1 = top;
				x2 = right;
				y2 = bottom;

			}
		}
		else//GDI边界值判断
		{
			hDC = GetDCEx(m_hwnd, NULL, DCX_PARENTCLIP);
			RECT clientrc;
			::GetClientRect(m_hwnd, &clientrc);
			scrennwide = clientrc.right - clientrc.left;
			scrennheight = clientrc.bottom - clientrc.top;
			m_Left = left;
			m_Top = top;
			m_Right = right;
			m_bottom = bottom;

			if (left < 0)
				m_Left = left = 0;
			if (left >= scrennwide)
				m_Left = scrennwide - 1;

			if (top < 0)
				m_Top = top = 0;
			if (top >= scrennheight)
				m_Top = scrennheight - 1;

			if (right >= scrennwide)
				m_Right = scrennwide - 1;

			if (bottom >= scrennheight)
				m_bottom = scrennheight - 1;

			x1 = left;
			y1 = top;
			x2 = right;
			y2 = bottom;
		}

		HDC hMemDC;					//内存缓冲设备环境
		HBITMAP hbmMem, hbmOld;		//内存缓冲设备环境中的位图

		// 24位图的BITMAPINFO
		BITMAPINFO* pBITMAPINFO = (BITMAPINFO*)malloc(sizeof(BITMAPINFOHEADER));
		memset(pBITMAPINFO, 0, sizeof(BITMAPINFOHEADER));
		BITMAPINFOHEADER* pInfo_Header = (BITMAPINFOHEADER*)pBITMAPINFO;
		pInfo_Header->biSize = sizeof(BITMAPINFOHEADER);
		pInfo_Header->biWidth = x2 - x1;
		pInfo_Header->biHeight = y2 - y1;
		pInfo_Header->biPlanes = 1;
		pInfo_Header->biBitCount = 24;
		pInfo_Header->biCompression = BI_RGB;

		int xc = 0;
		int cx = 0;
		int cy = 0;
		hMemDC = CreateCompatibleDC(hDC);	//创建内存兼容设备环境
		//创建内存兼容位图
		hbmMem = CreateCompatibleBitmap(hDC, pInfo_Header->biWidth, pInfo_Header->biHeight);
		hbmOld = (HBITMAP)SelectObject(hMemDC, hbmMem);
		if ((m_displayMode & DISPLAY_GDI2) == DISPLAY_GDI2)
		{
			RECT winret;
			::GetWindowRect(m_hwnd, &winret);
			POINT point;
			point.x = 0;
			point.y = 0;
			::ClientToScreen(m_hwnd, &point);
			cx = point.x - winret.left;
			cy = point.y - winret.top;
			HDC T_hMemDC = CreateCompatibleDC(hDC);	//创建内存兼容设备环境
			//创建内存兼容位图
			HBITMAP T_hbmMem = CreateCompatibleBitmap(hDC, pInfo_Header->biWidth + cx + x1, pInfo_Header->biHeight + cy + y1);
			HBITMAP T_hbmOld = (HBITMAP)SelectObject(T_hMemDC, T_hbmMem);
			::UpdateWindow(m_hwnd);
			::RedrawWindow(m_hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN | RDW_FRAME);
			::PrintWindow(m_hwnd, T_hMemDC, 0);
			BitBlt(hMemDC, 0, 0, pInfo_Header->biWidth, pInfo_Header->biHeight, T_hMemDC, xc + x1, cy + y1, CAPTUREBLT | SRCCOPY);
			DeleteDC(T_hMemDC);
			DeleteObject(T_hbmMem);
			DeleteObject(T_hbmOld);
		}
		else
		{
			//将内存设备环境中的内容绘制到物理设备环境   hDC
			BitBlt(hMemDC, 0, 0, pInfo_Header->biWidth, pInfo_Header->biHeight, hDC, xc + x1, cy + y1, CAPTUREBLT | SRCCOPY);
		}

		HBITMAP hBitmap = (HBITMAP)SelectObject(hMemDC, hbmOld);

		// 获得数据buf
		DWORD bufSize = (pInfo_Header->biWidth * 3 + 3) / 4 * 4 * pInfo_Header->biHeight;
		BYTE* pBuffer = new BYTE[bufSize];

		int aHeight = pInfo_Header->biHeight;

		if (::GetDIBits(hMemDC, hBitmap, 0, aHeight, pBuffer, pBITMAPINFO, DIB_RGB_COLORS) == 0)
		{
			if (TSRuntime::IsShowErrorMsg)
				::MessageBox(NULL, L"加载位图失败", L"TS", 0);
			return false;
		}

		int wndWidth = pBITMAPINFO->bmiHeader.biWidth;
		int wndHeight = pBITMAPINFO->bmiHeader.biHeight;
		//TSRuntime::add_log( "wndHeight:%d wndWidth%d",wndHeight,wndWidth);

		//HDC dd = ::GetWindowDC(::GetDesktopWindow());
		COLORREF helpcolor = 0;
		int pitch = wndWidth % 4;
		for (int i = 0; i < wndHeight; i++)
		{
			int realPitch = i * pitch;
			for (int j = 0; j < wndWidth; j++)
			{
				UCHAR b = pBuffer[(i * wndWidth + j) * 3 + realPitch];
				UCHAR g = pBuffer[(i * wndWidth + j) * 3 + 1 + realPitch];
				UCHAR r = pBuffer[(i * wndWidth + j) * 3 + 2 + realPitch];
				helpcolor = RGB(r, g, b);

				ColorDataInfo[wndHeight - i - 1][j] = helpcolor;
				//pColorBuffer[wndHeight-i-1][j]=helpcolor;
				//::SetPixel(dd,wndHeight-i-1,j,helpcolor);
			}
		}
		if (m_hwnd == GetDesktopWindow())
			DeleteDC(hDC);
		else
			ReleaseDC(m_hwnd, hDC);

		//释放资源
		DeleteObject(hbmMem);
		DeleteObject(hbmOld);
		DeleteDC(hMemDC);
		free(pBITMAPINFO);
		::DeleteObject(hBitmap);
		delete[] pBuffer;
	}
	else if (m_displayMode & DISPLAY_DX_3D)
	{
		if (!pData->ispichook)
			return 0;//如果PIC钩子HOOK失败,直接返回失败

		ST_TSFINDPIC getdata;
		getdata.left = x1;
		getdata.top = y1;
		getdata.right = x2;
		getdata.bottom = y2;
		getdata.ret = -1;
		pData->type = TS_GETSCREENDATA;
		::memcpy(pData->pmsg, &getdata, sizeof(ST_TSFINDPIC));
		wchar_t pszEventName[MAX_PATH] = { 0 };

		::wsprintf(pszEventName, L"%s%d", TS_EVENT_NAME, nPid);
		HANDLE picEvent = ::OpenEvent(EVENT_ALL_ACCESS, FALSE, pszEventName);
		if (picEvent)
		{
			::WaitForSingleObject(picEvent, 10000);
			::CloseHandle(picEvent);
		}
		else
		{
			picEvent = ::CreateEvent(NULL, TRUE, FALSE, pszEventName);
			::WaitForSingleObject(picEvent, 3000);
			::CloseHandle(picEvent);
		}

		ST_TSFINDPIC* pcaptrue = (ST_TSFINDPIC*)pData->pmsg;
		nret = pcaptrue->ret;

		memcpy(ColorDataInfo, pData->ColorDataInfo, sizeof(ColorDataInfo));
		return nret;
	}

}

int DXBind::Capture(LONG x1, LONG y1, LONG x2, LONG y2, wchar_t* pic_path, int pictype)
{
	//TSRuntime::add_log( "截图");
	int nret = 0;
	//if(TSRuntime::m_displayMode&DISPLAY_GDI)
	RECT clientrc;
	::GetClientRect(m_hwnd, &clientrc);
	if (x1 >= clientrc.right || y1 >= clientrc.bottom)
		return 0;//已经越界
	::GetClientRect(m_hwnd, &clientrc);
	if ((m_displayMode & DISPLAY_GDI) == DISPLAY_GDI || (m_displayMode & DISPLAY_NORMAL) == DISPLAY_NORMAL || (m_displayMode & DISPLAY_DX2) == DISPLAY_DX2 || (m_displayMode & DISPLAY_GDI2) == DISPLAY_GDI2)
	{

		//TSRuntime::add_log( "gdi模式截图");

		wchar_t savepath[MAX_PATH] = { 0 };
		wchar_t* findpath = wcsstr(pic_path, L":");
		if (wcslen(m_SetPath) > 1 && findpath == NULL)
		{
			swprintf(savepath, L"%s\\%s", m_SetPath, pic_path);
		}
		else
		{
			swprintf(savepath, L"%s", pic_path);
		}
		MyFindPictureClass pic;
		pic.m_displayMode = m_displayMode;
		pic.m_parenthwnd = m_parenthwnd;
		//TSRuntime::add_log( "pic.m_parenthwnd:%d",pic.m_parenthwnd);
		RECT rc;
		rc.left = x1;
		rc.top = y1;
		rc.right = x2;
		rc.bottom = y2;
		int scrennwide;
		int scrennheight;
		scrennwide = ::GetSystemMetrics(SM_CXSCREEN);
		scrennheight = ::GetSystemMetrics(SM_CYSCREEN);
		bool bret = false;
		if (pictype == D3DXIFF_JPG || pictype == D3DXIFF_PNG)
		{
			wchar_t temppath[MAX_PATH] = { 0 };
			wchar_t path[MAX_PATH] = { 0 };
			GetTempPath(MAX_PATH, temppath);
			//DWORD nPid=0;
			//GetWindowThreadProcessId(m_hwnd,&nPid); //获取注入窗口的进程ID
			swprintf(path, L"%s\\TEMPBMP%d.BMP", temppath, nPid);
			if (m_displayMode & DISPLAY_NORMAL)
			{
				if (m_parenthwnd != ::GetDesktopWindow() && m_parenthwnd != 0)
				{
					int m_Left = 0, m_Top = 0, m_Right = 0, m_bottom = 0;
					int left = x1, right = x2, top = y1, bottom = y2;
					RECT rec;
					::GetWindowRect(m_parenthwnd, &rec);
					int xc = 0;
					int cx = 0;
					int cy = 0;
					if (m_hwnd != GetDesktopWindow())
					{
						xc = ::GetSystemMetrics(SM_CYCAPTION);
						cx = ::GetSystemMetrics(SM_CXFRAME);
						cy = ::GetSystemMetrics(SM_CYFRAME);
					}
					m_Left = rec.left + cx;
					m_Top = rec.top + xc + cy;
					m_Right = rec.right;
					m_bottom = rec.bottom;

					if (m_Left < 0)
					{
						if ((left + m_Left) <= 0)
							left = 0;//越界
						else
							left = m_Left + left;
					}
					else
						left = m_Left + left;

					if (m_Top >= 0)
						top = m_Top + top;

					if (m_Right >= scrennwide)
					{
						if ((right + m_Left) > scrennwide)
							right = scrennwide - 1;
						else
							right = right + m_Left;
					}
					else
						right = right + m_Left;

					if (m_bottom >= scrennheight)
					{
						if ((bottom + m_Top) >= scrennheight)
							bottom = scrennheight - 1;
						else
							bottom = bottom + m_Top;
					}
					else
						bottom = bottom + m_Top;

					rc.left = left;
					rc.top = top;
					rc.right = right;
					rc.bottom = bottom;
				}
				else
				{
					////确保选定区域是可见的
					if (rc.left < 0)
						rc.left = 0;
					if (rc.top < 0)
						rc.top = 0;
					if (rc.right > scrennwide)
						rc.right = scrennwide;
					if (rc.bottom > scrennheight)
						rc.bottom = scrennheight;
				}

				bret = pic.CopyScreenToBitmap(&rc, path);

				if (pictype == D3DXIFF_JPG && bret)
					bret = pic.BMP2JPG(path, savepath);
				else if (pictype == D3DXIFF_PNG && bret)
					bret = pic.BMP2PNG(path, savepath);
				DeleteFile(path);

			}
			else if (pic.SaveGDIBitmap(m_hwnd, rc, path))
			{
				////确保选定区域是可见的
				if (rc.left < 0)
					rc.left = 0;
				if (rc.top < 0)
					rc.top = 0;
				if (rc.right > clientrc.right)
					rc.right = clientrc.right;
				if (rc.bottom > clientrc.bottom)
					rc.bottom = clientrc.bottom;

				if (pictype == D3DXIFF_JPG)
					bret = pic.BMP2JPG(path, savepath);
				else if (pictype == D3DXIFF_PNG)
					bret = pic.BMP2PNG(path, savepath);
				DeleteFile(path);
			}
		}
		else if (pictype == D3DXIFF_BMP)
		{
			if (m_displayMode & DISPLAY_NORMAL)
			{
				//::GetWindowRect(m_parenthwnd,&rc);
				//int xc =::GetSystemMetrics(SM_CYCAPTION);
				//int cx =::GetSystemMetrics(SM_CXFRAME);
				//int cy =::GetSystemMetrics(SM_CYFRAME);
				//rc.top=rc.top+xc+cy;
				if (m_parenthwnd != ::GetDesktopWindow() && m_parenthwnd != 0)
				{
					int m_Left = 0, m_Top = 0, m_Right = 0, m_bottom = 0;
					int left = x1, right = x2, top = y1, bottom = y2;
					RECT rec;
					::GetWindowRect(m_parenthwnd, &rec);
					int xc = 0;
					int cx = 0;
					int cy = 0;
					if (m_hwnd != GetDesktopWindow())
					{
						xc = ::GetSystemMetrics(SM_CYCAPTION);
						cx = ::GetSystemMetrics(SM_CXFRAME);
						cy = ::GetSystemMetrics(SM_CYFRAME);
					}
					m_Left = rec.left + cx;
					m_Top = rec.top + xc + cy;
					m_Right = rec.right;
					m_bottom = rec.bottom;

					if (m_Left < 0)
					{
						if ((left + m_Left) <= 0)
							left = 0;//越界
						else
							left = m_Left + left;
					}
					else
						left = m_Left + left;

					if (m_Top >= 0)
						top = m_Top + top;

					if (m_Right >= scrennwide)
					{
						if ((right + m_Left) > scrennwide)
							right = scrennwide - 1;
						else
							right = right + m_Left;
					}
					else
						right = right + m_Left;

					if (m_bottom >= scrennheight)
					{
						if ((bottom + m_Top) >= scrennheight)
							bottom = scrennheight - 1;
						else
							bottom = bottom + m_Top;
					}
					else
						bottom = bottom + m_Top;

					rc.left = left;
					rc.top = top;
					rc.right = right;
					rc.bottom = bottom;
				}
				else
				{
					////确保选定区域是可见的
					if (rc.left < 0)
						rc.left = 0;
					if (rc.top < 0)
						rc.top = 0;
					if (rc.right > scrennwide)
						rc.right = scrennwide;
					if (rc.bottom > scrennheight)
						rc.bottom = scrennheight;
				}

				bret = pic.CopyScreenToBitmap(&rc, savepath);

			}
			else
				bret = pic.SaveGDIBitmap(m_hwnd, rc, savepath);
		}

		if (bret)
			nret = 1;
		else
			nret = 0;
		//USES_CONVERSION;
		//TSRuntime::add_log( "findPicture,pic_path:%s,X:%d,Y:%d",W2A(pic_name),intX,intY);
		return nret;
	}
	//else if(TSRuntime::m_displayMode&DISPLAY_DX_3D)
	else if (m_displayMode & DISPLAY_DX_3D)
	{
		//TSRuntime::add_log( "dx模式截图");

		if (!pData->ispichook)
			return 0;//如果PIC钩子HOOK失败,直接返回失败

		ST_TSFINDPIC captrue;
		captrue.left = x1;
		captrue.top = y1;
		captrue.right = x2;
		captrue.bottom = y2;
		wcscpy(captrue.path, pic_path);
		captrue.pictype = pictype;
		captrue.ret = -1;
		pData->type = TS_CAPTURE;
		::memcpy(pData->pmsg, &captrue, sizeof(ST_TSFINDPIC));
		wchar_t pszEventName[MAX_PATH] = { 0 };

		//DWORD nPid=0;
		//GetWindowThreadProcessId(m_hwnd,&nPid); //获取注入窗口的进程ID
		::wsprintf(pszEventName, L"%s%d", TS_EVENT_NAME, nPid);
		HANDLE picEvent = ::OpenEvent(EVENT_ALL_ACCESS, FALSE, pszEventName);
		if (picEvent)
		{
			::WaitForSingleObject(picEvent, 10000);
			::CloseHandle(picEvent);
		}
		else
		{
			picEvent = ::CreateEvent(NULL, TRUE, FALSE, pszEventName);
			::WaitForSingleObject(picEvent, 3000);
			::CloseHandle(picEvent);
		}
		ST_TSFINDPIC* pcaptrue = (ST_TSFINDPIC*)pData->pmsg;
		nret = pcaptrue->ret;
		return nret;
	}
}
//创建GIF图片
int DXBind::CaptureGif(LONG x1, LONG y1, LONG x2, LONG y2, wchar_t* pic_path, int delay, int time)
{
	//先截图,然后合成GIF图片
	wchar_t temppath[MAX_PATH] = { 0 };
	//最多存储260*2张图片
	wchar_t path[MAX_PATH * 4][MAX_PATH] = { 0 };
	GetTempPath(MAX_PATH, temppath);
	//DWORD pid=0;
	//GetWindowThreadProcessId(m_hwnd,&pid);
	DWORD time1 = GetTickCount();
	int n = 0;
	//先截图,存储临时图片到临时路径中
	while (1)
	{
		swprintf(path[n], L"%s\\%d%d.bmp", temppath, GetTickCount(), nPid);
		Capture(x1, y1, x2, y2, path[n], D3DXIFF_BMP);
		n++;
		DWORD time2 = GetTickCount();
		if ((time2 - time1) > time || n == (MAX_PATH * 4 - 1))
			break;
		Sleep(delay);
	}
	//然后合成GIF图片
	wchar_t savepath[MAX_PATH] = { 0 };
	wchar_t* findpath = wcsstr(pic_path, L":");
	if (wcslen(m_SetPath) > 1 && findpath == NULL)
	{
		swprintf(savepath, L"%s\\%s", m_SetPath, pic_path);
	}
	else
	{
		swprintf(savepath, L"%s", pic_path);
	}

	BYTE* palette = NULL;
	BYTE* pData = NULL;
	int nWidth, nHeight;
	BYTE bitsPixel = 8;

	//if(PathFileExists(savepath))
	//	{
	//		if(!DeleteFile(savepath))  //删除文件失败文件被占用
	//			return 0;
	//	}

	HANDLE hfile = ::CreateFile(savepath, GENERIC_ALL, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);//打开文件//不存在创建

	//写GIF头
	CreateGIFHeard(hfile, nWidth, nHeight, bitsPixel);

	int m = 0; //决定合成图片的个数

	if (delay <= 0)
		m = 1;
	else if (time / delay < n)
		m = time / delay;
	else if (time / delay >= n)
		m = n;

	for (int i = 0; i < m; i++)
	{
		HBITMAP hBmp2 = (HBITMAP)LoadImage(NULL, path[i], IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);

		if (hBmp2 == NULL)
		{
			CloseGIF(hfile);
			CloseHandle(hfile);
			break;
			//return 0;
		}

		if (GetData(hBmp2, &palette, &pData, &bitsPixel, &nWidth, &nHeight) == FALSE)
		{
			DeleteObject(hBmp2);
			CloseGIF(hfile);
			CloseHandle(hfile);
			break;
			//return 0;
		}
		DeleteObject(hBmp2);

		short	nTransparentColorIndex = -1;

		//加入其它图片
		AddImageToGIF(hfile, pData, palette, nWidth, nHeight, bitsPixel, delay, nTransparentColorIndex);
		delete[]pData;
		delete[]palette;
	}


	//结束GIF
	CloseGIF(hfile);
	CloseHandle(hfile);
	//然后合成GIF图片

	//清除临时图片到临时路径中图片
	for (int i = 0; i < n; i++)
		DeleteFile(path[i]);

	return 1;
}

//Findstrtype=0的时候Findstr=Findstr;Findstrtype=1的时候Findstr=FindStrFast;
int DXBind::Findstr(LONG x1, LONG y1, LONG x2, LONG y2, wchar_t* findstring, wchar_t* color, DOUBLE sim, LONG& intX, LONG& intY, BYTE Findstrtype, wchar_t* retstring, int type)
{
	//TSRuntime::add_log( "Findstr");
	intX = -1;
	intY = -1;

	if (wcslen(color) > MAX_PATH)
		return -1;

	RECT clientrc;
	::GetClientRect(m_hwnd, &clientrc);
	if (x1 >= clientrc.right || y1 >= clientrc.bottom)
	{
		intX = -1;
		intY = -1;
		return -1;
	}

	int findstringlen = wcslen(findstring);
	if (findstringlen<1 || findstringlen>MAX_PATH * 4)
	{
		return   -1;
	}

	wchar_t coloroffer[MAX_PATH] = { 0 };
	swprintf(coloroffer, L"%s", color);
	wchar_t fstring[MAX_PATH * 4] = { 0 };
	wcscpy(fstring, findstring);

	MyFindPictureClass  fpic;
	fpic.m_displayMode = m_displayMode;
	fpic.m_parenthwnd = m_parenthwnd;
	fpic.pWndBmpBuffer = pWndBmpBuffer;
	fpic.pWndBmpStrxy = pWndBmpStrxy;
	fpic.pBuffer = pBuffer;
	int bret = -1;

	if ((m_displayMode & DISPLAY_GDI) == DISPLAY_GDI || (m_displayMode & DISPLAY_NORMAL) == DISPLAY_NORMAL || (m_displayMode & DISPLAY_DX2) == DISPLAY_DX2 || (m_displayMode & DISPLAY_GDI2) == DISPLAY_GDI2)
	{

		TSRuntime::NowUsingDictIndex = NowUsingDictIndex;
		TSRuntime::nMyDictCountsize[TSRuntime::NowUsingDictIndex] = nMyDictCountsize[NowUsingDictIndex];
		TSRuntime::nMaxStrHight[TSRuntime::NowUsingDictIndex] = nMaxStrHight[NowUsingDictIndex];
		TSRuntime::MyDictCount[TSRuntime::NowUsingDictIndex] = MyDictCount[NowUsingDictIndex];
		if (Findstrtype == 0)   //FindStr
		{
			bret = fpic.FindStr(NULL, m_hwnd, x1,
				y1,
				x2,
				y2,
				fstring,
				coloroffer,
				sim,
				intX, intY, MyDictCount, nMyDictCountsize, NowUsingDictIndex, NULL, retstring, type);
		}
		else if (Findstrtype == 1)	 //FindStrFast
		{
			bret = fpic.FindStrFast(NULL, m_hwnd, x1,
				y1,
				x2,
				y2,
				fstring,
				coloroffer,
				sim,
				intX, intY, MyDictCount, nMyDictCountsize, NowUsingDictIndex, NULL, retstring, type);
		}
		//USES_CONVERSION;
		//TSRuntime::add_log( "findPicture,findstring:%s,X:%d,Y:%d",W2A(findstring),intX,intY);
		return bret;
	}
	else if (m_displayMode & DISPLAY_DX_3D)
	{
		if (!pData->ispichook)
			return 0;//如果PIC钩子HOOK失败,直接返回失败

		fpic.m_hwnd = m_hwnd;
		fpic.m_parenthwnd = 0;
		ST_TSFINDPIC getdata;
		getdata.left = x1;
		getdata.top = y1;
		getdata.right = x2;
		getdata.bottom = y2;
		getdata.ret = -1;
		pData->type = TS_GETSCREENDATA;
		::memcpy(pData->pmsg, &getdata, sizeof(ST_TSFINDPIC));
		wchar_t pszEventName[MAX_PATH] = { 0 };

		::wsprintf(pszEventName, L"%s%d", TS_EVENT_NAME, nPid);
		HANDLE picEvent = ::OpenEvent(EVENT_ALL_ACCESS, FALSE, pszEventName);
		if (picEvent)
		{
			::WaitForSingleObject(picEvent, 10000);
			::CloseHandle(picEvent);
		}
		else
		{
			picEvent = ::CreateEvent(NULL, TRUE, FALSE, pszEventName);
			::WaitForSingleObject(picEvent, 3000);
			::CloseHandle(picEvent);
		}
		DWORD(*Data)[2000] = (DWORD(*)[2000])pData->ColorDataInfo;

		if (Findstrtype == 0)   //FindStr
		{
			bret = fpic.FindStr(NULL, m_hwnd, x1,
				y1,
				x2,
				y2,
				fstring,
				coloroffer,
				sim,
				intX, intY, MyDictCount, nMyDictCountsize, NowUsingDictIndex, Data, retstring, type);
		}
		else if (Findstrtype == 1)	 //FindStrFast
		{
			bret = fpic.FindStrFast(NULL, m_hwnd, x1,
				y1,
				x2,
				y2,
				fstring,
				coloroffer,
				sim,
				intX, intY, MyDictCount, nMyDictCountsize, NowUsingDictIndex, Data, retstring, type);
		}
		return bret;

		//TSRuntime::add_log( "dxFindstr");
		//ST_TSFINDPIC pic;
		//pic.left=x1;
		//pic.top=y1;
		//pic.right=x2;
		//pic.bottom=y2;
		//wcscpy(pic.path,findstring);
		//wcscpy(pic.color_format,coloroffer);
		//pic.simi=sim;
		//pic.x=-1;
		//pic.y=-1;
		//pic.ret=-1;
		//if(Findstrtype==0&&retstring==NULL)   //FindStr
		//	pData->type=TS_FINDSTR;
		//else if(Findstrtype==1&&retstring==NULL)	 //FindStrFast
		//	pData->type=TS_FINDSTRFAST;
		//else if(Findstrtype==0&&retstring!=NULL&&type==0)//FindStrEx
		//	pData->type=TS_FINDSTREX;
		//else if(Findstrtype==1&&retstring!=NULL&&type==0)//FindStrFastEx
		//	pData->type=TS_FINDSTRFASTEX;
		//else if(Findstrtype==0&&retstring==NULL&&type==2)   //FindStrS
		//	pData->type=TS_FINDSTRS;
		//else if(Findstrtype==1&&retstring==NULL&&type==2)	 //FindStrFastS
		//	pData->type=TS_FINDSTRFASTS;
		//else if(Findstrtype==0&&retstring!=NULL&&type==1)  //FindStrExS
		//	pData->type=TS_FINDSTREXS;
		//else if(Findstrtype==1&&retstring!=NULL&&type==1)   //FindStrFastExS
		//	pData->type=TS_FINDSTRFASTEXS;


		//::memcpy(pData->pmsg,&pic,sizeof(ST_TSFINDPIC));
		//wchar_t pszEventName[MAX_PATH]={0}; 
		////DWORD nPid=0;
		////GetWindowThreadProcessId(m_hwnd,&nPid); //获取注入窗口的进程ID
		//::wsprintf(pszEventName,L"%s%d",TS_EVENT_NAME,nPid);
		//HANDLE picEvent=::CreateEvent(NULL,TRUE,FALSE,pszEventName);
		//::WaitForSingleObject(picEvent,INFINITE);
		//::CloseHandle(picEvent);
		//ST_TSFINDPIC *pPic=(ST_TSFINDPIC *)pData->pmsg;
		//intX=pPic->x;
		//intY=pPic->y;

		//if(retstring!=NULL)
		//	wcscpy(retstring,pData->RetString);

		//return pPic->ret;
	}
}

int DXBind::findPic(LONG x1, LONG y1, LONG x2, LONG y2, wchar_t* pic_name, wchar_t* color, DOUBLE sim, LONG dir, LONG& intX, LONG& intY, wchar_t* retstring, int type)
{
	//TSRuntime::add_log( "找图");
	//if(TSRuntime::m_displayMode&DISPLAY_GDI)

	if (wcslen(pic_name) >= 1024)
	{
		intX = -1;
		intY = -1;
		return -1;
	}
	RECT clientrc;
	::GetClientRect(m_hwnd, &clientrc);
	if (x1 >= clientrc.right || y1 >= clientrc.bottom)
	{
		intX = -1;
		intY = -1;
		return -1;
	}

	int bret = 0;
	MyFindPictureClass  fpic;
	fpic.m_displayMode = m_displayMode;
	fpic.m_parenthwnd = m_parenthwnd;
	fpic.pWndBmpBuffer = pWndBmpBuffer;
	fpic.pBuffer = pBuffer;
	if ((m_displayMode & DISPLAY_GDI) == DISPLAY_GDI || (m_displayMode & DISPLAY_NORMAL) == DISPLAY_NORMAL || (m_displayMode & DISPLAY_DX2) == DISPLAY_DX2 || (m_displayMode & DISPLAY_GDI2) == DISPLAY_GDI2)
	{
		if (wcslen(m_SetPath) > 0)
			wcscpy(fpic.SetPath, m_SetPath);

		bret = fpic.findPicture(NULL, m_hwnd, x1,
			y1,
			x2,
			y2,
			pic_name,
			color,
			sim,
			dir,
			intX, intY, NULL, retstring, type);
		//USES_CONVERSION;
		//TSRuntime::add_log( "findPicture,pic_path:%s,X:%d,Y:%d",W2A(pic_name),intX,intY);
		return bret;
	}
	else if (m_displayMode & DISPLAY_DX_3D)
	{
		if (!pData->ispichook)
			return 0;//如果PIC钩子HOOK失败,直接返回失败

		fpic.m_hwnd = m_hwnd;
		fpic.m_parenthwnd = 0;
		ST_TSFINDPIC getdata;
		getdata.left = x1;
		getdata.top = y1;
		getdata.right = x2;
		getdata.bottom = y2;
		getdata.ret = -1;
		pData->type = TS_GETSCREENDATA;
		::memcpy(pData->pmsg, &getdata, sizeof(ST_TSFINDPIC));
		wchar_t pszEventName[MAX_PATH] = { 0 };

		::wsprintf(pszEventName, L"%s%d", TS_EVENT_NAME, nPid);
		HANDLE picEvent = ::OpenEvent(EVENT_ALL_ACCESS, FALSE, pszEventName);
		if (picEvent)
		{
			::WaitForSingleObject(picEvent, 10000);
			::CloseHandle(picEvent);
		}
		else
		{
			picEvent = ::CreateEvent(NULL, TRUE, FALSE, pszEventName);
			::WaitForSingleObject(picEvent, 3000);
			::CloseHandle(picEvent);
		}
		DWORD(*Data)[2000] = (DWORD(*)[2000])pData->ColorDataInfo;

		if (wcslen(m_SetPath) > 0)
			wcscpy(fpic.SetPath, m_SetPath);

		bret = fpic.findPicture(NULL, m_hwnd, x1,
			y1,
			x2,
			y2,
			pic_name,
			color,
			sim,
			dir,
			intX, intY, Data, retstring, type);

		return bret;
		//TSRuntime::add_log( "dx模式找图,ndx:%d",++add);
		//ST_TSFINDPIC pic;
		//pic.left=x1;
		//pic.top=y1;
		//pic.right=x2;
		//pic.bottom=y2;
		//wcscpy(pic.path,pic_name);
		//wcscpy(pic.color_format,color);
		////pic.colorOffset=delta_color;
		//pic.simi=sim;
		//pic.dir=dir;
		//pic.x=-1;
		//pic.y=-1;
		//pic.ret=-1;
		//if(retstring==NULL)
		//	pData->type=TS_FINDPIC;
		//else if(retstring&&type==2)
		//	pData->type=TS_FINDPICS;
		//else if(retstring&&type==0)
		//	pData->type=TS_FINDPICEX;
		//else if(retstring&&type==1)
		//	pData->type=TS_FINDPICEXS;
		//::memcpy(pData->pmsg,&pic,sizeof(ST_TSFINDPIC)); 

		////DWORD nPid=0;
		////GetWindowThreadProcessId(m_hwnd,&nPid); //获取注入窗口的进程ID
		//wchar_t pszEventName[MAX_PATH]={0};
		//::wsprintf(pszEventName,L"%s%d",TS_EVENT_NAME,nPid);
		//HANDLE picEvent=::CreateEvent(NULL,TRUE,FALSE,pszEventName);
		//::WaitForSingleObject(picEvent,INFINITE);
		//::CloseHandle(picEvent);
		//ST_TSFINDPIC *pPic=(ST_TSFINDPIC *)pData->pmsg;
		//intX=pPic->x;
		//intY=pPic->y;
		//if(retstring!=NULL)
		//	wcscpy(retstring,pData->RetString);
		//return pPic->ret;
	}
}

//判断是否卡屏
int DXBind::IsDisplayDead(LONG x1, LONG y1, LONG x2, LONG y2, int times)
{
	//DWORD npid=0;
	//GetWindowThreadProcessId(m_hwnd,&npid);
	wchar_t path[MAX_PATH] = { 0 };
	if (nPid != 0)
	{
		GetTempPath(MAX_PATH, path);
		swprintf(path, L"%s\\tbmp%d.bmp", path, nPid);
		Capture(x1, y1, x2, y2, path, D3DXIFF_BMP);
		times = times * 1000;
		LONG retx = -1, rety = -1;
		int t1, t2, t3 = 0;
		for (int i = 0; i < times; i = i + t3)
		{
			t1 = GetTickCount();
			int bfind = findPic(x1 - 10, y1 - 10, x2 + 10, y2 + 10, path, L"000000", 1.0, 0, retx, rety);
			if (bfind == -1 && retx == -1)
			{
				DeleteFile(path);
				return 1;
			}
			Sleep(10);
			t2 = GetTickCount();
			t3 = t2 - t1;

		}
	}
	DeleteFile(path);
	return 0;
}

void DXBind::setIsBind(bool isbind)
{
	m_isBind = isbind;
}

bool DXBind::isBind()
{
	return m_isBind;
}

bool DXBind::TSMatchPicName(wchar_t* pic_name, wchar_t* ret_name)
{

	if (wcslen(pic_name) <= 0)
		return false;

	wchar_t picname[MAX_PATH][MAX_PATH];//存储多个字符串
	for (int i = 0; i < MAX_PATH; i++)
	{
		memset(picname[i], 0, 16);
	}
	int col = 0;
	short nstr = 0;//要查找文件类型个数 ,最多支持(MAX_PATH)个
	bool bfindxing = false;   //找到*
	bool bfindwen = false;	   //找到?
	while (*pic_name)
	{
		if (*pic_name != L'|')
		{
			if (*pic_name == '*')
				bfindxing = true;
			if (*pic_name == '?')
				bfindwen = true;

			picname[nstr][col++] = *pic_name;
			pic_name++;
			continue;
		}
		else
		{
			if (col < 1)
			{
				pic_name++;
				continue;
			}
			nstr++;
			col = 0;
			pic_name++;
		}
	}
	if (col >= 1)
		nstr++;

	col = 0;
	if (wcslen(m_SetPath) > 0)
	{
		wchar_t szFind[MAX_PATH] = { 0 };
		TCHAR szFile[MAX_PATH] = { 0 };
		wcscpy(szFind, m_SetPath);
		wcscat(szFind, L"\\*.bmp");
		WIN32_FIND_DATA FindFileData;
		HANDLE hFind = ::FindFirstFile(szFind, &FindFileData);
		if (INVALID_HANDLE_VALUE == hFind)    return false;
		int retnamelen = 0;
		while (TRUE)
		{
			if (FindFileData.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY)
			{
				//FindFileData.cFileName
				for (int i = col; i < nstr; i++)
				{
					int len = wcslen(FindFileData.cFileName);
					wchar_t pic[MAX_PATH] = { 0 };
					bool findxing = false;   //找到*
					bool findwen = false;	   //找到?
					bool bcontinue = true;
					bool bfind = false;
					for (int j = 0; j < len; j++)
					{
						if (FindFileData.cFileName[j] == '.')
						{

							for (int n = 0; n < nstr; n++)
							{
								if (wcscmp(FindFileData.cFileName, picname[n]) == 0)
								{
									bfind = true;
									break;
								}
							}
							if (!bfind)
							{
								//bcontinue=false;
								break;
							}

							if (retnamelen == 0)
								retnamelen = wcslen(ret_name);
							if (retnamelen == 0)
								swprintf(ret_name, L"%s", FindFileData.cFileName);
							else
								swprintf(ret_name, L"%s|%s", ret_name, FindFileData.cFileName);

							if (!bfindxing && !bfindwen)
								col++;
							bcontinue = false;
							break;
						}


						if (picname[i][j] == '*')
							findxing = true;
						else if (picname[i][j] == '?')
							findwen = true;
						else if (picname[i][j] != '*' || picname[i][j] != '?')
							pic[j] = picname[i][j];

						if (findxing)//找到*
						{
							int cmp = wcsncmp(FindFileData.cFileName, pic, j);
							if (cmp == 0)
							{
								if (retnamelen == 0)
									retnamelen = wcslen(ret_name);
								if (retnamelen == 0)
									swprintf(ret_name, L"%s", FindFileData.cFileName);
								else
									swprintf(ret_name, L"%s|%s", ret_name, FindFileData.cFileName);

								bcontinue = false;
								break;
							}
						}
						else if (findwen)//找到?
						{
							int filelen = wcslen(pic);
							filelen = len - filelen;
							int cmp = wcsncmp(FindFileData.cFileName, pic, j);
							if (cmp == 0)
							{
								for (int k = 0; k < filelen; k++)
								{
									if (FindFileData.cFileName[j + k] == '.')
									{
										if (retnamelen == 0)
											retnamelen = wcslen(ret_name);
										if (retnamelen == 0)
											swprintf(ret_name, L"%s", FindFileData.cFileName);
										else
											swprintf(ret_name, L"%s|%s", ret_name, FindFileData.cFileName);
										bcontinue = false;
										break;
									}
									if (picname[i][j + k] == '?')
									{
										pic[j + k] = FindFileData.cFileName[j + k];
										continue;
									}
									else
										break;
								}
								if (!bcontinue)
									break;
							}
						}
					}
					if (!bcontinue)
					{
						break;
					}

				}
			}

			if (!FindNextFile(hFind, &FindFileData) || col == nstr)    break;
		}
		FindClose(hFind);

	}
}

void DXBind::InitGdiNormal()
{
	//if((m_displayMode&DISPLAY_GDI)==DISPLAY_GDI||(m_displayMode&DISPLAY_NORMAL)==DISPLAY_NORMAL||(m_displayMode&DISPLAY_DX2)==DISPLAY_DX2||(m_displayMode&DISPLAY_GDI2)==DISPLAY_GDI2)
	{
		if (pWndBmpBuffer == NULL)
		{
			pWndBmpBuffer = new COLORREF * [2000];             /////二维数组 用来存储图像的颜色值
			for (int i = 0; i < 2000; i++)
			{
				pWndBmpBuffer[i] = new COLORREF[2000];
			}
		}
		if (pWndBmpStrxy == NULL)
		{
			pWndBmpStrxy = new short* [2000];
			for (int i = 0; i < 2000; i++)
			{
				pWndBmpStrxy[i] = new short[2000];
				memset(pWndBmpStrxy[i], 0, 2000);
				for (int j = 0; j < 2000; j++)
					pWndBmpStrxy[i][j] = 0;
			}
		}
		if (pBuffer == NULL)
		{
			pBuffer = new BYTE[(2000 * 3 + 3) / 4 * 4 * 2000];
		}
	}
}
void DXBind::mysleep(DWORD delaytime)
{
	char eventname[MAX_PATH] = { 0 };
	sprintf(eventname, "MYSLEEPEVENT:%d", nPid);
	HANDLE hEvent = ::CreateEventA(NULL, TRUE, FALSE, eventname);
	DWORD dtime1 = ::GetTickCount();
	DWORD dtime2 = dtime1;
	DWORD result;
	MSG msg;
	while (1)
	{
		result = ::MsgWaitForMultipleObjects(1, &hEvent, FALSE, INFINITE, QS_ALLINPUT);
		dtime1 = ::GetTickCount();
		if ((dtime1 - dtime2) >= delaytime)
		{
			CloseHandle(hEvent);
			break;
		}

		if (result == WAIT_OBJECT_0 + 1)
		{
			while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}

	}
}

bool DXBind::TSEnableRealMouse(LONG X, LONG Y)
{
	bool bret = false;
	double DouMovelen = 0.0;
	ULONG Movelen = ::abs(X - LastMouseMoveX) * ::abs(X - LastMouseMoveX) + ::abs(Y - LastMouseMoveY) * ::abs(Y - LastMouseMoveY);//(x*x+y*y)后在开方求长度
	DouMovelen = ::sqrt((double)Movelen);//开方
	Movelen = (ULONG)DouMovelen;
	short x = X, y = Y;
	DWORD MouseMoveX = LastMouseMoveX;
	DWORD MouseMoveY = LastMouseMoveY;
	while (mousestep < Movelen)
	{
		if (X == LastMouseMoveX)
		{
			x = X;
			if (Y > LastMouseMoveY)
			{
				y = MouseMoveY + mousestep;
				MouseMoveY = y;
			}
			else
			{
				y = MouseMoveY - mousestep;
				MouseMoveY = y;
			}

		}
		else  if (X > LastMouseMoveX)
		{
			if (Y > LastMouseMoveY)
			{
				x = (X - MouseMoveX) * mousestep / Movelen + MouseMoveX;
				y = (Y - MouseMoveY) * mousestep / Movelen + MouseMoveY;
				MouseMoveX = x;
				MouseMoveY = y;
			}
			else
			{
				x = (X - MouseMoveX) * mousestep / Movelen + MouseMoveX;
				y = MouseMoveY - (MouseMoveY - Y) * mousestep / Movelen;
				MouseMoveX = x;
				MouseMoveY = y;
			}
		}
		else if (X < LastMouseMoveX)
		{
			if (Y > LastMouseMoveY)
			{
				x = MouseMoveX - (MouseMoveX - X) * mousestep / Movelen;
				y = (Y - MouseMoveY) * mousestep / Movelen + MouseMoveY;
				MouseMoveX = x;
				MouseMoveY = y;
			}
			else
			{
				x = MouseMoveX - (MouseMoveX - X) * mousestep / Movelen;
				y = MouseMoveY - (MouseMoveY - Y) * mousestep / Movelen;
				MouseMoveX = x;
				MouseMoveY = y;
			}
		}

		if ((m_mouseMode & MOUSE_NORMAL) == MOUSE_NORMAL)
		{
			if (TSRuntime::SetSimModeType == 0)//普通模式
				::SetCursorPos(x, y);
		}
		else
		{
			if (m_mouseMode & MOUSE_WINDOW)
				PostMessage(m_mousekeyhwnd, WM_MOUSEMOVE, 0, MAKELPARAM(x, y));
			else
			{
				SendMsg(TS_MOUSEMOVE, 0, MAKELPARAM(x, y));
				//*nret=gDxObj.SendMsg(TS_MOUSEMOVEOVER);
			}
		}
		Movelen -= mousestep;
		Sleep(mousedelay);
	}
	x = X, y = Y;
	if ((m_mouseMode & MOUSE_NORMAL) == MOUSE_NORMAL)
	{
		if (TSRuntime::SetSimModeType == 0)//普通模式
			::SetCursorPos(x, y);
	}
	else
	{
		if (m_mouseMode & MOUSE_WINDOW)
			PostMessage(m_mousekeyhwnd, WM_MOUSEMOVE, 0, MAKELPARAM(x, y));
		else
		{
			SendMsg(TS_MOUSEMOVE, 0, MAKELPARAM(x, y));
		}
	}
	return bret;
}

DWORD  DXBind::TSRealKeyMousSleepTime(DWORD type)
{
	srand(::GetTickCount());
	DWORD sleeptime = 0;
	if (type == 0)//鼠标
	{
		DWORD Moustart = MouseClicksleep / 2; //范围的最小值
		DWORD Mouend = MouseClicksleep + Moustart;//范围的最大值
		int randnum = rand();
		if (randnum <= Moustart)
		{
			Moustart += (Moustart - randnum);
			sleeptime = Moustart;
		}
		else
		{
			if (randnum / Mouend == 0)
				sleeptime = Mouend - (Mouend - randnum);
			else
			{
				sleeptime = Mouend - (randnum - Mouend * (randnum / Mouend));
				if (sleeptime < Moustart)
					sleeptime = sleeptime + Moustart;
			}
		}
	}
	else//键盘
	{
		DWORD Keytart = KeyDownsleep / 2; //范围的最小值
		DWORD Keyend = KeyDownsleep + Keytart;//范围的最大值
		int randnum = rand();
		if (randnum <= Keytart)
		{
			Keytart += (Keytart - randnum);
			sleeptime = Keytart;
		}
		else
		{
			if (randnum / Keyend == 0)
				sleeptime = Keyend - (Keyend - randnum);
			else
			{
				sleeptime = Keyend - (randnum - Keyend * (randnum / Keyend));
				if (sleeptime < Keytart)
					sleeptime = sleeptime + Keytart;
			}
		}
	}
	return sleeptime;
}

void DXBind::TSMoveToEx(ULONG x, ULONG y, ULONG w, ULONG h, wchar_t* retstring)
{
	Sleep(5);
	srand(::GetTickCount());
	int randnum = rand();
	DWORD movx = 0, movy = 0;
	DWORD xw = w + x;
	DWORD hy = h + y;
	if (randnum <= x)
	{
		movx = x + (x - randnum);
		if (movx > xw)
			movx = x + (movx - xw);
	}
	else
	{
		if (randnum / xw == 0)
			movx = randnum;
		else
		{
			movx = x + (randnum - w * (randnum / w));
		}
	}

	if (randnum <= y)
	{
		movy = y + (y - randnum);
		if (movy > hy)
			movy = y + (movy - hy);
	}
	else
	{
		if (randnum / h == 0)
			movy = randnum;
		else
			movy = y + (randnum - h * (randnum / h));

	}
	swprintf(retstring, L"%d,%d", movx, movy);

}


//////////////////////////////////这里是注入游戏远程使用的API接口///////////////////////////////

//这里拦截API,并且开启检测线程
bool DXBind::hookApi()
{
	//开启线程
	//if(TSRuntime::MapViewThread==NULL)
	TSRuntime::MapViewThread = (HANDLE)_beginthread(ReadShareMemoryThreadFunc, 0, (void*)true);//启动注入HOOK线程
	//ReadShareMemoryThreadFunc((void*)true);//HookandUnhookAPI((void*)false);
	return true;
}

//获取机器码
bool DXBind::TSGetMachineCode(wchar_t* retcode)
{
	return true;
}