mirror of
https://github.com/rn10950/RetroZilla.git
synced 2024-09-19 11:40:21 +02:00
412 lines
14 KiB
JavaScript
412 lines
14 KiB
JavaScript
# -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
# ***** BEGIN LICENSE BLOCK *****
|
|
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
#
|
|
# The contents of this file are subject to the Mozilla Public License Version
|
|
# 1.1 (the "License"); you may not use this file except in compliance with
|
|
# the License. You may obtain a copy of the License at
|
|
# http://www.mozilla.org/MPL/
|
|
#
|
|
# Software distributed under the License is distributed on an "AS IS" basis,
|
|
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
# for the specific language governing rights and limitations under the
|
|
# License.
|
|
#
|
|
# The Original Code is the Firefox Preferences System.
|
|
#
|
|
# The Initial Developer of the Original Code is
|
|
# Ben Goodger.
|
|
# Portions created by the Initial Developer are Copyright (C) 2005
|
|
# the Initial Developer. All Rights Reserved.
|
|
#
|
|
# Contributor(s):
|
|
# Ben Goodger <ben@mozilla.org>
|
|
# Jeff Walden <jwalden+code@mit.edu>
|
|
#
|
|
# Alternatively, the contents of this file may be used under the terms of
|
|
# either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
# in which case the provisions of the GPL or the LGPL are applicable instead
|
|
# of those above. If you wish to allow use of your version of this file only
|
|
# under the terms of either the GPL or the LGPL, and not to allow others to
|
|
# use your version of this file under the terms of the MPL, indicate your
|
|
# decision by deleting the provisions above and replace them with the notice
|
|
# and other provisions required by the GPL or the LGPL. If you do not delete
|
|
# the provisions above, a recipient may use your version of this file under
|
|
# the terms of any one of the MPL, the GPL or the LGPL.
|
|
#
|
|
# ***** END LICENSE BLOCK *****
|
|
|
|
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 preference = document.getElementById("browser.preferences.advanced.selectedTabIndex");
|
|
if (preference.value === null)
|
|
return;
|
|
advancedPrefs.selectedIndex = preference.value;
|
|
|
|
this.updateAppUpdateItems();
|
|
this.updateAutoItems();
|
|
this.updateModeItems();
|
|
},
|
|
|
|
/**
|
|
* 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;
|
|
},
|
|
|
|
/**
|
|
* Shows a dialog in which the preferred language for web content may be set.
|
|
*/
|
|
showLanguages: function ()
|
|
{
|
|
document.documentElement.openSubDialog("chrome://browser/content/preferences/languages.xul",
|
|
"", null);
|
|
},
|
|
|
|
// NETWORK TAB
|
|
|
|
/*
|
|
* Preferences:
|
|
*
|
|
* browser.cache.disk.capacity
|
|
* - the size of the browser cache in KB
|
|
*/
|
|
|
|
/**
|
|
* Displays a dialog in which proxy settings may be changed.
|
|
*/
|
|
showConnections: function ()
|
|
{
|
|
document.documentElement.openSubDialog("chrome://browser/content/preferences/connection.xul",
|
|
"", null);
|
|
},
|
|
|
|
/**
|
|
* 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 / 1000;
|
|
},
|
|
|
|
/**
|
|
* 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 * 1000;
|
|
},
|
|
|
|
/**
|
|
* Clears the cache.
|
|
*/
|
|
clearCache: function ()
|
|
{
|
|
var cacheService = Components.classes["@mozilla.org/network/cache-service;1"]
|
|
.getService(Components.interfaces.nsICacheService);
|
|
try {
|
|
cacheService.evictEntries(Components.interfaces.nsICache.STORE_ANYWHERE);
|
|
} catch(ex) {}
|
|
},
|
|
|
|
// 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
|
|
*/
|
|
|
|
/**
|
|
* Enables and disables various UI preferences as necessary to reflect locked,
|
|
* disabled, and checked/unchecked states.
|
|
*
|
|
* UI state matrix for update preference conditions
|
|
*
|
|
* UI Components: Preferences
|
|
* 1 = Firefox checkbox i = app.update.enabled
|
|
* 2 = When updates for Firefox are found label ii = app.update.auto
|
|
* 3 = Automatic Radiogroup (Ask vs. Automatically) iii = app.update.mode
|
|
* 4 = Warn before disabling extensions checkbox
|
|
*
|
|
* States:
|
|
* Element p val locked Disabled
|
|
* 1 i t/f f false
|
|
* i t/f t true
|
|
* ii t/f t/f false
|
|
* iii 0/1/2 t/f false
|
|
* 2,3 i t t/f false
|
|
* i f t/f true
|
|
* ii t/f f false
|
|
* ii t/f t true
|
|
* iii 0/1/2 t/f false
|
|
* 4 i t t/f false
|
|
* i f t/f true
|
|
* ii t t/f false
|
|
* ii f t/f true
|
|
* iii 0/1/2 f false
|
|
* iii 0/1/2 t true
|
|
*
|
|
*/
|
|
updateAppUpdateItems: function ()
|
|
{
|
|
var aus =
|
|
Components.classes["@mozilla.org/updates/update-service;1"].
|
|
getService(Components.interfaces.nsIApplicationUpdateService);
|
|
|
|
var enabledPref = document.getElementById("app.update.enabled");
|
|
var enableAppUpdate = document.getElementById("enableAppUpdate");
|
|
|
|
enableAppUpdate.disabled = !aus.canUpdate || enabledPref.locked;
|
|
},
|
|
|
|
/**
|
|
* Enables/disables UI for "when updates are found" based on the values,
|
|
* and "locked" states of associated preferences.
|
|
*/
|
|
updateAutoItems: function ()
|
|
{
|
|
var enabledPref = document.getElementById("app.update.enabled");
|
|
var autoPref = document.getElementById("app.update.auto");
|
|
|
|
var updateModeLabel = document.getElementById("updateModeLabel");
|
|
var updateMode = document.getElementById("updateMode");
|
|
|
|
var disable = enabledPref.locked || !enabledPref.value ||
|
|
autoPref.locked;
|
|
updateModeLabel.disabled = updateMode.disabled = disable;
|
|
},
|
|
|
|
/**
|
|
* Enables/disables the "warn if incompatible extensions/themes exist" UI
|
|
* based on the values and "locked" states of various preferences.
|
|
*/
|
|
updateModeItems: function ()
|
|
{
|
|
var enabledPref = document.getElementById("app.update.enabled");
|
|
var autoPref = document.getElementById("app.update.auto");
|
|
var modePref = document.getElementById("app.update.mode");
|
|
|
|
var warnIncompatible = document.getElementById("warnIncompatible");
|
|
|
|
var disable = enabledPref.locked || !enabledPref.value || autoPref.locked ||
|
|
!autoPref.value || modePref.locked;
|
|
warnIncompatible.disabled = disable;
|
|
},
|
|
|
|
/**
|
|
* The Extensions checkbox and button are disabled only if the enable Addon
|
|
* update preference is locked.
|
|
*/
|
|
updateAddonUpdateUI: function ()
|
|
{
|
|
var enabledPref = document.getElementById("extensions.update.enabled");
|
|
var enableAddonUpdate = document.getElementById("enableAddonUpdate");
|
|
|
|
enableAddonUpdate.disabled = enabledPref.locked;
|
|
},
|
|
|
|
/**
|
|
* 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.modee 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 doNotWarn = preference.value != 0;
|
|
gAdvancedPane._modePreference = doNotWarn ? preference.value : 1;
|
|
return doNotWarn;
|
|
},
|
|
|
|
/**
|
|
* 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);
|
|
},
|
|
|
|
// ENCRYPTION TAB
|
|
|
|
/*
|
|
* Preferences:
|
|
*
|
|
* security.enable_ssl3
|
|
* - true if SSL 3 encryption is enabled, false otherwise
|
|
* security.enable_tls
|
|
* - true if TLS encryption is enabled, false otherwise
|
|
* 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 which describes the user's CRLs.
|
|
*/
|
|
showCRLs: function ()
|
|
{
|
|
document.documentElement.openWindow("Mozilla:CRLManager",
|
|
"chrome://pippki/content/crlManager.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);
|
|
}
|
|
};
|