38884687fe
p=me r=mnyromyr sr=neil SM-only patch git-svn-id: svn://10.0.0.236/trunk@247517 18797224-902f-48f8-a5cc-f745e15eee43
261 lines
9.7 KiB
JavaScript
261 lines
9.7 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 mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Gervase Markham <gerv@gerv.net>
|
|
* Tuukka Tolvanen <tt@lament.cjb.net>
|
|
* Stefan Borggraefe <Stefan.Borggraefe@gmx.de>
|
|
* Ben Goodger <ben@mozilla.org>
|
|
* Asaf Romano <mozilla.mano@sent.com>
|
|
* Ian Neal <iann_bugzilla@blueyonder.co.uk>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either of 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 gAllFonts = null;
|
|
var gFontEnumerator = null;
|
|
var gDisabled = false;
|
|
|
|
function GetFontEnumerator()
|
|
{
|
|
if (!gFontEnumerator)
|
|
{
|
|
gFontEnumerator = Components.classes["@mozilla.org/gfx/fontenumerator;1"]
|
|
.createInstance(Components.interfaces.nsIFontEnumerator);
|
|
}
|
|
return gFontEnumerator;
|
|
}
|
|
|
|
function BuildFontList(aLanguage, aFontType, aMenuList, aPreference)
|
|
{
|
|
var defaultFont = null;
|
|
// Load Font Lists
|
|
var fonts = GetFontEnumerator().EnumerateFonts(aLanguage, aFontType, {});
|
|
if (fonts.length)
|
|
{
|
|
defaultFont = GetFontEnumerator().getDefaultFont(aLanguage, aFontType);
|
|
}
|
|
else
|
|
{
|
|
fonts = GetFontEnumerator().EnumerateFonts(aLanguage, "", {});
|
|
if (fonts.length)
|
|
defaultFont = GetFontEnumerator().getDefaultFont(aLanguage, "");
|
|
}
|
|
|
|
if (!gAllFonts)
|
|
gAllFonts = GetFontEnumerator().EnumerateAllFonts({});
|
|
|
|
// Reset the list
|
|
while (aMenuList.hasChildNodes())
|
|
aMenuList.removeChild(aMenuList.firstChild);
|
|
|
|
// Build the UI for the Default Font and Fonts for this CSS type.
|
|
var popup = document.createElement("menupopup");
|
|
var separator;
|
|
if (fonts.length)
|
|
{
|
|
if (defaultFont)
|
|
{
|
|
var bundlePreferences = document.getElementById("bundlePreferences");
|
|
var label = bundlePreferences.getFormattedString("labelDefaultFont", [defaultFont]);
|
|
var menuitem = document.createElement("menuitem");
|
|
menuitem.setAttribute("label", label);
|
|
menuitem.setAttribute("value", ""); // Default Font has a blank value
|
|
popup.appendChild(menuitem);
|
|
|
|
separator = document.createElement("menuseparator");
|
|
popup.appendChild(separator);
|
|
}
|
|
|
|
for (var i = 0; i < fonts.length; ++i)
|
|
{
|
|
menuitem = document.createElement("menuitem");
|
|
menuitem.setAttribute("value", fonts[i]);
|
|
menuitem.setAttribute("label", fonts[i]);
|
|
popup.appendChild(menuitem);
|
|
}
|
|
}
|
|
|
|
// Build the UI for the remaining fonts.
|
|
if (gAllFonts.length > fonts.length)
|
|
{
|
|
// Both lists are sorted, and the Fonts-By-Type list is a subset of the
|
|
// All-Fonts list, so walk both lists side-by-side, skipping values we've
|
|
// already created menu items for.
|
|
|
|
if (fonts.length)
|
|
{
|
|
separator = document.createElement("menuseparator");
|
|
popup.appendChild(separator);
|
|
}
|
|
|
|
for (i = 0; i < gAllFonts.length; ++i)
|
|
{
|
|
if (fonts.lastIndexOf(gAllFonts[i], 0) == 0)
|
|
{
|
|
fonts.shift(); //Remove matched font from array
|
|
}
|
|
else
|
|
{
|
|
menuitem = document.createElement("menuitem");
|
|
menuitem.setAttribute("value", gAllFonts[i]);
|
|
menuitem.setAttribute("label", gAllFonts[i]);
|
|
popup.appendChild(menuitem);
|
|
}
|
|
}
|
|
}
|
|
aMenuList.appendChild(popup);
|
|
|
|
// Fully populated so re-enable menulist before setting preference,
|
|
// unless panel is locked.
|
|
if (!gDisabled)
|
|
aMenuList.disabled = false;
|
|
aMenuList.setAttribute("preference", aPreference.id);
|
|
aPreference.setElementValue(aMenuList);
|
|
}
|
|
|
|
function ReadFontLanguageGroup()
|
|
{
|
|
var prefs = [{format: "default", type: "string", element: "defaultFontType", fonttype: "" },
|
|
{format: "name.", type: "unichar", element: "serif", fonttype: "serif" },
|
|
{format: "name.", type: "unichar", element: "sans-serif", fonttype: "sans-serif"},
|
|
{format: "name.", type: "unichar", element: "monospace", fonttype: "monospace" },
|
|
{format: "name.", type: "unichar", element: "cursive", fonttype: "cursive" },
|
|
{format: "name.", type: "unichar", element: "fantasy", fonttype: "fantasy" },
|
|
{format: "name-list.", type: "unichar", element: null, fonttype: "serif" },
|
|
{format: "name-list.", type: "unichar", element: null, fonttype: "sans-serif"},
|
|
{format: "name-list.", type: "unichar", element: null, fonttype: "monospace" },
|
|
{format: "name-list.", type: "unichar", element: null, fonttype: "cursive" },
|
|
{format: "name-list.", type: "unichar", element: null, fonttype: "fantasy" },
|
|
{format: "size.variable", type: "int", element: "sizeVar", fonttype: "" },
|
|
{format: "size.fixed", type: "int", element: "sizeMono", fonttype: "" },
|
|
{format: "minimum-size", type: "int", element: "minSize", fonttype: "" }];
|
|
gDisabled = document.getElementById("browser.display.languageList").locked;
|
|
var fontLanguage = document.getElementById("font.language.group");
|
|
if (gDisabled)
|
|
fontLanguage.disabled = true;
|
|
var languageGroup = fontLanguage.value;
|
|
var preferences = document.getElementById("fonts_preferences");
|
|
for (var i = 0; i < prefs.length; ++i)
|
|
{
|
|
var name = "font."+ prefs[i].format + prefs[i].fonttype + "." + languageGroup;
|
|
var preference = document.getElementById(name);
|
|
if (!preference)
|
|
{
|
|
preference = document.createElement("preference");
|
|
preference.id = name;
|
|
preference.setAttribute("name", name);
|
|
preference.setAttribute("type", prefs[i].type);
|
|
preferences.appendChild(preference);
|
|
}
|
|
|
|
if (!prefs[i].element)
|
|
continue;
|
|
|
|
var element = document.getElementById(prefs[i].element);
|
|
if (element)
|
|
{
|
|
if (prefs[i].fonttype)
|
|
{
|
|
// Set an empty label so it does not jump when items are added.
|
|
element.setAttribute("label", "");
|
|
// Disable menulist for the moment.
|
|
element.disabled = true;
|
|
// Lazily populate font lists, each gets re-enabled at the end.
|
|
window.setTimeout(BuildFontList, 0, languageGroup,
|
|
prefs[i].fonttype, element, preference);
|
|
}
|
|
else
|
|
{
|
|
// Unless the panel is locked, make sure these elements are not
|
|
// disabled just in case they were in the last language group.
|
|
element.disabled = gDisabled;
|
|
element.setAttribute("preference", preference.id);
|
|
preference.setElementValue(element);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function ReadFontSelection(aElement)
|
|
{
|
|
// Determine the appropriate value to select, for the following cases:
|
|
// - there is no setting
|
|
// - the font selected by the user is no longer present (e.g. deleted from
|
|
// fonts folder)
|
|
var preference = document.getElementById(aElement.getAttribute("preference"));
|
|
if (preference.value)
|
|
{
|
|
var fontItems = aElement.getElementsByAttribute("value", preference.value);
|
|
|
|
// There is a setting that actually is in the list. Respect it.
|
|
if (fontItems.length)
|
|
return undefined;
|
|
}
|
|
|
|
var defaultValue = aElement.firstChild.firstChild.getAttribute("value");
|
|
var languagePref = document.getElementById("font.language.group");
|
|
preference = document.getElementById("font.name-list." + aElement.id + "." + languagePref.value);
|
|
if (!preference || !preference.hasUserValue)
|
|
return defaultValue;
|
|
|
|
var fontNames = preference.value.split(",");
|
|
|
|
for (var i = 0; i < fontNames.length; ++i)
|
|
{
|
|
var fontName = fontNames[i].replace(/^\s+|\s+$/g, "");
|
|
fontItems = aElement.getElementsByAttribute("value", fontName);
|
|
if (fontItems.length)
|
|
return fontItems[0].getAttribute("value");
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
function ReadFontPref(aElement, aDefaultValue)
|
|
{
|
|
// Check to see if preference value exists,
|
|
// if not return given default value.
|
|
var preference = document.getElementById(aElement.getAttribute("preference"));
|
|
return preference.value || aDefaultValue;
|
|
}
|
|
|
|
function ReadUseDocumentFonts()
|
|
{
|
|
var preference = document.getElementById("browser.display.use_document_fonts");
|
|
return preference.value == 1;
|
|
}
|
|
|
|
function WriteUseDocumentFonts(aUseDocumentFonts)
|
|
{
|
|
return aUseDocumentFonts.checked ? 1 : 0;
|
|
}
|