模拟键盘与鼠标操作 C++

今天给大家带来,模拟键盘与鼠标操作的C++代码

都是独立的函数模块

废话不多说,直接上代码

#include "stdafx.h"
#include "Shunli.h"
#include "conio.h"
#include <iostream>  
#include <sstream>
#include <string>  
#include <algorithm>
#include <vector>
#include <imm.h>
#include <stdio.h>   
#include <Windows.h>
#include <atlstr.h>
#include <cmath>
#include <TlHelp32.h>
#include <Psapi.h>
#pragma comment (lib ,"imm32.lib")
using namespace std;



//单击
int SingleClick()
{
	try
	{
		mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
		Sleep(10);//要留给某些应用的反应时间 
		mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}
//双击
int DoubleClick()
{
	try
	{
		mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
		Sleep(10);//要留给某些应用的反应时间 
		mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
		mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
		Sleep(10);//要留给某些应用的反应时间 
		mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}
//回车
int Enter()
{
	try
	{
		keybd_event(0x0D, 0, 0, 0);
		Sleep(10);//要留给某些应用的反应时间 
		keybd_event(0x0D, 0, KEYEVENTF_KEYUP, 0);
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}
//回退
int Back()
{
	try
	{
		keybd_event(VK_BACK, 0, 0, 0);
		Sleep(10);//要留给某些应用的反应时间 
		keybd_event(VK_BACK, 0, KEYEVENTF_KEYUP, 0);
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}
//Tab
int Tab()
{
	try
	{
		keybd_event(VK_TAB, 0, 0, 0);
		Sleep(10);//要留给某些应用的反应时间 
		keybd_event(VK_TAB, 0, KEYEVENTF_KEYUP, 0);
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}
//小写
int CapslockMin()
{
	try
	{
		if (GetKeyState(VK_CAPITAL))
		{
			keybd_event(VK_CAPITAL, 0, 0, 0);
			Sleep(10);
			keybd_event(VK_CAPITAL, 0, KEYEVENTF_KEYUP, 0);
			Sleep(10);
		}
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}
//大写
int CapslockMax()
{
	try
	{
		if (GetKeyState(VK_CAPITAL))
		{
			return 0;
		}
		else
		{
			keybd_event(VK_CAPITAL, 0, 0, 0);
			Sleep(10);
			keybd_event(VK_CAPITAL, 0, KEYEVENTF_KEYUP, 0);
			Sleep(10);
		}
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}

//根据窗体名字获取窗体句柄
extern "C" SHUNLI_API int ShowMainHWND(char* MainName, HWND *HWnd)
{
	try
	{
		HWND hWnd = FindWindow(NULL, MainName);
		if (hWnd != NULL)
		{
			*HWnd = hWnd;
			return 0;
		}
		else
		{
			return -1;
		}
	}
	catch (char)
	{
		return -1;
	}
}

//根据坐标获取窗体句柄
extern "C" SHUNLI_API int ShowXYHWND(int X, int Y, HWND *HWnd)
{
	try
	{
		POINT Position = {X,Y};
		HWND hWnd = WindowFromPoint(Position);
		if (hWnd != NULL)
		{
			*HWnd = hWnd;
			return 0;
		}
		else
		{
			return -1;
		}
	}
	catch (char)
	{
		return -1;
	}
}


//移动窗体
extern "C" SHUNLI_API int MoveMain(HWND hWnd, int X, int Y, int Width, int Height)
{
	try
	{
		if (MoveWindow(hWnd, X, Y, Width, Height, true))
		{
			return 0;
		}
		else
		{
			return -1;
		}
	}
	catch (char)
	{
		return -1;
	}
}

//移动鼠标
extern "C" SHUNLI_API int MobileMouse(int X, int Y)
{
	try
	{
		if (SetCursorPos(X, Y))//更改鼠标坐标
		{
			return 0;
		}
		else
		{
			return -1;
		}
	}
	catch (char)
	{
		return -1;
	}
}

//0单击   1双击   2回车   3换行    4回退   5输入法大写  6输入法小写   7按下ctrl+v  8切换系统键盘为美式键盘
extern "C" SHUNLI_API int KeyboardAndMouseOperation(int KeyboardAndMouseType)
{
	int RetData = -1;
	switch (KeyboardAndMouseType)
	{
		//单击
	case 0:
		RetData = SingleClick();
		break;
		//双击
	case 1:
		RetData = DoubleClick();
		break;
		//回车
	case 2:
		RetData = Enter();
		break;
		//换行
	case 3:
		RetData = Tab();
		break;
		//回退
	case 4:
		RetData = Back();
		break;
	case 5://输入法大写
		RetData = CapslockMax();
		break;
	case 6://输入法小写
		RetData = CapslockMin();
		break;
	case 7://按下 ctrl+V
		keybd_event(VK_CONTROL, 0, 0, 0);
		Sleep(10);
		keybd_event('V', 0, 0, 0);
		keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
		keybd_event('V', 0, KEYEVENTF_KEYUP, 0);
		break;
	case 8://输入法切换成美式键盘
		LoadKeyboardLayout("0x409", KLF_ACTIVATE | KLF_SETFORPROCESS);
		break;
	}
	return RetData;
}
//按下
int PressDown(string Info)
{
	try
	{
		if (Info == "A")
		{
			CapslockMax();
			keybd_event('A', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('A', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "B")
		{
			CapslockMax();
			keybd_event('B', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('B', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "C")
		{
			CapslockMax();
			keybd_event('C', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('C', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "D")
		{
			CapslockMax();
			keybd_event('D', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('D', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "E")
		{
			CapslockMax();
			keybd_event('E', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('E', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "F")
		{
			CapslockMax();
			keybd_event('F', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "G")
		{
			CapslockMax();
			keybd_event('G', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('G', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "H")
		{
			CapslockMax();
			keybd_event('H', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('H', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "I")
		{
			CapslockMax();
			keybd_event('I', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('I', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "J")
		{
			CapslockMax();
			keybd_event('J', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('J', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "K")
		{
			CapslockMax();
			keybd_event('K', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('K', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "L")
		{
			CapslockMax();
			keybd_event('L', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('L', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "M")
		{
			CapslockMax();
			keybd_event('M', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('M', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "N")
		{
			CapslockMax();
			keybd_event('N', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "O")
		{
			CapslockMax();
			keybd_event('O', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('O', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "P")
		{
			CapslockMax();
			keybd_event('P', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('P', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "Q")
		{
			CapslockMax();
			keybd_event('Q', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('Q', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "R")
		{
			CapslockMax();
			keybd_event('R', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('R', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "S")
		{
			CapslockMax();
			keybd_event('S', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('S', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "T")
		{
			CapslockMax();
			keybd_event('T', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('T', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "U")
		{
			CapslockMax();
			keybd_event('U', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('U', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "V")
		{
			CapslockMax();
			keybd_event('V', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('V', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "W")
		{
			CapslockMax();
			keybd_event('W', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('W', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "X")
		{
			CapslockMax();
			keybd_event('X', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('X', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "Y")
		{
			CapslockMax();
			keybd_event('Y', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('Y', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "Z")
		{
			CapslockMax();
			keybd_event('Z', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('Z', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "a")
		{
			CapslockMin();
			keybd_event('A', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('A', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "b")
		{
			CapslockMin();
			keybd_event('B', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('B', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "c")
		{
			CapslockMin();
			keybd_event('C', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('C', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "d")
		{
			CapslockMin();
			keybd_event('D', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('D', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "e")
		{
			CapslockMin();
			keybd_event('E', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('E', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "f")
		{
			CapslockMin();
			keybd_event('F', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('F', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "G")
		{
			CapslockMin();
			keybd_event('G', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('G', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "h")
		{
			CapslockMin();
			keybd_event('H', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('H', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "i")
		{
			CapslockMin();
			keybd_event('I', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('I', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "j")
		{
			CapslockMin();
			keybd_event('J', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('J', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "k")
		{
			CapslockMin();
			keybd_event('K', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('K', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "l")
		{
			keybd_event('L', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('L', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "m")
		{
			CapslockMin();
			keybd_event('M', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('M', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "n")
		{
			CapslockMin();
			keybd_event('N', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('N', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "o")
		{
			CapslockMin();
			keybd_event('O', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('O', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "p")
		{
			CapslockMin();
			keybd_event('P', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('P', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "q")
		{
			CapslockMin();
			keybd_event('Q', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('Q', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "r")
		{
			CapslockMin();
			keybd_event('R', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('R', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "s")
		{
			CapslockMin();
			keybd_event('S', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('S', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "t")
		{
			CapslockMin();
			keybd_event('T', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('T', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "u")
		{
			CapslockMin();
			keybd_event('U', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('U', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "v")
		{
			CapslockMin();
			keybd_event('V', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('V', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "w")
		{
			CapslockMin();
			keybd_event('W', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('W', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "x")
		{
			CapslockMin();
			keybd_event('X', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('X', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "y")
		{
			CapslockMin();
			keybd_event('Y', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('Y', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "z")
		{
			CapslockMin();
			keybd_event('Z', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('Z', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "0")
		{
			
			keybd_event('0', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('0', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "1")
		{
			keybd_event('1', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('1', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "2")
		{
			keybd_event('2', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('2', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "3")
		{
			keybd_event('3', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('3', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "4")
		{
			keybd_event('4', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('4', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "5")
		{
			keybd_event('5', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('5', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "6")
		{
			keybd_event('6', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('6', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "7")
		{
			keybd_event('7', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('7', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "8")
		{
			keybd_event('8', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('8', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == "9")
		{
			keybd_event('9', 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event('9', 0, KEYEVENTF_KEYUP, 0);
		}
		else if (Info == ".")
		{
			keybd_event(VK_OEM_PERIOD, 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event(VK_OEM_PERIOD, 0, KEYEVENTF_KEYUP, 0);
			return 0;
		}
		else if (Info =="+")
		{
			keybd_event(VK_OEM_PLUS, 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event(VK_OEM_PLUS, 0, KEYEVENTF_KEYUP, 0);
			return 0;
		}
		else if (Info == "-")
		{
			keybd_event(VK_OEM_MINUS, 0, 0, 0);
			Sleep(10);//要留给某些应用的反应时间 
			keybd_event(VK_OEM_MINUS, 0, KEYEVENTF_KEYUP, 0);
			return 0;
		}
		else
		{
			if (Info == "*")  
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('8', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('8', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "~")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event(VK_OEM_3, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_3, 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "`")
			{
				keybd_event(VK_OEM_3, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_3, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "!")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('1', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('1', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "@")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('2', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('2', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "#")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('3', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('3', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "$")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('4', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('4', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "%")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('5', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('5', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "^")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('6', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('6', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "&")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('7', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('7', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "(")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('9', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('9', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == ")")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event('0', 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event('0', 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "|")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event(VK_OEM_5, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_5, 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "\\")
			{
				keybd_event(VK_OEM_5, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_5, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "{")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event(VK_OEM_4, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_4, 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "}")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event(VK_OEM_6, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_6, 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "[")
			{
				keybd_event(VK_OEM_4, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_4, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "]")
			{
				keybd_event(VK_OEM_6, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_6, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "?")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event(VK_OEM_2, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_2, 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == "/")
			{
				keybd_event(VK_OEM_2, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_OEM_2, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == ":")
			{
				keybd_event(VK_SHIFT, 0, 0, 0);
				keybd_event(VK_HANGUL, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_HANGUL, 0, KEYEVENTF_KEYUP, 0);
				keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);
			}
			else if (Info == ";")//【"】
			{
				keybd_event(VK_HANGUL, 0, 0, 0);
				Sleep(10);//要留给某些应用的反应时间 
				keybd_event(VK_HANGUL, 0, KEYEVENTF_KEYUP, 0);
			}
			return 0;
		}
		return -1;
	}
	catch (char)
	{
		return -1;
	}
}
//转大写
void StringToUpper(string &str)
{
	std::transform(str.begin(), str.end(), str.begin(), ::toupper);
}
//转小写
void StringToLower(string &str)
{
	std::transform(str.begin(), str.end(), str.begin(), ::tolower);
}
//判断是不是数字
bool isNum(string str)
{
	stringstream sin(str);
	double d;
	char c;
	if (!(sin >> d))
	{
		return false;
	}
	if (sin >> c)
	{
		return false;
	}
	return true;
}
//按下数字与字母 ,大小写得外部区分
extern "C" SHUNLI_API int Input(char* Info)
{
	try
	{
		string _Data = Info;
		for (size_t i = 0; i < _Data.length(); i++)
		{
			string Data = _Data.substr(i,1);
			PressDown(Data);
		}
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}

//获取指定坐标颜色   
extern "C" SHUNLI_API int ShowColour(int X, int Y, int *Red, int *Green, int *Blue)
{
	try
	{
		HWND hWnd = ::GetDesktopWindow();
		HDC hdc = ::GetDC(hWnd);
		COLORREF pixel = ::GetPixel(hdc, X, Y);
		if (pixel != CLR_INVALID) 
		{
			*Red = GetRValue(pixel);
			*Green = GetGValue(pixel);
			*Blue = GetBValue(pixel);
			return 0;
		}
		else
		{
			return -1;
		}
	}
	catch (char)
	{
		return -1;
	}
}

//复制粘贴 
extern "C" SHUNLI_API int CopyPaste(CString source)
{
	try
	{
		if (OpenClipboard(NULL) || EmptyClipboard())
		{
			//防止非ASCII语言复制到剪切板为乱码
			int buff_size = source.GetLength();
			CStringW strWide = CStringW(source);
			int nLen = strWide.GetLength();
			//将剪切板置空
			EmptyClipboard();
			HANDLE clipbuffer = GlobalAlloc(GMEM_DDESHARE, (nLen + 1) * 2);
			if (!clipbuffer)
			{
				CloseClipboard();
				return -1;
			}
			char* buffer = (char*)::GlobalLock(clipbuffer);
			memset(buffer, 0, (nLen + 1) * 2);
			memcpy_s(buffer, nLen * 2, strWide.GetBuffer(0), nLen * 2);
			strWide.ReleaseBuffer();
			GlobalUnlock(clipbuffer);
			SetClipboardData(CF_UNICODETEXT, clipbuffer);
			CloseClipboard();

			//按下CTRL+V 
			KeyboardAndMouseOperation(7);
			return 0;
		}
		else
		{
			return -1;
		}

	}
	catch (char)
	{
		return -1;
	}
}

//隐藏指定窗口
extern "C" SHUNLI_API int HideWindows(HWND hwnd, char * FormName)
{
	try
	{
		char wtitle[512];
		GetWindowText(hwnd, wtitle, sizeof(wtitle));
		if (strstr(wtitle, FormName))
		{
			ShowWindow(hwnd, SW_HIDE);
		}
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}
//隐藏指定窗口
extern "C" SHUNLI_API int ShowWindows(HWND hwnd, char * FormName)
{
	try
	{
		char wtitle[512];
		GetWindowText(hwnd, wtitle, sizeof(wtitle));
		if (strstr(wtitle, FormName))
		{
			ShowWindow(hwnd, SW_SHOW);
		}
		return 0;
	}
	catch (char)
	{
		return -1;
	}
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • pywin32模拟鼠标键盘操作

    第三个参数:函数操作的一个标志位,如果值为KEYEVENTF_EXTENDEDKEY则该键被按下,也可设置为0即可,如果值为KEYEVENTF_KEYUP则该按...

    周小董
  • python 捕捉和模拟鼠标键盘操作

    使用的python版本为:3.6.1,使用anaconda配置的python环境 参考博文

    py3study
  • Python模拟键盘输入和鼠标操作

    一、Python键盘输入模拟: import win32api import win32con win32api.keybd_event(17,0,0,0)  ...

    代码伴一生
  • Python模拟键盘输入和鼠标操作

    一、Python键盘输入模拟: import win32api import win32con win32api.keybd_event(17,0,0,0)  ...

    用户7365393
  • Python模拟键盘输入和鼠标操作

    一、Python键盘输入模拟: import win32api import win32con win32api.keybd_event(17,0,0,0)  ...

    用户7705674
  • [PyUserInput]模拟鼠标和键盘模拟

    http://www.lfd.uci.edu/~gohlke/pythonlibs/

    周小董
  • c# 模拟window 操作鼠标|winapi

    适合场景:LinkButton如果想要弹出右键菜单的时候,可以在Click事件中通过API模拟鼠标右击事件。

    跟着阿笨一起玩NET
  • python selenium2 - 鼠标键盘操作

    完整路径 C:\Python27\Lib\site-packages\selenium\webdriver\common\action_chains.py 注...

    苦叶子
  • 鼠标操作、下拉列表、键盘操作

    首先了解鼠标操作这个东西是怎么实现的,用了一个类,这个类叫做actionChains

    清菡
  • Selenium 鼠标键盘操作与滚动条控制

    清风穆云
  • MATLAB调用Java操作键盘鼠标

    MATLAB在plot之后得到图像figure窗体的句柄,可以操作figure修改尺寸以及各种参数。

    万木逢春
  • MFC--响应鼠标和键盘操作

      一.  理解鼠标事件.之前对鼠标事件的认识仅仅局限于处理控件的单击与双击事件.但实际鼠标的操作包含很多.这里将以一个画图的小程序讲解对鼠标的响应.

    用户2038589
  • Python:监控键盘输入、鼠标操作,并

      使用pyhook模块可以很快地完成键盘及鼠标事件捕获,本来想使用...

    py3study
  • Selenium自动化测试-6.鼠标键盘操作

    在上一篇:Selenium自动化测试-脚本录制神器Katalon Recorder,我们认识了一个实用的脚本录制神器。到此为止,已经学完了8种定位方式以及利用F...

    王大力测试进阶之路
  • Selenium自动化测试-6.鼠标键盘操作

    在上一篇:Selenium自动化测试-脚本录制神器Katalon Recorder,我们认识了一个实用的脚本录制神器。到此为止,已经学完了8种定位方式以及利用F...

    ITester软件测试小栈
  • Electron中的键盘鼠标操作(Windows环境下)

    ROBOTJS官网: https://robotjs.io/docs/ ROBOTJS源码: https://github.com/octalmage/robo...

    剑行者
  • Electron中使用Node-ffi模拟键鼠操作

    折腾这个东西就是要实现一个很简单的功能:在我的应用中控制处于后台的PPT进行翻页。

    剑行者
  • Nightwatch中如何模拟键盘操作

    在自动化测试中有这样一个场景,在一个输入框中输入一串字符,然后执行敲回车键,验证搜索结果,以Google搜索为例,代码如下:

    Peter Shen
  • 换个姿势「模拟登录」

    今天老肥给大家介绍Python一个非常有意思的库PyUserInput,它集成了PyMouse和PyKeyboard这俩模块,能够模拟鼠标和键盘的操作,可以说是...

    老肥码码码

扫码关注云+社区

领取腾讯云代金券