www

EventUtils.jsm (28283B)

---

 /* Taken from MozMill 6c0948d80eebcbb104ce7a776c65aeae634970dd
  *
  * 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/. */
 
  // Export all available functions for Mozmill
 var EXPORTED_SYMBOLS = ["disableNonTestMouseEvents","sendMouseEvent", "sendChar",
                         "sendString", "sendKey", "synthesizeMouse", "synthesizeTouch",
                         "synthesizeMouseAtPoint", "synthesizeTouchAtPoint",
                         "synthesizeMouseAtCenter", "synthesizeTouchAtCenter",
                         "synthesizeWheel", "synthesizeKey",
                         "synthesizeMouseExpectEvent", "synthesizeKeyExpectEvent",
                         "synthesizeText",
                         "synthesizeComposition", "synthesizeQuerySelectedText"];
 
 const Ci = Components.interfaces;
 const Cc = Components.classes;
 
 var window = Cc["@mozilla.org/appshell/appShellService;1"]
              .getService(Ci.nsIAppShellService).hiddenDOMWindow;
 
 var _EU_Ci = Ci;
 var navigator = window.navigator;
 var KeyEvent = window.KeyEvent;
 var parent = window.parent;
 
 function is(aExpression1, aExpression2, aMessage) {
   if (aExpression1 !== aExpression2) {
     throw new Error(aMessage);
   }
 }
 
 /**
  * EventUtils provides some utility methods for creating and sending DOM events.
  * Current methods:
  *  sendMouseEvent
  *  sendChar
  *  sendString
  *  sendKey
  *  synthesizeMouse
  *  synthesizeMouseAtCenter
  *  synthesizeWheel
  *  synthesizeKey
  *  synthesizeMouseExpectEvent
  *  synthesizeKeyExpectEvent
  *
  *  When adding methods to this file, please add a performance test for it.
  */
 
 /**
  * Send a mouse event to the node aTarget (aTarget can be an id, or an
  * actual node) . The "event" passed in to aEvent is just a JavaScript
  * object with the properties set that the real mouse event object should
  * have. This includes the type of the mouse event.
  * E.g. to send an click event to the node with id 'node' you might do this:
  *
  * sendMouseEvent({type:'click'}, 'node');
  */
 function getElement(id) {
   return ((typeof(id) == "string") ?
     document.getElementById(id) : id); 
 };   
 
 this.$ = this.getElement;
 
 function sendMouseEvent(aEvent, aTarget, aWindow) {
   if (['click', 'dblclick', 'mousedown', 'mouseup', 'mouseover', 'mouseout'].indexOf(aEvent.type) == -1) {
     throw new Error("sendMouseEvent doesn't know about event type '" + aEvent.type + "'");
   }
 
   if (!aWindow) {
     aWindow = window;
   }
 
   if (!(aTarget instanceof aWindow.Element)) {
     aTarget = aWindow.document.getElementById(aTarget);
   }
 
   var event = aWindow.document.createEvent('MouseEvent');
 
   var typeArg          = aEvent.type;
   var canBubbleArg     = true;
   var cancelableArg    = true;
   var viewArg          = aWindow;
   var detailArg        = aEvent.detail        || (aEvent.type == 'click'     ||
                                                   aEvent.type == 'mousedown' ||
                                                   aEvent.type == 'mouseup' ? 1 :
                                                   aEvent.type == 'dblclick'? 2 : 0);
   var screenXArg       = aEvent.screenX       || 0;
   var screenYArg       = aEvent.screenY       || 0;
   var clientXArg       = aEvent.clientX       || 0;
   var clientYArg       = aEvent.clientY       || 0;
   var ctrlKeyArg       = aEvent.ctrlKey       || false;
   var altKeyArg        = aEvent.altKey        || false;
   var shiftKeyArg      = aEvent.shiftKey      || false;
   var metaKeyArg       = aEvent.metaKey       || false;
   var buttonArg        = aEvent.button        || 0;
   var relatedTargetArg = aEvent.relatedTarget || null;
 
   event.initMouseEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg,
                        screenXArg, screenYArg, clientXArg, clientYArg,
                        ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg,
                        buttonArg, relatedTargetArg);
 
   aTarget.dispatchEvent(event);
 }
 
 /**
  * Send the char aChar to the focused element.  This method handles casing of
  * chars (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 ASCII characters and emulates the shift
  * key state on US keyboard layout.
  */
 function sendChar(aChar, aWindow) {
   var hasShift;
   // Emulate US keyboard layout for the shiftKey state.
   switch (aChar) {
     case "!":
     case "@":
     case "#":
     case "$":
     case "%":
     case "^":
     case "&":
     case "*":
     case "(":
     case ")":
     case "_":
     case "+":
     case "{":
     case "}":
     case ":":
     case "\"":
     case "|":
     case "<":
     case ">":
     case "?":
       hasShift = true;
       break;
     default:
       hasShift = (aChar == aChar.toUpperCase());
       break;
   }
   synthesizeKey(aChar, { shiftKey: hasShift }, aWindow);
 }
 
 /**
  * Send the string aStr to the focused element.
  *
  * For now this method only works for ASCII characters and emulates the shift
  * key state on US keyboard layout.
  */
 function sendString(aStr, aWindow) {
   for (var i = 0; i < aStr.length; ++i) {
     sendChar(aStr.charAt(i), aWindow);
   }
 }
 
 /**
  * Send the non-character key aKey to the focused node.
  * The name of the key should be the part that comes after "DOM_VK_" in the
  *   KeyEvent constant name for this key.
  * No modifiers are handled at this point.
  */
 function sendKey(aKey, aWindow) {
   var keyName = "VK_" + aKey.toUpperCase();
   synthesizeKey(keyName, { shiftKey: false }, aWindow);
 }
 
 /**
  * Parse the key modifier flags from aEvent. Used to share code between
  * synthesizeMouse and synthesizeKey.
  */
 function _parseModifiers(aEvent)
 {
   const nsIDOMWindowUtils = _EU_Ci.nsIDOMWindowUtils;
   var mval = 0;
   if (aEvent.shiftKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_SHIFT;
   }
   if (aEvent.ctrlKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_CONTROL;
   }
   if (aEvent.altKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_ALT;
   }
   if (aEvent.metaKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_META;
   }
   if (aEvent.accelKey) {
     mval |= (navigator.platform.indexOf("Mac") >= 0) ?
       nsIDOMWindowUtils.MODIFIER_META : nsIDOMWindowUtils.MODIFIER_CONTROL;
   }
   if (aEvent.altGrKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_ALTGRAPH;
   }
   if (aEvent.capsLockKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_CAPSLOCK;
   }
   if (aEvent.fnKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_FN;
   }
   if (aEvent.numLockKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_NUMLOCK;
   }
   if (aEvent.scrollLockKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_SCROLLLOCK;
   }
   if (aEvent.symbolLockKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_SYMBOLLOCK;
   }
   if (aEvent.osKey) {
     mval |= nsIDOMWindowUtils.MODIFIER_OS;
   }
 
   return mval;
 }
 
 /**
  * Synthesize a mouse event on a target. The actual client point is determined
  * by taking the aTarget's client box and offseting it by aOffsetX and
  * aOffsetY. This allows mouse clicks to be simulated by calling this method.
  *
  * aEvent is an object which may contain the properties:
  *   shiftKey, ctrlKey, altKey, metaKey, accessKey, clickCount, button, type
  *
  * If the type is specified, an mouse event of that type is fired. Otherwise,
  * a mousedown followed by a mouse up is performed.
  *
  * aWindow is optional, and defaults to the current window object.
  *
  * Returns whether the event had preventDefault() called on it.
  */
 function synthesizeMouse(aTarget, aOffsetX, aOffsetY, aEvent, aWindow)
 {
   var rect = aTarget.getBoundingClientRect();
   return synthesizeMouseAtPoint(rect.left + aOffsetX, rect.top + aOffsetY,
        aEvent, aWindow);
 }
 function synthesizeTouch(aTarget, aOffsetX, aOffsetY, aEvent, aWindow)
 {
   var rect = aTarget.getBoundingClientRect();
   synthesizeTouchAtPoint(rect.left + aOffsetX, rect.top + aOffsetY,
        aEvent, aWindow);
 }
 
 /*
  * Synthesize a mouse event at a particular point in aWindow.
  *
  * aEvent is an object which may contain the properties:
  *   shiftKey, ctrlKey, altKey, metaKey, accessKey, clickCount, button, type
  *
  * If the type is specified, an mouse event of that type is fired. Otherwise,
  * a mousedown followed by a mouse up is performed.
  *
  * aWindow is optional, and defaults to the current window object.
  */
 function synthesizeMouseAtPoint(left, top, aEvent, aWindow)
 {
   var utils = _getDOMWindowUtils(aWindow);
   var defaultPrevented = false;
 
   if (utils) {
     var button = aEvent.button || 0;
     var clickCount = aEvent.clickCount || 1;
     var modifiers = _parseModifiers(aEvent);
     var pressure = ("pressure" in aEvent) ? aEvent.pressure : 0;
     var inputSource = ("inputSource" in aEvent) ? aEvent.inputSource : 0;
 
     if (("type" in aEvent) && aEvent.type) {
       defaultPrevented = utils.sendMouseEvent(aEvent.type, left, top, button, clickCount, modifiers, false, pressure, inputSource);
     }
     else {
       utils.sendMouseEvent("mousedown", left, top, button, clickCount, modifiers, false, pressure, inputSource);
       utils.sendMouseEvent("mouseup", left, top, button, clickCount, modifiers, false, pressure, inputSource);
     }
   }
 
   return defaultPrevented;
 }
 function synthesizeTouchAtPoint(left, top, aEvent, aWindow)
 {
   var utils = _getDOMWindowUtils(aWindow);
 
   if (utils) {
     var id = aEvent.id || 0;
     var rx = aEvent.rx || 1;
     var ry = aEvent.rx || 1;
     var angle = aEvent.angle || 0;
     var force = aEvent.force || 1;
     var modifiers = _parseModifiers(aEvent);
 
     if (("type" in aEvent) && aEvent.type) {
       utils.sendTouchEvent(aEvent.type, [id], [left], [top], [rx], [ry], [angle], [force], 1, modifiers);
     }
     else {
       utils.sendTouchEvent("touchstart", [id], [left], [top], [rx], [ry], [angle], [force], 1, modifiers);
       utils.sendTouchEvent("touchend", [id], [left], [top], [rx], [ry], [angle], [force], 1, modifiers);
     }
   }
 }
 // Call synthesizeMouse with coordinates at the center of aTarget.
 function synthesizeMouseAtCenter(aTarget, aEvent, aWindow)
 {
   var rect = aTarget.getBoundingClientRect();
   synthesizeMouse(aTarget, rect.width / 2, rect.height / 2, aEvent,
                   aWindow);
 }
 function synthesizeTouchAtCenter(aTarget, aEvent, aWindow)
 {
   var rect = aTarget.getBoundingClientRect();
   synthesizeTouch(aTarget, rect.width / 2, rect.height / 2, aEvent,
                   aWindow);
 }
 
 /**
  * Synthesize a wheel event on a target. The actual client point is determined
  * by taking the aTarget's client box and offseting it by aOffsetX and
  * aOffsetY.
  *
  * aEvent is an object which may contain the properties:
  *   shiftKey, ctrlKey, altKey, metaKey, accessKey, deltaX, deltaY, deltaZ,
  *   deltaMode, lineOrPageDeltaX, lineOrPageDeltaY, isMomentum, isPixelOnlyDevice,
  *   isCustomizedByPrefs, expectedOverflowDeltaX, expectedOverflowDeltaY
  *
  * deltaMode must be defined, others are ok even if undefined.
  *
  * expectedOverflowDeltaX and expectedOverflowDeltaY take integer value.  The
  * value is just checked as 0 or positive or negative.
  *
  * aWindow is optional, and defaults to the current window object.
  */
 function synthesizeWheel(aTarget, aOffsetX, aOffsetY, aEvent, aWindow)
 {
   var utils = _getDOMWindowUtils(aWindow);
   if (!utils) {
     return;
   }
 
   var modifiers = _parseModifiers(aEvent);
   var options = 0;
   if (aEvent.isPixelOnlyDevice &&
       (aEvent.deltaMode == WheelEvent.DOM_DELTA_PIXEL)) {
     options |= utils.WHEEL_EVENT_CAUSED_BY_PIXEL_ONLY_DEVICE;
   }
   if (aEvent.isMomentum) {
     options |= utils.WHEEL_EVENT_CAUSED_BY_MOMENTUM;
   }
   if (aEvent.isCustomizedByPrefs) {
     options |= utils.WHEEL_EVENT_CUSTOMIZED_BY_USER_PREFS;
   }
   if (typeof aEvent.expectedOverflowDeltaX !== "undefined") {
     if (aEvent.expectedOverflowDeltaX === 0) {
       options |= utils.WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_ZERO;
     } else if (aEvent.expectedOverflowDeltaX > 0) {
       options |= utils.WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_POSITIVE;
     } else {
       options |= utils.WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_X_NEGATIVE;
     }
   }
   if (typeof aEvent.expectedOverflowDeltaY !== "undefined") {
     if (aEvent.expectedOverflowDeltaY === 0) {
       options |= utils.WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_ZERO;
     } else if (aEvent.expectedOverflowDeltaY > 0) {
       options |= utils.WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_POSITIVE;
     } else {
       options |= utils.WHEEL_EVENT_EXPECTED_OVERFLOW_DELTA_Y_NEGATIVE;
     }
   }
   var isPixelOnlyDevice =
     aEvent.isPixelOnlyDevice && aEvent.deltaMode == WheelEvent.DOM_DELTA_PIXEL;
 
   // Avoid the JS warnings "reference to undefined property"
   if (!aEvent.deltaX) {
     aEvent.deltaX = 0;
   }
   if (!aEvent.deltaY) {
     aEvent.deltaY = 0;
   }
   if (!aEvent.deltaZ) {
     aEvent.deltaZ = 0;
   }
 
   var lineOrPageDeltaX =
     aEvent.lineOrPageDeltaX != null ? aEvent.lineOrPageDeltaX :
                   aEvent.deltaX > 0 ? Math.floor(aEvent.deltaX) :
                                       Math.ceil(aEvent.deltaX);
   var lineOrPageDeltaY =
     aEvent.lineOrPageDeltaY != null ? aEvent.lineOrPageDeltaY :
                   aEvent.deltaY > 0 ? Math.floor(aEvent.deltaY) :
                                       Math.ceil(aEvent.deltaY);
 
   var rect = aTarget.getBoundingClientRect();
   utils.sendWheelEvent(rect.left + aOffsetX, rect.top + aOffsetY,
                        aEvent.deltaX, aEvent.deltaY, aEvent.deltaZ,
                        aEvent.deltaMode, modifiers,
                        lineOrPageDeltaX, lineOrPageDeltaY, options);
 }
 
 function _computeKeyCodeFromChar(aChar)
 {
   if (aChar.length != 1) {
     return 0;
   }
   const nsIDOMKeyEvent = _EU_Ci.nsIDOMKeyEvent;
   if (aChar >= 'a' && aChar <= 'z') {
     return nsIDOMKeyEvent.DOM_VK_A + aChar.charCodeAt(0) - 'a'.charCodeAt(0);
   }
   if (aChar >= 'A' && aChar <= 'Z') {
     return nsIDOMKeyEvent.DOM_VK_A + aChar.charCodeAt(0) - 'A'.charCodeAt(0);
   }
   if (aChar >= '0' && aChar <= '9') {
     return nsIDOMKeyEvent.DOM_VK_0 + aChar.charCodeAt(0) - '0'.charCodeAt(0);
   }
   // returns US keyboard layout's keycode
   switch (aChar) {
     case '~':
     case '`':
       return nsIDOMKeyEvent.DOM_VK_BACK_QUOTE;
     case '!':
       return nsIDOMKeyEvent.DOM_VK_1;
     case '@':
       return nsIDOMKeyEvent.DOM_VK_2;
     case '#':
       return nsIDOMKeyEvent.DOM_VK_3;
     case '$':
       return nsIDOMKeyEvent.DOM_VK_4;
     case '%':
       return nsIDOMKeyEvent.DOM_VK_5;
     case '^':
       return nsIDOMKeyEvent.DOM_VK_6;
     case '&':
       return nsIDOMKeyEvent.DOM_VK_7;
     case '*':
       return nsIDOMKeyEvent.DOM_VK_8;
     case '(':
       return nsIDOMKeyEvent.DOM_VK_9;
     case ')':
       return nsIDOMKeyEvent.DOM_VK_0;
     case '-':
     case '_':
       return nsIDOMKeyEvent.DOM_VK_SUBTRACT;
     case '+':
     case '=':
       return nsIDOMKeyEvent.DOM_VK_EQUALS;
     case '{':
     case '[':
       return nsIDOMKeyEvent.DOM_VK_OPEN_BRACKET;
     case '}':
     case ']':
       return nsIDOMKeyEvent.DOM_VK_CLOSE_BRACKET;
     case '|':
     case '\\':
       return nsIDOMKeyEvent.DOM_VK_BACK_SLASH;
     case ':':
     case ';':
       return nsIDOMKeyEvent.DOM_VK_SEMICOLON;
     case '\'':
     case '"':
       return nsIDOMKeyEvent.DOM_VK_QUOTE;
     case '<':
     case ',':
       return nsIDOMKeyEvent.DOM_VK_COMMA;
     case '>':
     case '.':
       return nsIDOMKeyEvent.DOM_VK_PERIOD;
     case '?':
     case '/':
       return nsIDOMKeyEvent.DOM_VK_SLASH;
     default:
       return 0;
   }
 }
 
 /**
  * isKeypressFiredKey() returns TRUE if the given key should cause keypress
  * event when widget handles the native key event.  Otherwise, FALSE.
  *
  * aDOMKeyCode should be one of consts of nsIDOMKeyEvent::DOM_VK_*, or a key
  * name begins with "VK_", or a character.
  */
 function isKeypressFiredKey(aDOMKeyCode)
 {
   if (typeof(aDOMKeyCode) == "string") {
     if (aDOMKeyCode.indexOf("VK_") == 0) {
       aDOMKeyCode = KeyEvent["DOM_" + aDOMKeyCode];
       if (!aDOMKeyCode) {
         throw "Unknown key: " + aDOMKeyCode;
       }
     } else {
       // If the key generates a character, it must cause a keypress event.
       return true;
     }
   }
   switch (aDOMKeyCode) {
     case KeyEvent.DOM_VK_SHIFT:
     case KeyEvent.DOM_VK_CONTROL:
     case KeyEvent.DOM_VK_ALT:
     case KeyEvent.DOM_VK_CAPS_LOCK:
     case KeyEvent.DOM_VK_NUM_LOCK:
     case KeyEvent.DOM_VK_SCROLL_LOCK:
     case KeyEvent.DOM_VK_META:
       return false;
     default:
       return true;
   }
 }
 
 /**
  * Synthesize a key event. It is targeted at whatever would be targeted by an
  * actual keypress by the user, typically the focused element.
  *
  * aKey should be either a character or a keycode starting with VK_ such as
  * VK_ENTER.
  *
  * aEvent is an object which may contain the properties:
  *   shiftKey, ctrlKey, altKey, metaKey, accessKey, type, location
  *
  * Sets one of KeyboardEvent.DOM_KEY_LOCATION_* to location.  Otherwise,
  * DOMWindowUtils will choose good location from the keycode.
  *
  * If the type is specified, a key event of that type is fired. Otherwise,
  * a keydown, a keypress and then a keyup event are fired in sequence.
  *
  * aWindow is optional, and defaults to the current window object.
  */
 function synthesizeKey(aKey, aEvent, aWindow)
 {
   var utils = _getDOMWindowUtils(aWindow);
   if (utils) {
     var keyCode = 0, charCode = 0;
     if (aKey.indexOf("VK_") == 0) {
       keyCode = KeyEvent["DOM_" + aKey];
       if (!keyCode) {
         throw "Unknown key: " + aKey;
       }
     } else {
       charCode = aKey.charCodeAt(0);
       keyCode = _computeKeyCodeFromChar(aKey.charAt(0));
     }
 
     var modifiers = _parseModifiers(aEvent);
     var flags = 0;
     if (aEvent.location != undefined) {
       switch (aEvent.location) {
         case KeyboardEvent.DOM_KEY_LOCATION_STANDARD:
           flags |= utils.KEY_FLAG_LOCATION_STANDARD;
           break;
         case KeyboardEvent.DOM_KEY_LOCATION_LEFT:
           flags |= utils.KEY_FLAG_LOCATION_LEFT;
           break;
         case KeyboardEvent.DOM_KEY_LOCATION_RIGHT:
           flags |= utils.KEY_FLAG_LOCATION_RIGHT;
           break;
         case KeyboardEvent.DOM_KEY_LOCATION_NUMPAD:
           flags |= utils.KEY_FLAG_LOCATION_NUMPAD;
           break;
         case KeyboardEvent.DOM_KEY_LOCATION_MOBILE:
           flags |= utils.KEY_FLAG_LOCATION_MOBILE;
           break;
         case KeyboardEvent.DOM_KEY_LOCATION_JOYSTICK:
           flags |= utils.KEY_FLAG_LOCATION_JOYSTICK;
           break;
       }
     }
 
     if (!("type" in aEvent) || !aEvent.type) {
       // Send keydown + (optional) keypress + keyup events.
       var keyDownDefaultHappened =
         utils.sendKeyEvent("keydown", keyCode, 0, modifiers, flags);
       if (isKeypressFiredKey(keyCode)) {
         if (!keyDownDefaultHappened) {
           flags |= utils.KEY_FLAG_PREVENT_DEFAULT;
         }
         utils.sendKeyEvent("keypress", keyCode, charCode, modifiers, flags);
       }
       utils.sendKeyEvent("keyup", keyCode, 0, modifiers, flags);
     } else if (aEvent.type == "keypress") {
       // Send standalone keypress event.
       utils.sendKeyEvent(aEvent.type, keyCode, charCode, modifiers, flags);
     } else {
       // Send other standalone event than keypress.
       utils.sendKeyEvent(aEvent.type, keyCode, 0, modifiers, flags);
     }
   }
 }
 
 var _gSeenEvent = false;
 
 /**
  * Indicate that an event with an original target of aExpectedTarget and
  * a type of aExpectedEvent is expected to be fired, or not expected to
  * be fired.
  */
 function _expectEvent(aExpectedTarget, aExpectedEvent, aTestName)
 {
   if (!aExpectedTarget || !aExpectedEvent)
     return null;
 
   _gSeenEvent = false;
 
   var type = (aExpectedEvent.charAt(0) == "!") ?
              aExpectedEvent.substring(1) : aExpectedEvent;
   var eventHandler = function(event) {
     var epassed = (!_gSeenEvent && event.originalTarget == aExpectedTarget &&
                    event.type == type);
     is(epassed, true, aTestName + " " + type + " event target " + (_gSeenEvent ? "twice" : ""));
     _gSeenEvent = true;
   };
 
   aExpectedTarget.addEventListener(type, eventHandler, false);
   return eventHandler;
 }
 
 /**
  * Check if the event was fired or not. The event handler aEventHandler
  * will be removed.
  */
 function _checkExpectedEvent(aExpectedTarget, aExpectedEvent, aEventHandler, aTestName)
 {
   if (aEventHandler) {
     var expectEvent = (aExpectedEvent.charAt(0) != "!");
     var type = expectEvent ? aExpectedEvent : aExpectedEvent.substring(1);
     aExpectedTarget.removeEventListener(type, aEventHandler, false);
     var desc = type + " event";
     if (!expectEvent)
       desc += " not";
     is(_gSeenEvent, expectEvent, aTestName + " " + desc + " fired");
   }
 
   _gSeenEvent = false;
 }
 
 /**
  * Similar to synthesizeMouse except that a test is performed to see if an
  * event is fired at the right target as a result.
  *
  * aExpectedTarget - the expected originalTarget of the event.
  * aExpectedEvent - the expected type of the event, such as 'select'.
  * aTestName - the test name when outputing results
  *
  * 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.
  *
  * aWindow is optional, and defaults to the current window object.
  */
 function synthesizeMouseExpectEvent(aTarget, aOffsetX, aOffsetY, aEvent,
                                     aExpectedTarget, aExpectedEvent, aTestName,
                                     aWindow)
 {
   var eventHandler = _expectEvent(aExpectedTarget, aExpectedEvent, aTestName);
   synthesizeMouse(aTarget, aOffsetX, aOffsetY, aEvent, aWindow);
   _checkExpectedEvent(aExpectedTarget, aExpectedEvent, eventHandler, aTestName);
 }
 
 /**
  * Similar to synthesizeKey except that a test is performed to see if an
  * event is fired at the right target as a result.
  *
  * aExpectedTarget - the expected originalTarget of the event.
  * aExpectedEvent - the expected type of the event, such as 'select'.
  * aTestName - the test name when outputing results
  *
  * 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.
  */
 function synthesizeKeyExpectEvent(key, aEvent, aExpectedTarget, aExpectedEvent,
                                   aTestName, aWindow)
 {
   var eventHandler = _expectEvent(aExpectedTarget, aExpectedEvent, aTestName);
   synthesizeKey(key, aEvent, aWindow);
   _checkExpectedEvent(aExpectedTarget, aExpectedEvent, eventHandler, aTestName);
 }
 
 function disableNonTestMouseEvents(aDisable)
 {
   var domutils = _getDOMWindowUtils();
   domutils.disableNonTestMouseEvents(aDisable);
 }
 
 function _getDOMWindowUtils(aWindow)
 {
   if (!aWindow) {
     aWindow = window;
   }
 
   // we need parent.SpecialPowers for:
   //  layout/base/tests/test_reftests_with_caret.html
   //  chrome: toolkit/content/tests/chrome/test_findbar.xul
   //  chrome: toolkit/content/tests/chrome/test_popup_anchor.xul
   if ("SpecialPowers" in window && window.SpecialPowers != undefined) {
     return SpecialPowers.getDOMWindowUtils(aWindow);
   }
   if ("SpecialPowers" in parent && parent.SpecialPowers != undefined) {
     return parent.SpecialPowers.getDOMWindowUtils(aWindow);
   }
 
   //TODO: this is assuming we are in chrome space
   return aWindow.QueryInterface(_EU_Ci.nsIInterfaceRequestor).
                                getInterface(_EU_Ci.nsIDOMWindowUtils);
 }
 
 // Must be synchronized with nsIDOMWindowUtils.
 const COMPOSITION_ATTR_RAWINPUT              = 0x02;
 const COMPOSITION_ATTR_SELECTEDRAWTEXT       = 0x03;
 const COMPOSITION_ATTR_CONVERTEDTEXT         = 0x04;
 const COMPOSITION_ATTR_SELECTEDCONVERTEDTEXT = 0x05;
 
 /**
  * Synthesize a composition event.
  *
  * @param aEvent               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 aWindow              Optional (If null, current |window| will be used)
  */
 function synthesizeComposition(aEvent, aWindow)
 {
   var utils = _getDOMWindowUtils(aWindow);
   if (!utils) {
     return;
   }
 
   utils.sendCompositionEvent(aEvent.type, aEvent.data ? aEvent.data : "",
                              aEvent.locale ? aEvent.locale : "");
 }
 /**
  * Synthesize a text event.
  *
  * @param aEvent   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.
  *
  *                 aEvent
  *                   +-- 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|. It's 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 aWindow  Optional (If null, current |window| will be used)
  */
 function synthesizeText(aEvent, aWindow)
 {
   var utils = _getDOMWindowUtils(aWindow);
   if (!utils) {
     return;
   }
 
   if (!aEvent.composition || !aEvent.composition.clauses ||
       !aEvent.composition.clauses[0]) {
     return;
   }
 
   var firstClauseLength = aEvent.composition.clauses[0].length;
   var firstClauseAttr   = aEvent.composition.clauses[0].attr;
   var secondClauseLength = 0;
   var secondClauseAttr = 0;
   var thirdClauseLength = 0;
   var thirdClauseAttr = 0;
   if (aEvent.composition.clauses[1]) {
     secondClauseLength = aEvent.composition.clauses[1].length;
     secondClauseAttr   = aEvent.composition.clauses[1].attr;
     if (aEvent.composition.clauses[2]) {
       thirdClauseLength = aEvent.composition.clauses[2].length;
       thirdClauseAttr   = aEvent.composition.clauses[2].attr;
     }
   }
 
   var caretStart = -1;
   var caretLength = 0;
   if (aEvent.caret) {
     caretStart = aEvent.caret.start;
     caretLength = aEvent.caret.length;
   }
 
   utils.sendTextEvent(aEvent.composition.string,
                       firstClauseLength, firstClauseAttr,
                       secondClauseLength, secondClauseAttr,
                       thirdClauseLength, thirdClauseAttr,
                       caretStart, caretLength);
 }
 
 /**
  * Synthesize a query selected text event.
  *
  * @param aWindow  Optional (If null, current |window| will be used)
  * @return         An nsIQueryContentEventResult object.  If this failed,
  *                 the result might be null.
  */
 function synthesizeQuerySelectedText(aWindow)
 {
   var utils = _getDOMWindowUtils(aWindow);
   if (!utils) {
     return null;
   }
 
   return utils.sendQueryContentEvent(utils.QUERY_SELECTED_TEXT, 0, 0, 0, 0);
 }