2018-03-06 03:52:07 +03:00
|
|
|
/* 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/. */
|
|
|
|
|
2018-03-08 18:54:53 +03:00
|
|
|
/* import-globals-from extensionControlled.js */
|
|
|
|
/* import-globals-from preferences.js */
|
2018-04-04 19:28:22 +03:00
|
|
|
/* import-globals-from main.js */
|
2019-07-05 10:53:32 +03:00
|
|
|
|
2018-03-08 18:54:53 +03:00
|
|
|
// HOME PAGE
|
2019-07-05 10:53:32 +03:00
|
|
|
|
2018-03-08 18:54:53 +03:00
|
|
|
/*
|
|
|
|
* Preferences:
|
|
|
|
*
|
|
|
|
* browser.startup.homepage
|
|
|
|
* - the user's home page, as a string; if the home page is a set of tabs,
|
|
|
|
* this will be those URLs separated by the pipe character "|"
|
|
|
|
* browser.newtabpage.enabled
|
|
|
|
* - determines that is shown on the user's new tab page.
|
|
|
|
* true = Activity Stream is shown,
|
|
|
|
* false = about:blank is shown
|
|
|
|
*/
|
|
|
|
|
|
|
|
Preferences.addAll([
|
|
|
|
{ id: "browser.startup.homepage", type: "wstring" },
|
|
|
|
{ id: "pref.browser.homepage.disable_button.current_page", type: "bool" },
|
|
|
|
{ id: "pref.browser.homepage.disable_button.bookmark_page", type: "bool" },
|
|
|
|
{ id: "pref.browser.homepage.disable_button.restore_default", type: "bool" },
|
|
|
|
{ id: "browser.newtabpage.enabled", type: "bool" },
|
|
|
|
]);
|
|
|
|
|
|
|
|
const HOMEPAGE_OVERRIDE_KEY = "homepage_override";
|
|
|
|
const URL_OVERRIDES_TYPE = "url_overrides";
|
|
|
|
const NEW_TAB_KEY = "newTabURL";
|
|
|
|
|
2018-07-03 21:02:26 +03:00
|
|
|
var gHomePane = {
|
2018-03-08 18:54:53 +03:00
|
|
|
HOME_MODE_FIREFOX_HOME: "0",
|
|
|
|
HOME_MODE_BLANK: "1",
|
|
|
|
HOME_MODE_CUSTOM: "2",
|
2019-04-23 21:30:07 +03:00
|
|
|
HOMEPAGE_PREF: "browser.startup.homepage",
|
2018-03-08 18:54:53 +03:00
|
|
|
NEWTAB_ENABLED_PREF: "browser.newtabpage.enabled",
|
2018-07-03 21:02:26 +03:00
|
|
|
ACTIVITY_STREAM_PREF_BRANCH: "browser.newtabpage.activity-stream.",
|
|
|
|
|
|
|
|
get homePanePrefs() {
|
|
|
|
return Preferences.getAll().filter(pref =>
|
|
|
|
pref.id.includes(this.ACTIVITY_STREAM_PREF_BRANCH)
|
|
|
|
);
|
|
|
|
},
|
2018-03-08 18:54:53 +03:00
|
|
|
|
2019-01-18 17:51:17 +03:00
|
|
|
get isPocketNewtabEnabled() {
|
|
|
|
const value = Services.prefs.getStringPref(
|
|
|
|
"browser.newtabpage.activity-stream.discoverystream.config",
|
|
|
|
""
|
|
|
|
);
|
|
|
|
if (value) {
|
|
|
|
try {
|
|
|
|
return JSON.parse(value).enabled;
|
|
|
|
} catch (e) {
|
|
|
|
console.error("Failed to parse Discovery Stream pref.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
|
2018-03-08 18:54:53 +03:00
|
|
|
/**
|
|
|
|
* _handleNewTabOverrides: disables new tab settings UI. Called by
|
|
|
|
* an observer in ._watchNewTab that watches for new tab url changes
|
|
|
|
*/
|
|
|
|
async _handleNewTabOverrides() {
|
|
|
|
const isControlled = await handleControllingExtension(
|
2018-04-18 01:31:50 +03:00
|
|
|
URL_OVERRIDES_TYPE,
|
|
|
|
NEW_TAB_KEY
|
|
|
|
);
|
2018-03-08 18:54:53 +03:00
|
|
|
const el = document.getElementById("newTabMode");
|
|
|
|
el.disabled = isControlled;
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* watchNewTab: Listen for changes to the new tab url and disable appropriate
|
|
|
|
* areas of the UI
|
|
|
|
*/
|
|
|
|
watchNewTab() {
|
|
|
|
this._handleNewTabOverrides();
|
|
|
|
let newTabObserver = {
|
|
|
|
observe: this._handleNewTabOverrides.bind(this),
|
|
|
|
};
|
|
|
|
Services.obs.addObserver(newTabObserver, "newtab-url-changed");
|
|
|
|
window.addEventListener("unload", () => {
|
|
|
|
Services.obs.removeObserver(newTabObserver, "newtab-url-changed");
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
2018-07-03 21:02:26 +03:00
|
|
|
/**
|
|
|
|
* Listen for all preferences changes on the Home Tab in order to show or
|
|
|
|
* hide the Restore Defaults button.
|
|
|
|
*/
|
|
|
|
watchHomeTabPrefChange() {
|
|
|
|
const observer = () => this.toggleRestoreDefaultsBtn();
|
|
|
|
Services.prefs.addObserver(this.ACTIVITY_STREAM_PREF_BRANCH, observer);
|
2019-04-23 21:30:07 +03:00
|
|
|
Services.prefs.addObserver(this.HOMEPAGE_PREF, observer);
|
2018-07-03 21:02:26 +03:00
|
|
|
Services.prefs.addObserver(this.NEWTAB_ENABLED_PREF, observer);
|
|
|
|
|
|
|
|
window.addEventListener("unload", () => {
|
|
|
|
Services.prefs.removeObserver(this.ACTIVITY_STREAM_PREF_BRANCH, observer);
|
2019-04-23 21:30:07 +03:00
|
|
|
Services.prefs.removeObserver(this.HOMEPAGE_PREF, observer);
|
2018-07-03 21:02:26 +03:00
|
|
|
Services.prefs.removeObserver(this.NEWTAB_ENABLED_PREF, observer);
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
2018-03-08 18:54:53 +03:00
|
|
|
/**
|
|
|
|
* _renderCustomSettings: Hides or shows the UI for setting a custom
|
|
|
|
* homepage URL
|
2018-04-04 19:28:22 +03:00
|
|
|
* @param {obj} options
|
|
|
|
* @param {bool} options.shouldShow Should the custom UI be shown?
|
|
|
|
* @param {bool} options.isControlled Is an extension controlling the home page?
|
2018-03-08 18:54:53 +03:00
|
|
|
*/
|
2018-04-04 19:28:22 +03:00
|
|
|
_renderCustomSettings(options = {}) {
|
|
|
|
let { shouldShow, isControlled } = options;
|
2018-03-08 18:54:53 +03:00
|
|
|
const customSettingsContainerEl = document.getElementById("customSettings");
|
|
|
|
const customUrlEl = document.getElementById("homePageUrl");
|
2019-04-23 21:30:07 +03:00
|
|
|
const homePage = HomePage.get();
|
2018-03-08 18:54:53 +03:00
|
|
|
|
2018-04-04 19:28:22 +03:00
|
|
|
const isHomePageCustom =
|
|
|
|
isControlled ||
|
|
|
|
(!this._isHomePageDefaultValue() && !this.isHomePageBlank());
|
|
|
|
if (typeof shouldShow === "undefined") {
|
|
|
|
shouldShow = isHomePageCustom;
|
|
|
|
}
|
2018-03-08 18:54:53 +03:00
|
|
|
customSettingsContainerEl.hidden = !shouldShow;
|
2018-04-04 19:28:22 +03:00
|
|
|
|
|
|
|
// We can't use isHomePageDefaultValue and isHomePageBlank here because we want to disregard the blank
|
|
|
|
// possibility triggered by the browser.startup.page being 0.
|
2019-04-23 21:30:07 +03:00
|
|
|
// We also skip when HomePage is locked because it might be locked to a default that isn't "about:home"
|
|
|
|
// (and it makes existing tests happy).
|
2018-04-04 19:28:22 +03:00
|
|
|
let newValue;
|
2019-04-23 21:30:07 +03:00
|
|
|
if (
|
|
|
|
homePage === "about:blank" ||
|
|
|
|
(HomePage.isDefault && !HomePage.locked)
|
|
|
|
) {
|
2018-04-04 19:28:22 +03:00
|
|
|
newValue = "";
|
2019-04-23 21:30:07 +03:00
|
|
|
} else {
|
|
|
|
newValue = homePage;
|
2018-04-04 19:28:22 +03:00
|
|
|
}
|
|
|
|
if (customUrlEl.value !== newValue) {
|
|
|
|
customUrlEl.value = newValue;
|
2018-03-08 18:54:53 +03:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _isHomePageDefaultValue
|
|
|
|
* @returns {bool} Is the homepage set to the default pref value?
|
|
|
|
*/
|
|
|
|
_isHomePageDefaultValue() {
|
2018-04-04 19:28:22 +03:00
|
|
|
const startupPref = Preferences.get("browser.startup.page");
|
2019-04-23 21:30:07 +03:00
|
|
|
return (
|
|
|
|
startupPref.value !== gMainPane.STARTUP_PREF_BLANK && HomePage.isDefault
|
|
|
|
);
|
2018-03-08 18:54:53 +03:00
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
2018-04-04 19:28:22 +03:00
|
|
|
* isHomePageBlank
|
2018-03-08 18:54:53 +03:00
|
|
|
* @returns {bool} Is the homepage set to about:blank?
|
|
|
|
*/
|
2018-04-04 19:28:22 +03:00
|
|
|
isHomePageBlank() {
|
|
|
|
const startupPref = Preferences.get("browser.startup.page");
|
2019-04-23 21:30:07 +03:00
|
|
|
return (
|
|
|
|
["about:blank", ""].includes(HomePage.get()) ||
|
|
|
|
startupPref.value === gMainPane.STARTUP_PREF_BLANK
|
|
|
|
);
|
2018-04-04 19:28:22 +03:00
|
|
|
},
|
|
|
|
/**
|
|
|
|
* isHomePageControlled
|
|
|
|
* @resolves {bool} Is the homepage being controlled by an extension?
|
|
|
|
* @returns {Promise}
|
|
|
|
*/
|
|
|
|
isHomePageControlled() {
|
2019-04-23 21:30:07 +03:00
|
|
|
if (HomePage.locked) {
|
2018-04-04 19:28:22 +03:00
|
|
|
return Promise.resolve(false);
|
|
|
|
}
|
2018-04-18 01:31:50 +03:00
|
|
|
return handleControllingExtension(PREF_SETTING_TYPE, HOMEPAGE_OVERRIDE_KEY);
|
2018-03-08 18:54:53 +03:00
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _isTabAboutPreferences: Is a given tab set to about:preferences?
|
|
|
|
* @param {Element} aTab A tab element
|
|
|
|
* @returns {bool} Is the linkedBrowser of aElement set to about:preferences?
|
|
|
|
*/
|
|
|
|
_isTabAboutPreferences(aTab) {
|
|
|
|
return aTab.linkedBrowser.currentURI.spec.startsWith("about:preferences");
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _getTabsForHomePage
|
|
|
|
* @returns {Array} An array of current tabs
|
|
|
|
*/
|
|
|
|
_getTabsForHomePage() {
|
|
|
|
let tabs = [];
|
|
|
|
let win = Services.wm.getMostRecentWindow("navigator:browser");
|
|
|
|
|
|
|
|
// We should only include visible & non-pinned tabs
|
|
|
|
if (
|
|
|
|
win &&
|
|
|
|
win.document.documentElement.getAttribute("windowtype") ===
|
|
|
|
"navigator:browser"
|
|
|
|
) {
|
|
|
|
tabs = win.gBrowser.visibleTabs.slice(win.gBrowser._numPinnedTabs);
|
|
|
|
tabs = tabs.filter(tab => !this._isTabAboutPreferences(tab));
|
|
|
|
// XXX: Bug 1441637 - Fix tabbrowser to report tab.closing before it blurs it
|
|
|
|
tabs = tabs.filter(tab => !tab.closing);
|
|
|
|
}
|
|
|
|
|
|
|
|
return tabs;
|
|
|
|
},
|
|
|
|
|
2018-04-04 19:28:22 +03:00
|
|
|
_renderHomepageMode(isControlled) {
|
2018-03-08 18:54:53 +03:00
|
|
|
const isDefault = this._isHomePageDefaultValue();
|
2018-04-04 19:28:22 +03:00
|
|
|
const isBlank = this.isHomePageBlank();
|
2018-03-08 18:54:53 +03:00
|
|
|
const el = document.getElementById("homeMode");
|
2018-04-04 19:28:22 +03:00
|
|
|
let newValue;
|
2018-03-08 18:54:53 +03:00
|
|
|
|
2018-04-04 19:28:22 +03:00
|
|
|
if (isControlled) {
|
|
|
|
newValue = this.HOME_MODE_CUSTOM;
|
|
|
|
} else if (isDefault) {
|
|
|
|
newValue = this.HOME_MODE_FIREFOX_HOME;
|
2018-03-08 18:54:53 +03:00
|
|
|
} else if (isBlank) {
|
2018-04-04 19:28:22 +03:00
|
|
|
newValue = this.HOME_MODE_BLANK;
|
2018-03-08 18:54:53 +03:00
|
|
|
} else {
|
2018-04-04 19:28:22 +03:00
|
|
|
newValue = this.HOME_MODE_CUSTOM;
|
|
|
|
}
|
|
|
|
if (el.value !== newValue) {
|
|
|
|
el.value = newValue;
|
2018-03-08 18:54:53 +03:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
_setInputDisabledStates(isControlled) {
|
|
|
|
let tabCount = this._getTabsForHomePage().length;
|
|
|
|
|
|
|
|
// Disable or enable the inputs based on if this is controlled by an extension.
|
|
|
|
document
|
|
|
|
.querySelectorAll(".check-home-page-controlled")
|
|
|
|
.forEach(element => {
|
|
|
|
let isDisabled;
|
|
|
|
let pref =
|
|
|
|
element.getAttribute("preference") ||
|
|
|
|
element.getAttribute("data-preference-related");
|
|
|
|
if (!pref) {
|
|
|
|
throw new Error(
|
2020-03-09 00:45:16 +03:00
|
|
|
`Element with id ${element.id} did not have preference or data-preference-related attribute defined.`
|
2018-03-08 18:54:53 +03:00
|
|
|
);
|
|
|
|
}
|
2019-04-23 21:30:07 +03:00
|
|
|
|
|
|
|
if (pref === this.HOMEPAGE_PREF) {
|
|
|
|
isDisabled = HomePage.locked || isControlled;
|
|
|
|
} else {
|
|
|
|
isDisabled = Preferences.get(pref).locked || isControlled;
|
|
|
|
}
|
2018-03-08 18:54:53 +03:00
|
|
|
|
|
|
|
if (pref === "pref.browser.disable_button.current_page") {
|
|
|
|
// Special case for current_page to disable it if tabCount is 0
|
|
|
|
isDisabled = isDisabled || tabCount < 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
element.disabled = isDisabled;
|
|
|
|
});
|
|
|
|
},
|
|
|
|
|
|
|
|
async _handleHomePageOverrides() {
|
2019-04-23 21:30:07 +03:00
|
|
|
if (HomePage.locked) {
|
2018-03-08 18:54:53 +03:00
|
|
|
// An extension can't control these settings if they're locked.
|
|
|
|
hideControllingExtension(HOMEPAGE_OVERRIDE_KEY);
|
|
|
|
this._setInputDisabledStates(false);
|
|
|
|
} else {
|
2018-04-04 19:28:22 +03:00
|
|
|
const isControlled = await this.isHomePageControlled();
|
|
|
|
this._setInputDisabledStates(isControlled);
|
|
|
|
this._renderCustomSettings({ isControlled });
|
|
|
|
this._renderHomepageMode(isControlled);
|
2018-03-08 18:54:53 +03:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
syncFromHomePref() {
|
|
|
|
this._updateUseCurrentButton();
|
|
|
|
this._renderCustomSettings();
|
|
|
|
this._renderHomepageMode();
|
|
|
|
this._handleHomePageOverrides();
|
|
|
|
},
|
|
|
|
|
|
|
|
syncFromNewTabPref() {
|
|
|
|
const newtabPref = Preferences.get(this.NEWTAB_ENABLED_PREF);
|
|
|
|
return newtabPref.value
|
|
|
|
? this.HOME_MODE_FIREFOX_HOME
|
|
|
|
: this.HOME_MODE_BLANK;
|
|
|
|
},
|
|
|
|
|
|
|
|
syncToNewTabPref(value) {
|
|
|
|
return value !== this.HOME_MODE_BLANK;
|
|
|
|
},
|
|
|
|
|
|
|
|
onMenuChange(event) {
|
|
|
|
const { value } = event.target;
|
2018-04-04 19:28:22 +03:00
|
|
|
const startupPref = Preferences.get("browser.startup.page");
|
|
|
|
|
2018-03-08 18:54:53 +03:00
|
|
|
switch (value) {
|
|
|
|
case this.HOME_MODE_FIREFOX_HOME:
|
2018-04-04 19:28:22 +03:00
|
|
|
if (startupPref.value === gMainPane.STARTUP_PREF_BLANK) {
|
|
|
|
startupPref.value = gMainPane.STARTUP_PREF_HOMEPAGE;
|
|
|
|
}
|
2019-04-23 21:30:07 +03:00
|
|
|
if (!HomePage.isDefault) {
|
|
|
|
HomePage.reset();
|
2018-03-08 18:54:53 +03:00
|
|
|
} else {
|
2018-04-04 19:28:22 +03:00
|
|
|
this._renderCustomSettings({ shouldShow: false });
|
2018-03-08 18:54:53 +03:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case this.HOME_MODE_BLANK:
|
2019-04-23 21:30:07 +03:00
|
|
|
if (HomePage.get() !== "about:blank") {
|
2019-08-06 00:52:59 +03:00
|
|
|
HomePage.safeSet("about:blank");
|
2018-03-08 18:54:53 +03:00
|
|
|
} else {
|
2018-04-04 19:28:22 +03:00
|
|
|
this._renderCustomSettings({ shouldShow: false });
|
2018-03-08 18:54:53 +03:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case this.HOME_MODE_CUSTOM:
|
2018-07-18 15:22:47 +03:00
|
|
|
if (startupPref.value === gMainPane.STARTUP_PREF_BLANK) {
|
|
|
|
Services.prefs.clearUserPref(startupPref.id);
|
|
|
|
}
|
2019-10-01 00:35:38 +03:00
|
|
|
if (HomePage.getDefault() != HomePage.getOriginalDefault()) {
|
|
|
|
HomePage.clear();
|
|
|
|
}
|
2018-04-04 19:28:22 +03:00
|
|
|
this._renderCustomSettings({ shouldShow: true });
|
2018-03-08 18:54:53 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Switches the "Use Current Page" button between its singular and plural
|
|
|
|
* forms.
|
|
|
|
*/
|
|
|
|
async _updateUseCurrentButton() {
|
|
|
|
let useCurrent = document.getElementById("useCurrentBtn");
|
|
|
|
let tabs = this._getTabsForHomePage();
|
|
|
|
const tabCount = tabs.length;
|
|
|
|
document.l10n.setAttributes(useCurrent, "use-current-pages", { tabCount });
|
|
|
|
|
|
|
|
// If the homepage is controlled by an extension then you can't use this.
|
|
|
|
if (
|
|
|
|
await getControllingExtensionInfo(
|
|
|
|
PREF_SETTING_TYPE,
|
|
|
|
HOMEPAGE_OVERRIDE_KEY
|
2019-07-05 10:53:32 +03:00
|
|
|
)
|
2018-03-08 18:54:53 +03:00
|
|
|
) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// In this case, the button's disabled state is set by preferences.xml.
|
|
|
|
let prefName = "pref.browser.homepage.disable_button.current_page";
|
2018-04-04 19:28:22 +03:00
|
|
|
if (Preferences.get(prefName).locked) {
|
2018-03-08 18:54:53 +03:00
|
|
|
return;
|
2018-04-04 19:28:22 +03:00
|
|
|
}
|
2018-03-08 18:54:53 +03:00
|
|
|
|
|
|
|
useCurrent.disabled = tabCount < 1;
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the home page to the URL(s) of any currently opened tab(s),
|
|
|
|
* updating about:preferences#home UI to reflect this.
|
|
|
|
*/
|
|
|
|
setHomePageToCurrent() {
|
|
|
|
let tabs = this._getTabsForHomePage();
|
|
|
|
function getTabURI(t) {
|
|
|
|
return t.linkedBrowser.currentURI.spec;
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME Bug 244192: using dangerous "|" joiner!
|
|
|
|
if (tabs.length) {
|
2019-08-06 00:52:59 +03:00
|
|
|
HomePage.set(tabs.map(getTabURI).join("|")).catch(Cu.reportError);
|
2018-03-08 18:54:53 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
Services.telemetry.scalarAdd("preferences.use_current_page", 1);
|
|
|
|
},
|
|
|
|
|
|
|
|
_setHomePageToBookmarkClosed(rv, aEvent) {
|
|
|
|
if (aEvent.detail.button != "accept") {
|
|
|
|
return;
|
2019-07-05 10:53:32 +03:00
|
|
|
}
|
2018-03-08 18:54:53 +03:00
|
|
|
if (rv.urls && rv.names) {
|
|
|
|
// XXX still using dangerous "|" joiner!
|
2019-08-06 00:52:59 +03:00
|
|
|
HomePage.set(rv.urls.join("|")).catch(Cu.reportError);
|
2018-03-08 18:54:53 +03:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Displays a dialog in which the user can select a bookmark to use as home
|
|
|
|
* page. If the user selects a bookmark, that bookmark's name is displayed in
|
|
|
|
* UI and the bookmark's address is stored to the home page preference.
|
|
|
|
*/
|
|
|
|
setHomePageToBookmark() {
|
|
|
|
const rv = { urls: null, names: null };
|
|
|
|
gSubDialog.open(
|
2020-04-23 02:35:08 +03:00
|
|
|
"chrome://browser/content/preferences/dialogs/selectBookmark.xhtml",
|
2020-09-02 17:24:47 +03:00
|
|
|
{
|
|
|
|
features: "resizable=yes, modal=yes",
|
|
|
|
closingCallback: this._setHomePageToBookmarkClosed.bind(this, rv),
|
|
|
|
},
|
|
|
|
rv
|
2018-03-08 18:54:53 +03:00
|
|
|
);
|
|
|
|
Services.telemetry.scalarAdd("preferences.use_bookmark", 1);
|
|
|
|
},
|
|
|
|
|
|
|
|
restoreDefaultHomePage() {
|
2019-04-23 21:30:07 +03:00
|
|
|
HomePage.reset();
|
2018-07-18 15:22:47 +03:00
|
|
|
Services.prefs.clearUserPref(this.NEWTAB_ENABLED_PREF);
|
2018-03-08 18:54:53 +03:00
|
|
|
},
|
|
|
|
|
|
|
|
onCustomHomePageInput(event) {
|
|
|
|
if (this._telemetryHomePageTimer) {
|
|
|
|
clearTimeout(this._telemetryHomePageTimer);
|
|
|
|
}
|
|
|
|
let browserHomePage = event.target.value;
|
|
|
|
// The length of the home page URL string should be more then four,
|
|
|
|
// and it should contain at least one ".", for example, "https://mozilla.org".
|
|
|
|
if (browserHomePage.length > 4 && browserHomePage.includes(".")) {
|
|
|
|
this._telemetryHomePageTimer = setTimeout(() => {
|
|
|
|
let homePageNumber = browserHomePage.split("|").length;
|
|
|
|
Services.telemetry.scalarAdd("preferences.browser_home_page_change", 1);
|
|
|
|
Services.telemetry.keyedScalarAdd(
|
|
|
|
"preferences.browser_home_page_count",
|
|
|
|
homePageNumber,
|
|
|
|
1
|
|
|
|
);
|
|
|
|
}, 3000);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
|
|
|
onCustomHomePageChange(event) {
|
2019-04-23 21:30:07 +03:00
|
|
|
const value = event.target.value || HomePage.getDefault();
|
2019-08-06 00:52:59 +03:00
|
|
|
HomePage.set(value).catch(Cu.reportError);
|
2018-03-08 18:54:53 +03:00
|
|
|
},
|
|
|
|
|
2018-07-03 21:02:26 +03:00
|
|
|
/**
|
|
|
|
* Check all Home Tab preferences for user set values.
|
|
|
|
*/
|
|
|
|
_changedHomeTabDefaultPrefs() {
|
2019-01-18 17:51:17 +03:00
|
|
|
// If Discovery Stream is enabled Firefox Home Content preference options are hidden
|
|
|
|
const homeContentChanged =
|
|
|
|
!this.isPocketNewtabEnabled &&
|
|
|
|
this.homePanePrefs.some(pref => pref.hasUserValue);
|
2018-07-03 21:02:26 +03:00
|
|
|
const newtabPref = Preferences.get(this.NEWTAB_ENABLED_PREF);
|
|
|
|
|
2019-04-23 21:30:07 +03:00
|
|
|
return homeContentChanged || HomePage.overridden || newtabPref.hasUserValue;
|
2018-07-03 21:02:26 +03:00
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Show the Restore Defaults button if any preference on the Home tab was
|
|
|
|
* changed, or hide it otherwise.
|
|
|
|
*/
|
|
|
|
toggleRestoreDefaultsBtn() {
|
|
|
|
const btn = document.getElementById("restoreDefaultHomePageBtn");
|
|
|
|
const prefChanged = this._changedHomeTabDefaultPrefs();
|
|
|
|
btn.style.visibility = prefChanged ? "visible" : "hidden";
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set all prefs on the Home tab back to their default values.
|
|
|
|
*/
|
|
|
|
restoreDefaultPrefsForHome() {
|
|
|
|
this.restoreDefaultHomePage();
|
2019-01-18 17:51:17 +03:00
|
|
|
// If Discovery Stream is enabled Firefox Home Content preference options are hidden
|
|
|
|
if (!this.isPocketNewtabEnabled) {
|
|
|
|
this.homePanePrefs.forEach(pref => Services.prefs.clearUserPref(pref.id));
|
|
|
|
}
|
2018-07-03 21:02:26 +03:00
|
|
|
},
|
|
|
|
|
2018-03-08 18:54:53 +03:00
|
|
|
init() {
|
|
|
|
// Event Listeners
|
|
|
|
document
|
|
|
|
.getElementById("homeMode")
|
|
|
|
.addEventListener("command", this.onMenuChange.bind(this));
|
|
|
|
document
|
|
|
|
.getElementById("homePageUrl")
|
|
|
|
.addEventListener("change", this.onCustomHomePageChange.bind(this));
|
|
|
|
document
|
|
|
|
.getElementById("homePageUrl")
|
|
|
|
.addEventListener("input", this.onCustomHomePageInput.bind(this));
|
|
|
|
document
|
|
|
|
.getElementById("useCurrentBtn")
|
|
|
|
.addEventListener("command", this.setHomePageToCurrent.bind(this));
|
|
|
|
document
|
|
|
|
.getElementById("useBookmarkBtn")
|
|
|
|
.addEventListener("command", this.setHomePageToBookmark.bind(this));
|
2018-07-03 21:02:26 +03:00
|
|
|
document
|
|
|
|
.getElementById("restoreDefaultHomePageBtn")
|
|
|
|
.addEventListener("command", this.restoreDefaultPrefsForHome.bind(this));
|
2018-03-08 18:54:53 +03:00
|
|
|
|
2019-07-11 12:37:59 +03:00
|
|
|
Preferences.addSyncFromPrefListener(
|
|
|
|
document.getElementById("homePrefHidden"),
|
|
|
|
() => this.syncFromHomePref()
|
|
|
|
);
|
|
|
|
Preferences.addSyncFromPrefListener(
|
|
|
|
document.getElementById("newTabMode"),
|
|
|
|
() => this.syncFromNewTabPref()
|
|
|
|
);
|
|
|
|
Preferences.addSyncToPrefListener(
|
|
|
|
document.getElementById("newTabMode"),
|
|
|
|
element => this.syncToNewTabPref(element.value)
|
|
|
|
);
|
|
|
|
|
2018-03-08 18:54:53 +03:00
|
|
|
this._updateUseCurrentButton();
|
|
|
|
window.addEventListener("focus", this._updateUseCurrentButton.bind(this));
|
|
|
|
|
|
|
|
// Extension/override-related events
|
|
|
|
this.watchNewTab();
|
|
|
|
document
|
|
|
|
.getElementById("disableHomePageExtension")
|
|
|
|
.addEventListener(
|
|
|
|
"command",
|
|
|
|
makeDisableControllingExtension(
|
|
|
|
PREF_SETTING_TYPE,
|
|
|
|
HOMEPAGE_OVERRIDE_KEY
|
2019-07-05 10:53:32 +03:00
|
|
|
)
|
2018-03-08 18:54:53 +03:00
|
|
|
);
|
|
|
|
document
|
|
|
|
.getElementById("disableNewTabExtension")
|
|
|
|
.addEventListener(
|
|
|
|
"command",
|
|
|
|
makeDisableControllingExtension(URL_OVERRIDES_TYPE, NEW_TAB_KEY)
|
|
|
|
);
|
2018-05-31 03:32:44 +03:00
|
|
|
|
2018-07-03 21:02:26 +03:00
|
|
|
this.watchHomeTabPrefChange();
|
2018-05-31 03:32:44 +03:00
|
|
|
// Notify observers that the UI is now ready
|
|
|
|
Services.obs.notifyObservers(window, "home-pane-loaded");
|
2018-03-08 18:54:53 +03:00
|
|
|
},
|
2018-03-06 03:52:07 +03:00
|
|
|
};
|