The Tor Browser / file revision

 # 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/.

 # Global Variables

 var helpBrowser;

 var helpSearchPanel;

 var emptySearch;

 var emptySearchText;

 var emptySearchLink = "about:blank";

 var helpTocPanel;

 var helpIndexPanel;

 var helpGlossaryPanel;

 var strBundle;

 var gTocDSList = "";

 # Namespaces

 const NC = "http://home.netscape.com/NC-rdf#";

 const MAX_LEVEL = 40; // maximum depth of recursion in search datasources.

 const MAX_HISTORY_MENU_ITEMS = 6;

 # ifdef logic ripped from toolkit/components/help/content/platformClasses.css

 #ifdef XP_WIN

 const platform = "win";

 #else

 #ifdef XP_MACOSX

 const platform = "mac";

 #else

 const platform = "unix";

 #endif

 #endif

 # Resources

 const RDF = Components.classes["@mozilla.org/rdf/rdf-service;1"]

     .getService(Components.interfaces.nsIRDFService);

 const RDF_ROOT = RDF.GetResource("urn:root");

 const NC_PANELLIST = RDF.GetResource(NC + "panellist");

 const NC_PANELID = RDF.GetResource(NC + "panelid");

 const NC_EMPTY_SEARCH_TEXT = RDF.GetResource(NC + "emptysearchtext");

 const NC_EMPTY_SEARCH_LINK = RDF.GetResource(NC + "emptysearchlink");

 const NC_DATASOURCES = RDF.GetResource(NC + "datasources");

 const NC_PLATFORM = RDF.GetResource(NC + "platform");

 const NC_SUBHEADINGS = RDF.GetResource(NC + "subheadings");

 const NC_NAME = RDF.GetResource(NC + "name");

 const NC_CHILD = RDF.GetResource(NC + "child");

 const NC_LINK = RDF.GetResource(NC + "link");

 const NC_TITLE = RDF.GetResource(NC + "title");

 const NC_BASE = RDF.GetResource(NC + "base");

 const NC_DEFAULTTOPIC = RDF.GetResource(NC + "defaulttopic");

 var RDFContainer =

    Components.classes["@mozilla.org/rdf/container;1"]

              .createInstance(Components.interfaces.nsIRDFContainer);

 const CONSOLE_SERVICE = Components.classes['@mozilla.org/consoleservice;1']

     .getService(Components.interfaces.nsIConsoleService);

 var RE;

 var helpFileURI;

 var helpFileDS;

 # Set from nc:base attribute on help rdf file. It may be used for prefix

 # reduction on all links within the current help set.

 var helpBaseURI;

 /* defaultTopic is either set

    1. in the openHelp() call, passed as an argument to the Help window and

       evaluated in init(), or

    2. in nc:defaulttopic in the content pack (e.g. firebirdhelp.rdf),

       evaluated in loadHelpRDF(), or

    3. "welcome" as a fallback, specified in loadHelpRDF() as well;

       displayTopic() then uses defaultTopic because topic is null. */

 var defaultTopic;

 const NSRESULT_RDF_SYNTAX_ERROR = 0x804e03f7;

 # This function is called by dialogs/windows that want to display

 # context-sensitive help

 # These dialogs/windows should include the script

 # chrome://help/content/contextHelp.js

 function displayTopic(topic) {

     // Get the page to open.

     var uri = getLink(topic);

     // Use default topic if specified topic is not found.

     if (!uri) {

         uri = getLink(defaultTopic);

     }

     // Load the page.

     if (uri)

       loadURI(uri);

 }

 # Initialize the Help window

 function init() {

   // Cache panel references.

   helpSearchPanel = document.getElementById("help-search-panel");

   helpTocPanel = document.getElementById("help-toc-panel");

   helpIndexPanel = document.getElementById("help-index-panel");

   helpGlossaryPanel = document.getElementById("help-glossary-panel");

   helpBrowser = document.getElementById("help-content");

   // Turn off unnecessary features for security

   helpBrowser.docShell.allowJavascript = false;

   helpBrowser.docShell.allowPlugins = false;

   helpBrowser.docShell.allowSubframes = false;

   helpBrowser.docShell.allowMetaRedirects = false;

   strBundle = document.getElementById("bundle_help");

   emptySearchText = strBundle.getString("emptySearchText");

   // Get the content pack, base URL, and help topic

   var helpTopic = defaultTopic;

   if ("arguments" in window && 

        window.arguments[0] instanceof Components.interfaces.nsIDialogParamBlock) {

     helpFileURI = window.arguments[0].GetString(0);

     // trailing "/" included.

     helpBaseURI = helpFileURI.substring(0, helpFileURI.lastIndexOf("/")+1);

     helpTopic = window.arguments[0].GetString(1);

   }

   loadHelpRDF();

   displayTopic(helpTopic);

   // Move to Center of Screen

   const width = document.documentElement.getAttribute("width");

   const height = document.documentElement.getAttribute("height");

   window.moveTo((screen.availWidth - width) / 2, (screen.availHeight - height) / 2);

   // Initialize history.

   getWebNavigation().sessionHistory = 

     Components.classes["@mozilla.org/browser/shistory;1"]

               .createInstance(Components.interfaces.nsISHistory);

   window.XULBrowserWindow = new nsHelpStatusHandler();

   //Start the status handler.

   window.XULBrowserWindow.init();

   // Hook up UI through Progress Listener

   const interfaceRequestor = helpBrowser.docShell.QueryInterface(Components.interfaces.nsIInterfaceRequestor);

   const webProgress = interfaceRequestor.getInterface(Components.interfaces.nsIWebProgress);

   webProgress.addProgressListener(window.XULBrowserWindow, Components.interfaces.nsIWebProgress.NOTIFY_ALL);

   var searchBox = document.getElementById("findText");

   searchBox.clickSelectsAll = getBoolPref("browser.urlbar.clickSelectsAll", true);

   setTimeout(focusSearch, 0);

 }

 function showSearchSidebar() {

   // if you tab too quickly, you end up with stuck focus, revert focus to the searchbar

   var searchTree = document.getElementById("help-toc-panel");

   if (searchTree.treeBoxObject.focused) {

     focusSearch();

   }

   var tableOfContents = document.getElementById("help-toc-sidebar");

   tableOfContents.setAttribute("hidden", "true");

   var sidebar = document.getElementById("help-search-sidebar");

   sidebar.removeAttribute("hidden");

 }

 function hideSearchSidebar(aEvent) {

   // if we're focused in the search results, focus content

   var searchTree = document.getElementById("help-search-tree");

   if (searchTree.treeBoxObject.focused) {

     content.focus();

   }

   var sidebar = document.getElementById("help-search-sidebar");

   sidebar.setAttribute("hidden", "true");

   var tableOfContents = document.getElementById("help-toc-sidebar");

   tableOfContents.removeAttribute("hidden");

 }

 # loadHelpRDF

 # Parse the provided help content pack RDF file, and use it to

 # populate the datasources attached to the trees in the viewer.

 # Filter out any information not applicable to the user's platform.

 function loadHelpRDF() {

   if (!helpFileDS) {

     try {

       helpFileDS = RDF.GetDataSourceBlocking(helpFileURI);

     } catch (e if (e.result == NSRESULT_RDF_SYNTAX_ERROR)) {

       log("Help file: " + helpFileURI + " contains a syntax error.");

     } catch (e) {

       log("Help file: " + helpFileURI + " was not found.");

     }

     try {

       document.title = getAttribute(helpFileDS, RDF_ROOT, NC_TITLE, "");

       helpBaseURI = getAttribute(helpFileDS, RDF_ROOT, NC_BASE, helpBaseURI);

       // if there's no nc:defaulttopic in the content pack, set "welcome"

       // as the default topic

       defaultTopic = getAttribute(helpFileDS,

         RDF_ROOT, NC_DEFAULTTOPIC, "welcome");

       var panelDefs = helpFileDS.GetTarget(RDF_ROOT, NC_PANELLIST, true);

       RDFContainer.Init(helpFileDS, panelDefs);

       var iterator = RDFContainer.GetElements();

       while (iterator.hasMoreElements()) {

         var panelDef = iterator.getNext();

         var panelID        = getAttribute(helpFileDS, panelDef, NC_PANELID, null);

         var datasources    = getAttribute(helpFileDS, panelDef, NC_DATASOURCES, "");

         var panelPlatforms = getAttribute(helpFileDS, panelDef, NC_PLATFORM, null);

         if (panelPlatforms && panelPlatforms.split(/\s+/).indexOf(platform) == -1)

           continue; // ignore datasources for other platforms

         // empty datasources are valid on search panel definitions

         // convert them to "rdf:null" which can be filtered and ignored

         if (!datasources)

           datasources = "rdf:null";

         datasources = normalizeLinks(helpBaseURI, datasources);

         var datasourceArray = datasources.split(/\s+/)

                                          .filter(function(x) { return x != "rdf:null"; })

                                          .map(RDF.GetDataSourceBlocking);

         // Cache Additional Datasources to Augment Search Datasources.

         if (panelID == "search") {

           emptySearchText = getAttribute(helpFileDS, panelDef, NC_EMPTY_SEARCH_TEXT, emptySearchText);

           emptySearchLink = getAttribute(helpFileDS, panelDef, NC_EMPTY_SEARCH_LINK, emptySearchLink);

           datasourceArray.forEach(helpSearchPanel.database.AddDataSource,

                                   helpSearchPanel.database);

           if (!panelPlatforms)

             filterDatasourceByPlatform(helpSearchPanel.database);

           continue; // to next panel definition

         }

         // cache toc datasources list for use in getLink()

         if (panelID == "toc")

           gTocDSList += " " + datasources;

         var tree = document.getElementById("help-" + panelID + "-panel");

         // add each datasource to the current tree

         datasourceArray.forEach(tree.database.AddDataSource,

                                 tree.database);

         // filter and display the current tree

         if (!panelPlatforms)

           filterDatasourceByPlatform(tree.database);

         tree.builder.rebuild();

       }

     } catch (e) {

       log(e + "");

     }

   }

 }

 # filterDatasourceByPlatform

 # Remove statements for other platforms from a datasource.

 function filterDatasourceByPlatform(aDatasource) {

   filterNodeByPlatform(aDatasource, RDF_ROOT, 0);

 }

 # filterNodeByPlatform

 # Remove statements for other platforms from the provided datasource.

 function filterNodeByPlatform(aDatasource, aCurrentResource, aCurrentLevel) {

   if (aCurrentLevel > MAX_LEVEL) {

      log("Datasources over " + MAX_LEVEL + " levels deep are unsupported.");

      return;

   }

   // get the subheadings under aCurrentResource and filter them

   var nodes = aDatasource.GetTargets(aCurrentResource, NC_SUBHEADINGS, true);

   while (nodes.hasMoreElements()) {

     var node = nodes.getNext();

     node = node.QueryInterface(Components.interfaces.nsIRDFResource);

     // should we test for rdf:Seq here?  see also doFindOnDatasource

     filterSeqByPlatform(aDatasource, node, aCurrentLevel+1);

   }

 }

 # filterSeqByPlatform

 # Go through the children of aNode, if any, removing statements applicable

 # only on other platforms.

 function filterSeqByPlatform(aDatasource, aNode, aCurrentLevel) {

   // get nc:subheading children into an enumerator

   var RDFC = Components.classes["@mozilla.org/rdf/container;1"]

                        .createInstance(Components.interfaces.nsIRDFContainer);

   RDFC.Init(aDatasource, aNode);

   var targets = RDFC.GetElements();

   // process items in the rdf:Seq

   while (targets.hasMoreElements()) {

     var currentTarget = targets.getNext();

     // find out on which platforms this node is meaningful

     var nodePlatforms = getAttribute(aDatasource,

                                      currentTarget.QueryInterface(Components.interfaces.nsIRDFResource),

                                      NC_PLATFORM,

                                      platform);

     if (nodePlatforms.split(/\s+/).indexOf(platform) == -1) { // node is for another platform

       var currentNode = currentTarget.QueryInterface(Components.interfaces.nsIRDFNode);

       // "false" because we don't want to renumber elements in the container

       RDFC.RemoveElement(currentNode, false);

       // move to next node - ignore the children, because 1) they might be

       // needed elsewhere and 2) nodes not connected to RDF_ROOT are ignored

       continue;

     }

     // filter any children

     filterNodeByPlatform(aDatasource, currentTarget, aCurrentLevel+1);

   }

 }

 # Prepend helpBaseURI to list of space separated links if they don't start with

 # "chrome:"

 function normalizeLinks(helpBaseURI, links) {

   if (!helpBaseURI) {

     return links;

   }

   var ls = links.split(/\s+/);

   if (ls.length == 0) {

     return links;

   }

   for (var i=0; i < ls.length; ++i) {

     if (ls[i] == "")

       continue;

     if (ls[i].substr(0,7) != "chrome:" && ls[i].substr(0,4) != "rdf:")

       ls[i] = helpBaseURI + ls[i];

   }

   return ls.join(" ");

 }

 function getLink(ID) {

     if (!ID)

       return null;

     var tocDS = document.getElementById("help-toc-panel").database;

     if (!tocDS)

       return null;

     // URIs include both the ID part and the base file name,

     // so we need to check for a matching ID in each datasource

     var tocDSArray = gTocDSList.split(/\s+/)

                                .filter(function(x) { return x != "rdf:null"; });

     for (var i = 0; i < tocDSArray.length; i++) {

       var resource = RDF.GetResource(tocDSArray[i] + "#" + ID);

       var link = tocDS.GetTarget(resource, NC_LINK, true);

       if (!link)  // no such rdf:ID found

         continue;

       return link.QueryInterface(Components.interfaces.nsIRDFLiteral).Value;

     }

     return null;

 }

 # Called by contextHelp.js to determine if this window is displaying the

 # requested help file.

 function getHelpFileURI() {

     return helpFileURI;

 }

 function getBrowser() {

   return helpBrowser;

 }

 function getWebNavigation() {

   try {

     return helpBrowser.webNavigation;

   } catch (e)

   {

     return null;

   }

 }

 function loadURI(uri) {

     if (uri.substr(0,7) != "chrome:") {

         uri = helpBaseURI + uri;

     }

     getWebNavigation().loadURI(uri, Components.interfaces.nsIWebNavigation.LOAD_FLAGS_NONE,

         null, null, null);

 }

 function goBack() {

   try

   {

     getWebNavigation().goBack();

   } catch (e)

   {

   }

 }

 function goForward() {

     try

     {

       getWebNavigation().goForward();

     } catch(e)

     {

     }

 }

 function goHome() {

     // Load "Welcome" page

     displayTopic(defaultTopic);

 }

 function print() {

     try {

         _content.print();

     } catch (e) {

     }

 }

 function FillHistoryMenu(aParent, aMenu)

   {

     // Remove old entries if any

     deleteHistoryItems(aParent);

     var sessionHistory = getWebNavigation().sessionHistory;

     var count = sessionHistory.count;

     var index = sessionHistory.index;

     var end;

     var j;

     var entry;

     switch (aMenu)

       {

         case "back":

           end = (index > MAX_HISTORY_MENU_ITEMS) ? index - MAX_HISTORY_MENU_ITEMS : 0;

           if ((index - 1) < end) return false;

           for (j = index - 1; j >= end; j--)

             {

               entry = sessionHistory.getEntryAtIndex(j, false);

               if (entry)

                 createMenuItem(aParent, j, entry.title);

             }

           break;

         case "forward":

           end  = ((count-index) > MAX_HISTORY_MENU_ITEMS) ? index + MAX_HISTORY_MENU_ITEMS : count - 1;

           if ((index + 1) > end) return false;

           for (j = index + 1; j <= end; j++)

             {

               entry = sessionHistory.getEntryAtIndex(j, false);

               if (entry)

                 createMenuItem(aParent, j, entry.title);

             }

           break;

       }

     return true;

   }

 function createMenuItem( aParent, aIndex, aLabel)

   {

     var menuitem = document.createElement( "menuitem" );

     menuitem.setAttribute( "label", aLabel );

     menuitem.setAttribute( "index", aIndex );

     aParent.appendChild( menuitem );

   }

 function deleteHistoryItems(aParent)

 {

   var children = aParent.childNodes;

   for (var i = children.length - 1; i >= 0; --i)

     {

       var index = children[i].getAttribute("index");

       if (index)

         aParent.removeChild(children[i]);

     }

 }

 function createBackMenu(event) {

     return FillHistoryMenu(event.target, "back");

 }

 function createForwardMenu(event) {

     return FillHistoryMenu(event.target, "forward");

 }

 function gotoHistoryIndex(aEvent) {

     var index = aEvent.target.getAttribute("index");

     if (!index) {

         return false;

     }

     try {

         getWebNavigation().gotoIndex(index);

     } catch(ex) {

         return false;

     }

     return true;

 }

 function nsHelpStatusHandler() {

   this.init();

 }

 nsHelpStatusHandler.prototype = {

     onStateChange : function(aWebProgress, aRequest, aStateFlags, aStatus) {},

     onProgressChange : function(aWebProgress, aRequest, aCurSelfProgress,

         aMaxSelfProgress, aCurTotalProgress, aMaxTotalProgress) {},

     onStatusChange : function(aWebProgress, aRequest, aStatus, aMessage) {},

     onSecurityChange : function(aWebProgress, aRequest, state) {},

     onLocationChange : function(aWebProgress, aRequest, aLocation, aFlags) {

         UpdateBackForwardButtons();

     },

     QueryInterface : function(aIID) {

         if (aIID.equals(Components.interfaces.nsIWebProgressListener) ||

                 aIID.equals(Components.interfaces.nsISupportsWeakReference) ||

                 aIID.equals(Components.interfaces.nsIXULBrowserWindow) ||

                 aIID.equals(Components.interfaces.nsISupports)) {

             return this;

         }

         throw Components.results.NS_NOINTERFACE;

     },

     init : function() {},

     destroy : function() {},

     setJSStatus : function(status) {},

     setOverLink : function(link, context) {},

     onBeforeLinkTraversal: function(originalTarget, linkURI, linkNode, isAppTab) {}

 }

 function UpdateBackForwardButtons() {

     var backBroadcaster = document.getElementById("canGoBack");

     var forwardBroadcaster = document.getElementById("canGoForward");

     var webNavigation = getWebNavigation();

     // Avoid setting attributes on broadcasters if the value hasn't changed!

     // Remember, guys, setting attributes on elements is expensive!  They

     // get inherited into anonymous content, broadcast to other widgets, etc.!

     // Don't do it if the value hasn't changed! - dwh

     var backDisabled = (backBroadcaster.getAttribute("disabled") == "true");

     var forwardDisabled = (forwardBroadcaster.getAttribute("disabled") == "true");

     if (backDisabled == webNavigation.canGoBack) {

       if (backDisabled)

         backBroadcaster.removeAttribute("disabled");

       else

         backBroadcaster.setAttribute("disabled", true);

     }

     if (forwardDisabled == webNavigation.canGoForward) {

       if (forwardDisabled)

         forwardBroadcaster.removeAttribute("disabled");

       else

         forwardBroadcaster.setAttribute("disabled", true);

     }

 }

 function onselect_loadURI(tree) {

     try {

         var resource = tree.view.getResourceAtIndex(tree.currentIndex);

         var link = tree.database.GetTarget(resource, NC_LINK, true);

         if (link) {

             link = link.QueryInterface(Components.interfaces.nsIRDFLiteral);

             loadURI(link.Value);

         }

     } catch (e) {

     }// when switching between tabs a spurious row number is returned.

 }

 function focusSearch() {

   var searchBox = document.getElementById("findText");

   searchBox.focus();

 }

 # doFind - Searches the help files for what is located in findText and outputs into

 #        the find search tree.

 function doFind() {

     if (document.getElementById("help-search-sidebar").hidden)

       showSearchSidebar();

     var searchTree = document.getElementById("help-search-tree");

     var findText = document.getElementById("findText");

     // clear any previous results.

     clearDatabases(searchTree.database);

     // if the search string is empty or contains only whitespace, purge the results tree and return

     RE = findText.value.match(/\S+/g);

     if (!RE) {

       searchTree.builder.rebuild();

       hideSearchSidebar();

       return;

     }

     // compile the search string, which has already been split up above, into regexps

     for (var i=0; i < RE.length; ++i) {

       RE[i] = new RegExp(RE[i], "i");

     }

     emptySearch = true;

     // search TOC

     var resultsDS = Components.classes["@mozilla.org/rdf/datasource;1?name=in-memory-datasource"]

         .createInstance(Components.interfaces.nsIRDFDataSource);

     var sourceDS = helpTocPanel.database;

     doFindOnDatasource(resultsDS, sourceDS, RDF_ROOT, 0);

     // search glossary.

     sourceDS = helpGlossaryPanel.database;

     doFindOnDatasource(resultsDS, sourceDS, RDF_ROOT, 0);

     // search index

     sourceDS = helpIndexPanel.database;

     doFindOnDatasource(resultsDS, sourceDS, RDF_ROOT, 0);

     // search additional search datasources

     sourceDS = helpSearchPanel.database;

     doFindOnDatasource(resultsDS, sourceDS, RDF_ROOT, 0);

     if (emptySearch)

         assertSearchEmpty(resultsDS);

     // Add the datasource to the search tree

     searchTree.database.AddDataSource(resultsDS);

     searchTree.builder.rebuild();

 }

 function clearDatabases(compositeDataSource) {

     var enumDS = compositeDataSource.GetDataSources()

     while (enumDS.hasMoreElements()) {

         var ds = enumDS.getNext();

         compositeDataSource.RemoveDataSource(ds);

     }

 }

 function doFindOnDatasource(resultsDS, sourceDS, resource, level) {

     if (level > MAX_LEVEL) {

         try {

             log("Recursive reference to resource: " + resource.Value + ".");

         } catch (e) {

             log("Recursive reference to unknown resource.");

         }

         return;

     }

     // find all SUBHEADING children of current resource.

     var targets = sourceDS.GetTargets(resource, NC_SUBHEADINGS, true);

     while (targets.hasMoreElements()) {

         var target = targets.getNext();

         target = target.QueryInterface(Components.interfaces.nsIRDFResource);

         // The first child of a rdf:subheading should (must) be a rdf:seq.

         // Should we test for a SEQ here?

         doFindOnSeq(resultsDS, sourceDS, target, level+1);

     }

 }

 function doFindOnSeq(resultsDS, sourceDS, resource, level) {

     // load up an RDFContainer so we can access the contents of the current

     // rdf:seq.

     RDFContainer.Init(sourceDS, resource);

     var targets = RDFContainer.GetElements();

     while (targets.hasMoreElements()) {

         var target = targets.getNext();

         var link = sourceDS.GetTarget(target, NC_LINK, true);

         var name = sourceDS.GetTarget(target, NC_NAME, true);

         if (link &&

             name instanceof Components.interfaces.nsIRDFLiteral &&

             isMatch(name.Value)) {

             // we have found a search entry - add it to the results datasource.

             var urn = RDF.GetAnonymousResource();

             resultsDS.Assert(urn, NC_NAME, name, true);

             resultsDS.Assert(urn, NC_LINK, link, true);

             resultsDS.Assert(RDF_ROOT, NC_CHILD, urn, true);

             emptySearch = false;

         }

         // process any nested rdf:seq elements.

         doFindOnDatasource(resultsDS, sourceDS, target, level+1);

     }

 }

 function assertSearchEmpty(resultsDS) {

     var resSearchEmpty = RDF.GetResource("urn:emptySearch");

         resultsDS.Assert(RDF_ROOT,

             NC_CHILD,

                 resSearchEmpty,

                 true);

         resultsDS.Assert(resSearchEmpty,

             NC_NAME,

                 RDF.GetLiteral(emptySearchText),

                 true);

         resultsDS.Assert(resSearchEmpty,

                 NC_LINK,

                 RDF.GetLiteral(emptySearchLink),

                 true);

 }

 function isMatch(text) {

     for (var i=0; i < RE.length; ++i ) {

         if (!RE[i].test(text)) {

             return false;

         }

     }

     return true;

 }

 function getAttribute(datasource, resource, attributeResourceName,

         defaultValue) {

     var literal = datasource.GetTarget(resource, attributeResourceName, true);

     if (!literal) {

         return defaultValue;

     }

     return getLiteralValue(literal, defaultValue);

 }

 function getLiteralValue(literal, defaultValue) {

     if (literal) {

         literal = literal.QueryInterface(Components.interfaces.nsIRDFLiteral);

         if (literal) {

             return literal.Value;

         }

     }

     if (defaultValue) {

         return defaultValue;

     }

     return null;

 }

 # Write debug string to error console.

 function log(aText) {

     CONSOLE_SERVICE.logStringMessage(aText);

 }

 function getBoolPref (aPrefname, aDefault)

 {

   try { 

     var pref = Components.classes["@mozilla.org/preferences-service;1"]

                          .getService(Components.interfaces.nsIPrefBranch);

     return pref.getBoolPref(aPrefname);

   }

   catch(e) {

     return aDefault;

   }

 }

 # getXulWin - Returns the current Help window as a nsIXULWindow.

 function getXulWin()

 {

   window.QueryInterface(Components.interfaces.nsIInterfaceRequestor);

   var webnav = window.getInterface(Components.interfaces.nsIWebNavigation);

   var dsti = webnav.QueryInterface(Components.interfaces.nsIDocShellTreeItem);

   var treeowner = dsti.treeOwner;

   var ifreq = treeowner.QueryInterface(Components.interfaces.nsIInterfaceRequestor);

   return ifreq.getInterface(Components.interfaces.nsIXULWindow);

 }

 # toggleZLevel - Toggles whether or not the window will always appear on top. Because

 #   alwaysRaised is not supported on an OS other than Windows, this code will not

 #   appear in those builds.

 #

 #   element - The DOM node that persists the checked state.

 #ifdef XP_WIN

 #define HELP_ALWAYS_RAISED_TOGGLE

 #endif

 #ifdef HELP_ALWAYS_RAISED_TOGGLE

 function toggleZLevel(element)

 {

   var xulwin = getXulWin();

   // Now we can flip the zLevel, and set the attribute so that it persists correctly

   if (xulwin.zLevel > xulwin.normalZ) {

     xulwin.zLevel = xulwin.normalZ;

     element.setAttribute("checked", "false");

   } else {

     xulwin.zLevel = xulwin.raisedZ;

     element.setAttribute("checked", "true");

   }

 }

 #endif