summaryrefslogtreecommitdiffstats
path: root/application/basilisk/components/search/content
diff options
context:
space:
mode:
authorMatt A. Tobin <email@mattatobin.com>2018-02-02 03:32:58 -0500
committerMatt A. Tobin <email@mattatobin.com>2018-02-02 03:32:58 -0500
commite72ef92b5bdc43cd2584198e2e54e951b70299e8 (patch)
tree01ceb4a897c33eca9e7ccf2bc3aefbe530169fe5 /application/basilisk/components/search/content
parent0d19b77d3eaa5b8d837bf52c19759e68e42a1c4c (diff)
downloadUXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.tar
UXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.tar.gz
UXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.tar.lz
UXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.tar.xz
UXP-e72ef92b5bdc43cd2584198e2e54e951b70299e8.zip
Add Basilisk
Diffstat (limited to 'application/basilisk/components/search/content')
-rw-r--r--application/basilisk/components/search/content/search.xml2325
-rw-r--r--application/basilisk/components/search/content/searchReset.js90
-rw-r--r--application/basilisk/components/search/content/searchReset.xhtml61
-rw-r--r--application/basilisk/components/search/content/searchbarBindings.css18
4 files changed, 2494 insertions, 0 deletions
diff --git a/application/basilisk/components/search/content/search.xml b/application/basilisk/components/search/content/search.xml
new file mode 100644
index 000000000..3b675df57
--- /dev/null
+++ b/application/basilisk/components/search/content/search.xml
@@ -0,0 +1,2325 @@
+<?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 % searchBarDTD SYSTEM "chrome://browser/locale/searchbar.dtd" >
+%searchBarDTD;
+<!ENTITY % browserDTD SYSTEM "chrome://browser/locale/browser.dtd">
+%browserDTD;
+]>
+
+<bindings id="SearchBindings"
+ 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">
+
+ <binding id="searchbar">
+ <resources>
+ <stylesheet src="chrome://browser/content/search/searchbarBindings.css"/>
+ <stylesheet src="chrome://browser/skin/searchbar.css"/>
+ </resources>
+ <content>
+ <xul:stringbundle src="chrome://browser/locale/search.properties"
+ anonid="searchbar-stringbundle"/>
+ <!--
+ There is a dependency between "maxrows" attribute and
+ "SuggestAutoComplete._historyLimit" (nsSearchSuggestions.js). Changing
+ one of them requires changing the other one.
+ -->
+ <xul:textbox class="searchbar-textbox"
+ anonid="searchbar-textbox"
+ type="autocomplete"
+ inputtype="search"
+ flex="1"
+ autocompletepopup="PopupSearchAutoComplete"
+ autocompletesearch="search-autocomplete"
+ autocompletesearchparam="searchbar-history"
+ maxrows="10"
+ completeselectedindex="true"
+ minresultsforpopup="0"
+ xbl:inherits="disabled,disableautocomplete,searchengine,src,newlines">
+ <!--
+ Empty <box> to properly position the icon within the autocomplete
+ binding's anonymous children (the autocomplete binding positions <box>
+ children differently)
+ -->
+ <xul:box>
+ <xul:hbox class="searchbar-search-button-container">
+ <xul:image class="searchbar-search-button"
+ anonid="searchbar-search-button"
+ xbl:inherits="addengines"
+ tooltiptext="&searchEndCap.label;"/>
+ </xul:hbox>
+ </xul:box>
+ <xul:hbox class="search-go-container">
+ <xul:image class="search-go-button" hidden="true"
+ anonid="search-go-button"
+ onclick="handleSearchCommand(event);"
+ tooltiptext="&searchEndCap.label;"/>
+ </xul:hbox>
+ </xul:textbox>
+ </content>
+
+ <implementation implements="nsIObserver">
+ <constructor><![CDATA[
+ if (this.parentNode.parentNode.localName == "toolbarpaletteitem")
+ return;
+ // Make sure we rebuild the popup in onpopupshowing
+ this._needToBuildPopup = true;
+
+ Services.obs.addObserver(this, "browser-search-engine-modified", false);
+
+ this._initialized = true;
+
+ Services.search.init((function search_init_cb(aStatus) {
+ // Bail out if the binding's been destroyed
+ if (!this._initialized)
+ return;
+
+ if (Components.isSuccessCode(aStatus)) {
+ // Refresh the display (updating icon, etc)
+ this.updateDisplay();
+ BrowserSearch.updateOpenSearchBadge();
+ } else {
+ Components.utils.reportError("Cannot initialize search service, bailing out: " + aStatus);
+ }
+ }).bind(this));
+ ]]></constructor>
+
+ <destructor><![CDATA[
+ this.destroy();
+ ]]></destructor>
+
+ <method name="destroy">
+ <body><![CDATA[
+ if (this._initialized) {
+ this._initialized = false;
+
+ Services.obs.removeObserver(this, "browser-search-engine-modified");
+ }
+
+ // Make sure to break the cycle from _textbox to us. Otherwise we leak
+ // the world. But make sure it's actually pointing to us.
+ // Also make sure the textbox has ever been constructed, otherwise the
+ // _textbox getter will cause the textbox constructor to run, add an
+ // observer, and leak the world too.
+ if (this._textboxInitialized && this._textbox.mController.input == this)
+ this._textbox.mController.input = null;
+ ]]></body>
+ </method>
+
+ <field name="_ignoreFocus">false</field>
+ <field name="_clickClosedPopup">false</field>
+ <field name="_stringBundle">document.getAnonymousElementByAttribute(this,
+ "anonid", "searchbar-stringbundle");</field>
+ <field name="_textboxInitialized">false</field>
+ <field name="_textbox">document.getAnonymousElementByAttribute(this,
+ "anonid", "searchbar-textbox");</field>
+ <field name="_engines">null</field>
+ <field name="FormHistory" readonly="true">
+ (Components.utils.import("resource://gre/modules/FormHistory.jsm", {})).FormHistory;
+ </field>
+
+ <property name="engines" readonly="true">
+ <getter><![CDATA[
+ if (!this._engines)
+ this._engines = Services.search.getVisibleEngines();
+ return this._engines;
+ ]]></getter>
+ </property>
+
+ <property name="currentEngine">
+ <setter><![CDATA[
+ Services.search.currentEngine = val;
+ return val;
+ ]]></setter>
+ <getter><![CDATA[
+ var currentEngine = Services.search.currentEngine;
+ // Return a dummy engine if there is no currentEngine
+ return currentEngine || {name: "", uri: null};
+ ]]></getter>
+ </property>
+
+ <!-- textbox is used by sanitize.js to clear the undo history when
+ clearing form information. -->
+ <property name="textbox" readonly="true"
+ onget="return this._textbox;"/>
+
+ <property name="value" onget="return this._textbox.value;"
+ onset="return this._textbox.value = val;"/>
+
+ <method name="focus">
+ <body><![CDATA[
+ this._textbox.focus();
+ ]]></body>
+ </method>
+
+ <method name="select">
+ <body><![CDATA[
+ this._textbox.select();
+ ]]></body>
+ </method>
+
+ <method name="observe">
+ <parameter name="aEngine"/>
+ <parameter name="aTopic"/>
+ <parameter name="aVerb"/>
+ <body><![CDATA[
+ if (aTopic == "browser-search-engine-modified") {
+ switch (aVerb) {
+ case "engine-removed":
+ this.offerNewEngine(aEngine);
+ break;
+ case "engine-added":
+ this.hideNewEngine(aEngine);
+ break;
+ case "engine-changed":
+ // An engine was removed (or hidden) or added, or an icon was
+ // changed. Do nothing special.
+ }
+
+ // Make sure the engine list is refetched next time it's needed
+ this._engines = null;
+
+ // Update the popup header and update the display after any modification.
+ this._textbox.popup.updateHeader();
+ this.updateDisplay();
+ }
+ ]]></body>
+ </method>
+
+ <!-- There are two seaprate lists of search engines, whose uses intersect
+ in this file. The search service (nsIBrowserSearchService and
+ nsSearchService.js) maintains a list of Engine objects which is used to
+ populate the searchbox list of available engines and to perform queries.
+ That list is accessed here via this.SearchService, and it's that sort of
+ Engine that is passed to this binding's observer as aEngine.
+
+ In addition, browser.js fills two lists of autodetected search engines
+ (browser.engines and browser.hiddenEngines) as properties of
+ mCurrentBrowser. Those lists contain unnamed JS objects of the form
+ { uri:, title:, icon: }, and that's what the searchbar uses to determine
+ whether to show any "Add <EngineName>" menu items in the drop-down.
+
+ The two types of engines are currently related by their identifying
+ titles (the Engine object's 'name'), although that may change; see bug
+ 335102. -->
+
+ <!-- If the engine that was just removed from the searchbox list was
+ autodetected on this page, move it to each browser's active list so it
+ will be offered to be added again. -->
+ <method name="offerNewEngine">
+ <parameter name="aEngine"/>
+ <body><![CDATA[
+ for (let browser of gBrowser.browsers) {
+ if (browser.hiddenEngines) {
+ // XXX This will need to be changed when engines are identified by
+ // URL rather than title; see bug 335102.
+ var removeTitle = aEngine.wrappedJSObject.name;
+ for (var i = 0; i < browser.hiddenEngines.length; i++) {
+ if (browser.hiddenEngines[i].title == removeTitle) {
+ if (!browser.engines)
+ browser.engines = [];
+ browser.engines.push(browser.hiddenEngines[i]);
+ browser.hiddenEngines.splice(i, 1);
+ break;
+ }
+ }
+ }
+ }
+ BrowserSearch.updateOpenSearchBadge();
+ ]]></body>
+ </method>
+
+ <!-- If the engine that was just added to the searchbox list was
+ autodetected on this page, move it to each browser's hidden list so it is
+ no longer offered to be added. -->
+ <method name="hideNewEngine">
+ <parameter name="aEngine"/>
+ <body><![CDATA[
+ for (let browser of gBrowser.browsers) {
+ if (browser.engines) {
+ // XXX This will need to be changed when engines are identified by
+ // URL rather than title; see bug 335102.
+ var removeTitle = aEngine.wrappedJSObject.name;
+ for (var i = 0; i < browser.engines.length; i++) {
+ if (browser.engines[i].title == removeTitle) {
+ if (!browser.hiddenEngines)
+ browser.hiddenEngines = [];
+ browser.hiddenEngines.push(browser.engines[i]);
+ browser.engines.splice(i, 1);
+ break;
+ }
+ }
+ }
+ }
+ BrowserSearch.updateOpenSearchBadge();
+ ]]></body>
+ </method>
+
+ <method name="setIcon">
+ <parameter name="element"/>
+ <parameter name="uri"/>
+ <body><![CDATA[
+ element.setAttribute("src", uri);
+ ]]></body>
+ </method>
+
+ <method name="updateDisplay">
+ <body><![CDATA[
+ var uri = this.currentEngine.iconURI;
+ this.setIcon(this, uri ? uri.spec : "");
+
+ var name = this.currentEngine.name;
+ var text = this._stringBundle.getFormattedString("searchtip", [name]);
+
+ this._textbox.placeholder = this._stringBundle.getString("searchPlaceholder");
+ this._textbox.label = text;
+ this._textbox.tooltipText = text;
+ ]]></body>
+ </method>
+
+ <method name="updateGoButtonVisibility">
+ <body><![CDATA[
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "search-go-button")
+ .hidden = !this._textbox.value;
+ ]]></body>
+ </method>
+
+ <method name="openSuggestionsPanel">
+ <parameter name="aShowOnlySettingsIfEmpty"/>
+ <body><![CDATA[
+ if (this._textbox.open)
+ return;
+
+ this._textbox.showHistoryPopup();
+
+ if (this._textbox.value) {
+ // showHistoryPopup does a startSearch("") call, ensure the
+ // controller handles the text from the input box instead:
+ this._textbox.mController.handleText();
+ } else if (aShowOnlySettingsIfEmpty) {
+ this.setAttribute("showonlysettings", "true");
+ }
+ ]]></body>
+ </method>
+
+ <method name="selectEngine">
+ <parameter name="aEvent"/>
+ <parameter name="isNextEngine"/>
+ <body><![CDATA[
+ // Find the new index
+ var newIndex = this.engines.indexOf(this.currentEngine);
+ newIndex += isNextEngine ? 1 : -1;
+
+ if (newIndex >= 0 && newIndex < this.engines.length) {
+ this.currentEngine = this.engines[newIndex];
+ }
+
+ aEvent.preventDefault();
+ aEvent.stopPropagation();
+
+ this.openSuggestionsPanel();
+ ]]></body>
+ </method>
+
+ <method name="handleSearchCommand">
+ <parameter name="aEvent"/>
+ <parameter name="aEngine"/>
+ <parameter name="aForceNewTab"/>
+ <body><![CDATA[
+ var where = "current";
+ let params;
+
+ // Open ctrl/cmd clicks on one-off buttons in a new background tab.
+ if (aEvent && aEvent.originalTarget.getAttribute("anonid") == "search-go-button") {
+ if (aEvent.button == 2)
+ return;
+ where = whereToOpenLink(aEvent, false, true);
+ } else if (aForceNewTab) {
+ where = "tab";
+ if (Services.prefs.getBoolPref("browser.tabs.loadInBackground"))
+ where += "-background";
+ } else {
+ var newTabPref = Services.prefs.getBoolPref("browser.search.openintab");
+ if (((aEvent instanceof KeyboardEvent) && aEvent.altKey) ^ newTabPref)
+ where = "tab";
+ if ((aEvent instanceof MouseEvent) &&
+ (aEvent.button == 1 || aEvent.getModifierState("Accel"))) {
+ where = "tab";
+ params = {
+ inBackground: true,
+ };
+ }
+ }
+
+ this.handleSearchCommandWhere(aEvent, aEngine, where, params);
+ ]]></body>
+ </method>
+
+ <method name="handleSearchCommandWhere">
+ <parameter name="aEvent"/>
+ <parameter name="aEngine"/>
+ <parameter name="aWhere"/>
+ <parameter name="aParams"/>
+ <body><![CDATA[
+ var textBox = this._textbox;
+ var textValue = textBox.value;
+
+ let selection = this.telemetrySearchDetails;
+ let oneOffRecorded = false;
+
+ if (!selection || (selection.index == -1)) {
+ oneOffRecorded = this.textbox.popup.oneOffButtons
+ .maybeRecordTelemetry(aEvent, aWhere, aParams);
+ if (!oneOffRecorded) {
+ let source = "unknown";
+ let type = "unknown";
+ let target = aEvent.originalTarget;
+ if (aEvent instanceof KeyboardEvent) {
+ type = "key";
+ } else if (aEvent instanceof MouseEvent) {
+ type = "mouse";
+ if (target.classList.contains("search-panel-header") ||
+ target.parentNode.classList.contains("search-panel-header")) {
+ source = "header";
+ }
+ } else if (aEvent instanceof XULCommandEvent) {
+ if (target.getAttribute("anonid") == "paste-and-search") {
+ source = "paste";
+ }
+ }
+ if (!aEngine) {
+ aEngine = this.currentEngine;
+ }
+ BrowserSearch.recordOneoffSearchInTelemetry(aEngine, source, type,
+ aWhere);
+ }
+ }
+
+ // This is a one-off search only if oneOffRecorded is true.
+ this.doSearch(textValue, aWhere, aEngine, aParams, oneOffRecorded);
+
+ if (aWhere == "tab" && aParams && aParams.inBackground)
+ this.focus();
+ ]]></body>
+ </method>
+
+ <method name="doSearch">
+ <parameter name="aData"/>
+ <parameter name="aWhere"/>
+ <parameter name="aEngine"/>
+ <parameter name="aParams"/>
+ <parameter name="aOneOff"/>
+ <body><![CDATA[
+ var textBox = this._textbox;
+
+ // Save the current value in the form history
+ if (aData && !PrivateBrowsingUtils.isWindowPrivate(window) && this.FormHistory.enabled) {
+ this.FormHistory.update(
+ { op : "bump",
+ fieldname : textBox.getAttribute("autocompletesearchparam"),
+ value : aData },
+ { handleError(aError) {
+ Components.utils.reportError("Saving search to form history failed: " + aError.message);
+ }});
+ }
+
+ let engine = aEngine || this.currentEngine;
+ var submission = engine.getSubmission(aData, null, "searchbar");
+ let telemetrySearchDetails = this.telemetrySearchDetails;
+ this.telemetrySearchDetails = null;
+ if (telemetrySearchDetails && telemetrySearchDetails.index == -1) {
+ telemetrySearchDetails = null;
+ }
+ // If we hit here, we come either from a one-off, a plain search or a suggestion.
+ const details = {
+ isOneOff: aOneOff,
+ isSuggestion: (!aOneOff && telemetrySearchDetails),
+ selection: telemetrySearchDetails
+ };
+ BrowserSearch.recordSearchInTelemetry(engine, "searchbar", details);
+ // null parameter below specifies HTML response for search
+ let params = {
+ postData: submission.postData,
+ };
+ if (aParams) {
+ for (let key in aParams) {
+ params[key] = aParams[key];
+ }
+ }
+ openUILinkIn(submission.uri.spec, aWhere, params);
+ ]]></body>
+ </method>
+ </implementation>
+
+ <handlers>
+ <handler event="command"><![CDATA[
+ const target = event.originalTarget;
+ if (target.engine) {
+ this.currentEngine = target.engine;
+ } else if (target.classList.contains("addengine-item")) {
+ // Select the installed engine if the installation succeeds
+ var installCallback = {
+ onSuccess: engine => this.currentEngine = engine
+ }
+ Services.search.addEngine(target.getAttribute("uri"), null,
+ target.getAttribute("src"), false,
+ installCallback);
+ } else
+ return;
+
+ this.focus();
+ this.select();
+ ]]></handler>
+
+ <handler event="DOMMouseScroll"
+ phase="capturing"
+ modifiers="accel"
+ action="this.selectEngine(event, (event.detail > 0));"/>
+
+ <handler event="input" action="this.updateGoButtonVisibility();"/>
+ <handler event="drop" action="this.updateGoButtonVisibility();"/>
+
+ <handler event="blur">
+ <![CDATA[
+ // If the input field is still focused then a different window has
+ // received focus, ignore the next focus event.
+ this._ignoreFocus = (document.activeElement == this._textbox.inputField);
+ ]]></handler>
+
+ <handler event="focus">
+ <![CDATA[
+ // Speculatively connect to the current engine's search URI (and
+ // suggest URI, if different) to reduce request latency
+ this.currentEngine.speculativeConnect({window});
+
+ if (this._ignoreFocus) {
+ // This window has been re-focused, don't show the suggestions
+ this._ignoreFocus = false;
+ return;
+ }
+
+ // Don't open the suggestions if there is no text in the textbox.
+ if (!this._textbox.value)
+ return;
+
+ // Don't open the suggestions if the mouse was used to focus the
+ // textbox, that will be taken care of in the click handler.
+ if (Services.focus.getLastFocusMethod(window) & Services.focus.FLAG_BYMOUSE)
+ return;
+
+ this.openSuggestionsPanel();
+ ]]></handler>
+
+ <handler event="mousedown" phase="capturing">
+ <![CDATA[
+ if (event.originalTarget.getAttribute("anonid") == "searchbar-search-button") {
+ this._clickClosedPopup = this._textbox.popup._isHiding;
+ }
+ ]]></handler>
+
+ <handler event="click" button="0">
+ <![CDATA[
+ // Ignore clicks on the search go button.
+ if (event.originalTarget.getAttribute("anonid") == "search-go-button") {
+ return;
+ }
+
+ let isIconClick = event.originalTarget.getAttribute("anonid") == "searchbar-search-button";
+
+ // Ignore clicks on the icon if they were made to close the popup
+ if (isIconClick && this._clickClosedPopup) {
+ return;
+ }
+
+ // Open the suggestions whenever clicking on the search icon or if there
+ // is text in the textbox.
+ if (isIconClick || this._textbox.value) {
+ this.openSuggestionsPanel(true);
+ }
+ ]]></handler>
+
+ </handlers>
+ </binding>
+
+ <binding id="searchbar-textbox"
+ extends="chrome://global/content/bindings/autocomplete.xml#autocomplete">
+ <implementation implements="nsIObserver">
+ <constructor><![CDATA[
+ const kXULNS =
+ "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+ if (document.getBindingParent(this).parentNode.parentNode.localName ==
+ "toolbarpaletteitem")
+ return;
+
+ // Initialize fields
+ this._stringBundle = document.getBindingParent(this)._stringBundle;
+ this._suggestEnabled =
+ Services.prefs.getBoolPref("browser.search.suggest.enabled");
+
+ if (Services.prefs.getBoolPref("browser.urlbar.clickSelectsAll"))
+ this.setAttribute("clickSelectsAll", true);
+
+ // Add items to context menu and attach controller to handle them
+ var textBox = document.getAnonymousElementByAttribute(this,
+ "anonid", "textbox-input-box");
+ var cxmenu = document.getAnonymousElementByAttribute(textBox,
+ "anonid", "input-box-contextmenu");
+ var pasteAndSearch;
+ cxmenu.addEventListener("popupshowing", function() {
+ BrowserSearch.searchBar._textbox.closePopup();
+ if (!pasteAndSearch)
+ return;
+ var controller = document.commandDispatcher.getControllerForCommand("cmd_paste");
+ var enabled = controller.isCommandEnabled("cmd_paste");
+ if (enabled)
+ pasteAndSearch.removeAttribute("disabled");
+ else
+ pasteAndSearch.setAttribute("disabled", "true");
+ });
+
+ var element, label, akey;
+
+ element = document.createElementNS(kXULNS, "menuseparator");
+ cxmenu.appendChild(element);
+
+ this.setAttribute("aria-owns", this.popup.id);
+
+ var insertLocation = cxmenu.firstChild;
+ while (insertLocation.nextSibling &&
+ insertLocation.getAttribute("cmd") != "cmd_paste")
+ insertLocation = insertLocation.nextSibling;
+ if (insertLocation) {
+ element = document.createElementNS(kXULNS, "menuitem");
+ label = this._stringBundle.getString("cmd_pasteAndSearch");
+ element.setAttribute("label", label);
+ element.setAttribute("anonid", "paste-and-search");
+ element.setAttribute("oncommand", "BrowserSearch.pasteAndSearch(event)");
+ cxmenu.insertBefore(element, insertLocation.nextSibling);
+ pasteAndSearch = element;
+ }
+
+ element = document.createElementNS(kXULNS, "menuitem");
+ label = this._stringBundle.getString("cmd_clearHistory");
+ akey = this._stringBundle.getString("cmd_clearHistory_accesskey");
+ element.setAttribute("label", label);
+ element.setAttribute("accesskey", akey);
+ element.setAttribute("cmd", "cmd_clearhistory");
+ cxmenu.appendChild(element);
+
+ element = document.createElementNS(kXULNS, "menuitem");
+ label = this._stringBundle.getString("cmd_showSuggestions");
+ akey = this._stringBundle.getString("cmd_showSuggestions_accesskey");
+ element.setAttribute("anonid", "toggle-suggest-item");
+ element.setAttribute("label", label);
+ element.setAttribute("accesskey", akey);
+ element.setAttribute("cmd", "cmd_togglesuggest");
+ element.setAttribute("type", "checkbox");
+ element.setAttribute("checked", this._suggestEnabled);
+ element.setAttribute("autocheck", "false");
+ this._suggestMenuItem = element;
+ cxmenu.appendChild(element);
+
+ this.addEventListener("keypress", aEvent => {
+ if (navigator.platform.startsWith("Mac") && aEvent.keyCode == KeyEvent.VK_F4)
+ this.openSearch()
+ }, true);
+
+ this.controllers.appendController(this.searchbarController);
+ document.getBindingParent(this)._textboxInitialized = true;
+
+ // Add observer for suggest preference
+ Services.prefs.addObserver("browser.search.suggest.enabled", this, false);
+ ]]></constructor>
+
+ <destructor><![CDATA[
+ Services.prefs.removeObserver("browser.search.suggest.enabled", this);
+
+ // Because XBL and the customize toolbar code interacts poorly,
+ // there may not be anything to remove here
+ try {
+ this.controllers.removeController(this.searchbarController);
+ } catch (ex) { }
+ ]]></destructor>
+
+ <field name="_stringBundle"/>
+ <field name="_suggestMenuItem"/>
+ <field name="_suggestEnabled"/>
+
+ <!--
+ This overrides the searchParam property in autocomplete.xml. We're
+ hijacking this property as a vehicle for delivering the privacy
+ information about the window into the guts of nsSearchSuggestions.
+
+ Note that the setter is the same as the parent. We were not sure whether
+ we can override just the getter. If that proves to be the case, the setter
+ can be removed.
+ -->
+ <property name="searchParam"
+ onget="return this.getAttribute('autocompletesearchparam') +
+ (PrivateBrowsingUtils.isWindowPrivate(window) ? '|private' : '');"
+ onset="this.setAttribute('autocompletesearchparam', val); return val;"/>
+
+ <!-- This is implemented so that when textbox.value is set directly (e.g.,
+ by tests), the one-off query is updated. -->
+ <method name="onBeforeValueSet">
+ <parameter name="aValue"/>
+ <body><![CDATA[
+ this.popup.oneOffButtons.query = aValue;
+ return aValue;
+ ]]></body>
+ </method>
+
+ <!--
+ This method overrides the autocomplete binding's openPopup (essentially
+ duplicating the logic from the autocomplete popup binding's
+ openAutocompletePopup method), modifying it so that the popup is aligned with
+ the inner textbox, but sized to not extend beyond the search bar border.
+ -->
+ <method name="openPopup">
+ <body><![CDATA[
+ var popup = this.popup;
+ if (!popup.mPopupOpen) {
+ // Initially the panel used for the searchbar (PopupSearchAutoComplete
+ // in browser.xul) is hidden to avoid impacting startup / new
+ // window performance. The base binding's openPopup would normally
+ // call the overriden openAutocompletePopup in
+ // browser-search-autocomplete-result-popup binding to unhide the popup,
+ // but since we're overriding openPopup we need to unhide the panel
+ // ourselves.
+ popup.hidden = false;
+
+ // Don't roll up on mouse click in the anchor for the search UI.
+ if (popup.id == "PopupSearchAutoComplete") {
+ popup.setAttribute("norolluponanchor", "true");
+ }
+
+ popup.mInput = this;
+ popup.view = this.controller.QueryInterface(Ci.nsITreeView);
+ popup.invalidate();
+
+ popup.showCommentColumn = this.showCommentColumn;
+ popup.showImageColumn = this.showImageColumn;
+
+ document.popupNode = null;
+
+ const isRTL = getComputedStyle(this, "").direction == "rtl";
+
+ var outerRect = this.getBoundingClientRect();
+ var innerRect = this.inputField.getBoundingClientRect();
+ let width = isRTL ?
+ innerRect.right - outerRect.left :
+ outerRect.right - innerRect.left;
+ popup.setAttribute("width", width > 100 ? width : 100);
+
+ var yOffset = outerRect.bottom - innerRect.bottom;
+ popup.openPopup(this.inputField, "after_start", 0, yOffset, false, false);
+ }
+ ]]></body>
+ </method>
+
+ <method name="observe">
+ <parameter name="aSubject"/>
+ <parameter name="aTopic"/>
+ <parameter name="aData"/>
+ <body><![CDATA[
+ if (aTopic == "nsPref:changed") {
+ this._suggestEnabled =
+ Services.prefs.getBoolPref("browser.search.suggest.enabled");
+ this._suggestMenuItem.setAttribute("checked", this._suggestEnabled);
+ }
+ ]]></body>
+ </method>
+
+ <method name="openSearch">
+ <body>
+ <![CDATA[
+ if (!this.popupOpen) {
+ document.getBindingParent(this).openSuggestionsPanel();
+ return false;
+ }
+ return true;
+ ]]>
+ </body>
+ </method>
+
+ <method name="handleEnter">
+ <parameter name="event"/>
+ <body><![CDATA[
+ // Toggle the open state of the add-engine menu button if it's
+ // selected. We're using handleEnter for this instead of listening
+ // for the command event because a command event isn't fired.
+ if (this.selectedButton &&
+ this.selectedButton.getAttribute("anonid") ==
+ "addengine-menu-button") {
+ this.selectedButton.open = !this.selectedButton.open;
+ return true;
+ }
+ // Otherwise, "call super": do what the autocomplete binding's
+ // handleEnter implementation does.
+ return this.mController.handleEnter(false, event || null);
+ ]]></body>
+ </method>
+
+ <!-- override |onTextEntered| in autocomplete.xml -->
+ <method name="onTextEntered">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ let engine;
+ let oneOff = this.selectedButton;
+ if (oneOff) {
+ if (!oneOff.engine) {
+ oneOff.doCommand();
+ return;
+ }
+ engine = oneOff.engine;
+ }
+ if (this._selectionDetails &&
+ this._selectionDetails.currentIndex != -1) {
+ BrowserSearch.searchBar.telemetrySearchDetails = this._selectionDetails;
+ this._selectionDetails = null;
+ }
+ document.getBindingParent(this).handleSearchCommand(aEvent, engine);
+ ]]></body>
+ </method>
+
+ <property name="selectedButton">
+ <getter><![CDATA[
+ return this.popup.oneOffButtons.selectedButton;
+ ]]></getter>
+ <setter><![CDATA[
+ return this.popup.oneOffButtons.selectedButton = val;
+ ]]></setter>
+ </property>
+
+ <method name="handleKeyboardNavigation">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ let popup = this.popup;
+ if (!popup.popupOpen)
+ return;
+
+ // accel + up/down changes the default engine and shouldn't affect
+ // the selection on the one-off buttons.
+ if (aEvent.getModifierState("Accel"))
+ return;
+
+ let suggestions =
+ document.getAnonymousElementByAttribute(popup, "anonid", "tree");
+ let suggestionsHidden =
+ suggestions.getAttribute("collapsed") == "true";
+ let numItems = suggestionsHidden ? 0 : this.popup.view.rowCount;
+ this.popup.oneOffButtons.handleKeyPress(aEvent, numItems, true);
+ ]]></body>
+ </method>
+
+ <!-- nsIController -->
+ <field name="searchbarController" readonly="true"><![CDATA[({
+ _self: this,
+ supportsCommand(aCommand) {
+ return aCommand == "cmd_clearhistory" ||
+ aCommand == "cmd_togglesuggest";
+ },
+
+ isCommandEnabled(aCommand) {
+ return true;
+ },
+
+ doCommand(aCommand) {
+ switch (aCommand) {
+ case "cmd_clearhistory":
+ var param = this._self.getAttribute("autocompletesearchparam");
+
+ BrowserSearch.searchBar.FormHistory.update({ op : "remove", fieldname : param }, null);
+ this._self.value = "";
+ break;
+ case "cmd_togglesuggest":
+ // The pref observer will update _suggestEnabled and the menu
+ // checkmark.
+ Services.prefs.setBoolPref("browser.search.suggest.enabled",
+ !this._self._suggestEnabled);
+ break;
+ default:
+ // do nothing with unrecognized command
+ }
+ }
+ })]]></field>
+ </implementation>
+
+ <handlers>
+ <handler event="input"><![CDATA[
+ this.popup.removeAttribute("showonlysettings");
+ ]]></handler>
+
+ <handler event="keypress" phase="capturing"
+ action="return this.handleKeyboardNavigation(event);"/>
+
+ <handler event="keypress" keycode="VK_UP" modifiers="accel"
+ phase="capturing"
+ action="document.getBindingParent(this).selectEngine(event, false);"/>
+
+ <handler event="keypress" keycode="VK_DOWN" modifiers="accel"
+ phase="capturing"
+ action="document.getBindingParent(this).selectEngine(event, true);"/>
+
+ <handler event="keypress" keycode="VK_DOWN" modifiers="alt"
+ phase="capturing"
+ action="return this.openSearch();"/>
+
+ <handler event="keypress" keycode="VK_UP" modifiers="alt"
+ phase="capturing"
+ action="return this.openSearch();"/>
+
+ <handler event="dragover">
+ <![CDATA[
+ var types = event.dataTransfer.types;
+ if (types.includes("text/plain") || types.includes("text/x-moz-text-internal"))
+ event.preventDefault();
+ ]]>
+ </handler>
+
+ <handler event="drop">
+ <![CDATA[
+ var dataTransfer = event.dataTransfer;
+ var data = dataTransfer.getData("text/plain");
+ if (!data)
+ data = dataTransfer.getData("text/x-moz-text-internal");
+ if (data) {
+ event.preventDefault();
+ this.value = data;
+ document.getBindingParent(this).openSuggestionsPanel();
+ }
+ ]]>
+ </handler>
+
+ </handlers>
+ </binding>
+
+ <binding id="browser-search-autocomplete-result-popup" extends="chrome://global/content/bindings/autocomplete.xml#autocomplete-result-popup">
+ <resources>
+ <stylesheet src="chrome://browser/content/search/searchbarBindings.css"/>
+ <stylesheet src="chrome://browser/skin/searchbar.css"/>
+ </resources>
+ <content ignorekeys="true" level="top" consumeoutsideclicks="never">
+ <xul:hbox anonid="searchbar-engine" xbl:inherits="showonlysettings"
+ class="search-panel-header search-panel-current-engine">
+ <xul:image class="searchbar-engine-image" xbl:inherits="src"/>
+ <xul:label anonid="searchbar-engine-name" flex="1" crop="end"
+ role="presentation"/>
+ </xul:hbox>
+ <xul:tree anonid="tree" flex="1"
+ class="autocomplete-tree plain search-panel-tree"
+ hidecolumnpicker="true" seltype="single">
+ <xul:treecols anonid="treecols">
+ <xul:treecol id="treecolAutoCompleteValue" class="autocomplete-treecol" flex="1" overflow="true"/>
+ </xul:treecols>
+ <xul:treechildren class="autocomplete-treebody"/>
+ </xul:tree>
+ <xul:vbox anonid="search-one-off-buttons" class="search-one-offs"/>
+ </content>
+ <implementation>
+
+ <method name="openAutocompletePopup">
+ <parameter name="aInput"/>
+ <parameter name="aElement"/>
+ <body><![CDATA[
+ // initially the panel is hidden
+ // to avoid impacting startup / new window performance
+ aInput.popup.hidden = false;
+
+ // this method is defined on the base binding
+ this._openAutocompletePopup(aInput, aElement);
+ ]]></body>
+ </method>
+
+ <method name="onPopupClick">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ // Ignore all right-clicks
+ if (aEvent.button == 2)
+ return;
+
+ var controller = this.view.QueryInterface(Components.interfaces.nsIAutoCompleteController);
+
+ var searchBar = BrowserSearch.searchBar;
+ var popupForSearchBar = searchBar && searchBar.textbox == this.mInput;
+ if (popupForSearchBar) {
+ searchBar.telemetrySearchDetails = {
+ index: controller.selection.currentIndex,
+ kind: "mouse"
+ };
+ }
+
+ // Check for unmodified left-click, and use default behavior
+ if (aEvent.button == 0 && !aEvent.shiftKey && !aEvent.ctrlKey &&
+ !aEvent.altKey && !aEvent.metaKey) {
+ controller.handleEnter(true, aEvent);
+ return;
+ }
+
+ // Check for middle-click or modified clicks on the search bar
+ if (popupForSearchBar) {
+ // Handle search bar popup clicks
+ var search = controller.getValueAt(this.selectedIndex);
+
+ // open the search results according to the clicking subtlety
+ var where = whereToOpenLink(aEvent, false, true);
+ let params = {};
+
+ // But open ctrl/cmd clicks on autocomplete items in a new background tab.
+#ifdef XP_MACOSX
+ let modifier = aEvent.metaKey;
+#else
+ let modifier = aEvent.ctrlKey;
+#endif
+ if (where == "tab" && (aEvent instanceof MouseEvent) &&
+ (aEvent.button == 1 || modifier))
+ params.inBackground = true;
+
+ // leave the popup open for background tab loads
+ if (!(where == "tab" && params.inBackground)) {
+ // close the autocomplete popup and revert the entered search term
+ this.closePopup();
+ controller.handleEscape();
+ }
+
+ searchBar.doSearch(search, where, null, params);
+ if (where == "tab" && params.inBackground)
+ searchBar.focus();
+ else
+ searchBar.value = search;
+ }
+ ]]></body>
+ </method>
+
+ <!-- Popup rollup is triggered by native events before the mousedown event
+ reaches the DOM. The will be set to true by the popuphiding event and
+ false after the mousedown event has been triggered to detect what
+ caused rollup. -->
+ <field name="_isHiding">false</field>
+ <field name="_bundle">null</field>
+ <property name="bundle" readonly="true">
+ <getter>
+ <![CDATA[
+ if (!this._bundle) {
+ const kBundleURI = "chrome://browser/locale/search.properties";
+ this._bundle = Services.strings.createBundle(kBundleURI);
+ }
+ return this._bundle;
+ ]]>
+ </getter>
+ </property>
+
+ <field name="oneOffButtons" readonly="true">
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "search-one-off-buttons");
+ </field>
+
+ <method name="updateHeader">
+ <body><![CDATA[
+ let currentEngine = Services.search.currentEngine;
+ let uri = currentEngine.iconURI;
+ if (uri) {
+ this.setAttribute("src", uri.spec);
+ } else {
+ // If the default has just been changed to a provider without icon,
+ // avoid showing the icon of the previous default provider.
+ this.removeAttribute("src");
+ }
+
+ let headerText = this.bundle.formatStringFromName("searchHeader",
+ [currentEngine.name], 1);
+ document.getAnonymousElementByAttribute(this, "anonid", "searchbar-engine-name")
+ .setAttribute("value", headerText);
+ document.getAnonymousElementByAttribute(this, "anonid", "searchbar-engine")
+ .engine = currentEngine;
+ ]]></body>
+ </method>
+
+ <!-- This is called when a one-off is clicked and when "search in new tab"
+ is selected from a one-off context menu. -->
+ <method name="handleOneOffSearch">
+ <parameter name="event"/>
+ <parameter name="engine"/>
+ <parameter name="where"/>
+ <parameter name="params"/>
+ <body><![CDATA[
+ let searchbar = document.getElementById("searchbar");
+ searchbar.handleSearchCommandWhere(event, engine, where, params);
+ ]]></body>
+ </method>
+ </implementation>
+
+ <handlers>
+ <handler event="popupshowing"><![CDATA[
+ if (!this.oneOffButtons.popup) {
+ // The panel width only spans to the textbox size, but we also want it
+ // to include the magnifier icon's width.
+ let ltr = getComputedStyle(this).direction == "ltr";
+ let magnifierWidth = parseInt(getComputedStyle(this)[
+ ltr ? "marginLeft" : "marginRight"
+ ]) * -1;
+ // Ensure the panel is wide enough to fit at least 3 engines.
+ let minWidth = Math.max(
+ parseInt(this.width) + magnifierWidth,
+ this.oneOffButtons.buttonWidth * 3
+ );
+ this.style.minWidth = minWidth + "px";
+
+ // Set the origin before assigning the popup, as the assignment does
+ // a rebuild and would miss the origin.
+ this.oneOffButtons.telemetryOrigin = "searchbar";
+ // Set popup after setting the minWidth since it builds the buttons.
+ this.oneOffButtons.popup = this;
+ this.oneOffButtons.textbox = this.input;
+ }
+
+ // First handle deciding if we are showing the reduced version of the
+ // popup containing only the preferences button. We do this if the
+ // glass icon has been clicked if the text field is empty.
+ let searchbar = document.getElementById("searchbar");
+ let tree = document.getAnonymousElementByAttribute(this, "anonid",
+ "tree")
+ if (searchbar.hasAttribute("showonlysettings")) {
+ searchbar.removeAttribute("showonlysettings");
+ this.setAttribute("showonlysettings", "true");
+
+ // Setting this with an xbl-inherited attribute gets overridden the
+ // second time the user clicks the glass icon for some reason...
+ tree.collapsed = true;
+ } else {
+ this.removeAttribute("showonlysettings");
+ // Uncollapse as long as we have a tree with a view which has >= 1 row.
+ // The autocomplete binding itself will take care of uncollapsing later,
+ // if we currently have no rows but end up having some in the future
+ // when the search string changes
+ tree.collapsed = !tree.view || !tree.view.rowCount;
+ }
+
+ // Show the current default engine in the top header of the panel.
+ this.updateHeader();
+ ]]></handler>
+
+ <handler event="popuphiding"><![CDATA[
+ this._isHiding = true;
+ setTimeout(() => {
+ this._isHiding = false;
+ }, 0);
+ ]]></handler>
+
+ <!-- This handles clicks on the topmost "Foo Search" header in the
+ popup (hbox[anonid="searchbar-engine"]). -->
+ <handler event="click"><![CDATA[
+ if (event.button == 2) {
+ // Ignore right clicks.
+ return;
+ }
+ let button = event.originalTarget;
+ let engine = button.parentNode.engine;
+ if (!engine) {
+ return;
+ }
+ this.oneOffButtons.handleSearchCommand(event, engine);
+ ]]></handler>
+ </handlers>
+
+ </binding>
+
+ <!-- Used for additional open search providers in the search panel. -->
+ <binding id="addengine-icon" extends="xul:box">
+ <content>
+ <xul:image class="addengine-icon" xbl:inherits="src"/>
+ <xul:image class="addengine-badge"/>
+ </content>
+ </binding>
+
+ <binding id="search-one-offs">
+ <content context="_child">
+ <xul:deck anonid="search-panel-one-offs-header"
+ selectedIndex="0"
+ class="search-panel-header search-panel-current-input">
+ <xul:label anonid="searchbar-oneoffheader-search"
+ value="&searchWithHeader.label;"/>
+ <xul:hbox anonid="search-panel-searchforwith"
+ class="search-panel-current-input">
+ <xul:label anonid="searchbar-oneoffheader-before"
+ value="&searchFor.label;"/>
+ <xul:label anonid="searchbar-oneoffheader-searchtext"
+ class="search-panel-input-value"
+ flex="1"
+ crop="end"/>
+ <xul:label anonid="searchbar-oneoffheader-after"
+ flex="10000"
+ value="&searchWith.label;"/>
+ </xul:hbox>
+ <xul:hbox anonid="search-panel-searchonengine"
+ class="search-panel-current-input">
+ <xul:label anonid="searchbar-oneoffheader-beforeengine"
+ value="&search.label;"/>
+ <xul:label anonid="searchbar-oneoffheader-engine"
+ class="search-panel-input-value"
+ flex="1"
+ crop="end"/>
+ <xul:label anonid="searchbar-oneoffheader-afterengine"
+ flex="10000"
+ value="&searchAfter.label;"/>
+ </xul:hbox>
+ </xul:deck>
+ <xul:description anonid="search-panel-one-offs"
+ role="group"
+ class="search-panel-one-offs"
+ xbl:inherits="compact">
+ <xul:button anonid="search-settings-compact"
+ oncommand="showSettings();"
+ class="searchbar-engine-one-off-item search-setting-button-compact"
+ tooltiptext="&changeSearchSettings.tooltip;"
+ xbl:inherits="compact"/>
+ </xul:description>
+ <xul:vbox anonid="add-engines"/>
+ <xul:button anonid="search-settings"
+ oncommand="showSettings();"
+ class="search-setting-button search-panel-header"
+ label="&changeSearchSettings.button;"
+ xbl:inherits="compact"/>
+ <xul:menupopup anonid="search-one-offs-context-menu">
+ <xul:menuitem anonid="search-one-offs-context-open-in-new-tab"
+ label="&searchInNewTab.label;"
+ accesskey="&searchInNewTab.accesskey;"/>
+ <xul:menuitem anonid="search-one-offs-context-set-default"
+ label="&searchSetAsDefault.label;"
+ accesskey="&searchSetAsDefault.accesskey;"/>
+ </xul:menupopup>
+ </content>
+
+ <implementation implements="nsIDOMEventListener">
+
+ <!-- Width in pixels of the one-off buttons. 49px is the min-width of
+ each search engine button, adapt this const when changing the css.
+ It's actually 48px + 1px of right border. -->
+ <property name="buttonWidth" readonly="true" onget="return 49;"/>
+
+ <field name="_popup">null</field>
+
+ <!-- The popup that contains the one-offs. This is required, so it should
+ never be null or undefined, except possibly before the one-offs are
+ used. -->
+ <property name="popup">
+ <getter><![CDATA[
+ return this._popup;
+ ]]></getter>
+ <setter><![CDATA[
+ if (this._popup == val) {
+ return val;
+ }
+
+ let events = [
+ "popupshowing",
+ "popuphidden",
+ ];
+ if (this._popup) {
+ for (let event of events) {
+ this._popup.removeEventListener(event, this);
+ }
+ }
+ if (val) {
+ for (let event of events) {
+ val.addEventListener(event, this);
+ }
+ }
+ this._popup = val;
+
+ // If the popup is already open, rebuild the one-offs now. The
+ // popup may be opening, so check that the state is not closed
+ // instead of checking popupOpen.
+ if (val && val.state != "closed") {
+ this._rebuild();
+ }
+ return val;
+ ]]></setter>
+ </property>
+
+ <field name="_textbox">null</field>
+
+ <!-- The textbox associated with the one-offs. Set this to a textbox to
+ automatically keep the related one-offs UI up to date. Otherwise you
+ can leave it null/undefined, and in that case you should update the
+ query property manually. -->
+ <property name="textbox">
+ <getter><![CDATA[
+ return this._textbox;
+ ]]></getter>
+ <setter><![CDATA[
+ if (this._textbox == val) {
+ return val;
+ }
+ if (this._textbox) {
+ this._textbox.removeEventListener("input", this);
+ }
+ if (val) {
+ val.addEventListener("input", this);
+ }
+ return this._textbox = val;
+ ]]></setter>
+ </property>
+
+ <!-- Set this to a string that identifies your one-offs consumer. It'll
+ be appended to telemetry recorded with maybeRecordTelemetry(). -->
+ <field name="telemetryOrigin">""</field>
+
+ <field name="_query">""</field>
+
+ <!-- The query string currently shown in the one-offs. If the textbox
+ property is non-null, then this is automatically updated on
+ input. -->
+ <property name="query">
+ <getter><![CDATA[
+ return this._query;
+ ]]></getter>
+ <setter><![CDATA[
+ this._query = val;
+ if (this.popup && this.popup.popupOpen) {
+ this._updateAfterQueryChanged();
+ }
+ return val;
+ ]]></setter>
+ </property>
+
+ <field name="_selectedButton">null</field>
+
+ <!-- The selected one-off, a xul:button, including the add-engine button
+ and the search-settings button. Null if no one-off is selected. -->
+ <property name="selectedButton">
+ <getter><![CDATA[
+ return this._selectedButton;
+ ]]></getter>
+ <setter><![CDATA[
+ this._changeVisuallySelectedButton(val, true);
+ return val;
+ ]]></setter>
+ </property>
+
+ <!-- The index of the selected one-off, including the add-engine button
+ and the search-settings button. -1 if no one-off is selected. -->
+ <property name="selectedButtonIndex">
+ <getter><![CDATA[
+ let buttons = this.getSelectableButtons(true);
+ for (let i = 0; i < buttons.length; i++) {
+ if (buttons[i] == this._selectedButton) {
+ return i;
+ }
+ }
+ return -1;
+ ]]></getter>
+ <setter><![CDATA[
+ let buttons = this.getSelectableButtons(true);
+ this.selectedButton = buttons[val];
+ return val;
+ ]]></setter>
+ </property>
+
+ <!-- The visually selected one-off is the same as the selected one-off
+ unless a one-off is moused over. In that case, the visually selected
+ one-off is the moused-over one-off, which may be different from the
+ selected one-off. The visually selected one-off is always the one
+ that is visually highlighted. Includes the add-engine button and the
+ search-settings button. A xul:button. -->
+ <property name="visuallySelectedButton" readonly="true">
+ <getter><![CDATA[
+ return this.getSelectableButtons(true).find(button => {
+ return button.getAttribute("selected") == "true";
+ });
+ ]]></getter>
+ </property>
+
+ <property name="compact" readonly="true">
+ <getter><![CDATA[
+ return this.getAttribute("compact") == "true";
+ ]]></getter>
+ </property>
+
+ <property name="settingsButton" readonly="true">
+ <getter><![CDATA[
+ let id = this.compact ? "search-settings-compact" : "search-settings";
+ return document.getAnonymousElementByAttribute(this, "anonid", id);
+ ]]></getter>
+ </property>
+
+ <field name="_bundle">null</field>
+
+ <property name="bundle" readonly="true">
+ <getter><![CDATA[
+ if (!this._bundle) {
+ const kBundleURI = "chrome://browser/locale/search.properties";
+ this._bundle = Services.strings.createBundle(kBundleURI);
+ }
+ return this._bundle;
+ ]]></getter>
+ </property>
+
+ <!-- When a context menu is opened on a one-off button, this is set to the
+ engine of that button for use with the context menu actions. -->
+ <field name="_contextEngine">null</field>
+
+ <constructor><![CDATA[
+ // Prevent popup events from the context menu from reaching the autocomplete
+ // binding (or other listeners).
+ let menu = document.getAnonymousElementByAttribute(this, "anonid", "search-one-offs-context-menu");
+ let listener = aEvent => aEvent.stopPropagation();
+ menu.addEventListener("popupshowing", listener);
+ menu.addEventListener("popuphiding", listener);
+ menu.addEventListener("popupshown", aEvent => {
+ this._ignoreMouseEvents = true;
+ aEvent.stopPropagation();
+ });
+ menu.addEventListener("popuphidden", aEvent => {
+ this._ignoreMouseEvents = false;
+ aEvent.stopPropagation();
+ });
+ ]]></constructor>
+
+ <!-- This handles events outside the one-off buttons, like on the popup
+ and textbox. -->
+ <method name="handleEvent">
+ <parameter name="event"/>
+ <body><![CDATA[
+ switch (event.type) {
+ case "input":
+ // Allow the consumer's input to override its value property with
+ // a oneOffSearchQuery property. That way if the value is not
+ // actually what the user typed (e.g., it's autofilled, or it's a
+ // mozaction URI), the consumer has some way of providing it.
+ this.query = event.target.oneOffSearchQuery || event.target.value;
+ break;
+ case "popupshowing":
+ this._rebuild();
+ break;
+ case "popuphidden":
+ Services.tm.mainThread.dispatch(() => {
+ this.selectedButton = null;
+ this._contextEngine = null;
+ }, Ci.nsIThread.DISPATCH_NORMAL);
+ break;
+ }
+ ]]></body>
+ </method>
+
+ <method name="showSettings">
+ <body><![CDATA[
+ BrowserUITelemetry.countSearchSettingsEvent(this.telemetryOrigin);
+ openPreferences("paneSearch");
+ // If the preference tab was already selected, the panel doesn't
+ // close itself automatically.
+ this.popup.hidePopup();
+ ]]></body>
+ </method>
+
+ <!-- Updates the parts of the UI that show the query string. -->
+ <method name="_updateAfterQueryChanged">
+ <body><![CDATA[
+ let headerSearchText =
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "searchbar-oneoffheader-searchtext");
+ let headerPanel =
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "search-panel-one-offs-header");
+ let list = document.getAnonymousElementByAttribute(this, "anonid",
+ "search-panel-one-offs");
+ headerSearchText.setAttribute("value", this.query);
+ let groupText;
+ let isOneOffSelected =
+ this.selectedButton &&
+ this.selectedButton.classList.contains("searchbar-engine-one-off-item");
+ // Typing de-selects the settings or opensearch buttons at the bottom
+ // of the search panel, as typing shows the user intends to search.
+ if (this.selectedButton && !isOneOffSelected)
+ this.selectedButton = null;
+ if (this.query) {
+ groupText = headerSearchText.previousSibling.value +
+ '"' + headerSearchText.value + '"' +
+ headerSearchText.nextSibling.value;
+ if (!isOneOffSelected)
+ headerPanel.selectedIndex = 1;
+ } else {
+ let noSearchHeader =
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "searchbar-oneoffheader-search");
+ groupText = noSearchHeader.value;
+ if (!isOneOffSelected)
+ headerPanel.selectedIndex = 0;
+ }
+ list.setAttribute("aria-label", groupText);
+ ]]></body>
+ </method>
+
+ <!-- Builds all the UI. -->
+ <method name="_rebuild">
+ <body><![CDATA[
+ // Update the 'Search for <keywords> with:" header.
+ this._updateAfterQueryChanged();
+
+ let list = document.getAnonymousElementByAttribute(this, "anonid",
+ "search-panel-one-offs");
+
+ // Handle opensearch items. This needs to be done before building the
+ // list of one off providers, as that code will return early if all the
+ // alternative engines are hidden.
+ this._rebuildAddEngineList();
+
+ let settingsButton =
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "search-settings-compact");
+ // Finally, build the list of one-off buttons.
+ while (list.firstChild != settingsButton)
+ list.firstChild.remove();
+ // Remove the trailing empty text node introduced by the binding's
+ // content markup above.
+ if (settingsButton.nextSibling)
+ settingsButton.nextSibling.remove();
+
+ let Preferences =
+ Cu.import("resource://gre/modules/Preferences.jsm", {}).Preferences;
+ let pref = Preferences.get("browser.search.hiddenOneOffs");
+ let hiddenList = pref ? pref.split(",") : [];
+
+ let currentEngineName = Services.search.currentEngine.name;
+ let includeCurrentEngine = this.getAttribute("includecurrentengine");
+ let engines = Services.search.getVisibleEngines().filter(e => {
+ return (includeCurrentEngine || e.name != currentEngineName) &&
+ !hiddenList.includes(e.name);
+ });
+
+ let header = document.getAnonymousElementByAttribute(this, "anonid",
+ "search-panel-one-offs-header")
+ // header is a xul:deck so collapsed doesn't work on it, see bug 589569.
+ header.hidden = list.collapsed = !engines.length;
+
+ if (!engines.length)
+ return;
+
+ let panelWidth = parseInt(this.popup.clientWidth);
+ // The + 1 is because the last button doesn't have a right border.
+ let enginesPerRow = Math.floor((panelWidth + 1) / this.buttonWidth);
+ let buttonWidth = Math.floor(panelWidth / enginesPerRow);
+ // There will be an emtpy area of:
+ // panelWidth - enginesPerRow * buttonWidth px
+ // at the end of each row.
+
+ // If the <description> tag with the list of search engines doesn't have
+ // a fixed height, the panel will be sized incorrectly, causing the bottom
+ // of the suggestion <tree> to be hidden.
+ let oneOffCount = engines.length;
+ if (this.compact)
+ ++oneOffCount;
+ let rowCount = Math.ceil(oneOffCount / enginesPerRow);
+ let height = rowCount * 33; // 32px per row, 1px border.
+ list.setAttribute("height", height + "px");
+
+ // Ensure we can refer to the settings buttons by ID:
+ let settingsEl = document.getAnonymousElementByAttribute(this, "anonid", "search-settings");
+ settingsEl.id = this.telemetryOrigin + "-anon-search-settings";
+ let compactSettingsEl = document.getAnonymousElementByAttribute(this, "anonid", "search-settings-compact");
+ compactSettingsEl.id = this.telemetryOrigin +
+ "-anon-search-settings-compact";
+
+ const kXULNS =
+ "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+ let dummyItems = enginesPerRow - (oneOffCount % enginesPerRow || enginesPerRow);
+ for (let i = 0; i < engines.length; ++i) {
+ let engine = engines[i];
+ let button = document.createElementNS(kXULNS, "button");
+ button.id = this._buttonIDForEngine(engine);
+ let uri = "chrome://browser/skin/search-engine-placeholder.png";
+ if (engine.iconURI) {
+ uri = engine.iconURI.spec;
+ }
+ button.setAttribute("image", uri);
+ button.setAttribute("class", "searchbar-engine-one-off-item");
+ button.setAttribute("tooltiptext", engine.name);
+ button.setAttribute("width", buttonWidth);
+ button.engine = engine;
+
+ if ((i + 1) % enginesPerRow == 0)
+ button.classList.add("last-of-row");
+
+ if (i + 1 == engines.length)
+ button.classList.add("last-engine");
+
+ if (i >= oneOffCount + dummyItems - enginesPerRow)
+ button.classList.add("last-row");
+
+ list.insertBefore(button, settingsButton);
+ }
+
+ let hasDummyItems = !!dummyItems;
+ while (dummyItems) {
+ let button = document.createElementNS(kXULNS, "button");
+ button.setAttribute("class", "searchbar-engine-one-off-item dummy last-row");
+ button.setAttribute("width", buttonWidth);
+
+ if (!--dummyItems)
+ button.classList.add("last-of-row");
+
+ list.insertBefore(button, settingsButton);
+ }
+
+ if (this.compact) {
+ this.settingsButton.setAttribute("width", buttonWidth);
+ if (rowCount == 1 && hasDummyItems) {
+ // When there's only one row, make the compact settings button
+ // hug the right edge of the panel. It may not due to the panel's
+ // width not being an integral multiple of the button width. (See
+ // the "There will be an emtpy area" comment above.) Increase the
+ // width of the last dummy item by the remainder.
+ //
+ // There's one weird thing to guard against. When layout pixels
+ // aren't an integral multiple of device pixels, the calculated
+ // remainder can end up being ~1px too big, at least on Windows,
+ // which pushes the settings button to a new row. The remainder
+ // is integral, not a fraction, so that's not the problem. To
+ // work around that, unscale the remainder, floor it, scale it
+ // back, and then floor that.
+ let scale = window.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils)
+ .screenPixelsPerCSSPixel;
+ let remainder = panelWidth - (enginesPerRow * buttonWidth);
+ remainder = Math.floor(Math.floor(remainder * scale) / scale);
+ let width = remainder + buttonWidth;
+ let lastDummyItem = this.settingsButton.previousSibling;
+ lastDummyItem.setAttribute("width", width);
+ }
+ }
+ ]]></body>
+ </method>
+
+ <!-- If a page offers more than this number of engines, the add-engines
+ menu button is shown, instead of showing the engines directly in the
+ popup. -->
+ <field name="_addEngineMenuThreshold">5</field>
+
+ <method name="_rebuildAddEngineList">
+ <body><![CDATA[
+ let list = document.getAnonymousElementByAttribute(this, "anonid",
+ "add-engines");
+ while (list.firstChild) {
+ list.firstChild.remove();
+ }
+
+ // Add a button for each engine that the page in the selected browser
+ // offers, but with the following exceptions:
+ //
+ // (1) Not when the one-offs are compact. Compact one-offs are shown in
+ // the urlbar, and the add-engine buttons span the width of the popup,
+ // so if we added all the engines that a page offers, it could break the
+ // urlbar popup by offering a ton of engines. We should probably make a
+ // smaller version of the buttons for compact one-offs.
+ //
+ // (2) Not when there are too many offered engines. The popup isn't
+ // designed to handle too many (by scrolling for example), so a page
+ // could break the popup by offering too many. Instead, add a single
+ // menu button with a submenu of all the engines.
+
+ if (this.compact || !gBrowser.selectedBrowser.engines) {
+ return;
+ }
+
+ const kXULNS =
+ "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+ let engines = gBrowser.selectedBrowser.engines;
+ let tooManyEngines = engines.length > this._addEngineMenuThreshold;
+
+ if (tooManyEngines) {
+ // Make the top-level menu button.
+ let button = document.createElementNS(kXULNS, "button");
+ list.appendChild(button);
+ button.classList.add("addengine-item");
+ button.setAttribute("anonid", "addengine-menu-button");
+ button.setAttribute("type", "menu");
+ button.setAttribute("label",
+ this.bundle.GetStringFromName("cmd_addFoundEngineMenu"));
+ button.setAttribute("crop", "end");
+ button.setAttribute("pack", "start");
+
+ // Set the menu button's image to the image of the first engine. The
+ // offered engines may have differing images, so there's no perfect
+ // choice here.
+ let engine = engines[0];
+ if (engine.icon) {
+ button.setAttribute("image", engine.icon);
+ }
+
+ // Now make the button's child menupopup.
+ list = document.createElementNS(kXULNS, "menupopup");
+ button.appendChild(list);
+ list.setAttribute("anonid", "addengine-menu");
+ list.setAttribute("position", "topright topleft");
+
+ // Events from child menupopups bubble up to the autocomplete binding,
+ // which breaks it, so prevent these events from propagating.
+ let suppressEventTypes = [
+ "popupshowing",
+ "popuphiding",
+ "popupshown",
+ "popuphidden",
+ ];
+ for (let type of suppressEventTypes) {
+ list.addEventListener(type, event => {
+ event.stopPropagation();
+ });
+ }
+ }
+
+ // Finally, add the engines to the list. If there aren't too many
+ // engines, the list is the add-engines vbox. Otherwise it's the
+ // menupopup created earlier. In the latter case, create menuitem
+ // elements instead of buttons, because buttons don't get keyboard
+ // handling for free inside menupopups.
+ let eltType = tooManyEngines ? "menuitem" : "button";
+ for (let engine of engines) {
+ let button = document.createElementNS(kXULNS, eltType);
+ button.classList.add("addengine-item");
+ button.id = this.telemetryOrigin + "-add-engine-" +
+ this._fixUpEngineNameForID(engine.title);
+ let label = this.bundle.formatStringFromName("cmd_addFoundEngine",
+ [engine.title], 1);
+ button.setAttribute("label", label);
+ button.setAttribute("crop", "end");
+ button.setAttribute("tooltiptext", engine.uri);
+ button.setAttribute("uri", engine.uri);
+ button.setAttribute("title", engine.title);
+ if (engine.icon) {
+ button.setAttribute("image", engine.icon);
+ }
+ if (tooManyEngines) {
+ button.classList.add("menuitem-iconic");
+ } else {
+ button.setAttribute("pack", "start");
+ }
+ list.appendChild(button);
+ }
+ ]]></body>
+ </method>
+
+ <method name="_buttonIDForEngine">
+ <parameter name="engine"/>
+ <body><![CDATA[
+ return this.telemetryOrigin + "-engine-one-off-item-" +
+ this._fixUpEngineNameForID(engine.name);
+ ]]></body>
+ </method>
+
+ <method name="_fixUpEngineNameForID">
+ <parameter name="name"/>
+ <body><![CDATA[
+ return name.replace(/ /g, "-");
+ ]]></body>
+ </method>
+
+ <method name="_buttonForEngine">
+ <parameter name="engine"/>
+ <body><![CDATA[
+ return document.getElementById(this._buttonIDForEngine(engine));
+ ]]></body>
+ </method>
+
+ <method name="_changeVisuallySelectedButton">
+ <parameter name="val"/>
+ <parameter name="aUpdateLogicallySelectedButton"/>
+ <body><![CDATA[
+ let visuallySelectedButton = this.visuallySelectedButton;
+ if (visuallySelectedButton)
+ visuallySelectedButton.removeAttribute("selected");
+
+ let header =
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "search-panel-one-offs-header");
+ // Avoid selecting dummy buttons.
+ if (val && !val.classList.contains("dummy")) {
+ val.setAttribute("selected", "true");
+ if (val.classList.contains("searchbar-engine-one-off-item") &&
+ val.engine) {
+ let headerEngineText =
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "searchbar-oneoffheader-engine");
+ header.selectedIndex = 2;
+ headerEngineText.value = val.engine.name;
+ } else {
+ header.selectedIndex = this.query ? 1 : 0;
+ }
+ if (this.textbox) {
+ this.textbox.setAttribute("aria-activedescendant", val.id);
+ }
+ } else {
+ val = null;
+ header.selectedIndex = this.query ? 1 : 0;
+ if (this.textbox) {
+ this.textbox.removeAttribute("aria-activedescendant");
+ }
+ }
+
+ if (aUpdateLogicallySelectedButton) {
+ this._selectedButton = val;
+ if (val && !val.engine) {
+ // If the button doesn't have an engine, then clear the popup's
+ // selection to indicate that pressing Return while the button is
+ // selected will do the button's command, not search.
+ this.popup.selectedIndex = -1;
+ }
+ let event = document.createEvent("Events");
+ event.initEvent("SelectedOneOffButtonChanged", true, false);
+ this.dispatchEvent(event);
+ }
+ ]]></body>
+ </method>
+
+ <method name="getSelectableButtons">
+ <parameter name="aIncludeNonEngineButtons"/>
+ <body><![CDATA[
+ let buttons = [];
+ let oneOff = document.getAnonymousElementByAttribute(this, "anonid",
+ "search-panel-one-offs");
+ for (oneOff = oneOff.firstChild; oneOff; oneOff = oneOff.nextSibling) {
+ // oneOff may be a text node since the list xul:description contains
+ // whitespace and the compact settings button. See the markup
+ // above. _rebuild removes text nodes, but it may not have been
+ // called yet (because e.g. the popup hasn't been opened yet).
+ if (oneOff.nodeType == Node.ELEMENT_NODE) {
+ if (oneOff.classList.contains("dummy") ||
+ oneOff.classList.contains("search-setting-button-compact"))
+ break;
+ buttons.push(oneOff);
+ }
+ }
+
+ if (!aIncludeNonEngineButtons)
+ return buttons;
+
+ let addEngine =
+ document.getAnonymousElementByAttribute(this, "anonid", "add-engines");
+ for (addEngine = addEngine.firstChild; addEngine; addEngine = addEngine.nextSibling)
+ buttons.push(addEngine);
+
+ buttons.push(this.settingsButton);
+ return buttons;
+ ]]></body>
+ </method>
+
+ <method name="handleSearchCommand">
+ <parameter name="aEvent"/>
+ <parameter name="aEngine"/>
+ <parameter name="aForceNewTab"/>
+ <body><![CDATA[
+ let where = "current";
+ let params;
+
+ // Open ctrl/cmd clicks on one-off buttons in a new background tab.
+ if (aForceNewTab) {
+ where = "tab";
+ if (Services.prefs.getBoolPref("browser.tabs.loadInBackground")) {
+ params = {
+ inBackground: true,
+ };
+ }
+ } else {
+ var newTabPref = Services.prefs.getBoolPref("browser.search.openintab");
+ if (((aEvent instanceof KeyboardEvent) && aEvent.altKey) ^ newTabPref)
+ where = "tab";
+ if ((aEvent instanceof MouseEvent) &&
+ (aEvent.button == 1 || aEvent.getModifierState("Accel"))) {
+ where = "tab";
+ params = {
+ inBackground: true,
+ };
+ }
+ }
+
+ this.popup.handleOneOffSearch(aEvent, aEngine, where, params);
+ ]]></body>
+ </method>
+
+ <!--
+ Increments or decrements the index of the currently selected one-off.
+
+ @param aForward
+ If true, the index is incremented, and if false, the index is
+ decremented.
+ @param aWrapAround
+ This has a couple of effects, depending on whether there is
+ currently a selection.
+ (1) If true and the last one-off is currently selected,
+ incrementing the index will cause the selection to be cleared and
+ this method to return true. Calling advanceSelection again after
+ that (again with aForward=true) will select the first one-off.
+ Likewise if decrementing the index when the first one-off is
+ selected, except in the opposite direction of course.
+ (2) If true and there currently is no selection, decrementing the
+ index will cause the last one-off to become selected and this
+ method to return true. Only the aForward=false case is affected
+ because it is always the case that if aForward=true and there
+ currently is no selection, the first one-off becomes selected and
+ this method returns true.
+ @param aCycleEngines
+ If true, only engine buttons are included.
+ @return True if the selection can continue to advance after this method
+ returns and false if not.
+ -->
+ <method name="advanceSelection">
+ <parameter name="aForward"/>
+ <parameter name="aWrapAround"/>
+ <parameter name="aCycleEngines"/>
+ <body><![CDATA[
+ let selectedButton = this.selectedButton;
+ let buttons = this.getSelectableButtons(aCycleEngines);
+
+ if (selectedButton) {
+ // cycle through one-off buttons.
+ let index = buttons.indexOf(selectedButton);
+ if (aForward)
+ ++index;
+ else
+ --index;
+
+ if (index >= 0 && index < buttons.length)
+ this.selectedButton = buttons[index];
+ else
+ this.selectedButton = null;
+
+ if (this.selectedButton || aWrapAround)
+ return true;
+
+ return false;
+ }
+
+ // If no selection, select the first button or ...
+ if (aForward) {
+ this.selectedButton = buttons[0];
+ return true;
+ }
+
+ if (!aForward && aWrapAround) {
+ // the last button.
+ this.selectedButton = buttons[buttons.length - 1];
+ return true;
+ }
+
+ return false;
+ ]]></body>
+ </method>
+
+ <!--
+ This handles key presses specific to the one-off buttons like Tab and
+ Alt-Up/Down, and Up/Down keys within the buttons. Since one-off buttons
+ are always used in conjunction with a list of some sort (in this.popup),
+ it also handles Up/Down keys that cross the boundaries between list
+ items and the one-off buttons.
+
+ @param event
+ The key event.
+ @param numListItems
+ The number of items in the list. The reason that this is a
+ parameter at all is that the list may contain items at the end
+ that should be ignored, depending on the consumer. That's true
+ for the urlbar for example.
+ @param allowEmptySelection
+ Pass true if it's OK that neither the list nor the one-off
+ buttons contains a selection. Pass false if either the list or
+ the one-off buttons (or both) should always contain a selection.
+ @param textboxUserValue
+ When the last list item is selected and the user presses Down,
+ the first one-off becomes selected and the textbox value is
+ restored to the value that the user typed. Pass that value here.
+ However, if you pass true for allowEmptySelection, you don't need
+ to pass anything for this parameter. (Pass undefined or null.)
+ @return True if this method handled the keypress and false if not. If
+ false, then you should let the autocomplete controller handle
+ the keypress. The value of event.defaultPrevented will be the
+ same as this return value.
+ -->
+ <method name="handleKeyPress">
+ <parameter name="event"/>
+ <parameter name="numListItems"/>
+ <parameter name="allowEmptySelection"/>
+ <parameter name="textboxUserValue"/>
+ <body><![CDATA[
+ if (!this.popup) {
+ return false;
+ }
+
+ let stopEvent = false;
+
+ // Tab cycles through the one-offs and moves the focus out at the end.
+ // But only if non-Shift modifiers aren't also pressed, to avoid
+ // clobbering other shortcuts.
+ if (event.keyCode == KeyEvent.DOM_VK_TAB &&
+ !event.altKey &&
+ !event.ctrlKey &&
+ !event.metaKey &&
+ this.getAttribute("disabletab") != "true") {
+ stopEvent = this.advanceSelection(!event.shiftKey, false, true);
+ } else if (event.altKey &&
+ (event.keyCode == KeyEvent.DOM_VK_DOWN ||
+ event.keyCode == KeyEvent.DOM_VK_UP)) {
+ // Alt + up/down is very similar to (shift +) tab but differs in that
+ // it loops through the list, whereas tab will move the focus out.
+ stopEvent =
+ this.advanceSelection(event.keyCode == KeyEvent.DOM_VK_DOWN,
+ true, false);
+ } else if (event.keyCode == Ci.nsIDOMKeyEvent.DOM_VK_UP) {
+ if (numListItems > 0) {
+ if (this.popup.selectedIndex > 0) {
+ // The autocomplete controller should handle this case.
+ } else if (this.popup.selectedIndex == 0) {
+ if (!allowEmptySelection) {
+ // Wrap around the selection to the last one-off.
+ this.selectedButton = null;
+ this.popup.selectedIndex = -1;
+ // Call advanceSelection after setting selectedIndex so that
+ // screen readers see the newly selected one-off. Both trigger
+ // accessibility events.
+ this.advanceSelection(false, true, true);
+ stopEvent = true;
+ }
+ } else {
+ let firstButtonSelected =
+ this.selectedButton &&
+ this.selectedButton == this.getSelectableButtons(true)[0];
+ if (firstButtonSelected) {
+ this.selectedButton = null;
+ } else {
+ stopEvent = this.advanceSelection(false, true, true);
+ }
+ }
+ } else {
+ stopEvent = this.advanceSelection(false, true, true);
+ }
+ } else if (event.keyCode == Ci.nsIDOMKeyEvent.DOM_VK_DOWN) {
+ if (numListItems > 0) {
+ if (this.popup.selectedIndex >= 0 &&
+ this.popup.selectedIndex < numListItems - 1) {
+ // The autocomplete controller should handle this case.
+ } else if (this.popup.selectedIndex == numListItems - 1) {
+ this.selectedButton = null;
+ if (!allowEmptySelection) {
+ this.popup.selectedIndex = -1;
+ stopEvent = true;
+ }
+ if (this.textbox && typeof(textboxUserValue) == "string") {
+ this.textbox.value = textboxUserValue;
+ }
+ // Call advanceSelection after setting selectedIndex so that
+ // screen readers see the newly selected one-off. Both trigger
+ // accessibility events.
+ this.advanceSelection(true, true, true);
+ } else {
+ let buttons = this.getSelectableButtons(true);
+ let lastButtonSelected =
+ this.selectedButton &&
+ this.selectedButton == buttons[buttons.length - 1];
+ if (lastButtonSelected) {
+ this.selectedButton = null;
+ stopEvent = allowEmptySelection;
+ } else if (this.selectedButton) {
+ stopEvent = this.advanceSelection(true, true, true);
+ } else {
+ // The autocomplete controller should handle this case.
+ }
+ }
+ } else {
+ stopEvent = this.advanceSelection(true, true, true);
+ }
+ } else if (this.selectedButton &&
+ this.selectedButton.getAttribute("anonid") ==
+ "addengine-menu-button" &&
+ event.keyCode == KeyEvent.DOM_VK_RIGHT) {
+ // If the add-engine overflow menu item is selected and the user
+ // presses the right arrow key, open the submenu. Unfortunately
+ // handling the left arrow key -- to close the popup -- isn't
+ // straightforward. Once the popup is open, it consumes all key
+ // events. Setting ignorekeys=handled on it doesn't help, since the
+ // popup handles all arrow keys. Setting ignorekeys=true on it does
+ // mean that the popup no longer consumes the left arrow key, but then
+ // it no longer handles up/down keys to select items in the popup.
+ this.selectedButton.open = true;
+ stopEvent = true;
+ }
+
+ if (stopEvent) {
+ event.preventDefault();
+ event.stopPropagation();
+ return true;
+ }
+ return false;
+ ]]></body>
+ </method>
+
+ <!--
+ If the given event is related to the one-offs, this method records
+ one-off telemetry for it. this.telemetryOrigin will be appended to the
+ computed source, so make sure you set that first.
+
+ @param aEvent
+ An event, like a click on a one-off button.
+ @param aOpenUILinkWhere
+ The "where" passed to openUILink.
+ @param aOpenUILinkParams
+ The "params" passed to openUILink.
+ @return True if telemetry was recorded and false if not.
+ -->
+ <method name="maybeRecordTelemetry">
+ <parameter name="aEvent"/>
+ <parameter name="aOpenUILinkWhere"/>
+ <parameter name="aOpenUILinkParams"/>
+ <body><![CDATA[
+ if (!aEvent) {
+ return false;
+ }
+
+ let source = null;
+ let type = "unknown";
+ let engine = null;
+ let target = aEvent.originalTarget;
+
+ if (aEvent instanceof KeyboardEvent) {
+ type = "key";
+ if (this.selectedButton) {
+ source = "oneoff";
+ engine = this.selectedButton.engine;
+ }
+ } else if (aEvent instanceof MouseEvent) {
+ type = "mouse";
+ if (target.classList.contains("searchbar-engine-one-off-item")) {
+ source = "oneoff";
+ engine = target.engine;
+ }
+ } else if ((aEvent instanceof XULCommandEvent) &&
+ target.getAttribute("anonid") ==
+ "search-one-offs-context-open-in-new-tab") {
+ source = "oneoff-context";
+ engine = this._contextEngine;
+ }
+
+ if (!source) {
+ return false;
+ }
+
+ if (this.telemetryOrigin) {
+ source += "-" + this.telemetryOrigin;
+ }
+
+ let tabBackground = aOpenUILinkWhere == "tab" &&
+ aOpenUILinkParams &&
+ aOpenUILinkParams.inBackground;
+ let where = tabBackground ? "tab-background" : aOpenUILinkWhere;
+ BrowserSearch.recordOneoffSearchInTelemetry(engine, source, type,
+ where);
+ return true;
+ ]]></body>
+ </method>
+
+ <!-- All this stuff is to make the add-engines menu button behave like an
+ actual menu. The add-engines menu button is shown when there are
+ many engines offered by the current site. -->
+ <field name="_addEngineMenuTimeoutMs">200</field>
+ <field name="_addEngineMenuTimeout">null</field>
+ <field name="_addEngineMenuShouldBeOpen">false</field>
+
+ <method name="_resetAddEngineMenuTimeout">
+ <body><![CDATA[
+ if (this._addEngineMenuTimeout) {
+ clearTimeout(this._addEngineMenuTimeout);
+ }
+ this._addEngineMenuTimeout = setTimeout(() => {
+ delete this._addEngineMenuTimeout;
+ let button = document.getAnonymousElementByAttribute(
+ this, "anonid", "addengine-menu-button"
+ );
+ button.open = this._addEngineMenuShouldBeOpen;
+ }, this._addEngineMenuTimeoutMs);
+ ]]></body>
+ </method>
+
+ </implementation>
+
+ <handlers>
+
+ <handler event="mousedown"><![CDATA[
+ let target = event.originalTarget;
+ if (target.getAttribute("anonid") == "addengine-menu-button") {
+ return;
+ }
+ // Required to receive click events from the buttons on Linux.
+ event.preventDefault();
+ ]]></handler>
+
+ <handler event="mousemove"><![CDATA[
+ let target = event.originalTarget;
+
+ // Handle mouseover on the add-engine menu button and its popup items.
+ if (target.getAttribute("anonid") == "addengine-menu-button" ||
+ (target.localName == "menuitem" &&
+ target.classList.contains("addengine-item"))) {
+ // Make the menu button visually selected. It's highlighted in the
+ // CSS when the popup is open, but the popup doesn't open until a
+ // short timeout has elapsed. Making the button visually selected now
+ // provides better feedback to the user.
+ let menuButton = document.getAnonymousElementByAttribute(
+ this, "anonid", "addengine-menu-button"
+ );
+ this._changeVisuallySelectedButton(menuButton);
+ this._addEngineMenuShouldBeOpen = true;
+ this._resetAddEngineMenuTimeout();
+ return;
+ }
+
+ if (target.localName != "button")
+ return;
+
+ // Ignore mouse events when the context menu is open.
+ if (this._ignoreMouseEvents)
+ return;
+
+ let isOneOff =
+ target.classList.contains("searchbar-engine-one-off-item") &&
+ !target.classList.contains("dummy");
+ if (isOneOff ||
+ target.classList.contains("addengine-item") ||
+ target.classList.contains("search-setting-button")) {
+ this._changeVisuallySelectedButton(target);
+ }
+ ]]></handler>
+
+ <handler event="mouseout"><![CDATA[
+
+ let target = event.originalTarget;
+
+ // Handle mouseout on the add-engine menu button and its popup items.
+ if (target.getAttribute("anonid") == "addengine-menu-button" ||
+ (target.localName == "menuitem" &&
+ target.classList.contains("addengine-item"))) {
+ // The menu button will appear selected since the mouse is either over
+ // it or over one of the menu items in the popup. Make it unselected.
+ this._changeVisuallySelectedButton(null);
+ this._addEngineMenuShouldBeOpen = false;
+ this._resetAddEngineMenuTimeout();
+ return;
+ }
+
+ if (target.localName != "button") {
+ return;
+ }
+
+ // Don't deselect the current button if the context menu is open.
+ if (this._ignoreMouseEvents)
+ return;
+
+ // Unfortunately this will fire before mouseover hits another item.
+ // If this button is selected, we replace that selection only if
+ // we're not moving to a different one-off item:
+ if (target.getAttribute("selected") == "true" &&
+ (!event.relatedTarget ||
+ !event.relatedTarget.classList.contains("searchbar-engine-one-off-item") ||
+ event.relatedTarget.classList.contains("dummy"))) {
+ this._changeVisuallySelectedButton(this.selectedButton);
+ }
+ ]]></handler>
+
+ <handler event="click"><![CDATA[
+ if (event.button == 2)
+ return; // ignore right clicks.
+
+ let button = event.originalTarget;
+ let engine = button.engine;
+
+ if (!engine)
+ return;
+
+ // Select the clicked button so that consumers can easily tell which
+ // button was acted on.
+ this.selectedButton = button;
+ this.handleSearchCommand(event, engine);
+ ]]></handler>
+
+ <handler event="command"><![CDATA[
+ let target = event.originalTarget;
+ if (target.classList.contains("addengine-item")) {
+ // On success, hide the panel and tell event listeners to reshow it to
+ // show the new engine.
+ let installCallback = {
+ onSuccess: engine => {
+ this._rebuild();
+ },
+ onError(errorCode) {
+ if (errorCode != Ci.nsISearchInstallCallback.ERROR_DUPLICATE_ENGINE) {
+ // Download error is shown by the search service
+ return;
+ }
+ const kSearchBundleURI = "chrome://global/locale/search/search.properties";
+ let searchBundle = Services.strings.createBundle(kSearchBundleURI);
+ let brandBundle = document.getElementById("bundle_brand");
+ let brandName = brandBundle.getString("brandShortName");
+ let title = searchBundle.GetStringFromName("error_invalid_engine_title");
+ let text = searchBundle.formatStringFromName("error_duplicate_engine_msg",
+ [brandName, target.getAttribute("uri")], 2);
+ Services.prompt.QueryInterface(Ci.nsIPromptFactory);
+ let prompt = Services.prompt.getPrompt(gBrowser.contentWindow, Ci.nsIPrompt);
+ prompt.QueryInterface(Ci.nsIWritablePropertyBag2);
+ prompt.setPropertyAsBool("allowTabModal", true);
+ prompt.alert(title, text);
+ }
+ }
+ Services.search.addEngine(target.getAttribute("uri"), null,
+ target.getAttribute("image"), false,
+ installCallback);
+ }
+ let anonid = target.getAttribute("anonid");
+ if (anonid == "search-one-offs-context-open-in-new-tab") {
+ // Select the context-clicked button so that consumers can easily
+ // tell which button was acted on.
+ this.selectedButton = this._buttonForEngine(this._contextEngine);
+ this.handleSearchCommand(event, this._contextEngine, true);
+ }
+ if (anonid == "search-one-offs-context-set-default") {
+ let currentEngine = Services.search.currentEngine;
+
+ if (!this.getAttribute("includecurrentengine")) {
+ // Make the target button of the context menu reflect the current
+ // search engine first. Doing this as opposed to rebuilding all the
+ // one-off buttons avoids flicker.
+ let button = this._buttonForEngine(this._contextEngine);
+ button.id = this._buttonIDForEngine(currentEngine);
+ let uri = "chrome://browser/skin/search-engine-placeholder.png";
+ if (currentEngine.iconURI)
+ uri = currentEngine.iconURI.spec;
+ button.setAttribute("image", uri);
+ button.setAttribute("tooltiptext", currentEngine.name);
+ button.engine = currentEngine;
+ }
+
+ Services.search.currentEngine = this._contextEngine;
+ }
+ ]]></handler>
+
+ <handler event="contextmenu"><![CDATA[
+ let target = event.originalTarget;
+ // Prevent the context menu from appearing except on the one off buttons.
+ if (!target.classList.contains("searchbar-engine-one-off-item") ||
+ target.classList.contains("dummy")) {
+ event.preventDefault();
+ return;
+ }
+ document.getAnonymousElementByAttribute(this, "anonid", "search-one-offs-context-set-default")
+ .setAttribute("disabled", target.engine == Services.search.currentEngine);
+
+ this._contextEngine = target.engine;
+ ]]></handler>
+ </handlers>
+
+ </binding>
+
+</bindings>
diff --git a/application/basilisk/components/search/content/searchReset.js b/application/basilisk/components/search/content/searchReset.js
new file mode 100644
index 000000000..b541d41da
--- /dev/null
+++ b/application/basilisk/components/search/content/searchReset.js
@@ -0,0 +1,90 @@
+/* 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 {classes: Cc, interfaces: Ci, utils: Cu} = Components;
+
+Cu.import("resource://gre/modules/Services.jsm");
+
+const TELEMETRY_RESULT_ENUM = {
+ RESTORED_DEFAULT: 0,
+ KEPT_CURRENT: 1,
+ CHANGED_ENGINE: 2,
+ CLOSED_PAGE: 3,
+ OPENED_SETTINGS: 4
+};
+
+window.onload = function() {
+ let defaultEngine = document.getElementById("defaultEngine");
+ let originalDefault = Services.search.originalDefaultEngine;
+ defaultEngine.textContent = originalDefault.name;
+ defaultEngine.style.backgroundImage =
+ 'url("' + originalDefault.iconURI.spec + '")';
+
+ document.getElementById("searchResetChangeEngine").focus();
+ window.addEventListener("unload", recordPageClosed);
+ document.getElementById("linkSettingsPage")
+ .addEventListener("click", openingSettings);
+};
+
+function doSearch() {
+ let queryString = "";
+ let purpose = "";
+ let params = window.location.href.match(/^about:searchreset\?([^#]*)/);
+ if (params) {
+ params = params[1].split("&");
+ for (let param of params) {
+ if (param.startsWith("data="))
+ queryString = decodeURIComponent(param.slice(5));
+ else if (param.startsWith("purpose="))
+ purpose = param.slice(8);
+ }
+ }
+
+ let engine = Services.search.currentEngine;
+ let submission = engine.getSubmission(queryString, null, purpose);
+
+ window.removeEventListener("unload", recordPageClosed);
+
+ let win = window.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIWebNavigation)
+ .QueryInterface(Ci.nsIDocShellTreeItem)
+ .rootTreeItem
+ .QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindow);
+ win.openUILinkIn(submission.uri.spec, "current", false, submission.postData);
+}
+
+function openingSettings() {
+ record(TELEMETRY_RESULT_ENUM.OPENED_SETTINGS);
+ window.removeEventListener("unload", recordPageClosed);
+}
+
+function record(result) {
+ Services.telemetry.getHistogramById("SEARCH_RESET_RESULT").add(result);
+}
+
+function keepCurrentEngine() {
+ // Calling the currentEngine setter will force a correct loadPathHash to be
+ // written for this engine, so that we don't prompt the user again.
+ Services.search.currentEngine = Services.search.currentEngine;
+ record(TELEMETRY_RESULT_ENUM.KEPT_CURRENT);
+ doSearch();
+}
+
+function changeSearchEngine() {
+ let engine = Services.search.originalDefaultEngine;
+ if (engine.hidden)
+ engine.hidden = false;
+ Services.search.currentEngine = engine;
+
+ record(TELEMETRY_RESULT_ENUM.RESTORED_DEFAULT);
+
+ doSearch();
+}
+
+function recordPageClosed() {
+ record(TELEMETRY_RESULT_ENUM.CLOSED_PAGE);
+}
diff --git a/application/basilisk/components/search/content/searchReset.xhtml b/application/basilisk/components/search/content/searchReset.xhtml
new file mode 100644
index 000000000..b851dd383
--- /dev/null
+++ b/application/basilisk/components/search/content/searchReset.xhtml
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- 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 html [
+ <!ENTITY % htmlDTD PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "DTD/xhtml1-strict.dtd">
+ %htmlDTD;
+ <!ENTITY % globalDTD SYSTEM "chrome://global/locale/global.dtd">
+ %globalDTD;
+ <!ENTITY % searchresetDTD SYSTEM "chrome://browser/locale/aboutSearchReset.dtd">
+ %searchresetDTD;
+ <!ENTITY % brandDTD SYSTEM "chrome://branding/locale/brand.dtd">
+ %brandDTD;
+]>
+
+<html xmlns="http://www.w3.org/1999/xhtml"
+ xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+ <head>
+ <title>&searchreset.tabtitle;</title>
+ <link rel="stylesheet" type="text/css" media="all"
+ href="chrome://global/skin/in-content/info-pages.css"/>
+ <link rel="stylesheet" type="text/css" media="all"
+ href="chrome://browser/skin/searchReset.css"/>
+ <link rel="icon" type="image/png"
+ href="chrome://browser/skin/favicon-search-16.svg"/>
+
+ <script type="application/javascript;version=1.8"
+ src="chrome://browser/content/search/searchReset.js"/>
+ </head>
+
+ <body dir="&locale.dir;">
+
+ <div class="container">
+ <div class="title">
+ <h1 class="title-text">&searchreset.pageTitle;</h1>
+ </div>
+
+ <div class="description">
+ <p>&searchreset.pageInfo1;</p>
+ <p>&searchreset.selector.label;<span id="defaultEngine"/></p>
+
+ <p>&searchreset.beforelink.pageInfo2;<a id="linkSettingsPage" href="about:preferences#search">&searchreset.link.pageInfo2;</a>&searchreset.afterlink.pageInfo2;</p>
+ </div>
+
+ <div class="button-container">
+ <xul:button id="searchResetKeepCurrent"
+ label="&searchreset.noChangeButton;"
+ accesskey="&searchreset.noChangeButton.access;"
+ oncommand="keepCurrentEngine();"/>
+ <xul:button class="primary"
+ id="searchResetChangeEngine"
+ label="&searchreset.changeEngineButton;"
+ accesskey="&searchreset.changeEngineButton.access;"
+ oncommand="changeSearchEngine();"/>
+ </div>
+ </div>
+
+ </body>
+</html>
diff --git a/application/basilisk/components/search/content/searchbarBindings.css b/application/basilisk/components/search/content/searchbarBindings.css
new file mode 100644
index 000000000..0429e8811
--- /dev/null
+++ b/application/basilisk/components/search/content/searchbarBindings.css
@@ -0,0 +1,18 @@
+/* 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/. */
+
+@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");
+
+.searchbar-textbox {
+ -moz-binding: url("chrome://browser/content/search/search.xml#searchbar-textbox");
+}
+
+.search-one-offs {
+ -moz-binding: url("chrome://browser/content/search/search.xml#search-one-offs");
+}
+
+.search-setting-button[compact=true],
+.search-setting-button-compact:not([compact=true]) {
+ display: none;
+}