gecko-dev/testing/marionette/event.js
Maja Frydrychowicz 5095f8b5b8 Bug 1320389 - Implement dispatch of key actions in content context; r=ato
MozReview-Commit-ID: AxHTFdDtXJN

--HG--
extra : rebase_source : 0d12a5f56bcd05d0eccb8aa794779002f555e62d
2016-12-13 18:29:48 -05:00

1355 lines
38 KiB
JavaScript

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// Provides functionality for creating and sending DOM events.
"use strict";
const {interfaces: Ci, utils: Cu, classes: Cc} = Components;
Cu.import("resource://gre/modules/Log.jsm");
const logger = Log.repository.getLogger("Marionette");
Cu.import("chrome://marionette/content/element.js");
Cu.import("chrome://marionette/content/error.js");
this.EXPORTED_SYMBOLS = ["event"];
// must be synchronised with nsIDOMWindowUtils
const COMPOSITION_ATTR_RAWINPUT = 0x02;
const COMPOSITION_ATTR_SELECTEDRAWTEXT = 0x03;
const COMPOSITION_ATTR_CONVERTEDTEXT = 0x04;
const COMPOSITION_ATTR_SELECTEDCONVERTEDTEXT = 0x05;
// TODO(ato): Document!
let seenEvent = false;
function getDOMWindowUtils(win) {
if (!win) {
win = window;
}
// this assumes we are operating in chrome space
return win.QueryInterface(Ci.nsIInterfaceRequestor)
.getInterface(Ci.nsIDOMWindowUtils);
}
this.event = {};
event.MouseEvents = {
click: 0,
dblclick: 1,
mousedown: 2,
mouseup: 3,
mouseover: 4,
mouseout: 5,
};
event.Modifiers = {
shiftKey: 0,
ctrlKey: 1,
altKey: 2,
metaKey: 3,
};
/**
* Sends a mouse event to given target.
*
* @param {nsIDOMMouseEvent} mouseEvent
* Event to send.
* @param {(DOMElement|string)} target
* Target of event. Can either be an element or the ID of an element.
* @param {Window=} window
* Window object. Defaults to the current window.
*
* @throws {TypeError}
* If the event is unsupported.
*/
event.sendMouseEvent = function (mouseEvent, target, window = undefined) {
if (!event.MouseEvents.hasOwnProperty(mouseEvent.type)) {
throw new TypeError("Unsupported event type: " + mouseEvent.type);
}
if (!target.nodeType && typeof target != "string") {
throw new TypeError("Target can only be a DOM element or a string: " + target);
}
if (!target.nodeType) {
target = window.document.getElementById(target);
} else {
window = window || target.ownerDocument.defaultView;
}
let ev = window.document.createEvent("MouseEvent");
let type = mouseEvent.type;
let view = window;
let detail = mouseEvent.detail;
if (!detail) {
if (mouseEvent.type in ["click", "mousedown", "mouseup"]) {
detail = 1;
} else if (mouseEvent.type == "dblclick") {
detail = 2;
} else {
detail = 0;
}
}
let screenX = mouseEvent.screenX || 0;
let screenY = mouseEvent.screenY || 0;
let clientX = mouseEvent.clientX || 0;
let clientY = mouseEvent.clientY || 0;
let ctrlKey = mouseEvent.ctrlKey || false;
let altKey = mouseEvent.altKey || false;
let shiftKey = mouseEvent.shiftKey || false;
let metaKey = mouseEvent.metaKey || false;
let button = mouseEvent.button || 0;
let relatedTarget = mouseEvent.relatedTarget || null;
ev.initMouseEvent(
mouseEvent.type,
/* canBubble */ true,
/* cancelable */ true,
view,
detail,
screenX,
screenY,
clientX,
clientY,
ctrlKey,
altKey,
shiftKey,
metaKey,
button,
relatedTarget);
};
/**
* Send character to the currently focused element.
*
* This function handles casing of characters (sends the right charcode,
* and sends a shift key for uppercase chars). No other modifiers are
* handled at this point.
*
* For now this method only works for English letters (lower and upper
* case) and the digits 0-9.
*/
event.sendChar = function (char, window = undefined) {
// DOM event charcodes match ASCII (JS charcodes) for a-zA-Z0-9
let hasShift = (char == char.toUpperCase());
event.synthesizeKey(char, {shiftKey: hasShift}, window);
};
/**
* Send string to the focused element.
*
* For now this method only works for English letters (lower and upper
* case) and the digits 0-9.
*/
event.sendString = function (string, window = undefined) {
for (let i = 0; i < string.length; ++i) {
event.sendChar(string.charAt(i), window);
}
};
/**
* Send the non-character key to the focused element.
*
* The name of the key should be the part that comes after "DOM_VK_"
* in the nsIDOMKeyEvent constant name for this key. No modifiers are
* handled at this point.
*/
event.sendKey = function (key, window = undefined) {
let keyName = "VK_" + key.toUpperCase();
event.synthesizeKey(keyName, {shiftKey: false}, window);
};
// TODO(ato): Unexpose this when action.Chain#emitMouseEvent
// no longer emits its own events
event.parseModifiers_ = function (modifiers) {
let mval = 0;
if (modifiers.shiftKey) {
mval |= Ci.nsIDOMNSEvent.SHIFT_MASK;
}
if (modifiers.ctrlKey) {
mval |= Ci.nsIDOMNSEvent.CONTROL_MASK;
}
if (modifiers.altKey) {
mval |= Ci.nsIDOMNSEvent.ALT_MASK;
}
if (modifiers.metaKey) {
mval |= Ci.nsIDOMNSEvent.META_MASK;
}
if (modifiers.accelKey) {
if (navigator.platform.indexOf("Mac") >= 0) {
mval |= Ci.nsIDOMNSEvent.META_MASK;
} else {
mval |= Ci.nsIDOMNSEvent.CONTROL_MASK;
}
}
return mval;
};
/**
* Synthesise a mouse event on a target.
*
* The actual client point is determined by taking the aTarget's client
* box and offseting it by offsetX and offsetY. This allows mouse clicks
* to be simulated by calling this method.
*
* If the type is specified, an mouse event of that type is
* fired. Otherwise, a mousedown followed by a mouse up is performed.
*
* @param {Element} element
* Element to click.
* @param {number} offsetX
* Horizontal offset to click from the target's bounding box.
* @param {number} offsetY
* Vertical offset to click from the target's bounding box.
* @param {Object.<string, ?>} opts
* Object which may contain the properties "shiftKey", "ctrlKey",
* "altKey", "metaKey", "accessKey", "clickCount", "button", and
* "type".
* @param {Window=} window
* Window object. Defaults to the current window.
*/
event.synthesizeMouse = function (
element, offsetX, offsetY, opts, window = undefined) {
let rect = element.getBoundingClientRect();
event.synthesizeMouseAtPoint(
rect.left + offsetX, rect.top + offsetY, opts, window);
};
/*
* Synthesize a mouse event at a particular point in a window.
*
* If the type of the event is specified, a mouse event of that type is
* fired. Otherwise, a mousedown followed by a mouse up is performed.
*
* @param {number} left
* CSS pixels from the left document margin.
* @param {number} top
* CSS pixels from the top document margin.
* @param {Object.<string, ?>} event
* Object which may contain the properties "shiftKey", "ctrlKey",
* "altKey", "metaKey", "accessKey", "clickCount", "button", and
* "type".
* @param {Window=} window
* Window object. Defaults to the current window.
*/
event.synthesizeMouseAtPoint = function (
left, top, opts, window = undefined) {
let domutils = getDOMWindowUtils(window);
let button = opts.button || 0;
let clickCount = opts.clickCount || 1;
let modifiers = event.parseModifiers_(opts);
if (("type" in event) && opts.type) {
domutils.sendMouseEvent(
opts.type, left, top, button, clickCount, modifiers);
} else {
domutils.sendMouseEvent(
"mousedown", left, top, button, clickCount, modifiers);
domutils.sendMouseEvent(
"mouseup", left, top, button, clickCount, modifiers);
}
};
/**
* Call event.synthesizeMouse with coordinates at the centre of the
* target.
*/
event.synthesizeMouseAtCenter = function (element, event, window) {
let rect = element.getBoundingClientRect();
event.synthesizeMouse(
element,
rect.width / 2,
rect.height / 2,
event,
window);
};
/**
* Synthesise a mouse scroll event on a target.
*
* The actual client point is determined by taking the target's client
* box and offseting it by |offsetX| and |offsetY|.
*
* If the |type| property is specified for the |event| argument, a mouse
* scroll event of that type is fired. Otherwise, DOMMouseScroll is used.
*
* If the |axis| is specified, it must be one of "horizontal" or
* "vertical". If not specified, "vertical" is used.
*
* |delta| is the amount to scroll by (can be positive or negative).
* It must be specified.
*
* |hasPixels| specifies whether kHasPixels should be set in the
* |scrollFlags|.
*
* |isMomentum| specifies whether kIsMomentum should be set in the
* |scrollFlags|.
*
* @param {Element} target
* @param {number} offsetY
* @param {number} offsetY
* @param {Object.<string, ?>} event
* Object which may contain the properties shiftKey, ctrlKey, altKey,
* metaKey, accessKey, button, type, axis, delta, and hasPixels.
* @param {Window=} window
* Window object. Defaults to the current window.
*/
event.synthesizeMouseScroll = function (
target, offsetX, offsetY, ev, window = undefined) {
let domutils = getDOMWindowUtils(window);
// see nsMouseScrollFlags in nsGUIEvent.h
const kIsVertical = 0x02;
const kIsHorizontal = 0x04;
const kHasPixels = 0x08;
const kIsMomentum = 0x40;
let button = ev.button || 0;
let modifiers = event.parseModifiers_(ev);
let rect = target.getBoundingClientRect();
let left = rect.left;
let top = rect.top;
let type = (("type" in ev) && ev.type) || "DOMMouseScroll";
let axis = ev.axis || "vertical";
let scrollFlags = (axis == "horizontal") ? kIsHorizontal : kIsVertical;
if (ev.hasPixels) {
scrollFlags |= kHasPixels;
}
if (ev.isMomentum) {
scrollFlags |= kIsMomentum;
}
domutils.sendMouseScrollEvent(
type,
left + offsetX,
top + offsetY,
button,
scrollFlags,
ev.delta,
modifiers);
};
function computeKeyCodeFromChar_(char) {
if (char.length != 1) {
return 0;
}
if (char >= "a" && char <= "z") {
return Ci.nsIDOMKeyEvent.DOM_VK_A + char.charCodeAt(0) - "a".charCodeAt(0);
}
if (char >= "A" && char <= "Z") {
return Ci.nsIDOMKeyEvent.DOM_VK_A + char.charCodeAt(0) - "A".charCodeAt(0);
}
if (char >= "0" && char <= "9") {
return Ci.nsIDOMKeyEvent.DOM_VK_0 + char.charCodeAt(0) - "0".charCodeAt(0);
}
// returns US keyboard layout's keycode
switch (char) {
case "~":
case "`":
return Ci.nsIDOMKeyEvent.DOM_VK_BACK_QUOTE;
case "!":
return Ci.nsIDOMKeyEvent.DOM_VK_1;
case "@":
return Ci.nsIDOMKeyEvent.DOM_VK_2;
case "#":
return Ci.nsIDOMKeyEvent.DOM_VK_3;
case "$":
return Ci.nsIDOMKeyEvent.DOM_VK_4;
case "%":
return Ci.nsIDOMKeyEvent.DOM_VK_5;
case "^":
return Ci.nsIDOMKeyEvent.DOM_VK_6;
case "&":
return Ci.nsIDOMKeyEvent.DOM_VK_7;
case "*":
return Ci.nsIDOMKeyEvent.DOM_VK_8;
case "(":
return Ci.nsIDOMKeyEvent.DOM_VK_9;
case ")":
return Ci.nsIDOMKeyEvent.DOM_VK_0;
case "-":
case "_":
return Ci.nsIDOMKeyEvent.DOM_VK_SUBTRACT;
case "+":
case "=":
return Ci.nsIDOMKeyEvent.DOM_VK_EQUALS;
case "{":
case "[":
return Ci.nsIDOMKeyEvent.DOM_VK_OPEN_BRACKET;
case "}":
case "]":
return Ci.nsIDOMKeyEvent.DOM_VK_CLOSE_BRACKET;
case "|":
case "\\":
return Ci.nsIDOMKeyEvent.DOM_VK_BACK_SLASH;
case ":":
case ";":
return Ci.nsIDOMKeyEvent.DOM_VK_SEMICOLON;
case "'":
case "\"":
return Ci.nsIDOMKeyEvent.DOM_VK_QUOTE;
case "<":
case ",":
return Ci.nsIDOMKeyEvent.DOM_VK_COMMA;
case ">":
case ".":
return Ci.nsIDOMKeyEvent.DOM_VK_PERIOD;
case "?":
case "/":
return Ci.nsIDOMKeyEvent.DOM_VK_SLASH;
case "\n":
return Ci.nsIDOMKeyEvent.DOM_VK_RETURN;
default:
return 0;
}
}
/**
* Returns true if the given key should cause keypress event when widget
* handles the native key event. Otherwise, false.
*
* The key code should be one of consts of nsIDOMKeyEvent.DOM_VK_*,
* or a key name begins with "VK_", or a character.
*/
event.isKeypressFiredKey = function (key) {
if (typeof key == "string") {
if (key.indexOf("VK_") === 0) {
key = Ci.nsIDOMKeyEvent["DOM_" + key];
if (!key) {
throw new TypeError("Unknown key: " + key);
}
// if key generates a character, it must cause a keypress event
} else {
return true;
}
}
switch (key) {
case Ci.nsIDOMKeyEvent.DOM_VK_SHIFT:
case Ci.nsIDOMKeyEvent.DOM_VK_CONTROL:
case Ci.nsIDOMKeyEvent.DOM_VK_ALT:
case Ci.nsIDOMKeyEvent.DOM_VK_CAPS_LOCK:
case Ci.nsIDOMKeyEvent.DOM_VK_NUM_LOCK:
case Ci.nsIDOMKeyEvent.DOM_VK_SCROLL_LOCK:
case Ci.nsIDOMKeyEvent.DOM_VK_META:
return false;
default:
return true;
}
};
/**
* Synthesise a key event.
*
* It is targeted at whatever would be targeted by an actual keypress
* by the user, typically the focused element.
*
* @param {string} key
* Key to synthesise. Should either be a character or a key code
* starting with "VK_" such as VK_RETURN, or a normalized key value.
* @param {Object.<string, ?>} event
* Object which may contain the properties shiftKey, ctrlKey, altKey,
* metaKey, accessKey, type. If the type is specified (keydown or keyup),
* a key event of that type is fired. Otherwise, a keydown, a keypress,
* and then a keyup event are fired in sequence.
* @param {Window=} window
* Window object. Defaults to the current window.
*
* @throws {TypeError}
* If unknown key.
*/
event.synthesizeKey = function (key, event, win = undefined)
{
var TIP = getTIP_(win);
if (!TIP) {
return;
}
var KeyboardEvent = getKeyboardEvent_(win);
var modifiers = emulateToActivateModifiers_(TIP, event, win);
var keyEventDict = createKeyboardEventDictionary_(key, event, win);
var keyEvent = new KeyboardEvent("", keyEventDict.dictionary);
var dispatchKeydown =
!("type" in event) || event.type === "keydown" || !event.type;
var dispatchKeyup =
!("type" in event) || event.type === "keyup" || !event.type;
try {
if (dispatchKeydown) {
TIP.keydown(keyEvent, keyEventDict.flags);
if ("repeat" in event && event.repeat > 1) {
keyEventDict.dictionary.repeat = true;
var repeatedKeyEvent = new KeyboardEvent("", keyEventDict.dictionary);
for (var i = 1; i < event.repeat; i++) {
TIP.keydown(repeatedKeyEvent, keyEventDict.flags);
}
}
}
if (dispatchKeyup) {
TIP.keyup(keyEvent, keyEventDict.flags);
}
} finally {
emulateToInactivateModifiers_(TIP, modifiers, win);
}
};
var TIPMap = new WeakMap();
function getTIP_(win, callback)
{
if (!win) {
win = window;
}
var tip;
if (TIPMap.has(win)) {
tip = TIPMap.get(win);
} else {
tip =
Cc["@mozilla.org/text-input-processor;1"].
createInstance(Ci.nsITextInputProcessor);
TIPMap.set(win, tip);
}
if (!tip.beginInputTransactionForTests(win, callback)) {
tip = null;
TIPMap.delete(win);
}
return tip;
}
function getKeyboardEvent_(win = window)
{
if (typeof KeyboardEvent != "undefined") {
try {
// See if the object can be instantiated; sometimes this yields
// 'TypeError: can't access dead object' or 'KeyboardEvent is not a constructor'.
new KeyboardEvent("", {});
return KeyboardEvent;
} catch (ex) {}
}
if (typeof content != "undefined" && ("KeyboardEvent" in content)) {
return content.KeyboardEvent;
}
return win.KeyboardEvent;
}
function createKeyboardEventDictionary_(key, keyEvent, win = window) {
var result = { dictionary: null, flags: 0 };
var keyCodeIsDefined = "keyCode" in keyEvent;
var keyCode =
(keyCodeIsDefined && keyEvent.keyCode >= 0 && keyEvent.keyCode <= 255) ?
keyEvent.keyCode : 0;
var keyName = "Unidentified";
if (key.indexOf("KEY_") == 0) {
keyName = key.substr("KEY_".length);
result.flags |= Ci.nsITextInputProcessor.KEY_NON_PRINTABLE_KEY;
} else if (key.indexOf("VK_") == 0) {
keyCode = Ci.nsIDOMKeyEvent["DOM_" + key];
if (!keyCode) {
throw "Unknown key: " + key;
}
keyName = guessKeyNameFromKeyCode_(keyCode, win);
result.flags |= Ci.nsITextInputProcessor.KEY_NON_PRINTABLE_KEY;
} else if (key != "") {
keyName = key;
if (!keyCodeIsDefined) {
keyCode = computeKeyCodeFromChar_(key.charAt(0));
}
if (!keyCode) {
result.flags |= Ci.nsITextInputProcessor.KEY_KEEP_KEYCODE_ZERO;
}
// keyName was already determined in keyEvent so no fall-back needed
if (!("key" in keyEvent && keyName == keyEvent.key)) {
result.flags |= Ci.nsITextInputProcessor.KEY_FORCE_PRINTABLE_KEY;
}
}
var locationIsDefined = "location" in keyEvent;
if (locationIsDefined && keyEvent.location === 0) {
result.flags |= Ci.nsITextInputProcessor.KEY_KEEP_KEY_LOCATION_STANDARD;
}
result.dictionary = {
key: keyName,
code: "code" in keyEvent ? keyEvent.code : "",
location: locationIsDefined ? keyEvent.location : 0,
repeat: "repeat" in keyEvent ? keyEvent.repeat === true : false,
keyCode: keyCode,
};
return result;
}
function emulateToActivateModifiers_(TIP, keyEvent, win = window)
{
if (!keyEvent) {
return null;
}
var KeyboardEvent = getKeyboardEvent_(win);
var navigator = getNavigator_(win);
var modifiers = {
normal: [
{ key: "Alt", attr: "altKey" },
{ key: "AltGraph", attr: "altGraphKey" },
{ key: "Control", attr: "ctrlKey" },
{ key: "Fn", attr: "fnKey" },
{ key: "Meta", attr: "metaKey" },
{ key: "OS", attr: "osKey" },
{ key: "Shift", attr: "shiftKey" },
{ key: "Symbol", attr: "symbolKey" },
{ key: isMac_(win) ? "Meta" : "Control",
attr: "accelKey" },
],
lockable: [
{ key: "CapsLock", attr: "capsLockKey" },
{ key: "FnLock", attr: "fnLockKey" },
{ key: "NumLock", attr: "numLockKey" },
{ key: "ScrollLock", attr: "scrollLockKey" },
{ key: "SymbolLock", attr: "symbolLockKey" },
]
}
for (var i = 0; i < modifiers.normal.length; i++) {
if (!keyEvent[modifiers.normal[i].attr]) {
continue;
}
if (TIP.getModifierState(modifiers.normal[i].key)) {
continue; // already activated.
}
var event = new KeyboardEvent("", { key: modifiers.normal[i].key });
TIP.keydown(event,
TIP.KEY_NON_PRINTABLE_KEY | TIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT);
modifiers.normal[i].activated = true;
}
for (var i = 0; i < modifiers.lockable.length; i++) {
if (!keyEvent[modifiers.lockable[i].attr]) {
continue;
}
if (TIP.getModifierState(modifiers.lockable[i].key)) {
continue; // already activated.
}
var event = new KeyboardEvent("", { key: modifiers.lockable[i].key });
TIP.keydown(event,
TIP.KEY_NON_PRINTABLE_KEY | TIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT);
TIP.keyup(event,
TIP.KEY_NON_PRINTABLE_KEY | TIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT);
modifiers.lockable[i].activated = true;
}
return modifiers;
}
function emulateToInactivateModifiers_(TIP, modifiers, win = window)
{
if (!modifiers) {
return;
}
var KeyboardEvent = getKeyboardEvent_(win);
for (var i = 0; i < modifiers.normal.length; i++) {
if (!modifiers.normal[i].activated) {
continue;
}
var event = new KeyboardEvent("", { key: modifiers.normal[i].key });
TIP.keyup(event,
TIP.KEY_NON_PRINTABLE_KEY | TIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT);
}
for (var i = 0; i < modifiers.lockable.length; i++) {
if (!modifiers.lockable[i].activated) {
continue;
}
if (!TIP.getModifierState(modifiers.lockable[i].key)) {
continue; // who already inactivated this?
}
var event = new KeyboardEvent("", { key: modifiers.lockable[i].key });
TIP.keydown(event,
TIP.KEY_NON_PRINTABLE_KEY | TIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT);
TIP.keyup(event,
TIP.KEY_NON_PRINTABLE_KEY | TIP.KEY_DONT_DISPATCH_MODIFIER_KEY_EVENT);
}
}
function getNavigator_(win = window)
{
if (typeof navigator != "undefined") {
return navigator;
}
return win.navigator;
}
function isMac_(win = window) {
if (win) {
try {
return win.navigator.platform.indexOf("Mac") > -1;
} catch (ex) {}
}
return navigator.platform.indexOf("Mac") > -1;
}
function guessKeyNameFromKeyCode_(aKeyCode, win = window)
{
var KeyboardEvent = getKeyboardEvent_(win);
switch (aKeyCode) {
case KeyboardEvent.DOM_VK_CANCEL:
return "Cancel";
case KeyboardEvent.DOM_VK_HELP:
return "Help";
case KeyboardEvent.DOM_VK_BACK_SPACE:
return "Backspace";
case KeyboardEvent.DOM_VK_TAB:
return "Tab";
case KeyboardEvent.DOM_VK_CLEAR:
return "Clear";
case KeyboardEvent.DOM_VK_RETURN:
return "Enter";
case KeyboardEvent.DOM_VK_SHIFT:
return "Shift";
case KeyboardEvent.DOM_VK_CONTROL:
return "Control";
case KeyboardEvent.DOM_VK_ALT:
return "Alt";
case KeyboardEvent.DOM_VK_PAUSE:
return "Pause";
case KeyboardEvent.DOM_VK_EISU:
return "Eisu";
case KeyboardEvent.DOM_VK_ESCAPE:
return "Escape";
case KeyboardEvent.DOM_VK_CONVERT:
return "Convert";
case KeyboardEvent.DOM_VK_NONCONVERT:
return "NonConvert";
case KeyboardEvent.DOM_VK_ACCEPT:
return "Accept";
case KeyboardEvent.DOM_VK_MODECHANGE:
return "ModeChange";
case KeyboardEvent.DOM_VK_PAGE_UP:
return "PageUp";
case KeyboardEvent.DOM_VK_PAGE_DOWN:
return "PageDown";
case KeyboardEvent.DOM_VK_END:
return "End";
case KeyboardEvent.DOM_VK_HOME:
return "Home";
case KeyboardEvent.DOM_VK_LEFT:
return "ArrowLeft";
case KeyboardEvent.DOM_VK_UP:
return "ArrowUp";
case KeyboardEvent.DOM_VK_RIGHT:
return "ArrowRight";
case KeyboardEvent.DOM_VK_DOWN:
return "ArrowDown";
case KeyboardEvent.DOM_VK_SELECT:
return "Select";
case KeyboardEvent.DOM_VK_PRINT:
return "Print";
case KeyboardEvent.DOM_VK_EXECUTE:
return "Execute";
case KeyboardEvent.DOM_VK_PRINTSCREEN:
return "PrintScreen";
case KeyboardEvent.DOM_VK_INSERT:
return "Insert";
case KeyboardEvent.DOM_VK_DELETE:
return "Delete";
case KeyboardEvent.DOM_VK_WIN:
return "OS";
case KeyboardEvent.DOM_VK_CONTEXT_MENU:
return "ContextMenu";
case KeyboardEvent.DOM_VK_SLEEP:
return "Standby";
case KeyboardEvent.DOM_VK_F1:
return "F1";
case KeyboardEvent.DOM_VK_F2:
return "F2";
case KeyboardEvent.DOM_VK_F3:
return "F3";
case KeyboardEvent.DOM_VK_F4:
return "F4";
case KeyboardEvent.DOM_VK_F5:
return "F5";
case KeyboardEvent.DOM_VK_F6:
return "F6";
case KeyboardEvent.DOM_VK_F7:
return "F7";
case KeyboardEvent.DOM_VK_F8:
return "F8";
case KeyboardEvent.DOM_VK_F9:
return "F9";
case KeyboardEvent.DOM_VK_F10:
return "F10";
case KeyboardEvent.DOM_VK_F11:
return "F11";
case KeyboardEvent.DOM_VK_F12:
return "F12";
case KeyboardEvent.DOM_VK_F13:
return "F13";
case KeyboardEvent.DOM_VK_F14:
return "F14";
case KeyboardEvent.DOM_VK_F15:
return "F15";
case KeyboardEvent.DOM_VK_F16:
return "F16";
case KeyboardEvent.DOM_VK_F17:
return "F17";
case KeyboardEvent.DOM_VK_F18:
return "F18";
case KeyboardEvent.DOM_VK_F19:
return "F19";
case KeyboardEvent.DOM_VK_F20:
return "F20";
case KeyboardEvent.DOM_VK_F21:
return "F21";
case KeyboardEvent.DOM_VK_F22:
return "F22";
case KeyboardEvent.DOM_VK_F23:
return "F23";
case KeyboardEvent.DOM_VK_F24:
return "F24";
case KeyboardEvent.DOM_VK_NUM_LOCK:
return "NumLock";
case KeyboardEvent.DOM_VK_SCROLL_LOCK:
return "ScrollLock";
case KeyboardEvent.DOM_VK_VOLUME_MUTE:
return "AudioVolumeMute";
case KeyboardEvent.DOM_VK_VOLUME_DOWN:
return "AudioVolumeDown";
case KeyboardEvent.DOM_VK_VOLUME_UP:
return "AudioVolumeUp";
case KeyboardEvent.DOM_VK_META:
return "Meta";
case KeyboardEvent.DOM_VK_ALTGR:
return "AltGraph";
case KeyboardEvent.DOM_VK_ATTN:
return "Attn";
case KeyboardEvent.DOM_VK_CRSEL:
return "CrSel";
case KeyboardEvent.DOM_VK_EXSEL:
return "ExSel";
case KeyboardEvent.DOM_VK_EREOF:
return "EraseEof";
case KeyboardEvent.DOM_VK_PLAY:
return "Play";
default:
return "Unidentified";
}
}
/**
* Indicate that an event with an original target and type is expected
* to be fired, or not expected to be fired.
*/
function expectEvent_(expectedTarget, expectedEvent, testName) {
if (!expectedTarget || !expectedEvent) {
return null;
}
seenEvent = false;
let type;
if (expectedEvent.charAt(0) == "!") {
type = expectedEvent.substring(1);
} else {
type = expectedEvent;
}
let handler = ev => {
let pass = (!seenEvent && ev.originalTarget == expectedTarget && ev.type == type);
is(pass, true, `${testName} ${type} event target ${seenEvent ? "twice" : ""}`);
seenEvent = true;
};
expectedTarget.addEventListener(type, handler, false);
return handler;
}
/**
* Check if the event was fired or not. The provided event handler will
* be removed.
*/
function checkExpectedEvent_(
expectedTarget, expectedEvent, eventHandler, testName) {
if (eventHandler) {
let expectEvent = (expectedEvent.charAt(0) != "!");
let type = expectEvent;
if (!type) {
type = expectedEvent.substring(1);
}
expectedTarget.removeEventListener(type, eventHandler, false);
let desc = `${type} event`;
if (!expectEvent) {
desc += " not";
}
is(seenEvent, expectEvent, `${testName} ${desc} fired`);
}
seenEvent = false;
}
/**
* Similar to event.synthesizeMouse except that a test is performed to
* see if an event is fired at the right target as a result.
*
* To test that an event is not fired, use an expected type preceded by
* an exclamation mark, such as "!select". This might be used to test that
* a click on a disabled element doesn't fire certain events for instance.
*
* @param {Element} target
* Synthesise the mouse event on this target.
* @param {number} offsetX
* Horizontal offset from the target's bounding box.
* @param {number} offsetY
* Vertical offset from the target's bounding box.
* @param {Object.<string, ?>} ev
* Object which may contain the properties shiftKey, ctrlKey, altKey,
* metaKey, accessKey, type.
* @param {Element} expectedTarget
* Expected originalTarget of the event.
* @param {DOMEvent} expectedEvent
* Expected type of the event, such as "select".
* @param {string} testName
* Test name when outputing results.
* @param {Window=} window
* Window object. Defaults to the current window.
*/
event.synthesizeMouseExpectEvent = function (
target, offsetX, offsetY, ev, expectedTarget, expectedEvent,
testName, window = undefined) {
let eventHandler = expectEvent_(
expectedTarget,
expectedEvent,
testName);
event.synthesizeMouse(target, offsetX, offsetY, ev, window);
checkExpectedEvent_(
expectedTarget,
expectedEvent,
eventHandler,
testName);
};
/**
* Similar to synthesizeKey except that a test is performed to see if
* an event is fired at the right target as a result.
*
* @param {string} key
* Key to synthesise.
* @param {Object.<string, ?>} ev
* Object which may contain the properties shiftKey, ctrlKey, altKey,
* metaKey, accessKey, type.
* @param {Element} expectedTarget
* Expected originalTarget of the event.
* @param {DOMEvent} expectedEvent
* Expected type of the event, such as "select".
* @param {string} testName
* Test name when outputing results
* @param {Window=} window
* Window object. Defaults to the current window.
*
* To test that an event is not fired, use an expected type preceded by an
* exclamation mark, such as "!select".
*
* aWindow is optional, and defaults to the current window object.
*/
event.synthesizeKeyExpectEvent = function (
key, ev, expectedTarget, expectedEvent, testName,
window = undefined) {
let eventHandler = expectEvent_(
expectedTarget,
expectedEvent,
testName);
event.synthesizeKey(key, ev, window);
checkExpectedEvent_(
expectedTarget,
expectedEvent,
eventHandler,
testName);
};
/**
* Synthesize a composition event.
*
* @param {DOMEvent} ev
* The composition event information. This must have |type|
* member. The value must be "compositionstart", "compositionend" or
* "compositionupdate". And also this may have |data| and |locale|
* which would be used for the value of each property of the
* composition event. Note that the data would be ignored if the
* event type were "compositionstart".
* @param {Window=} window
* Window object. Defaults to the current window.
*/
event.synthesizeComposition = function (ev, window = undefined) {
let domutils = getDOMWindowUtils(window);
domutils.sendCompositionEvent(ev.type, ev.data || "", ev.locale || "");
};
/**
* Synthesize a text event.
*
* The text event's information, this has |composition| and |caret|
* members. |composition| has |string| and |clauses| members. |clauses|
* must be array object. Each object has |length| and |attr|.
* And |caret| has |start| and |length|. See the following tree image.
*
* ev
* +-- composition
* | +-- string
* | +-- clauses[]
* | +-- length
* | +-- attr
* +-- caret
* +-- start
* +-- length
*
* Set the composition string to |composition.string|. Set its clauses
* information to the |clauses| array.
*
* When it's composing, set the each clauses' length
* to the |composition.clauses[n].length|. The sum
* of the all length values must be same as the length of
* |composition.string|. Set nsIDOMWindowUtils.COMPOSITION_ATTR_* to the
* |composition.clauses[n].attr|.
*
* When it's not composing, set 0 to the |composition.clauses[0].length|
* and |composition.clauses[0].attr|.
*
* Set caret position to the |caret.start|. Its offset from the start of
* the composition string. Set caret length to |caret.length|. If it's
* larger than 0, it should be wide caret. However, current nsEditor
* doesn't support wide caret, therefore, you should always set 0 now.
*
* @param {Object.<string, ?>} ev
* The text event's information,
* @param {Window=} window
* Window object. Defaults to the current window.
*/
event.synthesizeText = function (ev, window = undefined) {
let domutils = getDOMWindowUtils(window);
if (!ev.composition ||
!ev.composition.clauses ||
!ev.composition.clauses[0]) {
return;
}
let firstClauseLength = ev.composition.clauses[0].length;
let firstClauseAttr = ev.composition.clauses[0].attr;
let secondClauseLength = 0;
let secondClauseAttr = 0;
let thirdClauseLength = 0;
let thirdClauseAttr = 0;
if (ev.composition.clauses[1]) {
secondClauseLength = ev.composition.clauses[1].length;
secondClauseAttr = ev.composition.clauses[1].attr;
if (event.composition.clauses[2]) {
thirdClauseLength = ev.composition.clauses[2].length;
thirdClauseAttr = ev.composition.clauses[2].attr;
}
}
let caretStart = -1;
let caretLength = 0;
if (event.caret) {
caretStart = ev.caret.start;
caretLength = ev.caret.length;
}
domutils.sendTextEvent(
ev.composition.string,
firstClauseLength,
firstClauseAttr,
secondClauseLength,
secondClauseAttr,
thirdClauseLength,
thirdClauseAttr,
caretStart,
caretLength);
};
/**
* Synthesize a query selected text event.
*
* @param {Window=}
* Window object. Defaults to the current window.
*
* @return {(nsIQueryContentEventResult|null)}
* Event's result, or null if it failed.
*/
event.synthesizeQuerySelectedText = function (window = undefined) {
let domutils = getDOMWindowUtils(window);
return domutils.sendQueryContentEvent(
domutils.QUERY_SELECTED_TEXT, 0, 0, 0, 0);
};
/**
* Synthesize a selection set event.
*
* @param {number} offset
* Character offset. 0 means the first character in the selection
* root.
* @param {number} length
* Length of the text. If the length is too long, the extra length
* is ignored.
* @param {boolean} reverse
* If true, the selection is from |aOffset + aLength| to |aOffset|.
* Otherwise, from |aOffset| to |aOffset + aLength|.
* @param {Window=} window
* Window object. Defaults to the current window.
*
* @return True, if succeeded. Otherwise false.
*/
event.synthesizeSelectionSet = function (
offset, length, reverse, window = undefined) {
let domutils = getDOMWindowUtils(window);
return domutils.sendSelectionSetEvent(offset, length, reverse);
};
const KEYCODES_LOOKUP = {
"VK_SHIFT": "shiftKey",
"VK_CONTROL": "ctrlKey",
"VK_ALT": "altKey",
"VK_META": "metaKey",
};
const VIRTUAL_KEYCODE_LOOKUP = {
"\uE001": "VK_CANCEL",
"\uE002": "VK_HELP",
"\uE003": "VK_BACK_SPACE",
"\uE004": "VK_TAB",
"\uE005": "VK_CLEAR",
"\uE006": "VK_RETURN",
"\uE007": "VK_RETURN",
"\uE008": "VK_SHIFT",
"\uE009": "VK_CONTROL",
"\uE00A": "VK_ALT",
"\uE03D": "VK_META",
"\uE00B": "VK_PAUSE",
"\uE00C": "VK_ESCAPE",
"\uE00D": "VK_SPACE", // printable
"\uE00E": "VK_PAGE_UP",
"\uE00F": "VK_PAGE_DOWN",
"\uE010": "VK_END",
"\uE011": "VK_HOME",
"\uE012": "VK_LEFT",
"\uE013": "VK_UP",
"\uE014": "VK_RIGHT",
"\uE015": "VK_DOWN",
"\uE016": "VK_INSERT",
"\uE017": "VK_DELETE",
"\uE018": "VK_SEMICOLON",
"\uE019": "VK_EQUALS",
"\uE01A": "VK_NUMPAD0",
"\uE01B": "VK_NUMPAD1",
"\uE01C": "VK_NUMPAD2",
"\uE01D": "VK_NUMPAD3",
"\uE01E": "VK_NUMPAD4",
"\uE01F": "VK_NUMPAD5",
"\uE020": "VK_NUMPAD6",
"\uE021": "VK_NUMPAD7",
"\uE022": "VK_NUMPAD8",
"\uE023": "VK_NUMPAD9",
"\uE024": "VK_MULTIPLY",
"\uE025": "VK_ADD",
"\uE026": "VK_SEPARATOR",
"\uE027": "VK_SUBTRACT",
"\uE028": "VK_DECIMAL",
"\uE029": "VK_DIVIDE",
"\uE031": "VK_F1",
"\uE032": "VK_F2",
"\uE033": "VK_F3",
"\uE034": "VK_F4",
"\uE035": "VK_F5",
"\uE036": "VK_F6",
"\uE037": "VK_F7",
"\uE038": "VK_F8",
"\uE039": "VK_F9",
"\uE03A": "VK_F10",
"\uE03B": "VK_F11",
"\uE03C": "VK_F12",
};
function getKeyCode(c) {
if (c in VIRTUAL_KEYCODE_LOOKUP) {
return VIRTUAL_KEYCODE_LOOKUP[c];
}
return c;
}
event.sendKeyDown = function (keyToSend, modifiers, document) {
modifiers.type = "keydown";
event.sendSingleKey(keyToSend, modifiers, document);
// TODO This doesn't do anything since |synthesizeKeyEvent| ignores explicit
// keypress request, and instead figures out itself when to send keypress
if (["VK_SHIFT", "VK_CONTROL", "VK_ALT", "VK_META"].indexOf(getKeyCode(keyToSend)) < 0) {
modifiers.type = "keypress";
event.sendSingleKey(keyToSend, modifiers, document);
}
delete modifiers.type;
};
event.sendKeyUp = function (keyToSend, modifiers, window = undefined) {
modifiers.type = "keyup";
event.sendSingleKey(keyToSend, modifiers, window);
delete modifiers.type;
};
/**
* Synthesize a key event for a single key.
*
* @param {string} keyToSend
* Code point or normalized key value
* @param {?} modifiers
* Object with properties used in KeyboardEvent (shiftkey, repeat, ...)
* as well as, the event |type| such as keydown. All properties are optional.
* @param {Window=} window
* Window object. If |window| is undefined, the event is synthesized in
* current window.
*/
event.sendSingleKey = function (keyToSend, modifiers, window = undefined) {
let keyCode = getKeyCode(keyToSend);
if (keyCode in KEYCODES_LOOKUP) {
// We assume that if |keyToSend| is a raw code point (like "\uE009") then
// |modifiers| does not already have correct value for corresponding
// |modName| attribute (like ctrlKey), so that value needs to be flipped
let modName = KEYCODES_LOOKUP[keyCode];
modifiers[modName] = !modifiers[modName];
} else if (modifiers.shiftKey && keyCode != "Shift") {
keyCode = keyCode.toUpperCase();
}
event.synthesizeKey(keyCode, modifiers, window);
};
/**
* Focus element and, if a textual input field and no previous selection
* state exists, move the caret to the end of the input field.
*
* @param {Element} element
* Element to focus.
*/
function focusElement(element) {
let t = element.type;
if (t && (t == "text" || t == "textarea")) {
if (element.selectionEnd == 0) {
let len = element.value.length;
element.setSelectionRange(len, len);
}
}
element.focus();
}
/**
* @param {Array.<string>} keySequence
* @param {Element} element
* @param {Object.<string, boolean>=} opts
* @param {Window=} window
*/
event.sendKeysToElement = function (
keySequence, el, opts = {}, window = undefined) {
if (opts.ignoreVisibility || element.isVisible(el)) {
focusElement(el);
// make Object.<modifier, false> map
let modifiers = Object.create(event.Modifiers);
for (let modifier in event.Modifiers) {
modifiers[modifier] = false;
}
let value = keySequence.join("");
for (let i = 0; i < value.length; i++) {
let c = value.charAt(i);
event.sendSingleKey(c, modifiers, window);
}
} else {
throw new ElementNotVisibleError("Element is not visible");
}
};
event.sendEvent = function (eventType, el, modifiers = {}, opts = {}) {
opts.canBubble = opts.canBubble || true;
let doc = el.ownerDocument || el.document;
let ev = doc.createEvent("Event");
ev.shiftKey = modifiers["shift"];
ev.metaKey = modifiers["meta"];
ev.altKey = modifiers["alt"];
ev.ctrlKey = modifiers["ctrl"];
ev.initEvent(eventType, opts.canBubble, true);
el.dispatchEvent(ev);
};
event.focus = function (el, opts = {}) {
opts.canBubble = opts.canBubble || true;
let doc = el.ownerDocument || el.document;
let win = doc.defaultView;
let ev = new win.FocusEvent(el);
ev.initEvent("focus", opts.canBubble, true);
el.dispatchEvent(ev);
};
event.mouseover = function (el, modifiers = {}, opts = {}) {
return event.sendEvent("mouseover", el, modifiers, opts);
};
event.mousemove = function (el, modifiers = {}, opts = {}) {
return event.sendEvent("mousemove", el, modifiers, opts);
};
event.mousedown = function (el, modifiers = {}, opts = {}) {
return event.sendEvent("mousedown", el, modifiers, opts);
};
event.mouseup = function (el, modifiers = {}, opts = {}) {
return event.sendEvent("mouseup", el, modifiers, opts);
};
event.click = function (el, modifiers = {}, opts = {}) {
return event.sendEvent("click", el, modifiers, opts);
};
event.change = function (el, modifiers = {}, opts = {}) {
return event.sendEvent("change", el, modifiers, opts);
};
event.input = function (el, modifiers = {}, opts = {}) {
return event.sendEvent("input", el, modifiers, opts);
};