home *** CD-ROM | disk | FTP | other *** search
/ ftp.swcp.com / ftp.swcp.com.zip / ftp.swcp.com / mac / mozilla-macos9-1.3.1.sea.bin / Mozilla1.3.1 / Chrome / comm.jar / content / communicator / pref / pref-fonts.js < prev    next >
Text File  |  2003-06-08  |  25KB  |  642 lines
  1. /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: NPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Netscape Public License
  6.  * Version 1.1 (the "License"); you may not use this file except in
  7.  * compliance with the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/NPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org code.
  16.  *
  17.  * The Initial Developer of the Original Code is 
  18.  * Netscape Communications Corporation.
  19.  * Portions created by the Initial Developer are Copyright (C) 1998
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  *    Gervase Markham <gerv@gerv.net>
  24.  *    Tuukka Tolvanen <tt@lament.cjb.net>
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either the GNU General Public License Version 2 or later (the "GPL"), or 
  28.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the NPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the NPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40. try
  41.   {
  42.     var fontList = Components.classes["@mozilla.org/gfx/fontlist;1"].createInstance();
  43.     if (fontList)
  44.       fontList = fontList.QueryInterface(Components.interfaces.nsIFontList);
  45.  
  46.     var pref = Components.classes["@mozilla.org/preferences;1"].getService( Components.interfaces.nsIPref );
  47.   }
  48. catch(e)
  49.   {
  50.     dump("failed to get font list or pref object: "+e+" in pref-fonts.js\n");
  51.   }
  52.  
  53. var fontTypes   = ["serif", "sans-serif", "cursive", "fantasy", "monospace"];
  54. var variableSize, fixedSize, minSize, languageList;
  55. var languageData = [];
  56. var currentLanguage;
  57. var gPrefutilitiesBundle;
  58.  
  59. // manual data retrieval function for PrefWindow
  60. function GetFields()
  61.   {
  62.     var dataObject = parent.hPrefWindow.wsm.dataManager.pageData["chrome://communicator/content/pref/pref-fonts.xul"];
  63.  
  64.     // store data for language independent widgets
  65.     var lists = ["selectLangs", "proportionalFont"];
  66.     for( var i = 0; i < lists.length; i++ )
  67.       {
  68.         if( !( "dataEls" in dataObject ) )
  69.           dataObject.dataEls = [];
  70.         dataObject.dataEls[ lists[i] ] = [];
  71.         dataObject.dataEls[ lists[i] ].value = document.getElementById( lists[i] ).value;
  72.       }
  73.  
  74.    dataObject.defaultFont = document.getElementById( "proportionalFont" ).value;
  75.    dataObject.fontDPI = document.getElementById( "screenResolution" ).value;
  76.    dataObject.useDocFonts = document.getElementById( "browserUseDocumentFonts" ).checked ? 1 : 0;
  77.  
  78.     // save current state for language dependent fields and store
  79.     saveState();
  80.     dataObject.languageData = languageData;
  81.  
  82.     return dataObject;
  83.   }
  84.  
  85. // manual data setting function for PrefWindow
  86. function SetFields( aDataObject )
  87.   {
  88.     languageData = "languageData" in aDataObject ? aDataObject.languageData : languageData ;
  89.     currentLanguage = "currentLanguage" in aDataObject ? aDataObject.currentLanguage : null ;
  90.  
  91.     var lists = ["selectLangs", "proportionalFont"];
  92.     var prefvalue;
  93.     
  94.     for( var i = 0; i < lists.length; i++ )
  95.       {
  96.         var element = document.getElementById( lists[i] );
  97.         if( "dataEls" in aDataObject )
  98.           {
  99.             element.selectedItem = element.getElementsByAttribute( "value", aDataObject.dataEls[ lists[i] ].value )[0];
  100.           }
  101.         else
  102.           {
  103.             var prefstring = element.getAttribute( "prefstring" );
  104.             var preftype = element.getAttribute( "preftype" );
  105.             if( prefstring && preftype )
  106.               {
  107.                 prefvalue = parent.hPrefWindow.getPref( preftype, prefstring );
  108.                 element.selectedItem = element.getElementsByAttribute( "value", prefvalue )[0];
  109.               }
  110.           }
  111.       }
  112.  
  113.     var screenResolution = document.getElementById( "screenResolution" );
  114.     var resolution;
  115.     
  116.     if( "fontDPI" in aDataObject )
  117.       {
  118.         resolution = aDataObject.fontDPI;
  119.       }
  120.     else
  121.       {
  122.         prefvalue = parent.hPrefWindow.getPref( "int", "browser.display.screen_resolution" );
  123.         if( prefvalue != "!/!ERROR_UNDEFINED_PREF!/!" )
  124.             resolution = prefvalue;
  125.         else
  126.             resolution = 96; // If it all goes horribly wrong, fall back on 96.
  127.       }
  128.     
  129.     setResolution( resolution );
  130.     
  131.     if ( parent.hPrefWindow.getPrefIsLocked( "browser.display.screen_resolution" ) ) {
  132.         screenResolution.disabled = true;
  133.     }
  134.  
  135.     var useDocFontsCheckbox = document.getElementById( "browserUseDocumentFonts" );
  136.     if( "useDocFonts" in aDataObject && aDataObject.useDocFonts != undefined )
  137.       useDocFontsCheckbox.checked = aDataObject.useDocFonts ? true : false;
  138.     else
  139.       {
  140.         prefvalue = parent.hPrefWindow.getPref( "int", "browser.display.use_document_fonts" );
  141.         if( prefvalue != "!/!ERROR_UNDEFINED_PREF!/!" )
  142.           useDocFontsCheckbox.checked = prefvalue ? true : false ;
  143.       }
  144.     if ( parent.hPrefWindow.getPrefIsLocked( "browser.display.use_document_fonts" ) ) {
  145.         useDocFontsCheckbox.disabled = true;
  146.     }
  147.   }
  148.  
  149. function Startup()
  150.   {
  151.     variableSize = document.getElementById( "sizeVar" );
  152.     fixedSize    = document.getElementById( "sizeMono" );
  153.     minSize      = document.getElementById( "minSize" );
  154.     languageList = document.getElementById( "selectLangs" );
  155.  
  156.     gPrefutilitiesBundle = document.getElementById("bundle_prefutilities");
  157.  
  158.     // register our ok callback function
  159.     parent.hPrefWindow.registerOKCallbackFunc( saveFontPrefs );
  160.  
  161.     // eventually we should detect the default language and select it by default
  162.     selectLanguage();
  163.     
  164.     // Allow user to ask the OS for a DPI if we are under X or OS/2
  165.     if ((navigator.appVersion.indexOf("X11") != -1) || (navigator.appVersion.indexOf("OS/2") != -1))
  166.       {
  167.          document.getElementById( "systemResolution" ).removeAttribute( "hidden" ); 
  168.       }
  169.     
  170.     // Set up the labels for the standard issue resolutions
  171.     var resolution;
  172.     resolution = document.getElementById( "screenResolution" );
  173.  
  174.     // Set an attribute on the selected resolution item so we can fall back on
  175.     // it if an invalid selection is made (select "Other...", hit Cancel)
  176.     resolution.selectedItem.setAttribute("current", "true");
  177.  
  178.     var defaultResolution;
  179.     var otherResolution;
  180.  
  181.     // On OS/2, 120 is the default system resolution.
  182.     // 96 is valid, but used only for for 640x480.
  183.     if (navigator.appVersion.indexOf("OS/2") != -1)
  184.       {
  185.         defaultResolution = "120";
  186.         otherResolution = "96";
  187.         document.getElementById( "arbitraryResolution" ).setAttribute( "hidden", "true" ); 
  188.         document.getElementById( "resolutionSeparator" ).setAttribute( "hidden", "true" ); 
  189.       } else {
  190.         defaultResolution = "96";
  191.         otherResolution = "72";
  192.       }
  193.  
  194.     var dpi = resolution.getAttribute( "dpi" );
  195.     resolution = document.getElementById( "defaultResolution" );
  196.     resolution.setAttribute( "value", defaultResolution );
  197.     resolution.setAttribute( "label", dpi.replace(/\$val/, defaultResolution ) );
  198.     resolution = document.getElementById( "otherResolution" );
  199.     resolution.setAttribute( "value", otherResolution );
  200.     resolution.setAttribute( "label", dpi.replace(/\$val/, otherResolution ) );
  201.  
  202.     // Get the pref and set up the dialog appropriately. Startup is called
  203.     // after SetFields so we can't rely on that call to do the business.
  204.     var prefvalue = parent.hPrefWindow.getPref( "int", "browser.display.screen_resolution" );
  205.     if( prefvalue != "!/!ERROR_UNDEFINED_PREF!/!" )
  206.         resolution = prefvalue;
  207.     else
  208.         resolution = 96; // If it all goes horribly wrong, fall back on 96.
  209.     
  210.     setResolution( resolution );
  211.  
  212.     // This prefstring is a contrived pref whose sole purpose is to lock some
  213.     // elements in this panel.  The value of the pref is not used and does not matter.
  214.     if ( parent.hPrefWindow.getPrefIsLocked( "browser.display.languageList" ) ) {
  215.       disableAllFontElements();
  216.     }
  217.   }
  218.  
  219. function listElement( aListID )
  220.   {
  221.     this.listElement = document.getElementById( aListID );
  222.   }
  223.  
  224. listElement.prototype =
  225.   {
  226.     clearList:
  227.       function ()
  228.         {
  229.           // remove the menupopup node child of the menulist.
  230.           this.listElement.removeChild( this.listElement.firstChild );
  231.         },
  232.  
  233.     appendString:
  234.       function ( aString )
  235.         {
  236.           var menuItemNode = document.createElement( "menuitem" );
  237.           if( menuItemNode )
  238.             {
  239.               menuItemNode.setAttribute( "label", aString );
  240.               this.listElement.firstChild.appendChild( menuItemNode );
  241.             }
  242.         },
  243.  
  244.     appendFontNames: 
  245.       function ( aDataObject ) 
  246.         { 
  247.           var popupNode = document.createElement( "menupopup" ); 
  248.           var strDefaultFontFace = "";
  249.           var fontName;
  250.           while (aDataObject.hasMoreElements()) {
  251.             fontName = aDataObject.getNext();
  252.             fontName = fontName.QueryInterface(Components.interfaces.nsISupportsString);
  253.             var fontNameStr = fontName.toString();
  254.             if (strDefaultFontFace == "")
  255.               strDefaultFontFace = fontNameStr;
  256.             var itemNode = document.createElement( "menuitem" );
  257.             itemNode.setAttribute( "value", fontNameStr );
  258.             itemNode.setAttribute( "label", fontNameStr );
  259.             popupNode.appendChild( itemNode );
  260.           }
  261.           if (strDefaultFontFace != "") {
  262.             this.listElement.removeAttribute( "disabled" );
  263.           } else {
  264.             this.listElement.setAttribute( "value", strDefaultFontFace );
  265.             this.listElement.setAttribute( "label",
  266.                                     gPrefutilitiesBundle.getString("nofontsforlang") );
  267.             this.listElement.setAttribute( "disabled", "true" );
  268.           }
  269.           this.listElement.appendChild( popupNode ); 
  270.           return strDefaultFontFace;
  271.         } 
  272.   };
  273.  
  274. function saveFontPrefs()
  275.   {
  276.     // if saveState function is available, assume can call it.
  277.     // why is this extra qualification required?!!!!
  278.     if( top.hPrefWindow.wsm.contentArea.saveState )
  279.       {
  280.         saveState();
  281.         parent.hPrefWindow.wsm.dataManager.pageData["chrome://communicator/content/pref/pref-fonts.xul"] = GetFields();
  282.       }
  283.  
  284.     // saving font prefs
  285.     var dataObject = parent.hPrefWindow.wsm.dataManager.pageData["chrome://communicator/content/pref/pref-fonts.xul"];
  286.     var pref = parent.hPrefWindow.pref;
  287.     for( var language in dataObject.languageData )
  288.       {
  289.         for( var type in dataObject.languageData[language].types )
  290.           {
  291.             var fontPrefString = "font.name." + type + "." + language;
  292.             var currValue = "";
  293.             try
  294.               {
  295.                 currValue = pref.CopyUnicharPref( fontPrefString );
  296.               }
  297.             catch(e)
  298.               {
  299.               }
  300.             if( currValue != dataObject.languageData[language].types[type] )
  301.               pref.SetUnicharPref( fontPrefString, dataObject.languageData[language].types[type] );
  302.           }
  303.         var variableSizePref = "font.size.variable." + language;
  304.         var fixedSizePref = "font.size.fixed." + language;
  305.         var minSizePref = "font.minimum-size." + language;
  306.         var currVariableSize = 12, currFixedSize = 12, minSizeVal = 0;
  307.         try
  308.           {
  309.             currVariableSize = pref.GetIntPref( variableSizePref );
  310.             currFixedSize = pref.GetIntPref( fixedSizePref );
  311.             minSizeVal = pref.GetIntPref( minSizePref );
  312.           }
  313.         catch(e)
  314.           {
  315.           }
  316.         if( currVariableSize != dataObject.languageData[language].variableSize )
  317.           pref.SetIntPref( variableSizePref, dataObject.languageData[language].variableSize );
  318.         if( currFixedSize != dataObject.languageData[language].fixedSize )
  319.           pref.SetIntPref( fixedSizePref, dataObject.languageData[language].fixedSize );
  320.         if ( minSizeVal != dataObject.languageData[language].minSize ) {
  321.           pref.SetIntPref ( minSizePref, dataObject.languageData[language].minSize );
  322.         }
  323.       }
  324.  
  325.     // font scaling
  326.     var fontDPI       = parseInt( dataObject.fontDPI );
  327.     var documentFonts = dataObject.useDocFonts;
  328.     var defaultFont   = dataObject.defaultFont;
  329.  
  330.     try
  331.       {
  332.         var currDPI = pref.GetIntPref( "browser.display.screen_resolution" );
  333.         var currFonts = pref.GetIntPref( "browser.display.use_document_fonts" );
  334.         var currDefault = pref.CopyUnicharPref( "font.default" );
  335.       }
  336.     catch(e)
  337.       {
  338.       }
  339.     if( currDPI != fontDPI )
  340.       pref.SetIntPref( "browser.display.screen_resolution", fontDPI );
  341.     if( currFonts != documentFonts )
  342.       pref.SetIntPref( "browser.display.use_document_fonts", documentFonts );
  343.     if( currDefault != defaultFont )
  344.       {
  345.         pref.SetUnicharPref( "font.default", defaultFont );
  346.       }
  347.   }
  348.  
  349. function saveState()
  350.   {
  351.     for( var i = 0; i < fontTypes.length; i++ )
  352.       {
  353.         // preliminary initialisation
  354.         if( currentLanguage && !( currentLanguage in languageData ) )
  355.           languageData[currentLanguage] = [];
  356.         if( currentLanguage && !( "types" in languageData[currentLanguage] ) )
  357.           languageData[currentLanguage].types = [];
  358.         // save data for the previous language
  359.         if( currentLanguage && currentLanguage in languageData &&
  360.             "types" in languageData[currentLanguage] )
  361.           languageData[currentLanguage].types[fontTypes[i]] = document.getElementById( fontTypes[i] ).value;
  362.       }
  363.  
  364.     if( currentLanguage && currentLanguage in languageData &&
  365.         "types" in languageData[currentLanguage] )
  366.       {
  367.         languageData[currentLanguage].variableSize = parseInt( variableSize.value );
  368.         languageData[currentLanguage].fixedSize = parseInt( fixedSize.value );
  369.         languageData[currentLanguage].minSize = parseInt( minSize.value );
  370.       }
  371.   }
  372.  
  373. // Selects size (or the nearest entry that exists in the list)
  374. // in the menulist minSize
  375. function minSizeSelect(size)
  376.   {
  377.     var items = minSize.getElementsByAttribute( "value", size );
  378.     if (items.length > 0)
  379.       minSize.selectedItem = items[0];
  380.     else if (size < 6)
  381.       minSizeSelect(6);
  382.     else if (size > 24)
  383.       minSizeSelect(24);
  384.     else
  385.       minSizeSelect(size - 1);
  386.   }
  387.  
  388. function selectLanguage()
  389.   {
  390.     // save current state
  391.     saveState();
  392.  
  393.     if( !currentLanguage )
  394.       currentLanguage = languageList.value;
  395.  
  396.     for( var i = 0; i < fontTypes.length; i++ )
  397.       {
  398.         // build and populate the font list for the newly chosen font type
  399.         var fontEnumerator = fontList.availableFonts(languageList.value, fontTypes[i]);
  400.         var selectElement = new listElement( fontTypes[i] );
  401.         selectElement.clearList();
  402.         var strDefaultFontFace = selectElement.appendFontNames(fontEnumerator);
  403.         //the first font face name returned by the enumerator is our last resort
  404.         var defaultListSelection = selectElement.listElement.getElementsByAttribute( "value", strDefaultFontFace)[0];
  405.         var selectedItem;
  406.  
  407.         //fall-back initialization values (first font face list entry)
  408.         defaultListSelection = strDefaultFontFace ? selectElement.listElement.getElementsByAttribute( "value", strDefaultFontFace)[0] : null;
  409.  
  410.         if( languageList.value in languageData )
  411.           {
  412.             // data exists for this language, pre-select items based on this information
  413.             var dataElements = selectElement.listElement.getElementsByAttribute( "value", languageData[languageList.value].types[fontTypes[i]] );
  414.             selectedItem = dataElements.length ? dataElements[0] : defaultListSelection;
  415.  
  416.             minSizeSelect(languageData[languageList.value].minSize);
  417.             if (strDefaultFontFace)
  418.               {
  419.                 selectElement.listElement.selectedItem = selectedItem;
  420.                 variableSize.removeAttribute("disabled");
  421.                 fixedSize.removeAttribute("disabled");
  422.                 minSize.removeAttribute("disabled");
  423.                 variableSize.selectedItem = variableSize.getElementsByAttribute( "value", languageData[languageList.value].variableSize )[0];
  424.                 fixedSize.selectedItem = fixedSize.getElementsByAttribute( "value", languageData[languageList.value].fixedSize )[0];
  425.               }
  426.             else
  427.               {
  428.                 variableSize.setAttribute("disabled","true");
  429.                 fixedSize.setAttribute("disabled","true");
  430.                 minSize.setAttribute("disabled","true");
  431.               }
  432.           }
  433.         else
  434.           {
  435.  
  436.             if (strDefaultFontFace) {
  437.                 //initialze pref panel only if font faces are available for this language family
  438.  
  439.                 var selectVal;
  440.  
  441.                 try {
  442.                     var fontPrefString = "font.name." + fontTypes[i] + "." + languageList.value;
  443.                     selectVal   = parent.hPrefWindow.pref.CopyUnicharPref( fontPrefString );
  444.                     var dataEls = selectElement.listElement.getElementsByAttribute( "value", selectVal );
  445.  
  446.                     // we need to honor name-list in case name is unavailable 
  447.                     if (!dataEls.length) {
  448.                         var fontListPrefString = "font.name-list." + fontTypes[i] + "." + languageList.value;
  449.                         var nameList   = parent.hPrefWindow.pref.CopyUnicharPref( fontListPrefString );
  450.                         var fontNames = nameList.split(",");
  451.                         var stripWhitespace = /^\s*(.*)\s*$/;
  452.  
  453.                         for (j = 0; j < fontNames.length; j++) {
  454.                           selectVal = fontNames[j].replace(stripWhitespace, "$1");
  455.                           dataEls = selectElement.listElement.getElementsByAttribute("value", selectVal);
  456.                           if (dataEls.length)  
  457.                             break;  // exit loop if we find one
  458.                         }
  459.                     }                     
  460.  
  461.                     selectedItem = dataEls.length ? dataEls[0] : defaultListSelection;
  462.                     if (!dataEls.length) 
  463.                       selectedVal = strDefaultFontFace;
  464.                 }
  465.                 catch(e) {
  466.                     //always initialize: fall-back to default values
  467.                     selectVal       = strDefaultFontFace;
  468.                     selectedItem    = defaultListSelection;
  469.                 }
  470.  
  471.                 selectElement.listElement.selectedItem = selectedItem;
  472.  
  473.                 variableSize.removeAttribute("disabled");
  474.                 fixedSize.removeAttribute("disabled");
  475.                 minSize.removeAttribute("disabled");
  476.  
  477.  
  478.                 try {
  479.                     var variableSizePref = "font.size.variable." + languageList.value;
  480.                     var fixedSizePref = "font.size.fixed." + languageList.value;
  481.  
  482.                     var sizeVarVal = parent.hPrefWindow.pref.GetIntPref( variableSizePref );
  483.                     var sizeFixedVal = parent.hPrefWindow.pref.GetIntPref( fixedSizePref );
  484.  
  485.                     variableSize.selectedItem = variableSize.getElementsByAttribute( "value", sizeVarVal )[0];
  486.  
  487.                     fixedSize.selectedItem = fixedSize.getElementsByAttribute( "value", sizeFixedVal )[0];
  488.                 }
  489.  
  490.                 catch(e) {
  491.                     //font size lists can simply deafult to the first entry
  492.                 }
  493.                 var minSizeVal = 0;
  494.                 try {
  495.                   var minSizePref = "font.minimum-size." + languageList.value;
  496.                   minSizeVal = pref.GetIntPref( minSizePref );
  497.                 }
  498.                 catch(e) {}
  499.                 minSizeSelect( minSizeVal );
  500.  
  501.             }
  502.             else
  503.             {
  504.                 //disable otherwise                
  505.                 variableSize.setAttribute("disabled","true");
  506.                 fixedSize.setAttribute("disabled","true");
  507.                 minSize.setAttribute("disabled","true");
  508.                 minSizeSelect(0);
  509.             }
  510.           }
  511.       }
  512.     currentLanguage = languageList.value;
  513.   }
  514.  
  515. function changeScreenResolution()
  516.   {
  517.     var screenResolution = document.getElementById("screenResolution");
  518.     var userResolution = document.getElementById("userResolution");
  519.  
  520.     var previousSelection = screenResolution.getElementsByAttribute("current", "true")[0];
  521.  
  522.     if (screenResolution.value == "other")
  523.       {
  524.         // If the user selects "Other..." we bring up the calibrate screen dialog
  525.         var rv = { newdpi : 0 };
  526.         var calscreen = window.openDialog("chrome://communicator/content/pref/pref-calibrate-screen.xul", 
  527.                                       "_blank", 
  528.                                       "modal,chrome,centerscreen,resizable=no,titlebar",
  529.                                       rv);
  530.         if (rv.newdpi != -1) 
  531.           {
  532.             // They have entered values, and we have a DPI value back
  533.             var dpi = screenResolution.getAttribute( "dpi" );
  534.             setResolution ( rv.newdpi );
  535.  
  536.             previousSelection.removeAttribute("current");
  537.             screenResolution.selectedItem.setAttribute("current", "true");
  538.           }
  539.         else
  540.           {
  541.             // They've cancelled. We can't leave "Other..." selected, so...
  542.             // we re-select the previously selected item.
  543.             screenResolution.selectedItem = previousSelection;
  544.           }
  545.       }
  546.     else if (!(screenResolution.value == userResolution.value))
  547.       {
  548.         // User has selected one of the hard-coded resolutions
  549.         userResolution.setAttribute("hidden", "true");
  550.  
  551.         previousSelection.removeAttribute("current");
  552.         screenResolution.selectedItem.setAttribute("current", "true");
  553.       }
  554.   }
  555.  
  556. function setResolution( resolution )
  557.   {
  558.     // Given a number, if it's equal to a hard-coded resolution we use that,
  559.     // otherwise we set the userResolution field.
  560.     var screenResolution = document.getElementById( "screenResolution" );
  561.     var userResolution = document.getElementById( "userResolution" );
  562.  
  563.     var items = screenResolution.getElementsByAttribute( "value", resolution );
  564.     if (items.length)
  565.       {
  566.         // If it's one of the hard-coded values, we'll select it directly 
  567.         screenResolution.selectedItem = items[0];
  568.         userResolution.setAttribute( "hidden", "true" );
  569.       }   
  570.     else
  571.       {
  572.         // Otherwise we need to set up the userResolution field
  573.         var dpi = screenResolution.getAttribute( "dpi" );
  574.         userResolution.setAttribute( "value", resolution );
  575.         userResolution.setAttribute( "label", dpi.replace(/\$val/, resolution) );
  576.         userResolution.removeAttribute( "hidden" );
  577.         screenResolution.selectedItem = userResolution;   
  578.       }
  579.   }
  580.   
  581. // "Calibrate screen" dialog code
  582.  
  583. function Init()
  584.   {
  585.       sizeToContent();
  586.       doSetOKCancel(onOK, onCancel);
  587.       document.getElementById("horizSize").focus();
  588.   }
  589.   
  590. function onOK()
  591.   {
  592.     // Get value from the dialog to work out dpi
  593.     var horizSize = parseFloat(document.getElementById("horizSize").value);
  594.     var units = document.getElementById("units").value;
  595.   
  596.     if (!horizSize || horizSize < 0)
  597.       {
  598.         // We can't calculate anything without a proper value
  599.         window.arguments[0].newdpi = -1;
  600.         return true;
  601.       }
  602.       
  603.     // Convert centimetres to inches.
  604.     // The magic number is allowed because it's a fundamental constant :-)
  605.     if (units === "centimetres")
  606.       {
  607.         horizSize /= 2.54;
  608.       }
  609.   
  610.     // These shouldn't change, but you can't be too careful.
  611.     var horizBarLengthPx = document.getElementById("horizRuler").boxObject.width;
  612.   
  613.     var horizDPI = parseInt(horizBarLengthPx) / horizSize;
  614.   
  615.     // Average the two <shrug>.
  616.     window.arguments[0].newdpi = Math.round(horizDPI);
  617.   
  618.     return true;
  619.   }
  620.  
  621. function onCancel()
  622.   {
  623.       // We return -1 to show that no value has been given.
  624.       window.arguments[0].newdpi = -1;
  625.       return true;
  626.   }
  627.  
  628. // disable font items, but not the browserUseDocumentFonts checkbox nor the resolution
  629. // menulist
  630. function disableAllFontElements()
  631.   {
  632.       var doc_ids = [ "selectLangs", "proportionalFont",
  633.                       "sizeVar", "serif", "sans-serif",
  634.                       "cursive", "fantasy", "monospace",
  635.                       "sizeMono", "minSize" ];
  636.       for (i=0; i<doc_ids.length; i++) {
  637.           element = document.getElementById( doc_ids[i] );
  638.           element.disabled = true;
  639.       }
  640.   }
  641.  
  642.