home *** CD-ROM | disk | FTP | other *** search
/ Chip 2003 January / 01_03.iso / software / ghostzilla_hit / files / ghostzilla-1.0-plus-install.exe / chrome / toolkit.jar / content / global / config.js < prev    next >
Encoding:
JavaScript  |  2002-04-09  |  7.4 KB  |  264 lines
  1. /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  * The contents of this file are subject to the Netscape Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/NPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is Mozilla Communicator client code, released
  13.  * March 31, 1998.
  14.  * 
  15.  * The Initial Developer of the Original Code is Netscape
  16.  * Communications Corporation. Portions created by Netscape are
  17.  * Copyright (C) 1998-1999 Netscape Communications Corporation. All
  18.  * Rights Reserved.
  19.  *
  20.  * Contributors:
  21.  *  Chip Clark <chipc@netscape.com>
  22.  *  Seth Spitzer <sspitzer@netscape.com>
  23.  */
  24.  
  25. var baseArray = new Array();
  26.  
  27. const kDefault = 0;
  28. const kUserSet = 1;
  29. const kLocked = 2;
  30.  
  31. const nsIAtomService = Components.interfaces.nsIAtomService;
  32. const nsAtomService_CONTRACTID = "@mozilla.org/atom-service;1";
  33.  
  34. var atomService = Components.classes[nsAtomService_CONTRACTID].getService(nsIAtomService);
  35. var gLockAtoms = [atomService.getAtom("default"), atomService.getAtom("user"), atomService.getAtom("locked")];
  36. // XXX get these from a string bundle
  37. var gLockStrs = ["default", "user set","locked"]; 
  38.  
  39. const kStrType = 0;
  40. const kIntType = 1;
  41. const kBoolType = 2;
  42.  
  43. var gTypeStrs = ["string","int","bool"];
  44.  
  45. var gTree;
  46.  
  47. var view = ({
  48.     rowCount : 0, 
  49.     getCellText : function(k, col) {    
  50.             if (!baseArray[k])
  51.                 return "";
  52.             
  53.             var value = baseArray[k][col];
  54.             var strvalue;
  55.  
  56.             switch (col) {
  57.               case "lockCol":           
  58.                 strvalue = gLockStrs[value];
  59.                 break;
  60.               case "typeCol":
  61.                 strvalue = gTypeStrs[value];
  62.                 break;
  63.               default:
  64.                 // already a str.
  65.                 strvalue = value;    
  66.                 break;
  67.             }
  68.             return strvalue;
  69.         },
  70.     getRowProperties : function(index, prop) {},
  71.     getCellProperties : function(index, col, prop) {
  72.       prop.AppendElement(gLockAtoms[baseArray[index]["lockCol"]]);
  73.     },
  74.     getColumnProperties : function(col, elt, prop) {},
  75.     treebox : null,
  76.     selection : null,
  77.     isContainer : function(index) { return false; },
  78.     isContainerOpen : function(index) { return false; },
  79.     isContainerEmpty : function(index) { return false; },
  80.     isSorted : function() { },
  81.     canDropOn : function(index) { return false; },
  82.     canDropBeforeAfter : function(index,before) { return false; },
  83.     drop : function(row,orientation) {},
  84.     setTree : function(out) { this.treebox = out; },
  85.     getParentIndex: function(rowIndex) { return -1 },
  86.     hasNextSibling: function(rowIndex, afterIndex) { return false },
  87.     getLevel: function(index) { return 1},
  88.     toggleOpenState : function(index) {},
  89.     cycleHeader: function(colID, elt) {},
  90.     selectionChanged : function() {},
  91.     cycleCell: function(row, colID) {},
  92.     isEditable: function(row, valueCol) {return true},
  93.     isEditable: function(row, colID) {return false},
  94.     setCellText: function(row, colID, value) {},
  95.     performAction: function(action) {},
  96.     performActionOnRow: function(action, row) {},
  97.     performActionOnCell: function(action, row, colID) {},
  98.     isSeparator: function(index) {return false}
  99. });
  100.  
  101. function onConfigLoad()
  102. {
  103.     document.title = "about:config";
  104.  
  105.     var prefCount = {value:0};
  106.     var prefService = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefService);
  107.     var prefBranch = prefService.getBranch(null);
  108.     var prefArray = prefBranch.getChildList("" , prefCount);
  109.     var prefName, prefType, prefValue, prefIndex, prefLockState;
  110.  
  111.     var i = 0;
  112.     var j = 0;   // This is used to avoid counting the "capability" preferences
  113.     var k = 0;     // This is to maintain a count of prefs (not including the "capability" prefs);
  114.  
  115.     prefArray.sort();
  116.     for (i = 0; i < prefCount.value; i++) 
  117.     {
  118.         if((prefArray[i].indexOf("capability", 0) + 1) > 0)    // avoid displaying "private" preferences
  119.         {
  120.             j++;
  121.             continue;
  122.         }
  123.  
  124.         k = (i - j);   // avoid numbering "capability" prefs
  125.  
  126.         prefIndex = k + 1;
  127.     
  128.         if (prefBranch.prefIsLocked(prefArray[i]))
  129.           prefLockState = kLocked;
  130.         else if(prefBranch.prefHasUserValue(prefArray[i]))
  131.           prefLockState = kUserSet;
  132.         else
  133.           prefLockState = kDefault;
  134.  
  135.         const nsIPrefBranch = Components.interfaces.nsIPrefBranch;
  136.  
  137.         switch (prefBranch.getPrefType(prefArray[i])) {
  138.             case nsIPrefBranch.PREF_INT:
  139.             prefType = kIntType;
  140.             // convert to a string
  141.             prefValue = "" + prefBranch.getIntPref(prefArray[i]);
  142.                 break;
  143.             case nsIPrefBranch.PREF_BOOL:
  144.             prefType = kBoolType;
  145.             // convert to a string
  146.             if (prefBranch.getBoolPref(prefArray[i]))
  147.               prefValue = "true";
  148.             else
  149.               prefValue = "false";
  150.                 break;
  151.           case nsIPrefBranch.PREF_STRING:
  152.             default: 
  153.             prefType = kStrType;
  154.             prefValue = htmlEscape(prefBranch.getCharPref(prefArray[i]));
  155.                 break;
  156.         }
  157.  
  158.         prefArray[i] = htmlEscape(prefArray[i]);
  159.         baseArray[k] = {indexCol:prefIndex, prefCol:prefArray[i], lockCol:prefLockState, typeCol:prefType, valueCol:prefValue};
  160.     }
  161.  
  162.     view.rowCount = k + 1;
  163.  
  164.     gTree = document.getElementById("configTree");
  165.     gTree.treeBoxObject.view = view;
  166. }
  167.  
  168. function htmlEscape(s) 
  169. { 
  170.     s = s.replace(/\&/g, "&"); 
  171.     s = s.replace(/\>/g, ">"); 
  172.     s = s.replace(/\</g, "<"); 
  173.     return s; 
  174. }
  175.  
  176.  
  177. function ConfigOnClick(event)
  178. {
  179.     // we only care about button 0 (left click) events
  180.     if (event.button != 0) return;
  181.  
  182.     var t = event.originalTarget;
  183.  
  184.     if (t.localName == "treecol") {
  185.        HandleColumnClick(t.id);
  186.     }
  187. }
  188.  
  189. var gSortedColumn = "indexCol";
  190. var gSortAscending = true;
  191.  
  192. function stringSortFunction(a,b)
  193. {
  194.   var value;
  195.   if (a<b)
  196.     value = 1;
  197.   else if (a>b) 
  198.     value = -1;
  199.   else
  200.     value = 0;
  201.  
  202.   if (gSortAscending)
  203.     return value;
  204.   else
  205.     return (value * -1);
  206. }
  207.  
  208. function intSortFunction(a,b)
  209. {
  210.   if (gSortAscending) 
  211.     return (a - b);
  212.   else 
  213.     return (b - a);
  214. }
  215.  
  216. function indexColSortFunction(x,y)
  217. {
  218.   return intSortFunction(x.indexCol, y.indexCol);
  219. }
  220.  
  221. function prefColSortFunction(x,y)
  222. {
  223.   return stringSortFunction(x.prefCol, y.prefCol);
  224. }
  225.  
  226. function lockColSortFunction(x,y)
  227. {
  228.   return stringSortFunction(x.lockCol, y.lockCol);
  229. }
  230.  
  231. function typeColSortFunction(x,y)
  232. {
  233.   return intSortFunction(x.typeCol, y.typeCol);
  234. }
  235.  
  236. function valueColSortFunction(x,y)
  237. {
  238.   return stringSortFunction(x.valueCol, y.valueCol);
  239. }
  240.  
  241. var gSortFunctions = {indexCol:indexColSortFunction, 
  242.                  prefCol:prefColSortFunction, 
  243.                  lockCol:lockColSortFunction, 
  244.                  typeCol:typeColSortFunction, 
  245.                  valueCol:valueColSortFunction};
  246.  
  247. function HandleColumnClick(id)
  248. {
  249.   if (id == gSortedColumn) {
  250.     gSortAscending = !gSortAscending;
  251.     baseArray.reverse();
  252.   }
  253.   else {
  254.     baseArray.sort(gSortFunctions[id]);
  255.     gSortedColumn = id;
  256.   }
  257.  
  258.   gTree.treeBoxObject.invalidate();
  259. }
  260.  
  261.  
  262.  
  263.  
  264.