diff options
Diffstat (limited to 'testing/marionette/event.js')
| -rw-r--r-- | testing/marionette/event.js | 1365 |
1 files changed, 1365 insertions, 0 deletions
diff --git a/testing/marionette/event.js b/testing/marionette/event.js new file mode 100644 index 000000000..c60ca306b --- /dev/null +++ b/testing/marionette/event.js @@ -0,0 +1,1365 @@ +/* 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, ?>} 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.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); + let pressure = ("pressure" in opts) ? opts.pressure : 0; + let inputSource = ("inputSource" in opts) ? opts.inputSource : + Ci.nsIDOMMouseEvent.MOZ_SOURCE_MOUSE; + let isDOMEventSynthesized = + ("isSynthesized" in opts) ? opts.isSynthesized : true; + let isWidgetEventSynthesized = + ("isWidgetEventSynthesized" in opts) ? opts.isWidgetEventSynthesized : false; + let buttons = ("buttons" in opts) ? opts.buttons : domutils.MOUSE_BUTTONS_NOT_SPECIFIED; + + if (("type" in opts) && opts.type) { + domutils.sendMouseEvent( + opts.type, left, top, button, clickCount, modifiers, false, pressure, inputSource, + isDOMEventSynthesized, isWidgetEventSynthesized, buttons); + } else { + domutils.sendMouseEvent( + "mousedown", left, top, button, clickCount, modifiers, false, pressure, inputSource, + isDOMEventSynthesized, isWidgetEventSynthesized, buttons); + domutils.sendMouseEvent( + "mouseup", left, top, button, clickCount, modifiers, false, pressure, inputSource, + isDOMEventSynthesized, isWidgetEventSynthesized, buttons); + } +}; + +/** + * 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 ElementNotInteractableError("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); +}; |