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

#include "stdafx.h"
#include "TSPlugInterFace.h"
#include "TSRuntime.h"
#include "DXBind.h"
#include "TsMessage.h"
#include "D3dx9tex.h"
#include <comutil.h>
#pragma comment(lib, "comsuppw.lib")
#include "dllmain.h"
#include "TSMyKernel32DllFuntion.h"
#include "Wininet.h"
#pragma comment(lib,"Wininet.lib")


//绑定互斥
TsMutex gDXbindMutex(TS_BINDEVEN);
//解绑定互斥
TsMutex gDXUnbindMutex(TS_UNBINDEVEN);
//按键按下互斥
TsMutex gDXKeyDownMutex(TS_KEYDOWNEVEN);
//按键弹起互斥
TsMutex gDXKeyUpMutex(TS_KEYUPEVEN);
//按键互斥
TsMutex gDXKeyPressMutex(TS_KEYPRESSEVEN);
//KeyPressStr互斥
TsMutex gDXKeyPressStrMutex(TS_KEYPRESSSTREVEN);
//KeyPressChar互斥
TsMutex gDXKeyPressCharMutex(TS_KEYPRESSCHAREVEN);
//SendString互斥
TsMutex gDXSendStringMutex(TS_SENDSTRINGEVEN);
//SendString互斥
TsMutex gDXSendString2Mutex(TS_SENDSTRING2EVEN);
//SendStringIme互斥
TsMutex gDXSendStringImeMutex(TS_SENDSTRINGIMEEVEN);
//LeftDown互斥		  
TsMutex gDXLeftDownMutex(TS_LEFTDOWNEVEN);
//LeftUp互斥		  
TsMutex gDXLeftUpMutex(TS_LEFTUPEVEN);
//LeftClick互斥		  
TsMutex gDXLeftClickMutex(TS_MOVETOEVEN);
//MoveTo互斥		  
TsMutex gDXMoveToMutex(TS_LEFTCLICKEVEN);
//FindPic互斥		  
TsMutex gDXFindPicMutex(TS_FINDPICEVEN);
////RightClick互斥		  
TsMutex gDXRightClickMutex(TS_RIGHTCLICKEVEN);
//RightDown互斥		  
TsMutex gDXRightDownMutex(TS_RIGHTDOWNEVEN);
//RightUp互斥		  
TsMutex gDXRightUpMutex(TS_RIGHTUPEVEN);
//FindColor互斥		  
TsMutex gDXFindColorMutex(TS_FINDCOLOREVEN);
//GetColor互斥		  
TsMutex gDXGetColorMutex(TS_GETCOLOREVEN);
//GetCursorShape互斥		  
TsMutex gDXGetCursorShapeMutex(TS_GETCURSORSHAPEEVEN);
//SetPath互斥		  
TsMutex gDXSetPathMutex(TS_SETPATHEVEN);
//GetCursorPos互斥		  
TsMutex gDXGetCursorPosMutex(TS_GETCURSORPOSEVEN);
//MoveR互斥		  
TsMutex gDXMoveRMutex(TS_MOVEREVEN);
//MiddleClick互斥		  
TsMutex gDXMiddleClickMutex(TS_MIDDLECLICKEVEN);
//WheelDown互斥						
TsMutex gDXWheelDownMutex(TS_WHEELDOWNEVEN);
//WheelUp互斥						
TsMutex gDXWheelUpMutex(TS_WHEELUPEVEN);
//Capture互斥						
TsMutex gDXCaptureMutex(TS_CAPTUREEVEN);
//LockInput互斥						
TsMutex gDXLockInputMutex(TS_LOCKINPUTEVEN);
//Ocr互斥						
TsMutex gDXOcrMutex(TS_OCREVEN);
//SetDict互斥						
TsMutex gDXSetDictMutex(TS_SETDICTEVEN);
//UseDict互斥						
TsMutex gDXUseDictMutex(TS_USEDICTEVEN);
//ClearDict互斥						
TsMutex gDXClearDictMutex(TS_CLEARDICTEVEN);
//FindStr互斥						
TsMutex gDXFindStrMutex(TS_FINDSTREVEN);
//GetNowDict互斥						
TsMutex gDXGetNowDictMutex(TS_GETNOWDICTEVEN);
//CaptureGif互斥						
TsMutex gDXCaptureGifMutex(TS_CAPTUREGIFEVEN);
//EnumWindow互斥						
TsMutex gDXEnumWindowMutex(TS_ENUMWINDOWEVEN);
//EnumWindowByProcess互斥						
TsMutex gDXEnumWindowByProcessMutex(TS_ENUMWINDOWBYPROCESSEVEN);
//EnumProcess互斥						
TsMutex gDXEnumProcessMutex(TS_ENUMPROCESSEVEN);
//FindData
TsMutex gDXFindDataMutex(TS_FINDDATAEVEN);
//FindDouble
TsMutex gDXFindDoubleMutex(TS_FINDDOUBLEEVEN);
//FindFloat
TsMutex gDXFindFloatMutex(TS_FINDFLOATEVEN);
//FindInt
TsMutex gDXFindIntMutex(TS_FINDINTEVEN);
//FindString
TsMutex gDXFindStringMutex(TS_FINDSTRINGEVEN);

TsMutex gDXMySleepMutex(TS_MYSLEEPEVEN);
//GetScreenData
TsMutex gDXMyGetScreenDataMutex(TS_MYGETSCREENDATAEVEN);
//MoveToEx
TsMutex gDXMoveToExMutex(TS_MOVETOEXEVEN);


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

int Loginlog(wchar_t * macode)   //统计使用人数
{																					

	{
		{
			HINTERNET internetopen = InternetOpen(L"TC",INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0);
			if (internetopen==NULL)
			{
				return 0;
			}
			wchar_t url[MAX_PATH]={0};
			swprintf(url,L"http://www.tyuyan.com/tongjiversion.aspx?version=2.5&maccode=%s",macode);
			HINTERNET internetopenurl = InternetOpenUrl(internetopen,url,NULL,0,INTERNET_FLAG_RELOAD,0);
			if (internetopenurl==NULL)
			{    
				InternetCloseHandle(internetopen);
				return 0;
			}
			InternetCloseHandle(internetopenurl);
			InternetCloseHandle(internetopen);
		}
	}

}

// CTSPlugInterFace
STDMETHODIMP CTSPlugInterFace::BindWindow(LONG hwnd, BSTR display, BSTR mouse, BSTR keypad, LONG mode, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXbindMutex);

	gDxObj.m_mousekeyhwnd=(HWND)hwnd;
	gDxObj.m_hwnd=(HWND)hwnd;
	*nret=false;

	VMPBEGIN    //VMP保护
		//if(!TSRuntime::IsVipLogin)
		//	{
		//		//::GetTickCount();
		//		int bret=TSRuntime::VipLogin(L"",0,false);   //试用验证
		//		if(bret<=0)
		//			{
		//				INT64 t=0;
		//				if(my_myGetTickCount)
		//					t=my_myGetTickCount();
		//				else
		//					t=::GetTickCount();
		//				if(t==TSRuntime::checkthreadtime||abs((int)(t-TSRuntime::checkthreadtime))>=60*1000*10||TSRuntime::checkthreadtime==0)	//校验线程是否被挂起或者GetTickCount被人下钩子
		//					{
		//						gDxObj.SendMsg(TS_UNBIND);
		//						Sleep(200);
		//						gDxObj.UnBind();
		//						Sleep(200);
		//						gDxObj.SendMsg(TS_UNBIND);
		//						Sleep(200);
		//						gDxObj.UnBind();
		//						if(TSRuntime::IsStartProtect)
		//							TSRuntime::StartProtect(0,L"");
		//						*nret=0;
		//						TSRuntime::h_checkthread=NULL;
		//						return S_OK;
		//					}
		//				
		//			}
		//	}
	DWORD displayMode=NULL,keyMode=NULL,mouseMode=NULL;
	//TSRuntime::add_log( "获得模式 外部 :%s",display);
	gDxObj.BindMode=0;
	gDxObj.m_keyMode=0;
	gDxObj.m_mouseMode=0;
	TSRuntime::getMode(mouse,keypad,display,mouseMode,keyMode,displayMode);

	if(displayMode==-1||keyMode==-1||mouseMode==-1)
		return false;

	gDxObj.m_displayMode=displayMode;
	gDxObj.m_keyMode=keyMode;
	gDxObj.m_mouseMode=mouseMode;

	gDxObj.BindMode=mode;
	gDxObj.m_mousekeyhwnd=(HWND)hwnd;
	bool sucee=false;
	if((gDxObj.m_displayMode&DISPLAY_DX_3D)==DISPLAY_DX_3D||(gDxObj.m_mouseMode&MOUSE_API)==MOUSE_API||(gDxObj.m_keyMode&KEY_API)==KEY_API)
	{
		sucee = gDxObj.bind(gDxObj.m_hwnd,0,0,gDxObj.m_displayMode,(BIND_MODE)gDxObj.BindMode);

		if(sucee==false&&::IsWindow(gDxObj.m_hwnd))//如果绑定失败,这里调用一次解绑动作
			gDxObj.UnBind();
		*nret=sucee;
	}
	else
		*nret=true;

	if((gDxObj.m_displayMode&DISPLAY_GDI) == DISPLAY_GDI||(gDxObj.m_displayMode&DISPLAY_DX2) == DISPLAY_DX2)
	{
		//TSRuntime::add_log( "DISPLAY_GDI");
		//TSRuntime::add_log( "gdi模式找图初始化");
		//GDI模式需要修改WINDOW样式
		//遍历获取父窗口句柄
		HWND parenthwnd=0;
		HWND hparent=0;
		bool findparent=false;
		do{
			if(parenthwnd==0)
				parenthwnd=GetParent(gDxObj.m_hwnd);
			else
			{
				hparent=GetParent(parenthwnd);
				if(hparent!=0&&hparent!=parenthwnd)
				{
					//gDxObj.m_parenthwnd=hparent;
					//TSRuntime::add_log( "gDxObj.m_parenthwnd:%d",gDxObj.m_parenthwnd);
					hwnd=(LONG)hparent;
					findparent=true;
				}
				parenthwnd=hparent;
			}

		}while(parenthwnd!=NULL);


		char pszBinWindow_GDIWINDOW[MAX_PATH]={0};
		sprintf( pszBinWindow_GDIWINDOW,"%s%d",TS_BINDWINDOW_GDIWINDOW,gDxObj.nPid);
		SetPropA((HWND)hwnd,pszBinWindow_GDIWINDOW,(HANDLE)1);   //设置绑定标识符

		typedef bool (__stdcall  *  myGetLayeredWindowAttributes)( 
			HWND hwnd,
			COLORREF *pcrKey,
			BYTE *pbAlpha,
			DWORD *pdwFlags); 
		myGetLayeredWindowAttributes obj_GetLayeredWindowAttributes= NULL; 
		typedef bool (__stdcall  *  mySetLayeredWindowAttributes)( 
			HWND hwnd,
			COLORREF pcrKey,
			BYTE pbAlpha,
			DWORD pdwFlags); 
		mySetLayeredWindowAttributes obj_SetLayeredWindowAttributes=  NULL; 
		HINSTANCE hlibrary;
		hlibrary = LoadLibrary(_T("user32.dll"));
		obj_GetLayeredWindowAttributes=(myGetLayeredWindowAttributes)GetProcAddress(hlibrary,"GetLayeredWindowAttributes");
		obj_SetLayeredWindowAttributes=(mySetLayeredWindowAttributes)GetProcAddress(hlibrary,"SetLayeredWindowAttributes");
		DWORD dwExStyle = GetWindowLong((HWND)hwnd,GWL_EXSTYLE);
		gDxObj.GDI_dwExStyle=dwExStyle;
		COLORREF crKey=0;
		BYTE bAlpha=0;
		DWORD dwFlags=0;
		bool ret=obj_GetLayeredWindowAttributes((HWND)hwnd, &crKey, &bAlpha, &dwFlags);
		//GDI:crKey=0xff00ff,bAlpha=0,dwFlags=1;//DX2:crKey=0;bAlpha=0XFF;dwFlags=2;
		if(gDxObj.m_displayMode&DISPLAY_GDI)
		{
			crKey=0xff00ff;
			bAlpha=0;
			dwFlags=LWA_COLORKEY;
			::SetWindowLong((HWND)hwnd, GWL_EXSTYLE, 0x80100);
		}
		else if(gDxObj.m_displayMode&DISPLAY_DX2)
		{
			crKey=0;
			bAlpha=0XFF;
			dwFlags=LWA_ALPHA;
			::SetWindowLong((HWND)hwnd, GWL_EXSTYLE, 0x80100);
		}
		obj_SetLayeredWindowAttributes((HWND)hwnd, crKey, bAlpha, dwFlags);
		::UpdateWindow((HWND)hwnd);
		Sleep(100); //疑问 这里等1秒是等待窗口刷新
		gDxObj.m_dwExStyle=dwExStyle;

		//GDI模式需要修改WINDOW样式
	}
	else if(gDxObj.m_displayMode&DISPLAY_NORMAL)
	{
		gDxObj.m_hwnd=GetDesktopWindow();
		if(::IsWindow((HWND)hwnd))
			gDxObj.m_parenthwnd=(HWND)hwnd;
		else
			gDxObj.m_parenthwnd=gDxObj.m_hwnd;//桌面句柄;
	}
	gDxObj.InitGdiNormal();
	if(sucee||*nret==true)
		gDxObj.m_isBind=true;
	VMPEND
		//TSRuntime::add_log( "TS_BIND-end");
		return S_OK;
}

STDMETHODIMP CTSPlugInterFace::BindWindowEx(LONG hwnd, BSTR display, BSTR mouse, BSTR keypad, BSTR publics, LONG mode, LONG* nret)
{
	// TODO: 在此添加实现代码
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::UnBindWindow(LONG* nret)
{
	TsMutexlock ts_mutexlock(&gDXUnbindMutex);
	//TSRuntime::g_DxObj.SendMsg(TS_UNBIND);
	if(gDxObj.m_isBind)
	{
		gDxObj.SendMsg(TS_UNBIND);
		Sleep(200);
		gDxObj.UnBind();
		gDxObj.m_isBind=false;
		if(!TSRuntime::IsLoginlog)
		{
			Loginlog(TSRuntime::MachineCode);
			TSRuntime::IsLoginlog=true;
		}
	}
	* nret=1;
	// TODO: 在此添加实现代码
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::KeyDown(LONG vk_code, LONG* nret)
{
	TsMutexlock ts_mutexlock(&gDXKeyDownMutex);
	// TODO: 在此添加实现代码
	if(vk_code==VK_MENU)
	{
		//TSRuntime::g_IsSYSKEY=true;
		gDxObj.g_IsSYSKEY=true;
	}
	if((gDxObj.m_keyMode&KEY_NORMAL)==KEY_NORMAL)//判断是否是前台模式
	{

	if(TSRuntime::SetSimModeType==0)
			TSRuntime::g_KeyBoard.keyDown(vk_code);
	}
	else
	{
		if(gDxObj.g_IsSYSKEY&&vk_code!=VK_MENU)
			*nret=PostMessage(gDxObj.m_mousekeyhwnd,WM_SYSKEYDOWN,vk_code,1<<29);
		gDxObj.SendMsg(TS_KEYDOWN,vk_code);	
		//*nret=PostMessage(TSRuntime::g_DxObj.m_hwnd,WM_SYSKEYDOWN,vk_code,1<<29);
		if(gDxObj.m_keyMode&KEY_WINDOW)
			PostMessage(gDxObj.m_mousekeyhwnd,WM_KEYDOWN,vk_code,TSRuntime::retrunLparamDown(vk_code));
		//TSRuntime::g_DxObj.SendMsg(WM_KEYDOWN,vk_code);
	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::KeyUp(LONG vk_code, LONG* nret)
{
	TsMutexlock ts_mutexlock(&gDXKeyUpMutex);
	// TODO: 在此添加实现代码
	if(vk_code==VK_MENU)
	{
		//TSRuntime::g_IsSYSKEY=false;
		gDxObj.g_IsSYSKEY=false;
	}
	if((gDxObj.m_keyMode&KEY_NORMAL)==KEY_NORMAL)//判断是否是前台模式
	{
		if(TSRuntime::SetSimModeType==0)
			TSRuntime::g_KeyBoard.keyUp(vk_code);
	}
	else
	{
		if(TSRuntime::g_IsSYSKEY)
			*nret=::PostMessage(gDxObj.m_mousekeyhwnd,WM_SYSKEYUP,vk_code,0);
		*nret=gDxObj.SendMsg(TS_KEYUP,vk_code);
		//	*nret=::PostMessage(TSRuntime::g_DxObj.m_hwnd,WM_SYSKEYUP,vk_code,0);
		//*nret=TSRuntime::g_DxObj.SendMsg(TS_KEYUP,vk_code);
		if(gDxObj.m_keyMode&KEY_WINDOW)
			//TSRuntime::g_DxObj.SendMsg(WM_KEYUP,vk_code);
			PostMessage(gDxObj.m_mousekeyhwnd,WM_KEYUP,vk_code,(0xC0000000|TSRuntime::retrunLparamDown(vk_code)));
	}

	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::KeyPress(LONG vk_code, LONG* nret)
{
	TsMutexlock ts_mutexlock(&gDXKeyPressMutex);
	// TODO: 在此添加实现代码

	if((gDxObj.m_keyMode&KEY_NORMAL)==KEY_NORMAL)//判断是否是前台模式
	{
		if(TSRuntime::SetSimModeType==0)
		{
			TSRuntime::g_KeyBoard.delaytime=gDxObj.NormalKeysleep;
			TSRuntime::g_KeyBoard.keyPress(vk_code);
		}
	}
	else
	{
		if(gDxObj.g_IsSYSKEY&&vk_code!=VK_MENU)
			*nret=PostMessage(gDxObj.m_mousekeyhwnd,WM_SYSKEYDOWN,vk_code,1<<29);
		else
			*nret=gDxObj.SendMsg(TS_KEYDOWN,vk_code);

		if(gDxObj.m_keyMode&KEY_WINDOW)
			PostMessage(gDxObj.m_mousekeyhwnd,WM_KEYDOWN,vk_code,TSRuntime::retrunLparamDown(vk_code));

		if(gDxObj.m_keyMode&KEY_WINDOW)	//window模式默认延时))
		{
			if(gDxObj.IsTSEnableRealKeypad)
				Sleep(gDxObj.TSRealKeyMousSleepTime(1));
			else
				Sleep(gDxObj.WindowsKeyMouseClicksleep);
		}
		else
		{
			if(gDxObj.IsTSEnableRealKeypad)
				Sleep(gDxObj.TSRealKeyMousSleepTime(1));
			else
				Sleep(gDxObj.KeyDownsleep);
		}

		*nret=gDxObj.SendMsg(TS_KEYUP,vk_code);

		if(gDxObj.m_keyMode&KEY_WINDOW)
			PostMessage(gDxObj.m_mousekeyhwnd,WM_KEYUP,vk_code,(0xC0000000|TSRuntime::retrunLparamDown(vk_code)));

	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::LeftDown(LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXLeftDownMutex);
	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		//
		if(TSRuntime::SetSimModeType==0)//普通模式
			TSRuntime::g_Mouse.leftDown();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
		{
			SendMessage(gDxObj.m_mousekeyhwnd,WM_SETFOCUS,(WPARAM)gDxObj.m_mousekeyhwnd,0);
			SendMessage(gDxObj.m_mousekeyhwnd,WM_CAPTURECHANGED,(WPARAM)gDxObj.m_mousekeyhwnd,0);
			PostMessage(gDxObj.m_mousekeyhwnd,WM_LBUTTONDOWN,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
		}
		else
			*nret=gDxObj.SendMsg(TS_LBUTTONDOWN,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
	}

	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::LeftUp(LONG* nret)
{
	// TODO: 在此添加实现代
	TsMutexlock ts_mutexlock(&gDXLeftUpMutex);
	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		//TSRuntime::g_Mouse.leftUp();
		if(TSRuntime::SetSimModeType==0)//普通模式
			TSRuntime::g_Mouse.leftUp();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
		{
			PostMessage(gDxObj.m_mousekeyhwnd,WM_LBUTTONUP,0,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
			SendMessage(gDxObj.m_mousekeyhwnd,WM_CAPTURECHANGED,0,0);
		}
		else
			*nret=gDxObj.SendMsg(TS_LBUTTOUP,0,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::LeftClick(LONG* nret)
{
	TsMutexlock ts_mutexlock(&gDXLeftClickMutex);
	// TODO: 在此添加实现代码

	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		TSRuntime::g_Mouse.delaytimes=gDxObj.NormalClicksleep;
		if(TSRuntime::SetSimModeType==0)//普通模式
			TSRuntime::g_Mouse.leftClick();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
		{
			SendMessage(gDxObj.m_mousekeyhwnd,WM_SETFOCUS,(WPARAM)gDxObj.m_mousekeyhwnd,0);
			SendMessage(gDxObj.m_mousekeyhwnd,WM_CAPTURECHANGED,(WPARAM)gDxObj.m_mousekeyhwnd,0);
			PostMessage(gDxObj.m_mousekeyhwnd,WM_LBUTTONDOWN,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
		}
		else
			*nret=gDxObj.SendMsg(TS_LBUTTONDOWN,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)	//window模式默认延时
		{
			if(gDxObj.IsTSEnableRealMouse)
				Sleep(gDxObj.TSRealKeyMousSleepTime(0));
			else
				Sleep(gDxObj.WindowsKeyMouseClicksleep);
		}
		else
		{
			if(gDxObj.IsTSEnableRealMouse)
				Sleep(gDxObj.TSRealKeyMousSleepTime(0));
			else
				Sleep(gDxObj.MouseClicksleep);  //dx模式默认延时
		}
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
		{
			PostMessage(gDxObj.m_mousekeyhwnd,WM_LBUTTONUP,0,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
			SendMessage(gDxObj.m_mousekeyhwnd,WM_CAPTURECHANGED,0,0);
		}
		else
			*nret=gDxObj.SendMsg(TS_LBUTTOUP,0,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
	}

	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::MoveTo(LONG x, LONG y, LONG* nret)
{
	TsMutexlock ts_mutexlock(&gDXMoveToMutex);
	// TODO: 在此添加实现代码
	POINT pos;
	pos.x=x;
	pos.y=y;
	if(gDxObj.IsTSEnableRealMouse)
	{
		if(IsWindow(gDxObj.m_hwnd))
		{
			::ClientToScreen(gDxObj.m_mousekeyhwnd,&pos);
			gDxObj.TSEnableRealMouse(pos.x,pos.y);
			gDxObj.LastMouseMoveX=pos.x;
			gDxObj.LastMouseMoveY=pos.y;
		}
		else
		{
			gDxObj.TSEnableRealMouse(x,y);
			gDxObj.LastMouseMoveX=x;
			gDxObj.LastMouseMoveY=y;
		}

	}
	else
	{
		if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
		{
			if(IsWindow(gDxObj.m_hwnd))
			{
				::ClientToScreen(gDxObj.m_mousekeyhwnd,&pos);
				if(TSRuntime::SetSimModeType==0)//普通模式
					::SetCursorPos(pos.x,pos.y);
				gDxObj.LastMouseMoveX=pos.x;
				gDxObj.LastMouseMoveY=pos.y;
			}
			else
			{
				//::SetCursorPos(x,y);
				if(TSRuntime::SetSimModeType==0)//普通模式
					::SetCursorPos(x,y);
				gDxObj.LastMouseMoveX=x;
				gDxObj.LastMouseMoveY=y;
			}
		}
		else
		{
			if(gDxObj.m_mouseMode&MOUSE_WINDOW)
				PostMessage(gDxObj.m_mousekeyhwnd,WM_MOUSEMOVE,0,MAKELPARAM(x,y));
			else
			{
				*nret=gDxObj.SendMsg(TS_MOUSEMOVE,0,MAKELPARAM(x,y));
				//*nret=gDxObj.SendMsg(TS_MOUSEMOVEOVER);
			}
			gDxObj.LastMouseMoveX=x;
			gDxObj.LastMouseMoveY=y;
		}
	}

	*nret=1;
	return S_OK;
}

//int addr=0;
STDMETHODIMP CTSPlugInterFace::FindPic(LONG x1, LONG y1, LONG x2, LONG y2, BSTR pic_name, BSTR delta_color, DOUBLE sim, LONG dir, VARIANT* intX, VARIANT* intY, LONG* nret)
{	 //
	TsMutexlock ts_mutexlock(&gDXFindPicMutex);
	LONG x=-1,y=-1,ret=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	//ret=TSRuntime::g_DxObj.findPic(x1,y1,x2,y2,pic_name,delta_color,sim,dir,x,y);
	ret=gDxObj.findPic(x1,y1,x2,y2,pic_name,delta_color,sim,dir,x,y);
	intX->vt=VT_I4;
	intY->vt=VT_I4;
	intX->lVal=x;
	intY->lVal=y;
	if(x==-1||y==-1)
		ret=-1;
	*nret=ret;
	//TSRuntime::add_log( "findPicture,X:%d,Y:%d",x,y);
	//TSRuntime::add_log( "findPicture,X:%d,Y:%d,add:%d",x,y,++addr);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::RightClick(LONG* nret)
{
	TsMutexlock ts_mutexlock(&gDXRightClickMutex);

	// TODO: 在此添加实现代码
	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		TSRuntime::g_Mouse.delaytimes=gDxObj.NormalClicksleep;
		//TSRuntime::g_Mouse.rightClick();
		if(TSRuntime::SetSimModeType==0)//普通模式
			TSRuntime::g_Mouse.rightClick();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
		{
			PostMessage(gDxObj.m_mousekeyhwnd,WM_RBUTTONDOWN,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
			SendMessage(gDxObj.m_mousekeyhwnd,WM_SETFOCUS,(WPARAM)gDxObj.m_hwnd,0);
			SendMessage(gDxObj.m_mousekeyhwnd,WM_CAPTURECHANGED,(WPARAM)gDxObj.m_mousekeyhwnd,0);
		}
		else
			*nret=gDxObj.SendMsg(TS_RBUTTONDOWN,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)	//window模式默认延时
		{
			if(gDxObj.IsTSEnableRealMouse)
				Sleep(gDxObj.TSRealKeyMousSleepTime(0));
			else
				Sleep(gDxObj.WindowsKeyMouseClicksleep);
		}
		else
		{
			if(gDxObj.IsTSEnableRealMouse)
				Sleep(gDxObj.TSRealKeyMousSleepTime(0));
			else
				Sleep(gDxObj.MouseClicksleep);  //dx模式默认延时
		}
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
		{
			PostMessage(gDxObj.m_mousekeyhwnd,WM_RBUTTONUP,0,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
			SendMessage(gDxObj.m_mousekeyhwnd,WM_CAPTURECHANGED,0,0);
		}
		else
			*nret=gDxObj.SendMsg(TS_RBUTTONUP,0,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
	}

	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::RightDown(LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXRightDownMutex);

	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		//TSRuntime::g_Mouse.rightDown();
		if(TSRuntime::SetSimModeType==0)//普通模式
			TSRuntime::g_Mouse.rightDown();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
		{
			PostMessage(gDxObj.m_mousekeyhwnd,WM_RBUTTONDOWN,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
			SendMessage(gDxObj.m_mousekeyhwnd,WM_SETFOCUS,(WPARAM)gDxObj.m_hwnd,0);
			SendMessage(gDxObj.m_mousekeyhwnd,WM_CAPTURECHANGED,(WPARAM)gDxObj.m_mousekeyhwnd,0);
		}
		else
			*nret=gDxObj.SendMsg(TS_RBUTTONDOWN,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
	}

	*nret=1;
	return S_OK;
}
STDMETHODIMP CTSPlugInterFace::FindColor(LONG x1, LONG y1, LONG x2, LONG y2, BSTR color, DOUBLE sim, LONG dir, VARIANT* intX, VARIANT* intY, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindColorMutex);
	if(x1>=x2||y1>=y2)
	{
		MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	//wchar_t* p=0;
	DWORD ncolor=0x100;
	//ncolor=::wcstol(color,&p,16);
	//int r=0,g=0,b=0;
	//r=GetRValue(ncolor);
	//g=GetGValue(ncolor);
	//b=GetBValue(ncolor);
	//swprintf(color,L"%x%x%x",r,g,b);//将传入的RGB颜色值转换为BGR进行找色
	//ncolor=::wcstol(color,&p,16);
	LONG x=-1,y=-1,ret;
	//TSRuntime::add_log("FindColor:_wtoi:%x",ncolor);
	//ret=TSRuntime::g_DxObj.findColor(x1,y1,x2,y2,ncolor,sim,dir,x,y);
	ret=gDxObj.findColor(x1,y1,x2,y2,ncolor,sim,dir,x,y,color);
	intX->vt=VT_I4;
	intY->vt=VT_I4;
	intX->lVal=x;
	intY->lVal=y;
	*nret=ret;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::RightUp(LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXRightUpMutex);

	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		//TSRuntime::g_Mouse.rightUp();
		if(TSRuntime::SetSimModeType==0)//普通模式
			TSRuntime::g_Mouse.rightUp();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
		{
			PostMessage(gDxObj.m_mousekeyhwnd,WM_RBUTTONUP,0,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
			SendMessage(gDxObj.m_mousekeyhwnd,WM_CAPTURECHANGED,0,0);
		}
		else
			*nret=gDxObj.SendMsg(TS_RBUTTONUP,0,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
	}
	*nret=1;
	return S_OK;
}


STDMETHODIMP CTSPlugInterFace::GetColor(LONG x, LONG y, BSTR* RetStrColor)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXGetColorMutex);
	//TSRuntime::g_DxObj.GetColor(x,y,*RetStrColor);

	//memset(TSRuntime::RetStr,0,MAX_PATH);
	gDxObj.GetColor(x,y,TSRuntime::RetStr);
	CComBSTR newbstr;
	newbstr.Append(TSRuntime::RetStr);
	newbstr.CopyTo(RetStrColor);
	//_variant_t strVar();
	//*RetStrColor=strVar.bstrVal;//_bstr_t(TSRuntime::RetStr)
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetCursorShape(BSTR* RetCursorShape)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXGetCursorShapeMutex);

	DWORD mouseshape=0;
	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		TSRuntime::g_Mouse.getmouseshape(mouseshape);
	}
	else
		mouseshape=gDxObj.SendMsg(TS_GETMOUSESHARE,0,0);
	if(mouseshape)
	{
		memset(TSRuntime::RetStr,0,MAX_PATH);
		swprintf(TSRuntime::RetStr,L"%x",mouseshape);
		_variant_t strVar(TSRuntime::RetStr);
		*RetCursorShape=strVar.bstrVal;
	}
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetPath(BSTR path, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXSetPathMutex);
	//*nret=TSRuntime::g_DxObj.TSSetpath(path);
	*nret=gDxObj.TSSetpath(path);
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::TSGuardProtect(LONG enable, BSTR type,LONG* nret)
{
	// TODO: 在此添加实现代码
	// TsMutexlock ts_mutexlock(&gDXbindMutex);
	VMPBEGIN    //VMP保护
	if(!TSRuntime::IsVipLogin)
	{
		if(TSRuntime::IsRegLogin==false&&TSRuntime::IsVipLogin==false)//TS盾不允许试用
		{
			*nret=0;
			return S_OK;
		}
		INT64 t=0;
		if(my_myGetTickCount)
			t=my_myGetTickCount();
		else
			t=::GetTickCount();
		if(t==TSRuntime::checkthreadtime||abs((int)(t-TSRuntime::checkthreadtime))>=60*1000*10||TSRuntime::checkthreadtime==0)	//校验线程是否被挂起或者GetTickCount被人下钩子
		{
			if(TSRuntime::IsStartProtect)
				TSRuntime::StartProtect(0,0,-1);//Pid
			*nret=0;
			TSRuntime::h_checkthread=NULL;
			return S_OK;
		}
	}
	TSRuntime::IsProid=wcstol(type,0,10);
	*nret=TSRuntime::StartProtect(enable,0);
	VMPEND
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::KeyPressStr(BSTR key_str, LONG delay, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXKeyPressStrMutex);
	if((gDxObj.m_keyMode&KEY_NORMAL)==KEY_NORMAL)//判断是否是前台模式
	{
		if(TSRuntime::SetSimModeType==0)
			TSRuntime::g_KeyBoard.sendkeyString(key_str,delay);
	}
	else
	{
		int len=wcslen(key_str);
		for(int i=0;i<len;i++)
		{
			// * nret=TSRuntime::g_DxObj.SendMsg(TS_CHAR,key_str[i]);	
			gDxObj.SendMsg(TS_CHAR,key_str[i]);
			if(gDxObj.m_keyMode&KEY_WINDOW)
				gDxObj.SendMsg(WM_CHAR,i);
			Sleep(delay);
		}
	}
	//std::string dd=gDxObj.pData->tt;
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SendString(LONG hwnd, BSTR str, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXSendStringMutex);
	int len=wcslen(str);
	//MessageBoxA(NULL,tts,tts,NULL);
	for(int i=0;i<len;i++)
	{
		* nret=::SendMessage((HWND)hwnd,WM_CHAR,(WPARAM)str[i],(LPARAM)1);
		Sleep(10);
	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SendString2(LONG hwnd, BSTR str, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXSendString2Mutex);
	int len=wcslen(str);
	for(int i=0;i<len;i++)
	{								   
		* nret=::PostMessage((HWND)hwnd,WM_CHAR,(WPARAM)str[i],(LPARAM)1);
		Sleep(10);
	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::KeyPressChar(BSTR key_str, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXKeyPressCharMutex);

	for(int i=0;i<0x100;i++)
	{
		if(TSRuntime::KeyPressCharMap[i])
		{
			if(wcscmp(TSRuntime::KeyPressCharMap[i],_wcslwr(key_str))==0)
			{
				if((gDxObj.m_keyMode&KEY_NORMAL)==KEY_NORMAL)//判断是否是前台模式
				{
					if(TSRuntime::SetSimModeType==0)
					{
						TSRuntime::g_KeyBoard.delaytime=gDxObj.NormalKeysleep;
						TSRuntime::g_KeyBoard.keyPress(i);
					}
				}
				else
				{
					//if(TSRuntime::g_IsSYSKEY&&wcscmp(L"alt",TSRuntime::KeyPressCharMap[i])!=0)
					if(gDxObj.g_IsSYSKEY&&wcscmp(L"alt",TSRuntime::KeyPressCharMap[i])!=0&&gDxObj.m_keyMode&KEY_WINDOW)
						*nret=PostMessage(gDxObj.m_mousekeyhwnd,WM_SYSKEYDOWN,i,1<<29);
					//*nret=PostMessage(TSRuntime::g_DxObj.m_hwnd,WM_SYSKEYDOWN,i,1<<29);

					//*nret=TSRuntime::g_DxObj.SendMsg(TS_KEYDOWN,i);
					*nret=gDxObj.SendMsg(TS_KEYDOWN,i);
					if(gDxObj.m_keyMode&KEY_WINDOW)
						//TSRuntime::g_DxObj.SendMsg(WM_KEYDOWN,i,TSRuntime::retrunLparamDown(i));
						PostMessage(gDxObj.m_mousekeyhwnd,WM_KEYDOWN,i,TSRuntime::retrunLparamDown(i));

					if(gDxObj.m_keyMode&KEY_WINDOW)	//window模式默认延时))
					{
						if(gDxObj.IsTSEnableRealKeypad)
							Sleep(gDxObj.TSRealKeyMousSleepTime(1));
						else
							Sleep(gDxObj.WindowsKeyMouseClicksleep);
					}
					else
					{
						if(gDxObj.IsTSEnableRealKeypad)
							Sleep(gDxObj.TSRealKeyMousSleepTime(1));
						else
							Sleep(gDxObj.KeyDownsleep);
					}

					//*nret=TSRuntime::g_DxObj.SendMsg(TS_KEYUP,i);
					*nret=gDxObj.SendMsg(TS_KEYUP,i);
					if(gDxObj.m_keyMode&KEY_WINDOW)
						//TSRuntime::g_DxObj.SendMsg(WM_KEYUP,i,(0xC0000000|TSRuntime::retrunLparamDown(i)));
						PostMessage(gDxObj.m_mousekeyhwnd,WM_KEYUP,i,(0xC0000000|TSRuntime::retrunLparamDown(i)));
				}
				break;

			}


		}
	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::KeyDownChar(BSTR key_str, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXKeyDownMutex);
	if(wcscmp(L"alt",_wcslwr(key_str))==0)
	{
		//TSRuntime::g_IsSYSKEY=true;
		gDxObj.g_IsSYSKEY=true;
	}

	for(int i=0;i<0x100;i++)
	{
		if(TSRuntime::KeyPressCharMap[i])
		{
			if(wcscmp(TSRuntime::KeyPressCharMap[i],_wcslwr(key_str))==0)
			{
				if((gDxObj.m_keyMode&KEY_NORMAL)==KEY_NORMAL)//判断是否是前台模式
				{
 if(TSRuntime::SetSimModeType==0)
						TSRuntime::g_KeyBoard.keyDown(i);
				}
				else
				{
					if(gDxObj.g_IsSYSKEY&&wcscmp(L"alt",TSRuntime::KeyPressCharMap[i])!=0)
						*nret=PostMessage(gDxObj.m_mousekeyhwnd,WM_SYSKEYDOWN,i,1<<29);
					*nret=gDxObj.SendMsg(TS_KEYDOWN,i);
					if(gDxObj.m_keyMode&KEY_WINDOW)
						//TSRuntime::g_DxObj.SendMsg(WM_KEYDOWN,i);
						PostMessage(gDxObj.m_mousekeyhwnd,WM_KEYDOWN,i,TSRuntime::retrunLparamDown(i));

				}
				break;
			}
		}
	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::KeyUpChar(BSTR key_str, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXKeyUpMutex);
	if(wcscmp(L"alt",_wcslwr(key_str))==0)
		gDxObj.g_IsSYSKEY=false;
	for(int i=0;i<0x100;i++)
	{
		if(TSRuntime::KeyPressCharMap[i]!=NULL)
		{
			if(wcscmp(TSRuntime::KeyPressCharMap[i],_wcslwr( key_str))==0)
			{
				if((gDxObj.m_keyMode&KEY_NORMAL)==KEY_NORMAL)//判断是否是前台模式
				{
 if(TSRuntime::SetSimModeType==0)
						TSRuntime::g_KeyBoard.keyUp(i);
				}
				else
				{
					*nret=gDxObj.SendMsg(TS_KEYUP,i);
					if(gDxObj.m_keyMode&KEY_WINDOW)
						//TSRuntime::g_DxObj.SendMsg(WM_KEYUP,i);
						PostMessage(gDxObj.m_mousekeyhwnd,WM_KEYUP,i,(0xC0000000|TSRuntime::retrunLparamDown(i)));
				}
				break;
			}

		}
	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetCursorPos(VARIANT* x, VARIANT* y, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXGetCursorPosMutex);
	//LONG lParam=0;
	//lParam=TSRuntime::g_DxObj.SendMsg(TS_GETCURSORPOS);
	//lParam=gDxObj.SendMsg(TS_GETCURSORPOS);
	x->vt=VT_I4;
	y->vt=VT_I4;
	x->lVal=gDxObj.LastMouseMoveX;
	y->lVal=gDxObj.LastMouseMoveY;
	* nret=1;
	////if(lParam)
	//{
	//	x->lVal=(short)LOWORD(lParam);
	//	y->lVal=(short)HIWORD(lParam);
	//	* nret=1;
	//}
	//else
		//* nret=0;

	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::MoveR(LONG rx, LONG ry, LONG* rnet)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXMoveRMutex);
		
	POINT pos;
	pos.x=rx+gDxObj.LastMouseMoveX;
	pos.y=ry+gDxObj.LastMouseMoveY;
	if(gDxObj.IsTSEnableRealMouse)
	{
		if(IsWindow(gDxObj.m_hwnd))
		{
			::ScreenToClient(gDxObj.m_mousekeyhwnd,&pos);
			gDxObj.TSEnableRealMouse(pos.x,pos.y);
			gDxObj.LastMouseMoveX=pos.x;
			gDxObj.LastMouseMoveY=pos.y;
		}
		else
		{
			gDxObj.TSEnableRealMouse(rx+gDxObj.LastMouseMoveX,ry+gDxObj.LastMouseMoveY);
			gDxObj.LastMouseMoveX=rx+gDxObj.LastMouseMoveX;
			gDxObj.LastMouseMoveY=ry+gDxObj.LastMouseMoveY;
		}
	}
	else
	{
		if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
		{
			if(IsWindow(gDxObj.m_hwnd))
			{
				::ClientToScreen(gDxObj.m_mousekeyhwnd,&pos);
				if(TSRuntime::SetSimModeType==0)//普通模式
					::SetCursorPos(pos.x,pos.y);
				gDxObj.LastMouseMoveX=pos.x;
				gDxObj.LastMouseMoveY=pos.y;
			}
			else
			{
				if(TSRuntime::SetSimModeType==0)//普通模式
					TSRuntime::g_Mouse.mouseMvrelative(rx,ry);
				gDxObj.LastMouseMoveX=rx+gDxObj.LastMouseMoveX;
				gDxObj.LastMouseMoveY=ry+gDxObj.LastMouseMoveY;
			}
		}
		else
		{
			if(gDxObj.m_mouseMode&MOUSE_WINDOW)
			{
				PostMessage(gDxObj.m_mousekeyhwnd,WM_MOUSEMOVE,0,MAKELPARAM(rx+gDxObj.LastMouseMoveX,ry+gDxObj.LastMouseMoveY));
			}
			else
			{
				*rnet=gDxObj.SendMsg(TS_MOUSER,0,MAKELPARAM(rx,ry));
			}
			gDxObj.LastMouseMoveX=rx+gDxObj.LastMouseMoveX;
			gDxObj.LastMouseMoveY=ry+gDxObj.LastMouseMoveY;
		}
	}

	//*rnet=gDxObj.SendMsg(TS_MOUSEMOVEOVER);
	//*rnet=TSRuntime::g_DxObj.SendMsg(TS_MOUSER,0,MAKELPARAM(rx,ry));
	//*rnet=TSRuntime::g_DxObj.SendMsg(TS_MOUSEMOVEOVER);
	*rnet=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::Ver(BSTR* retver)
{
	// TODO: 在此添加实现代码
	//_variant_t strVar(TS_VERSION);
	//*retver=strVar.bstrVal;
	CComBSTR newbstr;
	newbstr.Append(TS_VERSION);
	newbstr.CopyTo(retver);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetPath(BSTR* retpath)
{
	// TODO: 在此添加实现代码
	//_variant_t strVar(TSRuntime::SetPath);
	//strVar.bstrVal;
	//	TsMutexlock ts_mutexlock(&gDXbindMutex);
	CComBSTR newbstr;
	newbstr.Append(gDxObj.m_SetPath);
	newbstr.CopyTo(retpath);

	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::MiddleClick(LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXMiddleClickMutex);

	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		TSRuntime::g_Mouse.delaytimes=gDxObj.NormalClicksleep;
		//TSRuntime::g_Mouse.middleClick();
		if(TSRuntime::SetSimModeType==0)//普通模式
			TSRuntime::g_Mouse.middleClick();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
			PostMessage(gDxObj.m_mousekeyhwnd,WM_MBUTTONUP,1,0);
		* nret=gDxObj.SendMsg(TS_MBUTTONDOWN,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)	//window模式默认延时
		{
			if(gDxObj.IsTSEnableRealMouse)
				Sleep(gDxObj.TSRealKeyMousSleepTime(0));
			else
				Sleep(gDxObj.WindowsKeyMouseClicksleep);
		}
		else
		{
			if(gDxObj.IsTSEnableRealMouse)
				Sleep(gDxObj.TSRealKeyMousSleepTime(0));
			else
				Sleep(gDxObj.MouseClicksleep);  //dx模式默认延时
		}
		PostMessage(gDxObj.m_mousekeyhwnd,WM_MBUTTONUP,0,0);
		* nret=gDxObj.SendMsg(TS_MBUTTONUP);
	}

	*nret=1;
	return S_OK;

}

STDMETHODIMP CTSPlugInterFace::WheelDown(LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXWheelDownMutex);

	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		TSRuntime::g_Mouse.mouseSheetDown();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
			PostMessage(gDxObj.m_mousekeyhwnd,WM_MOUSEWHEEL,0xff880000,0);
		* nret=gDxObj.SendMsg(TS_MOUSEWHEEL,0xff880000,0);
	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::WheelUp(LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXWheelUpMutex);

	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		TSRuntime::g_Mouse.mouseSheetUp();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
			PostMessage(gDxObj.m_mousekeyhwnd,WM_MOUSEWHEEL,0x780000,0);
		* nret=gDxObj.SendMsg(TS_MOUSEWHEEL,0x780000,0);
	}
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::Capture(LONG x1, LONG y1, LONG x2, LONG y2, BSTR file, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXCaptureMutex);

	//VMPBEGIN    //VMP保护
	//if(!TSRuntime::IsVipLogin)
	// {
	// int bret=TSRuntime::VipLogin(L"",0,false);   //试用验证
	// if(bret<=0)
	//  {		
	//  INT64 t=0;
	//  if(my_myGetTickCount)
	//	  t=my_myGetTickCount();
	//  else
	//	  t=::GetTickCount();
	//  if(t==TSRuntime::checkthreadtime||abs((int)(t-TSRuntime::checkthreadtime))>=60*1000*10||TSRuntime::checkthreadtime==0)	//校验线程是否被挂起或者GetTickCount被人下钩子
	//	  {
	//	  gDxObj.SendMsg(TS_UNBIND);
	//	  Sleep(200);
	//	  gDxObj.UnBind();
	//	  Sleep(200);
	//	  gDxObj.SendMsg(TS_UNBIND);
	//	  Sleep(200);
	//	  gDxObj.UnBind();
	//	  if(TSRuntime::IsStartProtect)
	//		  TSRuntime::StartProtect(0,L"");
	//	  *nret=0;
	//	  TSRuntime::h_checkthread=NULL;
	//	  return S_OK;
	//	  }

	//  }
	// }
	// VMPEND

	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	* nret=gDxObj.Capture(x1,y1,x2,y2,file,D3DXIFF_BMP);
	//* nret=TSRuntime::g_DxObj.Capture(x1,y1,x2,y2,file,D3DXIFF_BMP);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::CaptureJpg(LONG x1, LONG y1, LONG x2, LONG y2,BSTR file, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXCaptureMutex);
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	* nret=gDxObj.Capture(x1,y1,x2,y2,file,D3DXIFF_JPG);
	//* nret=TSRuntime::g_DxObj.Capture(x1,y1,x2,y2,file,D3DXIFF_JPG);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::CapturePng(LONG x1, LONG y1, LONG x2, LONG y2, BSTR file, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXCaptureMutex);
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	* nret=gDxObj.Capture(x1,y1,x2,y2,file,D3DXIFF_PNG);
	//* nret=TSRuntime::g_DxObj.Capture(x1,y1,x2,y2,file,D3DXIFF_PNG);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::LockInput(LONG lock, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXLockInputMutex);
	//* nret=TSRuntime::g_DxObj.SendMsg(TS_LOCKINPUT,lock);
	* nret=gDxObj.SendMsg(TS_LOCKINPUT,lock);
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::Ocr(LONG x1, LONG y1, LONG x2, LONG y2, BSTR color_format, FLOAT sim, BSTR* retstr)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXOcrMutex);
	if(wcslen(color_format)==0)
		return S_OK;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	//TSRuntime::g_DxObj.Ocr(x1,y1,x2,y2,color_format,sim);
	gDxObj.Ocr(x1,y1,x2,y2,color_format,sim);
	//TSRuntime::add_log( "TSRuntime::pData->RetString:%s",TSRuntime::pData->RetString);

	CComBSTR newbstr;

	if(gDxObj.pData)
		//*retstr=_bstr_t();
		newbstr.Append(gDxObj.pData->RetString);
	else
		//*retstr=_bstr_t();
		newbstr.Append(gDxObj.m_Retstr);

	newbstr.CopyTo(retstr);

	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetDict(LONG index, BSTR file, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXSetDictMutex);
	//*nret=TSRuntime::g_DxObj.TSSetDict(index,file);
	*nret=gDxObj.TSSetDict(index,file);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::UseDict(LONG index, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXUseDictMutex);
	//*nret=TSRuntime::g_DxObj.TSUseDict(index);
	*nret=gDxObj.TSUseDict(index);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::ClearDict(LONG index, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXClearDictMutex);
	if(index>=0&&index<20&&index!=gDxObj.NowUsingDictIndex)
	{
		if(gDxObj.MyDictCount[index]!=NULL)
		{
			gDxObj.nMyDictCountsize[index]=0;
			gDxObj.nMaxStrHight[index]=0;
			delete [] gDxObj.MyDictCount[index];
			gDxObj.MyDictCount[index]=NULL;
			*nret=1;
		}
	}
	*nret=0;

	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindStr(LONG x1, LONG y1, LONG x2, LONG y2, BSTR string, BSTR color_format, FLOAT sim, VARIANT* intX, VARIANT* intY, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindStrMutex);
	LONG x=-1,y=-1,ret=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	ret=gDxObj.Findstr(x1,y1,x2,y2,string,color_format,sim,x,y,0);
	intX->vt=VT_I4;
	intY->vt=VT_I4;
	intX->lVal=x;
	intY->lVal=y;
	if(x==-1||y==-1)
		ret=-1;
	*nret=ret;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindStrFast(LONG x1, LONG y1, LONG x2, LONG y2, BSTR string, BSTR color_format, FLOAT sim, VARIANT* intX, VARIANT* intY, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindStrMutex);
	//TSRuntime::add_log("FindStrFast-start:操作窗口句柄:%d",gDxObj.m_hwnd);
	LONG x=-1,y=-1,ret=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	ret=gDxObj.Findstr(x1,y1,x2,y2,string,color_format,sim,x,y,1);
	intX->vt=VT_I4;
	intY->vt=VT_I4;
	intX->lVal=x;
	intY->lVal=y;
	if(x==-1||y==-1)
		ret=-1;
	*nret=ret;
	//TSRuntime::add_log("FindStrFast-end:操作窗口句柄:%d",gDxObj.m_hwnd);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetNowDict(LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXGetNowDictMutex);
	*nret=gDxObj.NowUsingDictIndex;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetBasePath(BSTR* retpath)
{
	//TsMutexlock ts_mutexlock(&gDXbindMutex);
	// TODO: 在此添加实现代码
	//*retpath=_bstr_t(gDLLFolder);
	CComBSTR newbstr;
	newbstr.Append(gDLLFolder);
	newbstr.CopyTo(retpath);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::IsDisplayDead(LONG x1, LONG y1, LONG x2, LONG y2, LONG t, LONG* bret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindPicMutex);
	LONG x=-1,y=-1,ret=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	ret=gDxObj.IsDisplayDead(x1,y1,x2,y2,t);
	*bret=ret;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindPicEx(LONG x1, LONG y1, LONG x2, LONG y2, BSTR pic_name, BSTR delta_color, DOUBLE sim, LONG dir, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindPicMutex);

	LONG x=-1,y=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	wchar_t retstr[MAX_PATH*100]={0};
	gDxObj.findPic(x1,y1,x2,y2,pic_name,delta_color,sim,dir,x,y,retstr);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindStrEx(LONG x1, LONG y1, LONG x2, LONG y2, BSTR string, BSTR color_format, DOUBLE sim, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindStrMutex);
	LONG x=-1,y=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	wchar_t retstr[MAX_PATH*100]={0};
	gDxObj.Findstr(x1,y1,x2,y2,string,color_format,sim,x,y,0,retstr);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindStrFastEx(LONG x1, LONG y1, LONG x2, LONG y2, BSTR string, BSTR color_format, DOUBLE sim, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindStrMutex);
	LONG x=-1,y=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	wchar_t retstr[MAX_PATH*100]={0};
	gDxObj.Findstr(x1,y1,x2,y2,string,color_format,sim,x,y,1,retstr);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::CaptureGif(LONG x1, LONG y1, LONG x2, LONG y2, BSTR file, LONG delay, LONG time, LONG* nret)
{
	TsMutexlock ts_mutexlock(&gDXCaptureGifMutex);
	// TODO: 在此添加实现代码
	*nret=gDxObj.CaptureGif(x1,y1,x2,y2,file,delay,time);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::DownCpu(LONG rate, LONG* nret)
{
	// TODO: 在此添加实现代码
	*nret=gDxObj.DownCpu(rate);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetKeypadDelay(BSTR type, LONG delay, LONG* nret)
{
	// TODO: 在此添加实现代码
	if((gDxObj.m_keyMode&KEY_NORMAL)==KEY_NORMAL)
		gDxObj.NormalKeysleep=delay;
	else if(gDxObj.m_keyMode&KEY_WINDOW)	//window模式默认延时)
		gDxObj.WindowsKeyMouseClicksleep=delay;
	else
		gDxObj.KeyDownsleep=delay;
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetMouseDelay(BSTR type, LONG delay, LONG* nret)
{
	// TODO: 在此添加实现代码
	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
		gDxObj.NormalClicksleep=delay;
	else if(gDxObj.m_mouseMode&MOUSE_WINDOW)	//window模式默认延时
		gDxObj.WindowsKeyMouseClicksleep=delay;
	else
		gDxObj.MouseClicksleep=delay;
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::CmpColor(LONG x, LONG y, BSTR color, DOUBLE sim, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutex gDXGetColorMutex(TS_GETCOLOREVEN);
	*nret=gDxObj.CmpColor(x,y,color,sim);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SendStringIme(BSTR str, LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXSendStringImeMutex);

	if(wcslen(str)>1024)
	{
		*nret=0;
		return S_OK;
	}
	memset(gDxObj.pData->pmsg,0,2048);
	USES_CONVERSION;
	strcpy(gDxObj.pData->pmsg,W2A(str));
	gDxObj.SendMsg(TS_SENDSTRINGIME);
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindColorEx(LONG x1, LONG y1, LONG x2, LONG y2, BSTR color, DOUBLE sim, LONG dir, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindColorMutex);
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	DWORD ncolor=0x100;
	LONG x=-1,y=-1;
	wchar_t retstr[MAX_PATH*4]={0};
	gDxObj.findColor(x1,y1,x2,y2,ncolor,sim,dir,x,y,color,retstr);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::EnumWindow(LONG parent, BSTR title, BSTR class_name, LONG filter, BSTR* retstr)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXEnumWindowMutex);
	wchar_t retstring[MAX_PATH*200]={0};
	gWindowObj.TSEnumWindow((HWND)parent,title,class_name,filter,retstring);
	//*retstr=_bstr_t(retstring);
	CComBSTR newbstr;
	newbstr.Append(retstring);
	newbstr.CopyTo(retstr);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::EnumWindowByProcess(BSTR process_name, BSTR title, BSTR class_name, LONG filter, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXEnumWindowByProcessMutex);
	wchar_t retstr[MAX_PATH*200]={0};
	gWindowObj.TSEnumWindow((HWND)0,title,class_name,filter,retstr,process_name);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::EnumProcess(BSTR name, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXEnumProcessMutex);
	wchar_t retstr[MAX_PATH*100]={0};
	gWindowObj.TSEnumProcess(name,retstr);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::ClientToScreen(LONG ClientToScreen, VARIANT* x, VARIANT* y, LONG* bret)
{
	// TODO: 在此添加实现代码
	x->vt=VT_I4;
	y->vt=VT_I4;
	*bret=gWindowObj.TSClientToScreen(ClientToScreen,x->lVal,y->lVal);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindWindow(BSTR class_name,BSTR title,LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	gWindowObj.TSFindWindow(class_name,title,*rethwnd);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindWindowByProcess(BSTR process_name, BSTR class_name, BSTR title, LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	gWindowObj.TSFindWindowByProcess(class_name,title,*rethwnd,process_name);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindWindowByProcessId(LONG process_id, BSTR class_name, BSTR title, LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	gWindowObj.TSFindWindowByProcess(class_name,title,*rethwnd,NULL,process_id);
	return S_OK;
}
STDMETHODIMP CTSPlugInterFace::FindWindowEx(LONG parent,BSTR class_name,BSTR title,LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	gWindowObj.TSFindWindow(class_name,title,*rethwnd,parent);
	return S_OK;
}
STDMETHODIMP CTSPlugInterFace::GetClientRect(LONG hwnd, VARIANT* x1, VARIANT* y1, VARIANT* x2, VARIANT* y2, LONG* nret)
{
	// TODO: 在此添加实现代码
	x1->vt=VT_I4;
	y1->vt=VT_I4;
	x2->vt=VT_I4;
	y2->vt=VT_I4;
	* nret=gWindowObj.TSGetClientRect(hwnd,x1->lVal,y1->lVal,x2->lVal,y2->lVal);
	return S_OK;
}


STDMETHODIMP CTSPlugInterFace::GetClientSize(LONG hwnd, VARIANT* width, VARIANT* height, LONG* nret)
{
	// TODO: 在此添加实现代码
	width->vt=VT_I4;
	height->vt=VT_I4;
	* nret=gWindowObj.TSGetClientSize(hwnd,width->lVal,height->lVal);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetForegroundFocus(LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	* rethwnd=(LONG)::GetFocus();
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetForegroundWindow(LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	* rethwnd=(LONG)::GetForegroundWindow();
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetMousePointWindow(LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	//::Sleep(2000);
	gWindowObj.TSGetMousePointWindow(* rethwnd);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetPointWindow(LONG x, LONG y, LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	gWindowObj.TSGetMousePointWindow(* rethwnd,x,y);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetProcessInfo(LONG pid, BSTR* retstring)
{
	// TODO: 在此添加实现代码

	wchar_t retstr[MAX_PATH]={0};
	gWindowObj.TSGetProcessInfo(pid,retstr);
	//* retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetSpecialWindow(LONG flag, LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	*rethwnd=0;
	if(flag==0)
		*rethwnd =(LONG)GetDesktopWindow();
	else if(flag==1)
	{
		*rethwnd=(LONG)::FindWindow(L"Shell_TrayWnd",NULL);
	}

	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetWindow(LONG hwnd, LONG flag, LONG* nret)
{
	// TODO: 在此添加实现代码
	gWindowObj.TSGetWindow(hwnd,flag,* nret);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetWindowClass(LONG hwnd, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t classname[MAX_PATH]={0};
	::GetClassName((HWND)hwnd,classname,MAX_PATH);
	//* retstring=_bstr_t(classname);
	CComBSTR newbstr;
	newbstr.Append(classname);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetWindowProcessId(LONG hwnd, LONG* nretpid)
{
	// TODO: 在此添加实现代码
	DWORD pid=0;
	::GetWindowThreadProcessId((HWND)hwnd,&pid);
	*nretpid=pid;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetWindowProcessPath(LONG hwnd, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	DWORD pid=0;
	::GetWindowThreadProcessId((HWND)hwnd,&pid);
	wchar_t process_path[MAX_PATH]={0};
	gWindowObj.GetProcesspath(pid,process_path);
	//* retstring=_bstr_t(process_path);
	CComBSTR newbstr;
	newbstr.Append(process_path);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetWindowRect(LONG hwnd, VARIANT* x1, VARIANT* y1, VARIANT* x2, VARIANT* y2, LONG* nret)
{
	// TODO: 在此添加实现代码
	x1->vt=VT_I4;
	x2->vt=VT_I4;
	y1->vt=VT_I4;
	y2->vt=VT_I4;
	RECT winrect;
	* nret=::GetWindowRect((HWND)hwnd,&winrect);
	x1->intVal=winrect.left;
	y1->intVal=winrect.top;
	x2->intVal=winrect.right;
	y2->intVal=winrect.bottom;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetWindowState(LONG hwnd, LONG flag, LONG* rethwnd)
{
	// TODO: 在此添加实现代码
	* rethwnd=gWindowObj.TSGetWindowState(hwnd,flag);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetWindowTitle(LONG hwnd, BSTR* rettitle)
{
	// TODO: 在此添加实现代码
	wchar_t title[MAX_PATH]={0};
	::GetWindowText((HWND)hwnd,title,MAX_PATH);
	//* rettitle=_bstr_t(title);
	CComBSTR newbstr;
	newbstr.Append(title);
	newbstr.CopyTo(rettitle);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::MoveWindow(LONG hwnd, LONG x, LONG y, LONG* nret)
{
	// TODO: 在此添加实现代码
	RECT winrect;
	::GetWindowRect((HWND)hwnd,&winrect);
	int width=winrect.right-winrect.left;
	int hight=winrect.bottom-winrect.top;
	*nret=::MoveWindow((HWND)hwnd,x,y,width,hight,false);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::ScreenToClient(LONG hwnd, VARIANT* x, VARIANT* y,LONG* nret)
{
	// TODO: 在此添加实现代码
	x->vt=VT_I4;
	y->vt=VT_I4;
	POINT point;
	* nret=::ScreenToClient((HWND)hwnd,&point);
	x->intVal=point.x;
	y->intVal=point.y;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SendPaste(LONG hwnd, LONG* nret)
{
	// TODO: 在此添加实现代码
	* nret=gWindowObj.TSSendPaste(hwnd);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetClientSize(LONG hwnd, LONG width, LONG hight, LONG* nret)
{
	// TODO: 在此添加实现代码
	*nret=gWindowObj.TSSetWindowSize(hwnd,width,hight);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetWindowState(LONG hwnd, LONG flag, LONG* nret)
{
	// TODO: 在此添加实现代码  
	*nret=gWindowObj.TSSetWindowState(hwnd,flag);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetWindowSize(LONG hwnd, LONG width, LONG height, LONG* nret)
{
	// TODO: 在此添加实现代码
	*nret=gWindowObj.TSSetWindowSize(hwnd,width,height,1);
	return S_OK;
}
STDMETHODIMP CTSPlugInterFace::SetWindowText(LONG hwnd,BSTR title, LONG* nret)
{
	// TODO: 在此添加实现代码  
	//*nret=gWindowObj.TSSetWindowState(hwnd,flag);
	* nret=::SetWindowText((HWND)hwnd,title);
	return S_OK;
}
STDMETHODIMP CTSPlugInterFace::SetWindowTransparent(LONG hwnd, LONG trans, LONG* nret)
{
	// TODO: 在此添加实现代码
	* nret=gWindowObj.TSSetWindowTransparent(hwnd,trans);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetClipboard(BSTR value, LONG* nret)
{
	// TODO: 在此添加实现代码
	* nret=gWindowObj.TSSetClipboard(value);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetClipboard(BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t retstr[MAX_PATH*4]={0};
	gWindowObj.TSGetClipboard(retstr);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::DoubleToData(DOUBLE value, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t retstr[MAX_PATH]={0};
	gMemoryObj.TSValueTypeToData(0,retstr,value);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FloatToData(FLOAT value, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t retstr[MAX_PATH]={0};
	gMemoryObj.TSValueTypeToData(1,retstr,NULL,value);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::IntToData(LONG value, LONG type, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t retstr[MAX_PATH]={0};
	gMemoryObj.TSValueTypeToData(2,retstr,NULL,NULL,value,NULL,type);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::StringToData(BSTR value, LONG type, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t retstr[MAX_PATH]={0};
	gMemoryObj.TSValueTypeToData(3,retstr,NULL,NULL,NULL,value,type);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindData(LONG hwnd, BSTR addr_range, BSTR data, BSTR* retstring)
{
	TsMutexlock ts_mutexlock(&gDXFindDataMutex);
	// TODO: 在此添加实现代码
	//wchar_t retstr[MAX_PATH*200]={0};
	//gMemoryObj.TSFindData(hwnd,addr_range,data,retstr);
	//*retstring=_bstr_t(retstr);
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindData(hwnd,addr_range,data,retstr);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindDouble(LONG hwnd, BSTR addr_range, DOUBLE double_value_min, DOUBLE double_value_max, BSTR* retstring)
{
	TsMutexlock ts_mutexlock(&gDXFindDoubleMutex);
	// TODO: 在此添加实现代码
	//wchar_t retstr[MAX_PATH*200]={0};
	//gMemoryObj.TSFindDouble(hwnd,addr_range,retstr,double_value_min,double_value_max);
	//*retstring=_bstr_t(retstr);
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindDouble(hwnd,addr_range,retstr,double_value_min,double_value_max);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindFloat(LONG hwnd, BSTR addr_range, FLOAT float_value_min, FLOAT float_value_max, BSTR* retstring)
{
	TsMutexlock ts_mutexlock(&gDXFindFloatMutex);
	// TODO: 在此添加实现代码
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindFloat(hwnd,addr_range,retstr,float_value_min,float_value_max);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindInt(LONG hwnd, BSTR addr_range, LONG int_value_min, LONG int_value_max, LONG type, BSTR* retstring)
{
	TsMutexlock ts_mutexlock(&gDXFindIntMutex);
	// TODO: 在此添加实现代码
	//wchar_t retstr[MAX_PATH*200]={0};
	//gMemoryObj.TSFindInt(hwnd,addr_range,retstr,int_value_min,int_value_max,type);
	//*retstring=_bstr_t(retstr);
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindInt(hwnd,addr_range,retstr,int_value_min,int_value_max,type);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);

	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindString(LONG hwnd, BSTR addr_range, BSTR string_value, LONG type, BSTR* retstring)
{
	TsMutexlock ts_mutexlock(&gDXFindStringMutex);
	// TODO: 在此添加实现代码
	//wchar_t retstr[MAX_PATH*200]={0};
	//gMemoryObj.TSFindString(hwnd,addr_range,retstr,string_value,type);
	//*retstring=_bstr_t(retstr);
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindString(hwnd,addr_range,retstr,string_value,type);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::ReadData(LONG hwnd, BSTR addr, LONG len, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t retstr[MAX_PATH]={0};
	gMemoryObj.TSReadData(hwnd,addr,retstr,len);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::OcrEx(LONG x1, LONG y1, LONG x2, LONG y2, BSTR color_format, DOUBLE sim, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXOcrMutex);
	if(wcslen(color_format)==0)
		return S_OK;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	//TSRuntime::g_DxObj.Ocr(x1,y1,x2,y2,color_format,sim);
	gDxObj.Ocr(x1,y1,x2,y2,color_format,sim,1);
	//TSRuntime::add_log( "TSRuntime::pData->RetString:%s",TSRuntime::pData->RetString);
	CComBSTR newbstr;

	if(gDxObj.pData)
		//*retstring=_bstr_t(gDxObj.pData->RetString);
		newbstr.Append(gDxObj.pData->RetString);
	else
		//*retstring=_bstr_t(TSRuntime::RetStr);
		newbstr.Append(gDxObj.m_Retstr);

	newbstr.CopyTo(retstring);

	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::ReadDouble(LONG hwnd, BSTR addr, DOUBLE* retdouble)
{
	// TODO: 在此添加实现代码
	float fvalue=0;
	gMemoryObj.TSReadDouble(hwnd,addr,* retdouble,fvalue);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::ReadFloat(LONG hwnd, BSTR addr, FLOAT* retfloat)
{
	// TODO: 在此添加实现代码
	DOUBLE dvalue=0;
	gMemoryObj.TSReadDouble(hwnd,addr,dvalue,* retfloat,1);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::ReadInt(LONG hwnd, BSTR addr, LONG type, LONG* retint)
{
	// TODO: 在此添加实现代码
	int ivalue=0;
	short svalue=0;
	BYTE bvalue=0;
	gMemoryObj.TSReadInt(hwnd,addr,ivalue,svalue,bvalue,type);
	if(type==0)
		*retint=ivalue;
	else if(type==1)
		*retint=svalue;
	else if(type==2)
		*retint=bvalue;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::ReadString(LONG hwnd, BSTR addr, LONG type, LONG len, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t retstr[MAX_PATH]={0};
	gMemoryObj.TSReadString(hwnd,addr,retstr,len,type);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::TerminateProcess(LONG pid, LONG* bret)
{
	// TODO: 在此添加实现代码
	* bret=gMemoryObj.TSTerminateProcess(pid);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::VirtualAllocEx(LONG hwnd, LONG addr, LONG size, LONG type, LONG* bret)
{
	// TODO: 在此添加实现代码
	LONG retaddr=addr;
	gMemoryObj.TSVirtualAllocEx(hwnd,retaddr,size,type);
	* bret=retaddr;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::VirtualFreeEx(LONG hwnd, LONG addr, LONG* bret)
{
	// TODO: 在此添加实现代码
	* bret=gMemoryObj.TSVirtualFreeEx(hwnd,addr);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::WriteDouble(LONG hwnd, BSTR addr, DOUBLE v, LONG* bret)
{
	// TODO: 在此添加实现代码
	* bret=gMemoryObj.TSWriteDouble(hwnd,addr,v);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::WriteFloat(LONG hwnd, BSTR addr, FLOAT v, LONG* bret)
{
	// TODO: 在此添加实现代码
	* bret=gMemoryObj.TSWriteDouble(hwnd,addr,0,v);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::WriteInt(LONG hwnd, BSTR addr, LONG type, LONG v, LONG* bret)
{
	// TODO: 在此添加实现代码
	int ivalue=0;
	short svalue=0;
	BYTE bvalue=0;
	if(type==0)	//0 : 32位
		ivalue=v;
	else if(type==1)//1 : 16 位
		svalue=v;
	else if(type==2) //2 : 8位
		bvalue=v;
	* bret=gMemoryObj.TSWriteInt(hwnd,addr,ivalue,svalue,bvalue);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::WriteString(LONG hwnd, BSTR addr, LONG type, BSTR v, LONG* bret)
{
	// TODO: 在此添加实现代码
	* bret=gMemoryObj.TSWriteString(hwnd,addr,v,type);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::WriteData(LONG hwnd, BSTR addr, BSTR data, LONG* nret)
{
	// TODO: 在此添加实现代码
	* nret=gMemoryObj.TSWriteData(hwnd,addr,data);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::IsBind(LONG hwnd, LONG* nret)
{
	// TODO: 在此添加实现代码

	if(::IsWindow((HWND)hwnd)==false)
	{
		* nret=0;
		return S_OK;
	}
	if(gDxObj.m_isBind==true)
	{
		* nret=1;
		return S_OK;
	}

	//DWORD nPid=0;
	//::GetWindowThreadProcessId((HWND)hwnd,&nPid);

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

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

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

	char pszBinWindow_GDIWINDOW[MAX_PATH]={0};
	sprintf( pszBinWindow_GDIWINDOW,"%s%d",TS_BINDWINDOW_GDIWINDOW,gDxObj.nPid);
	HANDLE hbindGdiWindow=GetPropA((HWND)hwnd,pszBinWindow_GDIWINDOW);
	if(hbindGdiWindow==NULL)
	{
		//遍历获取父窗口句柄
		HWND parenthwnd=0;
		HWND hparent=0;
		do{
			if(parenthwnd==0)
				parenthwnd=GetParent((HWND)hwnd);
			else
			{
				hparent=GetParent(parenthwnd);
				if(hparent!=0&&hparent!=parenthwnd)
				{
					hwnd=(LONG)hparent;
				}
				parenthwnd=hparent;
			}

		}while(parenthwnd!=NULL);
		//::GetWindowThreadProcessId((HWND)hwnd,&nPid);
		char pszBinWindow_GDIWINDOW[MAX_PATH]={0};
		sprintf( pszBinWindow_GDIWINDOW,"%s%d",TS_BINDWINDOW_GDIWINDOW,gDxObj.nPid);
		hbindGdiWindow=GetPropA((HWND)hwnd,pszBinWindow_GDIWINDOW);
	}

	if(hbindprop==NULL&&hbindIMEprop==NULL&&hbindIMEprop101==NULL&&hbindGdiWindow==NULL)
		* nret=0;
	else
		* nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindFloatEx(LONG hwnd, BSTR addr_range, FLOAT float_value_min, FLOAT float_value_max, LONG step, LONG multi_thread, LONG mode, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindFloatMutex);
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindFloat(hwnd,addr_range,retstr,float_value_min,float_value_max,multi_thread);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindDoubleEx(LONG hwnd, BSTR addr_range, DOUBLE double_value_min, DOUBLE double_value_max, LONG step, LONG multi_thread, LONG mode, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindDoubleMutex);
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindDouble(hwnd,addr_range,retstr,double_value_min,double_value_max,multi_thread);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindIntEx(LONG hwnd, BSTR addr_range, LONG int_value_min, LONG int_value_max, LONG type, LONG step, LONG multi_thread, LONG mode, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindIntMutex);
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindInt(hwnd,addr_range,retstr,int_value_min,int_value_max,type,multi_thread);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindDataEx(LONG hwnd, BSTR addr_range, BSTR data, LONG step, LONG multi_thread, LONG mode, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindDataMutex);
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindData(hwnd,addr_range,data,retstr,multi_thread);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindStringEx(LONG hwnd, BSTR addr_range, BSTR string_value, LONG type, LONG step, LONG multi_thread, LONG mode, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindStringMutex);
	wchar_t retstr[MAX_PATH*1024]={0};
	CComBSTR newbstr;
	gMemoryObj.TSFindString(hwnd,addr_range,retstr,string_value,type,multi_thread);
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetModuleBaseAddr(LONG hwnd, BSTR modulename, LONG* nret)
{
	// TODO: 在此添加实现代码
	DWORD pid=0;
	::GetWindowThreadProcessId((HWND)hwnd,&pid);
	* nret=TSRuntime::GetRemoteModuleBaseAddr(modulename,pid);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetCommandLine(LONG hwnd, BSTR* retstring)
{
	// TODO: 在此添加实现代码;		   
	wchar_t argv[MAX_PATH]={0};
	gMemoryObj.TSGetCmdLine(hwnd,argv);
	//*retstring=_bstr_t(argv);
	CComBSTR newbstr;
	newbstr.Append(argv);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::AsmAdd(BSTR asm_ins, LONG* nret)
{
	// TODO: 在此添加实现代码
	* nret=gMemoryObj.TSAsmAdd(asm_ins);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::AsmCall(LONG hwnd, LONG mode, LONG* nret)
{
	// TODO: 在此添加实现代码
	* nret=gMemoryObj.TSAsmCall(hwnd,mode);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::AsmClear(LONG* nret)
{
	// TODO: 在此添加实现代码

	gMemoryObj.TSAsmClear();
	* nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::AsmCode(LONG base_addr, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t  retstr[MAX_PATH*10]={0};
	//std::string	  retstr;
	gMemoryObj.TSAsmCode(base_addr,retstr);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::Assemble(BSTR asm_code, LONG base_addr, LONG is_upper, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t  retstr[MAX_PATH*10]={0};
	gMemoryObj.TSAssemble(asm_code,base_addr,is_upper,retstr);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::MatchPicName(BSTR pic_name, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t  retstr[MAX_PATH*10]={0};
	gDxObj.TSMatchPicName(pic_name,retstr);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetShowErrorMsg(LONG show, LONG* nret)
{
	// TODO: 在此添加实现代码
	TSRuntime::IsShowErrorMsg=show;
	* nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::Reg(BSTR reg_code, LONG type, LONG* nret)
{
	// TODO: 在此添加实现代码
	VMPBEGIN
		//::GetModuleHandle(L"TSPlug.dll");
		int ret=TSRuntime::VipLogin(reg_code,type);
	if(ret>0&&type==0)//特权验证
	{
		TSRuntime::IsVipLogin=true;
		ret=1;
	}
	else if(ret>0&&type==1)//注册验证
	{
		TSRuntime::IsRegLogin=true;
		ret=1;
	}
	* nret=ret;

	VMPEND
		return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetMachineCode(BSTR* retstring)
{
	// TODO: 在此添加实现代码
	wchar_t machinecode[MAX_PATH]={0};
	gDxObj.TSGetMachineCode(machinecode);
	//* retstring=_bstr_t(machinecode);
	CComBSTR newbstr;
	newbstr.Append(machinecode);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::TSGuardProtectToHide(LONG enble, LONG* nret)
{
	// TODO: 在此添加实现代码
	VMPBEGIN    //VMP保护
		if(!TSRuntime::IsVipLogin)
		{
			if(TSRuntime::IsRegLogin==false&&TSRuntime::IsVipLogin==false)//TS盾不允许试用
			{
				*nret=0;
				return S_OK;
			}
			INT64 t=0;
			if(my_myGetTickCount)
				t=my_myGetTickCount();
			else
				t=::GetTickCount();
			if(t==TSRuntime::checkthreadtime||abs((int)(t-TSRuntime::checkthreadtime))>=60*1000*10||TSRuntime::checkthreadtime==0)	//校验线程是否被挂起或者GetTickCount被人下钩子
			{
				if(TSRuntime::IsStartProtect)
					TSRuntime::StartProtect(0,0,-1);
				*nret=0;
				TSRuntime::h_checkthread=NULL;
				return S_OK;
			}
		}
		*nret=TSRuntime::StartProtect(enble,1);
		//TSRuntime::add_log( "TSRuntime::IsVipLogin:%d,*nret:%d",TSRuntime::IsVipLogin,*nret);
		VMPEND
			return S_OK;
}

STDMETHODIMP CTSPlugInterFace::TSGuardProtectToHide2(LONG enable, LONG* nret)
{
	// TODO: 在此添加实现代码
	VMPBEGIN    //VMP保护
		if(!TSRuntime::IsVipLogin)
		{
			if(TSRuntime::IsRegLogin==false&&TSRuntime::IsVipLogin==false)//TS盾不允许试用
			{
				*nret=0;
				return S_OK;
			}
			INT64 t=0;
			if(my_myGetTickCount)
				t=my_myGetTickCount();
			else
				t=::GetTickCount();
			if(t==TSRuntime::checkthreadtime||abs((int)(t-TSRuntime::checkthreadtime))>=60*1000*10||TSRuntime::checkthreadtime==0)	//校验线程是否被挂起或者GetTickCount被人下钩子
			{
				if(TSRuntime::IsStartProtect)
					TSRuntime::StartProtect(0,0,-1);
				*nret=0;
				TSRuntime::h_checkthread=NULL;
				return S_OK;
			}
		}
		*nret=TSRuntime::StartProtect(enable,2);
		//TSRuntime::add_log( "TSRuntime::IsVipLogin:%d,*nret:%d",TSRuntime::IsVipLogin,*nret);
		VMPEND
			return S_OK;
}

STDMETHODIMP CTSPlugInterFace::TSGuardProtectToNP(LONG enable, LONG* nret)
{
	// TODO: 在此添加实现代码
	VMPBEGIN    //VMP保护
		if(!TSRuntime::IsVipLogin)
		{
			if(TSRuntime::IsRegLogin==false&&TSRuntime::IsVipLogin==false)//TS盾不允许试用
			{
				*nret=0;
				return S_OK;
			}
			INT64 t=0;
			if(my_myGetTickCount)
				t=my_myGetTickCount();
			else
				t=::GetTickCount();
			if(t==TSRuntime::checkthreadtime||abs((int)(t-TSRuntime::checkthreadtime))>=60*1000*10||TSRuntime::checkthreadtime==0)	//校验线程是否被挂起或者GetTickCount被人下钩子
			{
				if(TSRuntime::IsStartProtect)
					TSRuntime::StartProtect(0,0,-1);
				*nret=0;
				TSRuntime::h_checkthread=NULL;
				return S_OK;
			}
		}
		TSRuntime::InitialWindowsVersion();
		if(TSRuntime::IsWin7X64==false)
			TSRuntime::StartProtect(enable,0);
		if(TSRuntime::IsStartProtect==true||TSRuntime::IsWin7X64==true)
		{
			TSRuntime::IsNpProtect=true;
			*nret=true;
		}
		//TSRuntime::add_log( "TSRuntime::IsVipLogin:%d,*nret:%d",TSRuntime::IsVipLogin,*nret);
		VMPEND
			return S_OK;
}

STDMETHODIMP CTSPlugInterFace::Delay(LONG mis, LONG* nret)
{
	// TODO: 在此添加实现代码
	//TsMutexlock ts_mutexlock(&gDXMySleepMutex);
	gDxObj.mysleep(mis);
	*nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindStrS(LONG x1, LONG y1, LONG x2, LONG y2, BSTR string, BSTR color_format, DOUBLE sim, VARIANT* intX, VARIANT* intY, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindStrMutex);
	LONG x=-1,y=-1,ret=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	wchar_t retstr[MAX_PATH*100]={0};
	ret=gDxObj.Findstr(x1,y1,x2,y2,string,color_format,sim,x,y,0,retstr,2);
	intX->vt=VT_I4;
	intY->vt=VT_I4;
	intX->lVal=x;
	intY->lVal=y;
	if(x==-1||y==-1)
		ret=-1;
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}
STDMETHODIMP CTSPlugInterFace::FindStrFastS(LONG x1, LONG y1, LONG x2, LONG y2, BSTR string, BSTR color_format, DOUBLE sim, VARIANT* intX, VARIANT* intY, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindStrMutex);
	LONG x=-1,y=-1,ret=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	wchar_t retstr[MAX_PATH*100]={0};
	ret=gDxObj.Findstr(x1,y1,x2,y2,string,color_format,sim,x,y,1,retstr,2);
	intX->vt=VT_I4;
	intY->vt=VT_I4;
	intX->lVal=x;
	intY->lVal=y;
	if(x==-1||y==-1)
		ret=-1;
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindStrExS(LONG x1, LONG y1, LONG x2, LONG y2, BSTR string, BSTR color_format, DOUBLE sim, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindStrMutex);
	LONG x=-1,y=-1,ret=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	wchar_t retstr[MAX_PATH*100]={0};
	ret=gDxObj.Findstr(x1,y1,x2,y2,string,color_format,sim,x,y,0,retstr,1);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindStrFastExS(LONG x1, LONG y1, LONG x2, LONG y2, BSTR string, BSTR color_format, DOUBLE sim, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindStrMutex);
	LONG x=-1,y=-1,ret=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	wchar_t retstr[MAX_PATH*100]={0};
	ret=gDxObj.Findstr(x1,y1,x2,y2,string,color_format,sim,x,y,1,retstr,1);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindPicS(LONG x1, LONG y1, LONG x2, LONG y2, BSTR pic_name, BSTR delta_color, DOUBLE sim, LONG dir, VARIANT* intX, VARIANT* intY, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindPicMutex);
	LONG x=-1,y=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	wchar_t retstr[MAX_PATH*100]={0};
	gDxObj.findPic(x1,y1,x2,y2,pic_name,delta_color,sim,dir,x,y,retstr,2);
	intX->vt=VT_I4;
	intY->vt=VT_I4;
	intX->lVal=x;
	intY->lVal=y;
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindPicExS(LONG x1, LONG y1, LONG x2, LONG y2, BSTR pic_name, BSTR delta_color, DOUBLE sim, LONG dir, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindPicMutex);
	LONG x=-1,y=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	wchar_t retstr[MAX_PATH*100]={0};
	gDxObj.findPic(x1,y1,x2,y2,pic_name,delta_color,sim,dir,x,y,retstr,1);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetDictPwd(BSTR pwd, LONG* nret)
{
	// TODO: 在此添加实现代码
	int len=wcslen(pwd);
	if(len>0&&len<MAX_PATH)
	{
		wcscpy(TSRuntime::SetDictPwdString,pwd);
		* nret=1;
	}
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetPicPwd(BSTR pwd, LONG* nret)
{
	// TODO: 在此添加实现代码
	int len=wcslen(pwd);
	if(len>0&&len<MAX_PATH)
	{
		wcscpy(TSRuntime::SetPicPwdString,pwd);
		if(gDxObj.pData)
		{
			wcscpy(gDxObj.pData->SetPicPwdString,pwd);
			gDxObj.SendMsg(TS_SETPICPWD);
		}

		* nret=1;
	}
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::LeftDoubleClick(LONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXLeftDownMutex);
	if((gDxObj.m_mouseMode&MOUSE_NORMAL)==MOUSE_NORMAL)
	{
		TSRuntime::g_Mouse.delaytimes=gDxObj.NormalClicksleep;
		//TSRuntime::g_Mouse.leftDoubleClick();
		if(TSRuntime::SetSimModeType==0)//普通模式
			TSRuntime::g_Mouse.leftDoubleClick();
	}
	else
	{
		if(gDxObj.m_mouseMode&MOUSE_WINDOW)
		{
			SendMessage(gDxObj.m_mousekeyhwnd,WM_SETFOCUS,(WPARAM)gDxObj.m_mousekeyhwnd,0);
			SendMessage(gDxObj.m_mousekeyhwnd,WM_CAPTURECHANGED,(WPARAM)gDxObj.m_mousekeyhwnd,0);
			PostMessage(gDxObj.m_mousekeyhwnd,WM_LBUTTONDBLCLK,1,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
		}
		else
			*nret=gDxObj.SendMsg(TS_LBUTTONDOWN,WM_LBUTTONDBLCLK,MAKELPARAM(gDxObj.LastMouseMoveX,gDxObj.LastMouseMoveY));
	}
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FreeProcessMemory(LONG hwnd, LONG* nret)
{
	// TODO: 在此添加实现代码
	* nret=gMemoryObj.TSFreeProcessMemory(hwnd);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::TSDXGraphicProtect(LONG enable, LONG* nret)
{
	// TODO: 在此添加实现代码
	VMPBEGIN    //VMP保护
		if(!TSRuntime::IsVipLogin)
		{
			if(TSRuntime::IsRegLogin==false&&TSRuntime::IsVipLogin==false)//TS盾不允许试用
			{
				*nret=0;
				return S_OK;
			}
			INT64 t=0;
			if(my_myGetTickCount)
				t=my_myGetTickCount();
			else
				t=::GetTickCount();
			if(t==TSRuntime::checkthreadtime||abs((int)(t-TSRuntime::checkthreadtime))>=60*1000*10||TSRuntime::checkthreadtime==0)	//校验线程是否被挂起或者GetTickCount被人下钩子
			{
				if(TSRuntime::IsStartProtect)
					TSRuntime::StartProtect(0,0,-1);
				*nret=0;
				TSRuntime::h_checkthread=NULL;
				return S_OK;
			}
		}
		gDxObj.Isgraphicprotect=enable;
		if(gDxObj.pData)
		{
			if(enable==1)
			{
				gDxObj.pData->isgraphicprotect=true;
				gDxObj.Isgraphicprotect=true;
				Sleep(100);//等待游戏内部图色数据刷新
			}
			*nret=gDxObj.SendMsg(TS_ISGRAPHICPROTECT,enable);
			gDxObj.pData->ispichook=enable;
		}
		*nret=1;
		VMPEND
		return S_OK;
}

STDMETHODIMP CTSPlugInterFace::TSDXKmProtect(LONG enable, BSTR type, LONG* nret)
{
	// TODO: 在此添加实现代码
	VMPBEGIN    //VMP保护
	if(!TSRuntime::IsVipLogin)
	{
		if(TSRuntime::IsRegLogin==false&&TSRuntime::IsVipLogin==false)//TS盾不允许试用
		{
			*nret=0;
			return S_OK;
		}
		INT64 t=0;
		if(my_myGetTickCount)
			t=my_myGetTickCount();
		else
			t=::GetTickCount();
		if(t==TSRuntime::checkthreadtime||abs((int)(t-TSRuntime::checkthreadtime))>=60*1000*10||TSRuntime::checkthreadtime==0)	//校验线程是否被挂起或者GetTickCount被人下钩子
		{
			if(TSRuntime::IsStartProtect)
				TSRuntime::StartProtect(0,0,-1);
			*nret=0;
			TSRuntime::h_checkthread=NULL;
			return S_OK;
		}
	}
	gDxObj.Isdxkmprotect=enable;
	if(wcsicmp(type,L"dx.anti.api")==0)
		gDxObj.Isdxantiapi=true;
	else
		gDxObj.Isdxantiapi=false;

	*nret=1;
	VMPEND
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::CheckFontSmooth(LONG* nret)
{
	// TODO: 在此添加实现代码

	HKEY Reg_type=HKEY_LOCAL_MACHINE;
	HKEY hKey = NULL;
	wchar_t tempstr[MAX_PATH*2]={0};
	DWORD size=MAX_PATH*sizeof(wchar_t),dwType=0;
	LONG bret=0;
	if(RegOpenKeyEx(HKEY_CURRENT_USER, L"Control Panel\\Desktop", 0, KEY_WRITE|KEY_READ,&hKey)==ERROR_SUCCESS)
	{
		if(RegQueryValueEx(hKey,L"FontSmoothing",NULL,&dwType,(LPBYTE)tempstr,&size)==ERROR_SUCCESS)
		{
			if(_wtoi(tempstr)==2)
				bret=1;
		}

	}
	* nret=bret;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::DisableFontSmooth(LONG* nret)
{
	// TODO: 在此添加实现代码

	HKEY Reg_type=HKEY_LOCAL_MACHINE;
	HKEY hKey = NULL;
	LONG bret=0;
	if(RegOpenKeyEx(HKEY_CURRENT_USER, L"Control Panel\\Desktop", 0, KEY_WRITE|KEY_READ,&hKey)==ERROR_SUCCESS)
	{
		if(RegSetValueEx(hKey,L"FontSmoothing",NULL,REG_SZ,(LPBYTE)L"0",sizeof(wchar_t)*2)==ERROR_SUCCESS)
			bret=1;
	}
	* nret=bret;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::GetScreenData(LONG x1, LONG y1, LONG x2, LONG y2, LONG* RetAddr)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXMyGetScreenDataMutex);
	LONG x=-1,y=-1,ret=-1;
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	gDxObj.TSGetScreenData(x1,y1,x2,y2);
	*RetAddr=(ULONG)gDxObj.ColorDataInfo;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::EnableRealMouse(ULONG enable, ULONG mousedelay, ULONG mousestep, ULONG* nret)
{
	// TODO: 在此添加实现代码
	if(enable)
	{
		gDxObj.IsTSEnableRealMouse=true;
		gDxObj.mousedelay=mousedelay;
		gDxObj.mousestep=mousestep;
	}
	else
	{
		gDxObj.IsTSEnableRealMouse=false;
		gDxObj.mousedelay=0;
		gDxObj.mousestep=0;
	}
	* nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::EnableRealKeypad(ULONG enable, ULONG* nret)
{ 
	// TODO: 在此添加实现代码
	if(enable)
		gDxObj.IsTSEnableRealKeypad=true;
	else
		gDxObj.IsTSEnableRealKeypad=false;
	* nret=1;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::MoveToEx(ULONG x, ULONG y, ULONG w, ULONG h, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXMoveToExMutex);
	wchar_t retstr[16]={0};
	gDxObj.TSMoveToEx(x,y,w,h,retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::CheckUAC(ULONG* nret)
{
	// TODO: 在此添加实现代码
	HKEY Reg_type=HKEY_LOCAL_MACHINE;
	HKEY hKey = NULL;
	DWORD size=sizeof(DWORD),dwType=0,retvalue=0;
	LONG bret=0;
	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\System", 0, KEY_WRITE|KEY_READ,&hKey)==ERROR_SUCCESS)
	{
		if(RegQueryValueEx(hKey,L"ConsentPromptBehaviorAdmin",NULL,&dwType,(LPBYTE)&retvalue,&size)==ERROR_SUCCESS)
		{
			if(retvalue!=0)
				bret=1;
		}

	}
	* nret=bret;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetUAC(ULONG enable,ULONG* nret)
{
	// TODO: 在此添加实现代码
	HKEY Reg_type=HKEY_LOCAL_MACHINE;
	HKEY hKey = NULL;
	LONG bret=0;
	DWORD vlaue=0; 
	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\System", 0, KEY_WRITE|KEY_READ,&hKey)==ERROR_SUCCESS)
	{
		if(enable==0)//关闭
		{
			if(RegSetValueEx(hKey,L"ConsentPromptBehaviorAdmin",NULL,REG_DWORD,(LPBYTE)&vlaue,sizeof(DWORD))==ERROR_SUCCESS)
				bret=1;
		}
		else//打开
		{
			vlaue=2;
			if(RegSetValueEx(hKey,L"ConsentPromptBehaviorAdmin",NULL,REG_DWORD,(LPBYTE)&vlaue,sizeof(DWORD))==ERROR_SUCCESS)
				bret=1;
		}
			
	}
	* nret=bret;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::WaitKey(ULONG vk_code, ULONG time_out, ULONG* nret)
{
	// TODO: 在此添加实现代码
	* nret=TSRuntime::g_KeyBoard.waitkeypress(vk_code,time_out);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindMultiColor(ULONG x1, ULONG y1, ULONG x2, ULONG y2, BSTR first_color, BSTR offset_color, DOUBLE sim, ULONG dir, VARIANT* intX, VARIANT* intY, ULONG* nret)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindColorMutex);
	if(x1>=x2||y1>=y2)
	{
		MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	//wchar_t* p=0;
	DWORD ncolor=0x100;
	LONG x=-1,y=-1,ret;
	//TSRuntime::add_log("FindColor:_wtoi:%x",ncolor);
	//ret=TSRuntime::g_DxObj.findColor(x1,y1,x2,y2,ncolor,sim,dir,x,y);
	ret=gDxObj.findColor(x1,y1,x2,y2,ncolor,sim,dir,x,y,first_color,NULL,offset_color);
	intX->vt=VT_I4;
	intY->vt=VT_I4;
	intX->lVal=x;
	intY->lVal=y;
	*nret=ret;
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::FindMultiColorEx(ULONG x1, ULONG y1, ULONG x2, ULONG y2, BSTR first_color, BSTR offset_color, DOUBLE sim, ULONG dir, BSTR* retstring)
{
	// TODO: 在此添加实现代码
	TsMutexlock ts_mutexlock(&gDXFindColorMutex);
	if(x1>=x2||y1>=y2)
	{
		if(TSRuntime::IsShowErrorMsg)
			MessageBox(NULL,L"传入坐标已越界!",L"TS",NULL);
		return S_OK;
	}
	DWORD ncolor=0x100;
	LONG x=-1,y=-1;
	wchar_t retstr[MAX_PATH*5]={0};
	gDxObj.findColor(x1,y1,x2,y2,ncolor,sim,dir,x,y,first_color,retstr,offset_color);
	//*retstring=_bstr_t(retstr);
	CComBSTR newbstr;
	newbstr.Append(retstr);
	newbstr.CopyTo(retstring);
	return S_OK;
}

STDMETHODIMP CTSPlugInterFace::SetSimMode(ULONG mode, ULONG* nret)
{
	// TODO: 在此添加实现代码

	return S_OK;
}