The Tor Browser / file revision

 // -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

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

 /*** =================== INITIALISATION CODE =================== ***/

 var kObserverService;

 // interface variables

 var passwordmanager     = null;

 // password-manager lists

 var signons             = [];

 var rejects             = [];

 var deletedSignons      = [];

 var deletedRejects      = [];

 var signonsTree;

 var rejectsTree;

 var showingPasswords = false;

 function Startup() {

   // xpconnect to password manager interfaces

   passwordmanager = Components.classes["@mozilla.org/login-manager;1"]

                         .getService(Components.interfaces.nsILoginManager);

   // be prepared to reload the display if anything changes

   kObserverService = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);

   kObserverService.addObserver(signonReloadDisplay, "passwordmgr-storage-changed", false);

   signonsTree = document.getElementById("signonsTree");

   rejectsTree = document.getElementById("rejectsTree");

 }

 function Shutdown() {

   kObserverService.removeObserver(signonReloadDisplay, "passwordmgr-storage-changed");

 }

 var signonReloadDisplay = {

   observe: function(subject, topic, data) {

     if (topic == "passwordmgr-storage-changed") {

       switch (data) {

         case "addLogin":

         case "modifyLogin":

         case "removeLogin":

         case "removeAllLogins":

           if (!signonsTree) {

             return;

           }

           signons.length = 0;

           LoadSignons();

           // apply the filter if needed

           if (document.getElementById("filter") && document.getElementById("filter").value != "") {

             _filterPasswords();

           }

           break;

         case "hostSavingEnabled":

         case "hostSavingDisabled":

           if (!rejectsTree) {

             return;

           }

           rejects.length = 0;

           if (lastRejectSortColumn == "hostname") {

             lastRejectSortAscending = !lastRejectSortAscending; // prevents sort from being reversed

           }

           LoadRejects();

           break;

       }

       kObserverService.notifyObservers(null, "passwordmgr-dialog-updated", null);

     }

   }

 }

 /*** =================== GENERAL CODE =================== ***/

 function DeleteAllFromTree(tree, view, table, deletedTable, removeButton, removeAllButton) {

   // remove all items from table and place in deleted table

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

     deletedTable[deletedTable.length] = table[i];

   }

   table.length = 0;

   // clear out selections

   view.selection.select(-1); 

   // update the tree view and notify the tree

   view.rowCount = 0;

   var box = tree.treeBoxObject;

   box.rowCountChanged(0, -deletedTable.length);

   box.invalidate();

   // disable buttons

   document.getElementById(removeButton).setAttribute("disabled", "true")

   document.getElementById(removeAllButton).setAttribute("disabled","true");

 }

 function DeleteSelectedItemFromTree

     (tree, view, table, deletedTable, removeButton, removeAllButton) {

   // Turn off tree selection notifications during the deletion

   tree.view.selection.selectEventsSuppressed = true;

   // remove selected items from list (by setting them to null) and place in deleted list

   var selections = GetTreeSelections(tree);

   for (var s=selections.length-1; s>= 0; s--) {

     var i = selections[s];

     deletedTable[deletedTable.length] = table[i];

     table[i] = null;

   }

   // collapse list by removing all the null entries

   for (var j=0; j<table.length; j++) {

     if (table[j] == null) {

       var k = j;

       while ((k < table.length) && (table[k] == null)) {

         k++;

       }

       table.splice(j, k-j);

       view.rowCount -= k - j;

       tree.treeBoxObject.rowCountChanged(j, j - k);

     }

   }

   // update selection and/or buttons

   if (table.length) {

     // update selection

     var nextSelection = (selections[0] < table.length) ? selections[0] : table.length-1;

     tree.view.selection.select(nextSelection);

     tree.treeBoxObject.ensureRowIsVisible(nextSelection);

   } else {

     // disable buttons

     document.getElementById(removeButton).setAttribute("disabled", "true")

     document.getElementById(removeAllButton).setAttribute("disabled","true");

   }

   tree.view.selection.selectEventsSuppressed = false;

 }

 function GetTreeSelections(tree) {

   var selections = [];

   var select = tree.view.selection;

   if (select) {

     var count = select.getRangeCount();

     var min = new Object();

     var max = new Object();

     for (var i=0; i<count; i++) {

       select.getRangeAt(i, min, max);

       for (var k=min.value; k<=max.value; k++) {

         if (k != -1) {

           selections[selections.length] = k;

         }

       }

     }

   }

   return selections;

 }

 function SortTree(tree, view, table, column, lastSortColumn, lastSortAscending, updateSelection) {

   // remember which item was selected so we can restore it after the sort

   var selections = GetTreeSelections(tree);

   var selectedNumber = selections.length ? table[selections[0]].number : -1;

   // determine if sort is to be ascending or descending

   var ascending = (column == lastSortColumn) ? !lastSortAscending : true;

   // do the sort

   var compareFunc;

   if (ascending) {

     compareFunc = function compare(first, second) {

       return CompareLowerCase(first[column], second[column]);

     }

   } else {

     compareFunc = function compare(first, second) {

       return CompareLowerCase(second[column], first[column]);

     }

   }

   table.sort(compareFunc);

   // restore the selection

   var selectedRow = -1;

   if (selectedNumber>=0 && updateSelection) {

     for (var s=0; s<table.length; s++) {

       if (table[s].number == selectedNumber) {

         // update selection

         // note: we need to deselect before reselecting in order to trigger ...Selected()

         tree.view.selection.select(-1);

         tree.view.selection.select(s);

         selectedRow = s;

         break;

       }

     }

   }

   // display the results

   tree.treeBoxObject.invalidate();

   if (selectedRow >= 0) {

     tree.treeBoxObject.ensureRowIsVisible(selectedRow)

   }

   return ascending;

 }

 /**

  * Case insensitive string comparator.

  */

 function CompareLowerCase(first, second) {

   var firstLower, secondLower;

   // Are we sorting nsILoginInfo entries or just strings?

   if (first.hostname) {

     firstLower  = first.hostname.toLowerCase();

     secondLower = second.hostname.toLowerCase();

   } else {

     firstLower  = first.toLowerCase();

     secondLower = second.toLowerCase();

   }

   if (firstLower < secondLower) {

     return -1;

   }

   if (firstLower > secondLower) {

     return 1;

   }

   return 0;

 }