Использование Ловушек
Страница 2.

Пример

#define NUMHOOKS 7

// Глобальные переменные

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:
 
 // Сохраняем дескриптор меню.

 hmenu = GetMenu(hwndMain);

 // Инициализируем структуры данными ловушки. Пункты меню
 // определены в заголовочном файле с номерами с 0 по 6
 
 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;

 // Выставляем все флаги массива в FALSE.

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

 return 0;
 
 case WM_COMMAND:
 switch (LOWORD(wParam))
 {
 // Пользователь выбирает ловушку из меню.

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

 // Используем номера пунктов меню в качестве индекса
 // в массиве структур с данными ловушки.

 index = LOWORD(wParam); 

 // Если ловушка выбранного типа не установлена,
 // то устанавливаем её и добавляем галочку к
 // соответствующему пункту меню.

 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;
 }

 // Если ловушка выбранного типа уже установлена,
 // то удаляем её и убираем галочку в соответствующем
 // пункте меню.

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

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

 //
 // Обрабатываем другие сообщения.
 //

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

/****************************************************************
 Процедура ловушки WH_CALLWNDPROC
 ****************************************************************/

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

 if (nCode < 0) // не обрабатываем сообщение
 return CallNextHookEx(myhookdata[CALLWNDPROC].hhook, nCode,
 wParam, lParam);

 // Вызываем функцию, которая преобразует константу сообщения в
 // строку и копирует её буфер.

 LookUpTheMessage((PMSG) lParam, szMsg);

 hdc = GetDC(hwndMain);

 switch (nCode)
 {
 case HC_ACTION:
 hResult = StringCchPrintf(szCWPBuf, 256/sizeof(TCHAR),
 "CALLWNDPROC - tsk: %ld, msg: %s, %d times ",
 wParam, szMsg, c++);
 if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 hResult = StringCchLength(szCWPBuf, 256/sizeof(TCHAR), pcch);
 if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 TextOut(hdc, 2, 15, szCWPBuf, *pcch);
 break;
 
 default:
 break;
 }

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

/****************************************************************
 Процедура ловушки WH_GETMESSAGE
 ****************************************************************/

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

 if (nCode < 0) // не обрабатываем сообщение
 return CallNextHookEx(myhookdata[GETMESSAGE].hhook, nCode,
 wParam, lParam);

 switch (nCode)
 {
 case HC_ACTION:
 switch (wParam)
 {
 case PM_REMOVE:
 hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), "PM_REMOVE");
 if (FAILED(hResult))
{
// обработчик ошибки
}
 break;
 
 case PM_NOREMOVE:
 hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), "PM_NOREMOVE");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;
 
 default:
hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), "Unknown");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;
 }

 // Вызываем функцию, которая преобразует константу сообщения в
 // строку и копирует её буфер.

 LookUpTheMessage((PMSG) lParam, szMsg);

 hdc = GetDC(hwndMain);
 hResult = StringCchPrintf(szMSGBuf, 256/sizeof(TCHAR),
 "GETMESSAGE - wParam: %s, msg: %s, %d times ",
 szRem, szMsg, c++);
 if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 hResult = StringCchLength(szMSGBuf, 256/sizeof(TCHAR), pcch);
 if (FAILED(hResult))
 {
 // обработчик ошибки
 } 
 TextOut(hdc, 2, 35, szMSGBuf, *pcch);
 break;

 default:
 break;
 } 

 ReleaseDC(hwndMain, hdc);
 return CallNextHookEx(myhookdata[GETMESSAGE].hhook, nCode,
 wParam, lParam); 
} 
 
/****************************************************************
 Процедура ловушки WH_DEBUG
 ****************************************************************/

LRESULT CALLBACK DebugProc(int nCode, WPARAM wParam, LPARAM lParam)
{
 CHAR szBuf[128];
 HDC hdc;
 static int c = 0;
 size_t cch;
size_t * pcch;
HRESULT hResult;
 
 if (nCode < 0) // не обрабатываем сообщение
 return CallNextHookEx(myhookdata[DEBUG].hhook, nCode,
 wParam, lParam);

 hdc = GetDC(hwndMain);

 switch (nCode)
 {
 case HC_ACTION:
hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR), 
 "DEBUG - nCode: %d, tsk: %ld, %d times ", 
 nCode,wParam, c++);
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 TextOut(hdc, 2, 55, szBuf, *pcch);
 break;

 default:
 break;
 }

 ReleaseDC(hwndMain, hdc);
 return CallNextHookEx(myhookdata[DEBUG].hhook, nCode, wParam,
 lParam);
}
 
/**************************************************************** 
 Процедура ловушки WH_CBT
 ****************************************************************/ 

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

 if (nCode < 0) // не обрабатываем сообщение
 return CallNextHookEx(myhookdata[CBT].hhook, nCode, wParam,
 lParam);

 hdc = GetDC(hwndMain);

 switch (nCode)
 {
 case HCBT_ACTIVATE:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_ACTIVATE");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case HCBT_CLICKSKIPPED:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_CLICKSKIPPED");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case HCBT_CREATEWND:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_CREATEWND");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case HCBT_DESTROYWND:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_DESTROYWND");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case HCBT_KEYSKIPPED:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_KEYSKIPPED");
if (FAILED(hResult))
 {
  // обработчик ошибки
 }
 break;

 case HCBT_MINMAX:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_MINMAX");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case HCBT_MOVESIZE:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_MOVESIZE");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case HCBT_QS:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_QS");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case HCBT_SETFOCUS:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_SETFOCUS");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case HCBT_SYSCOMMAND:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "HCBT_SYSCOMMAND");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 default:
hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), "Unknown");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;
 }

 hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR),
 "CBT - nCode: %s, tsk: %ld, %d times ",
 szCode, wParam, c++);

 if (FAILED(hResult))
{
// обработчик ошибки
}
 hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
 if (FAILED(hResult))
{
// обработчик ошибки
} 
 TextOut(hdc, 2, 75, szBuf, *pcch);
 ReleaseDC(hwndMain, hdc);
 return CallNextHookEx(myhookdata[CBT].hhook, nCode, wParam, lParam);
} 

/****************************************************************
 Процедура ловушки WH_MOUSE
 ****************************************************************/

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

 if (nCode < 0) // не обрабатываем сообщение
 return CallNextHookEx(myhookdata[MOUSE].hhook, nCode,
 wParam, lParam);

 // Вызываем функцию, которая преобразует константу сообщения в
 // строку и копирует её буфер.

 LookUpTheMessage((PMSG) lParam, szMsg);

 hdc = GetDC(hwndMain);
hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR),
 "MOUSE - nCode: %d, msg: %s, x: %d, y: %d, %d times ",
 nCode, szMsg, LOWORD(lParam), HIWORD(lParam), c++);
if (FAILED(hResult))
{
// обработчик ошибки
}
hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
if (FAILED(hResult))
{
// обработчик ошибки
}
 TextOut(hdc, 2, 95, szBuf, *pcch);
 ReleaseDC(hwndMain, hdc);
 return CallNextHookEx(myhookdata[MOUSE].hhook, nCode, wParam,
 lParam);
}
 
/****************************************************************
 Процедура ловушки WH_KEYBOARD
 ****************************************************************/

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

 if (nCode < 0) // не обрабатываем сообщение
 return CallNextHookEx(myhookdata[KEYBOARD].hhook, nCode,
 wParam, lParam);

 hdc = GetDC(hwndMain);
hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR),
 "KEYBOARD - nCode: %d, vk: %d, %d times ", nCode, wParam, c++);
if (FAILED(hResult))
{
// обработчик ошибки
}
hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
if (FAILED(hResult))
{
// обработчик ошибки
}
 TextOut(hdc, 2, 115, szBuf, *pcch);
 ReleaseDC(hwndMain, hdc);
 return CallNextHookEx(myhookdata[KEYBOARD].hhook, nCode, wParam,
 lParam);
}
 
/****************************************************************
 Процедура ловушки WH_MSGFILTER
 ****************************************************************/

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

 if (nCode < 0) // не обрабатываем сообщение
 return CallNextHookEx(myhookdata[MSGFILTER].hhook, nCode,
 wParam, lParam);

 switch (nCode)
 {
 case MSGF_DIALOGBOX:
hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), "MSGF_DIALOGBOX");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case MSGF_MENU:
hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), "MSGF_MENU");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 case MSGF_SCROLLBAR:
hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), "MSGF_SCROLLBAR");
if (FAILED(hResult))
 {
 // обработчик ошибки
 }
 break;

 default:
hResult = StringCchPrintf(szCode, 128/sizeof(TCHAR), "Unknown: %d", nCode);
if (FAILED(hResult))
{
// обработчик ошибки
}
 break;
 }

 // Вызываем функцию, которая преобразует константу сообщения в
 // строку и копирует её буфер.

 LookUpTheMessage((PMSG) lParam, szMsg);

 hdc = GetDC(hwndMain);
hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR),
 "MSGFILTER nCode: %s, msg: %s, %d times ",
 szCode, szMsg, c++);
if (FAILED(hResult))
{
// обработчик ошибки
}
hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
if (FAILED(hResult))
{
// обработчик ошибки
}
 TextOut(hdc, 2, 135, szBuf, *pcch);
 ReleaseDC(hwndMain, hdc);
 return CallNextHookEx(myhookdata[MSGFILTER].hhook, nCode,
 wParam, lParam);
}