Использование Ловушек
Страница 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);
 
« Предыдущая статья   Следующая статья »