Google Git
Sign in
chromium / external / github.com / SeleniumHQ / selenium / refs/heads/trunk / . / cpp / iedriver / InputManager.cpp
blob: e7c24cdacff11141b32eead29852a15ede368100 [file] [log] [blame] [edit]
// Licensed to the Software Freedom Conservancy (SFC) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The SFC licenses this file
// to you under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "InputManager.h"
#include <ctime>
#include <codecvt>
#include <locale>
#include "errorcodes.h"
#include "json.h"
#include "keycodes.h"
#include "logging.h"
#include "ActionSimulators/JavaScriptActionSimulator.h"
#include "ActionSimulators/SendInputActionSimulator.h"
#include "ActionSimulators/SendMessageActionSimulator.h"
#include "DocumentHost.h"
#include "Element.h"
#include "HookProcessor.h"
#include "IElementManager.h"
#include "Script.h"
#include "StringUtilities.h"
#include "WebDriverConstants.h"
#include "Generated/atoms.h"
#define USER_INTERACTION_MUTEX_NAME L"WebDriverUserInteractionMutex"
#define WAIT_TIME_IN_MILLISECONDS_PER_INPUT_EVENT 100
#define MOVE_ERROR_TEMPLATE "The requested mouse movement to (%d, %d) would be outside the bounds of the current view port (left: %d, right: %d, top: %d, bottom: %d)"
#define MOVE_OVERFLOW_ERROR_TEMPLATE "The requested ending %s (%lld) would be outside the legal bounds (less than -2147483648 or greater than 2147483647"
#define MODIFIER_KEY_SHIFT 1
#define MODIFIER_KEY_CTRL 2
#define MODIFIER_KEY_ALT 4
// "Key" values for mouse buttons
#define WD_MOUSE_LBUTTON 0xE05EU
#define WD_MOUSE_RBUTTON 0xE05FU
namespace webdriver {
InputManager::InputManager() {
LOG(TRACE) << "Entering InputManager::InputManager";
this->use_native_events_ = true;
this->use_persistent_hover_ = false;
this->require_window_focus_ = true;
this->scroll_behavior_ = TOP;
this->current_input_state_.is_alt_pressed = false;
this->current_input_state_.is_control_pressed = false;
this->current_input_state_.is_shift_pressed = false;
this->current_input_state_.is_meta_pressed = false;
this->current_input_state_.is_left_button_pressed = false;
this->current_input_state_.is_right_button_pressed = false;
this->current_input_state_.mouse_x = 0;
this->current_input_state_.mouse_y = 0;
this->current_input_state_.last_click_time = clock();
this->current_input_state_.error_info = "";
this->action_simulator_ = NULL;
}
InputManager::~InputManager(void) {
if (this->action_simulator_ != NULL) {
delete this->action_simulator_;
}
}
void InputManager::Initialize(InputManagerSettings settings) {
LOG(TRACE) << "Entering InputManager::Initialize";
this->element_map_ = settings.element_repository;
this->scroll_behavior_ = settings.scroll_behavior;
this->use_native_events_ = settings.use_native_events;
this->use_persistent_hover_ = settings.enable_persistent_hover;
this->require_window_focus_ = settings.require_window_focus;
if (settings.use_native_events) {
if (settings.require_window_focus) {
this->action_simulator_ = new SendInputActionSimulator();
} else {
this->action_simulator_ = new SendMessageActionSimulator();
}
} else {
this->action_simulator_ = new JavaScriptActionSimulator();
}
this->SetupKeyDescriptions();
}
int InputManager::PerformInputSequence(BrowserHandle browser_wrapper,
const Json::Value& sequences,
std::string* error_info) {
LOG(TRACE) << "Entering InputManager::PerformInputSequence";
if (!sequences.isArray()) {
return EUNHANDLEDERROR;
}
int status_code = WD_SUCCESS;
// Use a single mutex, so that all instances synchronize on the same object
// for focus purposes.
HANDLE mutex_handle = this->AcquireMutex();
Json::Value ticks(Json::arrayValue);
status_code = this->GetTicks(sequences, &ticks);
if (status_code != WD_SUCCESS) {
this->ReleaseMutex(mutex_handle);
return status_code;
}
this->inputs_.clear();
this->current_input_state_.last_click_time = 0;
InputState current_input_state = this->CloneCurrentInputState();
for (size_t i = 0; i < ticks.size(); ++i) {
Json::UInt tick_index = static_cast<Json::UInt>(i);
Json::Value tick = ticks[tick_index];
for (size_t j = 0; j < tick.size(); ++j) {
Json::UInt action_index = static_cast<Json::UInt>(j);
Json::Value action = tick[action_index];
std::string action_subtype = action["type"].asString();
if (action_subtype == "pointerMove") {
status_code = this->PointerMoveTo(browser_wrapper, action, &current_input_state);
} else if (action_subtype == "pointerDown") {
status_code = this->PointerDown(browser_wrapper, action, &current_input_state);
} else if (action_subtype == "pointerUp") {
status_code = this->PointerUp(browser_wrapper, action, &current_input_state);
} else if (action_subtype == "keyDown") {
status_code = this->KeyDown(browser_wrapper, action, &current_input_state);
} else if (action_subtype == "keyUp") {
status_code = this->KeyUp(browser_wrapper, action, &current_input_state);
} else if (action_subtype == "pause") {
status_code = this->Pause(browser_wrapper, action);
}
if (status_code != WD_SUCCESS) {
this->ReleaseMutex(mutex_handle);
*error_info = current_input_state.error_info;
return status_code;
}
}
}
// If there are inputs in the array, then we've queued up input actions
// to be played back. So play them back.
if (this->inputs_.size() > 0) {
LOG(DEBUG) << "Processing a total of " << this->inputs_.size() << " input events";
this->action_simulator_->SimulateActions(browser_wrapper,
this->inputs_,
&this->current_input_state_);
}
::Sleep(50);
this->ReleaseMutex(mutex_handle);
return status_code;
}
int InputManager::GetTicks(const Json::Value& sequences, Json::Value* ticks) {
for (size_t i = 0; i < sequences.size(); ++i) {
Json::UInt index = static_cast<Json::UInt>(i);
Json::Value device_sequence = sequences[index];
if (!device_sequence.isMember("type") && !device_sequence["type"].isString()) {
return EINVALIDARGUMENT;
}
std::string device_type = device_sequence["type"].asString();
if (device_type != "key" && device_type != "pointer" && device_type != "none") {
return EINVALIDARGUMENT;
}
if (!device_sequence.isMember("id") && !device_sequence["id"].isString()) {
return EINVALIDARGUMENT;
}
std::string device_id = device_sequence["id"].asString();
if (!device_sequence.isMember("actions") && !device_sequence["actions"].isArray()) {
return EINVALIDARGUMENT;
}
// TODO: Add guards against bad action structure. Assume correct input for now.
Json::Value actions = device_sequence["actions"];
for (size_t j = 0; j < actions.size(); ++j) {
if (ticks->size() <= j) {
Json::Value tick(Json::arrayValue);
ticks->append(tick);
}
Json::UInt action_index = static_cast<Json::UInt>(j);
Json::Value action = actions[action_index];
if (action.isMember("type") &&
action["type"].isString() &&
action["type"].asString() == "pause") {
if (action.isMember("duration") &&
(action["duration"].type() != Json::ValueType::intValue ||
action["duration"].asInt() < 0)) {
return EINVALIDARGUMENT;
}
if (device_type == "key") {
// HACK! Ignore the duration of pause events in keyboard action
// sequences. This is deliberately in violation of the W3C spec.
// This allows us to better synchronize mixed keyboard and mouse
// action sequences.
action["duration"] = 10;
}
}
(*ticks)[action_index].append(action);
}
}
return WD_SUCCESS;
}
HANDLE InputManager::AcquireMutex() {
HANDLE mutex_handle = ::CreateMutex(NULL, FALSE, USER_INTERACTION_MUTEX_NAME);
if (mutex_handle != NULL) {
// Wait for up to the timeout (currently 30 seconds) for the mutex to be
// released.
DWORD mutex_wait_status = ::WaitForSingleObject(mutex_handle, 30000);
if (mutex_wait_status == WAIT_ABANDONED) {
LOG(WARN) << "Acquired mutex, but received wait abandoned status. This "
<< "could mean the process previously owning the mutex was "
<< "unexpectedly terminated.";
}
else if (mutex_wait_status == WAIT_TIMEOUT) {
LOG(WARN) << "Could not acquire mutex within the timeout. Multiple "
<< "instances may have incorrect synchronization for interactions";
}
else if (mutex_wait_status == WAIT_OBJECT_0) {
LOG(DEBUG) << "Mutex acquired for user interaction.";
}
}
else {
LOG(WARN) << "Could not create user interaction mutex. Multiple "
<< "instances of IE may behave unpredictably.";
}
return mutex_handle;
}
void InputManager::ReleaseMutex(HANDLE mutex_handle) {
if (mutex_handle != NULL) {
::ReleaseMutex(mutex_handle);
::CloseHandle(mutex_handle);
}
}
InputState InputManager::CloneCurrentInputState(void) {
InputState current_input_state;
current_input_state.is_alt_pressed = this->current_input_state_.is_alt_pressed;
current_input_state.is_control_pressed = this->current_input_state_.is_control_pressed;
current_input_state.is_shift_pressed = this->current_input_state_.is_shift_pressed;
current_input_state.is_meta_pressed = this->current_input_state_.is_meta_pressed;
current_input_state.is_left_button_pressed = this->current_input_state_.is_left_button_pressed;
current_input_state.is_right_button_pressed = this->current_input_state_.is_right_button_pressed;
current_input_state.mouse_x = this->current_input_state_.mouse_x;
current_input_state.mouse_y = this->current_input_state_.mouse_y;
current_input_state.error_info = this->current_input_state_.error_info;
return current_input_state;
}
void InputManager::Reset(BrowserHandle browser_wrapper) {
LOG(TRACE) << "Entering InputManager::Reset";
LOG(DEBUG) << "Releasing " << this->pressed_keys_.size() << " keys";
std::vector<wchar_t> local_pressed_keys(this->pressed_keys_);
HWND browser_window_handle = browser_wrapper->GetContentWindowHandle();
InputState current_input_state = this->CloneCurrentInputState();
this->inputs_.clear();
std::vector<wchar_t>::const_reverse_iterator it = local_pressed_keys.rbegin();
for (; it != local_pressed_keys.rend(); ++it) {
std::wstring key_value = L"";
key_value.append(1, *it);
std::wstring key_description = this->GetKeyDescription(*it);
LOG(DEBUG) << "Key: " << LOGWSTRING(key_description);
if (*it == WD_MOUSE_LBUTTON) {
this->AddMouseInput(browser_window_handle, MOUSEEVENTF_LEFTUP, 0, 0);
} else if (*it == WD_MOUSE_RBUTTON) {
this->AddMouseInput(browser_window_handle, MOUSEEVENTF_RIGHTUP, 0, 0);
} else {
this->AddKeyboardInput(browser_window_handle,
key_value,
true,
&current_input_state);
}
}
// If there are inputs in the array, then we've queued up input actions
// to be played back. So play them back.
if (this->inputs_.size() > 0) {
LOG(DEBUG) << "Processing a total of " << this->inputs_.size() << " input events";
this->action_simulator_->SimulateActions(browser_wrapper,
this->inputs_,
&this->current_input_state_);
}
::Sleep(50);
if (this->current_input_state_.mouse_x > 0 ||
this->current_input_state_.mouse_y > 0) {
LOG(DEBUG) << "Resetting mouse position";
this->current_input_state_.mouse_x = 0;
this->current_input_state_.mouse_y = 0;
}
if (this->pressed_keys_.size() > 0) {
LOG(WARN) << "Pressed keys should have been empty, but had " << this->pressed_keys_.size() << " values.";
this->pressed_keys_.clear();
}
}
int InputManager::PointerMoveTo(BrowserHandle browser_wrapper,
const Json::Value& move_to_action,
InputState* input_state) {
LOG(TRACE) << "Entering InputManager::PointerMoveTo";
int status_code = WD_SUCCESS;
bool element_specified = false;
std::string origin = "viewport";
if (move_to_action.isMember("origin")) {
Json::Value origin_value = move_to_action["origin"];
if (origin_value.isString()) {
origin = origin_value.asString();
} else if (origin_value.isObject() && origin_value.isMember(JSON_ELEMENT_PROPERTY_NAME)) {
origin = origin_value[JSON_ELEMENT_PROPERTY_NAME].asString();
element_specified = true;
}
}
long x_offset = 0;
if (move_to_action.isMember("x") && move_to_action["x"].isInt()) {
x_offset = move_to_action["x"].asInt();
}
long y_offset = 0;
if (move_to_action.isMember("y") && move_to_action["y"].isInt()) {
y_offset = move_to_action["y"].asInt();
}
bool offset_specified = move_to_action.isMember("x") &&
move_to_action.isMember("y") &&
(x_offset != 0 || y_offset != 0);
long duration = 100;
if (move_to_action.isMember("duration") && move_to_action["duration"].isInt()) {
duration = move_to_action["duration"].asInt();
}
ElementHandle target_element;
if (element_specified) {
status_code = this->element_map_->GetManagedElement(origin, &target_element);
if (status_code != WD_SUCCESS) {
return status_code;
}
}
if (this->action_simulator_->UseExtraInfo()) {
MouseExtraInfo* extra_info = new MouseExtraInfo();
if (element_specified) {
extra_info->element = target_element->element();
} else {
extra_info->element = NULL;
}
extra_info->offset_specified = offset_specified;
extra_info->offset_x = x_offset;
extra_info->offset_y = y_offset;
INPUT mouse_input;
mouse_input.type = INPUT_MOUSE;
mouse_input.mi.dwFlags = MOUSEEVENTF_MOVE;
mouse_input.mi.dx = 0;
mouse_input.mi.dy = 0;
mouse_input.mi.dwExtraInfo = reinterpret_cast<ULONG_PTR>(extra_info);
mouse_input.mi.mouseData = 0;
mouse_input.mi.time = 0;
this->inputs_.push_back(mouse_input);
} else {
long start_x = input_state->mouse_x;
long start_y = input_state->mouse_y;
long end_x = start_x;
long end_y = start_y;
if (element_specified) {
LocationInfo element_location;
// Note: The caller of the action sequence is responsible for making
// sure the target element is in the view port. In particular, the
// high-level click and sendKeys implementations do this in their
// command handlers. Further note that offsets specified in this
// move action will be relative to the center of the element as
// calculated here.
status_code = target_element->GetStaticClickLocation(&element_location);
// We can't use the status code alone here. Even though the center of the
// element may not reachable via the mouse, we might still be able to move
// to whatever portion of the element *is* visible in the viewport, especially
// if we have an offset specifed, so we have to have an extra check.
if (status_code != WD_SUCCESS) {
if (status_code == EELEMENTCLICKPOINTNOTSCROLLED && !offset_specified) {
// If no offset is specified (meaning "move to the element's center"),
// and the "could not scroll center point into view" status code is
// returned, bail out here.
LOG(WARN) << "No offset was specified, and the center point of the element could not be scrolled into view.";
return status_code;
} else {
LOG(WARN) << "Element::GetStaticClickLocation() returned an error code indicating the element is not reachable.";
return status_code;
}
}
// An element was specified as the starting point, so we know the end of the mouse
// move will be at some offset from the element origin.
end_x = element_location.x;
end_y = element_location.y;
}
if (origin == "viewport") {
end_x = x_offset;
end_y = y_offset;
} else {
if (offset_specified) {
// An offset was specified. At this point, the end coordinates should
// be set to either (1) the previous mouse position if there was no
// element specified, or (2) the origin of the element from which to
// calculate the offset. While it may not be strictly spec-compliant,
// attempting to set an offset larger than 2,147,483,647 will be
// regarded as outside the move bounds.
long long temp_x = static_cast<long long>(end_x) + static_cast<long long>(x_offset);
if (temp_x > INT_MAX || temp_x < INT_MIN) {
input_state->error_info = StringUtilities::Format(MOVE_OVERFLOW_ERROR_TEMPLATE,
"x coordinate",
temp_x);
return EMOVETARGETOUTOFBOUNDS;
}
long long temp_y = static_cast<long long>(end_y) + static_cast<long long>(y_offset);
if (temp_y > INT_MAX || temp_y < INT_MIN) {
input_state->error_info = StringUtilities::Format(MOVE_OVERFLOW_ERROR_TEMPLATE,
"y coordinate",
temp_y);
return EMOVETARGETOUTOFBOUNDS;
}
end_x += x_offset;
end_y += y_offset;
}
}
LOG(DEBUG) << "Queueing SendInput structure for mouse move (origin: " << origin
<< ", x: " << end_x << ", y: " << end_y << ")";
HWND browser_window_handle = browser_wrapper->GetContentWindowHandle();
RECT window_rect;
::GetWindowRect(browser_window_handle, &window_rect);
POINT click_point = { end_x, end_y };
::ClientToScreen(browser_window_handle, &click_point);
if (click_point.x < window_rect.left ||
click_point.x > window_rect.right ||
click_point.y < window_rect.top ||
click_point.y > window_rect.bottom) {
input_state->error_info = StringUtilities::Format(MOVE_ERROR_TEMPLATE,
end_x,
end_y,
window_rect.left,
window_rect.right,
window_rect.top,
window_rect.bottom);
LOG(WARN) << input_state->error_info;
return EMOVETARGETOUTOFBOUNDS;
}
if (end_x == input_state->mouse_x && end_y == input_state->mouse_y) {
LOG(DEBUG) << "Omitting SendInput structure for mouse move; no movement required (x: "
<< end_x << ", y: " << end_y << ")";
} else {
const int min_duration = 50;
int step_count = 10;
if (duration <= min_duration) {
step_count = 0;
}
long step_sleep = duration / max(step_count, 1);
long x_distance = end_x - input_state->mouse_x;
long y_distance = end_y - input_state->mouse_y;
for (int i = 0; i < step_count; i++) {
//To avoid integer division rounding and cumulative floating point errors,
//calculate from scratch each time
double step_progress = ((double)i) / step_count;
int current_x = (int)(input_state->mouse_x + (x_distance * step_progress));
int current_y = (int)(input_state->mouse_y + (y_distance * step_progress));
this->AddMouseInput(browser_window_handle, MOUSEEVENTF_MOVE, current_x, current_y);
if (step_sleep > 0) {
this->AddPauseInput(browser_window_handle, step_sleep);
}
}
this->AddMouseInput(browser_window_handle, MOUSEEVENTF_MOVE, end_x, end_y);
}
input_state->mouse_x = end_x;
input_state->mouse_y = end_y;
}
return status_code;
}
int InputManager::PointerDown(BrowserHandle browser_wrapper,
const Json::Value& down_action,
InputState* input_state) {
LOG(TRACE) << "Entering InputManager::PointerDown";
int button = down_action["button"].asInt();
HWND browser_window_handle = browser_wrapper->GetContentWindowHandle();
LOG(DEBUG) << "Queueing SendInput structure for mouse button down";
long button_event_value = MOUSEEVENTF_LEFTDOWN;
if (button == WD_CLIENT_RIGHT_MOUSE_BUTTON) {
button_event_value = MOUSEEVENTF_RIGHTDOWN;
}
this->AddMouseInput(browser_window_handle,
button_event_value,
input_state->mouse_x,
input_state->mouse_y);
if (button == WD_CLIENT_RIGHT_MOUSE_BUTTON) {
input_state->is_right_button_pressed = true;
} else {
input_state->is_left_button_pressed = true;
}
return WD_SUCCESS;
}
int InputManager::PointerUp(BrowserHandle browser_wrapper,
const Json::Value& up_action,
InputState* input_state) {
LOG(TRACE) << "Entering InputManager::PointerUp";
int button = up_action["button"].asInt();
HWND browser_window_handle = browser_wrapper->GetContentWindowHandle();
LOG(DEBUG) << "Queueing SendInput structure for mouse button up";
long button_event_value = MOUSEEVENTF_LEFTUP;
if (button == WD_CLIENT_RIGHT_MOUSE_BUTTON) {
button_event_value = MOUSEEVENTF_RIGHTUP;
}
this->AddMouseInput(browser_window_handle,
button_event_value,
input_state->mouse_x,
input_state->mouse_y);
if (button == WD_CLIENT_RIGHT_MOUSE_BUTTON) {
input_state->is_right_button_pressed = false;
} else {
input_state->is_left_button_pressed = false;
}
return WD_SUCCESS;
}
int InputManager::KeyDown(BrowserHandle browser_wrapper,
const Json::Value& down_action,
InputState* input_state) {
int status_code = WD_SUCCESS;
std::string key_value = down_action["value"].asString();
std::wstring key = StringUtilities::ToWString(key_value);
if (!this->IsSingleKey(key)) {
return EINVALIDARGUMENT;
}
if (this->action_simulator_->UseExtraInfo()) {
LOG(DEBUG) << "Using synthetic events for sending keys";
KeyboardExtraInfo* extra_info = new KeyboardExtraInfo();
extra_info->character = key;
INPUT input_element;
input_element.type = INPUT_KEYBOARD;
input_element.ki.wVk = 0;
input_element.ki.wScan = 0;
input_element.ki.dwFlags = 0;
input_element.ki.dwExtraInfo = reinterpret_cast<ULONG_PTR>(extra_info);
input_element.ki.time = 0;
this->inputs_.push_back(input_element);
} else {
HWND window_handle = browser_wrapper->GetContentWindowHandle();
this->AddKeyboardInput(window_handle, key, false, input_state);
}
return status_code;
}
int InputManager::KeyUp(BrowserHandle browser_wrapper,
const Json::Value& up_action,
InputState* input_state) {
int status_code = WD_SUCCESS;
std::string key_value = up_action["value"].asString();
std::wstring key = StringUtilities::ToWString(key_value);
if (!this->IsSingleKey(key)) {
return EINVALIDARGUMENT;
}
if (!this->action_simulator_->UseExtraInfo()) {
HWND window_handle = browser_wrapper->GetContentWindowHandle();
this->AddKeyboardInput(window_handle, key, true, input_state);
}
return status_code;
}
bool InputManager::IsSingleKey(const std::wstring& input) {
bool is_single_key = true;
//StringUtilities::ComposeUnicodeString(input);
std::wstring composed_input = input;
StringUtilities::ComposeUnicodeString(&composed_input);
if (composed_input.size() > 1) {
WORD combining_bitmask = C3_NONSPACING | C3_DIACRITIC | C3_VOWELMARK;
std::vector<WORD> char_types(input.size());
BOOL get_type_success = ::GetStringTypeW(CT_CTYPE3,
input.c_str(),
static_cast<int>(input.size()),
&char_types[0]);
if (get_type_success) {
bool found_alpha = false;
for (size_t i = 0; i < char_types.size(); ++i) {
if (char_types[i] & combining_bitmask) {
continue;
}
if (char_types[i] & C3_ALPHA) {
if (!found_alpha) {
found_alpha = true;
} else {
is_single_key = false;
break;
}
}
}
}
}
if (!is_single_key) {
LOG(WARN) << "key value did not pass validation";
}
return is_single_key;
}
int InputManager::Pause(BrowserHandle browser_wrapper,
const Json::Value& pause_action) {
int status_code = 0;
int duration = 0;
if (pause_action.isMember("duration")) {
duration = pause_action["duration"].asInt();
}
if (duration > 0) {
this->AddPauseInput(browser_wrapper->GetContentWindowHandle(), duration);
}
return status_code;
}
void InputManager::AddPauseInput(HWND window_handle, int duration) {
// Leverage the INPUT_HARDWARE type.
INPUT pause_input;
pause_input.type = INPUT_HARDWARE;
pause_input.hi.uMsg = duration;
this->inputs_.push_back(pause_input);
}
void InputManager::AddMouseInput(HWND window_handle, long input_action, int x, int y) {
LOG(TRACE) << "Entering InputManager::AddMouseInput";
INPUT mouse_input;
mouse_input.type = INPUT_MOUSE;
mouse_input.mi.dwFlags = input_action | MOUSEEVENTF_ABSOLUTE;
mouse_input.mi.dx = x;
mouse_input.mi.dy = y;
mouse_input.mi.dwExtraInfo = 0;
mouse_input.mi.mouseData = 0;
mouse_input.mi.time = 0;
if (input_action == MOUSEEVENTF_LEFTDOWN) {
this->UpdatePressedKeys(WD_MOUSE_LBUTTON, true);
}
if (input_action == MOUSEEVENTF_RIGHTDOWN) {
this->UpdatePressedKeys(WD_MOUSE_RBUTTON, true);
}
if (input_action == MOUSEEVENTF_LEFTUP) {
this->UpdatePressedKeys(WD_MOUSE_LBUTTON, false);
}
if (input_action == MOUSEEVENTF_RIGHTUP) {
this->UpdatePressedKeys(WD_MOUSE_RBUTTON, false);
}
this->inputs_.push_back(mouse_input);
}
void InputManager::AddKeyboardInput(HWND window_handle,
std::wstring key,
bool key_up,
InputState* input_state) {
LOG(TRACE) << "Entering InputManager::AddKeyboardInput";
wchar_t character = key[0];
std::wstring log_key = key;
if (key.size() == 1) {
log_key = this->GetKeyDescription(character);
}
std::string log_event = "key down";
if (key_up) {
log_event = "key up";
}
LOG(DEBUG) << "Queueing SendInput structure for " << log_event
<< " (key: " << LOGWSTRING(log_key) << ")";
if (key.size() > 1) {
// If the key string passed in is greater than a single character,
// we've been sent a Unicode character with surrogate pairs. Do
// no further processing, just create the input items for the
// individual pieces of the surrogate pair, and let the system
// input manager do the rest.
std::wstring::const_iterator it = key.begin();
for (; it != key.end(); ++it) {
KeyInfo surrogate_key_info = { 0, 0, false, false, false, false, L'\0' };
surrogate_key_info.scan_code = static_cast<WORD>(*it);
surrogate_key_info.key_code = 0;
surrogate_key_info.is_extended_key = false;
this->CreateKeyboardInputItem(surrogate_key_info, KEYEVENTF_UNICODE, key_up);
}
return;
}
if (character == WD_KEY_NULL) {
std::vector<WORD> modifier_key_codes;
if (input_state->is_shift_pressed) {
if (this->IsKeyPressed(WD_KEY_SHIFT)) {
modifier_key_codes.push_back(VK_SHIFT);
this->UpdatePressedKeys(WD_KEY_SHIFT, false);
}
if (this->IsKeyPressed(WD_KEY_R_SHIFT)) {
modifier_key_codes.push_back(VK_RSHIFT);
this->UpdatePressedKeys(WD_KEY_R_SHIFT, false);
}
input_state->is_shift_pressed = false;
}
if (input_state->is_control_pressed) {
if (this->IsKeyPressed(WD_KEY_CONTROL)) {
modifier_key_codes.push_back(VK_CONTROL);
this->UpdatePressedKeys(WD_KEY_CONTROL, false);
}
if (this->IsKeyPressed(WD_KEY_R_CONTROL)) {
modifier_key_codes.push_back(VK_RCONTROL);
this->UpdatePressedKeys(WD_KEY_R_CONTROL, false);
}
input_state->is_control_pressed = false;
}
if (input_state->is_alt_pressed) {
if (this->IsKeyPressed(WD_KEY_ALT)) {
modifier_key_codes.push_back(VK_MENU);
this->UpdatePressedKeys(WD_KEY_ALT, false);
}
if (this->IsKeyPressed(WD_KEY_R_ALT)) {
modifier_key_codes.push_back(VK_RMENU);
this->UpdatePressedKeys(WD_KEY_R_ALT, false);
}
input_state->is_alt_pressed = false;
}
if (input_state->is_meta_pressed) {
if (this->IsKeyPressed(WD_KEY_META)) {
modifier_key_codes.push_back(VK_LWIN);
this->UpdatePressedKeys(WD_KEY_META, false);
}
if (this->IsKeyPressed(WD_KEY_R_META)) {
modifier_key_codes.push_back(VK_RWIN);
this->UpdatePressedKeys(WD_KEY_R_META, false);
}
input_state->is_meta_pressed = false;
}
std::vector<WORD>::const_iterator it = modifier_key_codes.begin();
for (; it != modifier_key_codes.end(); ++it) {
KeyInfo modifier_key_info = { 0, 0, false, false, false, false, character };
UINT scan_code = ::MapVirtualKey(*it, MAPVK_VK_TO_VSC);
modifier_key_info.key_code = *it;
modifier_key_info.scan_code = scan_code;
this->CreateKeyboardInputItem(modifier_key_info,
KEYEVENTF_SCANCODE,
true);
}
return;
}
if (this->IsModifierKey(character)) {
KeyInfo modifier_key_info = { 0, 0, false, false, false, false, character };
// If the character represents the Shift key, or represents the
// "release all modifiers" key and the Shift key is down, send
// the appropriate down or up keystroke for the Shift key.
if (character == WD_KEY_SHIFT ||
character == WD_KEY_R_SHIFT) {
WORD key_code = VK_SHIFT;
if (character == WD_KEY_R_SHIFT) {
key_code = VK_RSHIFT;
}
UINT scan_code = ::MapVirtualKey(key_code, MAPVK_VK_TO_VSC);
modifier_key_info.key_code = VK_SHIFT;
modifier_key_info.scan_code = scan_code;
this->CreateKeyboardInputItem(modifier_key_info,
KEYEVENTF_SCANCODE,
input_state->is_shift_pressed);
if (input_state->is_shift_pressed) {
input_state->is_shift_pressed = false;
} else {
input_state->is_shift_pressed = true;
}
this->UpdatePressedKeys(character, input_state->is_shift_pressed);
}
// If the character represents the Control key, or represents the
// "release all modifiers" key and the Control key is down, send
// the appropriate down or up keystroke for the Control key.
if (character == WD_KEY_CONTROL ||
character == WD_KEY_R_CONTROL) {
WORD key_code = VK_CONTROL;
if (character == WD_KEY_R_CONTROL) {
key_code = VK_RCONTROL;
modifier_key_info.is_extended_key = true;
}
UINT scan_code = ::MapVirtualKey(key_code, MAPVK_VK_TO_VSC);
modifier_key_info.key_code = VK_CONTROL;
modifier_key_info.scan_code = scan_code;
this->CreateKeyboardInputItem(modifier_key_info,
KEYEVENTF_SCANCODE,
input_state->is_control_pressed);
if (input_state->is_control_pressed) {
input_state->is_control_pressed = false;
} else {
input_state->is_control_pressed = true;
}
this->UpdatePressedKeys(character, input_state->is_control_pressed);
}
// If the character represents the Alt key, or represents the
// "release all modifiers" key and the Alt key is down, send
// the appropriate down or up keystroke for the Alt key.
if (character == WD_KEY_ALT ||
character == WD_KEY_R_ALT) {
WORD key_code = VK_MENU;
if (character == WD_KEY_R_ALT) {
key_code = VK_RMENU;
modifier_key_info.is_extended_key = true;
}
UINT scan_code = ::MapVirtualKey(key_code, MAPVK_VK_TO_VSC);
modifier_key_info.key_code = VK_MENU;
modifier_key_info.scan_code = scan_code;
this->CreateKeyboardInputItem(modifier_key_info,
KEYEVENTF_SCANCODE,
input_state->is_alt_pressed);
if (input_state->is_alt_pressed) {
input_state->is_alt_pressed = false;
} else {
input_state->is_alt_pressed = true;
}
this->UpdatePressedKeys(character, input_state->is_alt_pressed);
}
// If the character represents the Meta (Windows) key, or represents
// the "release all modifiers" key and the Meta key is down, send
// the appropriate down or up keystroke for the Meta key.
if (character == WD_KEY_META ||
character == WD_KEY_R_META) {
//modifier_key_info.key_code = VK_LWIN;
//this->CreateKeyboardInputItem(modifier_key_info,
// 0,
// input_state->is_meta_pressed);
//if (input_state->is_meta_pressed) {
// input_state->is_meta_pressed = false;
//} else {
// input_state->is_meta_pressed = true;
//}
//this->UpdatePressedKeys(WD_KEY_META, input_state->is_meta_pressed);
}
return;
}
if (key_up && !this->IsKeyPressed(character)) {
return;
}
this->UpdatePressedKeys(character, !key_up);
KeyInfo key_info = this->GetKeyInfo(window_handle, character);
if (key_info.is_ignored_key) {
return;
}
if (!key_info.is_webdriver_key) {
if (!key_info.scan_code || (key_info.key_code == 0xFFFFU)) {
LOG(WARN) << "No translation for key. Assuming unicode input: " << character;
key_info.scan_code = static_cast<WORD>(character);
key_info.key_code = 0;
key_info.is_extended_key = false;
this->CreateKeyboardInputItem(key_info, KEYEVENTF_UNICODE, key_up);
return;
}
}
unsigned short modifier_key_info = HIBYTE(key_info.key_code);
if (modifier_key_info != 0) {
// Requested key is a <modifier keys> + <key>. Thus, don't use the key code.
// Instead, send the modifier keystrokes, and use the scan code of the key.
bool is_shift_required = (modifier_key_info & MODIFIER_KEY_SHIFT) != 0 &&
!input_state->is_shift_pressed;
bool is_control_required = (modifier_key_info & MODIFIER_KEY_CTRL) != 0 &&
!input_state->is_control_pressed;
bool is_alt_required = (modifier_key_info & MODIFIER_KEY_ALT) != 0 &&
!input_state->is_alt_pressed;
if (!key_up) {
if (is_shift_required) {
KeyInfo shift_key_info = { VK_SHIFT, 0, false, false, false, false, character };
this->CreateKeyboardInputItem(shift_key_info, 0, false);
}
if (is_control_required) {
KeyInfo control_key_info = { VK_CONTROL, 0, false, false, false, false, character };
this->CreateKeyboardInputItem(control_key_info, 0, false);
}
if (is_alt_required) {
KeyInfo alt_key_info = { VK_MENU, 0, false, false, false, false, character };
this->CreateKeyboardInputItem(alt_key_info, 0, false);
}
}
this->CreateKeyboardInputItem(key_info, KEYEVENTF_SCANCODE, key_up);
if (key_up) {
if (is_shift_required) {
KeyInfo shift_key_info = { VK_SHIFT, 0, false, false, false, false, character };
this->CreateKeyboardInputItem(shift_key_info, 0, true);
}
if (is_control_required) {
KeyInfo control_key_info = { VK_CONTROL, 0, false, false, false, false, character };
this->CreateKeyboardInputItem(control_key_info, 0, true);
}
if (is_alt_required) {
KeyInfo alt_key_info = { VK_MENU, 0, false, false, false, false, character };
this->CreateKeyboardInputItem(alt_key_info, 0, true);
}
}
} else {
this->CreateKeyboardInputItem(key_info, 0, key_up);
}
}
bool InputManager::IsKeyPressed(wchar_t character) {
return std::find(this->pressed_keys_.begin(),
this->pressed_keys_.end(),
character) != this->pressed_keys_.end();
}
void InputManager::UpdatePressedKeys(wchar_t character, bool press_key) {
std::wstring log_string = this->GetKeyDescription(character);
if (press_key) {
LOG(TRACE) << "Adding key: " << LOGWSTRING(log_string);
this->pressed_keys_.push_back(character);
} else {
LOG(TRACE) << "Removing key: " << LOGWSTRING(log_string);
std::vector<wchar_t>::const_reverse_iterator reverse_it = this->pressed_keys_.rbegin();
for (; reverse_it != this->pressed_keys_.rend(); ++reverse_it) {
if (*reverse_it == character) {
break;
}
}
if (reverse_it != this->pressed_keys_.rend()) {
// Must advance the forward iterator to be on the right element
// of the vector.
std::vector<wchar_t>::const_iterator it = reverse_it.base();
this->pressed_keys_.erase(--it);
}
}
}
void InputManager::CreateKeyboardInputItem(KeyInfo key_info,
DWORD initial_flags,
bool is_generating_key_up) {
INPUT input_element;
input_element.type = INPUT_KEYBOARD;
input_element.ki.wVk = key_info.key_code;
input_element.ki.wScan = key_info.scan_code;
input_element.ki.dwFlags = initial_flags;
input_element.ki.dwExtraInfo = key_info.character;
input_element.ki.time = 0;
if (key_info.is_extended_key) {
input_element.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
}
if (is_generating_key_up) {
input_element.ki.dwFlags |= KEYEVENTF_KEYUP;
}
if (key_info.is_force_scan_code) {
input_element.ki.dwFlags |= KEYEVENTF_SCANCODE;
}
this->inputs_.push_back(input_element);
}
bool InputManager::IsModifierKey(wchar_t character) {
return character == WD_KEY_SHIFT ||
character == WD_KEY_CONTROL ||
character == WD_KEY_ALT ||
character == WD_KEY_META ||
character == WD_KEY_R_SHIFT ||
character == WD_KEY_R_CONTROL ||
character == WD_KEY_R_ALT ||
character == WD_KEY_R_META ||
character == WD_KEY_NULL;
}
KeyInfo InputManager::GetKeyInfo(HWND window_handle, wchar_t character) {
KeyInfo key_info;
key_info.is_ignored_key = false;
key_info.is_extended_key = false;
key_info.is_webdriver_key = true;
key_info.is_force_scan_code = false;
key_info.key_code = 0;
key_info.scan_code = 0;
key_info.character = character;
DWORD process_id = 0;
DWORD thread_id = ::GetWindowThreadProcessId(window_handle, &process_id);
HKL layout = ::GetKeyboardLayout(thread_id);
if (character == WD_KEY_CANCEL) { // ^break
key_info.key_code = VK_CANCEL;
key_info.scan_code = VK_CANCEL;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_HELP) { // help
key_info.key_code = VK_HELP;
key_info.scan_code = VK_HELP;
}
else if (character == WD_KEY_BACKSPACE) { // back space
key_info.key_code = VK_BACK;
key_info.scan_code = VK_BACK;
}
else if (character == WD_KEY_TAB) { // tab
key_info.key_code = VK_TAB;
key_info.scan_code = VK_TAB;
}
else if (character == WD_KEY_CLEAR) { // clear
key_info.key_code = VK_CLEAR;
key_info.scan_code = VK_CLEAR;
}
else if (character == WD_KEY_RETURN) { // return
key_info.key_code = VK_RETURN;
key_info.scan_code = VK_RETURN;
}
else if (character == WD_KEY_ENTER) { // enter
key_info.key_code = VK_RETURN;
key_info.scan_code = VK_RETURN;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_PAUSE) { // pause
key_info.key_code = VK_PAUSE;
key_info.scan_code = VK_PAUSE;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_ESCAPE) { // escape
key_info.key_code = VK_ESCAPE;
key_info.scan_code = VK_ESCAPE;
}
else if (character == WD_KEY_SPACE) { // space
key_info.key_code = VK_SPACE;
key_info.scan_code = VK_SPACE;
}
else if (character == WD_KEY_PAGEUP) { // page up
key_info.key_code = VK_PRIOR;
key_info.scan_code = VK_PRIOR;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_PAGEDOWN) { // page down
key_info.key_code = VK_NEXT;
key_info.scan_code = VK_NEXT;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_END) { // end
key_info.key_code = VK_END;
key_info.scan_code = VK_END;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_HOME) { // home
key_info.key_code = VK_HOME;
key_info.scan_code = VK_HOME;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_LEFT) { // left arrow
key_info.key_code = VK_LEFT;
key_info.scan_code = VK_LEFT;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_UP) { // up arrow
key_info.key_code = VK_UP;
key_info.scan_code = VK_UP;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_RIGHT) { // right arrow
key_info.key_code = VK_RIGHT;
key_info.scan_code = VK_RIGHT;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_DOWN) { // down arrow
key_info.key_code = VK_DOWN;
key_info.scan_code = VK_DOWN;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_INSERT) { // insert
key_info.key_code = VK_INSERT;
key_info.scan_code = VK_INSERT;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_DELETE) { // delete
key_info.key_code = VK_DELETE;
key_info.scan_code = VK_DELETE;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_SEMICOLON) { // semicolon
key_info.key_code = VkKeyScanExW(L';', layout);
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
}
else if (character == WD_KEY_EQUALS) { // equals
key_info.key_code = VkKeyScanExW(L'=', layout);
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
}
else if (character == WD_KEY_NUMPAD0) { // numpad0
key_info.key_code = VK_NUMPAD0;
key_info.scan_code = VK_NUMPAD0;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_NUMPAD1) { // numpad1
key_info.key_code = VK_NUMPAD1;
key_info.scan_code = VK_NUMPAD1;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_NUMPAD2) { // numpad2
key_info.key_code = VK_NUMPAD2;
key_info.scan_code = VK_NUMPAD2;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_NUMPAD3) { // numpad3
key_info.key_code = VK_NUMPAD3;
key_info.scan_code = VK_NUMPAD3;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_NUMPAD4) { // numpad4
key_info.key_code = VK_NUMPAD4;
key_info.scan_code = VK_NUMPAD4;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_NUMPAD5) { // numpad5
key_info.key_code = VK_NUMPAD5;
key_info.scan_code = VK_NUMPAD5;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_NUMPAD6) { // numpad6
key_info.key_code = VK_NUMPAD6;
key_info.scan_code = VK_NUMPAD6;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_NUMPAD7) { // numpad7
key_info.key_code = VK_NUMPAD7;
key_info.scan_code = VK_NUMPAD7;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_NUMPAD8) { // numpad8
key_info.key_code = VK_NUMPAD8;
key_info.scan_code = VK_NUMPAD8;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_NUMPAD9) { // numpad9
key_info.key_code = VK_NUMPAD9;
key_info.scan_code = VK_NUMPAD9;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_MULTIPLY) { // multiply
key_info.key_code = VK_MULTIPLY;
key_info.scan_code = VK_MULTIPLY;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_ADD) { // add
key_info.key_code = VK_ADD;
key_info.scan_code = VK_ADD;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_SEPARATOR) { // separator
key_info.key_code = VkKeyScanExW(L',', layout);
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_extended_key = true;
}
else if (character == WD_KEY_SUBTRACT) { // subtract
key_info.key_code = VK_SUBTRACT;
key_info.scan_code = VK_SUBTRACT;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_DECIMAL) { // decimal
key_info.key_code = VK_DECIMAL;
key_info.scan_code = VK_DECIMAL;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_DIVIDE) { // divide
key_info.key_code = VK_DIVIDE;
key_info.scan_code = VK_DIVIDE;
key_info.is_extended_key = true;
}
else if (character == WD_KEY_R_PAGEUP) {
key_info.key_code = VK_NUMPAD9;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_R_PAGEDN) {
key_info.key_code = VK_NUMPAD3;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_R_END) { // end
key_info.key_code = VK_NUMPAD1;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_R_HOME) { // home
key_info.key_code = VK_NUMPAD7;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_R_LEFT) { // left arrow
key_info.key_code = VK_NUMPAD4;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_R_UP) { // up arrow
key_info.key_code = VK_NUMPAD8;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_R_RIGHT) { // right arrow
key_info.key_code = VK_NUMPAD6;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_R_DOWN) { // down arrow
key_info.key_code = VK_NUMPAD2;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_R_INSERT) { // insert
key_info.key_code = VK_NUMPAD0;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_R_DELETE) { // delete
key_info.key_code = VK_DECIMAL;
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_force_scan_code = true;
}
else if (character == WD_KEY_F1) { // F1
key_info.key_code = VK_F1;
key_info.scan_code = VK_F1;
}
else if (character == WD_KEY_F2) { // F2
key_info.key_code = VK_F2;
key_info.scan_code = VK_F2;
}
else if (character == WD_KEY_F3) { // F3
key_info.key_code = VK_F3;
key_info.scan_code = VK_F3;
}
else if (character == WD_KEY_F4) { // F4
key_info.key_code = VK_F4;
key_info.scan_code = VK_F4;
}
else if (character == WD_KEY_F5) { // F5
key_info.key_code = VK_F5;
key_info.scan_code = VK_F5;
}
else if (character == WD_KEY_F6) { // F6
key_info.key_code = VK_F6;
key_info.scan_code = VK_F6;
}
else if (character == WD_KEY_F7) { // F7
key_info.key_code = VK_F7;
key_info.scan_code = VK_F7;
}
else if (character == WD_KEY_F8) { // F8
key_info.key_code = VK_F8;
key_info.scan_code = VK_F8;
}
else if (character == WD_KEY_F9) { // F9
key_info.key_code = VK_F9;
key_info.scan_code = VK_F9;
}
else if (character == WD_KEY_F10) { // F10
key_info.key_code = VK_F10;
key_info.scan_code = VK_F10;
}
else if (character == WD_KEY_F11) { // F11
key_info.key_code = VK_F11;
key_info.scan_code = VK_F11;
}
else if (character == WD_KEY_F12) { // F12
key_info.key_code = VK_F12;
key_info.scan_code = VK_F12;
}
else if (character == L'\n') { // line feed
key_info.key_code = VK_RETURN;
key_info.scan_code = VK_RETURN;
}
else if (character == L'\r') { // carriage return
key_info.is_ignored_key = true; // skip it
} else {
key_info.key_code = VkKeyScanExW(character, layout);
key_info.scan_code = MapVirtualKeyExW(LOBYTE(key_info.key_code), 0, layout);
key_info.is_webdriver_key = false;
}
return key_info;
}
std::wstring InputManager::GetKeyDescription(const wchar_t character) {
std::wstring description = L"";
description.append(1, character);
std::map<wchar_t, std::wstring>::const_iterator it = this->key_descriptions_.find(character);
if (it != this->key_descriptions_.end()) {
description = it->second;
}
return description;
}
void InputManager::SetupKeyDescriptions() {
this->key_descriptions_[WD_KEY_NULL] = L"Unidentified";
this->key_descriptions_[WD_KEY_CANCEL] = L"Cancel";
this->key_descriptions_[WD_KEY_HELP] = L"Help";
this->key_descriptions_[WD_KEY_BACKSPACE] = L"Backspace";
this->key_descriptions_[WD_KEY_TAB] = L"Tab";
this->key_descriptions_[WD_KEY_CLEAR] = L"Clear";
this->key_descriptions_[WD_KEY_RETURN] = L"Return";
this->key_descriptions_[WD_KEY_ENTER] = L"Enter";
this->key_descriptions_[WD_KEY_SHIFT] = L"Shift";
this->key_descriptions_[WD_KEY_CONTROL] = L"Control";
this->key_descriptions_[WD_KEY_ALT] = L"Alt";
this->key_descriptions_[WD_KEY_PAUSE] = L"Pause";
this->key_descriptions_[WD_KEY_ESCAPE] = L"Escape";
this->key_descriptions_[WD_KEY_SPACE] = L"Space";
this->key_descriptions_[WD_KEY_PAGEUP] = L"PageUp";
this->key_descriptions_[WD_KEY_PAGEDOWN] = L"PageDown";
this->key_descriptions_[WD_KEY_END] = L"End";
this->key_descriptions_[WD_KEY_HOME] = L"Home";
this->key_descriptions_[WD_KEY_LEFT] = L"ArrowLeft";
this->key_descriptions_[WD_KEY_UP] = L"ArrowUp";
this->key_descriptions_[WD_KEY_RIGHT] = L"ArrowRight";
this->key_descriptions_[WD_KEY_DOWN] = L"ArrowDown";
this->key_descriptions_[WD_KEY_INSERT] = L"Insert";
this->key_descriptions_[WD_KEY_DELETE] = L"Delete";
this->key_descriptions_[WD_KEY_SEMICOLON] = L";";
this->key_descriptions_[WD_KEY_EQUALS] = L"=";
this->key_descriptions_[WD_KEY_NUMPAD0] = L"0";
this->key_descriptions_[WD_KEY_NUMPAD1] = L"1";
this->key_descriptions_[WD_KEY_NUMPAD2] = L"2";
this->key_descriptions_[WD_KEY_NUMPAD3] = L"3";
this->key_descriptions_[WD_KEY_NUMPAD4] = L"4";
this->key_descriptions_[WD_KEY_NUMPAD5] = L"5";
this->key_descriptions_[WD_KEY_NUMPAD6] = L"6";
this->key_descriptions_[WD_KEY_NUMPAD7] = L"7";
this->key_descriptions_[WD_KEY_NUMPAD8] = L"8";
this->key_descriptions_[WD_KEY_NUMPAD9] = L"9";
this->key_descriptions_[WD_KEY_MULTIPLY] = L"*";
this->key_descriptions_[WD_KEY_ADD] = L"+";
this->key_descriptions_[WD_KEY_SEPARATOR] = L",";
this->key_descriptions_[WD_KEY_SUBTRACT] = L"-";
this->key_descriptions_[WD_KEY_DECIMAL] = L".";
this->key_descriptions_[WD_KEY_DIVIDE] = L"/";
this->key_descriptions_[WD_KEY_F1] = L"F1";
this->key_descriptions_[WD_KEY_F2] = L"F2";
this->key_descriptions_[WD_KEY_F3] = L"F3";
this->key_descriptions_[WD_KEY_F4] = L"F4";
this->key_descriptions_[WD_KEY_F5] = L"F5";
this->key_descriptions_[WD_KEY_F6] = L"F6";
this->key_descriptions_[WD_KEY_F7] = L"F7";
this->key_descriptions_[WD_KEY_F8] = L"F8";
this->key_descriptions_[WD_KEY_F9] = L"F9";
this->key_descriptions_[WD_KEY_F10] = L"F10";
this->key_descriptions_[WD_KEY_F11] = L"F11";
this->key_descriptions_[WD_KEY_F12] = L"F12";
this->key_descriptions_[WD_KEY_META] = L"Meta";
this->key_descriptions_[WD_KEY_ZEN] = L"ZenkakuHankaku";
this->key_descriptions_[WD_KEY_R_SHIFT] = L"Shift";
this->key_descriptions_[WD_KEY_R_CONTROL] = L"Control";
this->key_descriptions_[WD_KEY_R_ALT] = L"Alt";
this->key_descriptions_[WD_KEY_R_META] = L"Meta";
this->key_descriptions_[WD_KEY_R_PAGEUP] = L"PageUp";
this->key_descriptions_[WD_KEY_R_PAGEDN] = L"PageDown";
this->key_descriptions_[WD_KEY_R_END] = L"End";
this->key_descriptions_[WD_KEY_R_HOME] = L"Home";
this->key_descriptions_[WD_KEY_R_LEFT] = L"ArrowLeft";
this->key_descriptions_[WD_KEY_R_UP] = L"ArrowUp";
this->key_descriptions_[WD_KEY_R_RIGHT] = L"ArrowRight";
this->key_descriptions_[WD_KEY_R_DOWN] = L"ArrowDown";
this->key_descriptions_[WD_KEY_R_INSERT] = L"Insert";
this->key_descriptions_[WD_KEY_R_DELETE] = L"Delete";
this->key_descriptions_[WD_MOUSE_LBUTTON] = L"Left Mouse Button";
this->key_descriptions_[WD_MOUSE_RBUTTON] = L"Right Mouse Button";
}
} // namespace webdriver