Текущий контроль за системными событиями

Пример ниже использует ряд конкретных для потока процедур фильтра (hook), чтобы осуществлять текущий контроль за событиями в системе, влияющими на поток. Он демонстрирует, как обрабатывать события нижеперечисленными  типами  процедур фильтра (hook):

Пользователь может установить и удалить процедуру фильтра (hook), используя меню. Когда процедура фильтра (hook) устанавливается, а событие, которое проверяется процедурой, происходит, процедура пишет информацию о событии в рабочей области главного окна приложения.

Демонстрационный пример

#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); 
 
        // Инициализируем структуры с данными фильтра (hook). 
        // Пункты меню в заголовочном файле определяется от 
        // 0 до 6. Они могут использоваться для идентификации 
        // элементов массива и здесь, и в ходе сообщения 
        // WM_COMMAND. 
 
            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)) 
            { 
                 // Пользователь выбирает команду фильтра (hook) 
                 // в меню. 
 
                case IDM_CALLWNDPROC: 
                case IDM_CBT: 
                case IDM_DEBUG: 
                case IDM_GETMESSAGE: 
                case IDM_KEYBOARD: 
                case IDM_MOUSE: 
                case IDM_MSGFILTER: 
 
                  // Используем идентификатор пункта меню как
                  // внутренний индекс в массиве структур
                  // с данными фильтра (hook). 
 
                    index = LOWORD(wParam); 
 
                 // Если выбирается тип процедуры фильтра 
                 // (hook), не устанавливайте еще раз 
                 // установленный тип и проверим связь 
                 // с пунктом меню. 
 
                    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; 
                    } 
 
                  // Если выбранный тип процедуры фильтра (hook) 
                  // уже установлен, удаляем его и удаляем "галочку"
                  // из окошка, связанного с пунктом меню. 
 
                    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),  
            cch = wsprintf(szCWPBuf, 
               "CALLWNDPROC - tsk: %ld, msg: %s, %d times   ", 
                wParam, szMsg, c++);
			if (FAILED(hResult))
			{
			// завершаем по ошибке безопасно
                        // насколько это возможно
				return;
			}
			hResult = StringCchLength(szCWPBuf, 
                                       256/sizeof(TCHAR), pcch);
			if (FAILED(hResult))
			{
			// завершаем по ошибке безопасно
                        // насколько это возможно
				return;
			} 
            TextOut(hdc, 2, 15, szCWPBuf, *pcch); 
            break; 
 
        default: 
            break; 
    } 
 
    ReleaseDC(hwndMain, hdc); 
    return CallNextHookEx(myhookdata[CALLWNDPROC].hhook, nCode, 
        wParam, lParam); 
}
/**************************************************************** 
  Процедура фильтра(hook)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))
		{
		// завершаем по ошибке безопасно
                // насколько это возможно
		return;
		} 
                    break; 
 
                case PM_NOREMOVE:
		hResult = StringCchCopy(szRem, 16/sizeof(TCHAR), 
					"PM_NOREMOVE");
		if (FAILED(hResult))
		{
		// завершаем по ошибке безопасно
                // насколько это возможно
		return;
		} 
                    break; 
 
                default:
		hResult = StringCchCopy(szRem, 16/sizeof(TCHAR),
					 "Unknown");
		if (FAILED(hResult))
		{
		// завершаем по ошибке безопасно
                // насколько это возможно
		return;
		} 
                    break; 
            } 
 
         // Вызываем определяемую программой функцию, которая 
         // преобразует константу сообщения в символьную строку
         // и копирует ее в буфер. 
 
            LookUpTheMessage((PMSG) lParam, szMsg); 
 
            hdc = GetDC(hwndMain);
			hResult = StringCchPrintf(szMSGBuf, 
                                         256/sizeof(TCHAR), 
            cch = wsprintf(szMSGBuf, 
                "GETMESSAGE - wParam: %s, msg: %s, %d times   ", 
                szRem, szMsg, c++);
			if (FAILED(hResult))
			{
			// завершаем по ошибке безопасно
                        // насколько это возможно
				return;
			}
			hResult = StringCchLength(szMSGBuf, 
                                   256/sizeof(TCHAR), pcch);
			if (FAILED(hResult))
			{
			// завершаем по ошибке безопасно
                        // насколько это возможно
				return;
			} 
            TextOut(hdc, 2, 35, szMSGBuf, *pcch); 
            break; 
 
        default: 
            break; 
    } 
 
    ReleaseDC(hwndMain, hdc); 
    return CallNextHookEx(myhookdata[GETMESSAGE].hhook, nCode, 
        wParam, lParam); 
} 
/**************************************************************** 
  Процедура фильтра (hook) 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),  
            cch = wsprintf(szBuf, 
                "DEBUG - nCode: %d, tsk: %ld, %d times   ", 
                nCode,wParam, c++);
			if (FAILED(hResult))
			{
			// завершаем по ошибке безопасно
                        // насколько это возможно
				return;
			}
			hResult = StringCchLength(szBuf, 
                                     128/sizeof(TCHAR), pcch);
			if (FAILED(hResult))
			{
			// завершаем по ошибке безопасно
                        // насколько это возможно
				return;
			} 
            TextOut(hdc, 2, 55, szBuf, *pcch); 
            break; 
 
        default: 
            break; 
    } 
 
    ReleaseDC(hwndMain, hdc); 
    return CallNextHookEx(myhookdata[DEBUG].hhook, nCode, wParam, 
        lParam); 
} 
 
/**************************************************************** 
  Процедура фильтра (hook) 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))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
		} 
            break; 
 
        case HCBT_CLICKSKIPPED:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), 
				"HCBT_CLICKSKIPPED");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case HCBT_CREATEWND:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), 
				"HCBT_CREATEWND");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case HCBT_DESTROYWND:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), 
				"HCBT_DESTROYWND");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case HCBT_KEYSKIPPED:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), 
				"HCBT_KEYSKIPPED");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case HCBT_MINMAX:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), 
				"HCBT_MINMAX");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case HCBT_MOVESIZE:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR),
				 "HCBT_MOVESIZE");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case HCBT_QS:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR),
				 "HCBT_QS");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case HCBT_SETFOCUS:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR),
                                "HCBT_SETFOCUS");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case HCBT_SYSCOMMAND:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR),
                               "HCBT_SYSCOMMAND");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        default:
	hResult = StringCchCopy(szCode, 128/sizeof(TCHAR), 
                                "Unknown");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
    } 
	hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR), 
                   "CBT -  nCode: %s, tsk: %ld, %d times   ",
 
    cch = wsprintf(szBuf, "CBT - nCode: %s, tsk: %ld,
                   %d times   ", szCode, wParam, c++);
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
		return;
	}
	hResult = StringCchLength(szBuf, 
                                  128/sizeof(TCHAR), pcch);
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
		return;
	} 
    TextOut(hdc, 2, 75, szBuf, *pcch); 
    ReleaseDC(hwndMain, hdc); 
    return CallNextHookEx(myhookdata[CBT].hhook, nCode, wParam, 
        lParam); 
} 
 
/**************************************************************** 
  Процедура фильтра (hook) 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), 
    cch = wsprintf(szBuf, 
        "MOUSE - nCode: %d, msg: %s, x: %d, y: %d, %d times   ", 
        nCode, szMsg, LOWORD(lParam), HIWORD(lParam), c++); 
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
		return;
	}
	hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
		return;
	}
    TextOut(hdc, 2, 95, szBuf, *pcch); 
    ReleaseDC(hwndMain, hdc); 
    return CallNextHookEx(myhookdata[MOUSE].hhook, nCode, wParam, 
        lParam); 
} 
 
/**************************************************************** 
  Процедура фильтра (hook) 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++);
    cch = wsprintf(szBuf, "KEYBOARD - nCode: %d, vk: %d, %d times ", 
        nCode, wParam, c++);
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
		return;
	} 
	hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
		return;
	} 
    TextOut(hdc, 2, 115, szBuf, *pcch); 
    ReleaseDC(hwndMain, hdc); 
    return CallNextHookEx(myhookdata[KEYBOARD].hhook, nCode, wParam, 
        lParam); 
} 
 
/**************************************************************** 
  Процедура фильтра (hook)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))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case MSGF_MENU:
	hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), 
				"MSGF_MENU");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        case MSGF_SCROLLBAR:
	hResult = StringCchCopy(szCode, 32/sizeof(TCHAR), 
				"MSGF_SCROLLBAR");
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
	return;
	} 
            break; 
 
        default:
	hResult = StringCchPrintf(szCode, 128/sizeof(TCHAR), 
					"Unknown: %d", nCode);
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
		return;
	}
            break; 
    } 
 
   // Вызываем определяемую программой функцию, которая 
   // преобразует константу сообщения в символьную строку
   // и копирует ее в буфер. 
    LookUpTheMessage((PMSG) lParam, szMsg); 
 
    hdc = GetDC(hwndMain);
	hResult = StringCchPrintf(szBuf, 128/sizeof(TCHAR), 
    cch = wsprintf(szBuf, 
        "MSGFILTER  nCode: %s, msg: %s, %d times    ", 
        szCode, szMsg, c++);
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
		return;
	} 
	hResult = StringCchLength(szBuf, 128/sizeof(TCHAR), pcch);
	if (FAILED(hResult))
	{
	// завершаем по ошибке безопасно
        // насколько это возможно
		return;
	} 
    TextOut(hdc, 2, 135, szBuf, *pcch); 
    ReleaseDC(hwndMain, hdc); 
    return CallNextHookEx(myhookdata[MSGFILTER].hhook, nCode, 
        wParam, lParam); 
} 

 

Назад в оглавление
На главную страницу

Hosted by uCoz