Morph MORPH
SIGN IN SIGN UP
SeleniumHQ / selenium UNCLAIMED

A browser automation framework and ecosystem.

34182 0 172 Java
Normal View History Raw
Copyright uniformity for C++ projects Fixes copyright notices for files in the iedriver, iedriverserver, and webdriver-server, in accordance with issue #401.
2015-04-13 12:09:26 -04:00
// 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");
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
// 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.
Moving implementation code of IE driver command handlers from headers The initial implementation of the IE driver's command handlers put the implementation for each command directly in the header files. While this works, it's not standard practice, and has led to a spaghetti-code of include statements. This takes the first step toward fixing that by moving the implementation of each command into a .cpp file, leaving the header to only contain the class definition.
2017-02-14 09:48:56 -08:00
#include "InputManager.h"
Making InputManager more robust in the requireWindowFocus case. Previously, using the Windows SendInput API could cause keystrokes and mouse events to be added to the system message queue, but would return back to the caller before those events were processed by Internet Explorer's message loop. This change adds a Windows mouse hook and keyboard hook to monitor when the messages are processed by an applications message loop. There is still a potential race condition, and users may still need to execute some local synchronization code.
2013-05-17 11:01:23 -04:00
#include <ctime>
Updating sending of keystrokes to send keys outside the BMP in IE
2018-02-22 16:14:27 -08:00
#include <codecvt>
#include <locale>
Moving implementation code of IE driver command handlers from headers The initial implementation of the IE driver's command handlers put the implementation for each command directly in the header files. While this works, it's not standard practice, and has led to a spaghetti-code of include statements. This takes the first step toward fixing that by moving the implementation of each command into a .cpp file, leaving the header to only contain the class definition.
2017-02-14 09:48:56 -08:00
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
#include "errorcodes.h"
Cleaning up #includes in C++ code Also updating Visual Studio solution file to build correct projects in proper platform/configurations.
2014-08-19 21:11:00 +00:00
#include "json.h"
#include "keycodes.h"
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
#include "logging.h"
Moving implementation code of IE driver command handlers from headers The initial implementation of the IE driver's command handlers put the implementation for each command directly in the header files. While this works, it's not standard practice, and has led to a spaghetti-code of include statements. This takes the first step toward fixing that by moving the implementation of each command into a .cpp file, leaving the header to only contain the class definition.
2017-02-14 09:48:56 -08:00
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
#include "ActionSimulators/JavaScriptActionSimulator.h"
#include "ActionSimulators/SendInputActionSimulator.h"
#include "ActionSimulators/SendMessageActionSimulator.h"
#include "DocumentHost.h"
Moving implementation code of IE driver command handlers from headers The initial implementation of the IE driver's command handlers put the implementation for each command directly in the header files. While this works, it's not standard practice, and has led to a spaghetti-code of include statements. This takes the first step toward fixing that by moving the implementation of each command into a .cpp file, leaving the header to only contain the class definition.
2017-02-14 09:48:56 -08:00
#include "Element.h"
#include "HookProcessor.h"
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
#include "IElementManager.h"
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
#include "Script.h"
Moving implementation code of IE driver command handlers from headers The initial implementation of the IE driver's command handlers put the implementation for each command directly in the header files. While this works, it's not standard practice, and has led to a spaghetti-code of include statements. This takes the first step toward fixing that by moving the implementation of each command into a .cpp file, leaving the header to only contain the class definition.
2017-02-14 09:48:56 -08:00
#include "StringUtilities.h"
IE driver code cleanup - moving #defines from header files
2019-01-18 15:54:41 -08:00
#include "WebDriverConstants.h"
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
#include "Generated/atoms.h"
Moving implementation code of IE driver command handlers from headers The initial implementation of the IE driver's command handlers put the implementation for each command directly in the header files. While this works, it's not standard practice, and has led to a spaghetti-code of include statements. This takes the first step toward fixing that by moving the implementation of each command into a .cpp file, leaving the header to only contain the class definition.
2017-02-14 09:48:56 -08:00
#define USER_INTERACTION_MUTEX_NAME L"WebDriverUserInteractionMutex"
#define WAIT_TIME_IN_MILLISECONDS_PER_INPUT_EVENT 100
Adding ability to return extended error info from IE actions
2018-05-26 08:23:21 -07:00
#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)"
Fixing overflow in x-y offsets for mouse actions in IE
2018-09-17 08:13:56 -07:00
#define MOVE_OVERFLOW_ERROR_TEMPLATE "The requested ending %s (%lld) would be outside the legal bounds (less than -2147483648 or greater than 2147483647"
Moving implementation code of IE driver command handlers from headers The initial implementation of the IE driver's command handlers put the implementation for each command directly in the header files. While this works, it's not standard practice, and has led to a spaghetti-code of include statements. This takes the first step toward fixing that by moving the implementation of each command into a .cpp file, leaving the header to only contain the class definition.
2017-02-14 09:48:56 -08:00
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
#define MODIFIER_KEY_SHIFT 1
#define MODIFIER_KEY_CTRL 2
#define MODIFIER_KEY_ALT 4
Updating reset action for IE driver
2018-07-10 11:59:54 -07:00
// "Key" values for mouse buttons
#define WD_MOUSE_LBUTTON 0xE05EU
#define WD_MOUSE_RBUTTON 0xE05FU
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
namespace webdriver {
InputManager::InputManager() {
LOG(TRACE) << "Entering InputManager::InputManager";
this->use_native_events_ = true;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
this->use_persistent_hover_ = false;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
this->require_window_focus_ = true;
this->scroll_behavior_ = TOP;
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
this->current_input_state_.is_alt_pressed = false;
this->current_input_state_.is_control_pressed = false;
this->current_input_state_.is_shift_pressed = false;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
this->current_input_state_.is_meta_pressed = false;
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
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();
Adding ability to return extended error info from IE actions
2018-05-26 08:23:21 -07:00
this->current_input_state_.error_info = "";
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
this->action_simulator_ = NULL;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
InputManager::~InputManager(void) {
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
if (this->action_simulator_ != NULL) {
delete this->action_simulator_;
Refactoring of IE driver native events interaction code. This commit removes the dependency on shared native event code with Firefox. Since Firefox no longer supports native events, it makes no sense to have common code refactored for only one consumer, so this commit moves the Windows-only SendMessage code directly into the IE driver. This is a first step toward deleting the webdriver-interactions directory. While extreme care has been taken to ensure this refactoring causes no regressions, there is a chance something will still break. This particular refactor should also be treated as an intermediate step, as the ported code contains some redundancies to what is already present in the driver. Future refactoring will take place to remove the redundancies and better integrate the code.
2015-12-16 09:40:37 -08:00
}
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
void InputManager::Initialize(InputManagerSettings settings) {
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
LOG(TRACE) << "Entering InputManager::Initialize";
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
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();
}
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
this->SetupKeyDescriptions();
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
int InputManager::PerformInputSequence(BrowserHandle browser_wrapper,
Adding ability to return extended error info from IE actions
2018-05-26 08:23:21 -07:00
const Json::Value& sequences,
std::string* error_info) {
Better detect focus on incorrect UI elements when requireWindowFocus is specified.
2013-05-20 15:54:57 -04:00
LOG(TRACE) << "Entering InputManager::PerformInputSequence";
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (!sequences.isArray()) {
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
return EUNHANDLEDERROR;
}
Refactored IE driver element click code to all use InputManager class. Previously, WebElement.click() used a different code path than the Advanced User Interactions API. These code paths are now unified for the native events case.
2013-05-09 16:20:57 -04:00
int status_code = WD_SUCCESS;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
// Use a single mutex, so that all instances synchronize on the same object
// for focus purposes.
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
HANDLE mutex_handle = this->AcquireMutex();
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
Json::Value ticks(Json::arrayValue);
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
status_code = this->GetTicks(sequences, &ticks);
if (status_code != WD_SUCCESS) {
this->ReleaseMutex(mutex_handle);
return status_code;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
this->inputs_.clear();
Moving double-click detection logic inside InputManager for IE This also will prevent unnecessary expensive sleeps in the click command handler. Partially fixes issue #5024.
2018-02-14 14:33:24 -08:00
this->current_input_state_.last_click_time = 0;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
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) {
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
this->ReleaseMutex(mutex_handle);
Adding ability to return extended error info from IE actions
2018-05-26 08:23:21 -07:00
*error_info = current_input_state.error_info;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
return status_code;
}
Refactored IE driver element click code to all use InputManager class. Previously, WebElement.click() used a different code path than the Advanced User Interactions API. These code paths are now unified for the native events case.
2013-05-09 16:20:57 -04:00
}
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
// If there are inputs in the array, then we've queued up input actions
// to be played back. So play them back.
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (this->inputs_.size() > 0) {
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
LOG(DEBUG) << "Processing a total of " << this->inputs_.size() << " input events";
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
this->action_simulator_->SimulateActions(browser_wrapper,
this->inputs_,
&this->current_input_state_);
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
::Sleep(50);
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
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];
Properly validation duration property of pause actions in IE
2018-08-22 18:49:18 -07:00
if (action.isMember("type") &&
Modifying processing of pause actions in keyboard action sequences The vast majority of use of pause actions in a keyboard action sequence are used to synchronize the entire action chain with other (mouse) action sequences. To allow the driver to properly synchronize the input sequences, the driver will now ignore the duration property of pause events in keyboard action sequences. This is deliberately in violation of the W3C specification, and may be revisited in the future.
2018-02-23 05:49:33 -08:00
action["type"].isString() &&
action["type"].asString() == "pause") {
Allowing duration property of pause actions to be omitted for IE
2018-10-09 20:54:07 -07:00
if (action.isMember("duration") &&
(action["duration"].type() != Json::ValueType::intValue ||
action["duration"].asInt() < 0)) {
Properly validation duration property of pause actions in IE
2018-08-22 18:49:18 -07:00
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.
Fixing IE driver keyboard actions to better synchronize with mouse
2019-07-18 15:23:42 -07:00
action["duration"] = 10;
Properly validation duration property of pause actions in IE
2018-08-22 18:49:18 -07:00
}
Modifying processing of pause actions in keyboard action sequences The vast majority of use of pause actions in a keyboard action sequence are used to synchronize the entire action chain with other (mouse) action sequences. To allow the driver to properly synchronize the input sequences, the driver will now ignore the duration property of pause events in keyboard action sequences. This is deliberately in violation of the W3C specification, and may be revisited in the future.
2018-02-23 05:49:33 -08:00
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
(*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) {
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
if (mutex_handle != NULL) {
::ReleaseMutex(mutex_handle);
::CloseHandle(mutex_handle);
}
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
current_input_state.is_meta_pressed = this->current_input_state_.is_meta_pressed;
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
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;
Adding ability to return extended error info from IE actions
2018-05-26 08:23:21 -07:00
current_input_state.error_info = this->current_input_state_.error_info;
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
return current_input_state;
}
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
void InputManager::Reset(BrowserHandle browser_wrapper) {
LOG(TRACE) << "Entering InputManager::Reset";
Updating reset action for IE driver
2018-07-10 11:59:54 -07:00
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);
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
}
}
Updating reset action for IE driver
2018-07-10 11:59:54 -07:00
// 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_);
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
}
Updating reset action for IE driver
2018-07-10 11:59:54 -07:00
::Sleep(50);
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
if (this->current_input_state_.mouse_x > 0 ||
this->current_input_state_.mouse_y > 0) {
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
LOG(DEBUG) << "Resetting mouse position";
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
this->current_input_state_.mouse_x = 0;
this->current_input_state_.mouse_y = 0;
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
}
Updating reset action for IE driver
2018-07-10 11:59:54 -07:00
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();
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
}
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
int InputManager::PointerMoveTo(BrowserHandle browser_wrapper,
const Json::Value& move_to_action,
InputState* input_state) {
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
LOG(TRACE) << "Entering InputManager::PointerMoveTo";
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
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();
Replacing strings with #define constant in IE driver
2018-02-08 19:23:15 -08:00
} else if (origin_value.isObject() && origin_value.isMember(JSON_ELEMENT_PROPERTY_NAME)) {
origin = origin_value[JSON_ELEMENT_PROPERTY_NAME].asString();
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
element_specified = true;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
}
Fixing overflow in x-y offsets for mouse actions in IE
2018-09-17 08:13:56 -07:00
long x_offset = 0;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (move_to_action.isMember("x") && move_to_action["x"].isInt()) {
x_offset = move_to_action["x"].asInt();
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Fixing overflow in x-y offsets for mouse actions in IE
2018-09-17 08:13:56 -07:00
long y_offset = 0;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (move_to_action.isMember("y") && move_to_action["y"].isInt()) {
y_offset = move_to_action["y"].asInt();
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
bool offset_specified = move_to_action.isMember("x") &&
move_to_action.isMember("y") &&
(x_offset != 0 || y_offset != 0);
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
long duration = 100;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (move_to_action.isMember("duration") && move_to_action["duration"].isInt()) {
duration = move_to_action["duration"].asInt();
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
JimEvans: Introduced the "requireWindowFocus" capability into the IE driver. When used in conjunction with the "nativeEvents" capability, the driver will attempt to bring the current IE window to the foreground before executing a mouse or keyboard event. Also, when the requireWindowFocus capability is set to true, advanced user interactions will now use the Windows SendInput() API to execute the interactions. To enable this behavior, set the value of the requiresWindowFocus capability to "true" when creating an instance of the IE driver. The default for this new capability is "false". This functionality is currently considered extremely experimental; use at your own risk. r18424
2013-01-08 17:10:01 +00:00
ElementHandle target_element;
if (element_specified) {
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
status_code = this->element_map_->GetManagedElement(origin, &target_element);
Updating IEDriver native code to use the new WD_SUCCESS #define instead of just SUCCESS
2013-01-16 14:37:30 -05:00
if (status_code != WD_SUCCESS) {
JimEvans: Introduced the "requireWindowFocus" capability into the IE driver. When used in conjunction with the "nativeEvents" capability, the driver will attempt to bring the current IE window to the foreground before executing a mouse or keyboard event. Also, when the requireWindowFocus capability is set to true, advanced user interactions will now use the Windows SendInput() API to execute the interactions. To enable this behavior, set the value of the requiresWindowFocus capability to "true" when creating an instance of the IE driver. The default for this new capability is "false". This functionality is currently considered extremely experimental; use at your own risk. r18424
2013-01-08 17:10:01 +00:00
return status_code;
}
}
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
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 {
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
long start_x = input_state->mouse_x;
long start_y = input_state->mouse_y;
JimEvans: Introduced the "requireWindowFocus" capability into the IE driver. When used in conjunction with the "nativeEvents" capability, the driver will attempt to bring the current IE window to the foreground before executing a mouse or keyboard event. Also, when the requireWindowFocus capability is set to true, advanced user interactions will now use the Windows SendInput() API to execute the interactions. To enable this behavior, set the value of the requiresWindowFocus capability to "true" when creating an instance of the IE driver. The default for this new capability is "false". This functionality is currently considered extremely experimental; use at your own risk. r18424
2013-01-08 17:10:01 +00:00
long end_x = start_x;
long end_y = start_y;
if (element_specified) {
LocationInfo element_location;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
// 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);
Refactored IE driver element click code to all use InputManager class. Previously, WebElement.click() used a different code path than the Advanced User Interactions API. These code paths are now unified for the native events case.
2013-05-09 16:20:57 -04:00
// 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.
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
LOG(WARN) << "No offset was specified, and the center point of the element could not be scrolled into view.";
Refactored IE driver element click code to all use InputManager class. Previously, WebElement.click() used a different code path than the Advanced User Interactions API. These code paths are now unified for the native events case.
2013-05-09 16:20:57 -04:00
return status_code;
} else {
Fixing IE driver keyboard actions to better synchronize with mouse
2019-07-18 15:23:42 -07:00
LOG(WARN) << "Element::GetStaticClickLocation() returned an error code indicating the element is not reachable.";
Refactored IE driver element click code to all use InputManager class. Previously, WebElement.click() used a different code path than the Advanced User Interactions API. These code paths are now unified for the native events case.
2013-05-09 16:20:57 -04:00
return status_code;
}
JimEvans: Introduced the "requireWindowFocus" capability into the IE driver. When used in conjunction with the "nativeEvents" capability, the driver will attempt to bring the current IE window to the foreground before executing a mouse or keyboard event. Also, when the requireWindowFocus capability is set to true, advanced user interactions will now use the Windows SendInput() API to execute the interactions. To enable this behavior, set the value of the requiresWindowFocus capability to "true" when creating an instance of the IE driver. The default for this new capability is "false". This functionality is currently considered extremely experimental; use at your own risk. r18424
2013-01-08 17:10:01 +00:00
}
// 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;
}
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
if (origin == "viewport") {
end_x = x_offset;
end_y = y_offset;
} else {
if (offset_specified) {
Fixing overflow in x-y offsets for mouse actions in IE
2018-09-17 08:13:56 -07:00
// 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;
}
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
end_x += x_offset;
end_y += y_offset;
}
JimEvans: Introduced the "requireWindowFocus" capability into the IE driver. When used in conjunction with the "nativeEvents" capability, the driver will attempt to bring the current IE window to the foreground before executing a mouse or keyboard event. Also, when the requireWindowFocus capability is set to true, advanced user interactions will now use the Windows SendInput() API to execute the interactions. To enable this behavior, set the value of the requiresWindowFocus capability to "true" when creating an instance of the IE driver. The default for this new capability is "false". This functionality is currently considered extremely experimental; use at your own risk. r18424
2013-01-08 17:10:01 +00:00
}
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
LOG(DEBUG) << "Queueing SendInput structure for mouse move (origin: " << origin
<< ", x: " << end_x << ", y: " << end_y << ")";
Internal IE driver API change GetWindowHandle to GetContentWindowHandle Changing the base DocumentHost class to use GetContentWindowHandle as the method name for the method to get the content window handle.
2014-12-15 11:34:03 -05:00
HWND browser_window_handle = browser_wrapper->GetContentWindowHandle();
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
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) {
Adding ability to return extended error info from IE actions
2018-05-26 08:23:21 -07:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
return EMOVETARGETOUTOFBOUNDS;
}
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (end_x == input_state->mouse_x && end_y == input_state->mouse_y) {
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
LOG(DEBUG) << "Omitting SendInput structure for mouse move; no movement required (x: "
<< end_x << ", y: " << end_y << ")";
JimEvans: Introduced the "requireWindowFocus" capability into the IE driver. When used in conjunction with the "nativeEvents" capability, the driver will attempt to bring the current IE window to the foreground before executing a mouse or keyboard event. Also, when the requireWindowFocus capability is set to true, advanced user interactions will now use the Windows SendInput() API to execute the interactions. To enable this behavior, set the value of the requiresWindowFocus capability to "true" when creating an instance of the IE driver. The default for this new capability is "false". This functionality is currently considered extremely experimental; use at your own risk. r18424
2013-01-08 17:10:01 +00:00
} else {
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
const int min_duration = 50;
int step_count = 10;
if (duration <= min_duration) {
step_count = 0;
}
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
long step_sleep = duration / max(step_count, 1);
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
long x_distance = end_x - input_state->mouse_x;
long y_distance = end_y - input_state->mouse_y;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
for (int i = 0; i < step_count; i++) {
//To avoid integer division rounding and cumulative floating point errors,
//calculate from scratch each time
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
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));
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
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);
JimEvans: Introduced the "requireWindowFocus" capability into the IE driver. When used in conjunction with the "nativeEvents" capability, the driver will attempt to bring the current IE window to the foreground before executing a mouse or keyboard event. Also, when the requireWindowFocus capability is set to true, advanced user interactions will now use the Windows SendInput() API to execute the interactions. To enable this behavior, set the value of the requiresWindowFocus capability to "true" when creating an instance of the IE driver. The default for this new capability is "false". This functionality is currently considered extremely experimental; use at your own risk. r18424
2013-01-08 17:10:01 +00:00
}
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
input_state->mouse_x = end_x;
input_state->mouse_y = end_y;
JimEvans: Introduced the "requireWindowFocus" capability into the IE driver. When used in conjunction with the "nativeEvents" capability, the driver will attempt to bring the current IE window to the foreground before executing a mouse or keyboard event. Also, when the requireWindowFocus capability is set to true, advanced user interactions will now use the Windows SendInput() API to execute the interactions. To enable this behavior, set the value of the requiresWindowFocus capability to "true" when creating an instance of the IE driver. The default for this new capability is "false". This functionality is currently considered extremely experimental; use at your own risk. r18424
2013-01-08 17:10:01 +00:00
}
return status_code;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
int InputManager::PointerDown(BrowserHandle browser_wrapper,
const Json::Value& down_action,
InputState* input_state) {
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
LOG(TRACE) << "Entering InputManager::PointerDown";
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
int button = down_action["button"].asInt();
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
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;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
} else {
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
input_state->is_left_button_pressed = true;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
}
return WD_SUCCESS;
Refactoring of IE driver native events interaction code. This commit removes the dependency on shared native event code with Firefox. Since Firefox no longer supports native events, it makes no sense to have common code refactored for only one consumer, so this commit moves the Windows-only SendMessage code directly into the IE driver. This is a first step toward deleting the webdriver-interactions directory. While extreme care has been taken to ensure this refactoring causes no regressions, there is a chance something will still break. This particular refactor should also be treated as an intermediate step, as the ported code contains some redundancies to what is already present in the driver. Future refactoring will take place to remove the redundancies and better integrate the code.
2015-12-16 09:40:37 -08:00
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
int InputManager::PointerUp(BrowserHandle browser_wrapper,
const Json::Value& up_action,
InputState* input_state) {
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
LOG(TRACE) << "Entering InputManager::PointerUp";
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
int button = up_action["button"].asInt();
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
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;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
} else {
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
input_state->is_left_button_pressed = false;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
}
return WD_SUCCESS;
Refactoring of IE driver native events interaction code. This commit removes the dependency on shared native event code with Firefox. Since Firefox no longer supports native events, it makes no sense to have common code refactored for only one consumer, so this commit moves the Windows-only SendMessage code directly into the IE driver. This is a first step toward deleting the webdriver-interactions directory. While extreme care has been taken to ensure this refactoring causes no regressions, there is a chance something will still break. This particular refactor should also be treated as an intermediate step, as the ported code contains some redundancies to what is already present in the driver. Future refactoring will take place to remove the redundancies and better integrate the code.
2015-12-16 09:40:37 -08:00
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
int InputManager::KeyDown(BrowserHandle browser_wrapper,
const Json::Value& down_action,
InputState* input_state) {
Updating IEDriver native code to use the new WD_SUCCESS #define instead of just SUCCESS
2013-01-16 14:37:30 -05:00
int status_code = WD_SUCCESS;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
std::string key_value = down_action["value"].asString();
std::wstring key = StringUtilities::ToWString(key_value);
Again updated Unicode character processing for composition. The previous change in 3.141.5.1 for using composed Unicode character sequences on send and decomposed on retrieve was disturbingly naive, and entirely incorrect. This revision mostly reverts that change, with the difference of checking for "single-character" encoding sequences when sending. The IE driver will no longer produce the same input for some key combinations as other drivers (see some Hangul sequences for concrete examples). The mitigating factor of this difference in behavior, however, is that the driver should now produce identical input and output between sending keys and reading the text via either getting an element's text or its attributes. Hopefully. There are likely to continue to be corner cases where use of Unicode characters, does not entirely match up to expectations. This is particularly so in languages where individual code points can be combined to form other glyphs semantically or visually identical to other individual code points.
2019-01-28 16:39:20 -08:00
if (!this->IsSingleKey(key)) {
Throw an error for key actions taking multiple characters in IE The key actions as defined by the W3C WebDriver Specification take a JSON payload that requires the resulting key for the key down or key up action to resolve to a single Unicode code point or a single grapheme cluster (what appears to be a single logical "character" from a user's perspective). The IE driver will now evaluate the item passed into the key down or key up action, and, taking combining characters into account, attempts to make sure there is only a single grapheme present, if more than one Unicode code point is sent. If the entered string would results in multiple grapheme clusters, the driver now returns an invalid argument error, as per the spec.
2018-05-01 13:02:45 -07:00
return EINVALIDARGUMENT;
}
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
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 {
Internal IE driver API change GetWindowHandle to GetContentWindowHandle Changing the base DocumentHost class to use GetContentWindowHandle as the method name for the method to get the content window handle.
2014-12-15 11:34:03 -05:00
HWND window_handle = browser_wrapper->GetContentWindowHandle();
Updating sending of keystrokes to send keys outside the BMP in IE
2018-02-22 16:14:27 -08:00
this->AddKeyboardInput(window_handle, key, false, input_state);
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
}
return status_code;
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
int InputManager::KeyUp(BrowserHandle browser_wrapper,
const Json::Value& up_action,
InputState* input_state) {
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
int status_code = WD_SUCCESS;
std::string key_value = up_action["value"].asString();
std::wstring key = StringUtilities::ToWString(key_value);
Again updated Unicode character processing for composition. The previous change in 3.141.5.1 for using composed Unicode character sequences on send and decomposed on retrieve was disturbingly naive, and entirely incorrect. This revision mostly reverts that change, with the difference of checking for "single-character" encoding sequences when sending. The IE driver will no longer produce the same input for some key combinations as other drivers (see some Hangul sequences for concrete examples). The mitigating factor of this difference in behavior, however, is that the driver should now produce identical input and output between sending keys and reading the text via either getting an element's text or its attributes. Hopefully. There are likely to continue to be corner cases where use of Unicode characters, does not entirely match up to expectations. This is particularly so in languages where individual code points can be combined to form other glyphs semantically or visually identical to other individual code points.
2019-01-28 16:39:20 -08:00
if (!this->IsSingleKey(key)) {
Throw an error for key actions taking multiple characters in IE The key actions as defined by the W3C WebDriver Specification take a JSON payload that requires the resulting key for the key down or key up action to resolve to a single Unicode code point or a single grapheme cluster (what appears to be a single logical "character" from a user's perspective). The IE driver will now evaluate the item passed into the key down or key up action, and, taking combining characters into account, attempts to make sure there is only a single grapheme present, if more than one Unicode code point is sent. If the entered string would results in multiple grapheme clusters, the driver now returns an invalid argument error, as per the spec.
2018-05-01 13:02:45 -07:00
return EINVALIDARGUMENT;
}
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
if (!this->action_simulator_->UseExtraInfo()) {
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
HWND window_handle = browser_wrapper->GetContentWindowHandle();
Updating sending of keystrokes to send keys outside the BMP in IE
2018-02-22 16:14:27 -08:00
this->AddKeyboardInput(window_handle, key, true, input_state);
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
JimEvans: Introduced the "requireWindowFocus" capability into the IE driver. When used in conjunction with the "nativeEvents" capability, the driver will attempt to bring the current IE window to the foreground before executing a mouse or keyboard event. Also, when the requireWindowFocus capability is set to true, advanced user interactions will now use the Windows SendInput() API to execute the interactions. To enable this behavior, set the value of the requiresWindowFocus capability to "true" when creating an instance of the IE driver. The default for this new capability is "false". This functionality is currently considered extremely experimental; use at your own risk. r18424
2013-01-08 17:10:01 +00:00
return status_code;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Again updated Unicode character processing for composition. The previous change in 3.141.5.1 for using composed Unicode character sequences on send and decomposed on retrieve was disturbingly naive, and entirely incorrect. This revision mostly reverts that change, with the difference of checking for "single-character" encoding sequences when sending. The IE driver will no longer produce the same input for some key combinations as other drivers (see some Hangul sequences for concrete examples). The mitigating factor of this difference in behavior, however, is that the driver should now produce identical input and output between sending keys and reading the text via either getting an element's text or its attributes. Hopefully. There are likely to continue to be corner cases where use of Unicode characters, does not entirely match up to expectations. This is particularly so in languages where individual code points can be combined to form other glyphs semantically or visually identical to other individual code points.
2019-01-28 16:39:20 -08:00
bool InputManager::IsSingleKey(const std::wstring& input) {
Throw an error for key actions taking multiple characters in IE The key actions as defined by the W3C WebDriver Specification take a JSON payload that requires the resulting key for the key down or key up action to resolve to a single Unicode code point or a single grapheme cluster (what appears to be a single logical "character" from a user's perspective). The IE driver will now evaluate the item passed into the key down or key up action, and, taking combining characters into account, attempts to make sure there is only a single grapheme present, if more than one Unicode code point is sent. If the entered string would results in multiple grapheme clusters, the driver now returns an invalid argument error, as per the spec.
2018-05-01 13:02:45 -07:00
bool is_single_key = true;
Again updated Unicode character processing for composition. The previous change in 3.141.5.1 for using composed Unicode character sequences on send and decomposed on retrieve was disturbingly naive, and entirely incorrect. This revision mostly reverts that change, with the difference of checking for "single-character" encoding sequences when sending. The IE driver will no longer produce the same input for some key combinations as other drivers (see some Hangul sequences for concrete examples). The mitigating factor of this difference in behavior, however, is that the driver should now produce identical input and output between sending keys and reading the text via either getting an element's text or its attributes. Hopefully. There are likely to continue to be corner cases where use of Unicode characters, does not entirely match up to expectations. This is particularly so in languages where individual code points can be combined to form other glyphs semantically or visually identical to other individual code points.
2019-01-28 16:39:20 -08:00
//StringUtilities::ComposeUnicodeString(input);
std::wstring composed_input = input;
StringUtilities::ComposeUnicodeString(&composed_input);
if (composed_input.size() > 1) {
Throw an error for key actions taking multiple characters in IE The key actions as defined by the W3C WebDriver Specification take a JSON payload that requires the resulting key for the key down or key up action to resolve to a single Unicode code point or a single grapheme cluster (what appears to be a single logical "character" from a user's perspective). The IE driver will now evaluate the item passed into the key down or key up action, and, taking combining characters into account, attempts to make sure there is only a single grapheme present, if more than one Unicode code point is sent. If the entered string would results in multiple grapheme clusters, the driver now returns an invalid argument error, as per the spec.
2018-05-01 13:02:45 -07:00
WORD combining_bitmask = C3_NONSPACING | C3_DIACRITIC | C3_VOWELMARK;
Again updated Unicode character processing for composition. The previous change in 3.141.5.1 for using composed Unicode character sequences on send and decomposed on retrieve was disturbingly naive, and entirely incorrect. This revision mostly reverts that change, with the difference of checking for "single-character" encoding sequences when sending. The IE driver will no longer produce the same input for some key combinations as other drivers (see some Hangul sequences for concrete examples). The mitigating factor of this difference in behavior, however, is that the driver should now produce identical input and output between sending keys and reading the text via either getting an element's text or its attributes. Hopefully. There are likely to continue to be corner cases where use of Unicode characters, does not entirely match up to expectations. This is particularly so in languages where individual code points can be combined to form other glyphs semantically or visually identical to other individual code points.
2019-01-28 16:39:20 -08:00
std::vector<WORD> char_types(input.size());
Throw an error for key actions taking multiple characters in IE The key actions as defined by the W3C WebDriver Specification take a JSON payload that requires the resulting key for the key down or key up action to resolve to a single Unicode code point or a single grapheme cluster (what appears to be a single logical "character" from a user's perspective). The IE driver will now evaluate the item passed into the key down or key up action, and, taking combining characters into account, attempts to make sure there is only a single grapheme present, if more than one Unicode code point is sent. If the entered string would results in multiple grapheme clusters, the driver now returns an invalid argument error, as per the spec.
2018-05-01 13:02:45 -07:00
BOOL get_type_success = ::GetStringTypeW(CT_CTYPE3,
Again updated Unicode character processing for composition. The previous change in 3.141.5.1 for using composed Unicode character sequences on send and decomposed on retrieve was disturbingly naive, and entirely incorrect. This revision mostly reverts that change, with the difference of checking for "single-character" encoding sequences when sending. The IE driver will no longer produce the same input for some key combinations as other drivers (see some Hangul sequences for concrete examples). The mitigating factor of this difference in behavior, however, is that the driver should now produce identical input and output between sending keys and reading the text via either getting an element's text or its attributes. Hopefully. There are likely to continue to be corner cases where use of Unicode characters, does not entirely match up to expectations. This is particularly so in languages where individual code points can be combined to form other glyphs semantically or visually identical to other individual code points.
2019-01-28 16:39:20 -08:00
input.c_str(),
static_cast<int>(input.size()),
Throw an error for key actions taking multiple characters in IE The key actions as defined by the W3C WebDriver Specification take a JSON payload that requires the resulting key for the key down or key up action to resolve to a single Unicode code point or a single grapheme cluster (what appears to be a single logical "character" from a user's perspective). The IE driver will now evaluate the item passed into the key down or key up action, and, taking combining characters into account, attempts to make sure there is only a single grapheme present, if more than one Unicode code point is sent. If the entered string would results in multiple grapheme clusters, the driver now returns an invalid argument error, as per the spec.
2018-05-01 13:02:45 -07:00
&char_types[0]);
if (get_type_success) {
bool found_alpha = false;
Adding ability to return extended error info from IE actions
2018-05-26 08:23:21 -07:00
for (size_t i = 0; i < char_types.size(); ++i) {
Throw an error for key actions taking multiple characters in IE The key actions as defined by the W3C WebDriver Specification take a JSON payload that requires the resulting key for the key down or key up action to resolve to a single Unicode code point or a single grapheme cluster (what appears to be a single logical "character" from a user's perspective). The IE driver will now evaluate the item passed into the key down or key up action, and, taking combining characters into account, attempts to make sure there is only a single grapheme present, if more than one Unicode code point is sent. If the entered string would results in multiple grapheme clusters, the driver now returns an invalid argument error, as per the spec.
2018-05-01 13:02:45 -07:00
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;
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
int InputManager::Pause(BrowserHandle browser_wrapper,
const Json::Value& pause_action) {
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
int status_code = 0;
Allowing duration property of pause actions to be omitted for IE
2018-10-09 20:54:07 -07:00
int duration = 0;
if (pause_action.isMember("duration")) {
duration = pause_action["duration"].asInt();
}
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
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);
}
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
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;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
mouse_input.mi.dx = x;
mouse_input.mi.dy = y;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
mouse_input.mi.dwExtraInfo = 0;
mouse_input.mi.mouseData = 0;
mouse_input.mi.time = 0;
Updating reset action for IE driver
2018-07-10 11:59:54 -07:00
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);
}
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
this->inputs_.push_back(mouse_input);
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
void InputManager::AddKeyboardInput(HWND window_handle,
Updating sending of keystrokes to send keys outside the BMP in IE
2018-02-22 16:14:27 -08:00
std::wstring key,
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
bool key_up,
InputState* input_state) {
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
LOG(TRACE) << "Entering InputManager::AddKeyboardInput";
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
Updating sending of keystrokes to send keys outside the BMP in IE
2018-02-22 16:14:27 -08:00
wchar_t character = key[0];
std::wstring log_key = key;
if (key.size() == 1) {
log_key = this->GetKeyDescription(character);
}
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
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) << ")";
Updating sending of keystrokes to send keys outside the BMP in IE
2018-02-22 16:14:27 -08:00
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) {
Fixing uninitialized variable in IE
2019-02-01 07:37:14 -08:00
KeyInfo surrogate_key_info = { 0, 0, false, false, false, false, L'\0' };
Updating sending of keystrokes to send keys outside the BMP in IE
2018-02-22 16:14:27 -08:00
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;
}
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
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) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
KeyInfo modifier_key_info = { 0, 0, false, false, false, false, character };
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
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;
}
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
if (this->IsModifierKey(character)) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
KeyInfo modifier_key_info = { 0, 0, false, false, false, false, character };
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
// 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 ||
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
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);
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
modifier_key_info.key_code = VK_SHIFT;
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
modifier_key_info.scan_code = scan_code;
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
this->CreateKeyboardInputItem(modifier_key_info,
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
KEYEVENTF_SCANCODE,
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
input_state->is_shift_pressed);
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (input_state->is_shift_pressed) {
input_state->is_shift_pressed = false;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
} else {
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
input_state->is_shift_pressed = true;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
this->UpdatePressedKeys(character, input_state->is_shift_pressed);
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
// 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 ||
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
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);
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
modifier_key_info.key_code = VK_CONTROL;
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
modifier_key_info.scan_code = scan_code;
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
this->CreateKeyboardInputItem(modifier_key_info,
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
KEYEVENTF_SCANCODE,
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
input_state->is_control_pressed);
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (input_state->is_control_pressed) {
input_state->is_control_pressed = false;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
} else {
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
input_state->is_control_pressed = true;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
this->UpdatePressedKeys(character, input_state->is_control_pressed);
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
// 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 ||
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
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);
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
modifier_key_info.key_code = VK_MENU;
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
modifier_key_info.scan_code = scan_code;
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
this->CreateKeyboardInputItem(modifier_key_info,
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
KEYEVENTF_SCANCODE,
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
input_state->is_alt_pressed);
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (input_state->is_alt_pressed) {
input_state->is_alt_pressed = false;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
} else {
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
input_state->is_alt_pressed = true;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
this->UpdatePressedKeys(character, input_state->is_alt_pressed);
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
// 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 ||
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
character == WD_KEY_R_META) {
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
//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);
}
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
return;
}
Prevent keyup actions if key is not already down for IE This change now checks that a specified key is down before sending any input events when a keyUp action is specified. This prevents spurious events detected by the browser, events which cannot happen with an actual user.
2018-07-16 09:10:29 -07:00
if (key_up && !this->IsKeyPressed(character)) {
return;
}
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
this->UpdatePressedKeys(character, !key_up);
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
KeyInfo key_info = this->GetKeyInfo(window_handle, character);
Updating IE driver to properly handle carriage return ('\r') character
2017-11-02 10:37:20 -07:00
if (key_info.is_ignored_key) {
return;
}
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
if (!key_info.is_webdriver_key) {
if (!key_info.scan_code || (key_info.key_code == 0xFFFFU)) {
Removing tab characters from IE driver source code. No functional changes.
2013-04-11 11:56:51 -04:00
LOG(WARN) << "No translation for key. Assuming unicode input: " << character;
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
key_info.scan_code = static_cast<WORD>(character);
key_info.key_code = 0;
key_info.is_extended_key = false;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
this->CreateKeyboardInputItem(key_info, KEYEVENTF_UNICODE, key_up);
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
return;
Removing tab characters from IE driver source code. No functional changes.
2013-04-11 11:56:51 -04:00
}
}
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
Updating IE driver to better handle non-US keyboards in sendKeys In the transition to support the W3C specification, using sendKeys on non-US keyboard layouts got broken. This is an attempt to resolve that issue. Previously, we were only checking a high-order byte for the need to press the shift key, and not other modifier keys (control or alt) in sending keystrokes. This behavior has been restored. Fixes issue #4253.
2018-02-12 07:29:53 -08:00
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.
Code formatting and internal API cleanup for IE driver
2018-02-13 07:37:13 -08:00
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;
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (!key_up) {
Updating IE driver to better handle non-US keyboards in sendKeys In the transition to support the W3C specification, using sendKeys on non-US keyboard layouts got broken. This is an attempt to resolve that issue. Previously, we were only checking a high-order byte for the need to press the shift key, and not other modifier keys (control or alt) in sending keystrokes. This behavior has been restored. Fixes issue #4253.
2018-02-12 07:29:53 -08:00
if (is_shift_required) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
KeyInfo shift_key_info = { VK_SHIFT, 0, false, false, false, false, character };
Updating IE driver to better handle non-US keyboards in sendKeys In the transition to support the W3C specification, using sendKeys on non-US keyboard layouts got broken. This is an attempt to resolve that issue. Previously, we were only checking a high-order byte for the need to press the shift key, and not other modifier keys (control or alt) in sending keystrokes. This behavior has been restored. Fixes issue #4253.
2018-02-12 07:29:53 -08:00
this->CreateKeyboardInputItem(shift_key_info, 0, false);
}
if (is_control_required) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
KeyInfo control_key_info = { VK_CONTROL, 0, false, false, false, false, character };
Updating IE driver to better handle non-US keyboards in sendKeys In the transition to support the W3C specification, using sendKeys on non-US keyboard layouts got broken. This is an attempt to resolve that issue. Previously, we were only checking a high-order byte for the need to press the shift key, and not other modifier keys (control or alt) in sending keystrokes. This behavior has been restored. Fixes issue #4253.
2018-02-12 07:29:53 -08:00
this->CreateKeyboardInputItem(control_key_info, 0, false);
}
if (is_alt_required) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
KeyInfo alt_key_info = { VK_MENU, 0, false, false, false, false, character };
Updating IE driver to better handle non-US keyboards in sendKeys In the transition to support the W3C specification, using sendKeys on non-US keyboard layouts got broken. This is an attempt to resolve that issue. Previously, we were only checking a high-order byte for the need to press the shift key, and not other modifier keys (control or alt) in sending keystrokes. This behavior has been restored. Fixes issue #4253.
2018-02-12 07:29:53 -08:00
this->CreateKeyboardInputItem(alt_key_info, 0, false);
}
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
}
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
this->CreateKeyboardInputItem(key_info, KEYEVENTF_SCANCODE, key_up);
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
if (key_up) {
Updating IE driver to better handle non-US keyboards in sendKeys In the transition to support the W3C specification, using sendKeys on non-US keyboard layouts got broken. This is an attempt to resolve that issue. Previously, we were only checking a high-order byte for the need to press the shift key, and not other modifier keys (control or alt) in sending keystrokes. This behavior has been restored. Fixes issue #4253.
2018-02-12 07:29:53 -08:00
if (is_shift_required) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
KeyInfo shift_key_info = { VK_SHIFT, 0, false, false, false, false, character };
Updating IE driver to better handle non-US keyboards in sendKeys In the transition to support the W3C specification, using sendKeys on non-US keyboard layouts got broken. This is an attempt to resolve that issue. Previously, we were only checking a high-order byte for the need to press the shift key, and not other modifier keys (control or alt) in sending keystrokes. This behavior has been restored. Fixes issue #4253.
2018-02-12 07:29:53 -08:00
this->CreateKeyboardInputItem(shift_key_info, 0, true);
}
if (is_control_required) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
KeyInfo control_key_info = { VK_CONTROL, 0, false, false, false, false, character };
Updating IE driver to better handle non-US keyboards in sendKeys In the transition to support the W3C specification, using sendKeys on non-US keyboard layouts got broken. This is an attempt to resolve that issue. Previously, we were only checking a high-order byte for the need to press the shift key, and not other modifier keys (control or alt) in sending keystrokes. This behavior has been restored. Fixes issue #4253.
2018-02-12 07:29:53 -08:00
this->CreateKeyboardInputItem(control_key_info, 0, true);
}
if (is_alt_required) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
KeyInfo alt_key_info = { VK_MENU, 0, false, false, false, false, character };
Updating IE driver to better handle non-US keyboards in sendKeys In the transition to support the W3C specification, using sendKeys on non-US keyboard layouts got broken. This is an attempt to resolve that issue. Previously, we were only checking a high-order byte for the need to press the shift key, and not other modifier keys (control or alt) in sending keystrokes. This behavior has been restored. Fixes issue #4253.
2018-02-12 07:29:53 -08:00
this->CreateKeyboardInputItem(alt_key_info, 0, true);
}
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
}
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
} else {
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
this->CreateKeyboardInputItem(key_info, 0, key_up);
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
}
}
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
bool InputManager::IsKeyPressed(wchar_t character) {
return std::find(this->pressed_keys_.begin(),
this->pressed_keys_.end(),
character) != this->pressed_keys_.end();
}
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
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);
}
}
}
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
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;
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
input_element.ki.dwExtraInfo = key_info.character;
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
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;
}
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
if (key_info.is_force_scan_code) {
input_element.ki.dwFlags |= KEYEVENTF_SCANCODE;
}
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
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 ||
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
character == WD_KEY_META ||
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
character == WD_KEY_R_SHIFT ||
character == WD_KEY_R_CONTROL ||
character == WD_KEY_R_ALT ||
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
character == WD_KEY_R_META ||
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
character == WD_KEY_NULL;
}
KeyInfo InputManager::GetKeyInfo(HWND window_handle, wchar_t character) {
KeyInfo key_info;
Updating IE driver to properly handle carriage return ('\r') character
2017-11-02 10:37:20 -07:00
key_info.is_ignored_key = false;
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
key_info.is_extended_key = false;
key_info.is_webdriver_key = true;
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
key_info.is_force_scan_code = false;
Updating IE driver to properly handle carriage return ('\r') character
2017-11-02 10:37:20 -07:00
key_info.key_code = 0;
key_info.scan_code = 0;
Refactoring user input simulation code in IE driver This commit breaks out the three modes of user input simulation (native events using SendMessage, native events using SendInput, simulated events using JavaScript) into separate classes, making it easier to debug. Additionally, this commit removes the code for enabling persistent hovers. This code had been inadvertently disabled in a separate refactor some months ago, and there have been no issue reports in that area, leading the IE driver development team to believe that the issue in IE that required persistent hovers has been resolved (at least in IE11). The code for persistent hovers has been retained in a new, separate class in the project, but this class is not built as part of the IE driver at this time. If issue reports warrent its inclusion in the future, it can be easily re-added.
2018-02-19 16:52:23 -08:00
key_info.character = character;
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
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;
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
key_info.is_extended_key = true;
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
}
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;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
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);
Revamped handling of modifier keys in IE driver The IE driver is now able to distinguish between the left and right modifier keys (Shift, Control, Alt) on the keyboard.
2018-02-23 19:42:36 -08:00
key_info.is_extended_key = true;
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
}
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;
}
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
else if (character == WD_KEY_R_PAGEUP) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
else if (character == WD_KEY_R_PAGEDN) {
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
else if (character == WD_KEY_R_END) { // end
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
else if (character == WD_KEY_R_HOME) { // home
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
else if (character == WD_KEY_R_LEFT) { // left arrow
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
else if (character == WD_KEY_R_UP) { // up arrow
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
else if (character == WD_KEY_R_RIGHT) { // right arrow
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
else if (character == WD_KEY_R_DOWN) { // down arrow
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
else if (character == WD_KEY_R_INSERT) { // insert
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
else if (character == WD_KEY_R_DELETE) { // delete
Fixing proper keyboard event values for number pad keys
2019-01-31 20:39:00 -08:00
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;
Modifying mouse event handling to match W3C Specification THIS IS A POTENTIAL BREAKING CHANGE. The simulation of mouse movement for the actions command now conforms to the W3C WebDriver Specification for mouse movement. This means that offsets in elements are now measured from the center of the element instead of the top-left, which was the previous behavior. Additionally, attempting to move the mouse pointer outside the browser view port will result in a "mouse movement out of bounds" error. While users should be aware that this might cause code using user interactions to fail, not that the behavior is now consistent with the behavior outlined in the specification, and the behavior of geckodriver in particular.
2018-02-23 13:55:26 -08:00
}
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
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
Updating IE driver to properly handle carriage return ('\r') character
2017-11-02 10:37:20 -07:00
key_info.is_ignored_key = true; // skip it
Implementing W3C Specificiation compliance for IE driver This commit adds the remote protocol end points and handling of commands as required by the W3C WebDriver Specification for the IE driver. It deprecates and mostly removes behavior that is at odds with the specification, but may have been the proper behavior under the open-source dialect of the protocol. Issues arising from this version of the driver that appeared to work in previous versions will only be addressed if a simple test case is provided that demonstrates it working in a prior version of the driver and failing in this one. Reported issues lacking such a test case will be summarily closed.
2017-02-22 14:13:25 -08:00
} else {
Refactor of IE requireWindowFocus keyboard code. No functional changes
2015-12-08 10:36:25 -08:00
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;
KristianRosenvold: Removed windows carriage returns
2013-01-11 22:18:32 +01:00
}
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
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";
Updating reset action for IE driver
2018-07-10 11:59:54 -07:00
this->key_descriptions_[WD_MOUSE_LBUTTON] = L"Left Mouse Button";
this->key_descriptions_[WD_MOUSE_RBUTTON] = L"Right Mouse Button";
Updated IE driver to better support W3C WebDriver Specification This is a large update that includes implementation of the following things that are part of the WebDriver spec: * Implement the "get element property" command * Implement the "get named cookie" command * Implement the "minimize window" command * Implement the "fullscreen window" command * Update "set window rect" command to correctly recognize and restore from minimized or full screen state * Fix the "release actions" command to properly roll back all pending actions * Update the "perform actions" command to be more robust for pointer actions * Fix alert handling to handle dialogs with the "Do not show any more dialogs" check box * Added handling for the "dismiss and notify" and "accept and notify" user prompt handler states
2017-08-31 09:41:44 -07:00
}
Making InputManager more robust in the requireWindowFocus case. Previously, using the Windows SendInput API could cause keystrokes and mouse events to be added to the system message queue, but would return back to the caller before those events were processed by Internet Explorer's message loop. This change adds a Windows mouse hook and keyboard hook to monitor when the messages are processed by an applications message loop. There is still a potential race condition, and users may still need to execute some local synchronization code.
2013-05-17 11:01:23 -04:00
} // namespace webdriver
Reference in New Issue Copy Permalink