MSDN中SetWindowsHookEx的例子代码

最新推荐文章于 2023-02-05 11:17:23 发布
最新推荐文章于 2023-02-05 11:17:23 发布
阅读量1.5w 收藏 9
点赞数 2
分类专栏： 代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cpdoor2163_com/article/details/8259820
版权
目标：
运行SetWindowsHookEx在MSDN（2008）中的例子程序。
ms-help://MS.MSDNQTR.v90.en/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookfunctions/setwindowshookex.htm
ms-help://MS.MSDNQTR.v90.en/winui/winui/windowsuserinterface/windowing/hooks/usinghooks.htm

操作如下：
（1）使用VS2008默认设置建立一个C++DE“Win32 Project”的窗口程序，名为“hookTest4”。
（2）需要把相应的按钮事件关联到界面的菜单中，如hookTest4.rc中所述。
（3）需要在“Source Files”中添加新文件“hookExample.cpp”。其中，SetWindowsHookEx的示例代码为顺利运行有一些改动。
（4）运行程序，触发菜单“HOOK”下的选项，可以在窗口中看到调试输出。 

// hookExample.cpp
#include "stdafx.h"
#include <strsafe.h>// for using StringCchCopy,StringCchLength functions etc.
#include "Resource.h"

#define CALLWNDPROC					IDM_CALLWNDPROC 
#define CBT   						IDM_CBT   
#define DEBUG						IDM_DEBUG  
#define GETMESSAGE 					IDM_GETMESSAGE 
#define KEYBOARD 					IDM_KEYBOARD 
#define MOUSE  						IDM_MOUSE  
#define MSGFILTER 					IDM_MSGFILTER 


LRESULT WINAPI MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, LPARAM lParam);
LRESULT WINAPI CallWndProc(int nCode, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK GetMsgProc(int nCode, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK DebugProc(int nCode, WPARAM wParam, LPARAM lParam) ;
LRESULT CALLBACK CBTProc(int nCode, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK MessageProc(int nCode, WPARAM wParam, LPARAM lParam);

INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);

HWND hwndMain;
extern HINSTANCE hInst;	

//void LookUpTheMessage(PMSG pmsg, TCHAR* szMsg);
//application-defined function, I have written a simple one,you can
//write yours instead
void LookUpTheMessage(PMSG pmsg, TCHAR* szMsg)
{
	DWORD message = pmsg->message;
	StringCchPrintf(szMsg, sizeof(DWORD), L"%x", message);
}

//==============================================================================================================================================
// 下面是MSDN上SetWindowsHookEx的Example原文，为顺利运行有一些改动。
//==============================================================================================================================================
#define NUMHOOKS 7 

// Global variables 

typedef struct _MYHOOKDATA 
{ 
	int nType; 
	HOOKPROC hkprc; 
	HHOOK hhook; 
} MYHOOKDATA; 

MYHOOKDATA myhookdata[NUMHOOKS]; 

LRESULT WINAPI MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, 
						   LPARAM lParam) 
{ 
	static BOOL afHooks[NUMHOOKS]; 
	int index; 
	static HMENU hmenu; 

	switch (uMsg) 
	{ 
	case WM_CREATE: 

		// Save the menu handle. 

		hmenu = GetMenu(hwndMain); 

		// Initialize structures with hook data. The menu-item 
		// identifiers are defined as 0 through 6 in the 
		// header file. They can be used to identify array 
		// elements both here and during the WM_COMMAND 
		// message. 

		myhookdata[IDM_CALLWNDPROC].nType = WH_CALLWNDPROC; 
		myhookdata[IDM_CALLWNDPROC].hkprc = CallWndProc; 
		myhookdata[IDM_CBT].nType = WH_CBT; 
		myhookdata[IDM_CBT].hkprc = CBTProc; 
		myhookdata[IDM_DEBUG].nType = WH_DEBUG; 
		myhookdata[IDM_DEBUG].hkprc = DebugProc; 
		myhookdata[IDM_GETMESSAGE].nType = WH_GETMESSAGE; 
		myhookdata[IDM_GETMESSAGE].hkprc = GetMsgProc; 
		myhookdata[IDM_KEYBOARD].nType = WH_KEYBOARD; 
		myhookdata[IDM_KEYBOARD].hkprc = KeyboardProc; 
		myhookdata[IDM_MOUSE].nType = WH_MOUSE; 
		myhookdata[IDM_MOUSE].hkprc = MouseProc; 
		myhookdata[IDM_MSGFILTER].nType = WH_MSGFILTER; 
		myhookdata[IDM_MSGFILTER].hkprc = MessageProc; 

		// Initialize all flags in the array to FALSE. 

		memset(afHooks, FALSE, sizeof(afHooks)); 

		return 0; 

	case WM_COMMAND: 
		switch (LOWORD(wParam)) 
		{ 
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hwndMain, About);
			break;

		case IDM_EXIT:
			DestroyWindow(hwndMain);
			break;

			// The user selected a hook command from the menu. 

		case IDM_CALLWNDPROC: 
		case IDM_CBT: 
		case IDM_DEBUG: 
		case IDM_GETMESSAGE: 
		case IDM_KEYBOARD: 
		case IDM_MOUSE: 
		case IDM_MSGFILTER: 

			// Use the menu-item identifier as an index 
			// into the array of structures with hook data. 

			index = LOWORD(wParam); 

			// If the selected type of hook procedure isn't 
			// installed yet, install it and check the 
			// associated menu item. 

			if (!afHooks[index]) 
			{ 
				myhookdata[index].hhook = SetWindowsHookEx( 
					myhookdata[index].nType, 
					myhookdata[index].hkprc, 
					(HINSTANCE) NULL, GetCurrentThreadId()); 
				CheckMenuItem(hmenu, index, 
					MF_BYCOMMAND | MF_CHECKED); 
				afHooks[index] = TRUE; 
			} 

			// If the selected type of hook procedure is 
			// already installed, remove it and remove the 
			// check mark from the associated menu item. 

			else 
			{ 
				UnhookWindowsHookEx(myhookdata[index].hhook); 
				CheckMenuItem(hmenu, index, 
					MF_BYCOMMAND | MF_UNCHECKED); 
				afHooks[index] = FALSE; 
			} 

		default: 
			return (DefWindowProc(hwndMain, uMsg, wParam, 
				lParam)); 
		} 
		break; 

		//
		// Process other messages. 
		//

	default: 
		return DefWindowProc(hwndMain, uMsg, wParam, lParam); 
	} 
	return NULL; 
} 

/**************************************************************** 
WH_CALLWNDPROC hook procedure 
****************************************************************/ 

LRESULT WINAPI CallWndProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
	TCHAR szCWPBuf[256]; 
	TCHAR szMsg[16]; 
	HDC hdc; 
	static int c = 0; 
	size_t cch;
	size_t * pcch = &cch;
	HRESULT hResult; 

	if (nCode < 0)  // do not process message 
		return CallNextHookEx(myhookdata[CALLWNDPROC].hhook, nCode, 
		wParam, lParam); 

	// Call an application-defined function that converts a message 
	// constant to a string and copies it to a buffer. 

	LookUpTheMessage((PMSG) lParam, szMsg); 

	hdc = GetDC(hwndMain); 

	switch (nCode) 
	{ 
	case HC_ACTION:
		hResult = StringCchPrintf(szCWPBuf, 256/sizeof(TCHAR),  
			L"CALLWNDPROC - tsk: %ld, msg: %s, %d times   ", 
			wParam, szMsg, c++);
		if (FAILED(hResult))
		{
			// TODO: writer error handler
		}
		hResult = StringCchLength(szCWPBuf, 256/sizeof(TCHAR), pcch);
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		TextOut(hdc, 2, 15, szCWPBuf, *pcch); 
		break; 

	default: 
		break; 
	} 

	ReleaseDC(hwndMain, hdc); 
	return CallNextHookEx(myhookdata[CALLWNDPROC].hhook, nCode, 
		wParam, lParam); 
} 

/**************************************************************** 
WH_GETMESSAGE hook procedure 
****************************************************************/ 

LRESULT CALLBACK GetMsgProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
	TCHAR szMSGBuf[256]; 
	TCHAR szRem[16]; 
	TCHAR szMsg[16]; 
	HDC hdc; 
	static int c = 0; 
	size_t cch;
	size_t * pcch = &cch;
	HRESULT hResult;

	if (nCode < 0) // do not process message 
		return CallNextHookEx(myhookdata[GETMESSAGE].hhook, nCode, 
		wParam, lParam); 

	switch (nCode) 
	{ 
	case HC_ACTION: 
		switch (wParam) 
		{ 
		case PM_REMOVE:
			hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), L"PM_REMOVE");
			if (FAILED(hResult))
			{
				// TODO: write error handler
			} 
			break; 

		case PM_NOREMOVE:
			hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), L"PM_NOREMOVE");
			if (FAILED(hResult))
			{
				// TODO: write error handler
			} 
			break; 

		default:
			hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), L"Unknown");
			if (FAILED(hResult))
			{
				// TODO: write error handler
			} 
			break; 
		} 

		// Call an application-defined function that converts a 
		// message constant to a string and copies it to a 
		// buffer. 

		LookUpTheMessage((PMSG) lParam, szMsg); 

		hdc = GetDC(hwndMain);
		hResult = StringCchPrintf(szMSGBuf, 256/sizeof(TCHAR), 
			L"GETMESSAGE - wParam: %s, msg: %s, %d times   ", 
			szRem, szMsg, c++);
		if (FAILED(hResult))
		{
			// TODO: write error handler
		}
		hResult = StringCchLength(szMSGBuf, 256/sizeof(TCHAR), pcch);
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		TextOut(hdc, 2, 35, szMSGBuf, *pcch); 
		break; 

	default: 
		break; 
	} 

	ReleaseDC(hwndMain, hdc); 
	return CallNextHookEx(myhookdata[GETMESSAGE].hhook, nCode, 
		wParam, lParam); 
} 

/**************************************************************** 
WH_DEBUG hook procedure 
****************************************************************/ 

LRESULT CALLBACK DebugProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
	TCHAR szBuf[128]; 
	HDC hdc; 
	static int c = 0; 
	size_t cch;
	size_t * pcch = &cch;
	HRESULT hResult;

	if (nCode < 0)  // do not process message 
		return CallNextHookEx(myhookdata[DEBUG].hhook, nCode, 
		wParam, lParam); 

	hdc = GetDC(hwndMain); 

	switch (nCode) 
	{ 
	case HC_ACTION:
		hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR),   
			L"DEBUG - nCode: %d, tsk: %ld, %d times   ", 
			nCode,wParam, c++);
		if (FAILED(hResult))
		{
			// TODO: write error handler
		}
		hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		TextOut(hdc, 2, 55, szBuf, *pcch); 
		break; 

	default: 
		break; 
	} 

	ReleaseDC(hwndMain, hdc); 
	return CallNextHookEx(myhookdata[DEBUG].hhook, nCode, wParam, 
		lParam); 
} 

/**************************************************************** 
WH_CBT hook procedure 
****************************************************************/ 

LRESULT CALLBACK CBTProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
	TCHAR szBuf[128]; 
	TCHAR szCode[128]; 
	HDC hdc; 
	static int c = 0; 
	size_t cch;
	size_t * pcch = &cch;
	HRESULT hResult;

	if (nCode < 0)  // do not process message 
		return CallNextHookEx(myhookdata[CBT].hhook, nCode, wParam, 
		lParam); 

	hdc = GetDC(hwndMain); 

	switch (nCode) 
	{ 
	case HCBT_ACTIVATE:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_ACTIVATE");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case HCBT_CLICKSKIPPED:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_CLICKSKIPPED");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case HCBT_CREATEWND:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_CREATEWND");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case HCBT_DESTROYWND:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_DESTROYWND");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case HCBT_KEYSKIPPED:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_KEYSKIPPED");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case HCBT_MINMAX:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_MINMAX");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case HCBT_MOVESIZE:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_MOVESIZE");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case HCBT_QS:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_QS");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case HCBT_SETFOCUS:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_SETFOCUS");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case HCBT_SYSCOMMAND:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"HCBT_SYSCOMMAND");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	default:
		hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), L"Unknown");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 
	} 
	hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR), L"CBT -  nCode: %s, tsk: %ld, %d times   ",
		szCode, wParam, c++);
	if (FAILED(hResult))
	{
		// TODO: write error handler
	}
	hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
	if (FAILED(hResult))
	{
		// TODO: write error handler
	} 
	TextOut(hdc, 2, 75, szBuf, *pcch); 
	ReleaseDC(hwndMain, hdc); 
	return CallNextHookEx(myhookdata[CBT].hhook, nCode, wParam, 
		lParam); 
} 

/**************************************************************** 
WH_MOUSE hook procedure 
****************************************************************/ 

LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
	TCHAR szBuf[128]; 
	TCHAR szMsg[16]; 
	HDC hdc; 
	static int c = 0; 
	size_t cch;
	size_t * pcch = &cch;
	HRESULT hResult;

	if (nCode < 0)  // do not process the message 
		return CallNextHookEx(myhookdata[MOUSE].hhook, nCode, 
		wParam, lParam); 

	// Call an application-defined function that converts a message 
	// constant to a string and copies it to a buffer. 

	LookUpTheMessage((PMSG) lParam, szMsg); 

	hdc = GetDC(hwndMain);
	hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR), 
		L"MOUSE - nCode: %d, msg: %s, x: %d, y: %d, %d times   ", 
		nCode, szMsg, LOWORD(lParam), HIWORD(lParam), c++); 
	if (FAILED(hResult))
	{
		// TODO: write error handler
	}
	hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
	if (FAILED(hResult))
	{
		// TODO: write error handler
	}
	TextOut(hdc, 2, 95, szBuf, *pcch); 
	ReleaseDC(hwndMain, hdc); 
	return CallNextHookEx(myhookdata[MOUSE].hhook, nCode, wParam, 
		lParam); 
} 

/**************************************************************** 
WH_KEYBOARD hook procedure 
****************************************************************/ 

LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
	TCHAR szBuf[128]; 
	HDC hdc; 
	static int c = 0; 
	size_t cch;
	size_t * pcch = &cch;
	HRESULT hResult;

	if (nCode < 0)  // do not process message 
		return CallNextHookEx(myhookdata[KEYBOARD].hhook, nCode, 
		wParam, lParam); 

	hdc = GetDC(hwndMain);
	hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR), L"KEYBOARD - nCode: %d, vk: %d, %d times ", nCode, wParam, c++);
	if (FAILED(hResult))
	{
		// TODO: write error handler
	} 
	hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
	if (FAILED(hResult))
	{
		// TODO: write error handler
	} 
	TextOut(hdc, 2, 115, szBuf, *pcch); 
	ReleaseDC(hwndMain, hdc); 
	return CallNextHookEx(myhookdata[KEYBOARD].hhook, nCode, wParam, 
		lParam); 
} 

/**************************************************************** 
WH_MSGFILTER hook procedure 
****************************************************************/ 

LRESULT CALLBACK MessageProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
	TCHAR szBuf[128]; 
	TCHAR szMsg[16]; 
	TCHAR szCode[32]; 
	HDC hdc; 
	static int c = 0; 
	size_t cch;
	size_t * pcch = &cch;
	HRESULT hResult;

	if (nCode < 0)  // do not process message 
		return CallNextHookEx(myhookdata[MSGFILTER].hhook, nCode, 
		wParam, lParam); 

	switch (nCode) 
	{ 
	case MSGF_DIALOGBOX:
		hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), L"MSGF_DIALOGBOX");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case MSGF_MENU:
		hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), L"MSGF_MENU");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	case MSGF_SCROLLBAR:
		hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), L"MSGF_SCROLLBAR");
		if (FAILED(hResult))
		{
			// TODO: write error handler
		} 
		break; 

	default:
		hResult = StringCchPrintf(szCode, 128/sizeof(TCHAR), L"Unknown: %d", nCode);
		if (FAILED(hResult))
		{
			// TODO: write error handler
		}
		break; 
	} 

	// Call an application-defined function that converts a message 
	// constant to a string and copies it to a buffer. 

	LookUpTheMessage((PMSG) lParam, szMsg); 

	hdc = GetDC(hwndMain);
	hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR),  
		L"MSGFILTER  nCode: %s, msg: %s, %d times    ", 
		szCode, szMsg, c++);
	if (FAILED(hResult))
	{
		// TODO: write error handler
	} 
	hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
	if (FAILED(hResult))
	{
		// TODO: write error handler
	} 
	TextOut(hdc, 2, 135, szBuf, *pcch); 
	ReleaseDC(hwndMain, hdc); 
	return CallNextHookEx(myhookdata[MSGFILTER].hhook, nCode, 
		wParam, lParam); 
} 

// hookTest4.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "hookTest4.h"

extern HWND hwndMain;

LRESULT WINAPI MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, LPARAM lParam);

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE hInst;								// current instance
TCHAR szTitle[MAX_LOADSTRING];					// The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];			// the main window class name

// Forward declarations of functions included in this code module:
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

 	// TODO: Place code here.
	MSG msg;
	HACCEL hAccelTable;

	// Initialize global strings
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_HOOKTEST4, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Perform application initialization:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}

	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_HOOKTEST4));

	// Main message loop:
	while (GetMessage(&msg, NULL, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return (int) msg.wParam;
}



//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage are only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= MainWndProc; //WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_HOOKTEST4));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_HOOKTEST4);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	return RegisterClassEx(&wcex);
}

//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   //HWND hWnd;

   hInst = hInstance; // Store instance handle in our global variable

   hwndMain = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

   if (!hwndMain)
   {
      return FALSE;
   }

   ShowWindow(hwndMain, nCmdShow);
   UpdateWindow(hwndMain);

   return TRUE;
}


  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)

  PURPOSE:  Processes messages for the main window.

  WM_COMMAND	- process the application menu
  WM_PAINT	- Paint the main window
  WM_DESTROY	- post a quit message and return


//LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
//{
//	int wmId, wmEvent;
//	PAINTSTRUCT ps;
//	HDC hdc;
//
//	switch (message)
//	{
//	case WM_COMMAND:
//		wmId    = LOWORD(wParam);
//		wmEvent = HIWORD(wParam);
//		// Parse the menu selections:
//		switch (wmId)
//		{
//		case IDM_ABOUT:
//			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
//			break;
//		case IDM_EXIT:
//			DestroyWindow(hWnd);
//			break;
//		default:
//			return DefWindowProc(hWnd, message, wParam, lParam);
//		}
//		break;
//	case WM_PAINT:
//		hdc = BeginPaint(hWnd, &ps);
//		// TODO: Add any drawing code here...
//		EndPaint(hWnd, &ps);
//		break;
//	case WM_DESTROY:
//		PostQuitMessage(0);
//		break;
//	default:
//		return DefWindowProc(hWnd, message, wParam, lParam);
//	}
//	return 0;
//}

// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;

	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}

// Resource.h
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by hookTest4.rc
//

#define IDS_APP_TITLE			103

#define IDR_MAINFRAME			128
#define IDD_HOOKTEST4_DIALOG	102
#define IDD_ABOUTBOX			103
#define IDM_ABOUT				104
#define IDM_EXIT				105
#define IDI_HOOKTEST4			107
#define IDI_SMALL				108
#define IDC_HOOKTEST4			109
#define IDC_MYICON				2
#ifndef IDC_STATIC
#define IDC_STATIC				-1
#endif
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS

#define _APS_NO_MFC					130
#define _APS_NEXT_RESOURCE_VALUE	129
#define _APS_NEXT_COMMAND_VALUE		32771
#define _APS_NEXT_CONTROL_VALUE		1000
#define _APS_NEXT_SYMED_VALUE		110
#endif
#endif

// HOOK， 下面是添加的代码
#define IDM_CALLWNDPROC 0
#define IDM_CBT   1
#define IDM_DEBUG  2
#define IDM_GETMESSAGE 3
#define IDM_KEYBOARD 4
#define IDM_MOUSE  5
#define IDM_MSGFILTER 6

// hookTest4.rc
//Microsoft Visual C++ generated resource script.
//
#include "resource.h"

#define APSTUDIO_READONLY_SYMBOLS
/
//
// Generated from the TEXTINCLUDE 2 resource.
//
#ifndef APSTUDIO_INVOKED
#include "targetver.h"
#endif
#define APSTUDIO_HIDDEN_SYMBOLS
#include "windows.h"
#undef APSTUDIO_HIDDEN_SYMBOLS
/
#undef APSTUDIO_READONLY_SYMBOLS

#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
LANGUAGE 9, 1
#pragma code_page(936)

/
//
// Icon
//

// Icon with lowest ID value placed first to ensure application icon
// remains consistent on all systems.

IDI_HOOKTEST4       ICON         "hookTest4.ico"
IDI_SMALL               ICON         "small.ico"

/
//
// Menu
//

IDC_HOOKTEST4 MENU
BEGIN
    POPUP "&File"
    BEGIN
        MENUITEM "E&xit",                IDM_EXIT
    END
    POPUP "&Help"
    BEGIN
        MENUITEM "&About ...",           IDM_ABOUT
    END
	POPUP "&HOOK"
	BEGIN
		MENUITEM "&IDM_CALLWNDPROC",		IDM_CALLWNDPROC 
		MENUITEM "&IDM_CBT",				IDM_CBT   
		MENUITEM "&IDM_DEBUG",				IDM_DEBUG  
		MENUITEM "&IDM_GETMESSAGE",			IDM_GETMESSAGE 
		MENUITEM "&IDM_KEYBOARD",			IDM_KEYBOARD 
		MENUITEM "&IDM_MOUSE",				IDM_MOUSE  
		MENUITEM "&IDM_MSGFILTER",			IDM_MSGFILTER 
    END
END


/
//
// Accelerator
//

IDC_HOOKTEST4 ACCELERATORS
BEGIN"?",            IDM_ABOUT,              ASCII,  ALT
    "/",            IDM_ABOUT,              ASCII,  ALT
END


/
//
// Dialog
//

IDD_ABOUTBOX DIALOGEX 0, 0, 170, 62
STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "About hookTest4"
FONT 8, "MS Shell Dlg"
BEGIN
    ICON            IDR_MAINFRAME,IDC_STATIC,14,14,21,20
    LTEXT           "hookTest4, Version 1.0",IDC_STATIC,42,14,114,8,SS_NOPREFIX
    LTEXT           "Copyright (C) 2012",IDC_STATIC,42,26,114,8
    DEFPUSHBUTTON   "OK",IDOK,113,41,50,14,WS_GROUP
END

/
//
// DESIGNINFO
//

#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO
BEGIN
    IDD_ABOUTBOX, DIALOG
    BEGIN
        LEFTMARGIN, 7
        RIGHTMARGIN, 163
        TOPMARGIN, 7
        BOTTOMMARGIN, 55
    END
END
#endif    // APSTUDIO_INVOKED

#ifdef APSTUDIO_INVOKED
/
//
// TEXTINCLUDE
//
1 TEXTINCLUDE
BEGIN
    "resource.h\0"
END

2 TEXTINCLUDE
BEGIN
	"#ifndef APSTUDIO_INVOKED\r\n"
    "#include ""targetver.h""\r\n"
    "#endif\r\n"
    "#define APSTUDIO_HIDDEN_SYMBOLS\r\n"
    "#include ""windows.h""\r\n"
    "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n"
    "\0"
END

3 TEXTINCLUDE
BEGIN
    "\r\n"
    "\0"
END

#endif    // APSTUDIO_INVOKED

/
//
// String Table
//

STRINGTABLE
BEGIN
   IDC_HOOKTEST4   "HOOKTEST4"
   IDS_APP_TITLE       "hookTest4"
END

#endif
/



#ifndef APSTUDIO_INVOKED
/
//
// Generated from the TEXTINCLUDE 3 resource.
//

/
#endif    // not APSTUDIO_INVOKED

PeterNote
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SetWindowsHookEx Hook demo
03-21
SetWindowsHookEx 64位，或32位，不同，需要编译各自的库、SetWindowsHookEx 64位，或32位，不同，需要编译各自的库、
SetWinEventHook检测外部程序关闭
11-29
SetWinEventHook 检测程序关闭
SetWindowsHookEx实现DLL注入
06-05
SetWindowsHookEx实现DLL注入
DllInjection_SetWindowsHookEx
04-30
DllInjection_SetWindowsHookEx 参考ReverseCore 在Windows 7 32bit上成功运行 用法： injection.exe ProcessName DataDestinationPath 除非要将DLL注入系统程序，否则请不要以管理员身份运行。
SetWindowsHookEx函数详解
weixin_42887343的博客
03-25 7098
1、函数功能 该函数将一个应用程序定义的挂钩处理过程安装到挂钩链中去,您可以通过安装挂钩处理过程来对系统的某些类型事件进行监控,这些事件与某个特定的线程或系统中的所有事件相关。 所以，为什么要用钩子？ 窗口被强行至于底部或是最小化情况下是得不到焦点的（无法得到鼠标相关事件）。为了响应用户的消息，只能用钩子的方式，获取鼠标消息。 2、函数原型 函数原型： HHOOK SetWindowsHookEx( int idHook, HOOKPROC lpfn,HINSTANCEhMod,DWORD dwTh
SetWinEventHook 事件钩子
magictong的专栏
11-01 1万+
      相信消息钩子大家听的比较多，消息钩子能够在应用程序处理系统消息之前将其截获，提前处理并可以决定是否继续将消息往下传送，有些windows事件并没有消息对应，譬如弹出菜单，切换窗口，获得焦点，滚动条滚动等等，要截获这些事件可以使用SetWinEventHook，它的原型如下：HWINEVENTHOOK WINAPI SetWinEventHook(  __in  UINT event
应用SetWinEventHook截获Windows事件
liuyukuan的专栏
06-21 2193
应用SetWinEventHook截获Windows事件 用SetWindowsHookEx可以截获Windows中的消息，然而对于更高级一点的Windows事件(如:弹出菜单事件、ATL+TAB切换事件等等),可以用SetWinEventHook来截获. SetWinEventHook创建的钩子也分为进程内和进程外两种,进程内钩子效率高但必须以DLL形式存在，因为其须映射到别的进程中.在这个Demo中我采用进程外钩子来截获所有事件。 钩子例程如下所示: VOIDCALL...
追逐自己的梦想----------辅助制作第八课：利用SetWindowsHook将进程注入游戏主线程来解决资源冲突的问题
南的专栏
01-10 8782
本节课中，我们需要学习利用SetWindowsHook来注入主线程，然后利用多线程的原理来解决资源冲突的问题。 1.注入的原因：不同的线程在访问同一个共享数据的时候，如果没有同步处理，就会造成错误，从而导致程序崩溃，所以我们可以给自己编写的多线程，并且加上一些同步出来，然后再将dll注入到游戏的主线程中，就可以解决资源冲突的问题。 我们要用到的函数是SetWindowsHook
SetWindowsHook详解及应用实例
tosim的博客
12-05 2万+
SetWindowsHook详解及应用实例
钩子注入原理讲解（SetWindowsHook注入）
Non_function的博客
01-08 3060
我们想要用自己写的一个函数来接管A程序对某消息的处理，那么首先你这个函数所在的文件，是要在这个A程序里面的，也就是说，SetWindowsHookEx函数，在他下钩子的过程当中，操作系统帮助我们完成了一次注入。 HHOOK SetWindowsHookExA( intidHook, //钩子程序的类型，常用的有WH_KEYBOARD用于钩取键盘消息 HOOKPROC lpfn,//回调函数，就是...
hook_keyboard.zip_SetWindowsHookEx
09-21
简单的键盘记录器，利用HOOK技术，通过API函数SetWindowsHookEx完成的一款键盘记录器，可执行文件是控制台编写
windows hook SetWindowsHookEx 捕获键盘组合键 钩子
最新发布
07-04
windows hook SetWindowsHookEx 捕获键盘组合键 QT ,调出主界面。 组合键配置在./conf/Assist.ini 文件中，目前是M+N 按键。钩子捕获按键.在qt 5.7.0 下编译运行没有问题。
Windows注入之SetWindowsHookEx
weixin_42071117的博客
04-24 966
// console #include <Windows.h> #include <stdio.h> typedef LRESULT (*TestHookProc)(int code, WPARAM wParam, LPARAM lParam); int main() { HWND hwnd = FindWindow(NULL, L"SetWindowHook"); DWORD dwThreadId = 0; DWORD dwProcessId = 0; HMODULE
关于HOOK,如何通过钩子截获指定窗口的所有消息 SetWindowsHookEx demo
q610098308的专栏
09-11 2万+
具体使用见demo , 请注意: 32位只能用win32库， 64位 需要用64位 库。64位可以hook６４位程序，32位可以hook32位程序； SetWindowsHookEx 第三个参数为HINSTANCE，通过FindWindow找到指定窗口句柄后如何 得到该进程的HINSTANCE呢？ 这个参数应该是你调用SetWindowsHookEx的DLL的模块实例句柄...
深入浅出HOOKS（下）
away5678的专栏
04-08 880
2004-2-18加入  来自未知  作者佚名  1条评论  点击3046次        利用VB建立鼠标键盘操作回放    很多的教学软件或系统监视软件可以自动记录回放用户的输入文字或点击按钮等操作操作，这个功能的实现是使用了Windows的Hook函数。本文介绍如何通
SetWinEventHook应用于进程注入
Fzuim的博客
12-31 1850
SetWinEventHook 函数原型： HWINEVENTHOOK SetWinEventHook( DWORD eventMin, DWORD eventMax, HMODULE hmodWinEventProc, WINEVENTPROC pfnWinEventProc, DWORD idProcess, DWOR...
《MFC编程》：钩子函数
ProgramNovice的博客
02-05 683
《MFC编程》：钩子函数
SetWindowsHookEx详解
mmllkkjj的专栏
07-23 4万+
http://apps.hi.baidu.com/share/detail/23903142 SetWindowsHookEx详解 2010-06-17 18:21 函数功能:该函数将一个应用程序定义的挂钩处理过程安装到挂钩链中去,您可以通过安装挂钩处理过程来对系统的某些类型事件进行监控,这些事件与某个特定的线程或系统中的所有事件相关. 函数原形:HHOOK SetWindow
PYTHON编码转换小记
热门推荐
Peter的专栏
12-27 5万+
# -*- coding: gb2312 -*- # 16进制字符串->10进制数值，8进制字符串->10进制数值，2进制字符串->10进制数值 print "16进制字符串->10进制数值，8进制字符串->10进制数值，2进制字符串->10进制数值" print int("61", 16), int("141", 8), int("1100001", 2) # 10进制数值->16进制字符串
SetWindowsHookEx
06-11
`SetWindowsHookEx`是一个Windows API函数，用于安装一个全局的或局部的钩子函数。该函数可以用于截获和处理系统和应用程序的消息和事件，比如键盘、鼠标、消息等。使用钩子函数可以实现一些高级的功能，如键盘记录、鼠标跟踪、窗口监控等。 `SetWindowsHookEx`的函数原型如下： ```c++ HHOOK SetWindowsHookEx( int idHook, HOOKPROC lpfn, HINSTANCE hMod, DWORD dwThreadId ); ``` 其中，参数含义如下： - `idHook`：指定需要安装的钩子类型，可以使用以下常量中的一个或多个来指定钩子类型： - `WH_KEYBOARD`：键盘钩子。 - `WH_MOUSE`：鼠标钩子。 - `WH_CALLWNDPROC`：消息钩子。 - `WH_CBT`：窗口钩子。 - `WH_GETMESSAGE`：获取消息钩子。 - `WH_JOURNALRECORD`：记录钩子。 - `WH_KEYBOARD_LL`：低级键盘钩子。 - `WH_MOUSE_LL`：低级鼠标钩子。 - `lpfn`：指定钩子函数的地址，该函数的原型为`LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam)`，其中`nCode`表示钩子类型，`wParam`和`lParam`表示传递给钩子函数的消息和事件参数。钩子函数必须返回一个值，具体取决于钩子类型。 - `hMod`：指定包含钩子函数的模块的句柄，通常可以设置为NULL。 - `dwThreadId`：指定需要安装钩子的线程ID，如果为0，则表示钩子函数将被安装到系统的所有线程中，为全局钩子。 例如，以下代码安装一个键盘钩子： ```c++ HHOOK hHook = SetWindowsHookEx(WH_KEYBOARD, HookProc, NULL, 0); ``` 需要注意的是，安装钩子函数需要有足够的权限，并且需要谨慎使用，不当的使用可能会对系统和应用程序的稳定性产生不良影响。同时，安装钩子函数后，需要在使用完毕后及时卸载，否则可能会导致钩子函数一直运行，耗费系统资源。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值