diff -r 000000000000 -r 6474c204b198 browser/components/preferences/advanced.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/browser/components/preferences/advanced.js Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,897 @@ +# -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- +# 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/. + +// Load DownloadUtils module for convertByteUnits +Components.utils.import("resource://gre/modules/DownloadUtils.jsm"); +Components.utils.import("resource://gre/modules/ctypes.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); +Components.utils.import("resource://gre/modules/LoadContextInfo.jsm"); +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); + +var gAdvancedPane = { + _inited: false, + + /** + * Brings the appropriate tab to the front and initializes various bits of UI. + */ + init: function () + { + this._inited = true; + var advancedPrefs = document.getElementById("advancedPrefs"); + + var extraArgs = window.arguments[1]; + if (extraArgs && extraArgs["advancedTab"]){ + advancedPrefs.selectedTab = document.getElementById(extraArgs["advancedTab"]); + } else { + var preference = document.getElementById("browser.preferences.advanced.selectedTabIndex"); + if (preference.value !== null) + advancedPrefs.selectedIndex = preference.value; + } + +#ifdef HAVE_SHELL_SERVICE + this.updateSetDefaultBrowser(); +#ifdef XP_WIN + // In Windows 8 we launch the control panel since it's the only + // way to get all file type association prefs. So we don't know + // when the user will select the default. We refresh here periodically + // in case the default changes. On other Windows OS's defaults can also + // be set while the prefs are open. + window.setInterval(this.updateSetDefaultBrowser, 1000); + +#ifdef MOZ_METRO + // Pre Windows 8, we should hide the update related settings + // for the Metro browser + let version = Components.classes["@mozilla.org/system-info;1"]. + getService(Components.interfaces.nsIPropertyBag2). + getProperty("version"); + let preWin8 = parseFloat(version) < 6.2; + this._showingWin8Prefs = !preWin8; + if (preWin8) { + ["autoMetro", "autoMetroIndent"].forEach( + function(id) document.getElementById(id).collapsed = true + ); + } else { + let brandShortName = + document.getElementById("bundleBrand").getString("brandShortName"); + let bundlePrefs = document.getElementById("bundlePreferences"); + let autoDesktop = document.getElementById("autoDesktop"); + autoDesktop.label = + bundlePrefs.getFormattedString("updateAutoDesktop.label", + [brandShortName]); + autoDesktop.accessKey = + bundlePrefs.getString("updateAutoDesktop.accessKey"); + } +#endif +#endif +#endif + +#ifdef MOZ_UPDATER + this.updateReadPrefs(); +#endif + this.updateOfflineApps(); +#ifdef MOZ_CRASHREPORTER + this.initSubmitCrashes(); +#endif + this.initTelemetry(); +#ifdef MOZ_SERVICES_HEALTHREPORT + this.initSubmitHealthReport(); +#endif + + this.updateActualCacheSize(); + this.updateActualAppCacheSize(); + + // Notify observers that the UI is now ready + Services.obs.notifyObservers(window, "advanced-pane-loaded", null); + }, + + /** + * Stores the identity of the current tab in preferences so that the selected + * tab can be persisted between openings of the preferences window. + */ + tabSelectionChanged: function () + { + if (!this._inited) + return; + var advancedPrefs = document.getElementById("advancedPrefs"); + var preference = document.getElementById("browser.preferences.advanced.selectedTabIndex"); + preference.valueFromPreferences = advancedPrefs.selectedIndex; + }, + + // GENERAL TAB + + /* + * Preferences: + * + * accessibility.browsewithcaret + * - true enables keyboard navigation and selection within web pages using a + * visible caret, false uses normal keyboard navigation with no caret + * accessibility.typeaheadfind + * - when set to true, typing outside text areas and input boxes will + * automatically start searching for what's typed within the current + * document; when set to false, no search action happens + * general.autoScroll + * - when set to true, clicking the scroll wheel on the mouse activates a + * mouse mode where moving the mouse down scrolls the document downward with + * speed correlated with the distance of the cursor from the original + * position at which the click occurred (and likewise with movement upward); + * if false, this behavior is disabled + * general.smoothScroll + * - set to true to enable finer page scrolling than line-by-line on page-up, + * page-down, and other such page movements + * layout.spellcheckDefault + * - an integer: + * 0 disables spellchecking + * 1 enables spellchecking, but only for multiline text fields + * 2 enables spellchecking for all text fields + */ + + /** + * Stores the original value of the spellchecking preference to enable proper + * restoration if unchanged (since we're mapping a tristate onto a checkbox). + */ + _storedSpellCheck: 0, + + /** + * Returns true if any spellchecking is enabled and false otherwise, caching + * the current value to enable proper pref restoration if the checkbox is + * never changed. + */ + readCheckSpelling: function () + { + var pref = document.getElementById("layout.spellcheckDefault"); + this._storedSpellCheck = pref.value; + + return (pref.value != 0); + }, + + /** + * Returns the value of the spellchecking preference represented by UI, + * preserving the preference's "hidden" value if the preference is + * unchanged and represents a value not strictly allowed in UI. + */ + writeCheckSpelling: function () + { + var checkbox = document.getElementById("checkSpelling"); + return checkbox.checked ? (this._storedSpellCheck == 2 ? 2 : 1) : 0; + }, + + /** + * When the user toggles the layers.acceleration.disabled pref, + * sync its new value to the gfx.direct2d.disabled pref too. + */ + updateHardwareAcceleration: function() + { +#ifdef XP_WIN + var fromPref = document.getElementById("layers.acceleration.disabled"); + var toPref = document.getElementById("gfx.direct2d.disabled"); + toPref.value = fromPref.value; +#endif + }, + + // DATA CHOICES TAB + + /** + * opening links behind a modal dialog is poor form. Work around flawed text-link handling here. + */ + openTextLink: function (evt) { + let where = Services.prefs.getBoolPref("browser.preferences.instantApply") ? "tab" : "window"; + openUILinkIn(evt.target.getAttribute("href"), where); + evt.preventDefault(); + }, + + /** + * Set up or hide the Learn More links for various data collection options + */ + _setupLearnMoreLink: function (pref, element) { + // set up the Learn More link with the correct URL + let url = Services.prefs.getCharPref(pref); + let el = document.getElementById(element); + + if (url) { + el.setAttribute("href", url); + } else { + el.setAttribute("hidden", "true"); + } + }, + + /** + * + */ + initSubmitCrashes: function () + { + var checkbox = document.getElementById("submitCrashesBox"); + try { + var cr = Components.classes["@mozilla.org/toolkit/crash-reporter;1"]. + getService(Components.interfaces.nsICrashReporter); + checkbox.checked = cr.submitReports; + } catch (e) { + checkbox.style.display = "none"; + } + this._setupLearnMoreLink("toolkit.crashreporter.infoURL", "crashReporterLearnMore"); + }, + + /** + * + */ + updateSubmitCrashes: function () + { + var checkbox = document.getElementById("submitCrashesBox"); + try { + var cr = Components.classes["@mozilla.org/toolkit/crash-reporter;1"]. + getService(Components.interfaces.nsICrashReporter); + cr.submitReports = checkbox.checked; + } catch (e) { } + }, + + + /** + * The preference/checkbox is configured in XUL. + * + * In all cases, set up the Learn More link sanely + */ + initTelemetry: function () + { +#ifdef MOZ_TELEMETRY_REPORTING + this._setupLearnMoreLink("toolkit.telemetry.infoURL", "telemetryLearnMore"); +#endif + }, + +#ifdef MOZ_SERVICES_HEALTHREPORT + /** + * Initialize the health report service reference and checkbox. + */ + initSubmitHealthReport: function () { + this._setupLearnMoreLink("datareporting.healthreport.infoURL", "FHRLearnMore"); + + let policy = Components.classes["@mozilla.org/datareporting/service;1"] + .getService(Components.interfaces.nsISupports) + .wrappedJSObject + .policy; + + let checkbox = document.getElementById("submitHealthReportBox"); + + if (!policy || policy.healthReportUploadLocked) { + checkbox.setAttribute("disabled", "true"); + return; + } + + checkbox.checked = policy.healthReportUploadEnabled; + }, + + /** + * Update the health report policy acceptance with state from checkbox. + */ + updateSubmitHealthReport: function () { + let policy = Components.classes["@mozilla.org/datareporting/service;1"] + .getService(Components.interfaces.nsISupports) + .wrappedJSObject + .policy; + + if (!policy) { + return; + } + + let checkbox = document.getElementById("submitHealthReportBox"); + policy.recordHealthReportUploadEnabled(checkbox.checked, + "Checkbox from preferences pane"); + }, +#endif + + // NETWORK TAB + + /* + * Preferences: + * + * browser.cache.disk.capacity + * - the size of the browser cache in KB + * - Only used if browser.cache.disk.smart_size.enabled is disabled + */ + + /** + * Displays a dialog in which proxy settings may be changed. + */ + showConnections: function () + { + document.documentElement.openSubDialog("chrome://browser/content/preferences/connection.xul", + "", null); + }, + + // Retrieves the amount of space currently used by disk cache + updateActualCacheSize: function () + { + var actualSizeLabel = document.getElementById("actualDiskCacheSize"); + var prefStrBundle = document.getElementById("bundlePreferences"); + + // Needs to root the observer since cache service keeps only a weak reference. + this.observer = { + onNetworkCacheDiskConsumption: function(consumption) { + var size = DownloadUtils.convertByteUnits(consumption); + actualSizeLabel.value = prefStrBundle.getFormattedString("actualDiskCacheSize", size); + }, + + QueryInterface: XPCOMUtils.generateQI([ + Components.interfaces.nsICacheStorageConsumptionObserver, + Components.interfaces.nsISupportsWeakReference + ]) + }; + + actualSizeLabel.value = prefStrBundle.getString("actualDiskCacheSizeCalculated"); + + var cacheService = + Components.classes["@mozilla.org/netwerk/cache-storage-service;1"] + .getService(Components.interfaces.nsICacheStorageService); + cacheService.asyncGetDiskConsumption(this.observer); + }, + + // Retrieves the amount of space currently used by offline cache + updateActualAppCacheSize: function () + { + var visitor = { + visitDevice: function (deviceID, deviceInfo) + { + if (deviceID == "offline") { + var actualSizeLabel = document.getElementById("actualAppCacheSize"); + var sizeStrings = DownloadUtils.convertByteUnits(deviceInfo.totalSize); + var prefStrBundle = document.getElementById("bundlePreferences"); + var sizeStr = prefStrBundle.getFormattedString("actualAppCacheSize", sizeStrings); + actualSizeLabel.value = sizeStr; + } + // Do not enumerate entries + return false; + }, + + visitEntry: function (deviceID, entryInfo) + { + // Do not enumerate entries. + return false; + } + }; + + var cacheService = + Components.classes["@mozilla.org/network/cache-service;1"] + .getService(Components.interfaces.nsICacheService); + cacheService.visitEntries(visitor); + }, + + updateCacheSizeUI: function (smartSizeEnabled) + { + document.getElementById("useCacheBefore").disabled = smartSizeEnabled; + document.getElementById("cacheSize").disabled = smartSizeEnabled; + document.getElementById("useCacheAfter").disabled = smartSizeEnabled; + }, + + readSmartSizeEnabled: function () + { + // The smart_size.enabled preference element is inverted="true", so its + // value is the opposite of the actual pref value + var disabled = document.getElementById("browser.cache.disk.smart_size.enabled").value; + this.updateCacheSizeUI(!disabled); + }, + + /** + * Converts the cache size from units of KB to units of MB and returns that + * value. + */ + readCacheSize: function () + { + var preference = document.getElementById("browser.cache.disk.capacity"); + return preference.value / 1024; + }, + + /** + * Converts the cache size as specified in UI (in MB) to KB and returns that + * value. + */ + writeCacheSize: function () + { + var cacheSize = document.getElementById("cacheSize"); + var intValue = parseInt(cacheSize.value, 10); + return isNaN(intValue) ? 0 : intValue * 1024; + }, + + /** + * Clears the cache. + */ + clearCache: function () + { + var cache = Components.classes["@mozilla.org/netwerk/cache-storage-service;1"] + .getService(Components.interfaces.nsICacheStorageService); + try { + cache.clear(); + } catch(ex) {} + this.updateActualCacheSize(); + }, + + /** + * Clears the application cache. + */ + clearOfflineAppCache: function () + { + Components.utils.import("resource:///modules/offlineAppCache.jsm"); + OfflineAppCacheHelper.clear(); + + this.updateActualAppCacheSize(); + this.updateOfflineApps(); + }, + + readOfflineNotify: function() + { + var pref = document.getElementById("browser.offline-apps.notify"); + var button = document.getElementById("offlineNotifyExceptions"); + button.disabled = !pref.value; + return pref.value; + }, + + showOfflineExceptions: function() + { + var bundlePreferences = document.getElementById("bundlePreferences"); + var params = { blockVisible : false, + sessionVisible : false, + allowVisible : false, + prefilledHost : "", + permissionType : "offline-app", + manageCapability : Components.interfaces.nsIPermissionManager.DENY_ACTION, + windowTitle : bundlePreferences.getString("offlinepermissionstitle"), + introText : bundlePreferences.getString("offlinepermissionstext") }; + document.documentElement.openWindow("Browser:Permissions", + "chrome://browser/content/preferences/permissions.xul", + "", params); + }, + + // XXX: duplicated in browser.js + _getOfflineAppUsage: function (host, groups) + { + var cacheService = Components.classes["@mozilla.org/network/application-cache-service;1"]. + getService(Components.interfaces.nsIApplicationCacheService); + if (!groups) + groups = cacheService.getGroups(); + + var ios = Components.classes["@mozilla.org/network/io-service;1"]. + getService(Components.interfaces.nsIIOService); + + var usage = 0; + for (var i = 0; i < groups.length; i++) { + var uri = ios.newURI(groups[i], null, null); + if (uri.asciiHost == host) { + var cache = cacheService.getActiveCache(groups[i]); + usage += cache.usage; + } + } + + return usage; + }, + + /** + * Updates the list of offline applications + */ + updateOfflineApps: function () + { + var pm = Components.classes["@mozilla.org/permissionmanager;1"] + .getService(Components.interfaces.nsIPermissionManager); + + var list = document.getElementById("offlineAppsList"); + while (list.firstChild) { + list.removeChild(list.firstChild); + } + + var cacheService = Components.classes["@mozilla.org/network/application-cache-service;1"]. + getService(Components.interfaces.nsIApplicationCacheService); + var groups = cacheService.getGroups(); + + var bundle = document.getElementById("bundlePreferences"); + + var enumerator = pm.enumerator; + while (enumerator.hasMoreElements()) { + var perm = enumerator.getNext().QueryInterface(Components.interfaces.nsIPermission); + if (perm.type == "offline-app" && + perm.capability != Components.interfaces.nsIPermissionManager.DEFAULT_ACTION && + perm.capability != Components.interfaces.nsIPermissionManager.DENY_ACTION) { + var row = document.createElement("listitem"); + row.id = ""; + row.className = "offlineapp"; + row.setAttribute("host", perm.host); + var converted = DownloadUtils. + convertByteUnits(this._getOfflineAppUsage(perm.host, groups)); + row.setAttribute("usage", + bundle.getFormattedString("offlineAppUsage", + converted)); + list.appendChild(row); + } + } + }, + + offlineAppSelected: function() + { + var removeButton = document.getElementById("offlineAppsListRemove"); + var list = document.getElementById("offlineAppsList"); + if (list.selectedItem) { + removeButton.setAttribute("disabled", "false"); + } else { + removeButton.setAttribute("disabled", "true"); + } + }, + + removeOfflineApp: function() + { + var list = document.getElementById("offlineAppsList"); + var item = list.selectedItem; + var host = item.getAttribute("host"); + + var prompts = Components.classes["@mozilla.org/embedcomp/prompt-service;1"] + .getService(Components.interfaces.nsIPromptService); + var flags = prompts.BUTTON_TITLE_IS_STRING * prompts.BUTTON_POS_0 + + prompts.BUTTON_TITLE_CANCEL * prompts.BUTTON_POS_1; + + var bundle = document.getElementById("bundlePreferences"); + var title = bundle.getString("offlineAppRemoveTitle"); + var prompt = bundle.getFormattedString("offlineAppRemovePrompt", [host]); + var confirm = bundle.getString("offlineAppRemoveConfirm"); + var result = prompts.confirmEx(window, title, prompt, flags, confirm, + null, null, null, {}); + if (result != 0) + return; + + // clear offline cache entries + var cacheService = Components.classes["@mozilla.org/network/application-cache-service;1"]. + getService(Components.interfaces.nsIApplicationCacheService); + var ios = Components.classes["@mozilla.org/network/io-service;1"]. + getService(Components.interfaces.nsIIOService); + var groups = cacheService.getGroups(); + for (var i = 0; i < groups.length; i++) { + var uri = ios.newURI(groups[i], null, null); + if (uri.asciiHost == host) { + var cache = cacheService.getActiveCache(groups[i]); + cache.discard(); + } + } + + // remove the permission + var pm = Components.classes["@mozilla.org/permissionmanager;1"] + .getService(Components.interfaces.nsIPermissionManager); + pm.remove(host, "offline-app", + Components.interfaces.nsIPermissionManager.ALLOW_ACTION); + pm.remove(host, "offline-app", + Components.interfaces.nsIOfflineCacheUpdateService.ALLOW_NO_WARN); + + list.removeChild(item); + gAdvancedPane.offlineAppSelected(); + this.updateActualAppCacheSize(); + }, + + // UPDATE TAB + + /* + * Preferences: + * + * app.update.enabled + * - true if updates to the application are enabled, false otherwise + * extensions.update.enabled + * - true if updates to extensions and themes are enabled, false otherwise + * browser.search.update + * - true if updates to search engines are enabled, false otherwise + * app.update.auto + * - true if updates should be automatically downloaded and installed, + * possibly with a warning if incompatible extensions are installed (see + * app.update.mode); false if the user should be asked what he wants to do + * when an update is available + * app.update.mode + * - an integer: + * 0 do not warn if an update will disable extensions or themes + * 1 warn if an update will disable extensions or themes + * 2 warn if an update will disable extensions or themes *or* if the + * update is a major update + */ + +#ifdef MOZ_UPDATER + /** + * Selects the item of the radiogroup, and sets the warnIncompatible checkbox + * based on the pref values and locked states. + * + * UI state matrix for update preference conditions + * + * UI Components: Preferences + * Radiogroup i = app.update.enabled + * Warn before disabling extensions checkbox ii = app.update.auto + * iii = app.update.mode + * + * Disabled states: + * Element pref value locked disabled + * radiogroup i t/f f false + * i t/f *t* *true* + * ii t/f f false + * ii t/f *t* *true* + * iii 0/1/2 t/f false + * warnIncompatible i t f false + * i t *t* *true* + * i *f* t/f *true* + * ii t f false + * ii t *t* *true* + * ii *f* t/f *true* + * iii 0/1/2 f false + * iii 0/1/2 *t* *true* + */ + updateReadPrefs: function () + { + var enabledPref = document.getElementById("app.update.enabled"); + var autoPref = document.getElementById("app.update.auto"); +#ifdef XP_WIN +#ifdef MOZ_METRO + var metroEnabledPref = document.getElementById("app.update.metro.enabled"); +#endif +#endif + var radiogroup = document.getElementById("updateRadioGroup"); + + if (!enabledPref.value) // Don't care for autoPref.value in this case. + radiogroup.value="manual"; // 3. Never check for updates. +#ifdef XP_WIN +#ifdef MOZ_METRO + // enabledPref.value && autoPref.value && metroEnabledPref.value + else if (metroEnabledPref.value && this._showingWin8Prefs) + radiogroup.value="autoMetro"; // 0. Automatically install updates for both Metro and Desktop +#endif +#endif + else if (autoPref.value) // enabledPref.value && autoPref.value + radiogroup.value="auto"; // 1. Automatically install updates for Desktop only + else // enabledPref.value && !autoPref.value + radiogroup.value="checkOnly"; // 2. Check, but let me choose + + var canCheck = Components.classes["@mozilla.org/updates/update-service;1"]. + getService(Components.interfaces.nsIApplicationUpdateService). + canCheckForUpdates; + // canCheck is false if the enabledPref is false and locked, + // or the binary platform or OS version is not known. + // A locked pref is sufficient to disable the radiogroup. + radiogroup.disabled = !canCheck || enabledPref.locked || autoPref.locked; + + var modePref = document.getElementById("app.update.mode"); + var warnIncompatible = document.getElementById("warnIncompatible"); + // the warnIncompatible checkbox value is set by readAddonWarn + warnIncompatible.disabled = radiogroup.disabled || modePref.locked || + !enabledPref.value || !autoPref.value; +#ifdef XP_WIN +#ifdef MOZ_METRO + if (this._showingWin8Prefs) { + warnIncompatible.disabled |= metroEnabledPref.value; + warnIncompatible.checked |= metroEnabledPref.value; + } +#endif +#endif + +#ifdef MOZ_MAINTENANCE_SERVICE + // Check to see if the maintenance service is installed. + // If it is don't show the preference at all. + var installed; + try { + var wrk = Components.classes["@mozilla.org/windows-registry-key;1"] + .createInstance(Components.interfaces.nsIWindowsRegKey); + wrk.open(wrk.ROOT_KEY_LOCAL_MACHINE, + "SOFTWARE\\Mozilla\\MaintenanceService", + wrk.ACCESS_READ | wrk.WOW64_64); + installed = wrk.readIntValue("Installed"); + wrk.close(); + } catch(e) { + } + if (installed != 1) { + document.getElementById("useService").hidden = true; + } + try { + const DRIVE_FIXED = 3; + const LPCWSTR = ctypes.jschar.ptr; + const UINT = ctypes.uint32_t; + let kernel32 = ctypes.open("kernel32"); + let GetDriveType = kernel32.declare("GetDriveTypeW", ctypes.default_abi, UINT, LPCWSTR); + var UpdatesDir = Components.classes["@mozilla.org/updates/update-service;1"]. + getService(Components.interfaces.nsIApplicationUpdateService); + let rootPath = UpdatesDir.getUpdatesDirectory(); + while (rootPath.parent != null) { + rootPath = rootPath.parent; + } + if (GetDriveType(rootPath.path) != DRIVE_FIXED) { + document.getElementById("useService").hidden = true; + } + kernel32.close(); + } catch(e) { + } +#endif + }, + + /** + * Sets the pref values based on the selected item of the radiogroup, + * and sets the disabled state of the warnIncompatible checkbox accordingly. + */ + updateWritePrefs: function () + { + var enabledPref = document.getElementById("app.update.enabled"); + var autoPref = document.getElementById("app.update.auto"); + var modePref = document.getElementById("app.update.mode"); +#ifdef XP_WIN +#ifdef MOZ_METRO + var metroEnabledPref = document.getElementById("app.update.metro.enabled"); + // Initialize the pref to false only if we're showing the option + if (this._showingWin8Prefs) { + metroEnabledPref.value = false; + } +#endif +#endif + var radiogroup = document.getElementById("updateRadioGroup"); + switch (radiogroup.value) { + case "auto": // 1. Automatically install updates for Desktop only + enabledPref.value = true; + autoPref.value = true; + break; +#ifdef XP_WIN +#ifdef MOZ_METRO + case "autoMetro": // 0. Automatically install updates for both Metro and Desktop + enabledPref.value = true; + autoPref.value = true; + metroEnabledPref.value = true; + modePref.value = 1; + break; +#endif +#endif + case "checkOnly": // 2. Check, but let me choose + enabledPref.value = true; + autoPref.value = false; + break; + case "manual": // 3. Never check for updates. + enabledPref.value = false; + autoPref.value = false; + } + + var warnIncompatible = document.getElementById("warnIncompatible"); + warnIncompatible.disabled = enabledPref.locked || !enabledPref.value || + autoPref.locked || !autoPref.value || + modePref.locked; + +#ifdef XP_WIN +#ifdef MOZ_METRO + if (this._showingWin8Prefs) { + warnIncompatible.disabled |= metroEnabledPref.value; + warnIncompatible.checked |= metroEnabledPref.value; + } +#endif +#endif + }, + + /** + * Stores the value of the app.update.mode preference, which is a tristate + * integer preference. We store the value here so that we can properly + * restore the preference value if the UI reflecting the preference value + * is in a state which can represent either of two integer values (as + * opposed to only one possible value in the other UI state). + */ + _modePreference: -1, + + /** + * Reads the app.update.mode preference and converts its value into a + * true/false value for use in determining whether the "Warn me if this will + * disable extensions or themes" checkbox is checked. We also save the value + * of the preference so that the preference value can be properly restored if + * the user's preferences cannot adequately be expressed by a single checkbox. + * + * app.update.mode Checkbox State Meaning + * 0 Unchecked Do not warn + * 1 Checked Warn if there are incompatibilities + * 2 Checked Warn if there are incompatibilities, + * or the update is major. + */ + readAddonWarn: function () + { + var preference = document.getElementById("app.update.mode"); + var warn = preference.value != 0; + gAdvancedPane._modePreference = warn ? preference.value : 1; + return warn; + }, + + /** + * Converts the state of the "Warn me if this will disable extensions or + * themes" checkbox into the integer preference which represents it, + * returning that value. + */ + writeAddonWarn: function () + { + var warnIncompatible = document.getElementById("warnIncompatible"); + return !warnIncompatible.checked ? 0 : gAdvancedPane._modePreference; + }, + + /** + * Displays the history of installed updates. + */ + showUpdates: function () + { + var prompter = Components.classes["@mozilla.org/updates/update-prompt;1"] + .createInstance(Components.interfaces.nsIUpdatePrompt); + prompter.showUpdateHistory(window); + }, +#endif + + // ENCRYPTION TAB + + /* + * Preferences: + * + * security.default_personal_cert + * - a string: + * "Select Automatically" select a certificate automatically when a site + * requests one + * "Ask Every Time" present a dialog to the user so he can select + * the certificate to use on a site which + * requests one + */ + + /** + * Displays the user's certificates and associated options. + */ + showCertificates: function () + { + document.documentElement.openWindow("mozilla:certmanager", + "chrome://pippki/content/certManager.xul", + "", null); + }, + + /** + * Displays a dialog in which OCSP preferences can be configured. + */ + showOCSP: function () + { + document.documentElement.openSubDialog("chrome://mozapps/content/preferences/ocsp.xul", + "", null); + }, + + /** + * Displays a dialog from which the user can manage his security devices. + */ + showSecurityDevices: function () + { + document.documentElement.openWindow("mozilla:devicemanager", + "chrome://pippki/content/device_manager.xul", + "", null); + } +#ifdef HAVE_SHELL_SERVICE + , + + // SYSTEM DEFAULTS + + /* + * Preferences: + * + * browser.shell.checkDefault + * - true if a default-browser check (and prompt to make it so if necessary) + * occurs at startup, false otherwise + */ + + /** + * Show button for setting browser as default browser or information that + * browser is already the default browser. + */ + updateSetDefaultBrowser: function() + { + let shellSvc = getShellService(); + let setDefaultPane = document.getElementById("setDefaultPane"); + if (!shellSvc) { + setDefaultPane.hidden = true; + document.getElementById("alwaysCheckDefault").disabled = true; + return; + } + let selectedIndex = + shellSvc.isDefaultBrowser(false, true) ? 1 : 0; + setDefaultPane.selectedIndex = selectedIndex; + }, + + /** + * Set browser as the operating system default browser. + */ + setDefaultBrowser: function() + { + let shellSvc = getShellService(); + if (!shellSvc) + return; + shellSvc.setDefaultBrowser(true, false); + let selectedIndex = + shellSvc.isDefaultBrowser(false, true) ? 1 : 0; + document.getElementById("setDefaultPane").selectedIndex = selectedIndex; + } +#endif +};