The Tor Browser: comparison mobile/android/chrome/content/SelectionHandler.js

comparison: mobile/android/chrome/content/SelectionHandler.js

mobile/android/chrome/content/SelectionHandler.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:951b3818465a
+// -*- Mode: js2; tab-width: 2; indent-tabs-mode: nil; js2-basic-offset: 2; js2-skip-preprocessor-directives: t; -*-
+/* 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/. */
+"use strict";
+var SelectionHandler = {
+HANDLE_TYPE_START: "START",
+HANDLE_TYPE_MIDDLE: "MIDDLE",
+HANDLE_TYPE_END: "END",
+TYPE_NONE: 0,
+TYPE_CURSOR: 1,
+TYPE_SELECTION: 2,
+SELECT_ALL: 0,
+SELECT_AT_POINT: 1,
+// Keeps track of data about the dimensions of the selection. Coordinates
+// stored here are relative to the _contentWindow window.
+_cache: null,
+_activeType: 0, // TYPE_NONE
+_draggingHandles: false, // True while user drags text selection handles
+_ignoreCompositionChanges: false, // Persist caret during IME composition updates
+_prevHandlePositions: [], // Avoid issuing duplicate "TextSelection:Position" messages
+// TargetElement changes (text <--> no text) trigger actionbar UI update
+_prevTargetElementHasText: null,
+// The window that holds the selection (can be a sub-frame)
+get _contentWindow() {
+if (this._contentWindowRef)
+return this._contentWindowRef.get();
+return null;
+},
+set _contentWindow(aContentWindow) {
+this._contentWindowRef = Cu.getWeakReference(aContentWindow);
+},
+get _targetElement() {
+if (this._targetElementRef)
+return this._targetElementRef.get();
+return null;
+},
+set _targetElement(aTargetElement) {
+this._targetElementRef = Cu.getWeakReference(aTargetElement);
+},
+get _domWinUtils() {
+return BrowserApp.selectedBrowser.contentWindow.QueryInterface(Ci.nsIInterfaceRequestor).
+getInterface(Ci.nsIDOMWindowUtils);
+},
+_isRTL: false,
+_addObservers: function sh_addObservers() {
+Services.obs.addObserver(this, "Gesture:SingleTap", false);
+Services.obs.addObserver(this, "Tab:Selected", false);
+Services.obs.addObserver(this, "after-viewport-change", false);
+Services.obs.addObserver(this, "TextSelection:Move", false);
+Services.obs.addObserver(this, "TextSelection:Position", false);
+Services.obs.addObserver(this, "TextSelection:End", false);
+Services.obs.addObserver(this, "TextSelection:Action", false);
+Services.obs.addObserver(this, "TextSelection:LayerReflow", false);
+BrowserApp.deck.addEventListener("pagehide", this, false);
+BrowserApp.deck.addEventListener("blur", this, true);
+BrowserApp.deck.addEventListener("scroll", this, true);
+},
+_removeObservers: function sh_removeObservers() {
+Services.obs.removeObserver(this, "Gesture:SingleTap");
+Services.obs.removeObserver(this, "Tab:Selected");
+Services.obs.removeObserver(this, "after-viewport-change");
+Services.obs.removeObserver(this, "TextSelection:Move");
+Services.obs.removeObserver(this, "TextSelection:Position");
+Services.obs.removeObserver(this, "TextSelection:End");
+Services.obs.removeObserver(this, "TextSelection:Action");
+Services.obs.removeObserver(this, "TextSelection:LayerReflow");
+BrowserApp.deck.removeEventListener("pagehide", this, false);
+BrowserApp.deck.removeEventListener("blur", this, true);
+BrowserApp.deck.removeEventListener("scroll", this, true);
+},
+observe: function sh_observe(aSubject, aTopic, aData) {
+switch (aTopic) {
+// Update handle/caret position on page reflow (keyboard open/close,
+// dynamic DOM changes, orientation updates, etc).
+case "TextSelection:LayerReflow": {
+if (this._activeType == this.TYPE_SELECTION) {
+this._updateCacheForSelection();
+}
+if (this._activeType != this.TYPE_NONE) {
+this._positionHandlesOnChange();
+}
+break;
+}
+// Update caret position on keyboard activity
+case "TextSelection:UpdateCaretPos":
+// Generated by IME close, autoCorrection / styling
+this._positionHandles();
+break;
+case "Gesture:SingleTap": {
+if (this._activeType == this.TYPE_SELECTION) {
+let data = JSON.parse(aData);
+if (!this._pointInSelection(data.x, data.y))
+this._closeSelection();
+} else if (this._activeType == this.TYPE_CURSOR) {
+// attachCaret() is called in the "Gesture:SingleTap" handler in BrowserEventHandler
+// We're guaranteed to call this first, because this observer was added last
+this._deactivate();
+}
+break;
+}
+case "Tab:Selected":
+case "TextSelection:End":
+this._closeSelection();
+break;
+case "TextSelection:Action":
+for (let type in this.actions) {
+if (this.actions[type].id == aData) {
+this.actions[type].action(this._targetElement);
+break;
+}
+}
+break;
+case "after-viewport-change": {
+if (this._activeType == this.TYPE_SELECTION) {
+// Update the cache after the viewport changes (e.g. panning, zooming).
+this._updateCacheForSelection();
+}
+break;
+}
+case "TextSelection:Move": {
+let data = JSON.parse(aData);
+if (this._activeType == this.TYPE_SELECTION) {
+this._startDraggingHandles();
+this._moveSelection(data.handleType == this.HANDLE_TYPE_START, data.x, data.y);
+} else if (this._activeType == this.TYPE_CURSOR) {
+this._startDraggingHandles();
+// Ignore IMM composition notifications when caret movement starts
+this._ignoreCompositionChanges = true;
+// Send a click event to the text box, which positions the caret
+this._sendMouseEvents(data.x, data.y);
+// Move the handle directly under the caret
+this._positionHandles();
+}
+break;
+}
+case "TextSelection:Position": {
+if (this._activeType == this.TYPE_SELECTION) {
+this._startDraggingHandles();
+// Check to see if the handles should be reversed.
+let isStartHandle = JSON.parse(aData).handleType == this.HANDLE_TYPE_START;
+try {
+let selectionReversed = this._updateCacheForSelection(isStartHandle);
+if (selectionReversed) {
+// Reverse the anchor and focus to correspond to the new start and end handles.
+let selection = this._getSelection();
+let anchorNode = selection.anchorNode;
+let anchorOffset = selection.anchorOffset;
+selection.collapse(selection.focusNode, selection.focusOffset);
+selection.extend(anchorNode, anchorOffset);
+}
+} catch (e) {
+// User finished handle positioning with one end off the screen
+this._closeSelection();
+break;
+}
+this._stopDraggingHandles();
+this._positionHandles();
+// Changes to handle position can affect selection context and actionbar display
+this._updateMenu();
+} else if (this._activeType == this.TYPE_CURSOR) {
+// Act on IMM composition notifications after caret movement ends
+this._ignoreCompositionChanges = false;
+this._stopDraggingHandles();
+this._positionHandles();
+} else {
+Cu.reportError("Ignored \"TextSelection:Position\" message during invalid selection status");
+}
+break;
+}
+case "TextSelection:Get":
+sendMessageToJava({
+type: "TextSelection:Data",
+requestId: aData,
+text: this._getSelectedText()
+});
+break;
+}
+},
+// Ignore selectionChange notifications during handle dragging, disable dynamic
+// IME text compositions (autoSuggest, autoCorrect, etc)
+_startDraggingHandles: function sh_startDraggingHandles() {
+if (!this._draggingHandles) {
+this._draggingHandles = true;
+sendMessageToJava({ type: "TextSelection:DraggingHandle", dragging: true });
+}
+},
+// Act on selectionChange notifications when not dragging handles, allow dynamic
+// IME text compositions (autoSuggest, autoCorrect, etc)
+_stopDraggingHandles: function sh_stopDraggingHandles() {
+if (this._draggingHandles) {
+this._draggingHandles = false;
+sendMessageToJava({ type: "TextSelection:DraggingHandle", dragging: false });
+}
+},
+handleEvent: function sh_handleEvent(aEvent) {
+switch (aEvent.type) {
+case "scroll":
+// Maintain position when top-level document is scrolled
+this._positionHandlesOnChange();
+break;
+case "pagehide":
+case "blur":
+this._closeSelection();
+break;
+// Update caret position on keyboard activity
+case "keyup":
+// Not generated by Swiftkeyboard
+case "compositionupdate":
+case "compositionend":
+// Generated by SwiftKeyboard, et. al.
+if (!this._ignoreCompositionChanges) {
+this._positionHandles();
+}
+break;
+}
+},
+/** Returns true if the provided element can be selected in text selection, false otherwise. */
+canSelect: function sh_canSelect(aElement) {
+return !(aElement instanceof Ci.nsIDOMHTMLButtonElement ||
+aElement instanceof Ci.nsIDOMHTMLEmbedElement ||
+aElement instanceof Ci.nsIDOMHTMLImageElement ||
+aElement instanceof Ci.nsIDOMHTMLMediaElement) &&
+aElement.style.MozUserSelect != 'none';
+},
+_getScrollPos: function sh_getScrollPos() {
+// Get the current display position
+let scrollX = {}, scrollY = {};
+this._contentWindow.top.QueryInterface(Ci.nsIInterfaceRequestor).
+getInterface(Ci.nsIDOMWindowUtils).getScrollXY(false, scrollX, scrollY);
+return {
+X: scrollX.value,
+Y: scrollY.value
+};
+},
+notifySelectionChanged: function sh_notifySelectionChanged(aDocument, aSelection, aReason) {
+// Ignore selectionChange notifications during handle movements
+if (this._draggingHandles) {
+return;
+}
+// If the selection was collapsed to Start or to End, always close it
+if ((aReason & Ci.nsISelectionListener.COLLAPSETOSTART_REASON) ||
+(aReason & Ci.nsISelectionListener.COLLAPSETOEND_REASON)) {
+this._closeSelection();
+return;
+}
+// If selected text no longer exists, close
+if (!aSelection.toString()) {
+this._closeSelection();
+}
+},
+/*
+* Called from browser.js when the user long taps on text or chooses
+* the "Select Word" context menu item. Initializes SelectionHandler,
+* starts a selection, and positions the text selection handles.
+*
+* @param aOptions list of options describing how to start selection
+*                 Options include:
+*                   mode - SELECT_ALL to select everything in the target
+*                          element, or SELECT_AT_POINT to select a word.
+*                   x    - The x-coordinate for SELECT_AT_POINT.
+*                   y    - The y-coordinate for SELECT_AT_POINT.
+*/
+startSelection: function sh_startSelection(aElement, aOptions = { mode: SelectionHandler.SELECT_ALL }) {
+// Clear out any existing active selection
+this._closeSelection();
+this._initTargetInfo(aElement, this.TYPE_SELECTION);
+// Clear any existing selection from the document
+this._contentWindow.getSelection().removeAllRanges();
+// Perform the appropriate selection method, if we can't determine method, or it fails, return
+if (!this._performSelection(aOptions)) {
+this._deactivate();
+return false;
+}
+// Double check results of successful selection operation
+let selection = this._getSelection();
+if (!selection || selection.rangeCount == 0 || selection.getRangeAt(0).collapsed) {
+this._deactivate();
+return false;
+}
+if (this._isPhoneNumber(selection.toString())) {
+let anchorNode = selection.anchorNode;
+let anchorOffset = selection.anchorOffset;
+let focusNode = null;
+let focusOffset = null;
+while (this._isPhoneNumber(selection.toString().trim())) {
+focusNode = selection.focusNode;
+focusOffset = selection.focusOffset;
+selection.modify("extend", "forward", "word");
+// if we hit the end of the text on the page, we can't advance the selection
+if (focusNode == selection.focusNode && focusOffset == selection.focusOffset) {
+break;
+}
+}
+// reverse selection
+selection.collapse(focusNode, focusOffset);
+selection.extend(anchorNode, anchorOffset);
+anchorNode = focusNode;
+anchorOffset = focusOffset
+while (this._isPhoneNumber(selection.toString().trim())) {
+focusNode = selection.focusNode;
+focusOffset = selection.focusOffset;
+selection.modify("extend", "backward", "word");
+// if we hit the end of the text on the page, we can't advance the selection
+if (focusNode == selection.focusNode && focusOffset == selection.focusOffset) {
+break;
+}
+}
+selection.collapse(focusNode, focusOffset);
+selection.extend(anchorNode, anchorOffset);
+}
+// Add a listener to end the selection if it's removed programatically
+selection.QueryInterface(Ci.nsISelectionPrivate).addSelectionListener(this);
+this._activeType = this.TYPE_SELECTION;
+// Initialize the cache
+this._cache = { start: {}, end: {}};
+this._updateCacheForSelection();
+let scroll = this._getScrollPos();
+// Figure out the distance between the selection and the click
+let positions = this._getHandlePositions(scroll);
+if (aOptions.mode == this.SELECT_AT_POINT && !this._selectionNearClick(scroll.X + aOptions.x,
+scroll.Y + aOptions.y,
+positions)) {
+this._closeSelection();
+return false;
+}
+// Determine position and show handles, open actionbar
+this._positionHandles(positions);
+sendMessageToJava({
+type: "TextSelection:ShowHandles",
+handles: [this.HANDLE_TYPE_START, this.HANDLE_TYPE_END]
+});
+this._updateMenu();
+return true;
+},
+/*
+* Called to perform a selection operation, given a target element, selection method, starting point etc.
+*/
+_performSelection: function sh_performSelection(aOptions) {
+if (aOptions.mode == this.SELECT_AT_POINT) {
+return this._domWinUtils.selectAtPoint(aOptions.x, aOptions.y, Ci.nsIDOMWindowUtils.SELECT_WORDNOSPACE);
+}
+if (aOptions.mode != this.SELECT_ALL) {
+Cu.reportError("SelectionHandler.js: _performSelection() Invalid selection mode " + aOptions.mode);
+return false;
+}
+// HTMLPreElement is a #text node, SELECT_ALL implies entire paragraph
+if (this._targetElement instanceof HTMLPreElement)  {
+return this._domWinUtils.selectAtPoint(1, 1, Ci.nsIDOMWindowUtils.SELECT_PARAGRAPH);
+}
+// Else default to selectALL Document
+this._getSelectionController().selectAll();
+// Selection is entire HTMLHtmlElement, remove any trailing document whitespace
+let selection = this._getSelection();
+let lastNode = selection.focusNode;
+while (lastNode && lastNode.lastChild) {
+lastNode = lastNode.lastChild;
+}
+if (lastNode instanceof Text) {
+try {
+selection.extend(lastNode, lastNode.length);
+} catch (e) {
+Cu.reportError("SelectionHandler.js: _performSelection() whitespace trim fails: lastNode[" + lastNode +
+"] lastNode.length[" + lastNode.length + "]");
+}
+}
+return true;
+},
+/* Return true if the current selection (given by aPositions) is near to where the coordinates passed in */
+_selectionNearClick: function(aX, aY, aPositions) {
+let distance = 0;
+// Check if the click was in the bounding box of the selection handles
+if (aPositions[0].left < aX && aX < aPositions[1].left
+&& aPositions[0].top < aY && aY < aPositions[1].top) {
+distance = 0;
+} else {
+// If it was outside, check the distance to the center of the selection
+let selectposX = (aPositions[0].left + aPositions[1].left) / 2;
+let selectposY = (aPositions[0].top + aPositions[1].top) / 2;
+let dx = Math.abs(selectposX - aX);
+let dy = Math.abs(selectposY - aY);
+distance = dx + dy;
+}
+let maxSelectionDistance = Services.prefs.getIntPref("browser.ui.selection.distance");
+return (distance < maxSelectionDistance);
+},
+/* Reads a value from an action. If the action defines the value as a function, will return the result of calling
+the function. Otherwise, will return the value itself. If the value isn't defined for this action, will return a default */
+_getValue: function(obj, name, defaultValue) {
+if (!(name in obj))
+return defaultValue;
+if (typeof obj[name] == "function")
+return obj[name](this._targetElement);
+return obj[name];
+},
+addAction: function(action) {
+if (!action.id)
+action.id = uuidgen.generateUUID().toString()
+if (this.actions[action.id])
+throw "Action with id " + action.id + " already added";
+// Update actions list and actionbar UI if active.
+this.actions[action.id] = action;
+this._updateMenu();
+return action.id;
+},
+removeAction: function(id) {
+// Update actions list and actionbar UI if active.
+delete this.actions[id];
+this._updateMenu();
+},
+_updateMenu: function() {
+if (this._activeType == this.TYPE_NONE) {
+return;
+}
+// Update actionbar UI.
+let actions = [];
+for (let type in this.actions) {
+let action = this.actions[type];
+if (action.selector.matches(this._targetElement)) {
+let a = {
+id: action.id,
+label: this._getValue(action, "label", ""),
+icon: this._getValue(action, "icon", "drawable://ic_status_logo"),
+showAsAction: this._getValue(action, "showAsAction", true),
+order: this._getValue(action, "order", 0)
+};
+actions.push(a);
+}
+}
+actions.sort((a, b) => b.order - a.order);
+sendMessageToJava({
+type: "TextSelection:Update",
+actions: actions
+});
+},
+/*
+* Actionbar methods.
+*/
+actions: {
+SELECT_ALL: {
+label: Strings.browser.GetStringFromName("contextmenu.selectAll"),
+id: "selectall_action",
+icon: "drawable://ab_select_all",
+action: function(aElement) {
+SelectionHandler.startSelection(aElement);
+UITelemetry.addEvent("action.1", "actionbar", null, "select_all");
+},
+order: 5,
+selector: {
+matches: function(aElement) {
+return (aElement.textLength != 0);
+}
+}
+},
+CUT: {
+label: Strings.browser.GetStringFromName("contextmenu.cut"),
+id: "cut_action",
+icon: "drawable://ab_cut",
+action: function(aElement) {
+let start = aElement.selectionStart;
+let end   = aElement.selectionEnd;
+SelectionHandler.copySelection();
+aElement.value = aElement.value.substring(0, start) + aElement.value.substring(end)
+// copySelection closes the selection. Show a caret where we just cut the text.
+SelectionHandler.attachCaret(aElement);
+UITelemetry.addEvent("action.1", "actionbar", null, "cut");
+},
+order: 4,
+selector: {
+matches: function(aElement) {
+return SelectionHandler.isElementEditableText(aElement) ?
+SelectionHandler.isSelectionActive() : false;
+}
+}
+},
+COPY: {
+label: Strings.browser.GetStringFromName("contextmenu.copy"),
+id: "copy_action",
+icon: "drawable://ab_copy",
+action: function() {
+SelectionHandler.copySelection();
+UITelemetry.addEvent("action.1", "actionbar", null, "copy");
+},
+order: 3,
+selector: {
+matches: function(aElement) {
+// Don't include "copy" for password fields.
+// mozIsTextField(true) tests for only non-password fields.
+if (aElement instanceof Ci.nsIDOMHTMLInputElement && !aElement.mozIsTextField(true)) {
+return false;
+}
+return SelectionHandler.isSelectionActive();
+}
+}
+},
+PASTE: {
+label: Strings.browser.GetStringFromName("contextmenu.paste"),
+id: "paste_action",
+icon: "drawable://ab_paste",
+action: function(aElement) {
+if (aElement && (aElement instanceof Ci.nsIDOMNSEditableElement)) {
+let target = aElement.QueryInterface(Ci.nsIDOMNSEditableElement);
+target.editor.paste(Ci.nsIClipboard.kGlobalClipboard);
+target.focus();
+SelectionHandler._closeSelection();
+UITelemetry.addEvent("action.1", "actionbar", null, "paste");
+}
+},
+order: 2,
+selector: {
+matches: function(aElement) {
+if (SelectionHandler.isElementEditableText(aElement)) {
+let flavors = ["text/unicode"];
+return Services.clipboard.hasDataMatchingFlavors(flavors, flavors.length, Ci.nsIClipboard.kGlobalClipboard);
+}
+return false;
+}
+}
+},
+SHARE: {
+label: Strings.browser.GetStringFromName("contextmenu.share"),
+id: "share_action",
+icon: "drawable://ic_menu_share",
+action: function() {
+SelectionHandler.shareSelection();
+UITelemetry.addEvent("action.1", "actionbar", null, "share");
+},
+selector: {
+matches: function() {
+return SelectionHandler.isSelectionActive();
+}
+}
+},
+SEARCH: {
+label: function() {
+return Strings.browser.formatStringFromName("contextmenu.search", [Services.search.defaultEngine.name], 1);
+},
+id: "search_action",
+icon: "drawable://ab_search",
+action: function() {
+SelectionHandler.searchSelection();
+SelectionHandler._closeSelection();
+UITelemetry.addEvent("action.1", "actionbar", null, "search");
+},
+order: 1,
+selector: {
+matches: function() {
+return SelectionHandler.isSelectionActive();
+}
+}
+},
+CALL: {
+label: Strings.browser.GetStringFromName("contextmenu.call"),
+id: "call_action",
+icon: "drawable://phone",
+action: function() {
+SelectionHandler.callSelection();
+UITelemetry.addEvent("action.1", "actionbar", null, "call");
+},
+order: 1,
+selector: {
+matches: function () {
+return SelectionHandler._getSelectedPhoneNumber() != null;
+}
+}
+}
+},
+/*
+* Called by BrowserEventHandler when the user taps in a form input.
+* Initializes SelectionHandler and positions the caret handle.
+*
+* @param aX, aY tap location in client coordinates.
+*/
+attachCaret: function sh_attachCaret(aElement) {
+// Ensure it isn't disabled, isn't handled by Android native dialog, and is editable text element
+if (aElement.disabled || InputWidgetHelper.hasInputWidget(aElement) || !this.isElementEditableText(aElement)) {
+return;
+}
+this._initTargetInfo(aElement, this.TYPE_CURSOR);
+// Caret-specific observer/listeners
+Services.obs.addObserver(this, "TextSelection:UpdateCaretPos", false);
+BrowserApp.deck.addEventListener("keyup", this, false);
+BrowserApp.deck.addEventListener("compositionupdate", this, false);
+BrowserApp.deck.addEventListener("compositionend", this, false);
+this._activeType = this.TYPE_CURSOR;
+// Determine position and show caret, open actionbar
+this._positionHandles();
+sendMessageToJava({
+type: "TextSelection:ShowHandles",
+handles: [this.HANDLE_TYPE_MIDDLE]
+});
+this._updateMenu();
+},
+// Target initialization for both TYPE_CURSOR and TYPE_SELECTION
+_initTargetInfo: function sh_initTargetInfo(aElement, aSelectionType) {
+this._targetElement = aElement;
+if (aElement instanceof Ci.nsIDOMNSEditableElement) {
+if (aSelectionType === this.TYPE_SELECTION) {
+// Blur the targetElement to force IME code to undo previous style compositions
+// (visible underlines / etc generated by autoCorrection, autoSuggestion)
+aElement.blur();
+}
+// Ensure targetElement is now focused normally
+aElement.focus();
+}
+this._stopDraggingHandles();
+this._contentWindow = aElement.ownerDocument.defaultView;
+this._isRTL = (this._contentWindow.getComputedStyle(aElement, "").direction == "rtl");
+this._addObservers();
+},
+_getSelection: function sh_getSelection() {
+if (this._targetElement instanceof Ci.nsIDOMNSEditableElement)
+return this._targetElement.QueryInterface(Ci.nsIDOMNSEditableElement).editor.selection;
+else
+return this._contentWindow.getSelection();
+},
+_getSelectedText: function sh_getSelectedText() {
+if (!this._contentWindow)
+return "";
+let selection = this._getSelection();
+if (!selection)
+return "";
+if (this._targetElement instanceof Ci.nsIDOMHTMLTextAreaElement) {
+return selection.QueryInterface(Ci.nsISelectionPrivate).
+toStringWithFormat("text/plain", Ci.nsIDocumentEncoder.OutputPreformatted | Ci.nsIDocumentEncoder.OutputRaw, 0);
+}
+return selection.toString().trim();
+},
+_getSelectionController: function sh_getSelectionController() {
+if (this._targetElement instanceof Ci.nsIDOMNSEditableElement)
+return this._targetElement.QueryInterface(Ci.nsIDOMNSEditableElement).editor.selectionController;
+else
+return this._contentWindow.QueryInterface(Ci.nsIInterfaceRequestor).
+getInterface(Ci.nsIWebNavigation).
+QueryInterface(Ci.nsIInterfaceRequestor).
+getInterface(Ci.nsISelectionDisplay).
+QueryInterface(Ci.nsISelectionController);
+},
+// Used by the contextmenu "matches" functions in ClipboardHelper
+isSelectionActive: function sh_isSelectionActive() {
+return (this._activeType == this.TYPE_SELECTION);
+},
+isElementEditableText: function (aElement) {
+return ((aElement instanceof HTMLInputElement && aElement.mozIsTextField(false)) ||
+(aElement instanceof HTMLTextAreaElement));
+},
+/*
+* Helper function for moving the selection inside an editable element.
+*
+* @param aAnchorX the stationary handle's x-coordinate in client coordinates
+* @param aX the moved handle's x-coordinate in client coordinates
+* @param aCaretPos the current position of the caret
+*/
+_moveSelectionInEditable: function sh_moveSelectionInEditable(aAnchorX, aX, aCaretPos) {
+let anchorOffset = aX < aAnchorX ? this._targetElement.selectionEnd
+: this._targetElement.selectionStart;
+let newOffset = aCaretPos.offset;
+let [start, end] = anchorOffset <= newOffset ?
+[anchorOffset, newOffset] :
+[newOffset, anchorOffset];
+this._targetElement.setSelectionRange(start, end);
+},
+/*
+* Moves the selection as the user drags a selection handle.
+*
+* @param aIsStartHandle whether the user is moving the start handle (as opposed to the end handle)
+* @param aX, aY selection point in client coordinates
+*/
+_moveSelection: function sh_moveSelection(aIsStartHandle, aX, aY) {
+// XXX We should be smarter about the coordinates we pass to caretPositionFromPoint, especially
+// in editable targets. We should factor out the logic that's currently in _sendMouseEvents.
+let viewOffset = this._getViewOffset();
+let caretPos = this._contentWindow.document.caretPositionFromPoint(aX - viewOffset.x, aY - viewOffset.y);
+if (!caretPos) {
+// User moves handle offscreen while positioning
+return;
+}
+// Constrain text selection within editable elements.
+let targetIsEditable = this._targetElement instanceof Ci.nsIDOMNSEditableElement;
+if (targetIsEditable && (caretPos.offsetNode != this._targetElement)) {
+return;
+}
+// Update the cache as the handle is dragged (keep the cache in client coordinates).
+if (aIsStartHandle) {
+this._cache.start.x = aX;
+this._cache.start.y = aY;
+} else {
+this._cache.end.x = aX;
+this._cache.end.y = aY;
+}
+let selection = this._getSelection();
+// The handles work the same on both LTR and RTL pages, but the anchor/focus nodes
+// are reversed, so we need to reverse the logic to extend the selection.
+if ((aIsStartHandle && !this._isRTL) || (!aIsStartHandle && this._isRTL)) {
+if (targetIsEditable) {
+let anchorX = this._isRTL ? this._cache.start.x : this._cache.end.x;
+this._moveSelectionInEditable(anchorX, aX, caretPos);
+} else {
+let focusNode = selection.focusNode;
+let focusOffset = selection.focusOffset;
+selection.collapse(caretPos.offsetNode, caretPos.offset);
+selection.extend(focusNode, focusOffset);
+}
+} else {
+if (targetIsEditable) {
+let anchorX = this._isRTL ? this._cache.end.x : this._cache.start.x;
+this._moveSelectionInEditable(anchorX, aX, caretPos);
+} else {
+selection.extend(caretPos.offsetNode, caretPos.offset);
+}
+}
+},
+_sendMouseEvents: function sh_sendMouseEvents(aX, aY, useShift) {
+// If we're positioning a cursor in an input field, make sure the handle
+// stays within the bounds of the field
+if (this._activeType == this.TYPE_CURSOR) {
+// Get rect of text inside element
+let range = document.createRange();
+range.selectNodeContents(this._targetElement.QueryInterface(Ci.nsIDOMNSEditableElement).editor.rootElement);
+let textBounds = range.getBoundingClientRect();
+// Get rect of editor
+let editorBounds = this._domWinUtils.sendQueryContentEvent(this._domWinUtils.QUERY_EDITOR_RECT, 0, 0, 0, 0,
+this._domWinUtils.QUERY_CONTENT_FLAG_USE_XP_LINE_BREAK);
+// the return value from sendQueryContentEvent is in LayoutDevice pixels and we want CSS pixels, so
+// divide by the pixel ratio
+let editorRect = new Rect(editorBounds.left / window.devicePixelRatio,
+editorBounds.top / window.devicePixelRatio,
+editorBounds.width / window.devicePixelRatio,
+editorBounds.height / window.devicePixelRatio);
+// Use intersection of the text rect and the editor rect
+let rect = new Rect(textBounds.left, textBounds.top, textBounds.width, textBounds.height);
+rect.restrictTo(editorRect);
+// Clamp vertically and scroll if handle is at bounds. The top and bottom
+// must be restricted by an additional pixel since clicking on the top
+// edge of an input field moves the cursor to the beginning of that
+// field's text (and clicking the bottom moves the cursor to the end).
+if (aY < rect.y + 1) {
+aY = rect.y + 1;
+this._getSelectionController().scrollLine(false);
+} else if (aY > rect.y + rect.height - 1) {
+aY = rect.y + rect.height - 1;
+this._getSelectionController().scrollLine(true);
+}
+// Clamp horizontally and scroll if handle is at bounds
+if (aX < rect.x) {
+aX = rect.x;
+this._getSelectionController().scrollCharacter(false);
+} else if (aX > rect.x + rect.width) {
+aX = rect.x + rect.width;
+this._getSelectionController().scrollCharacter(true);
+}
+} else if (this._activeType == this.TYPE_SELECTION) {
+// Send mouse event 1px too high to prevent selection from entering the line below where it should be
+aY -= 1;
+}
+this._domWinUtils.sendMouseEventToWindow("mousedown", aX, aY, 0, 0, useShift ? Ci.nsIDOMNSEvent.SHIFT_MASK : 0, true);
+this._domWinUtils.sendMouseEventToWindow("mouseup", aX, aY, 0, 0, useShift ? Ci.nsIDOMNSEvent.SHIFT_MASK : 0, true);
+},
+copySelection: function sh_copySelection() {
+let selectedText = this._getSelectedText();
+if (selectedText.length) {
+let clipboard = Cc["@mozilla.org/widget/clipboardhelper;1"].getService(Ci.nsIClipboardHelper);
+clipboard.copyString(selectedText, this._contentWindow.document);
+NativeWindow.toast.show(Strings.browser.GetStringFromName("selectionHelper.textCopied"), "short");
+}
+this._closeSelection();
+},
+shareSelection: function sh_shareSelection() {
+let selectedText = this._getSelectedText();
+if (selectedText.length) {
+sendMessageToJava({
+type: "Share:Text",
+text: selectedText
+});
+}
+this._closeSelection();
+},
+searchSelection: function sh_searchSelection() {
+let selectedText = this._getSelectedText();
+if (selectedText.length) {
+let req = Services.search.defaultEngine.getSubmission(selectedText);
+let parent = BrowserApp.selectedTab;
+let isPrivate = PrivateBrowsingUtils.isWindowPrivate(parent.browser.contentWindow);
+// Set current tab as parent of new tab, and set new tab as private if the parent is.
+BrowserApp.addTab(req.uri.spec, {parentId: parent.id,
+selected: true,
+isPrivate: isPrivate});
+}
+this._closeSelection();
+},
+_phoneRegex: /^\+?[0-9\s,-.\(\)*#pw]{1,30}$/,
+_getSelectedPhoneNumber: function sh_getSelectedPhoneNumber() {
+return this._isPhoneNumber(this._getSelectedText().trim());
+},
+_isPhoneNumber: function sh_isPhoneNumber(selectedText) {
+return (this._phoneRegex.test(selectedText) ? selectedText : null);
+},
+callSelection: function sh_callSelection() {
+let selectedText = this._getSelectedPhoneNumber();
+if (selectedText) {
+BrowserApp.loadURI("tel:" + selectedText);
+}
+this._closeSelection();
+},
+/*
+* Shuts SelectionHandler down.
+*/
+_closeSelection: function sh_closeSelection() {
+// Bail if there's no active selection
+if (this._activeType == this.TYPE_NONE)
+return;
+if (this._activeType == this.TYPE_SELECTION)
+this._clearSelection();
+this._deactivate();
+},
+_clearSelection: function sh_clearSelection() {
+let selection = this._getSelection();
+if (selection) {
+// Remove our listener before we clear the selection
+selection.QueryInterface(Ci.nsISelectionPrivate).removeSelectionListener(this);
+// Clear selection without clearing the anchorNode or focusNode
+if (selection.rangeCount != 0) {
+selection.collapseToStart();
+}
+}
+},
+_deactivate: function sh_deactivate() {
+this._stopDraggingHandles();
+// Hide handle/caret, close actionbar
+sendMessageToJava({ type: "TextSelection:HideHandles" });
+this._removeObservers();
+// Only observed for caret positioning
+if (this._activeType == this.TYPE_CURSOR) {
+Services.obs.removeObserver(this, "TextSelection:UpdateCaretPos");
+BrowserApp.deck.removeEventListener("keyup", this);
+BrowserApp.deck.removeEventListener("compositionupdate", this);
+BrowserApp.deck.removeEventListener("compositionend", this);
+}
+this._contentWindow = null;
+this._targetElement = null;
+this._isRTL = false;
+this._cache = null;
+this._ignoreCompositionChanges = false;
+this._prevHandlePositions = [];
+this._prevTargetElementHasText = null;
+this._activeType = this.TYPE_NONE;
+},
+_getViewOffset: function sh_getViewOffset() {
+let offset = { x: 0, y: 0 };
+let win = this._contentWindow;
+// Recursively look through frames to compute the total position offset.
+while (win.frameElement) {
+let rect = win.frameElement.getBoundingClientRect();
+offset.x += rect.left;
+offset.y += rect.top;
+win = win.parent;
+}
+return offset;
+},
+_pointInSelection: function sh_pointInSelection(aX, aY) {
+let offset = this._getViewOffset();
+let rangeRect = this._getSelection().getRangeAt(0).getBoundingClientRect();
+let radius = ElementTouchHelper.getTouchRadius();
+return (aX - offset.x > rangeRect.left - radius.left &&
+aX - offset.x < rangeRect.right + radius.right &&
+aY - offset.y > rangeRect.top - radius.top &&
+aY - offset.y < rangeRect.bottom + radius.bottom);
+},
+// Returns true if the selection has been reversed. Takes optional aIsStartHandle
+// param to decide whether the selection has been reversed.
+_updateCacheForSelection: function sh_updateCacheForSelection(aIsStartHandle) {
+let rects = this._getSelection().getRangeAt(0).getClientRects();
+if (!rects[0]) {
+// nsISelection object exists, but there's nothing actually selected
+throw "Failed to update cache for invalid selection";
+}
+let start = { x: this._isRTL ? rects[0].right : rects[0].left, y: rects[0].bottom };
+let end = { x: this._isRTL ? rects[rects.length - 1].left : rects[rects.length - 1].right, y: rects[rects.length - 1].bottom };
+let selectionReversed = false;
+if (this._cache.start) {
+// If the end moved past the old end, but we're dragging the start handle, then that handle should become the end handle (and vice versa)
+selectionReversed = (aIsStartHandle && (end.y > this._cache.end.y || (end.y == this._cache.end.y && end.x > this._cache.end.x))) ||
+(!aIsStartHandle && (start.y < this._cache.start.y || (start.y == this._cache.start.y && start.x < this._cache.start.x)));
+}
+this._cache.start = start;
+this._cache.end = end;
+return selectionReversed;
+},
+_getHandlePositions: function sh_getHandlePositions(scroll) {
+// the checkHidden function tests to see if the given point is hidden inside an
+// iframe/subdocument. this is so that if we select some text inside an iframe and
+// scroll the iframe so the selection is out of view, we hide the handles rather
+// than having them float on top of the main page content.
+let checkHidden = function(x, y) {
+return false;
+};
+if (this._contentWindow.frameElement) {
+let bounds = this._contentWindow.frameElement.getBoundingClientRect();
+checkHidden = function(x, y) {
+return x < 0 || y < 0 || x > bounds.width || y > bounds.height;
+};
+}
+let positions = null;
+if (this._activeType == this.TYPE_CURSOR) {
+// The left and top properties returned are relative to the client area
+// of the window, so we don't need to account for a sub-frame offset.
+let cursor = this._domWinUtils.sendQueryContentEvent(this._domWinUtils.QUERY_CARET_RECT, this._targetElement.selectionEnd, 0, 0, 0,
+this._domWinUtils.QUERY_CONTENT_FLAG_USE_XP_LINE_BREAK);
+// the return value from sendQueryContentEvent is in LayoutDevice pixels and we want CSS pixels, so
+// divide by the pixel ratio
+let x = cursor.left / window.devicePixelRatio;
+let y = (cursor.top + cursor.height) / window.devicePixelRatio;
+return [{ handle: this.HANDLE_TYPE_MIDDLE,
+left: x + scroll.X,
+top: y + scroll.Y,
+hidden: checkHidden(x, y) }];
+} else {
+let sx = this._cache.start.x;
+let sy = this._cache.start.y;
+let ex = this._cache.end.x;
+let ey = this._cache.end.y;
+// Translate coordinates to account for selections in sub-frames. We can't cache
+// this because the top-level page may have scrolled since selection started.
+let offset = this._getViewOffset();
+return  [{ handle: this.HANDLE_TYPE_START,
+left: sx + offset.x + scroll.X,
+top: sy + offset.y + scroll.Y,
+hidden: checkHidden(sx, sy) },
+{ handle: this.HANDLE_TYPE_END,
+left: ex + offset.x + scroll.X,
+top: ey + offset.y + scroll.Y,
+hidden: checkHidden(ex, ey) }];
+}
+},
+// Position handles, but avoid superfluous re-positioning (helps during
+// "TextSelection:LayerReflow", "scroll" of top-level document, etc).
+_positionHandlesOnChange: function() {
+// Helper function to compare position messages
+let samePositions = function(aPrev, aCurr) {
+if (aPrev.length != aCurr.length) {
+return false;
+}
+for (let i = 0; i < aPrev.length; i++) {
+if (aPrev[i].left != aCurr[i].left ||
+aPrev[i].top != aCurr[i].top ||
+aPrev[i].hidden != aCurr[i].hidden) {
+return false;
+}
+}
+return true;
+}
+let positions = this._getHandlePositions(this._getScrollPos());
+if (!samePositions(this._prevHandlePositions, positions)) {
+this._positionHandles(positions);
+}
+},
+// Position handles, allow for re-position, in case user drags handle
+// to invalid position, then releases, we can put it back where it started
+// positions is an array of objects with data about handle positions,
+// which we get from _getHandlePositions.
+_positionHandles: function sh_positionHandles(positions) {
+if (!positions) {
+positions = this._getHandlePositions(this._getScrollPos());
+}
+sendMessageToJava({
+type: "TextSelection:PositionHandles",
+positions: positions,
+rtl: this._isRTL
+});
+this._prevHandlePositions = positions;
+// Text state transitions (text <--> no text) will affect selection context and actionbar display
+let currTargetElementHasText = (this._targetElement.textLength > 0);
+if (currTargetElementHasText != this._prevTargetElementHasText) {
+this._prevTargetElementHasText = currTargetElementHasText;
+this._updateMenu();
+}
+},
+subdocumentScrolled: function sh_subdocumentScrolled(aElement) {
+if (this._activeType == this.TYPE_NONE) {
+return;
+}
+let scrollView = aElement.ownerDocument.defaultView;
+let view = this._contentWindow;
+while (true) {
+if (view == scrollView) {
+// The selection is in a view (or sub-view) of the view that scrolled.
+// So we need to reposition the handles.
+if (this._activeType == this.TYPE_SELECTION) {
+this._updateCacheForSelection();
+}
+this._positionHandles();
+break;
+}
+if (view == view.parent) {
+break;
+}
+view = view.parent;
+}
+}
+};