summaryrefslogtreecommitdiffstats
path: root/toolkit/content/widgets/findbar.xml
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /toolkit/content/widgets/findbar.xml
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'toolkit/content/widgets/findbar.xml')
-rw-r--r--toolkit/content/widgets/findbar.xml1397
1 files changed, 1397 insertions, 0 deletions
diff --git a/toolkit/content/widgets/findbar.xml b/toolkit/content/widgets/findbar.xml
new file mode 100644
index 000000000..f90d41227
--- /dev/null
+++ b/toolkit/content/widgets/findbar.xml
@@ -0,0 +1,1397 @@
+<?xml version="1.0"?>
+
+<!-- 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/. -->
+
+<!DOCTYPE bindings [
+<!ENTITY % findBarDTD SYSTEM "chrome://global/locale/findbar.dtd" >
+%findBarDTD;
+]>
+
+<bindings id="findbarBindings"
+ xmlns="http://www.mozilla.org/xbl"
+ xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+ xmlns:xbl="http://www.mozilla.org/xbl">
+
+ <!-- Private binding -->
+ <binding id="findbar-textbox"
+ extends="chrome://global/content/bindings/textbox.xml#textbox">
+ <implementation>
+
+ <field name="_findbar">null</field>
+ <property name="findbar" readonly="true">
+ <getter>
+ return this._findbar ?
+ this._findbar : this._findbar = document.getBindingParent(this);
+ </getter>
+ </property>
+
+ <method name="_handleEnter">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ if (this.findbar._findMode == this.findbar.FIND_NORMAL) {
+ let findString = this.findbar._findField;
+ if (!findString.value)
+ return;
+ if (aEvent.getModifierState("Accel")) {
+ this.findbar.getElement("highlight").click();
+ return;
+ }
+
+ this.findbar.onFindAgainCommand(aEvent.shiftKey);
+ } else {
+ this.findbar._finishFAYT(aEvent);
+ }
+ ]]></body>
+ </method>
+
+ <method name="_handleTab">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ let shouldHandle = !aEvent.altKey && !aEvent.ctrlKey &&
+ !aEvent.metaKey;
+ if (shouldHandle &&
+ this.findbar._findMode != this.findbar.FIND_NORMAL) {
+
+ this.findbar._finishFAYT(aEvent);
+ }
+ ]]></body>
+ </method>
+ </implementation>
+
+ <handlers>
+ <handler event="input"><![CDATA[
+ // We should do nothing during composition. E.g., composing string
+ // before converting may matches a forward word of expected word.
+ // After that, even if user converts the composition string to the
+ // expected word, it may find second or later searching word in the
+ // document.
+ if (this.findbar._isIMEComposing) {
+ return;
+ }
+
+ if (this._hadValue && !this.value) {
+ this._willfullyDeleted = true;
+ this._hadValue = false;
+ } else if (this.value.trim()) {
+ this._hadValue = true;
+ this._willfullyDeleted = false;
+ }
+ this.findbar._find(this.value);
+ ]]></handler>
+
+ <handler event="keypress"><![CDATA[
+ let shouldHandle = !event.altKey && !event.ctrlKey &&
+ !event.metaKey && !event.shiftKey;
+
+ switch (event.keyCode) {
+ case KeyEvent.DOM_VK_RETURN:
+ this._handleEnter(event);
+ break;
+ case KeyEvent.DOM_VK_TAB:
+ this._handleTab(event);
+ break;
+ case KeyEvent.DOM_VK_PAGE_UP:
+ case KeyEvent.DOM_VK_PAGE_DOWN:
+ if (shouldHandle) {
+ this.findbar.browser.finder.keyPress(event);
+ event.preventDefault();
+ }
+ break;
+ case KeyEvent.DOM_VK_UP:
+ case KeyEvent.DOM_VK_DOWN:
+ this.findbar.browser.finder.keyPress(event);
+ event.preventDefault();
+ break;
+ }
+ ]]></handler>
+
+ <handler event="blur"><![CDATA[
+ let findbar = this.findbar;
+ // Note: This code used to remove the selection
+ // if it matched an editable.
+ findbar.browser.finder.enableSelection();
+ ]]></handler>
+
+ <handler event="focus"><![CDATA[
+ if (/Mac/.test(navigator.platform)) {
+ let findbar = this.findbar;
+ findbar._onFindFieldFocus();
+ }
+ ]]></handler>
+
+ <handler event="compositionstart"><![CDATA[
+ // Don't close the find toolbar while IME is composing.
+ let findbar = this.findbar;
+ findbar._isIMEComposing = true;
+ if (findbar._quickFindTimeout) {
+ clearTimeout(findbar._quickFindTimeout);
+ findbar._quickFindTimeout = null;
+ }
+ ]]></handler>
+
+ <handler event="compositionend"><![CDATA[
+ let findbar = this.findbar;
+ findbar._isIMEComposing = false;
+ if (findbar._findMode != findbar.FIND_NORMAL)
+ findbar._setFindCloseTimeout();
+ ]]></handler>
+
+ <handler event="dragover"><![CDATA[
+ if (event.dataTransfer.types.includes("text/plain"))
+ event.preventDefault();
+ ]]></handler>
+
+ <handler event="drop"><![CDATA[
+ let value = event.dataTransfer.getData("text/plain");
+ this.value = value;
+ this.findbar._find(value);
+ event.stopPropagation();
+ event.preventDefault();
+ ]]></handler>
+ </handlers>
+ </binding>
+
+ <binding id="findbar"
+ extends="chrome://global/content/bindings/toolbar.xml#toolbar">
+ <resources>
+ <stylesheet src="chrome://global/skin/findBar.css"/>
+ </resources>
+
+ <content hidden="true">
+ <xul:hbox anonid="findbar-container" class="findbar-container" flex="1" align="center">
+ <xul:hbox anonid="findbar-textbox-wrapper" align="stretch">
+ <xul:textbox anonid="findbar-textbox"
+ class="findbar-textbox findbar-find-fast"
+ xbl:inherits="flash"/>
+ <xul:toolbarbutton anonid="find-previous"
+ class="findbar-find-previous tabbable"
+ tooltiptext="&previous.tooltip;"
+ oncommand="onFindAgainCommand(true);"
+ disabled="true"
+ xbl:inherits="accesskey=findpreviousaccesskey"/>
+ <xul:toolbarbutton anonid="find-next"
+ class="findbar-find-next tabbable"
+ tooltiptext="&next.tooltip;"
+ oncommand="onFindAgainCommand(false);"
+ disabled="true"
+ xbl:inherits="accesskey=findnextaccesskey"/>
+ </xul:hbox>
+ <xul:toolbarbutton anonid="highlight"
+ class="findbar-highlight findbar-button tabbable"
+ label="&highlightAll.label;"
+ accesskey="&highlightAll.accesskey;"
+ tooltiptext="&highlightAll.tooltiptext;"
+ oncommand="toggleHighlight(this.checked);"
+ type="checkbox"
+ xbl:inherits="accesskey=highlightaccesskey"/>
+ <xul:toolbarbutton anonid="find-case-sensitive"
+ class="findbar-case-sensitive findbar-button tabbable"
+ label="&caseSensitive.label;"
+ accesskey="&caseSensitive.accesskey;"
+ tooltiptext="&caseSensitive.tooltiptext;"
+ oncommand="_setCaseSensitivity(this.checked ? 1 : 0);"
+ type="checkbox"
+ xbl:inherits="accesskey=matchcaseaccesskey"/>
+ <xul:toolbarbutton anonid="find-entire-word"
+ class="findbar-entire-word findbar-button tabbable"
+ label="&entireWord.label;"
+ accesskey="&entireWord.accesskey;"
+ tooltiptext="&entireWord.tooltiptext;"
+ oncommand="toggleEntireWord(this.checked);"
+ type="checkbox"
+ xbl:inherits="accesskey=entirewordaccesskey"/>
+ <xul:label anonid="match-case-status" class="findbar-find-fast"/>
+ <xul:label anonid="entire-word-status" class="findbar-find-fast"/>
+ <xul:label anonid="found-matches" class="findbar-find-fast found-matches" hidden="true"/>
+ <xul:image anonid="find-status-icon" class="findbar-find-fast find-status-icon"/>
+ <xul:description anonid="find-status"
+ control="findbar-textbox"
+ class="findbar-find-fast findbar-find-status">
+ <!-- Do not use value, first child is used because it provides a11y with text change events -->
+ </xul:description>
+ </xul:hbox>
+ <xul:toolbarbutton anonid="find-closebutton"
+ class="findbar-closebutton close-icon"
+ tooltiptext="&findCloseButton.tooltip;"
+ oncommand="close();"/>
+ </content>
+
+ <implementation implements="nsIMessageListener, nsIEditActionListener">
+ <!-- Please keep in sync with toolkit/content/browser-content.js -->
+ <field name="FIND_NORMAL">0</field>
+ <field name="FIND_TYPEAHEAD">1</field>
+ <field name="FIND_LINKS">2</field>
+
+ <field name="__findMode">0</field>
+ <property name="_findMode" onget="return this.__findMode;"
+ onset="this.__findMode = val; this._updateBrowserWithState(); return val;"/>
+
+ <field name="_flashFindBar">0</field>
+ <field name="_initialFlashFindBarCount">6</field>
+
+ <!--
+ - For tests that need to know when the find bar is finished
+ - initializing, we store a promise to notify on.
+ -->
+ <field name="_startFindDeferred">null</field>
+
+ <property name="prefillWithSelection"
+ onget="return this.getAttribute('prefillwithselection') != 'false'"
+ onset="this.setAttribute('prefillwithselection', val); return val;"/>
+
+ <method name="getElement">
+ <parameter name="aAnonymousID"/>
+ <body><![CDATA[
+ return document.getAnonymousElementByAttribute(this,
+ "anonid",
+ aAnonymousID)
+ ]]></body>
+ </method>
+
+ <property name="findMode"
+ readonly="true"
+ onget="return this._findMode;"/>
+
+ <property name="hasTransactions" readonly="true">
+ <getter><![CDATA[
+ if (this._findField.value)
+ return true;
+
+ // Watch out for lazy editor init
+ if (this._findField.editor) {
+ let tm = this._findField.editor.transactionManager;
+ return !!(tm.numberOfUndoItems || tm.numberOfRedoItems);
+ }
+ return false;
+ ]]></getter>
+ </property>
+
+ <field name="_browser">null</field>
+ <property name="browser">
+ <getter><![CDATA[
+ if (!this._browser) {
+ this._browser =
+ document.getElementById(this.getAttribute("browserid"));
+ }
+ return this._browser;
+ ]]></getter>
+ <setter><![CDATA[
+ if (this._browser) {
+ if (this._browser.messageManager) {
+ this._browser.messageManager.removeMessageListener("Findbar:Keypress", this);
+ this._browser.messageManager.removeMessageListener("Findbar:Mouseup", this);
+ }
+ let finder = this._browser.finder;
+ if (finder)
+ finder.removeResultListener(this);
+ }
+
+ this._browser = val;
+ if (this._browser) {
+ // Need to do this to ensure the correct initial state.
+ this._updateBrowserWithState();
+ this._browser.messageManager.addMessageListener("Findbar:Keypress", this);
+ this._browser.messageManager.addMessageListener("Findbar:Mouseup", this);
+ this._browser.finder.addResultListener(this);
+
+ this._findField.value = this._browser._lastSearchString;
+ }
+ return val;
+ ]]></setter>
+ </property>
+
+ <field name="__prefsvc">null</field>
+ <property name="_prefsvc">
+ <getter><![CDATA[
+ if (!this.__prefsvc) {
+ this.__prefsvc = Components.classes["@mozilla.org/preferences-service;1"]
+ .getService(Components.interfaces.nsIPrefBranch);
+ }
+ return this.__prefsvc;
+ ]]></getter>
+ </property>
+
+ <field name="_observer"><![CDATA[({
+ _self: this,
+
+ QueryInterface: function(aIID) {
+ if (aIID.equals(Components.interfaces.nsIObserver) ||
+ aIID.equals(Components.interfaces.nsISupportsWeakReference) ||
+ aIID.equals(Components.interfaces.nsISupports))
+ return this;
+
+ throw Components.results.NS_ERROR_NO_INTERFACE;
+ },
+
+ observe: function(aSubject, aTopic, aPrefName) {
+ if (aTopic != "nsPref:changed")
+ return;
+
+ let prefsvc = this._self._prefsvc;
+
+ switch (aPrefName) {
+ case "accessibility.typeaheadfind":
+ this._self._findAsYouType = prefsvc.getBoolPref(aPrefName);
+ break;
+ case "accessibility.typeaheadfind.linksonly":
+ this._self._typeAheadLinksOnly = prefsvc.getBoolPref(aPrefName);
+ break;
+ case "accessibility.typeaheadfind.casesensitive":
+ this._self._setCaseSensitivity(prefsvc.getIntPref(aPrefName));
+ break;
+ case "findbar.entireword":
+ this._self._entireWord = prefsvc.getBoolPref(aPrefName);
+ this._self.toggleEntireWord(this._self._entireWord, true);
+ break;
+ case "findbar.highlightAll":
+ this._self.toggleHighlight(prefsvc.getBoolPref(aPrefName), true);
+ break;
+ case "findbar.modalHighlight":
+ this._self._useModalHighlight = prefsvc.getBoolPref(aPrefName);
+ if (this._self.browser.finder)
+ this._self.browser.finder.onModalHighlightChange(this._self._useModalHighlight);
+ break;
+ }
+ }
+ })]]></field>
+
+ <field name="_destroyed">false</field>
+
+ <constructor><![CDATA[
+ // These elements are accessed frequently and are therefore cached
+ this._findField = this.getElement("findbar-textbox");
+ this._foundMatches = this.getElement("found-matches");
+ this._findStatusIcon = this.getElement("find-status-icon");
+ this._findStatusDesc = this.getElement("find-status");
+
+ this._foundURL = null;
+
+ let prefsvc = this._prefsvc;
+
+ this._quickFindTimeoutLength =
+ prefsvc.getIntPref("accessibility.typeaheadfind.timeout");
+ this._flashFindBar =
+ prefsvc.getIntPref("accessibility.typeaheadfind.flashBar");
+ this._useModalHighlight = prefsvc.getBoolPref("findbar.modalHighlight");
+
+ prefsvc.addObserver("accessibility.typeaheadfind",
+ this._observer, false);
+ prefsvc.addObserver("accessibility.typeaheadfind.linksonly",
+ this._observer, false);
+ prefsvc.addObserver("accessibility.typeaheadfind.casesensitive",
+ this._observer, false);
+ prefsvc.addObserver("findbar.entireword", this._observer, false);
+ prefsvc.addObserver("findbar.highlightAll", this._observer, false);
+ prefsvc.addObserver("findbar.modalHighlight", this._observer, false);
+
+ this._findAsYouType =
+ prefsvc.getBoolPref("accessibility.typeaheadfind");
+ this._typeAheadLinksOnly =
+ prefsvc.getBoolPref("accessibility.typeaheadfind.linksonly");
+ this._typeAheadCaseSensitive =
+ prefsvc.getIntPref("accessibility.typeaheadfind.casesensitive");
+ this._entireWord = prefsvc.getBoolPref("findbar.entireword");
+ this._highlightAll = prefsvc.getBoolPref("findbar.highlightAll");
+
+ // Convenience
+ this.nsITypeAheadFind = Components.interfaces.nsITypeAheadFind;
+ this.nsISelectionController = Components.interfaces.nsISelectionController;
+ this._findSelection = this.nsISelectionController.SELECTION_FIND;
+
+ this._findResetTimeout = -1;
+
+ // Make sure the FAYT keypress listener is attached by initializing the
+ // browser property
+ if (this.getAttribute("browserid"))
+ setTimeout(function(aSelf) { aSelf.browser = aSelf.browser; }, 0, this);
+ ]]></constructor>
+
+ <destructor><![CDATA[
+ this.destroy();
+ ]]></destructor>
+
+ <!-- This is necessary because the destructor isn't called when
+ we are removed from a document that is not destroyed. This
+ needs to be explicitly called in this case -->
+ <method name="destroy">
+ <body><![CDATA[
+ if (this._destroyed)
+ return;
+ this._destroyed = true;
+
+ if (this.browser.finder)
+ this.browser.finder.destroy();
+
+ this.browser = null;
+
+ let prefsvc = this._prefsvc;
+ prefsvc.removeObserver("accessibility.typeaheadfind",
+ this._observer);
+ prefsvc.removeObserver("accessibility.typeaheadfind.linksonly",
+ this._observer);
+ prefsvc.removeObserver("accessibility.typeaheadfind.casesensitive",
+ this._observer);
+ prefsvc.removeObserver("findbar.entireword", this._observer);
+ prefsvc.removeObserver("findbar.highlightAll", this._observer);
+ prefsvc.removeObserver("findbar.modalHighlight", this._observer);
+
+ // Clear all timers that might still be running.
+ this._cancelTimers();
+ ]]></body>
+ </method>
+
+ <method name="_cancelTimers">
+ <body><![CDATA[
+ if (this._flashFindBarTimeout) {
+ clearInterval(this._flashFindBarTimeout);
+ this._flashFindBarTimeout = null;
+ }
+ if (this._quickFindTimeout) {
+ clearTimeout(this._quickFindTimeout);
+ this._quickFindTimeout = null;
+ }
+ if (this._findResetTimeout) {
+ clearTimeout(this._findResetTimeout);
+ this._findResetTimeout = null;
+ }
+ ]]></body>
+ </method>
+
+ <method name="_setFindCloseTimeout">
+ <body><![CDATA[
+ if (this._quickFindTimeout)
+ clearTimeout(this._quickFindTimeout);
+
+ // Don't close the find toolbar while IME is composing OR when the
+ // findbar is already hidden.
+ if (this._isIMEComposing || this.hidden) {
+ this._quickFindTimeout = null;
+ return;
+ }
+
+ this._quickFindTimeout = setTimeout(() => {
+ if (this._findMode != this.FIND_NORMAL)
+ this.close();
+ this._quickFindTimeout = null;
+ }, this._quickFindTimeoutLength);
+ ]]></body>
+ </method>
+
+ <field name="_pluralForm">null</field>
+ <property name="pluralForm">
+ <getter><![CDATA[
+ if (!this._pluralForm) {
+ this._pluralForm = Components.utils.import(
+ "resource://gre/modules/PluralForm.jsm", {}).PluralForm;
+ }
+ return this._pluralForm;
+ ]]></getter>
+ </property>
+
+ <!--
+ - Updates the search match count after each find operation on a new string.
+ - @param aRes
+ - the result of the find operation
+ -->
+ <method name="_updateMatchesCount">
+ <body><![CDATA[
+ if (!this._dispatchFindEvent("matchescount"))
+ return;
+
+ this.browser.finder.requestMatchesCount(this._findField.value,
+ this._findMode == this.FIND_LINKS);
+ ]]></body>
+ </method>
+
+ <!--
+ - Turns highlight on or off.
+ - @param aHighlight (boolean)
+ - Whether to turn the highlight on or off
+ - @param aFromPrefObserver (boolean)
+ - Whether the callee is the pref observer, which means we should
+ - not set the same pref again.
+ -->
+ <method name="toggleHighlight">
+ <parameter name="aHighlight"/>
+ <parameter name="aFromPrefObserver"/>
+ <body><![CDATA[
+ if (aHighlight === this._highlightAll) {
+ return;
+ }
+
+ this.browser.finder.onHighlightAllChange(aHighlight);
+
+ this._setHighlightAll(aHighlight, aFromPrefObserver);
+
+ if (!this._dispatchFindEvent("highlightallchange")) {
+ return;
+ }
+
+ let word = this._findField.value;
+ // Bug 429723. Don't attempt to highlight ""
+ if (aHighlight && !word)
+ return;
+
+ this.browser.finder.highlight(aHighlight, word,
+ this._findMode == this.FIND_LINKS);
+
+ // Update the matches count
+ this._updateMatchesCount(this.nsITypeAheadFind.FIND_FOUND);
+ ]]></body>
+ </method>
+
+ <!--
+ - Updates the highlight-all mode of the findbar and its UI.
+ - @param aHighlight (boolean)
+ - Whether to turn the highlight on or off.
+ - @param aFromPrefObserver (boolean)
+ - Whether the callee is the pref observer, which means we should
+ - not set the same pref again.
+ -->
+ <method name="_setHighlightAll">
+ <parameter name="aHighlight"/>
+ <parameter name="aFromPrefObserver"/>
+ <body><![CDATA[
+ if (typeof aHighlight != "boolean") {
+ aHighlight = this._highlightAll;
+ }
+ if (aHighlight !== this._highlightAll && !aFromPrefObserver) {
+ this._prefsvc.setBoolPref("findbar.highlightAll", aHighlight);
+ }
+ this._highlightAll = aHighlight;
+ let checkbox = this.getElement("highlight");
+ checkbox.checked = this._highlightAll;
+ ]]></body>
+ </method>
+
+ <method name="_maybeHighlightAll">
+ <body><![CDATA[
+ let word = this._findField.value;
+ // Bug 429723. Don't attempt to highlight ""
+ if (!this._highlightAll || !word)
+ return;
+
+ this.browser.finder.highlight(true, word,
+ this._findMode == this.FIND_LINKS);
+ ]]></body>
+ </method>
+
+ <!--
+ - Updates the case-sensitivity mode of the findbar and its UI.
+ - @param [optional] aString
+ - The string for which case sensitivity might be turned on.
+ - This only used when case-sensitivity is in auto mode,
+ - @see _shouldBeCaseSensitive. The default value for this
+ - parameter is the find-field value.
+ -->
+ <method name="_updateCaseSensitivity">
+ <parameter name="aString"/>
+ <body><![CDATA[
+ let val = aString || this._findField.value;
+
+ let caseSensitive = this._shouldBeCaseSensitive(val);
+ let checkbox = this.getElement("find-case-sensitive");
+ let statusLabel = this.getElement("match-case-status");
+ checkbox.checked = caseSensitive;
+
+ statusLabel.value = caseSensitive ? this._caseSensitiveStr : "";
+
+ // Show the checkbox on the full Find bar in non-auto mode.
+ // Show the label in all other cases.
+ let hideCheckbox = this._findMode != this.FIND_NORMAL ||
+ (this._typeAheadCaseSensitive != 0 &&
+ this._typeAheadCaseSensitive != 1);
+ checkbox.hidden = hideCheckbox;
+ statusLabel.hidden = !hideCheckbox;
+
+ this.browser.finder.caseSensitive = caseSensitive;
+ ]]></body>
+ </method>
+
+ <!--
+ - Sets the findbar case-sensitivity mode
+ - @param aCaseSensitivity (int)
+ - 0 - case insensitive
+ - 1 - case sensitive
+ - 2 - auto = case sensitive iff match string contains upper case letters
+ - @see _shouldBeCaseSensitive
+ -->
+ <method name="_setCaseSensitivity">
+ <parameter name="aCaseSensitivity"/>
+ <body><![CDATA[
+ this._typeAheadCaseSensitive = aCaseSensitivity;
+ this._updateCaseSensitivity();
+ this._findFailedString = null;
+ this._find();
+
+ this._dispatchFindEvent("casesensitivitychange");
+ ]]></body>
+ </method>
+
+ <!--
+ - Updates the entire-word mode of the findbar and its UI.
+ -->
+ <method name="_setEntireWord">
+ <body><![CDATA[
+ let entireWord = this._entireWord;
+ let checkbox = this.getElement("find-entire-word");
+ let statusLabel = this.getElement("entire-word-status");
+ checkbox.checked = entireWord;
+
+ statusLabel.value = entireWord ? this._entireWordStr : "";
+
+ // Show the checkbox on the full Find bar in non-auto mode.
+ // Show the label in all other cases.
+ let hideCheckbox = this._findMode != this.FIND_NORMAL;
+ checkbox.hidden = hideCheckbox;
+ statusLabel.hidden = !hideCheckbox;
+
+ this.browser.finder.entireWord = entireWord;
+ ]]></body>
+ </method>
+
+ <!--
+ - Sets the findbar entire-word mode
+ - @param aEntireWord (boolean)
+ - Whether or not entire-word mode should be turned on.
+ -->
+ <method name="toggleEntireWord">
+ <parameter name="aEntireWord"/>
+ <parameter name="aFromPrefObserver"/>
+ <body><![CDATA[
+ if (!aFromPrefObserver) {
+ // Just set the pref; our observer will change the find bar behavior.
+ this._prefsvc.setBoolPref("findbar.entireword", aEntireWord);
+ return;
+ }
+
+ this._findFailedString = null;
+ this._find();
+ ]]></body>
+ </method>
+
+ <field name="_strBundle">null</field>
+ <property name="strBundle">
+ <getter><![CDATA[
+ if (!this._strBundle) {
+ this._strBundle =
+ Components.classes["@mozilla.org/intl/stringbundle;1"]
+ .getService(Components.interfaces.nsIStringBundleService)
+ .createBundle("chrome://global/locale/findbar.properties");
+ }
+ return this._strBundle;
+ ]]></getter>
+ </property>
+
+ <!--
+ - Opens and displays the find bar.
+ -
+ - @param aMode
+ - the find mode to be used, which is either FIND_NORMAL,
+ - FIND_TYPEAHEAD or FIND_LINKS. If not passed, the last
+ - find mode if any or FIND_NORMAL.
+ - @returns true if the find bar wasn't previously open, false otherwise.
+ -->
+ <method name="open">
+ <parameter name="aMode"/>
+ <body><![CDATA[
+ if (aMode != undefined)
+ this._findMode = aMode;
+
+ if (!this._notFoundStr) {
+ var stringsBundle = this.strBundle;
+ this._notFoundStr = stringsBundle.GetStringFromName("NotFound");
+ this._wrappedToTopStr =
+ stringsBundle.GetStringFromName("WrappedToTop");
+ this._wrappedToBottomStr =
+ stringsBundle.GetStringFromName("WrappedToBottom");
+ this._normalFindStr =
+ stringsBundle.GetStringFromName("NormalFind");
+ this._fastFindStr =
+ stringsBundle.GetStringFromName("FastFind");
+ this._fastFindLinksStr =
+ stringsBundle.GetStringFromName("FastFindLinks");
+ this._caseSensitiveStr =
+ stringsBundle.GetStringFromName("CaseSensitive");
+ this._entireWordStr =
+ stringsBundle.GetStringFromName("EntireWord");
+ }
+
+ this._findFailedString = null;
+
+ this._updateFindUI();
+ if (this.hidden) {
+ this.removeAttribute("noanim");
+ this.hidden = false;
+
+ this._updateStatusUI(this.nsITypeAheadFind.FIND_FOUND);
+
+ let event = document.createEvent("Events");
+ event.initEvent("findbaropen", true, false);
+ this.dispatchEvent(event);
+
+ this.browser.finder.onFindbarOpen();
+
+ return true;
+ }
+ return false;
+ ]]></body>
+ </method>
+
+ <!--
+ - Closes the findbar.
+ -->
+ <method name="close">
+ <parameter name="aNoAnim"/>
+ <body><![CDATA[
+ if (this.hidden)
+ return;
+
+ if (aNoAnim)
+ this.setAttribute("noanim", true);
+ this.hidden = true;
+
+ // 'focusContent()' iterates over all listeners in the chrome
+ // process, so we need to call it from here.
+ this.browser.finder.focusContent();
+ this.browser.finder.onFindbarClose();
+
+ this._cancelTimers();
+
+ this._findFailedString = null;
+ ]]></body>
+ </method>
+
+ <method name="clear">
+ <body><![CDATA[
+ this.browser.finder.removeSelection();
+ this._findField.reset();
+ this.toggleHighlight(false);
+ this._updateStatusUI();
+ this._enableFindButtons(false);
+ ]]></body>
+ </method>
+
+ <method name="_dispatchKeypressEvent">
+ <parameter name="aTarget"/>
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ if (!aTarget)
+ return;
+
+ let event = document.createEvent("KeyboardEvent");
+ event.initKeyEvent(aEvent.type, aEvent.bubbles, aEvent.cancelable,
+ aEvent.view, aEvent.ctrlKey, aEvent.altKey,
+ aEvent.shiftKey, aEvent.metaKey, aEvent.keyCode,
+ aEvent.charCode);
+ aTarget.dispatchEvent(event);
+ ]]></body>
+ </method>
+
+ <field name="_xulBrowserWindow">null</field>
+ <method name="_updateStatusUIBar">
+ <parameter name="aFoundURL"/>
+ <body><![CDATA[
+ if (!this._xulBrowserWindow) {
+ try {
+ this._xulBrowserWindow =
+ window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)
+ .getInterface(Components.interfaces.nsIWebNavigation)
+ .QueryInterface(Components.interfaces.nsIDocShellTreeItem)
+ .treeOwner
+ .QueryInterface(Components.interfaces.nsIInterfaceRequestor)
+ .getInterface(Components.interfaces.nsIXULWindow)
+ .XULBrowserWindow;
+ }
+ catch (ex) { }
+ if (!this._xulBrowserWindow)
+ return false;
+ }
+
+ // Call this has the same effect like hovering over link,
+ // the browser shows the URL as a tooltip.
+ this._xulBrowserWindow.setOverLink(aFoundURL || "", null);
+ return true;
+ ]]></body>
+ </method>
+
+ <method name="_finishFAYT">
+ <parameter name="aKeypressEvent"/>
+ <body><![CDATA[
+ this.browser.finder.focusContent();
+
+ if (aKeypressEvent)
+ aKeypressEvent.preventDefault();
+
+ this.browser.finder.keyPress(aKeypressEvent);
+
+ this.close();
+ return true;
+ ]]></body>
+ </method>
+
+ <method name="_shouldBeCaseSensitive">
+ <parameter name="aString"/>
+ <body><![CDATA[
+ if (this._typeAheadCaseSensitive == 0)
+ return false;
+ if (this._typeAheadCaseSensitive == 1)
+ return true;
+
+ return aString != aString.toLowerCase();
+ ]]></body>
+ </method>
+
+ <!-- We get a fake event object through an IPC message which contains the
+ data we need to make a decision. We then return |true| if and only if
+ the page gets to deal with the event itself. Everywhere we return
+ false, the message sender will take care of calling event.preventDefault
+ on the real event. -->
+ <method name="_onBrowserKeypress">
+ <parameter name="aFakeEvent"/>
+ <parameter name="aShouldFastFind"/>
+ <body><![CDATA[
+ const FAYT_LINKS_KEY = "'";
+ const FAYT_TEXT_KEY = "/";
+
+ // Fast keypresses can stack up when the content process is slow or
+ // hangs when in e10s mode. We make sure the findbar isn't 'opened'
+ // several times in a row, because then the find query is selected
+ // each time, losing characters typed initially.
+ let inputField = this._findField.inputField;
+ if (!this.hidden && document.activeElement == inputField) {
+ this._dispatchKeypressEvent(inputField, aFakeEvent);
+ return false;
+ }
+
+ if (this._findMode != this.FIND_NORMAL && this._quickFindTimeout) {
+ if (!aFakeEvent.charCode)
+ return true;
+
+ this._findField.select();
+ this._findField.focus();
+ this._dispatchKeypressEvent(this._findField.inputField, aFakeEvent);
+ return false;
+ }
+
+ if (!aShouldFastFind)
+ return true;
+
+ let key = aFakeEvent.charCode ? String.fromCharCode(aFakeEvent.charCode) : null;
+ let manualstartFAYT = (key == FAYT_LINKS_KEY || key == FAYT_TEXT_KEY);
+ let autostartFAYT = !manualstartFAYT && this._findAsYouType &&
+ key && key != " ";
+ if (manualstartFAYT || autostartFAYT) {
+ let mode = (key == FAYT_LINKS_KEY ||
+ (autostartFAYT && this._typeAheadLinksOnly)) ?
+ this.FIND_LINKS : this.FIND_TYPEAHEAD;
+
+ // Clear bar first, so that when openFindBar() calls setCaseSensitivity()
+ // it doesn't get confused by a lingering value
+ this._findField.value = "";
+
+ this.open(mode);
+ this._setFindCloseTimeout();
+ this._findField.select();
+ this._findField.focus();
+
+ if (autostartFAYT)
+ this._dispatchKeypressEvent(this._findField.inputField, aFakeEvent);
+ else
+ this._updateStatusUI(this.nsITypeAheadFind.FIND_FOUND);
+
+ return false;
+ }
+ return undefined;
+ ]]></body>
+ </method>
+
+ <!-- See nsIMessageListener -->
+ <method name="receiveMessage">
+ <parameter name="aMessage"/>
+ <body><![CDATA[
+ if (aMessage.target != this._browser) {
+ return undefined;
+ }
+ switch (aMessage.name) {
+ case "Findbar:Mouseup":
+ if (!this.hidden && this._findMode != this.FIND_NORMAL)
+ this.close();
+ break;
+
+ case "Findbar:Keypress":
+ return this._onBrowserKeypress(aMessage.data.fakeEvent,
+ aMessage.data.shouldFastFind);
+ }
+ return undefined;
+ ]]></body>
+ </method>
+
+ <method name="_updateBrowserWithState">
+ <body><![CDATA[
+ if (this._browser && this._browser.messageManager) {
+ this._browser.messageManager.sendAsyncMessage("Findbar:UpdateState", {
+ findMode: this._findMode
+ });
+ }
+ ]]></body>
+ </method>
+
+ <method name="_enableFindButtons">
+ <parameter name="aEnable"/>
+ <body><![CDATA[
+ this.getElement("find-next").disabled =
+ this.getElement("find-previous").disabled = !aEnable;
+ ]]></body>
+ </method>
+
+ <!--
+ - Determines whether minimalist or general-purpose search UI is to be
+ - displayed when the find bar is activated.
+ -->
+ <method name="_updateFindUI">
+ <body><![CDATA[
+ let showMinimalUI = this._findMode != this.FIND_NORMAL;
+
+ let nodes = this.getElement("findbar-container").childNodes;
+ let wrapper = this.getElement("findbar-textbox-wrapper");
+ let foundMatches = this._foundMatches;
+ for (let node of nodes) {
+ if (node == wrapper || node == foundMatches)
+ continue;
+ node.hidden = showMinimalUI;
+ }
+ this.getElement("find-next").hidden =
+ this.getElement("find-previous").hidden = showMinimalUI;
+ foundMatches.hidden = showMinimalUI || !foundMatches.value;
+ this._updateCaseSensitivity();
+ this._setEntireWord();
+ this._setHighlightAll();
+
+ if (showMinimalUI)
+ this._findField.classList.add("minimal");
+ else
+ this._findField.classList.remove("minimal");
+
+ if (this._findMode == this.FIND_TYPEAHEAD)
+ this._findField.placeholder = this._fastFindStr;
+ else if (this._findMode == this.FIND_LINKS)
+ this._findField.placeholder = this._fastFindLinksStr;
+ else
+ this._findField.placeholder = this._normalFindStr;
+ ]]></body>
+ </method>
+
+ <method name="_find">
+ <parameter name="aValue"/>
+ <body><![CDATA[
+ if (!this._dispatchFindEvent(""))
+ return;
+
+ let val = aValue || this._findField.value;
+
+ // We have to carry around an explicit version of this,
+ // because finder.searchString doesn't update on failed
+ // searches.
+ this.browser._lastSearchString = val;
+
+ // Only search on input if we don't have a last-failed string,
+ // or if the current search string doesn't start with it.
+ // In entire-word mode we always attemp a find; since sequential matching
+ // is not guaranteed, the first character typed may not be a word (no
+ // match), but the with the second character it may well be a word,
+ // thus a match.
+ if (!this._findFailedString ||
+ !val.startsWith(this._findFailedString) ||
+ this._entireWord) {
+ // Getting here means the user commanded a find op. Make sure any
+ // initial prefilling is ignored if it hasn't happened yet.
+ if (this._startFindDeferred) {
+ this._startFindDeferred.resolve();
+ this._startFindDeferred = null;
+ }
+
+ this._enableFindButtons(val);
+ this._updateCaseSensitivity(val);
+ this._setEntireWord();
+
+ this.browser.finder.fastFind(val, this._findMode == this.FIND_LINKS,
+ this._findMode != this.FIND_NORMAL);
+ }
+
+ if (this._findMode != this.FIND_NORMAL)
+ this._setFindCloseTimeout();
+
+ if (this._findResetTimeout != -1)
+ clearTimeout(this._findResetTimeout);
+
+ // allow a search to happen on input again after a second has
+ // expired since the previous input, to allow for dynamic
+ // content and/or page loading
+ this._findResetTimeout = setTimeout(() => {
+ this._findFailedString = null;
+ this._findResetTimeout = -1;
+ }, 1000);
+ ]]></body>
+ </method>
+
+ <method name="_flash">
+ <body><![CDATA[
+ if (this._flashFindBarCount === undefined)
+ this._flashFindBarCount = this._initialFlashFindBarCount;
+
+ if (this._flashFindBarCount-- == 0) {
+ clearInterval(this._flashFindBarTimeout);
+ this.removeAttribute("flash");
+ this._flashFindBarCount = 6;
+ return;
+ }
+
+ this.setAttribute("flash",
+ (this._flashFindBarCount % 2 == 0) ?
+ "false" : "true");
+ ]]></body>
+ </method>
+
+ <method name="_findAgain">
+ <parameter name="aFindPrevious"/>
+ <body><![CDATA[
+ this.browser.finder.findAgain(aFindPrevious,
+ this._findMode == this.FIND_LINKS,
+ this._findMode != this.FIND_NORMAL);
+ ]]></body>
+ </method>
+
+ <method name="_updateStatusUI">
+ <parameter name="res"/>
+ <parameter name="aFindPrevious"/>
+ <body><![CDATA[
+ switch (res) {
+ case this.nsITypeAheadFind.FIND_WRAPPED:
+ this._findStatusIcon.setAttribute("status", "wrapped");
+ this._findStatusDesc.textContent =
+ aFindPrevious ? this._wrappedToBottomStr : this._wrappedToTopStr;
+ this._findField.removeAttribute("status");
+ break;
+ case this.nsITypeAheadFind.FIND_NOTFOUND:
+ this._findStatusIcon.setAttribute("status", "notfound");
+ this._findStatusDesc.textContent = this._notFoundStr;
+ this._findField.setAttribute("status", "notfound");
+ break;
+ case this.nsITypeAheadFind.FIND_PENDING:
+ this._findStatusIcon.setAttribute("status", "pending");
+ this._findStatusDesc.textContent = "";
+ this._findField.removeAttribute("status");
+ break;
+ case this.nsITypeAheadFind.FIND_FOUND:
+ default:
+ this._findStatusIcon.removeAttribute("status");
+ this._findStatusDesc.textContent = "";
+ this._findField.removeAttribute("status");
+ break;
+ }
+ ]]></body>
+ </method>
+
+ <method name="updateControlState">
+ <parameter name="aResult"/>
+ <parameter name="aFindPrevious"/>
+ <body><![CDATA[
+ this._updateStatusUI(aResult, aFindPrevious);
+ this._enableFindButtons(aResult !== this.nsITypeAheadFind.FIND_NOTFOUND);
+ ]]></body>
+ </method>
+
+ <method name="_dispatchFindEvent">
+ <parameter name="aType"/>
+ <parameter name="aFindPrevious"/>
+ <body><![CDATA[
+ let event = document.createEvent("CustomEvent");
+ event.initCustomEvent("find" + aType, true, true, {
+ query: this._findField.value,
+ caseSensitive: !!this._typeAheadCaseSensitive,
+ entireWord: this._entireWord,
+ highlightAll: this._highlightAll,
+ findPrevious: aFindPrevious
+ });
+ return this.dispatchEvent(event);
+ ]]></body>
+ </method>
+
+
+ <!--
+ - Opens the findbar, focuses the findfield and selects its contents.
+ - Also flashes the findbar the first time it's used.
+ - @param aMode
+ - the find mode to be used, which is either FIND_NORMAL,
+ - FIND_TYPEAHEAD or FIND_LINKS. If not passed, the last
+ - find mode if any or FIND_NORMAL.
+ -->
+ <method name="startFind">
+ <parameter name="aMode"/>
+ <body><![CDATA[
+ let prefsvc = this._prefsvc;
+ let userWantsPrefill = true;
+ this.open(aMode);
+
+ if (this._flashFindBar) {
+ this._flashFindBarTimeout = setInterval(() => this._flash(), 500);
+ prefsvc.setIntPref("accessibility.typeaheadfind.flashBar",
+ --this._flashFindBar);
+ }
+
+ let {PromiseUtils} =
+ Components.utils.import("resource://gre/modules/PromiseUtils.jsm", {});
+ this._startFindDeferred = PromiseUtils.defer();
+ let startFindPromise = this._startFindDeferred.promise;
+
+ if (this.prefillWithSelection)
+ userWantsPrefill =
+ prefsvc.getBoolPref("accessibility.typeaheadfind.prefillwithselection");
+
+ if (this.prefillWithSelection && userWantsPrefill) {
+ // NB: We have to focus this._findField here so tests that send
+ // key events can open and close the find bar synchronously.
+ this._findField.focus();
+
+ // (e10s) since we focus lets also select it, otherwise that would
+ // only happen in this.onCurrentSelection and, because it is async,
+ // there's a chance keypresses could come inbetween, leading to
+ // jumbled up queries.
+ this._findField.select();
+
+ this.browser.finder.getInitialSelection();
+ return startFindPromise;
+ }
+
+ // If userWantsPrefill is false but prefillWithSelection is true,
+ // then we might need to check the selection clipboard. Call
+ // onCurrentSelection to do so.
+ // Note: this.onCurrentSelection clears this._startFindDeferred.
+ this.onCurrentSelection("", true);
+ return startFindPromise;
+ ]]></body>
+ </method>
+
+ <!--
+ - Convenient alias to startFind(gFindBar.FIND_NORMAL);
+ -
+ - You should generally map the window's find command to this method.
+ - e.g. <command name="cmd_find" oncommand="gFindBar.onFindCommand();"/>
+ -->
+ <method name="onFindCommand">
+ <body><![CDATA[
+ return this.startFind(this.FIND_NORMAL);
+ ]]></body>
+ </method>
+
+ <!--
+ - Stub for find-next and find-previous commands
+ - @param aFindPrevious
+ - true for find-previous, false otherwise.
+ -->
+ <method name="onFindAgainCommand">
+ <parameter name="aFindPrevious"/>
+ <body><![CDATA[
+ let findString = this._browser.finder.searchString || this._findField.value;
+ if (!findString)
+ return this.startFind();
+
+ // We dispatch the findAgain event here instead of in _findAgain since
+ // if there is a find event handler that prevents the default then
+ // finder.searchString will never get updated which in turn means
+ // there would never be findAgain events because of the logic below.
+ if (!this._dispatchFindEvent("again", aFindPrevious))
+ return undefined;
+
+ // user explicitly requested another search, so do it even if we think it'll fail
+ this._findFailedString = null;
+
+ // Ensure the stored SearchString is in sync with what we want to find
+ if (this._findField.value != this._browser.finder.searchString) {
+ this._find(this._findField.value);
+ } else {
+ this._findAgain(aFindPrevious);
+ if (this._useModalHighlight) {
+ this.open();
+ this._findField.select();
+ this._findField.focus();
+ }
+ }
+
+ return undefined;
+ ]]></body>
+ </method>
+
+#ifdef XP_MACOSX
+ <!--
+ - Fetches the currently selected text and sets that as the text to search
+ - next. This is a MacOS specific feature.
+ -->
+ <method name="onFindSelectionCommand">
+ <body><![CDATA[
+ let searchString = this.browser.finder.setSearchStringToSelection();
+ if (searchString)
+ this._findField.value = searchString;
+ ]]></body>
+ </method>
+
+ <method name="_onFindFieldFocus">
+ <body><![CDATA[
+ let prefsvc = this._prefsvc;
+ const kPref = "accessibility.typeaheadfind.prefillwithselection";
+ if (this.prefillWithSelection && prefsvc.getBoolPref(kPref))
+ return;
+
+ let clipboardSearchString = this._browser.finder.clipboardSearchString;
+ if (clipboardSearchString && this._findField.value != clipboardSearchString &&
+ !this._findField._willfullyDeleted) {
+ this._findField.value = clipboardSearchString;
+ this._findField._hadValue = true;
+ // Changing the search string makes the previous status invalid, so
+ // we better clear it here.
+ this._updateStatusUI();
+ }
+ ]]></body>
+ </method>
+#endif
+
+ <!--
+ - This handles all the result changes for both
+ - type-ahead-find and highlighting.
+ - @param aResult
+ - One of the nsITypeAheadFind.FIND_* constants
+ - indicating the result of a search operation.
+ - @param aFindBackwards
+ - If the search was done from the bottom to
+ - the top. This is used for right error messages
+ - when reaching "the end of the page".
+ - @param aLinkURL
+ - When a link matched then its URK. Always null
+ - when not in FIND_LINKS mode.
+ -->
+ <method name="onFindResult">
+ <parameter name="aData"/>
+ <body><![CDATA[
+ if (aData.result == this.nsITypeAheadFind.FIND_NOTFOUND) {
+ // If an explicit Find Again command fails, re-open the toolbar.
+ if (aData.storeResult && this.open()) {
+ this._findField.select();
+ this._findField.focus();
+ }
+ this._findFailedString = aData.searchString;
+ } else {
+ this._findFailedString = null;
+ }
+
+ this._updateStatusUI(aData.result, aData.findBackwards);
+ this._updateStatusUIBar(aData.linkURL);
+
+ if (this._findMode != this.FIND_NORMAL)
+ this._setFindCloseTimeout();
+ ]]></body>
+ </method>
+
+ <!--
+ - This handles all the result changes for matches counts.
+ - @param aResult
+ - Result Object, containing the total amount of matches and a vector
+ - of the current result.
+ -->
+ <method name="onMatchesCountResult">
+ <parameter name="aResult"/>
+ <body><![CDATA[
+ if (aResult.total !== 0) {
+ if (aResult.total == -1) {
+ this._foundMatches.value = this.pluralForm.get(
+ aResult.limit,
+ this.strBundle.GetStringFromName("FoundMatchesCountLimit")
+ ).replace("#1", aResult.limit);
+ } else {
+ this._foundMatches.value = this.pluralForm.get(
+ aResult.total,
+ this.strBundle.GetStringFromName("FoundMatches")
+ ).replace("#1", aResult.current)
+ .replace("#2", aResult.total);
+ }
+ this._foundMatches.hidden = false;
+ } else {
+ this._foundMatches.hidden = true;
+ this._foundMatches.value = "";
+ }
+ ]]></body>
+ </method>
+
+ <method name="onHighlightFinished">
+ <parameter name="result"/>
+ <body><![CDATA[
+ // Noop.
+ ]]></body>
+ </method>
+
+ <method name="onCurrentSelection">
+ <parameter name="aSelectionString" />
+ <parameter name="aIsInitialSelection" />
+ <body><![CDATA[
+ // Ignore the prefill if the user has already typed in the findbar,
+ // it would have been overwritten anyway. See bug 1198465.
+ if (aIsInitialSelection && !this._startFindDeferred)
+ return;
+
+ if (/Mac/.test(navigator.platform) && aIsInitialSelection && !aSelectionString) {
+ let clipboardSearchString = this.browser.finder.clipboardSearchString;
+ if (clipboardSearchString)
+ aSelectionString = clipboardSearchString;
+ }
+
+ if (aSelectionString)
+ this._findField.value = aSelectionString;
+
+ if (aIsInitialSelection) {
+ this._enableFindButtons(!!this._findField.value);
+ this._findField.select();
+ this._findField.focus();
+
+ this._startFindDeferred.resolve();
+ this._startFindDeferred = null;
+ }
+ ]]></body>
+ </method>
+
+ <!--
+ - This handler may cancel a request to focus content by returning |false|
+ - explicitly.
+ -->
+ <method name="shouldFocusContent">
+ <body><![CDATA[
+ const fm = Components.classes["@mozilla.org/focus-manager;1"]
+ .getService(Components.interfaces.nsIFocusManager);
+ if (fm.focusedWindow != window)
+ return false;
+
+ let focusedElement = fm.focusedElement;
+ if (!focusedElement)
+ return false;
+
+ let bindingParent = document.getBindingParent(focusedElement);
+ if (bindingParent != this && bindingParent != this._findField)
+ return false;
+
+ return true;
+ ]]></body>
+ </method>
+
+ </implementation>
+
+ <handlers>
+ <!--
+ - We have to guard against `this.close` being |null| due to an unknown
+ - issue, which is tracked in bug 957999.
+ -->
+ <handler event="keypress" keycode="VK_ESCAPE" phase="capturing"
+ action="if (this.close) this.close();" preventdefault="true"/>
+ </handlers>
+ </binding>
+</bindings>
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-22 00:05:01 +0000