forked from mirrors/gecko-dev
ae619c5049
This goes through the previous changes in the dependencies of bug 877389, and does two things: 1) Remove instances of \n 2) Change reporting of exceptions so that they are passed as separate arguments. This should result in an improved display of the exception in the browser console, should it occur. Differential Revision: https://phabricator.services.mozilla.com/D180843
1132 lines
35 KiB
JavaScript
1132 lines
35 KiB
JavaScript
/* 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/. */
|
|
|
|
const lazy = {};
|
|
|
|
ChromeUtils.defineESModuleGetters(lazy, {
|
|
PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
|
|
SearchUIUtils: "resource:///modules/SearchUIUtils.sys.mjs",
|
|
});
|
|
|
|
const EMPTY_ADD_ENGINES = [];
|
|
|
|
/**
|
|
* Defines the search one-off button elements. These are displayed at the bottom
|
|
* of the address bar and search bar. The address bar buttons are a subclass in
|
|
* browser/components/urlbar/UrlbarSearchOneOffs.jsm. If you are adding a new
|
|
* subclass, see "Methods for subclasses to override" below.
|
|
*/
|
|
export class SearchOneOffs {
|
|
constructor(container) {
|
|
this.container = container;
|
|
this.window = container.ownerGlobal;
|
|
this.document = container.ownerDocument;
|
|
|
|
this.container.appendChild(
|
|
this.window.MozXULElement.parseXULToFragment(
|
|
`
|
|
<hbox class="search-panel-one-offs-header search-panel-header">
|
|
<label class="search-panel-one-offs-header-label" data-l10n-id="search-one-offs-with-title"/>
|
|
</hbox>
|
|
<box class="search-panel-one-offs-container">
|
|
<hbox class="search-panel-one-offs" role="group"/>
|
|
<button class="searchbar-engine-one-off-item search-setting-button" tabindex="-1" data-l10n-id="search-one-offs-change-settings-compact-button"/>
|
|
</box>
|
|
<box>
|
|
<menupopup class="search-one-offs-context-menu">
|
|
<menuitem class="search-one-offs-context-open-in-new-tab" data-l10n-id="search-one-offs-context-open-new-tab"/>
|
|
<menuitem class="search-one-offs-context-set-default" data-l10n-id="search-one-offs-context-set-as-default"/>
|
|
<menuitem class="search-one-offs-context-set-default-private" data-l10n-id="search-one-offs-context-set-as-default-private"/>
|
|
</menupopup>
|
|
</box>
|
|
`
|
|
)
|
|
);
|
|
|
|
this._popup = null;
|
|
this._textbox = null;
|
|
|
|
this._textboxWidth = 0;
|
|
|
|
/**
|
|
* Set this to a string that identifies your one-offs consumer. It'll
|
|
* be appended to telemetry recorded with maybeRecordTelemetry().
|
|
*/
|
|
this.telemetryOrigin = "";
|
|
|
|
this._query = "";
|
|
|
|
this._selectedButton = null;
|
|
|
|
this.buttons = this.querySelector(".search-panel-one-offs");
|
|
|
|
this.header = this.querySelector(".search-panel-one-offs-header");
|
|
|
|
this.settingsButton = this.querySelector(".search-setting-button");
|
|
|
|
this.contextMenuPopup = this.querySelector(".search-one-offs-context-menu");
|
|
|
|
this._engineInfo = null;
|
|
|
|
/**
|
|
* `_rebuild()` is async, because it queries the Search Service, which means
|
|
* there is a potential for a race when it's called multiple times in succession.
|
|
*/
|
|
this._rebuilding = false;
|
|
|
|
this.addEventListener("mousedown", this);
|
|
this.addEventListener("click", this);
|
|
this.addEventListener("command", this);
|
|
this.addEventListener("contextmenu", this);
|
|
|
|
// Prevent popup events from the context menu from reaching the autocomplete
|
|
// binding (or other listeners).
|
|
let listener = aEvent => aEvent.stopPropagation();
|
|
this.contextMenuPopup.addEventListener("popupshowing", listener);
|
|
this.contextMenuPopup.addEventListener("popuphiding", listener);
|
|
this.contextMenuPopup.addEventListener("popupshown", aEvent => {
|
|
aEvent.stopPropagation();
|
|
});
|
|
this.contextMenuPopup.addEventListener("popuphidden", aEvent => {
|
|
aEvent.stopPropagation();
|
|
});
|
|
|
|
// Add weak referenced observers to invalidate our cached list of engines.
|
|
this.QueryInterface = ChromeUtils.generateQI([
|
|
"nsIObserver",
|
|
"nsISupportsWeakReference",
|
|
]);
|
|
Services.obs.addObserver(this, "browser-search-engine-modified", true);
|
|
Services.obs.addObserver(this, "browser-search-service", true);
|
|
|
|
// Rebuild the buttons when the theme changes. See bug 1357800 for
|
|
// details. Summary: On Linux, switching between themes can cause a row
|
|
// of buttons to disappear.
|
|
Services.obs.addObserver(this, "lightweight-theme-changed", true);
|
|
|
|
// This defaults to false in the Search Bar, subclasses can change their
|
|
// default in the constructor.
|
|
this.disableOneOffsHorizontalKeyNavigation = false;
|
|
}
|
|
|
|
addEventListener(...args) {
|
|
this.container.addEventListener(...args);
|
|
}
|
|
|
|
removeEventListener(...args) {
|
|
this.container.removeEventListener(...args);
|
|
}
|
|
|
|
dispatchEvent(...args) {
|
|
this.container.dispatchEvent(...args);
|
|
}
|
|
|
|
getAttribute(...args) {
|
|
return this.container.getAttribute(...args);
|
|
}
|
|
|
|
hasAttribute(...args) {
|
|
return this.container.hasAttribute(...args);
|
|
}
|
|
|
|
setAttribute(...args) {
|
|
this.container.setAttribute(...args);
|
|
}
|
|
|
|
querySelector(...args) {
|
|
return this.container.querySelector(...args);
|
|
}
|
|
|
|
handleEvent(event) {
|
|
let methodName = "_on_" + event.type;
|
|
if (methodName in this) {
|
|
this[methodName](event);
|
|
} else {
|
|
throw new Error("Unrecognized search-one-offs event: " + event.type);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {boolean}
|
|
* True if we will hide the one-offs when they are requested.
|
|
*/
|
|
async willHide() {
|
|
if (this._engineInfo?.willHide !== undefined) {
|
|
return this._engineInfo.willHide;
|
|
}
|
|
let engineInfo = await this.getEngineInfo();
|
|
let oneOffCount = engineInfo.engines.length;
|
|
this._engineInfo.willHide =
|
|
!oneOffCount ||
|
|
(oneOffCount == 1 &&
|
|
engineInfo.engines[0].name == engineInfo.default.name);
|
|
return this._engineInfo.willHide;
|
|
}
|
|
|
|
/**
|
|
* Invalidates the engine cache. After invalidating the cache, the one-offs
|
|
* will be rebuilt the next time they are shown.
|
|
*/
|
|
invalidateCache() {
|
|
if (!this._rebuilding) {
|
|
this._engineInfo = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Width in pixels of the one-off buttons.
|
|
* NOTE: Used in browser/components/search/content/searchbar.js only.
|
|
*
|
|
* @returns {number}
|
|
*/
|
|
get buttonWidth() {
|
|
return 48;
|
|
}
|
|
|
|
/**
|
|
* The popup that contains the one-offs.
|
|
*
|
|
* @param {DOMElement} val
|
|
* The new value to set.
|
|
*/
|
|
set popup(val) {
|
|
if (this._popup) {
|
|
this._popup.removeEventListener("popupshowing", this);
|
|
this._popup.removeEventListener("popuphidden", this);
|
|
}
|
|
if (val) {
|
|
val.addEventListener("popupshowing", this);
|
|
val.addEventListener("popuphidden", 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();
|
|
}
|
|
}
|
|
|
|
get popup() {
|
|
return this._popup;
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @param {DOMElement} val
|
|
* The new value to set.
|
|
*/
|
|
set textbox(val) {
|
|
if (this._textbox) {
|
|
this._textbox.removeEventListener("input", this);
|
|
}
|
|
if (val) {
|
|
val.addEventListener("input", this);
|
|
}
|
|
this._textbox = val;
|
|
}
|
|
|
|
get style() {
|
|
return this.container.style;
|
|
}
|
|
|
|
get textbox() {
|
|
return this._textbox;
|
|
}
|
|
|
|
/**
|
|
* The query string currently shown in the one-offs. If the textbox
|
|
* property is non-null, then this is automatically updated on
|
|
* input.
|
|
*
|
|
* @param {string} val
|
|
* The new query string to set.
|
|
*/
|
|
set query(val) {
|
|
this._query = val;
|
|
if (this.isViewOpen) {
|
|
let isOneOffSelected =
|
|
this.selectedButton &&
|
|
this.selectedButton.classList.contains(
|
|
"searchbar-engine-one-off-item"
|
|
) &&
|
|
!(
|
|
this.selectedButton == this.settingsButton &&
|
|
this.hasAttribute("is_searchbar")
|
|
);
|
|
// 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
get query() {
|
|
return this._query;
|
|
}
|
|
|
|
/**
|
|
* The selected one-off, a xul:button, including the add-engine button
|
|
* and the search-settings button.
|
|
*
|
|
* @param {DOMElement|null} val
|
|
* The selected one-off button. Null if no one-off is selected.
|
|
*/
|
|
set selectedButton(val) {
|
|
let previousButton = this._selectedButton;
|
|
if (previousButton) {
|
|
previousButton.removeAttribute("selected");
|
|
}
|
|
if (val) {
|
|
val.setAttribute("selected", "true");
|
|
}
|
|
this._selectedButton = val;
|
|
|
|
if (this.textbox) {
|
|
if (val) {
|
|
this.textbox.setAttribute("aria-activedescendant", val.id);
|
|
} else {
|
|
let active = this.textbox.getAttribute("aria-activedescendant");
|
|
if (active && active.includes("-engine-one-off-item-")) {
|
|
this.textbox.removeAttribute("aria-activedescendant");
|
|
}
|
|
}
|
|
}
|
|
|
|
let event = new CustomEvent("SelectedOneOffButtonChanged", {
|
|
previousSelectedButton: previousButton,
|
|
});
|
|
this.dispatchEvent(event);
|
|
}
|
|
|
|
get selectedButton() {
|
|
return this._selectedButton;
|
|
}
|
|
|
|
/**
|
|
* The index of the selected one-off, including the add-engine button
|
|
* and the search-settings button.
|
|
*
|
|
* @param {number} val
|
|
* The new index to set, -1 for nothing selected.
|
|
*/
|
|
set selectedButtonIndex(val) {
|
|
let buttons = this.getSelectableButtons(true);
|
|
this.selectedButton = buttons[val];
|
|
}
|
|
|
|
get selectedButtonIndex() {
|
|
let buttons = this.getSelectableButtons(true);
|
|
for (let i = 0; i < buttons.length; i++) {
|
|
if (buttons[i] == this._selectedButton) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
async getEngineInfo() {
|
|
if (this._engineInfo) {
|
|
return this._engineInfo;
|
|
}
|
|
|
|
this._engineInfo = {};
|
|
if (lazy.PrivateBrowsingUtils.isWindowPrivate(this.window)) {
|
|
this._engineInfo.default = await Services.search.getDefaultPrivate();
|
|
} else {
|
|
this._engineInfo.default = await Services.search.getDefault();
|
|
}
|
|
|
|
let currentEngineNameToIgnore;
|
|
if (!this.getAttribute("includecurrentengine")) {
|
|
currentEngineNameToIgnore = this._engineInfo.default.name;
|
|
}
|
|
|
|
this._engineInfo.engines = (
|
|
await Services.search.getVisibleEngines()
|
|
).filter(e => {
|
|
let name = e.name;
|
|
return (
|
|
(!currentEngineNameToIgnore || name != currentEngineNameToIgnore) &&
|
|
!e.hideOneOffButton
|
|
);
|
|
});
|
|
|
|
return this._engineInfo;
|
|
}
|
|
|
|
observe(aEngine, aTopic, aData) {
|
|
// For the "browser-search-service" topic, we only need to invalidate
|
|
// the cache on initialization complete or when the engines are reloaded.
|
|
if (
|
|
aTopic != "browser-search-service" ||
|
|
aData == "init-complete" ||
|
|
aData == "engines-reloaded"
|
|
) {
|
|
// Make sure the engine list was updated.
|
|
this.invalidateCache();
|
|
}
|
|
}
|
|
|
|
_getAddEngines() {
|
|
return this.window.gBrowser.selectedBrowser.engines || EMPTY_ADD_ENGINES;
|
|
}
|
|
|
|
get _maxInlineAddEngines() {
|
|
return 3;
|
|
}
|
|
|
|
/**
|
|
* Infallible, non-re-entrant version of `__rebuild()`.
|
|
*/
|
|
async _rebuild() {
|
|
if (this._rebuilding) {
|
|
return;
|
|
}
|
|
|
|
this._rebuilding = true;
|
|
try {
|
|
await this.__rebuild();
|
|
} catch (ex) {
|
|
console.error("Search-one-offs::_rebuild() error:", ex);
|
|
} finally {
|
|
this._rebuilding = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Builds all the UI.
|
|
*/
|
|
async __rebuild() {
|
|
// Return early if the list of engines has not changed.
|
|
if (!this.popup && this._engineInfo?.domWasUpdated) {
|
|
return;
|
|
}
|
|
|
|
const addEngines = this._getAddEngines();
|
|
|
|
// Return early if the engines and panel width have not changed.
|
|
if (this.popup && this._textbox) {
|
|
let textboxWidth = await this.window.promiseDocumentFlushed(() => {
|
|
return this._textbox.clientWidth;
|
|
});
|
|
|
|
if (
|
|
this._engineInfo?.domWasUpdated &&
|
|
this._textboxWidth == textboxWidth &&
|
|
this._addEngines == addEngines
|
|
) {
|
|
return;
|
|
}
|
|
this._textboxWidth = textboxWidth;
|
|
this._addEngines = addEngines;
|
|
}
|
|
|
|
const isSearchBar = this.hasAttribute("is_searchbar");
|
|
if (isSearchBar) {
|
|
// Hide the container during updating to avoid flickering.
|
|
this.container.hidden = true;
|
|
}
|
|
|
|
// Finally, build the list of one-off buttons.
|
|
while (this.buttons.firstElementChild) {
|
|
this.buttons.firstElementChild.remove();
|
|
}
|
|
|
|
let headerText = this.header.querySelector(
|
|
".search-panel-one-offs-header-label"
|
|
);
|
|
headerText.id = this.telemetryOrigin + "-one-offs-header-label";
|
|
this.buttons.setAttribute("aria-labelledby", headerText.id);
|
|
|
|
// For the search-bar, always show the one-off buttons where there is an
|
|
// option to add an engine.
|
|
let addEngineNeeded = isSearchBar && addEngines.length;
|
|
let hideOneOffs = (await this.willHide()) && !addEngineNeeded;
|
|
|
|
// The _engineInfo cache is used by more consumers, thus it is not a good
|
|
// representation of whether this method already updated the one-off buttons
|
|
// DOM. For this reason we introduce a separate flag tracking the DOM
|
|
// updating, and use it to know when it's okay to not rebuild the one-offs.
|
|
// We set this early, since we might either rebuild the DOM or hide it.
|
|
this._engineInfo.domWasUpdated = true;
|
|
|
|
this.container.hidden = hideOneOffs;
|
|
|
|
if (hideOneOffs) {
|
|
return;
|
|
}
|
|
|
|
// Ensure we can refer to the settings buttons by ID:
|
|
let origin = this.telemetryOrigin;
|
|
this.settingsButton.id = origin + "-anon-search-settings";
|
|
|
|
let engines = (await this.getEngineInfo()).engines;
|
|
this._rebuildEngineList(engines, addEngines);
|
|
|
|
this.dispatchEvent(new Event("rebuild"));
|
|
}
|
|
|
|
/**
|
|
* Adds one-offs for the given engines to the DOM.
|
|
*
|
|
* @param {Array} engines
|
|
* The engines to add.
|
|
* @param {Array} addEngines
|
|
* The engines that can be added.
|
|
*/
|
|
_rebuildEngineList(engines, addEngines) {
|
|
for (let i = 0; i < engines.length; ++i) {
|
|
let engine = engines[i];
|
|
let button = this.document.createXULElement("button");
|
|
button.engine = engine;
|
|
button.id = this._buttonIDForEngine(engine);
|
|
let iconURI =
|
|
engine.iconURI?.spec ||
|
|
"chrome://browser/skin/search-engine-placeholder.png";
|
|
button.setAttribute("image", iconURI);
|
|
button.setAttribute("class", "searchbar-engine-one-off-item");
|
|
button.setAttribute("tabindex", "-1");
|
|
this.setTooltipForEngineButton(button);
|
|
this.buttons.appendChild(button);
|
|
}
|
|
|
|
for (
|
|
let i = 0, len = Math.min(addEngines.length, this._maxInlineAddEngines);
|
|
i < len;
|
|
i++
|
|
) {
|
|
const engine = addEngines[i];
|
|
const button = this.document.createXULElement("button");
|
|
button.id = this._buttonIDForEngine(engine);
|
|
button.classList.add("searchbar-engine-one-off-item");
|
|
button.classList.add("searchbar-engine-one-off-add-engine");
|
|
button.setAttribute("tabindex", "-1");
|
|
if (engine.icon) {
|
|
button.setAttribute("image", engine.icon);
|
|
}
|
|
this.document.l10n.setAttributes(button, "search-one-offs-add-engine", {
|
|
engineName: engine.title,
|
|
});
|
|
button.setAttribute("engine-name", engine.title);
|
|
button.setAttribute("uri", engine.uri);
|
|
this.buttons.appendChild(button);
|
|
}
|
|
}
|
|
|
|
_buttonIDForEngine(engine) {
|
|
return (
|
|
this.telemetryOrigin +
|
|
"-engine-one-off-item-engine-" +
|
|
this._engineInfo.engines.indexOf(engine)
|
|
);
|
|
}
|
|
|
|
getSelectableButtons(aIncludeNonEngineButtons) {
|
|
const buttons = [
|
|
...this.buttons.querySelectorAll(".searchbar-engine-one-off-item"),
|
|
];
|
|
|
|
if (aIncludeNonEngineButtons) {
|
|
buttons.push(this.settingsButton);
|
|
}
|
|
|
|
return buttons;
|
|
}
|
|
|
|
/**
|
|
* Returns information on where a search results page should be loaded: in the
|
|
* current tab or a new tab.
|
|
*
|
|
* @param {event} aEvent
|
|
* The event that triggered the page load.
|
|
* @param {boolean} [aForceNewTab]
|
|
* True to force the load in a new tab.
|
|
* @returns {object} An object { where, params }. `where` is a string:
|
|
* "current" or "tab". `params` is an object further describing how
|
|
* the page should be loaded.
|
|
*/
|
|
_whereToOpen(aEvent, aForceNewTab = false) {
|
|
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 {
|
|
let newTabPref = Services.prefs.getBoolPref("browser.search.openintab");
|
|
if (
|
|
(KeyboardEvent.isInstance(aEvent) && aEvent.altKey) ^ newTabPref &&
|
|
!this.window.gBrowser.selectedTab.isEmpty
|
|
) {
|
|
where = "tab";
|
|
}
|
|
if (
|
|
MouseEvent.isInstance(aEvent) &&
|
|
(aEvent.button == 1 || aEvent.getModifierState("Accel"))
|
|
) {
|
|
where = "tab";
|
|
params = {
|
|
inBackground: true,
|
|
};
|
|
}
|
|
}
|
|
|
|
return { where, params };
|
|
}
|
|
|
|
/**
|
|
* Increments or decrements the index of the currently selected one-off.
|
|
*
|
|
* @param {boolean} aForward
|
|
* If true, the index is incremented, and if false, the index is
|
|
* decremented.
|
|
* @param {boolean} aIncludeNonEngineButtons
|
|
* If true, buttons that do not have engines are included.
|
|
* These buttons include the OpenSearch and settings buttons. For
|
|
* example, if the currently selected button is an engine button,
|
|
* the next button is the settings button, and you pass true for
|
|
* aForward, then passing true for this value would cause the
|
|
* settings to be selected. Passing false for this value would
|
|
* cause the selection to clear or wrap around, depending on what
|
|
* value you passed for the aWrapAround parameter.
|
|
* @param {boolean} aWrapAround
|
|
* If true, the selection wraps around between the first and last
|
|
* buttons.
|
|
*/
|
|
advanceSelection(aForward, aIncludeNonEngineButtons, aWrapAround) {
|
|
let buttons = this.getSelectableButtons(aIncludeNonEngineButtons);
|
|
let index;
|
|
if (this.selectedButton) {
|
|
let inc = aForward ? 1 : -1;
|
|
let oldIndex = buttons.indexOf(this.selectedButton);
|
|
index = (oldIndex + inc + buttons.length) % buttons.length;
|
|
if (
|
|
!aWrapAround &&
|
|
((aForward && index <= oldIndex) || (!aForward && oldIndex <= index))
|
|
) {
|
|
// The index has wrapped around, but wrapping around isn't
|
|
// allowed.
|
|
index = -1;
|
|
}
|
|
} else {
|
|
index = aForward ? 0 : buttons.length - 1;
|
|
}
|
|
this.selectedButton = index < 0 ? null : buttons[index];
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* If this method handles the key press, then it will call
|
|
* event.preventDefault() and return true.
|
|
*
|
|
* @param {Event} event
|
|
* The key event.
|
|
* @param {number} 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 {boolean} 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 {string} [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.)
|
|
* @returns {boolean} True if the one-offs handled the key press.
|
|
*/
|
|
handleKeyDown(event, numListItems, allowEmptySelection, textboxUserValue) {
|
|
if (!this.hasView) {
|
|
return false;
|
|
}
|
|
let handled = this._handleKeyDown(
|
|
event,
|
|
numListItems,
|
|
allowEmptySelection,
|
|
textboxUserValue
|
|
);
|
|
if (handled) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
return handled;
|
|
}
|
|
|
|
_handleKeyDown(event, numListItems, allowEmptySelection, textboxUserValue) {
|
|
if (this.container.hidden) {
|
|
return false;
|
|
}
|
|
if (
|
|
event.keyCode == KeyEvent.DOM_VK_RIGHT &&
|
|
this.selectedButton &&
|
|
this.selectedButton.classList.contains("addengine-menu-button")
|
|
) {
|
|
// 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;
|
|
return true;
|
|
}
|
|
|
|
// Handle the Tab key, but only if non-Shift modifiers aren't also
|
|
// pressed to avoid clobbering other shortcuts (like the Alt+Tab
|
|
// browser tab switcher). The reason this uses getModifierState() and
|
|
// checks for "AltGraph" is that when you press Shift-Alt-Tab,
|
|
// event.altKey is actually false for some reason, at least on macOS.
|
|
// getModifierState("Alt") is also false, but "AltGraph" is true.
|
|
if (
|
|
event.keyCode == KeyEvent.DOM_VK_TAB &&
|
|
!event.getModifierState("Alt") &&
|
|
!event.getModifierState("AltGraph") &&
|
|
!event.getModifierState("Control") &&
|
|
!event.getModifierState("Meta")
|
|
) {
|
|
if (
|
|
this.getAttribute("disabletab") == "true" ||
|
|
(event.shiftKey && this.selectedButtonIndex <= 0) ||
|
|
(!event.shiftKey &&
|
|
this.selectedButtonIndex ==
|
|
this.getSelectableButtons(true).length - 1)
|
|
) {
|
|
this.selectedButton = null;
|
|
return false;
|
|
}
|
|
this.selectedViewIndex = -1;
|
|
this.advanceSelection(!event.shiftKey, true, false);
|
|
return !!this.selectedButton;
|
|
}
|
|
|
|
if (event.keyCode == KeyboardEvent.DOM_VK_UP) {
|
|
if (event.altKey) {
|
|
// Keep the currently selected result in the list (if any) as a
|
|
// secondary "alt" selection and move the selection up within the
|
|
// buttons.
|
|
this.advanceSelection(false, false, false);
|
|
return true;
|
|
}
|
|
if (numListItems == 0) {
|
|
this.advanceSelection(false, true, false);
|
|
return true;
|
|
}
|
|
if (this.selectedViewIndex > 0) {
|
|
// Moving up within the list. The autocomplete controller should
|
|
// handle this case. A button may be selected, so null it.
|
|
this.selectedButton = null;
|
|
return false;
|
|
}
|
|
if (this.selectedViewIndex == 0) {
|
|
// Moving up from the top of the list.
|
|
if (allowEmptySelection) {
|
|
// Let the autocomplete controller remove selection in the list
|
|
// and revert the typed text in the textbox.
|
|
return false;
|
|
}
|
|
// Wrap selection around to the last button.
|
|
if (this.textbox && typeof textboxUserValue == "string") {
|
|
this.textbox.value = textboxUserValue;
|
|
}
|
|
this.selectedViewIndex = -1;
|
|
this.advanceSelection(false, true, true);
|
|
return true;
|
|
}
|
|
if (!this.selectedButton) {
|
|
// Moving up from no selection in the list or the buttons, back
|
|
// down to the last button.
|
|
this.advanceSelection(false, true, true);
|
|
return true;
|
|
}
|
|
if (this.selectedButtonIndex == 0) {
|
|
// Moving up from the buttons to the bottom of the list.
|
|
this.selectedButton = null;
|
|
return false;
|
|
}
|
|
// Moving up/left within the buttons.
|
|
this.advanceSelection(false, true, false);
|
|
return true;
|
|
}
|
|
|
|
if (event.keyCode == KeyboardEvent.DOM_VK_DOWN) {
|
|
if (event.altKey) {
|
|
// Keep the currently selected result in the list (if any) as a
|
|
// secondary "alt" selection and move the selection down within
|
|
// the buttons.
|
|
this.advanceSelection(true, false, false);
|
|
return true;
|
|
}
|
|
if (numListItems == 0) {
|
|
this.advanceSelection(true, true, false);
|
|
return true;
|
|
}
|
|
if (
|
|
this.selectedViewIndex >= 0 &&
|
|
this.selectedViewIndex < numListItems - 1
|
|
) {
|
|
// Moving down within the list. The autocomplete controller
|
|
// should handle this case. A button may be selected, so null it.
|
|
this.selectedButton = null;
|
|
return false;
|
|
}
|
|
if (this.selectedViewIndex == numListItems - 1) {
|
|
// Moving down from the last item in the list to the buttons.
|
|
if (!allowEmptySelection) {
|
|
this.selectedViewIndex = -1;
|
|
if (this.textbox && typeof textboxUserValue == "string") {
|
|
this.textbox.value = textboxUserValue;
|
|
}
|
|
}
|
|
this.selectedButtonIndex = 0;
|
|
if (allowEmptySelection) {
|
|
// Let the autocomplete controller remove selection in the list
|
|
// and revert the typed text in the textbox.
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if (this.selectedButton) {
|
|
let buttons = this.getSelectableButtons(true);
|
|
if (this.selectedButtonIndex == buttons.length - 1) {
|
|
// Moving down from the buttons back up to the top of the list.
|
|
this.selectedButton = null;
|
|
if (allowEmptySelection) {
|
|
// Prevent the selection from wrapping around to the top of
|
|
// the list by returning true, since the list currently has no
|
|
// selection. Nothing should be selected after handling this
|
|
// Down key.
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
// Moving down/right within the buttons.
|
|
this.advanceSelection(true, true, false);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (event.keyCode == KeyboardEvent.DOM_VK_LEFT) {
|
|
if (
|
|
this.selectedButton &&
|
|
this.selectedButton.engine &&
|
|
!this.disableOneOffsHorizontalKeyNavigation
|
|
) {
|
|
// Moving left within the buttons.
|
|
this.advanceSelection(false, true, true);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (event.keyCode == KeyboardEvent.DOM_VK_RIGHT) {
|
|
if (
|
|
this.selectedButton &&
|
|
this.selectedButton.engine &&
|
|
!this.disableOneOffsHorizontalKeyNavigation
|
|
) {
|
|
// Moving right within the buttons.
|
|
this.advanceSelection(true, true, true);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Determines if the target of the event is a one-off button or
|
|
* context menu on a one-off button.
|
|
*
|
|
* @param {Event} event
|
|
* An event, like a click on a one-off button.
|
|
* @returns {boolean} True if telemetry was recorded and false if not.
|
|
*/
|
|
eventTargetIsAOneOff(event) {
|
|
if (!event) {
|
|
return false;
|
|
}
|
|
|
|
let target = event.originalTarget;
|
|
|
|
if (KeyboardEvent.isInstance(event) && this.selectedButton) {
|
|
return true;
|
|
}
|
|
if (
|
|
MouseEvent.isInstance(event) &&
|
|
target.classList.contains("searchbar-engine-one-off-item")
|
|
) {
|
|
return true;
|
|
}
|
|
if (
|
|
this.window.XULCommandEvent.isInstance(event) &&
|
|
target.classList.contains("search-one-offs-context-open-in-new-tab")
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Methods for subclasses to override
|
|
|
|
/**
|
|
* @returns {boolean} True if the one-offs are connected to a view.
|
|
*/
|
|
get hasView() {
|
|
return !!this.popup;
|
|
}
|
|
|
|
/**
|
|
* @returns {boolean} True if the view is open.
|
|
*/
|
|
get isViewOpen() {
|
|
return this.popup && this.popup.popupOpen;
|
|
}
|
|
|
|
/**
|
|
* @returns {number} The selected index in the view or -1 if no selection.
|
|
*/
|
|
get selectedViewIndex() {
|
|
return this.popup.selectedIndex;
|
|
}
|
|
|
|
/**
|
|
* Sets the selected index in the view.
|
|
*
|
|
* @param {number} val
|
|
* The selected index or -1 if no selection.
|
|
*/
|
|
set selectedViewIndex(val) {
|
|
this.popup.selectedIndex = val;
|
|
}
|
|
|
|
/**
|
|
* Closes the view.
|
|
*/
|
|
closeView() {
|
|
this.popup.hidePopup();
|
|
}
|
|
|
|
/**
|
|
* Called when a one-off is clicked or the "Search in New Tab" context menu
|
|
* item is picked. This is not called for the settings button.
|
|
*
|
|
* @param {event} event
|
|
* The event that triggered the pick.
|
|
* @param {nsISearchEngine|SearchEngine} engine
|
|
* The engine that was picked.
|
|
* @param {boolean} forceNewTab
|
|
* True if the search results page should be loaded in a new tab.
|
|
*/
|
|
handleSearchCommand(event, engine, forceNewTab = false) {
|
|
let { where, params } = this._whereToOpen(event, forceNewTab);
|
|
this.popup.handleOneOffSearch(event, engine, where, params);
|
|
}
|
|
|
|
/**
|
|
* Sets the tooltip for a one-off button with an engine. This should set
|
|
* either the `tooltiptext` attribute or the relevant l10n ID.
|
|
*
|
|
* @param {element} button
|
|
* The one-off button.
|
|
*/
|
|
setTooltipForEngineButton(button) {
|
|
button.setAttribute("tooltiptext", button.engine.name);
|
|
}
|
|
|
|
// Event handlers below.
|
|
|
|
_on_mousedown(event) {
|
|
// This is necessary to prevent the input from losing focus and closing the
|
|
// popup. Unfortunately it also has the side effect of preventing the
|
|
// buttons from receiving the `:active` pseudo-class.
|
|
event.preventDefault();
|
|
}
|
|
|
|
_on_click(event) {
|
|
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);
|
|
}
|
|
|
|
_on_command(event) {
|
|
let target = event.target;
|
|
|
|
if (target == this.settingsButton) {
|
|
this.window.openPreferences("paneSearch");
|
|
|
|
// If the preference tab was already selected, the panel doesn't
|
|
// close itself automatically.
|
|
this.closeView();
|
|
return;
|
|
}
|
|
|
|
if (target.classList.contains("searchbar-engine-one-off-add-engine")) {
|
|
// On success, hide the panel and tell event listeners to reshow it to
|
|
// show the new engine.
|
|
lazy.SearchUIUtils.addOpenSearchEngine(
|
|
target.getAttribute("uri"),
|
|
target.getAttribute("image"),
|
|
this.window.gBrowser.selectedBrowser.browsingContext
|
|
)
|
|
.then(result => {
|
|
if (result) {
|
|
this._rebuild();
|
|
}
|
|
})
|
|
.catch(console.error);
|
|
return;
|
|
}
|
|
|
|
if (target.classList.contains("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 = target.closest("menupopup")._triggerButton;
|
|
this.handleSearchCommand(event, this.selectedButton.engine, true);
|
|
}
|
|
|
|
const isPrivateButton = target.classList.contains(
|
|
"search-one-offs-context-set-default-private"
|
|
);
|
|
if (
|
|
target.classList.contains("search-one-offs-context-set-default") ||
|
|
isPrivateButton
|
|
) {
|
|
const engineType = isPrivateButton
|
|
? "defaultPrivateEngine"
|
|
: "defaultEngine";
|
|
let currentEngine = Services.search[engineType];
|
|
|
|
const isPrivateWin = lazy.PrivateBrowsingUtils.isWindowPrivate(
|
|
this.window
|
|
);
|
|
let button = target.closest("menupopup")._triggerButton;
|
|
// We're about to replace this, so it must be stored now.
|
|
let newDefaultEngine = button.engine;
|
|
if (
|
|
!this.getAttribute("includecurrentengine") &&
|
|
isPrivateButton == isPrivateWin
|
|
) {
|
|
// 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 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;
|
|
}
|
|
|
|
if (isPrivateButton) {
|
|
Services.search.setDefaultPrivate(
|
|
newDefaultEngine,
|
|
Ci.nsISearchService.CHANGE_REASON_USER_SEARCHBAR_CONTEXT
|
|
);
|
|
} else {
|
|
Services.search.setDefault(
|
|
newDefaultEngine,
|
|
Ci.nsISearchService.CHANGE_REASON_USER_SEARCHBAR_CONTEXT
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
_on_contextmenu(event) {
|
|
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("search-setting-button")
|
|
) {
|
|
event.preventDefault();
|
|
return;
|
|
}
|
|
this.contextMenuPopup
|
|
.querySelector(".search-one-offs-context-set-default")
|
|
.setAttribute(
|
|
"disabled",
|
|
target.engine == Services.search.defaultEngine.wrappedJSObject
|
|
);
|
|
|
|
const privateDefaultItem = this.contextMenuPopup.querySelector(
|
|
".search-one-offs-context-set-default-private"
|
|
);
|
|
|
|
if (
|
|
Services.prefs.getBoolPref(
|
|
"browser.search.separatePrivateDefault.ui.enabled",
|
|
false
|
|
) &&
|
|
Services.prefs.getBoolPref("browser.search.separatePrivateDefault", false)
|
|
) {
|
|
privateDefaultItem.hidden = false;
|
|
privateDefaultItem.setAttribute(
|
|
"disabled",
|
|
target.engine == Services.search.defaultPrivateEngine.wrappedJSObject
|
|
);
|
|
} else {
|
|
privateDefaultItem.hidden = true;
|
|
}
|
|
|
|
// When a context menu is opened on a one-off button, this is set to the
|
|
// button to be used for the command.
|
|
this.contextMenuPopup._triggerButton = target;
|
|
this.contextMenuPopup.openPopupAtScreen(event.screenX, event.screenY, true);
|
|
event.preventDefault();
|
|
}
|
|
|
|
_on_input(event) {
|
|
// 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;
|
|
}
|
|
|
|
_on_popupshowing() {
|
|
this._rebuild();
|
|
}
|
|
|
|
_on_popuphidden() {
|
|
this.selectedButton = null;
|
|
}
|
|
}
|