/** * Run the command, we take into account the current selection and command parameters given. * @param CWnd* pWnd the last forground window. * @param const MYODD_STRING& szCommandLine the command line argument. * @param bool isPrivileged if we need administrator privilege to run this. * @return BOOL true. */ ActiveAction* Action::CreateActiveAction(CWnd* pWnd, const MYODD_STRING& szCommandLine, bool isPrivileged) const { // not sure how to do that... if ( Len() == 0) { return nullptr; } // we are about to execute a command, we don't know how long the command will last // a badly written plugin could take forever to return. BOOL bThen = hook_RejectKeyboad( FALSE ); // if we are here then we are going to load a user command // // If the user did not pass any arguments/command line then we must get them from the clipboard. ActiveAction* aa; if( szCommandLine.length() == 0 ) { aa = CreateActiveActionWithNoCommandLine( pWnd, isPrivileged); } else { // so now, at last we can call the command line aa = CreateActiveActionDirect( pWnd, szCommandLine.c_str(), isPrivileged); } // now that we are back from calling the plugin, restore the keyboard state. hook_RejectKeyboad( bThen ); return aa; }
LRESULT HookWnd::OnHookKeyUp(WPARAM wParam, LPARAM lParam) { TRACE("KeyUp 0x%x\n", wParam); // check the key that the user had released // if it the special key then tell the user that the key is no longer down if (IsSpecialKey(wParam)) { // the key is no longer down // but was it down at all to start with? - (sanity check) if ((_keyState & ACTION_MAINKEY_DOWN) == ACTION_MAINKEY_DOWN) { // remove the fact that the key was pressed. // do that next time we come around here we don't do it again _keyState &= ~ACTION_MAINKEY_DOWN; // execute the command _application.ExecuteCurrentAction(); // we are hidding the current action _actions.CurrentActionReset(); // hide the window _display.Hide(); // tell the system that we can now accept key press hook_RejectKeyboad(FALSE); _display.Inactive(); } } switch (wParam) { case VK_SHIFT: case VK_RSHIFT: case VK_LSHIFT: _keyState &= ~ACTION_SHIFT_DOWN; _keyState &= ~ACTION_LSHIFT_DOWN; break; default: break; } /** * The WM_KEYUP message is posted to the window with the keyboard focus when a nonsystem key is released. * A nonsystem key is a key that is pressed when the ALT key is not pressed, * or a keyboard key that is pressed when a window has the keyboard focus. */ return 0L; }
LRESULT HookWnd::OnHookKeyDown(WPARAM wParam, LPARAM lParam) { TRACE("KeyDown 0x%x\n", wParam); /** * The WM_KEYDOWN message is posted to the window with the keyboard focus when a nonsystem key is pressed. * A nonsystem key is a key that is pressed when the ALT key is not pressed. */ // if it is the special key then tell the system that from now own // we need to record keys and prevent any other key from passing accross. if (IsSpecialKey(wParam)) { // only do it if the key was NOT down previously. // otherwise we will forever be reseting if ((_keyState & ACTION_MAINKEY_DOWN) != ACTION_MAINKEY_DOWN) { // we need to save the last forground window // because showing our dialog box will change things a bit. _application.SetLastForegroundWindow( ); // tell the system to no longer accept any more key _keyState |= ACTION_MAINKEY_DOWN; hook_RejectKeyboad(TRUE); _display.Active(); // reset the last command _actions.CurrentActionReset(); _display.Show( _actions.ToChar() ); } } // if the special key is not down then we don't need to go any further if ((_keyState & ACTION_MAINKEY_DOWN) != ACTION_MAINKEY_DOWN) { return 0L; } switch (wParam) { case VK_BACK: // backspace _actions.CurrentActionBack(); _display.Show( _actions.ToChar() ); break; case 0x0A: // linefeed case VK_TAB: // tab case VK_RETURN: // carriage return case VK_CLEAR: break; case VK_ESCAPE: _actions.CurrentActionReset(); _display.Show( _actions.ToChar() ); break; case VK_DOWN: _actions.down(); _display.Show( _actions.ToChar() ); break; case VK_CAPITAL: break; case VK_UP: _actions.up(); _display.Show( _actions.ToChar() ); break; case VK_SHIFT: case VK_RSHIFT: _keyState |= ACTION_SHIFT_DOWN; break; case VK_LSHIFT: _keyState |= (ACTION_SHIFT_DOWN | ACTION_LSHIFT_DOWN); break; default: { BYTE ks[256]; memset(ks, 0, sizeof(ks)); GetKeyboardState(ks); WORD w; UINT scan = 0; ks[VK_SHIFT] = 1; if ((_keyState & ACTION_SHIFT_DOWN) == ACTION_SHIFT_DOWN) { // force the shift key down. // the low level keyboad does not alway pass the key(shift) before the letter key // so we might not know that the shift key is pressed. // so we set it here. ks[VK_SHIFT] = 129; } if (0 != ToAscii(wParam, scan, ks, &w, 0)) { const auto c = static_cast<TCHAR>(CHAR(w)); // add the current character to the list of items _actions.CurrentActionAdd(c); // make sure that the window is visible // This will also force a refresh of the window _display.Show( _actions.ToChar() ); } } break; } return 0L; }