diff options
Diffstat (limited to 'browser/components/preferences/search.js')
| -rw-r--r-- | browser/components/preferences/search.js | 1098 |
1 files changed, 1098 insertions, 0 deletions
diff --git a/browser/components/preferences/search.js b/browser/components/preferences/search.js new file mode 100644 index 0000000000..38d084ba10 --- /dev/null +++ b/browser/components/preferences/search.js @@ -0,0 +1,1098 @@ +/* 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/. */ + +/* import-globals-from extensionControlled.js */ +/* import-globals-from preferences.js */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + SearchUIUtils: "resource:///modules/SearchUIUtils.sys.mjs", +}); + +Preferences.addAll([ + { id: "browser.search.suggest.enabled", type: "bool" }, + { id: "browser.urlbar.suggest.searches", type: "bool" }, + { id: "browser.search.suggest.enabled.private", type: "bool" }, + { id: "browser.search.hiddenOneOffs", type: "unichar" }, + { id: "browser.search.widget.inNavBar", type: "bool" }, + { id: "browser.urlbar.showSearchSuggestionsFirst", type: "bool" }, + { id: "browser.urlbar.showSearchTerms.enabled", type: "bool" }, + { id: "browser.search.separatePrivateDefault", type: "bool" }, + { id: "browser.search.separatePrivateDefault.ui.enabled", type: "bool" }, +]); + +const ENGINE_FLAVOR = "text/x-moz-search-engine"; +const SEARCH_TYPE = "default_search"; +const SEARCH_KEY = "defaultSearch"; + +var gEngineView = null; + +var gSearchPane = { + init() { + gEngineView = new EngineView(new EngineStore()); + document.getElementById("engineList").view = gEngineView; + this.buildDefaultEngineDropDowns().catch(console.error); + + if ( + Services.policies && + !Services.policies.isAllowed("installSearchEngine") + ) { + document.getElementById("addEnginesBox").hidden = true; + } else { + let addEnginesLink = document.getElementById("addEngines"); + addEnginesLink.setAttribute("href", lazy.SearchUIUtils.searchEnginesURL); + } + + window.addEventListener("click", this); + window.addEventListener("command", this); + window.addEventListener("dragstart", this); + window.addEventListener("keypress", this); + window.addEventListener("select", this); + window.addEventListener("dblclick", this); + + Services.obs.addObserver(this, "browser-search-engine-modified"); + Services.obs.addObserver(this, "intl:app-locales-changed"); + window.addEventListener("unload", () => { + Services.obs.removeObserver(this, "browser-search-engine-modified"); + Services.obs.removeObserver(this, "intl:app-locales-changed"); + }); + + let suggestsPref = Preferences.get("browser.search.suggest.enabled"); + let urlbarSuggestsPref = Preferences.get("browser.urlbar.suggest.searches"); + let privateSuggestsPref = Preferences.get( + "browser.search.suggest.enabled.private" + ); + let updateSuggestionCheckboxes = this._updateSuggestionCheckboxes.bind( + this + ); + suggestsPref.on("change", updateSuggestionCheckboxes); + urlbarSuggestsPref.on("change", updateSuggestionCheckboxes); + let urlbarSuggests = document.getElementById("urlBarSuggestion"); + urlbarSuggests.addEventListener("command", () => { + urlbarSuggestsPref.value = urlbarSuggests.checked; + }); + let privateWindowCheckbox = document.getElementById( + "showSearchSuggestionsPrivateWindows" + ); + privateWindowCheckbox.addEventListener("command", () => { + privateSuggestsPref.value = privateWindowCheckbox.checked; + }); + + setEventListener( + "browserSeparateDefaultEngine", + "command", + this._onBrowserSeparateDefaultEngineChange.bind(this) + ); + setEventListener("openLocationBarPrivacyPreferences", "click", function( + event + ) { + if (event.button == 0) { + gotoPref("privacy-locationBar"); + } + }); + + this._initDefaultEngines(); + this._initShowSearchTermsCheckbox(); + this._updateSuggestionCheckboxes(); + this._showAddEngineButton(); + }, + + /** + * Initialize the default engine handling. This will hide the private default + * options if they are not enabled yet. + */ + _initDefaultEngines() { + this._separatePrivateDefaultEnabledPref = Preferences.get( + "browser.search.separatePrivateDefault.ui.enabled" + ); + + this._separatePrivateDefaultPref = Preferences.get( + "browser.search.separatePrivateDefault" + ); + + const checkbox = document.getElementById("browserSeparateDefaultEngine"); + checkbox.checked = !this._separatePrivateDefaultPref.value; + + this._updatePrivateEngineDisplayBoxes(); + + const listener = () => { + this._updatePrivateEngineDisplayBoxes(); + this.buildDefaultEngineDropDowns().catch(console.error); + }; + + this._separatePrivateDefaultEnabledPref.on("change", listener); + this._separatePrivateDefaultPref.on("change", listener); + }, + + _initShowSearchTermsCheckbox() { + let checkbox = document.getElementById("searchShowSearchTermCheckbox"); + + // Add Nimbus event to show/hide checkbox. + let onNimbus = () => { + checkbox.hidden = !UrlbarPrefs.get("showSearchTermsFeatureGate"); + }; + NimbusFeatures.urlbar.onUpdate(onNimbus); + + // Add observer of Search Bar preference as showSearchTerms + // can't be enabled/disabled while Search Bar is enabled. + let searchBarPref = Preferences.get("browser.search.widget.inNavBar"); + let updateCheckboxEnabled = () => { + checkbox.disabled = searchBarPref.value; + }; + searchBarPref.on("change", updateCheckboxEnabled); + + // Fire once to initialize. + onNimbus(); + updateCheckboxEnabled(); + + window.addEventListener("unload", () => { + NimbusFeatures.urlbar.off(onNimbus); + }); + }, + + _updatePrivateEngineDisplayBoxes() { + const separateEnabled = this._separatePrivateDefaultEnabledPref.value; + document.getElementById( + "browserSeparateDefaultEngine" + ).hidden = !separateEnabled; + + const separateDefault = this._separatePrivateDefaultPref.value; + + const vbox = document.getElementById("browserPrivateEngineSelection"); + vbox.hidden = !separateEnabled || !separateDefault; + }, + + _onBrowserSeparateDefaultEngineChange(event) { + this._separatePrivateDefaultPref.value = !event.target.checked; + }, + + _updateSuggestionCheckboxes() { + let suggestsPref = Preferences.get("browser.search.suggest.enabled"); + let permanentPB = Services.prefs.getBoolPref( + "browser.privatebrowsing.autostart" + ); + let urlbarSuggests = document.getElementById("urlBarSuggestion"); + let positionCheckbox = document.getElementById( + "showSearchSuggestionsFirstCheckbox" + ); + let privateWindowCheckbox = document.getElementById( + "showSearchSuggestionsPrivateWindows" + ); + + urlbarSuggests.disabled = !suggestsPref.value || permanentPB; + privateWindowCheckbox.disabled = !suggestsPref.value; + privateWindowCheckbox.checked = Preferences.get( + "browser.search.suggest.enabled.private" + ).value; + if (privateWindowCheckbox.disabled) { + privateWindowCheckbox.checked = false; + } + + let urlbarSuggestsPref = Preferences.get("browser.urlbar.suggest.searches"); + urlbarSuggests.checked = urlbarSuggestsPref.value; + if (urlbarSuggests.disabled) { + urlbarSuggests.checked = false; + } + + if (urlbarSuggests.checked) { + positionCheckbox.disabled = false; + // Update the checked state of the show-suggestions-first checkbox. Note + // that this does *not* also update its pref, it only checks the box. + positionCheckbox.checked = Preferences.get( + positionCheckbox.getAttribute("preference") + ).value; + } else { + positionCheckbox.disabled = true; + positionCheckbox.checked = false; + } + + let permanentPBLabel = document.getElementById( + "urlBarSuggestionPermanentPBLabel" + ); + permanentPBLabel.hidden = urlbarSuggests.hidden || !permanentPB; + }, + + _showAddEngineButton() { + let aliasRefresh = Services.prefs.getBoolPref( + "browser.urlbar.update2.engineAliasRefresh", + false + ); + if (aliasRefresh) { + let addButton = document.getElementById("addEngineButton"); + addButton.hidden = false; + } + }, + + /** + * Builds the default and private engines drop down lists. This is called + * each time something affects the list of engines. + */ + async buildDefaultEngineDropDowns() { + await this._buildEngineDropDown( + document.getElementById("defaultEngine"), + (await Services.search.getDefault()).name, + false + ); + + if (this._separatePrivateDefaultEnabledPref.value) { + await this._buildEngineDropDown( + document.getElementById("defaultPrivateEngine"), + (await Services.search.getDefaultPrivate()).name, + true + ); + } + }, + + /** + * Builds a drop down menu of search engines. + * + * @param {DOMMenuList} list + * The menu list element to attach the list of engines. + * @param {string} currentEngine + * The name of the current default engine. + * @param {boolean} isPrivate + * True if we are dealing with the default engine for private mode. + */ + async _buildEngineDropDown(list, currentEngine, isPrivate) { + // If the current engine isn't in the list any more, select the first item. + let engines = gEngineView._engineStore._engines; + if (!engines.length) { + return; + } + if (!engines.some(e => e.name == currentEngine)) { + currentEngine = engines[0].name; + } + + // Now clean-up and rebuild the list. + list.removeAllItems(); + gEngineView._engineStore._engines.forEach(e => { + let item = list.appendItem(e.name); + item.setAttribute( + "class", + "menuitem-iconic searchengine-menuitem menuitem-with-favicon" + ); + if (e.iconURI) { + item.setAttribute("image", e.iconURI.spec); + } + item.engine = e; + if (e.name == currentEngine) { + list.selectedItem = item; + } + }); + }, + + handleEvent(aEvent) { + switch (aEvent.type) { + case "dblclick": + if (aEvent.target.id == "engineChildren") { + let cell = aEvent.target.parentNode.getCellAt( + aEvent.clientX, + aEvent.clientY + ); + if (cell.col?.id == "engineKeyword") { + this.startEditingAlias(gEngineView.selectedIndex); + } + } + break; + case "click": + if ( + aEvent.target.id != "engineChildren" && + !aEvent.target.classList.contains("searchEngineAction") + ) { + let engineList = document.getElementById("engineList"); + // We don't want to toggle off selection while editing keyword + // so proceed only when the input field is hidden. + // We need to check that engineList.view is defined here + // because the "click" event listener is on <window> and the + // view might have been destroyed if the pane has been navigated + // away from. + if (engineList.inputField.hidden && engineList.view) { + let selection = engineList.view.selection; + if (selection.count > 0) { + selection.toggleSelect(selection.currentIndex); + } + engineList.blur(); + } + } + break; + case "command": + switch (aEvent.target.id) { + case "": + if ( + aEvent.target.parentNode && + aEvent.target.parentNode.parentNode + ) { + if (aEvent.target.parentNode.parentNode.id == "defaultEngine") { + gSearchPane.setDefaultEngine(); + } else if ( + aEvent.target.parentNode.parentNode.id == "defaultPrivateEngine" + ) { + gSearchPane.setDefaultPrivateEngine(); + } + } + break; + case "restoreDefaultSearchEngines": + gSearchPane.onRestoreDefaults(); + break; + case "removeEngineButton": + Services.search.removeEngine( + gEngineView.selectedEngine.originalEngine + ); + break; + case "addEngineButton": + gSubDialog.open( + "chrome://browser/content/preferences/dialogs/addEngine.xhtml", + { features: "resizable=no, modal=yes" } + ); + break; + } + break; + case "dragstart": + if (aEvent.target.id == "engineChildren") { + onDragEngineStart(aEvent); + } + break; + case "keypress": + if (aEvent.target.id == "engineList") { + gSearchPane.onTreeKeyPress(aEvent); + } + break; + case "select": + if (aEvent.target.id == "engineList") { + gSearchPane.onTreeSelect(); + } + break; + } + }, + + /** + * Handle when the app locale is changed. + */ + async appLocalesChanged() { + await document.l10n.ready; + await gEngineView.loadL10nNames(); + }, + + /** + * Update the default engine UI and engine tree view as appropriate when engine changes + * or locale changes occur. + * + * @param {Object} engine + * @param {string} data + */ + browserSearchEngineModified(engine, data) { + engine.QueryInterface(Ci.nsISearchEngine); + switch (data) { + case "engine-added": + gEngineView._engineStore.addEngine(engine); + gEngineView.rowCountChanged(gEngineView.lastEngineIndex, 1); + gSearchPane.buildDefaultEngineDropDowns(); + break; + case "engine-changed": + gSearchPane.buildDefaultEngineDropDowns(); + gEngineView._engineStore.updateEngine(engine); + gEngineView.invalidate(); + break; + case "engine-removed": + gSearchPane.remove(engine); + break; + case "engine-default": { + // If the user is going through the drop down using up/down keys, the + // dropdown may still be open (eg. on Windows) when engine-default is + // fired, so rebuilding the list unconditionally would get in the way. + let selectedEngine = document.getElementById("defaultEngine") + .selectedItem.engine; + if (selectedEngine.name != engine.name) { + gSearchPane.buildDefaultEngineDropDowns(); + } + break; + } + case "engine-default-private": { + if ( + this._separatePrivateDefaultEnabledPref.value && + this._separatePrivateDefaultPref.value + ) { + // If the user is going through the drop down using up/down keys, the + // dropdown may still be open (eg. on Windows) when engine-default is + // fired, so rebuilding the list unconditionally would get in the way. + const selectedEngine = document.getElementById("defaultPrivateEngine") + .selectedItem.engine; + if (selectedEngine.name != engine.name) { + gSearchPane.buildDefaultEngineDropDowns(); + } + } + break; + } + } + }, + + /** + * nsIObserver implementation. + */ + observe(subject, topic, data) { + switch (topic) { + case "intl:app-locales-changed": { + this.appLocalesChanged(); + break; + } + case "browser-search-engine-modified": { + this.browserSearchEngineModified(subject, data); + break; + } + } + }, + + onTreeSelect() { + document.getElementById( + "removeEngineButton" + ).disabled = !gEngineView.isEngineSelectedAndRemovable(); + }, + + onTreeKeyPress(aEvent) { + let index = gEngineView.selectedIndex; + let tree = document.getElementById("engineList"); + if (tree.hasAttribute("editing")) { + return; + } + + if (aEvent.charCode == KeyEvent.DOM_VK_SPACE) { + // Space toggles the checkbox. + let newValue = !gEngineView.getCellValue( + index, + tree.columns.getNamedColumn("engineShown") + ); + gEngineView.setCellValue( + index, + tree.columns.getFirstColumn(), + newValue.toString() + ); + // Prevent page from scrolling on the space key. + aEvent.preventDefault(); + } else { + let isMac = Services.appinfo.OS == "Darwin"; + if ( + (isMac && aEvent.keyCode == KeyEvent.DOM_VK_RETURN) || + (!isMac && aEvent.keyCode == KeyEvent.DOM_VK_F2) + ) { + this.startEditingAlias(index); + } else if ( + aEvent.keyCode == KeyEvent.DOM_VK_DELETE || + (isMac && + aEvent.shiftKey && + aEvent.keyCode == KeyEvent.DOM_VK_BACK_SPACE && + gEngineView.isEngineSelectedAndRemovable()) + ) { + // Delete and Shift+Backspace (Mac) removes selected engine. + Services.search.removeEngine(gEngineView.selectedEngine.originalEngine); + } + } + }, + + startEditingAlias(index) { + // Local shortcut aliases can't be edited. + if (gEngineView._getLocalShortcut(index)) { + return; + } + + let tree = document.getElementById("engineList"); + let engine = gEngineView._engineStore.engines[index]; + tree.startEditing(index, tree.columns.getLastColumn()); + tree.inputField.value = engine.alias || ""; + tree.inputField.select(); + }, + + async onRestoreDefaults() { + let num = await gEngineView._engineStore.restoreDefaultEngines(); + gEngineView.rowCountChanged(0, num); + gEngineView.invalidate(); + }, + + showRestoreDefaults(aEnable) { + document.getElementById("restoreDefaultSearchEngines").disabled = !aEnable; + }, + + remove(aEngine) { + let index = gEngineView._engineStore.removeEngine(aEngine); + if (!gEngineView.tree) { + // Only update the selection if it's visible in the UI. + return; + } + + gEngineView.rowCountChanged(index, -1); + gEngineView.invalidate(); + + gEngineView.selection.select(Math.min(index, gEngineView.rowCount - 1)); + gEngineView.ensureRowIsVisible(gEngineView.currentIndex); + + document.getElementById("engineList").focus(); + }, + + async editKeyword(aEngine, aNewKeyword) { + let keyword = aNewKeyword.trim(); + if (keyword) { + let eduplicate = false; + let dupName = ""; + + // Check for duplicates in Places keywords. + let bduplicate = !!(await PlacesUtils.keywords.fetch(keyword)); + + // Check for duplicates in changes we haven't committed yet + let engines = gEngineView._engineStore.engines; + let lc_keyword = keyword.toLocaleLowerCase(); + for (let engine of engines) { + if ( + engine.alias && + engine.alias.toLocaleLowerCase() == lc_keyword && + engine.name != aEngine.name + ) { + eduplicate = true; + dupName = engine.name; + break; + } + } + + // Notify the user if they have chosen an existing engine/bookmark keyword + if (eduplicate || bduplicate) { + let msgids = [{ id: "search-keyword-warning-title" }]; + if (eduplicate) { + msgids.push({ + id: "search-keyword-warning-engine", + args: { name: dupName }, + }); + } else { + msgids.push({ id: "search-keyword-warning-bookmark" }); + } + + let [dtitle, msg] = await document.l10n.formatValues(msgids); + + Services.prompt.alert(window, dtitle, msg); + return false; + } + } + + gEngineView._engineStore.changeEngine(aEngine, "alias", keyword); + gEngineView.invalidate(); + return true; + }, + + saveOneClickEnginesList() { + let hiddenList = []; + for (let engine of gEngineView._engineStore.engines) { + if (!engine.shown) { + hiddenList.push(engine.name); + } + } + Preferences.get("browser.search.hiddenOneOffs").value = hiddenList.join( + "," + ); + }, + + async setDefaultEngine() { + await Services.search.setDefault( + document.getElementById("defaultEngine").selectedItem.engine, + Ci.nsISearchService.CHANGE_REASON_USER + ); + if (ExtensionSettingsStore.getSetting(SEARCH_TYPE, SEARCH_KEY) !== null) { + ExtensionSettingsStore.select( + ExtensionSettingsStore.SETTING_USER_SET, + SEARCH_TYPE, + SEARCH_KEY + ); + } + }, + + async setDefaultPrivateEngine() { + await Services.search.setDefaultPrivate( + document.getElementById("defaultPrivateEngine").selectedItem.engine, + Ci.nsISearchService.CHANGE_REASON_USER + ); + }, +}; + +function onDragEngineStart(event) { + var selectedIndex = gEngineView.selectedIndex; + + // Local shortcut rows can't be dragged or re-ordered. + if (gEngineView._getLocalShortcut(selectedIndex)) { + event.preventDefault(); + return; + } + + var tree = document.getElementById("engineList"); + let cell = tree.getCellAt(event.clientX, event.clientY); + if (selectedIndex >= 0 && !gEngineView.isCheckBox(cell.row, cell.col)) { + event.dataTransfer.setData(ENGINE_FLAVOR, selectedIndex.toString()); + event.dataTransfer.effectAllowed = "move"; + } +} + +function EngineStore() { + let pref = Preferences.get("browser.search.hiddenOneOffs").value; + this.hiddenList = pref ? pref.split(",") : []; + + this._engines = []; + this._defaultEngines = []; + Promise.all([ + Services.search.getVisibleEngines(), + Services.search.getAppProvidedEngines(), + ]).then(([visibleEngines, defaultEngines]) => { + for (let engine of visibleEngines) { + this.addEngine(engine); + gEngineView.rowCountChanged(gEngineView.lastEngineIndex, 1); + } + this._defaultEngines = defaultEngines.map(this._cloneEngine, this); + gSearchPane.buildDefaultEngineDropDowns(); + + // check if we need to disable the restore defaults button + var someHidden = this._defaultEngines.some(e => e.hidden); + gSearchPane.showRestoreDefaults(someHidden); + }); +} +EngineStore.prototype = { + _engines: null, + _defaultEngines: null, + + get engines() { + return this._engines; + }, + set engines(val) { + this._engines = val; + }, + + _getIndexForEngine(aEngine) { + return this._engines.indexOf(aEngine); + }, + + _getEngineByName(aName) { + return this._engines.find(engine => engine.name == aName); + }, + + _cloneEngine(aEngine) { + var clonedObj = {}; + for (let i of ["id", "name", "alias", "iconURI", "hidden"]) { + clonedObj[i] = aEngine[i]; + } + clonedObj.originalEngine = aEngine; + clonedObj.shown = !this.hiddenList.includes(clonedObj.name); + return clonedObj; + }, + + // Callback for Array's some(). A thisObj must be passed to some() + _isSameEngine(aEngineClone) { + return aEngineClone.originalEngine == this.originalEngine; + }, + + addEngine(aEngine) { + this._engines.push(this._cloneEngine(aEngine)); + }, + + updateEngine(newEngine) { + let engineToUpdate = this._engines.findIndex( + e => e.originalEngine == newEngine + ); + if (engineToUpdate != -1) { + this.engines[engineToUpdate] = this._cloneEngine(newEngine); + } + }, + + moveEngine(aEngine, aNewIndex) { + if (aNewIndex < 0 || aNewIndex > this._engines.length - 1) { + throw new Error("ES_moveEngine: invalid aNewIndex!"); + } + var index = this._getIndexForEngine(aEngine); + if (index == -1) { + throw new Error("ES_moveEngine: invalid engine?"); + } + + if (index == aNewIndex) { + return Promise.resolve(); + } // nothing to do + + // Move the engine in our internal store + var removedEngine = this._engines.splice(index, 1)[0]; + this._engines.splice(aNewIndex, 0, removedEngine); + + return Services.search.moveEngine(aEngine.originalEngine, aNewIndex); + }, + + removeEngine(aEngine) { + if (this._engines.length == 1) { + throw new Error("Cannot remove last engine!"); + } + + let engineName = aEngine.name; + let index = this._engines.findIndex(element => element.name == engineName); + + if (index == -1) { + throw new Error("invalid engine?"); + } + + this._engines.splice(index, 1)[0]; + + if (aEngine.isAppProvided) { + gSearchPane.showRestoreDefaults(true); + } + gSearchPane.buildDefaultEngineDropDowns(); + return index; + }, + + async restoreDefaultEngines() { + var added = 0; + + for (var i = 0; i < this._defaultEngines.length; ++i) { + var e = this._defaultEngines[i]; + + // If the engine is already in the list, just move it. + if (this._engines.some(this._isSameEngine, e)) { + await this.moveEngine(this._getEngineByName(e.name), i); + } else { + // Otherwise, add it back to our internal store + + // The search service removes the alias when an engine is hidden, + // so clear any alias we may have cached before unhiding the engine. + e.alias = ""; + + this._engines.splice(i, 0, e); + let engine = e.originalEngine; + engine.hidden = false; + await Services.search.moveEngine(engine, i); + added++; + } + } + + // We can't do this as part of the loop above because the indices are + // used for moving engines. + let policyRemovedEngineNames = + Services.policies.getActivePolicies()?.SearchEngines?.Remove || []; + for (let engineName of policyRemovedEngineNames) { + let engine = Services.search.getEngineByName(engineName); + if (engine) { + try { + await Services.search.removeEngine(engine); + } catch (ex) { + // Engine might not exist + } + } + } + + Services.search.resetToAppDefaultEngine(); + gSearchPane.showRestoreDefaults(false); + gSearchPane.buildDefaultEngineDropDowns(); + return added; + }, + + changeEngine(aEngine, aProp, aNewValue) { + var index = this._getIndexForEngine(aEngine); + if (index == -1) { + throw new Error("invalid engine?"); + } + + this._engines[index][aProp] = aNewValue; + aEngine.originalEngine[aProp] = aNewValue; + }, + + reloadIcons() { + this._engines.forEach(function(e) { + e.iconURI = e.originalEngine.iconURI; + }); + }, +}; + +function EngineView(aEngineStore) { + this._engineStore = aEngineStore; + + UrlbarPrefs.addObserver(this); + + this.loadL10nNames(); +} + +EngineView.prototype = { + _engineStore: null, + tree: null, + + loadL10nNames() { + // This maps local shortcut sources to their l10n names. The names are needed + // by getCellText. Getting the names is async but getCellText is not, so we + // cache them here to retrieve them syncronously in getCellText. + this._localShortcutL10nNames = new Map(); + return document.l10n + .formatValues( + UrlbarUtils.LOCAL_SEARCH_MODES.map(mode => { + let name = UrlbarUtils.getResultSourceName(mode.source); + return { id: `urlbar-search-mode-${name}` }; + }) + ) + .then(names => { + for (let { source } of UrlbarUtils.LOCAL_SEARCH_MODES) { + this._localShortcutL10nNames.set(source, names.shift()); + } + // Invalidate the tree now that we have the names in case getCellText was + // called before name retrieval finished. + this.invalidate(); + }); + }, + + get lastEngineIndex() { + return this._engineStore.engines.length - 1; + }, + + get selectedIndex() { + var seln = this.selection; + if (seln.getRangeCount() > 0) { + var min = {}; + seln.getRangeAt(0, min, {}); + return min.value; + } + return -1; + }, + + get selectedEngine() { + return this._engineStore.engines[this.selectedIndex]; + }, + + // Helpers + rowCountChanged(index, count) { + if (this.tree) { + this.tree.rowCountChanged(index, count); + } + }, + + invalidate() { + this.tree?.invalidate(); + }, + + ensureRowIsVisible(index) { + this.tree.ensureRowIsVisible(index); + }, + + getSourceIndexFromDrag(dataTransfer) { + return parseInt(dataTransfer.getData(ENGINE_FLAVOR)); + }, + + isCheckBox(index, column) { + return column.id == "engineShown"; + }, + + isEngineSelectedAndRemovable() { + let defaultEngine = Services.search.defaultEngine; + let defaultPrivateEngine = Services.search.defaultPrivateEngine; + // We don't allow the last remaining engine to be removed, thus the + // `this.lastEngineIndex != 0` check. + // We don't allow the default engine to be removed. + return ( + this.selectedIndex != -1 && + this.lastEngineIndex != 0 && + !this._getLocalShortcut(this.selectedIndex) && + this.selectedEngine.name != defaultEngine.name && + this.selectedEngine.name != defaultPrivateEngine.name + ); + }, + + /** + * Returns the local shortcut corresponding to a tree row, or null if the row + * is not a local shortcut. + * + * @param {number} index + * The tree row index. + * @returns {object} + * The local shortcut object or null if the row is not a local shortcut. + */ + _getLocalShortcut(index) { + let engineCount = this._engineStore.engines.length; + if (index < engineCount) { + return null; + } + return UrlbarUtils.LOCAL_SEARCH_MODES[index - engineCount]; + }, + + /** + * Called by UrlbarPrefs when a urlbar pref changes. + * + * @param {string} pref + * The name of the pref relative to the browser.urlbar branch. + */ + onPrefChanged(pref) { + // If one of the local shortcut prefs was toggled, toggle its row's + // checkbox. + let parts = pref.split("."); + if (parts[0] == "shortcuts" && parts[1] && parts.length == 2) { + this.invalidate(); + } + }, + + // nsITreeView + get rowCount() { + return ( + this._engineStore.engines.length + UrlbarUtils.LOCAL_SEARCH_MODES.length + ); + }, + + getImageSrc(index, column) { + if (column.id == "engineName") { + let shortcut = this._getLocalShortcut(index); + if (shortcut) { + return shortcut.icon; + } + + if (this._engineStore.engines[index].iconURI) { + return this._engineStore.engines[index].iconURI.spec; + } + + if (window.devicePixelRatio > 1) { + return "chrome://browser/skin/search-engine-placeholder@2x.png"; + } + return "chrome://browser/skin/search-engine-placeholder.png"; + } + + return ""; + }, + + getCellText(index, column) { + if (column.id == "engineName") { + let shortcut = this._getLocalShortcut(index); + if (shortcut) { + return this._localShortcutL10nNames.get(shortcut.source) || ""; + } + return this._engineStore.engines[index].name; + } else if (column.id == "engineKeyword") { + let shortcut = this._getLocalShortcut(index); + if (shortcut) { + return shortcut.restrict; + } + return this._engineStore.engines[index].originalEngine.aliases.join(", "); + } + return ""; + }, + + setTree(tree) { + this.tree = tree; + }, + + canDrop(targetIndex, orientation, dataTransfer) { + var sourceIndex = this.getSourceIndexFromDrag(dataTransfer); + return ( + sourceIndex != -1 && + sourceIndex != targetIndex && + sourceIndex != targetIndex + orientation && + // Local shortcut rows can't be dragged or dropped on. + targetIndex < this._engineStore.engines.length + ); + }, + + async drop(dropIndex, orientation, dataTransfer) { + // Local shortcut rows can't be dragged or dropped on. This can sometimes + // be reached even though canDrop returns false for these rows. + if (this._engineStore.engines.length <= dropIndex) { + return; + } + + var sourceIndex = this.getSourceIndexFromDrag(dataTransfer); + var sourceEngine = this._engineStore.engines[sourceIndex]; + + const nsITreeView = Ci.nsITreeView; + if (dropIndex > sourceIndex) { + if (orientation == nsITreeView.DROP_BEFORE) { + dropIndex--; + } + } else if (orientation == nsITreeView.DROP_AFTER) { + dropIndex++; + } + + await this._engineStore.moveEngine(sourceEngine, dropIndex); + gSearchPane.showRestoreDefaults(true); + gSearchPane.buildDefaultEngineDropDowns(); + + // Redraw, and adjust selection + this.invalidate(); + this.selection.select(dropIndex); + }, + + selection: null, + getRowProperties(index) { + return ""; + }, + getCellProperties(index, column) { + if (column.id == "engineName") { + // For local shortcut rows, return the result source name so we can style + // the icons in CSS. + let shortcut = this._getLocalShortcut(index); + if (shortcut) { + return UrlbarUtils.getResultSourceName(shortcut.source); + } + } + return ""; + }, + getColumnProperties(column) { + return ""; + }, + isContainer(index) { + return false; + }, + isContainerOpen(index) { + return false; + }, + isContainerEmpty(index) { + return false; + }, + isSeparator(index) { + return false; + }, + isSorted(index) { + return false; + }, + getParentIndex(index) { + return -1; + }, + hasNextSibling(parentIndex, index) { + return false; + }, + getLevel(index) { + return 0; + }, + getCellValue(index, column) { + if (column.id == "engineShown") { + let shortcut = this._getLocalShortcut(index); + if (shortcut) { + return UrlbarPrefs.get(shortcut.pref); + } + return this._engineStore.engines[index].shown; + } + return undefined; + }, + toggleOpenState(index) {}, + cycleHeader(column) {}, + selectionChanged() {}, + cycleCell(row, column) {}, + isEditable(index, column) { + return ( + column.id != "engineName" && + (column.id == "engineShown" || !this._getLocalShortcut(index)) + ); + }, + setCellValue(index, column, value) { + if (column.id == "engineShown") { + let shortcut = this._getLocalShortcut(index); + if (shortcut) { + UrlbarPrefs.set(shortcut.pref, value == "true"); + this.invalidate(); + return; + } + this._engineStore.engines[index].shown = value == "true"; + gEngineView.invalidate(); + gSearchPane.saveOneClickEnginesList(); + } + }, + setCellText(index, column, value) { + if (column.id == "engineKeyword") { + gSearchPane + .editKeyword(this._engineStore.engines[index], value) + .then(valid => { + if (!valid) { + gSearchPane.startEditingAlias(index); + } + }); + } + }, +}; |