/// <summary> /// Low-level mouse hook procedure /// The system call this function every time a new mouse input event is /// about to be posted into a thread input queue. The mouse input can come /// from the local mouse driver or from calls to the mouse_event function. /// If the input comes from a call to mouse_event, the input was /// "injected". However, the WH_MOUSE_LL hook is not injected into another /// process. Instead, the context switches back to the process that /// installed the hook and it is called in its original context. Then the /// context switches back to the application that generated the event. /// </summary> /// <param name="nCode"> /// The hook code passed to the current hook procedure. /// When nCode equals HC_ACTION, the wParam and lParam parameters contain /// information about a mouse message. /// </param> /// <param name="wParam"> /// This parameter can be one of the following messages: /// WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MOUSEMOVE, WM_MOUSEWHEEL, /// WM_MOUSEHWHEEL, WM_RBUTTONDOWN, or WM_RBUTTONUP. /// </param> /// <param name="lParam">Pointer to an MSLLHOOKSTRUCT structure.</param> /// <returns></returns> /// <see cref="http://msdn.microsoft.com/en-us/library/ms644986.aspx"/> public int LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { // Marshal the MSLLHOOKSTRUCT data from the callback lParam MSLLHOOKSTRUCT mouseLLHookStruct = (MSLLHOOKSTRUCT) Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)); // Get the mouse WM from the wParam parameter MouseMessage wmMouse = (MouseMessage)wParam; MouseMessage left = (MouseMessage)WM_LBUTTONDOWN; MouseMessage right = (MouseMessage)WM_RBUTTONDOWN; if (wmMouse == left || wmMouse == right)/* It does the same thing as a panic they does */ { bufferObj.Clear(); WriteAndClearTuple_nTimer(); } } // Pass the hook information to the next hook procedure in chain return(WindowsAPI.CallNextHookEx(hGlobalLLMouseHook, nCode, wParam, lParam)); }
public int LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { // Marshal the KeyboardHookStruct data from the callback lParam KBDLLHOOKSTRUCT keyboardLLHookStruct = (KBDLLHOOKSTRUCT) Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT)); Keys vkCode = (Keys)keyboardLLHookStruct.vkCode; KeyboardMessage wmKeyboard = (KeyboardMessage)wParam; // Get the keyboard WM from the wParam parameter typeOfPressedKey = InputUtils.GetKeyType(vkCode);//Gets a type of pressed key TriggerFlagsInitialization(typeOfPressedKey, vkCode, wmKeyboard); if (typeOfPressedKey == "system") { for (int i = 0; i < InputUtils.systemKeys.Length; i++)// Have to check every possible trigger key { TriggerFlags(vkCode, InputUtils.ReturnSystemKey(i), wmKeyboard, i); } } if (wmKeyboard == keyUp || wmKeyboard == keyUpSys) { mainController.LastKeyPressed_LiftOff(vkCode); } if (wmKeyboard == keyDown || wmKeyboard == keyDownSys) { try { ExeUtils.AsyncGetExeID(); } catch (Exception) { /* In case of failure keeps old one */ } /* Sets up timer and stopwatch. Can't time timer */ if (!userLevelTimer.Enabled) { userLevelTimer.Enabled = true; userLevelTimer.Start(); timer2.Start(); } if (!inputStopWatch.IsRunning) { inputStopWatch.Start(); } int timePassed = (int)inputStopWatch.ElapsedMilliseconds; if (ExeUtils.isTrackable) { mainController.AddToInputBuffer(vkCode, timePassed, ExeUtils.exeID, typeOfPressedKey); } switch (typeOfPressedKey) { case "system": /* in case there's stuff to do */ break; case "panic": bufferObj.Clear(); WriteAndClearTuple_nTimer(); break; case "rule": if (bufferObj.Count() > 0) { int key = 0; /* WHEN BACKSPACE */ if (vkCode == Keys.Delete) { key = 1; /* WHEN DELETE */ } if (rules.OneWordValidation(vkCode, bufferObj)) /* Checks if space wasn't deleted. If it was just save to db */ { SortTupleList(); WriteAndClearTuple_nTimer(); } if (bufferObj.ValidateBounds(key)) /* */ { preDeleteBuffer.Add(bufferObj.GetInputForMistakes(vkCode)); tupleBuffer = rules.RuleKey(vkCode, tupleBuffer, bufferObj, (int)normalInputSW.ElapsedMilliseconds); bufferObj.SendRuleKeys(vkCode); bufferObj.ruleKeyPressed = true; } else { WriteAndClearTuple_nTimer(); } } break; case "pointer": string triggerFlag = TriggerFlags_Enabled_Keys(); if (triggerFlag != "Sys") { if (triggerFlag == "None") { bufferObj.SendRuleKeys(vkCode); } else if (triggerFlag == "Ctrl") { bufferObj.SendRuleKeys(vkCode, true); } WriteAndClearTuple(); } break; case "normal": if (!flagArray.Contains(true)) { if (bufferObj.ruleKeyPressed == true) { SortTupleList(); if (InputUtils.seperatorKeys.Contains(vkCode)) //space and rest of the buch { WriteAndClearTuple_nTimer(); Action(vkCode, wmKeyboard); } else { string replaceWith = InputUtils.GetCharsFromKeys(vkCode); rules.NormalKey(tupleBuffer, replaceWith, (int)normalInputSW.ElapsedMilliseconds); Action(vkCode, wmKeyboard); } } else { Action(vkCode, wmKeyboard); } } else { WriteAndClearTuple_nTimer(); } if (normalInputSW.IsRunning) { normalInputSW.Restart(); } else { normalInputSW.Start(); } break; default: break; } userLevelTimer.Stop(); userLevelTimer.Start(); inputStopWatch.Restart(); } } return(WindowsAPI.CallNextHookEx(hGlobalLLKeyboardHook, nCode, wParam, lParam)); }