home *** CD-ROM | disk | FTP | other *** search
/ PC World 2003 May / PCWorld_2003-05_cd.bin / Komunik / phoenix / chrome / toolkit.jar / content / global / config.js < prev    next >
Text File  |  2002-04-16  |  8KB  |  265 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.     getImageSrc: function(row, colID) { return ""},
  89.     toggleOpenState : function(index) {},
  90.     cycleHeader: function(colID, elt) {},
  91.     selectionChanged : function() {},
  92.     cycleCell: function(row, colID) {},
  93.     isEditable: function(row, valueCol) {return true},
  94.     isEditable: function(row, colID) {return false},
  95.     setCellText: function(row, colID, value) {},
  96.     performAction: function(action) {},
  97.     performActionOnRow: function(action, row) {},
  98.     performActionOnCell: function(action, row, colID) {},
  99.     isSeparator: function(index) {return false}
  100. });
  101.  
  102. function onConfigLoad()
  103. {
  104.     document.title = "about:config";
  105.  
  106.     var prefCount = {value:0};
  107.     var prefService = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefService);
  108.     var prefBranch = prefService.getBranch(null);
  109.     var prefArray = prefBranch.getChildList("" , prefCount);
  110.     var prefName, prefType, prefValue, prefIndex, prefLockState;
  111.  
  112.     var i = 0;
  113.     var j = 0;   // This is used to avoid counting the "capability" preferences
  114.     var k = 0;     // This is to maintain a count of prefs (not including the "capability" prefs);
  115.  
  116.     prefArray.sort();
  117.     for (i = 0; i < prefCount.value; i++) 
  118.     {
  119.         if((prefArray[i].indexOf("capability", 0) + 1) > 0)    // avoid displaying "private" preferences
  120.         {
  121.             j++;
  122.             continue;
  123.         }
  124.  
  125.         k = (i - j);   // avoid numbering "capability" prefs
  126.  
  127.         prefIndex = k + 1;
  128.     
  129.         if (prefBranch.prefIsLocked(prefArray[i]))
  130.           prefLockState = kLocked;
  131.         else if(prefBranch.prefHasUserValue(prefArray[i]))
  132.           prefLockState = kUserSet;
  133.         else
  134.           prefLockState = kDefault;
  135.  
  136.         const nsIPrefBranch = Components.interfaces.nsIPrefBranch;
  137.  
  138.         switch (prefBranch.getPrefType(prefArray[i])) {
  139.             case nsIPrefBranch.PREF_INT:
  140.             prefType = kIntType;
  141.             // convert to a string
  142.             prefValue = "" + prefBranch.getIntPref(prefArray[i]);
  143.                 break;
  144.             case nsIPrefBranch.PREF_BOOL:
  145.             prefType = kBoolType;
  146.             // convert to a string
  147.             if (prefBranch.getBoolPref(prefArray[i]))
  148.               prefValue = "true";
  149.             else
  150.               prefValue = "false";
  151.                 break;
  152.           case nsIPrefBranch.PREF_STRING:
  153.             default: 
  154.             prefType = kStrType;
  155.             prefValue = htmlEscape(prefBranch.getCharPref(prefArray[i]));
  156.                 break;
  157.         }
  158.  
  159.         prefArray[i] = htmlEscape(prefArray[i]);
  160.         baseArray[k] = {indexCol:prefIndex, prefCol:prefArray[i], lockCol:prefLockState, typeCol:prefType, valueCol:prefValue};
  161.     }
  162.  
  163.     view.rowCount = k + 1;
  164.  
  165.     gTree = document.getElementById("configTree");
  166.     gTree.treeBoxObject.view = view;
  167. }
  168.  
  169. function htmlEscape(s) 
  170. { 
  171.     s = s.replace(/\&/g, "&"); 
  172.     s = s.replace(/\>/g, ">"); 
  173.     s = s.replace(/\</g, "<"); 
  174.     return s; 
  175. }
  176.  
  177.  
  178. function ConfigOnClick(event)
  179. {
  180.     // we only care about button 0 (left click) events
  181.     if (event.button != 0) return;
  182.  
  183.     var t = event.originalTarget;
  184.  
  185.     if (t.localName == "treecol") {
  186.        HandleColumnClick(t.id);
  187.     }
  188. }
  189.  
  190. var gSortedColumn = "indexCol";
  191. var gSortAscending = true;
  192.  
  193. function stringSortFunction(a,b)
  194. {
  195.   var value;
  196.   if (a<b)
  197.     value = 1;
  198.   else if (a>b) 
  199.     value = -1;
  200.   else
  201.     value = 0;
  202.  
  203.   if (gSortAscending)
  204.     return value;
  205.   else
  206.     return (value * -1);
  207. }
  208.  
  209. function intSortFunction(a,b)
  210. {
  211.   if (gSortAscending) 
  212.     return (a - b);
  213.   else 
  214.     return (b - a);
  215. }
  216.  
  217. function indexColSortFunction(x,y)
  218. {
  219.   return intSortFunction(x.indexCol, y.indexCol);
  220. }
  221.  
  222. function prefColSortFunction(x,y)
  223. {
  224.   return stringSortFunction(x.prefCol, y.prefCol);
  225. }
  226.  
  227. function lockColSortFunction(x,y)
  228. {
  229.   return stringSortFunction(x.lockCol, y.lockCol);
  230. }
  231.  
  232. function typeColSortFunction(x,y)
  233. {
  234.   return intSortFunction(x.typeCol, y.typeCol);
  235. }
  236.  
  237. function valueColSortFunction(x,y)
  238. {
  239.   return stringSortFunction(x.valueCol, y.valueCol);
  240. }
  241.  
  242. var gSortFunctions = {indexCol:indexColSortFunction, 
  243.                  prefCol:prefColSortFunction, 
  244.                  lockCol:lockColSortFunction, 
  245.                  typeCol:typeColSortFunction, 
  246.                  valueCol:valueColSortFunction};
  247.  
  248. function HandleColumnClick(id)
  249. {
  250.   if (id == gSortedColumn) {
  251.     gSortAscending = !gSortAscending;
  252.     baseArray.reverse();
  253.   }
  254.   else {
  255.     baseArray.sort(gSortFunctions[id]);
  256.     gSortedColumn = id;
  257.   }
  258.  
  259.   gTree.treeBoxObject.invalidate();
  260. }
  261.  
  262.  
  263.  
  264.  
  265.