The Tor Browser: browser/base/content/sanitizeDialog.js@6474c204b198 (annotated)

browser/base/content/sanitizeDialog.js@6474c204b198 (annotated)

browser/base/content/sanitizeDialog.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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/. */
 const Cc = Components.classes;
 const Ci = Components.interfaces;
 var gSanitizePromptDialog = {
   get bundleBrowser()
   {
     if (!this._bundleBrowser)
       this._bundleBrowser = document.getElementById("bundleBrowser");
     return this._bundleBrowser;
   },
   get selectedTimespan()
   {
     var durList = document.getElementById("sanitizeDurationChoice");
     return parseInt(durList.value);
   },
   get sanitizePreferences()
   {
     if (!this._sanitizePreferences) {
       this._sanitizePreferences =
         document.getElementById("sanitizePreferences");
     }
     return this._sanitizePreferences;
   },
   get warningBox()
   {
     return document.getElementById("sanitizeEverythingWarningBox");
   },
   init: function ()
   {
     // This is used by selectByTimespan() to determine if the window has loaded.
     this._inited = true;
     var s = new Sanitizer();
     s.prefDomain = "privacy.cpd.";
     let sanitizeItemList = document.querySelectorAll("#itemList > [preference]");
     for (let i = 0; i < sanitizeItemList.length; i++) {
       let prefItem = sanitizeItemList[i];
       let name = s.getNameFromPreference(prefItem.getAttribute("preference"));
       s.canClearItem(name, function canClearCallback(aItem, aCanClear, aPrefItem) {
         if (!aCanClear) {
           aPrefItem.preference = null;
           aPrefItem.checked = false;
           aPrefItem.disabled = true;
         }
       }, prefItem);
     }
     document.documentElement.getButton("accept").label =
       this.bundleBrowser.getString("sanitizeButtonOK");
     if (this.selectedTimespan === Sanitizer.TIMESPAN_EVERYTHING) {
       this.prepareWarning();
       this.warningBox.hidden = false;
       document.title =
         this.bundleBrowser.getString("sanitizeDialog2.everything.title");
     }
     else
       this.warningBox.hidden = true;
   },
   selectByTimespan: function ()
   {
     // This method is the onselect handler for the duration dropdown.  As a
     // result it's called a couple of times before onload calls init().
     if (!this._inited)
       return;
     var warningBox = this.warningBox;
     // If clearing everything
     if (this.selectedTimespan === Sanitizer.TIMESPAN_EVERYTHING) {
       this.prepareWarning();
       if (warningBox.hidden) {
         warningBox.hidden = false;
         window.resizeBy(0, warningBox.boxObject.height);
       }
       window.document.title =
         this.bundleBrowser.getString("sanitizeDialog2.everything.title");
       return;
     }
     // If clearing a specific time range
     if (!warningBox.hidden) {
       window.resizeBy(0, -warningBox.boxObject.height);
       warningBox.hidden = true;
     }
     window.document.title =
       window.document.documentElement.getAttribute("noneverythingtitle");
   },
   sanitize: function ()
   {
     // Update pref values before handing off to the sanitizer (bug 453440)
     this.updatePrefs();
     var s = new Sanitizer();
     s.prefDomain = "privacy.cpd.";
     s.range = Sanitizer.getClearRange(this.selectedTimespan);
     s.ignoreTimespan = !s.range;
     // As the sanitize is async, we disable the buttons, update the label on
     // the 'accept' button to indicate things are happening and return false -
     // once the async operation completes (either with or without errors)
     // we close the window.
     let docElt = document.documentElement;
     let acceptButton = docElt.getButton("accept");
     acceptButton.disabled = true;
     acceptButton.setAttribute("label",
                               this.bundleBrowser.getString("sanitizeButtonClearing"));
     docElt.getButton("cancel").disabled = true;
     try {
       s.sanitize().then(null, Components.utils.reportError)
                   .then(() => window.close())
                   .then(null, Components.utils.reportError);
     } catch (er) {
       Components.utils.reportError("Exception during sanitize: " + er);
       return true; // We *do* want to close immediately on error.
     }
     return false;
   },
   /**
    * If the panel that displays a warning when the duration is "Everything" is
    * not set up, sets it up.  Otherwise does nothing.
    *
    * @param aDontShowItemList Whether only the warning message should be updated.
    *                          True means the item list visibility status should not
    *                          be changed.
    */
   prepareWarning: function (aDontShowItemList) {
     // If the date and time-aware locale warning string is ever used again,
     // initialize it here.  Currently we use the no-visits warning string,
     // which does not include date and time.  See bug 480169 comment 48.
     var warningStringID;
     if (this.hasNonSelectedItems()) {
       warningStringID = "sanitizeSelectedWarning";
       if (!aDontShowItemList)
         this.showItemList();
     }
     else {
       warningStringID = "sanitizeEverythingWarning2";
     }
     var warningDesc = document.getElementById("sanitizeEverythingWarning");
     warningDesc.textContent =
       this.bundleBrowser.getString(warningStringID);
   },
   /**
    * Called when the value of a preference element is synced from the actual
    * pref.  Enables or disables the OK button appropriately.
    */
   onReadGeneric: function ()
   {
     var found = false;
     // Find any other pref that's checked and enabled.
     var i = 0;
     while (!found && i < this.sanitizePreferences.childNodes.length) {
       var preference = this.sanitizePreferences.childNodes[i];
       found = !!preference.value &&
               !preference.disabled;
       i++;
     }
     try {
       document.documentElement.getButton("accept").disabled = !found;
     }
     catch (e) { }
     // Update the warning prompt if needed
     this.prepareWarning(true);
     return undefined;
   },
   /**
    * Sanitizer.prototype.sanitize() requires the prefs to be up-to-date.
    * Because the type of this prefwindow is "child" -- and that's needed because
    * without it the dialog has no OK and Cancel buttons -- the prefs are not
    * updated on dialogaccept on platforms that don't support instant-apply
    * (i.e., Windows).  We must therefore manually set the prefs from their
    * corresponding preference elements.
    */
   updatePrefs : function ()
   {
     var tsPref = document.getElementById("privacy.sanitize.timeSpan");
     Sanitizer.prefs.setIntPref("timeSpan", this.selectedTimespan);
     // Keep the pref for the download history in sync with the history pref.
     document.getElementById("privacy.cpd.downloads").value =
       document.getElementById("privacy.cpd.history").value;
     // Now manually set the prefs from their corresponding preference
     // elements.
     var prefs = this.sanitizePreferences.rootBranch;
     for (let i = 0; i < this.sanitizePreferences.childNodes.length; ++i) {
       var p = this.sanitizePreferences.childNodes[i];
       prefs.setBoolPref(p.name, p.value);
     }
   },
   /**
    * Check if all of the history items have been selected like the default status.
    */
   hasNonSelectedItems: function () {
     let checkboxes = document.querySelectorAll("#itemList > [preference]");
     for (let i = 0; i < checkboxes.length; ++i) {
       let pref = document.getElementById(checkboxes[i].getAttribute("preference"));
       if (!pref.value)
         return true;
     }
     return false;
   },
   /**
    * Show the history items list.
    */
   showItemList: function () {
     var itemList = document.getElementById("itemList");
     var expanderButton = document.getElementById("detailsExpander");
     if (itemList.collapsed) {
       expanderButton.className = "expander-up";
       itemList.setAttribute("collapsed", "false");
       if (document.documentElement.boxObject.height)
         window.resizeBy(0, itemList.boxObject.height);
     }
   },
   /**
    * Hide the history items list.
    */
   hideItemList: function () {
     var itemList = document.getElementById("itemList");
     var expanderButton = document.getElementById("detailsExpander");
     if (!itemList.collapsed) {
       expanderButton.className = "expander-down";
       window.resizeBy(0, -itemList.boxObject.height);
       itemList.setAttribute("collapsed", "true");
     }
   },
   /**
    * Called by the item list expander button to toggle the list's visibility.
    */
   toggleItemList: function ()
   {
     var itemList = document.getElementById("itemList");
     if (itemList.collapsed)
       this.showItemList();
     else
       this.hideItemList();
   }
 #ifdef CRH_DIALOG_TREE_VIEW
   // A duration value; used in the same context as Sanitizer.TIMESPAN_HOUR,
   // Sanitizer.TIMESPAN_2HOURS, et al.  This should match the value attribute
   // of the sanitizeDurationCustom menuitem.
   get TIMESPAN_CUSTOM()
   {
     return -1;
   },
   get placesTree()
   {
     if (!this._placesTree)
       this._placesTree = document.getElementById("placesTree");
     return this._placesTree;
   },
   init: function ()
   {
     // This is used by selectByTimespan() to determine if the window has loaded.
     this._inited = true;
     var s = new Sanitizer();
     s.prefDomain = "privacy.cpd.";
     let sanitizeItemList = document.querySelectorAll("#itemList > [preference]");
     for (let i = 0; i < sanitizeItemList.length; i++) {
       let prefItem = sanitizeItemList[i];
       let name = s.getNameFromPreference(prefItem.getAttribute("preference"));
       s.canClearItem(name, function canClearCallback(aCanClear) {
         if (!aCanClear) {
           prefItem.preference = null;
           prefItem.checked = false;
           prefItem.disabled = true;
         }
       });
     }
     document.documentElement.getButton("accept").label =
       this.bundleBrowser.getString("sanitizeButtonOK");
     this.selectByTimespan();
   },
   /**
    * Sets up the hashes this.durationValsToRows, which maps duration values
    * to rows in the tree, this.durationRowsToVals, which maps rows in
    * the tree to duration values, and this.durationStartTimes, which maps
    * duration values to their corresponding start times.
    */
   initDurationDropdown: function ()
   {
     // First, calculate the start times for each duration.
     this.durationStartTimes = {};
     var durVals = [];
     var durPopup = document.getElementById("sanitizeDurationPopup");
     var durMenuitems = durPopup.childNodes;
     for (let i = 0; i < durMenuitems.length; i++) {
       let durMenuitem = durMenuitems[i];
       let durVal = parseInt(durMenuitem.value);
       if (durMenuitem.localName === "menuitem" &&
           durVal !== Sanitizer.TIMESPAN_EVERYTHING &&
           durVal !== this.TIMESPAN_CUSTOM) {
         durVals.push(durVal);
         let durTimes = Sanitizer.getClearRange(durVal);
         this.durationStartTimes[durVal] = durTimes[0];
       }
     }
     // Sort the duration values ascending.  Because one tree index can map to
     // more than one duration, this ensures that this.durationRowsToVals maps
     // a row index to the largest duration possible in the code below.
     durVals.sort();
     // Now calculate the rows in the tree of the durations' start times.  For
     // each duration, we are looking for the node in the tree whose time is the
     // smallest time greater than or equal to the duration's start time.
     this.durationRowsToVals = {};
     this.durationValsToRows = {};
     var view = this.placesTree.view;
     // For all rows in the tree except the grippy row...
     for (let i = 0; i < view.rowCount - 1; i++) {
       let unfoundDurVals = [];
       let nodeTime = view.QueryInterface(Ci.nsINavHistoryResultTreeViewer).
                      nodeForTreeIndex(i).time;
       // For all durations whose rows have not yet been found in the tree, see
       // if index i is their index.  An index may map to more than one duration,
       // in which case the final duration (the largest) wins.
       for (let j = 0; j < durVals.length; j++) {
         let durVal = durVals[j];
         let durStartTime = this.durationStartTimes[durVal];
         if (nodeTime < durStartTime) {
           this.durationValsToRows[durVal] = i - 1;
           this.durationRowsToVals[i - 1] = durVal;
         }
         else
           unfoundDurVals.push(durVal);
       }
       durVals = unfoundDurVals;
     }
     // If any durations were not found above, then every node in the tree has a
     // time greater than or equal to the duration.  In other words, those
     // durations include the entire tree (except the grippy row).
     for (let i = 0; i < durVals.length; i++) {
       let durVal = durVals[i];
       this.durationValsToRows[durVal] = view.rowCount - 2;
       this.durationRowsToVals[view.rowCount - 2] = durVal;
     }
   },
   /**
    * If the Places tree is not set up, sets it up.  Otherwise does nothing.
    */
   ensurePlacesTreeIsInited: function ()
   {
     if (this._placesTreeIsInited)
       return;
     this._placesTreeIsInited = true;
     // Either "Last Four Hours" or "Today" will have the most history.  If
     // it's been more than 4 hours since today began, "Today" will. Otherwise
     // "Last Four Hours" will.
     var times = Sanitizer.getClearRange(Sanitizer.TIMESPAN_TODAY);
     // If it's been less than 4 hours since today began, use the past 4 hours.
     if (times[1] - times[0] < 14400000000) { // 4*60*60*1000000
       times = Sanitizer.getClearRange(Sanitizer.TIMESPAN_4HOURS);
     }
     var histServ = Cc["@mozilla.org/browser/nav-history-service;1"].
                    getService(Ci.nsINavHistoryService);
     var query = histServ.getNewQuery();
     query.beginTimeReference = query.TIME_RELATIVE_EPOCH;
     query.beginTime = times[0];
     query.endTimeReference = query.TIME_RELATIVE_EPOCH;
     query.endTime = times[1];
     var opts = histServ.getNewQueryOptions();
     opts.sortingMode = opts.SORT_BY_DATE_DESCENDING;
     opts.queryType = opts.QUERY_TYPE_HISTORY;
     var result = histServ.executeQuery(query, opts);
     var view = gContiguousSelectionTreeHelper.setTree(this.placesTree,
                                                       new PlacesTreeView());
     result.addObserver(view, false);
     this.initDurationDropdown();
   },
   /**
    * Called on select of the duration dropdown and when grippyMoved() sets a
    * duration based on the location of the grippy row.  Selects all the nodes in
    * the tree that are contained in the selected duration.  If clearing
    * everything, the warning panel is shown instead.
    */
   selectByTimespan: function ()
   {
     // This method is the onselect handler for the duration dropdown.  As a
     // result it's called a couple of times before onload calls init().
     if (!this._inited)
       return;
     var durDeck = document.getElementById("durationDeck");
     var durList = document.getElementById("sanitizeDurationChoice");
     var durVal = parseInt(durList.value);
     var durCustom = document.getElementById("sanitizeDurationCustom");
     // If grippy row is not at a duration boundary, show the custom menuitem;
     // otherwise, hide it.  Since the user cannot specify a custom duration by
     // using the dropdown, this conditional is true only when this method is
     // called onselect from grippyMoved(), so no selection need be made.
     if (durVal === this.TIMESPAN_CUSTOM) {
       durCustom.hidden = false;
       return;
     }
     durCustom.hidden = true;
     // If clearing everything, show the warning and change the dialog's title.
     if (durVal === Sanitizer.TIMESPAN_EVERYTHING) {
       this.prepareWarning();
       durDeck.selectedIndex = 1;
       window.document.title =
         this.bundleBrowser.getString("sanitizeDialog2.everything.title");
       document.documentElement.getButton("accept").disabled = false;
       return;
     }
     // Otherwise -- if clearing a specific time range -- select that time range
     // in the tree.
     this.ensurePlacesTreeIsInited();
     durDeck.selectedIndex = 0;
     window.document.title =
       window.document.documentElement.getAttribute("noneverythingtitle");
     var durRow = this.durationValsToRows[durVal];
     gContiguousSelectionTreeHelper.rangedSelect(durRow);
     gContiguousSelectionTreeHelper.scrollToGrippy();
     // If duration is empty (there are no selected rows), disable the dialog's
     // OK button.
     document.documentElement.getButton("accept").disabled = durRow < 0;
   },
   sanitize: function ()
   {
     // Update pref values before handing off to the sanitizer (bug 453440)
     this.updatePrefs();
     var s = new Sanitizer();
     s.prefDomain = "privacy.cpd.";
     var durList = document.getElementById("sanitizeDurationChoice");
     var durValue = parseInt(durList.value);
     s.ignoreTimespan = durValue === Sanitizer.TIMESPAN_EVERYTHING;
     // Set the sanitizer's time range if we're not clearing everything.
     if (!s.ignoreTimespan) {
       // If user selected a custom timespan, use that.
       if (durValue === this.TIMESPAN_CUSTOM) {
         var view = this.placesTree.view;
         var now = Date.now() * 1000;
         // We disable the dialog's OK button if there's no selection, but we'll
         // handle that case just in... case.
         if (view.selection.getRangeCount() === 0)
           s.range = [now, now];
         else {
           var startIndexRef = {};
           // Tree sorted by visit date DEscending, so start time time comes last.
           view.selection.getRangeAt(0, {}, startIndexRef);
           view.QueryInterface(Ci.nsINavHistoryResultTreeViewer);
           var startNode = view.nodeForTreeIndex(startIndexRef.value);
           s.range = [startNode.time, now];
         }
       }
       // Otherwise use the predetermined range.
       else
         s.range = [this.durationStartTimes[durValue], Date.now() * 1000];
     }
     try {
       s.sanitize();
     } catch (er) {
       Components.utils.reportError("Exception during sanitize: " + er);
     }
     return true;
   },
   /**
    * In order to mark the custom Places tree view and its nsINavHistoryResult
    * for garbage collection, we need to break the reference cycle between the
    * two.
    */
   unload: function ()
   {
     let result = this.placesTree.getResult();
     result.removeObserver(this.placesTree.view);
     this.placesTree.view = null;
   },
   /**
    * Called when the user moves the grippy by dragging it, clicking in the tree,
    * or on keypress.  Updates the duration dropdown so that it displays the
    * appropriate specific or custom duration.
    *
    * @param aEventName
    *        The name of the event whose handler called this method, e.g.,
    *        "ondragstart", "onkeypress", etc.
    * @param aEvent
    *        The event captured in the event handler.
    */
   grippyMoved: function (aEventName, aEvent)
   {
     gContiguousSelectionTreeHelper[aEventName](aEvent);
     var lastSelRow = gContiguousSelectionTreeHelper.getGrippyRow() - 1;
     var durList = document.getElementById("sanitizeDurationChoice");
     var durValue = parseInt(durList.value);
     // Multiple durations can map to the same row.  Don't update the dropdown
     // if the current duration is valid for lastSelRow.
     if ((durValue !== this.TIMESPAN_CUSTOM ||
          lastSelRow in this.durationRowsToVals) &&
         (durValue === this.TIMESPAN_CUSTOM ||
          this.durationValsToRows[durValue] !== lastSelRow)) {
       // Setting durList.value causes its onselect handler to fire, which calls
       // selectByTimespan().
       if (lastSelRow in this.durationRowsToVals)
         durList.value = this.durationRowsToVals[lastSelRow];
       else
         durList.value = this.TIMESPAN_CUSTOM;
     }
     // If there are no selected rows, disable the dialog's OK button.
     document.documentElement.getButton("accept").disabled = lastSelRow < 0;
   }
 #endif
 };
 #ifdef CRH_DIALOG_TREE_VIEW
 /**
  * A helper for handling contiguous selection in the tree.
  */
 var gContiguousSelectionTreeHelper = {
   /**
    * Gets the tree associated with this helper.
    */
   get tree()
   {
     return this._tree;
   },
   /**
    * Sets the tree that this module handles.  The tree is assigned a new view
    * that is equipped to handle contiguous selection.  You can pass in an
    * object that will be used as the prototype of the new view.  Otherwise
    * the tree's current view is used as the prototype.
    *
    * @param  aTreeElement
    *         The tree element
    * @param  aProtoTreeView
    *         If defined, this will be used as the prototype of the tree's new
    *         view
    * @return The new view
    */
   setTree: function CSTH_setTree(aTreeElement, aProtoTreeView)
   {
     this._tree = aTreeElement;
     var newView = this._makeTreeView(aProtoTreeView || aTreeElement.view);
     aTreeElement.view = newView;
     return newView;
   },
   /**
    * The index of the row that the grippy occupies.  Note that the index of the
    * last selected row is getGrippyRow() - 1.  If getGrippyRow() is 0, then
    * no selection exists.
    *
    * @return The row index of the grippy
    */
   getGrippyRow: function CSTH_getGrippyRow()
   {
     var sel = this.tree.view.selection;
     var rangeCount = sel.getRangeCount();
     if (rangeCount === 0)
       return 0;
     if (rangeCount !== 1) {
       throw "contiguous selection tree helper: getGrippyRow called with " +
             "multiple selection ranges";
     }
     var max = {};
     sel.getRangeAt(0, {}, max);
     return max.value + 1;
   },
   /**
    * Helper function for the dragover event.  Your dragover listener should
    * call this.  It updates the selection in the tree under the mouse.
    *
    * @param aEvent
    *        The observed dragover event
    */
   ondragover: function CSTH_ondragover(aEvent)
   {
     // Without this when dragging on Windows the mouse cursor is a "no" sign.
     // This makes it a drop symbol.
     var ds = Cc["@mozilla.org/widget/dragservice;1"].
              getService(Ci.nsIDragService).
              getCurrentSession();
     ds.canDrop = true;
     ds.dragAction = 0;
     var tbo = this.tree.treeBoxObject;
     aEvent.QueryInterface(Ci.nsIDOMMouseEvent);
     var hoverRow = tbo.getRowAt(aEvent.clientX, aEvent.clientY);
     if (hoverRow < 0)
       return;
     this.rangedSelect(hoverRow - 1);
   },
   /**
    * Helper function for the dragstart event.  Your dragstart listener should
    * call this.  It starts a drag session.
    *
    * @param aEvent
    *        The observed dragstart event
    */
   ondragstart: function CSTH_ondragstart(aEvent)
   {
     var tbo = this.tree.treeBoxObject;
     var clickedRow = tbo.getRowAt(aEvent.clientX, aEvent.clientY);
     if (clickedRow !== this.getGrippyRow())
       return;
     // This part is a hack.  What we really want is a grab and slide, not
     // drag and drop.  Start a move drag session with dummy data and a
     // dummy region.  Set the region's coordinates to (Infinity, Infinity)
     // so it's drawn offscreen and its size to (1, 1).
     var arr = Cc["@mozilla.org/supports-array;1"].
               createInstance(Ci.nsISupportsArray);
     var trans = Cc["@mozilla.org/widget/transferable;1"].
                 createInstance(Ci.nsITransferable);
     trans.init(null);
     trans.setTransferData('dummy-flavor', null, 0);
     arr.AppendElement(trans);
     var reg = Cc["@mozilla.org/gfx/region;1"].
               createInstance(Ci.nsIScriptableRegion);
     reg.setToRect(Infinity, Infinity, 1, 1);
     var ds = Cc["@mozilla.org/widget/dragservice;1"].
              getService(Ci.nsIDragService);
     ds.invokeDragSession(aEvent.target, arr, reg, ds.DRAGDROP_ACTION_MOVE);
   },
   /**
    * Helper function for the keypress event.  Your keypress listener should
    * call this.  Users can use Up, Down, Page Up/Down, Home, and End to move
    * the bottom of the selection window.
    *
    * @param aEvent
    *        The observed keypress event
    */
   onkeypress: function CSTH_onkeypress(aEvent)
   {
     var grippyRow = this.getGrippyRow();
     var tbo = this.tree.treeBoxObject;
     var rangeEnd;
     switch (aEvent.keyCode) {
     case aEvent.DOM_VK_HOME:
       rangeEnd = 0;
       break;
     case aEvent.DOM_VK_PAGE_UP:
       rangeEnd = grippyRow - tbo.getPageLength();
       break;
     case aEvent.DOM_VK_UP:
       rangeEnd = grippyRow - 2;
       break;
     case aEvent.DOM_VK_DOWN:
       rangeEnd = grippyRow;
       break;
     case aEvent.DOM_VK_PAGE_DOWN:
       rangeEnd = grippyRow + tbo.getPageLength();
       break;
     case aEvent.DOM_VK_END:
       rangeEnd = this.tree.view.rowCount - 2;
       break;
     default:
       return;
       break;
     }
     aEvent.stopPropagation();
     // First, clip rangeEnd.  this.rangedSelect() doesn't clip the range if we
     // select past the ends of the tree.
     if (rangeEnd < 0)
       rangeEnd = -1;
     else if (this.tree.view.rowCount - 2 < rangeEnd)
       rangeEnd = this.tree.view.rowCount - 2;
     // Next, (de)select.
     this.rangedSelect(rangeEnd);
     // Finally, scroll the tree.  We always want one row above and below the
     // grippy row to be visible if possible.
     if (rangeEnd < grippyRow) // moved up
       tbo.ensureRowIsVisible(rangeEnd < 0 ? 0 : rangeEnd);
     else {                    // moved down
       if (rangeEnd + 2 < this.tree.view.rowCount)
         tbo.ensureRowIsVisible(rangeEnd + 2);
       else if (rangeEnd + 1 < this.tree.view.rowCount)
         tbo.ensureRowIsVisible(rangeEnd + 1);
     }
   },
   /**
    * Helper function for the mousedown event.  Your mousedown listener should
    * call this.  Users can click on individual rows to make the selection
    * jump to them immediately.
    *
    * @param aEvent
    *        The observed mousedown event
    */
   onmousedown: function CSTH_onmousedown(aEvent)
   {
     var tbo = this.tree.treeBoxObject;
     var clickedRow = tbo.getRowAt(aEvent.clientX, aEvent.clientY);
     if (clickedRow < 0 || clickedRow >= this.tree.view.rowCount)
       return;
     if (clickedRow < this.getGrippyRow())
       this.rangedSelect(clickedRow);
     else if (clickedRow > this.getGrippyRow())
       this.rangedSelect(clickedRow - 1);
   },
   /**
    * Selects range [0, aEndRow] in the tree.  The grippy row will then be at
    * index aEndRow + 1.  aEndRow may be -1, in which case the selection is
    * cleared and the grippy row will be at index 0.
    *
    * @param aEndRow
    *        The range [0, aEndRow] will be selected.
    */
   rangedSelect: function CSTH_rangedSelect(aEndRow)
   {
     var tbo = this.tree.treeBoxObject;
     if (aEndRow < 0)
       this.tree.view.selection.clearSelection();
     else
       this.tree.view.selection.rangedSelect(0, aEndRow, false);
     tbo.invalidateRange(tbo.getFirstVisibleRow(), tbo.getLastVisibleRow());
   },
   /**
    * Scrolls the tree so that the grippy row is in the center of the view.
    */
   scrollToGrippy: function CSTH_scrollToGrippy()
   {
     var rowCount = this.tree.view.rowCount;
     var tbo = this.tree.treeBoxObject;
     var pageLen = tbo.getPageLength() ||
                   parseInt(this.tree.getAttribute("rows")) ||
 ;
     // All rows fit on a single page.
     if (rowCount <= pageLen)
       return;
     var scrollToRow = this.getGrippyRow() - Math.ceil(pageLen / 2.0);
     // Grippy row is in first half of first page.
     if (scrollToRow < 0)
       scrollToRow = 0;
     // Grippy row is in last half of last page.
     else if (rowCount < scrollToRow + pageLen)
       scrollToRow = rowCount - pageLen;
     tbo.scrollToRow(scrollToRow);
   },
   /**
    * Creates a new tree view suitable for contiguous selection.  If
    * aProtoTreeView is specified, it's used as the new view's prototype.
    * Otherwise the tree's current view is used as the prototype.
    *
    * @param aProtoTreeView
    *        Used as the new view's prototype if specified
    */
   _makeTreeView: function CSTH__makeTreeView(aProtoTreeView)
   {
     var view = aProtoTreeView;
     var that = this;
     //XXXadw: When Alex gets the grippy icon done, this may or may not change,
     //        depending on how we style it.
     view.isSeparator = function CSTH_View_isSeparator(aRow)
     {
       return aRow === that.getGrippyRow();
     };
     // rowCount includes the grippy row.
     view.__defineGetter__("_rowCount", view.__lookupGetter__("rowCount"));
     view.__defineGetter__("rowCount",
       function CSTH_View_rowCount()
       {
         return this._rowCount + 1;
       });
     // This has to do with visual feedback in the view itself, e.g., drawing
     // a small line underneath the dropzone.  Not what we want.
     view.canDrop = function CSTH_View_canDrop() { return false; };
     // No clicking headers to sort the tree or sort feedback on columns.
     view.cycleHeader = function CSTH_View_cycleHeader() {};
     view.sortingChanged = function CSTH_View_sortingChanged() {};
     // Override a bunch of methods to account for the grippy row.
     view._getCellProperties = view.getCellProperties;
     view.getCellProperties =
       function CSTH_View_getCellProperties(aRow, aCol)
       {
         var grippyRow = that.getGrippyRow();
         if (aRow === grippyRow)
           return "grippyRow";
         if (aRow < grippyRow)
           return this._getCellProperties(aRow, aCol);
         return this._getCellProperties(aRow - 1, aCol);
       };
     view._getRowProperties = view.getRowProperties;
     view.getRowProperties =
       function CSTH_View_getRowProperties(aRow)
       {
         var grippyRow = that.getGrippyRow();
         if (aRow === grippyRow)
           return "grippyRow";
         if (aRow < grippyRow)
           return this._getRowProperties(aRow);
         return this._getRowProperties(aRow - 1);
       };
     view._getCellText = view.getCellText;
     view.getCellText =
       function CSTH_View_getCellText(aRow, aCol)
       {
         var grippyRow = that.getGrippyRow();
         if (aRow === grippyRow)
           return "";
         aRow = aRow < grippyRow ? aRow : aRow - 1;
         return this._getCellText(aRow, aCol);
       };
     view._getImageSrc = view.getImageSrc;
     view.getImageSrc =
       function CSTH_View_getImageSrc(aRow, aCol)
       {
         var grippyRow = that.getGrippyRow();
         if (aRow === grippyRow)
           return "";
         aRow = aRow < grippyRow ? aRow : aRow - 1;
         return this._getImageSrc(aRow, aCol);
       };
     view.isContainer = function CSTH_View_isContainer(aRow) { return false; };
     view.getParentIndex = function CSTH_View_getParentIndex(aRow) { return -1; };
     view.getLevel = function CSTH_View_getLevel(aRow) { return 0; };
     view.hasNextSibling = function CSTH_View_hasNextSibling(aRow, aAfterIndex)
     {
       return aRow < this.rowCount - 1;
     };
     return view;
   }
 };
 #endif