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

 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")) ||

                   10;

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