diff --git a/browser/components/places/content/placesOverlay.xul b/browser/components/places/content/placesOverlay.xul
index b53c675adc2e..552a6f3ba5b7 100644
--- a/browser/components/places/content/placesOverlay.xul
+++ b/browser/components/places/content/placesOverlay.xul
@@ -54,6 +54,8 @@
src="chrome://browser/content/places/utils.js"/>
+
-
+
(original author)
+ * Asaf Romano (Javascript version)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+PlacesTreeView.prototype = {
+ _makeAtom: function PTV__makeAtom(aString) {
+ return Cc["@mozilla.org/atom-service;1"].
+ getService(Ci.nsIAtomService).
+ getAtom(aString);
+ },
+
+ __containerAtom: null,
+ get _containerAtom() {
+ if (!this.__containerAtom)
+ this.__containerAtom = this._makeAtom("container");
+
+ return this.__containerAtom;
+ },
+
+ __sessionStartAtom: null,
+ get _sessionStartAtom() {
+ if (!this.__sessionStartAtom)
+ this.__sessionStartAtom = this._makeAtom("session-start");
+
+ return this.__sessionStartAtom;
+ },
+
+ __sessionContinueAtom: null,
+ get _sessionContinueAtom() {
+ if (!this.__sessionContinueAtom)
+ this.__sessionContinueAtom = this._makeAtom("session-continue");
+
+ return this.__sessionContinueAtom;
+ },
+
+ _ensureValidRow: function PTV__ensureValidRow(aRow) {
+ if (aRow < 0 || aRow > this._visibleElements.length)
+ throw Cr.NS_ERROR_INVALID_ARG;
+ },
+
+ __dateService: null,
+ get _dateService() {
+ if (!this.__dateService) {
+ this.__dateService = Cc["@mozilla.org/intl/scriptabledateformat;1"].
+ getService(Ci.nsIScriptableDateFormat);
+ }
+ return this.__dateService;
+ },
+
+ QueryInterface: function PTV_QueryInterface(aIID) {
+ if (aIID.equals(Ci.nsITreeView) ||
+ aIID.equals(Ci.nsINavHistoryResultViewer) ||
+ aIID.equals(Ci.nsINavHistoryResultTreeViewer) ||
+ aIID.equals(Ci.nsISupports))
+ return this;
+
+ throw Cr.NS_ERROR_NO_INTERFACE;
+ },
+
+ /**
+ * This is called when the result or tree may have changed.
+ * It reinitializes everything. Result and/or tree can be null
+ * when calling.
+ */
+ _finishInit: function PTV__finishInit() {
+ if (this._tree && this._result) {
+ this._result.root
+ .QueryInterface(Ci.nsINavHistoryContainerResultNode)
+ .containerOpen = true;
+ this.sortingChanged(this._result.sortingMode);
+ }
+
+ // if there is no tree, BuildVisibleList will clear everything for us
+ this._buildVisibleList();
+ },
+
+ _computeShowSessions: function PTV__computeShowSessions() {
+ NS_ASSERT(this._result, "Must have a result to show sessions!");
+ this._showSessions = false;
+
+ var options = asQuery(this._result.root).queryOptions;
+ NS_ASSERT(options, "navHistoryResults must have valid options");
+
+ if (!options.showSessions)
+ return; // sessions are off
+
+ var resultType = options.resultType;
+ if (resultType != Ci.nsINavHistoryQueryOptions.RESULTS_AS_VISIT &&
+ resultType != Ci.nsINavHistoryQueryOptions.RESULTS_AS_FULL_VISIT)
+ return; // not visits
+
+ var sortType = this._result.sortingMode;
+ if (sortType != nsINavHistoryQueryOptions::SORT_BY_DATE_ASCENDING &&
+ sortType != nsINavHistoryQueryOptions::SORT_BY_DATE_DESCENDING)
+ return; // not date sorting
+
+ // showing sessions only makes sense if we are grouping by date
+ // any other grouping (or recursive grouping) doesn't make sense
+ var groupings = options.getGroupingMode({});
+ for (var i=0; i < groupings.length; i++) {
+ if (groupings[i] != Ci.nsINavHistoryQueryOptions.GROUP_BY_DAY)
+ return; // non-time-based grouping
+ }
+
+ this._showSessions = true;
+ },
+
+ SESSION_STATUS_NONE: 0,
+ SESSION_STATUS_START: 1,
+ SESSION_STATUS_CONTINUE: 2,
+ _getRowSessionStatus: function PTV__getRowSessionStatus(aRow) {
+ this._ensureValidRow(aRow);
+ var node = this._visibleElements[aRow];
+ if (!PlacesUtils.nodeIsVisit(node) || asVisit(node).sessionId == 0)
+ return this.SESSION_STATUS_NONE;
+
+ if (aRow == 0)
+ return this.SESSION_STATUS_START;
+
+ var previousNode = this._visibleElements[aRow - 1];
+ if (!PlacesUtils.nodeIsVisit(previousNode) ||
+ node.sessionId != asVisit(previousNode).sessionId)
+ return this.SESSION_STATUS_START;
+
+ return this.SESSION_STATUS_CONTINUE;
+ },
+
+ /**
+ * Call to completely rebuild the list of visible items. Note if there is no
+ * tree or root this will just clear out the list, so you can also call this
+ * when a tree is detached to clear the list.
+ *
+ * This does NOT update the screen.
+ */
+ _buildVisibleList: function PTV__buildVisibleList() {
+ if (this._result) {
+ // Any current visible elements need to be marked as invisible.
+ for (var i = 0; i < this._visibleElements.length; i++) {
+ this._visibleElements[i].viewIndex = -1;
+ }
+ }
+ this._visibleElements.splice(0);
+
+ if (this._result.root && this._tree) {
+ this._computeShowSessions();
+ this._buildVisibleSection(asContainer(this._result.root),
+ this._visibleElements, 0);
+ }
+ },
+
+ /**
+ * This takes a container and recursively appends visible elements to the
+ * given array. This is used to build the visible element list (with
+ * this._visibleElements passed as the array), or portions thereof (with
+ * a separate array that is merged with the main list later.
+ *
+ * aVisibleStartIndex is the visible index of the beginning of the 'aVisible'
+ * array. When aVisible is this._visibleElements, this is 0. This is non-zero
+ * when we are building up a sub-region for insertion. Then, this is the
+ * index where the new array will be inserted into this._visibleElements.
+ * It is used to compute each node's viewIndex.
+ */
+ _buildVisibleSection:
+ function PTV__buildVisibleSection(aContainer, aVisible, aVisibleStartIndex)
+ {
+ if (!aContainer.containerOpen)
+ return; // nothing to do
+
+ var cc = aContainer.childCount;
+ for (var i=0; i < cc; i++) {
+ var curChild = aContainer.getChild(i);
+
+ // collapse all duplicates starting from here
+ if (this._collapseDuplicates) {
+ var showThis = { value: false };
+ while (i < cc - 1 &&
+ this._canCollapseDuplicates(curChild, aContainer.getChild(i+1),
+ showThis)) {
+ if (showThis.value) {
+ // collapse the first and use the second
+ curChild.viewIndex = -1;
+ curChild = aContainer.getChild(i+1);
+ }
+ else {
+ // collapse the second and use the first
+ aContainer.getChild(i+1).viewIndex = -1;
+ }
+ i++;
+ }
+ }
+
+ // don't display separators when sorted
+ if (PlacesUtils.nodeIsSeparator(curChild)) {
+ if (this._result.sortingMode !=
+ Ci.nsINavHistoryQueryOptions.SORT_BY_NONE) {
+ curChild.viewIndex = -1;
+ continue;
+ }
+ }
+
+ // add item
+ curChild.viewIndex = aVisibleStartIndex + aVisible.length;
+ aVisible.push(curChild);
+
+ // recursively do containers
+ if (PlacesUtils.nodeIsContainer(curChild)) {
+ asContainer(curChild);
+ if (curChild.containerOpen && curChild.childCount > 0)
+ this._buildVisibleSection(curChild, aVisible, aVisibleStartIndex);
+ }
+ }
+ },
+
+ /**
+ * This counts how many rows an item takes in the tree, that is, the
+ * item itself plus any nodes following it with an increased indent.
+ * This allows you to figure out how many rows an item (=1) or a
+ * container with all of its children takes.
+ */
+ _countVisibleRowsForItem: function PTV__countVisibleRowsForItem(aNode) {
+ var viewIndex = aNode.viewIndex;
+ NS_ASSERT(viewIndex >= 0, "Item is not visible, no rows to count");
+ var outerLevel = aNode.indentLevel;
+ for (var i = viewIndex + 1; i < this._visibleElements.length; i++) {
+ if (this._visibleElements[i].indentLevel <= outerLevel)
+ return i - viewIndex;
+ }
+ // this node plus its children occupy the bottom of the list
+ return this._visibleElements.length - viewIndex;
+ },
+
+ /**
+ * This is called by containers when they change and we need to update
+ * everything about the container. We build a new visible section with
+ * the container as a separate object so we first know how the list
+ * changes. This way we only have to do one realloc/memcpy to update
+ * the list.
+ *
+ * We also try to be smart here about redrawing the screen.
+ */
+ _refreshVisibleSection: function PTV__refreshVisibleSection(aContainer) {
+ NS_ASSERT(this._result, "Need to have a result to update");
+ if (!this._tree)
+ return;
+
+ // The root node is invisible, so we can't check its index and indent
+ // level. Therefore, special case it. This is easy because we just
+ // rebuild everything
+ if (aContainer == this._result.root) {
+ this._buildVisibleList();
+ return;
+ }
+
+ // When the container is not the root, it better be visible if we are
+ // updating
+ if (aContainer.viewIndex < 0 &&
+ aContainer.viewIndex > this._visibleElements.length)
+ throw "Trying to expand a node that is not visible";
+ NS_ASSERT(this._visibleElements[aContainer.viewIndex] == aContainer,
+ "Visible index is out of sync!");
+
+ var startReplacement = aContainer.viewIndex + 1;
+ var replaceCount = this._countVisibleRowsForItem(aContainer) - 1;
+
+ // Mark the removees as invisible
+ for (var i = startReplacement; i < replaceCount; i ++)
+ this._visibleElements[startReplacement + i].viewIndex = -1;
+
+ // Building the new list will set the new elements' visible indices.
+ var newElements = [];
+ this._buildVisibleSection(aContainer, newElements, startReplacement);
+
+ // actually update the visible list
+ this._visibleElements =
+ this._visibleElements.slice(0, startReplacement).concat(newElements)
+ .concat(this._visibleElements.slice(startReplacement + replaceCount,
+ this._visibleElements.length));
+
+ if (replaceCount == newElements.length) {
+ // length is the same, just repaint the changed area
+ if (replaceCount > 0) {
+ this._tree.invalidateRange(startReplacement,
+ startReplacement + replaceCount - 1);
+ }
+ }
+ else {
+ // If the new area hasa different size, we'll have to renumber the
+ // elements following the area.
+ for (i = startReplacement + newElements.length;
+ i < this._visibleElements.length; i ++) {
+ this._visibleElements[i].viewIndex = i;
+ }
+
+ // repaint the region in which we didn't change the viewIndexs, also
+ // including the container element itself since its twisty could have
+ // changed.
+ var minLength = Math.min(newElements.length, replaceCount);
+ this._tree.invalidateRange(startReplacement - 1,
+ startReplacement + minLength - 1);
+
+ // now update the number of elements
+ this._tree.rowCountChanged(startReplacement + minLength,
+ newElements.length - replaceCount);
+ }
+ },
+
+ /**
+ * This returns true if the two results can be collapsed as duplicates.
+ * aShowThisOne will be either 0 or 1, indicating which of the
+ * duplicates should be shown.
+ */
+ _canCollapseDuplicates:
+ function PTV__canCollapseDuplicate(aTop, aNext, aShowThisOne) {
+ if (!this._collapseDuplicates)
+ return false;
+ if (!PlacesUtils.nodeIsVisit(aTop) ||
+ !PlacesUtils.nodeIsVisit(aNext))
+ return false; // only collapse two visits
+
+ asVisit(aTop);
+ asVisit(aNext);
+
+ if (aTop.uri != aNext.uri)
+ return false; // don't collapse nonmatching URIs
+
+ // now we know we want to collapse, show the one with the more recent time
+ aShowThisOne.value = aTop.time < aNext.time;
+ return true;
+ },
+
+ COLUMN_TYPE_UNKNOWN: 0,
+ COLUMN_TYPE_TITLE: 1,
+ COLUMN_TYPE_URI: 2,
+ COLUMN_TYPE_DATE: 3,
+ COLUMN_TYPE_VISITCOUNT: 4,
+ _getColumnType: function PTV__getColumnType(aColumn) {
+ switch (aColumn.id) {
+ case "title":
+ return this.COLUMN_TYPE_TITLE;
+ case "url":
+ return this.COLUMN_TYPE_URI;
+ case "date":
+ return this.COLUMN_TYPE_DATE;
+ case "visitCount":
+ return this.COLUMN_TYPE_VISITCOUNT;
+ }
+ return this.COLUMN_TYPE_UNKNOWN;
+ },
+
+ _sortTypeToColumnType: function PTV__sortTypeToColumnType(aSortType) {
+ switch(aSortType) {
+ case Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_ASCENDING:
+ return [this.COLUMN_TYPE_TITLE, false];
+ case Ci.nsINavHistoryQueryOptions.SORT_BY_TITLE_DESCENDING:
+ return [this.COLUMN_TYPE_TITLE, true];
+ case Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_ASCENDING:
+ return [this.COLUMN_TYPE_DATA, false];
+ case Ci.nsINavHistoryQueryOptions.SORT_BY_DATE_DESCENDING:
+ return [this.COLUMN_TYPE_DATA, true];
+ case Ci.nsINavHistoryQueryOptions.SORT_BY_URI_ASCENDING:
+ return [this.COLUMN_TYPE_URI, false];
+ case Ci.nsINavHistoryQueryOptions.SORT_BY_URI_DESCENDING:
+ return [this.COLUMN_TYPE_URI, true];
+ case Ci.nsINavHistoryQueryOptions.SORT_BY_VISITCOUNT_ASCENDING:
+ return [this.COLUMN_TYPE_VISITCOUNT, false];
+ case Ci.nsINavHistoryQueryOptions.SORT_BY_VISITCOUNT_DESCENDING:
+ return [this.COLUMN_TYPE_VISITCOUNT, true];
+ }
+ return [this.COLUMN_TYPE_UNKNOWN, false];
+ },
+
+ // nsINavHistoryResultViewer
+ itemInserted: function PTV_itemInserted(aParent, aItem, aNewIndex) {
+ if (!this._tree)
+ return;
+ if (!this._result)
+ throw Cr.NS_ERROR_UNEXPECTED;
+
+ if (PlacesUtils.nodeIsSeparator(aItem) &&
+ this._result.sortingMode != Ci.nsINavHistoryQueryOptions.SORT_BY_NONE) {
+ aItem.viewIndex = -1;
+ return;
+ }
+
+ // update parent when inserting the first item because twisty may
+ // have changed
+ if (aParent.childCount == 1)
+ this.itemChanged(aParent);
+
+ // compute the new view index of the item
+ var newViewIndex = -1;
+ if (aNewIndex == 0) {
+ // item is the first thing in our child list, it takes our index +1. Note
+ // that this computation still works if the parent is an invisible root
+ // node, because root_index + 1 = -1 + 1 = 0
+ newViewIndex = aParent.viewIndex + 1;
+ }
+ else {
+ // Here, we try to find the next visible element in the child list so we
+ // can set the new visible index to be right before that. Note that we
+ // have to search DOWN instead of up, because some siblings could have
+ // children themselves that would be in the way.
+ for (var i = aNewIndex + 1; i < aParent.childCount; i ++) {
+ var viewIndex = aParent.getChild(i).viewIndex;
+ if (viewIndex >= 0) {
+ // the view indices of subsequent children have not been shifted so
+ // the next item will have what should be our index
+ newViewIndex = viewIndex;
+ break;
+ }
+ }
+ if (newViewIndex < 0) {
+ // At the end of the child list without finding a visible sibling: This
+ // is a little harder because we don't know how many rows the last item
+ // in our list takes up (it could be a container with many children).
+ var lastRowCount =
+ this._countVisibleRowsForItem(aParent.getChild(aNewIndex - 1));
+ newViewIndex =
+ aParent.getChild(aNewIndex - 1).viewIndex + lastRowCount;
+ }
+ }
+
+ // Try collapsing with the previous node. Note that we do not have to try
+ // to redraw the surrounding rows (which we normally would because session
+ // boundaries may have changed) because when an item is merged, it will
+ // always be in the same session.
+ var showThis = { value: true };
+ if (newViewIndex > 0 &&
+ this._canCollapseDuplicates
+ (this._visibleElements[newViewIndex - 1], aItem, showThis)) {
+ if (!showThis.value) {
+ // new node is invisible, collapsed with previous one
+ aItem.viewIndex = -1;
+ }
+ else {
+ // new node replaces the previous
+ this.itemReplaced(aParent, this._visibleElements[newViewIndex - 1],
+ aItem, 0);
+ }
+ return;
+ }
+
+ // try collapsing with the next node (which is currently at the same
+ // index we are trying to insert at)
+ if (newViewIndex < this._visibleElements.length &&
+ this._canCollapseDuplicates(aItem, this._visibleElements[newViewIndex],
+ showThis)) {
+ if (!showThis.value) {
+ // new node replaces the next node
+ this.itemReplaced(aParent, this._visibleElements[newViewIndex], aItem,
+ 0);
+ }
+ else {
+ // new node is invisible, replaced by next one
+ aItem.viewIndex = -1;
+ }
+ return;
+ }
+
+ // no collapsing, insert new item
+ aItem.viewIndex = newViewIndex;
+ this._visibleElements.splice(newViewIndex, 0, aItem);
+ for (var i = newViewIndex + 1;
+ i < this._visibleElements.length; i ++) {
+ this._visibleElements[i].viewIndex = i;
+ }
+ this._tree.rowCountChanged(newViewIndex, 1);
+
+ // Need to redraw the rows around this one because session boundaries
+ // may have changed. For example, if we add a page to a session, the
+ // previous page will need to be redrawn because it's session border
+ // will disappear.
+ if (this._showSessions) {
+ if (newViewIndex > 0)
+ this._tree.invalidateRange(newViewIndex - 1, newViewIndex - 1);
+ if (newViewIndex < this._visibleElements.length -1)
+ this._tree.invalidateRange(newViewIndex + 1, newViewIndex + 1);
+ }
+
+ if (PlacesUtils.nodeIsContainer(aItem) && asContainer(aItem).containerOpen)
+ this._refreshVisibleSection(aItem);
+ },
+
+ /**
+ * THIS FUNCTION DOES NOT HANDLE cases where a collapsed node is being
+ * removed but the node it is collapsed with is not being removed (this then
+ * just swap out the removee with it's collapsing partner). The only time
+ * when we really remove things is when deleting URIs, which will apply to
+ * all collapsees. This function is called sometimes when resorting items.
+ * However, we won't do this when sorted by date because dates will never
+ * change for visits, and date sorting is the only time things are collapsed.
+ */
+ itemRemoved: function PTV_itemRemoved(aParent, aItem, aOldIndex) {
+ NS_ASSERT(this._result, "Got a notification but have no result!");
+ if (!this._tree)
+ return; // nothing to do
+
+ var oldViewIndex = aItem.viewIndex;
+ if (oldViewIndex < 0)
+ return; // item was already invisible, nothing to do
+
+ // this may have been a container, in which case it has a lot of rows
+ var count = this._countVisibleRowsForItem(aItem);
+
+ // We really want tail recursion here, since we sometimes do another
+ // remove after this when duplicates are being collapsed. This loop
+ // emulates that.
+ while (true) {
+ NS_ASSERT(oldViewIndex <= this._visibleElements.length,
+ "Trying to remove invalid row");
+ if (oldViewIndex > this._visibleElements.length)
+ return;
+
+ this._visibleElements.splice(oldViewIndex, count);
+ for (var i = oldViewIndex; i < this._visibleElements.length; i++)
+ this._visibleElements[i].viewIndex = i;
+
+ this._tree.rowCountChanged(oldViewIndex, -count);
+
+ // the removal might have put two things together that should be collapsed
+ if (oldViewIndex > 0 &&
+ oldViewIndex < this._visibleElements.length) {
+ var showThisOne = { value: true };
+ if (this._canCollapseDuplicates
+ (this._visibleElements[oldViewIndex - 1],
+ this._visibleElements[oldViewIndex], showThisOne))
+ {
+ // Fake-tail-recurse to the beginning of this function to
+ // remove the collapsed row. Note that we need to set the
+ // visible index to -1 before looping because we can never
+ // touch the row we're removing (callers may have already
+ // destroyed it).
+ oldViewIndex = oldViewIndex - 1 + (showThisOne.value ? 1 : 0);
+ this._visibleElements[oldViewIndex].viewIndex = -1;
+ count = 1; // next time remove one row
+ continue;
+ }
+ }
+ break; // normal path: just remove once
+ }
+
+ // redraw parent because twisty may have changed
+ if (!aParent.hasChildren)
+ this.itemChanged(aParent);
+ },
+
+ /**
+ * Be careful, the parameter 'aIndex' here specifies the index in the parent
+ * node of the item, not the visible index.
+ *
+ * This is called from the result when the item is replaced, but this object
+ * calls this function internally also when duplicate collapsing changes. In
+ * this case, aIndex will be 0, so we should be careful not to use the value.
+ */
+ itemReplaced:
+ function PTV_itemReplaced(aParent, aOldItem, aNewItem, aIndexDoNotUse) {
+ if (!this._tree)
+ return;
+
+ var viewIndex = aOldItem.viewIndex;
+ aNewItem.viewIndex = viewIndex;
+ if (viewIndex >= 0 &&
+ viewIndex < this._visibleElements.length)
+ this._visibleElements[viewIndex] = aNewItem;
+ aOldItem.viewIndex = -1;
+ this._tree.invalidateRow(viewIndex);
+ },
+
+ itemChanged: function PTV_itemChanged(aItem) {
+ NS_ASSERT(this._result, "Got a notification but have no result!");
+ var viewIndex = aItem.viewIndex;
+ if (this._tree && viewIndex >= 0)
+ this._tree.invalidateRow(viewIndex);
+ },
+
+ containerOpened: function PTV_containerOpened(aItem) {
+ this.invalidateContainer(aItem);
+ },
+
+ containerClosed: function PTV_containerClosed(aItem) {
+ this.invalidateContainer(aItem);
+ },
+
+ invalidateContainer: function PTV_invalidateContainer(aItem) {
+ NS_ASSERT(this._result, "Got a notification but have no result!");
+ if (!this._tree)
+ return; // nothing to do, container is not visible
+ var viewIndex = aItem.viewIndex;
+ if (viewIndex >= this._visibleElements.length) {
+ // be paranoid about visible indices since others can change it
+ throw Cr.NS_ERROR_UNEXPECTED;
+ }
+ this._refreshVisibleSection(aItem);
+ },
+
+ invalidateAll: function PTV_invalidateAll() {
+ NS_ASSERT(this._result, "Got message but don't have a result!");
+ if (!this._tree)
+ return;
+
+ var oldRowCount = this._visibleElements.length;
+
+ // update flat list to new contents
+ this._buildVisibleList();
+
+ // redraw the tree, inserting new items
+ this._tree.rowCountChanged(0, this._visibleElements.length - oldRowCount);
+ this._tree.invalidate();
+ },
+
+ sortingChanged: function PTV__sortingChanged(aSortingMode) {
+ if (!this._tree || !this._result)
+ return;
+
+ var columns = this._tree.columns;
+
+ // clear old sorting indicator
+ var sortedColumn = columns.getSortedColumn();
+ if (sortedColumn)
+ sortedColumn.element.removeAttribute("sortDirection");
+
+ // set new sorting indicator by looking through all columns for ours
+ if (aSortingMode == Ci.nsINavHistoryQueryOptions.SORT_BY_NONE)
+ return;
+ var [desiredColumn, desiredIsDescending] =
+ this._sortTypeToColumnType(aSortingMode);
+ var colCount = columns.count;
+ for (var i = 0; i < colCount; i ++) {
+ var column = columns.getColumnAt(i);
+ if (this._getColumnType(column) == desiredColumn) {
+ // found our desired one, set
+ if (desiredIsDescending)
+ column.element.setAttribute("sortDirection", "descending");
+ else
+ column.element.setAttribute("sortDirection", "ascending");
+ break;
+ }
+ }
+ },
+
+ get result() {
+ return this._result;
+ },
+
+ set result(val) {
+ this._result = val;
+ this._finishInit();
+ return val;
+ },
+
+ addViewObserver: function PTV_addViewObserver(aObserver, aWeak) {
+ if (aWeak)
+ throw Cr.NS_ERROR_NOT_IMPLEMENTED;
+
+ if (this._observers.indexOf(aObserver) == -1)
+ this._observers.push(aObserver);
+ },
+
+ removeViewObserver: function PTV_removeViewObserver(aObserver) {
+ var index = this._observers.indexOf(aObserver);
+ if (index != -1)
+ this._observers.splice(index, 1);
+ },
+
+ _enumerateObservers: function PTV__enumerateObservers(aFunctionName, aArgs) {
+ for (var i=0; i < this._observers.length; i++) {
+ // Don't bail out if one of the observer threw
+ try {
+ var obs = this._observers[i];
+ obs[aFunctionName].apply(obs, aArgs);
+ }
+ catch (ex) { Components.reportError(ex); }
+ }
+ },
+
+ // nsINavHistoryResultTreeViewer
+ get collapseDuplicates() {
+ return this._collapseDuplicates;
+ },
+
+ set collapseDuplicates(val) {
+ if (this._collapseDuplicates == val)
+ return; // no change;
+
+ this._collapseDuplicates = val;
+ if (this._tree && this._result)
+ this.invalidateAll();
+
+ return val;
+ },
+
+ get flatItemCount() {
+ return this._visibleElements.length;
+ },
+
+ nodeForTreeIndex: function PTV_nodeForTreeIndex(aIndex) {
+ if (aIndex > this._visibleElements.length)
+ throw Cr.NS_ERROR_INVALID_ARG;
+
+ return this._visibleElements[aIndex];
+ },
+
+ treeIndexForNode: function PTV_treeNodeForIndex(aNode) {
+ var viewIndex = aNode.viewIndex;
+ if (viewIndex < 0)
+ return Ci.nsINavHistoryResultTreeViewer.INDEX_INVISIBLE;
+
+ NS_ASSERT(this._visibleElements[viewIndex] == aNode,
+ "Node's visible index and array out of sync");
+ return viewIndex;
+ },
+
+ // nsITreeView
+ get rowCount() {
+ return this._visibleElements.length;
+ },
+
+ get selection() {
+ return this._selection;
+ },
+
+ set selection(val) {
+ return this._selection = val;
+ },
+
+ getRowProperties: function PTV_getRowProperties(aRow, aProperties) {
+ this._ensureValidRow(aRow);
+ var node = this._visibleElements[aRow];
+
+ // Add the container property if it's applicable for this row.
+ if (PlacesUtils.nodeIsContainer(node))
+ aProperties.AppendElement(this._containerAtom);
+
+ // Next handle properties for session information.
+ if (!this._showSessions)
+ return;
+
+ switch(this._getRowSessionStatus(aRow)) {
+ case this.SESSION_STATUS_NONE:
+ break;
+ case this.SESSION_STATUS_START:
+ aProperties.AppendElement(this._sessionStartAtom);
+ break;
+ case this.SESSION_STATUS_CONTINUE:
+ aProperties.AppendElement(this._sessionContinueAtom);
+ break
+ }
+ },
+
+ getCellProperties: function(aRow, aColumn, aProperties) { },
+ getColumnProperties: function(aColumn, aProperties) { },
+
+ isContainer: function PTV_isContainer(aRow) {
+ this._ensureValidRow(aRow);
+ var node = this._visibleElements[aRow];
+ if (PlacesUtils.nodeIsContainer(node)) {
+ // treat non-expandable queries as non-containers
+ if (PlacesUtils.nodeIsQuery(node)) {
+ asQuery(node);
+ if (node.queryOptions.expandQueries)
+ return true;
+ // the root node is always expandable
+ if (!node.parent)
+ return true;
+
+ return false;
+ }
+ return true;
+ }
+ return false;
+ },
+
+ isContainerOpen: function PTV_isContainerOpen(aRow) {
+ this._ensureValidRow(aRow);
+ if (!PlacesUtils.nodeIsContainer(this._visibleElements[aRow]))
+ throw Cr.NS_ERROR_INVALID_ARG;
+
+ return asContainer(this._visibleElements[aRow]).containerOpen;
+ },
+
+ isContainerEmpty: function PTV_isContainerOpen(aRow) {
+ this._ensureValidRow(aRow);
+ if (!PlacesUtils.nodeIsContainer(this._visibleElements[aRow]))
+ throw Cr.NS_ERROR_INVALID_ARG;
+
+ return !asContainer(this._visibleElements[aRow]).hasChildren;
+ },
+
+ isSeparator: function PTV_isSeparator(aRow) {
+ this._ensureValidRow(aRow);
+ return PlacesUtils.nodeIsSeparator(this._visibleElements[aRow]);
+ },
+
+ isSorted: function PTV_isSorted() {
+ return this._result.sortingMode !=
+ Components.interfaces.nsINavHistoryQueryOptions.SORT_BY_NONE;
+ },
+
+ canDrop: function PTV_canDrop(aRow, aOrientation) {
+ for (var i=0; i < this._observers.length; i++) {
+ if (this._observers[i].canDrop(aRow, aOrientation))
+ return true;
+ }
+ return false;
+ },
+
+ drop: function PTV_drop(aRow, aOrientation) {
+ this._enumerateObservers("onDrop", [aRow, aOrientation]);
+ },
+
+ getParentIndex: function PTV_getParentIndex(aRow) {
+ this._ensureValidRow(aRow);
+ var parent = this._visibleElements[aRow].parent;
+ if (!parent || parent.viewIndex < 0)
+ return -1;
+
+ return parent.viewIndex;
+ },
+
+ hasNextSibling: function PTV_hasNextSibling(aRow, aAfterIndex) {
+ this._ensureValidRow(aRow);
+ if (aRow == this._visibleElements.length -1) {
+ // this is the last thing in the list -> no next sibling
+ return false;
+ }
+
+ return this._visibleElements[aRow].indentLevel ==
+ this._visibleElements[aRow + 1].indentLevel;
+ },
+
+ getLevel: function PTV_getLevel(aRow) {
+ this._ensureValidRow(aRow);
+ return this._visibleElements[aRow].indentLevel;
+ },
+
+ getImageSrc: function PTV_getImageSrc(aRow, aColumn) {
+ this._ensureValidRow(aRow);
+
+ // only the first column has an image
+ if (aColumn.index != 0)
+ return "";
+
+ var node = this._visibleElements[aRow];
+
+ // Containers may or may not have favicons. If not, we will return
+ // nothing as the image, and the style rule should pick up the
+ // default. Separator rows never have icons.
+ if (PlacesUtils.nodeIsSeparator(node) ||
+ (PlacesUtils.nodeIsContainer(node) && !node.icon))
+ return "";
+
+ // For consistency, we always return a favicon for non-containers,
+ // even if it is just the default one.
+ var icon = node.icon || PlacesUtils.favicons.defaultFavicon;
+ if (icon)
+ return icon.spec;
+ },
+
+ getProgressMode: function(aRow, aColumn) { },
+ getCellValue: function(aRow, aColumn) { },
+
+ getCellText: function PTV_getCellText(aRow, aColumn) {
+ this._ensureValidRow(aRow);
+
+ var node = this._visibleElements[aRow];
+ switch (this._getColumnType(aColumn)) {
+ case this.COLUMN_TYPE_TITLE:
+ // normally, this is just the title, but we don't want empty items in
+ // the tree view so return a special string if the title is empty.
+ // Do it here so that callers can still get at the 0 length title
+ // if they go through the "result" API.
+ if (PlacesUtils.nodeIsSeparator(node))
+ return "";
+ return node.title || PlacesUtils.getString("noTitle");
+ case this.COLUMN_TYPE_URI:
+ if (PlacesUtils.nodeIsURI(node))
+ return node.uri;
+
+ return "";
+ case this.COLUMN_TYPE_DATE:
+ if (node.time == 0 || !PlacesUtils.nodeIsURI(node)) {
+ // hosts and days shouldn't have a value for the date column.
+ // Actually, you could argue this point, but looking at the
+ // results, seeing the most recently visited date is not what
+ // I expect, and gives me no information I know how to use.
+ // Only show this for URI-based items.
+ return "";
+ }
+ if (this._getRowSessionStatus(aRow) != this.SESSION_STATUS_CONTINUE) {
+ var nodeTime = node.time / 1000; // PRTime is in microseconds
+ var nodeTimeObj = new Date(nodeTime);
+
+ // Check if it is today and only display the time. Only bother
+ // checking for today if it's within the last 24 hours, since
+ // computing midnight is not really cheap. Sometimes we may get dates
+ // in the future, so always show those.
+ var ago = new Date(Date.now() - nodeTime);
+ var dateFormat = Ci.nsIScriptableDateFormat.dateFormatShort;
+ if (ago > -10000 && ago < (1000 * 24 * 60 * 60)) {
+ var midnight = new Date(nodeTime);
+ midnight.setHours(0);
+ midnight.setMinutes(0);
+ midnight.setSeconds(0);
+ midnight.setMilliseconds(0);
+
+ if (nodeTime > midnight.getTime())
+ dateFormat = Ci.nsIScriptableDateFormat.dateFormatNone;
+ }
+
+ return (this._dateService.FormatDateTime("", dateFormat,
+ Ci.nsIScriptableDateFormat.timeFormatNoSeconds,
+ nodeTimeObj.getFullYear(), nodeTimeObj.getMonth() + 1,
+ nodeTimeObj.getDate(), nodeTimeObj.getHours(),
+ nodeTimeObj.getMinutes(), nodeTimeObj.getSeconds()));
+ }
+ return "";
+ case this.COLUMN_TYPE_VISITCOUNT:
+ return node.accessCount;
+ }
+ return "";
+ },
+
+ setTree: function PTV_setTree(aTree) {
+ var hasOldTree = this._tree != null;
+ this._tree = aTree;
+
+ // do this before detaching from result when there is no tree.
+ // This ensures that the visible indices of the elements in the
+ // result have been set to -1
+ this._finishInit();
+
+ if (!aTree && hasOldTree && this._result) {
+ // detach from result when we are detaching from the tree.
+ // This breaks the reference cycle between us and the result.
+ this._result.viewer = null;
+ }
+ },
+
+ toggleOpenState: function PTV_toggleOpenState(aRow) {
+ if (!this._result)
+ throw Cr.NS_ERROR_UNEXPECTED;
+ this._ensureValidRow(aRow);
+
+ this._enumerateObservers("onToggleOpenState", [aRow]);
+
+ var node = this._visibleElements[aRow];
+ if (!PlacesUtils.nodeIsContainer(node))
+ return; // not a container, nothing to do
+
+ asContainer(node);
+ node.containerOpen = !node.containerOpen;
+ },
+
+ cycleHeader: function PTV_cycleHeader(aColumn) {
+ if (!this._result)
+ throw Cr.NS_ERROR_UNEXPECTED;
+
+ this._enumerateObservers("onCycleHeader", [aColumn]);
+
+ // Sometimes you want a tri-state sorting, and sometimes you don't. This
+ // rule allows tri-state sorting when the root node is a folder. This will
+ // catch the most common cases. When you are looking at folders, you want
+ // the third state to reset the sorting to the natural bookmark order. When
+ // you are looking at history, that third state has no meaning so we try
+ // to disallow it.
+ //
+ // The problem occurs when you have a query that results in bookmark
+ // folders. One example of this is the subscriptions view. In these cases,
+ // this rule doesn't allow you to sort those sub-folders by their natural
+ // order.
+ var allowTriState = PlacesUtils.nodeIsFolder(this._result.root);
+
+ var oldSort = this._result.sortingMode;
+ var newSort;
+ const NHQO = Ci.nsINavHistoryQueryOptions;
+ switch (this._getColumnType(aColumn)) {
+ case this.COLUMN_TYPE_TITLE:
+ if (oldSort == NHQO.SORT_BY_TITLE_ASCENDING)
+ newSort = NHQO.SORT_BY_TITLE_DESCENDING;
+ else if (allowTriState && oldSort == NHQO.SORT_BY_TITLE_DESCENDING)
+ newSort = NHQO.SORT_BY_NONE;
+ else
+ newSort = NHQO.SORT_BY_TITLE_ASCENDING;
+
+ break;
+ case this.COLUMN_TYPE_URI:
+ if (oldSort == NHQO.SORT_BY_URI_ASCENDING)
+ newSort = NHQO.SORT_BY_URI_DESCENDING;
+ else if (allowTriState && oldSort == NHQO.SORT_BY_URI_DESCENDING)
+ newSort = NHQO.SORT_BY_NONE;
+ else
+ newSort = NHQO.SORT_BY_URI_ASCENDING;
+
+ break;
+ case this.COLUMN_TYPE_DATE:
+ if (oldSort == NHQO.SORT_BY_DATE_ASCENDING)
+ newSort = NHQO.SORT_BY_DATE_DESCENDING;
+ else if (allowTriState &&
+ oldSort == NHQO.SORT_BY_DATE_DESCENDING)
+ newSort = NHQO.SORT_BY_NONE;
+ else
+ newSort = NHQO.SORT_BY_DATE_ASCENDING;
+
+ break;
+ case this.COLUMN_TYPE_VISITCOUNT:
+ // visit count default is unusual because we sort by descending
+ // by default because you are most likely to be looking for
+ // highly visited sites when you click it
+ if (oldSort == NHQO.SORT_BY_VISITCOUNT_DESCENDING)
+ newSort = NHQO.SORT_BY_VISITCOUNT_ASCENDING;
+ else if (allowTriState && oldSort == NHQO.SORT_BY_VISITCOUNT_ASCENDING)
+ newSort = NHQO.SORT_BY_NONE;
+ else
+ newSort = NHQO.SORT_BY_VISITCOUNT_DESCENDING;
+
+ break;
+ default:
+ throw Cr.NS_ERROR_INVALID_ARG;
+ }
+ this._result.sortingMode = newSort;
+ },
+
+ selectionChanged: function PTV_selectionChnaged() {
+ this._enumerateObservers("onSelectionChanged");
+ },
+
+ cycleCell: function PTV_cycleCell(aRow, aColumn) {
+ this._enumerateObservers("onCycleCell", [aRow, aColumn]);
+ },
+
+ isEditable: function(aRow, aColumn) { return false; },
+ isSelectable: function(aRow, aColumn) { return false; },
+ setCellText: function(aRow, aColumn) { },
+
+ performAction: function PTV_performAction(aAction) {
+ this._enumerateObservers("onPerformAction", [aAction]);
+ },
+
+ performActionOnRow: function PTV_perfromActionOnRow(aAction, aRow) {
+ this._enumerateObservers("onPerformActionOnRow", [aAction, aRow]);
+ },
+
+ performActionOnCell:
+ function PTV_performActionOnCell(aAction, aRow, aColumn) {
+ this._enumerateObservers("onPerformActionOnRow", [aAction, aRow, aColumn]);
+ }
+};
+
+function PlacesTreeView() {
+ this._tree = null;
+ this._result = null;
+ this._collapseDuplicates = true;
+ this._showSessions = false;
+ this._selection = null;
+ this._visibleElements = [];
+ this._observers = [];
+}
diff --git a/browser/components/places/content/utils.js b/browser/components/places/content/utils.js
index 407b692e915f..2ae1279c0a8a 100644
--- a/browser/components/places/content/utils.js
+++ b/browser/components/places/content/utils.js
@@ -126,6 +126,18 @@ var PlacesUtils = {
return this._annotations;
},
+ /**
+ * The Favicons Service
+ */
+ _favicons: null,
+ get favicons() {
+ if (!this._favicons) {
+ this._favicons = Cc["@mozilla.org/browser/favicon-service;1"].
+ getService(Ci.nsIFaviconService);
+ }
+ return this._favicons;
+ },
+
/**
* The Transaction Manager for this window.
*/
@@ -221,6 +233,21 @@ var PlacesUtils = {
return (aNode.type == Ci.nsINavHistoryResultNode.RESULT_TYPE_SEPARATOR);
},
+ /**
+ * Determines whether or not a ResultNode is a visit item or not
+ * @param aNode
+ * A NavHistoryResultNode
+ * @returns true if the node is a visit item, false otherwise
+ */
+ nodeIsVisit: function PU_nodeIsVisit(aNode) {
+ NS_ASSERT(aNode, "null node");
+
+ const NHRN = Ci.nsINavHistoryResultNode;
+ var type = aNode.type;
+ return type == NHRN.RESULT_TYPE_VISIT ||
+ type == NHRN.RESULT_TYPE_FULL_VISIT;
+ },
+
/**
* Determines whether or not a ResultNode is a URL item or not
* @param aNode
@@ -231,9 +258,10 @@ var PlacesUtils = {
NS_ASSERT(aNode, "null node");
const NHRN = Ci.nsINavHistoryResultNode;
- return aNode.type == NHRN.RESULT_TYPE_URI ||
- aNode.type == NHRN.RESULT_TYPE_VISIT ||
- aNode.type == NHRN.RESULT_TYPE_FULL_VISIT;
+ var type = aNode.type;
+ return type == NHRN.RESULT_TYPE_URI ||
+ type == NHRN.RESULT_TYPE_VISIT ||
+ type == NHRN.RESULT_TYPE_FULL_VISIT;
},
/**
@@ -287,10 +315,12 @@ var PlacesUtils = {
NS_ASSERT(aNode, "null node");
const NHRN = Ci.nsINavHistoryResultNode;
- return aNode.type == NHRN.RESULT_TYPE_HOST ||
- aNode.type == NHRN.RESULT_TYPE_QUERY ||
- aNode.type == NHRN.RESULT_TYPE_FOLDER ||
- aNode.type == NHRN.RESULT_TYPE_REMOTE_CONTAINER;
+ var type = aNode.type;
+ return type == NHRN.RESULT_TYPE_HOST ||
+ type == NHRN.RESULT_TYPE_QUERY ||
+ type == NHRN.RESULT_TYPE_FOLDER ||
+ type == NHRN.RESULT_TYPE_DAY ||
+ type == NHRN.RESULT_TYPE_REMOTE_CONTAINER;
},
/**
diff --git a/browser/components/places/jar.mn b/browser/components/places/jar.mn
index 439709864cd0..eb82a2fd343a 100755
--- a/browser/components/places/jar.mn
+++ b/browser/components/places/jar.mn
@@ -12,6 +12,7 @@ browser.jar:
* content/browser/places/tree.xml (content/tree.xml)
* content/browser/places/utils.js (content/utils.js)
* content/browser/places/controller.js (content/controller.js)
+* content/browser/places/treeView.js (content/treeView.js)
* content/browser/places/treeHelpers.js (content/treeHelpers.js)
* content/browser/places/demos/time.xul (content/demos/time.xul)
* content/browser/places/demos/time.html (content/demos/time.html)
diff --git a/toolkit/components/build/nsToolkitCompsCID.h b/toolkit/components/build/nsToolkitCompsCID.h
index 1147778dab95..e990dbcb65bc 100644
--- a/toolkit/components/build/nsToolkitCompsCID.h
+++ b/toolkit/components/build/nsToolkitCompsCID.h
@@ -88,9 +88,6 @@
#define NS_NAVHISTORYSERVICE_CONTRACTID \
"@mozilla.org/browser/nav-history-service;1"
-#define NS_NAVHISTORYRESULTTREEVIEWER_CONTRACTID \
- "@mozilla.org/browser/nav-history/result-tree-viewer;1"
-
#define NS_ANNOTATIONSERVICE_CONTRACTID \
"@mozilla.org/browser/annotation-service;1"
diff --git a/toolkit/components/places/public/nsIFaviconService.idl b/toolkit/components/places/public/nsIFaviconService.idl
index 4066aea724cc..3a9cd6be542a 100644
--- a/toolkit/components/places/public/nsIFaviconService.idl
+++ b/toolkit/components/places/public/nsIFaviconService.idl
@@ -40,7 +40,7 @@
interface nsIURI;
-[scriptable, uuid(b7fc8b9b-d85f-4d89-9b2a-0e67bd6e8d78)]
+[scriptable, uuid(91f635a4-2531-4f3d-89ef-81403a685f44)]
interface nsIFaviconService : nsISupports
{
/**
@@ -258,4 +258,9 @@ interface nsIFaviconService : nsISupports
* page on a site that doesn't have a favicon.
*/
boolean isFailedFavicon(in nsIURI aIcon);
+
+ /**
+ * The default favicon URL
+ */
+ readonly attribute nsIURI defaultFavicon;
};
diff --git a/toolkit/components/places/src/nsFaviconService.cpp b/toolkit/components/places/src/nsFaviconService.cpp
index 10df7a5b0233..012917be6518 100644
--- a/toolkit/components/places/src/nsFaviconService.cpp
+++ b/toolkit/components/places/src/nsFaviconService.cpp
@@ -209,6 +209,19 @@ nsFaviconService::SetFaviconUrlForPage(nsIURI* aPage, nsIURI* aFavicon)
return NS_OK;
}
+// nsFaviconService::GetDefaultFavicon
+
+NS_IMETHODIMP
+nsFaviconService::GetDefaultFavicon(nsIURI** _retval)
+{
+ // not found, use default
+ if (!mDefaultIcon) {
+ nsresult rv = NS_NewURI(getter_AddRefs(mDefaultIcon),
+ NS_LITERAL_CSTRING(FAVICON_DEFAULT_URL));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ return mDefaultIcon->Clone(_retval);
+}
// nsFaviconService::SetFaviconUrlForPageInternal
//
@@ -653,12 +666,7 @@ nsFaviconService::GetFaviconImageForPage(nsIURI* aPage, nsIURI** _retval)
}
// not found, use default
- if (! mDefaultIcon) {
- nsresult rv = NS_NewURI(getter_AddRefs(mDefaultIcon),
- NS_LITERAL_CSTRING(FAVICON_DEFAULT_URL));
- NS_ENSURE_SUCCESS(rv, rv);
- }
- return mDefaultIcon->Clone(_retval);
+ return GetDefaultFavicon(_retval);
}
diff --git a/toolkit/components/places/src/nsNavHistory.cpp b/toolkit/components/places/src/nsNavHistory.cpp
index 06ddf96a3ff2..0880cad44b56 100644
--- a/toolkit/components/places/src/nsNavHistory.cpp
+++ b/toolkit/components/places/src/nsNavHistory.cpp
@@ -219,11 +219,6 @@ static const char* gXpcomShutdown = "xpcom-shutdown";
// annotation names
const char nsNavHistory::kAnnotationPreviousEncoding[] = "history/encoding";
-nsIAtom* nsNavHistory::sMenuRootAtom = nsnull;
-nsIAtom* nsNavHistory::sToolbarFolderAtom = nsnull;
-nsIAtom* nsNavHistory::sSessionStartAtom = nsnull;
-nsIAtom* nsNavHistory::sSessionContinueAtom = nsnull;
-nsIAtom* nsNavHistory::sContainerAtom = nsnull;
nsNavHistory* nsNavHistory::gHistoryService;
@@ -242,12 +237,6 @@ nsNavHistory::nsNavHistory() : mNowValid(PR_FALSE),
#endif
NS_ASSERTION(! gHistoryService, "YOU ARE CREATING 2 COPIES OF THE HISTORY SERVICE. Everything will break.");
gHistoryService = this;
-
- sMenuRootAtom = NS_NewAtom("menu-root");
- sToolbarFolderAtom = NS_NewAtom("toolbar-folder");
- sSessionStartAtom = NS_NewAtom("session-start");
- sSessionContinueAtom = NS_NewAtom("session-continue");
- sContainerAtom = NS_NewAtom("container");
}
@@ -259,12 +248,6 @@ nsNavHistory::~nsNavHistory()
// in case somebody creates an extra instance of the service.
NS_ASSERTION(gHistoryService == this, "YOU CREATED 2 COPIES OF THE HISTORY SERVICE.");
gHistoryService = nsnull;
-
- NS_IF_RELEASE(sMenuRootAtom);
- NS_IF_RELEASE(sToolbarFolderAtom);
- NS_IF_RELEASE(sSessionStartAtom);
- NS_IF_RELEASE(sSessionContinueAtom);
- NS_IF_RELEASE(sContainerAtom);
}
diff --git a/toolkit/components/places/src/nsNavHistory.h b/toolkit/components/places/src/nsNavHistory.h
index 0d6cab2051d3..2e1566df9643 100644
--- a/toolkit/components/places/src/nsNavHistory.h
+++ b/toolkit/components/places/src/nsNavHistory.h
@@ -47,7 +47,6 @@
#include "nsCOMArray.h"
#include "nsCOMPtr.h"
#include "nsDataHashtable.h"
-#include "nsIAtom.h"
#include "nsINavHistoryService.h"
#include "nsIAutoCompleteSearch.h"
#include "nsIAutoCompleteResult.h"
@@ -242,12 +241,6 @@ public:
// used in execute queries to get session ID info (only for visits)
static const PRInt32 kGetInfoIndex_SessionId;
- static nsIAtom* sMenuRootAtom;
- static nsIAtom* sToolbarFolderAtom;
- static nsIAtom* sSessionStartAtom;
- static nsIAtom* sSessionContinueAtom;
- static nsIAtom* sContainerAtom;
-
// this actually executes a query and gives you results, it is used by
// nsNavHistoryQueryResultNode
nsresult GetQueryResults(const nsCOMArray& aQueries,
diff --git a/toolkit/components/places/src/nsNavHistoryResult.cpp b/toolkit/components/places/src/nsNavHistoryResult.cpp
index fdecd4607e01..8380d97a11ef 100644
--- a/toolkit/components/places/src/nsNavHistoryResult.cpp
+++ b/toolkit/components/places/src/nsNavHistoryResult.cpp
@@ -3783,1601 +3783,3 @@ nsNavHistoryResult::OnPageExpired(nsIURI* aURI, PRTime aVisitTime,
{
return NS_OK;
}
-
-
-// nsNavHistoryResultTreeViewer ************************************************
-
-NS_IMPL_ADDREF(nsNavHistoryResultTreeViewer)
-NS_IMPL_RELEASE(nsNavHistoryResultTreeViewer)
-
-NS_INTERFACE_MAP_BEGIN(nsNavHistoryResultTreeViewer)
- NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsINavHistoryResultTreeViewer)
- NS_INTERFACE_MAP_ENTRY(nsINavHistoryResultViewer)
- NS_INTERFACE_MAP_ENTRY(nsINavHistoryResultTreeViewer)
- NS_INTERFACE_MAP_ENTRY(nsITreeView)
-NS_INTERFACE_MAP_END
-
-nsNavHistoryResultTreeViewer::nsNavHistoryResultTreeViewer() :
- mCollapseDuplicates(PR_TRUE),
- mShowSessions(PR_FALSE)
-{
-
-}
-
-
-// nsNavHistoryResultTreeViewer::FinishInit
-//
-// This is called when the result or tree may have changed. It reinitializes
-// everything. Result and/or tree can be null when calling.
-
-nsresult
-nsNavHistoryResultTreeViewer::FinishInit()
-{
- if (mTree && mResult) {
- mResult->mRootNode->SetContainerOpen(PR_TRUE);
- SortingChanged(mResult->mSortingMode);
- }
- // if there is no tree, BuildVisibleList will clear everything for us
- return BuildVisibleList();
-}
-
-
-// nsNavHistoryResultTreeViewer::ComputeShowSessions
-//
-// Computes the value of mShowSessions, which is used to see if we should
-// try to set styles for session groupings. We only want to do session
-// grouping if we're in an appropriate view, which is view by visit and
-// sorted by date.
-
-void
-nsNavHistoryResultTreeViewer::ComputeShowSessions()
-{
- NS_ASSERTION(mResult, "Must have a result to show sessions!");
- mShowSessions = PR_FALSE;
-
- nsNavHistoryQueryOptions* options = mResult->mOptions;
- NS_ASSERTION(options, "navHistoryResults must have valid options");
-
- if (!options->ShowSessions())
- return; // sessions are off
-
- if (options->ResultType() != nsINavHistoryQueryOptions::RESULTS_AS_VISIT &&
- options->ResultType() != nsINavHistoryQueryOptions::RESULTS_AS_FULL_VISIT)
- return; // not visits
-
- if (mResult->mSortingMode != nsINavHistoryQueryOptions::SORT_BY_DATE_ASCENDING &&
- mResult->mSortingMode != nsINavHistoryQueryOptions::SORT_BY_DATE_DESCENDING)
- return; // not date sorting
-
- // showing sessions only makes sense if we are grouping by date
- // any other grouping (or recursive grouping) doesn't make sense
- PRUint32 groupCount;
- const PRUint32* groupings = options->GroupingMode(&groupCount);
- for (PRUint32 i = 0; i < groupCount; i ++) {
- if (groupings[i] != nsINavHistoryQueryOptions::GROUP_BY_DAY)
- return; // non-time-based grouping
- }
-
- mShowSessions = PR_TRUE;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetRowSessionStatus
-
-nsNavHistoryResultTreeViewer::SessionStatus
-nsNavHistoryResultTreeViewer::GetRowSessionStatus(PRInt32 row)
-{
- NS_ASSERTION(row >= 0 && row < PRInt32(mVisibleElements.Length()),
- "Invalid row!");
-
- nsNavHistoryResultNode *node = mVisibleElements[row];
- if (! node->IsVisit())
- return Session_None; // not a visit, so there are no sessions
- nsNavHistoryVisitResultNode* visit = node->GetAsVisit();
-
- if (visit->mSessionId != 0) {
- if (row == 0) {
- return Session_Start;
- } else {
- nsNavHistoryResultNode* previousNode = mVisibleElements[row - 1];
- if (previousNode->IsVisit() &&
- visit->mSessionId != previousNode->GetAsVisit()->mSessionId) {
- return Session_Start;
- } else {
- return Session_Continue;
- }
- }
- }
- return Session_None;
-}
-
-
-// nsNavHistoryResultTreeViewer::BuildVisibleList
-//
-// Call to completely rebuild the list of visible items. Note if there is no
-// tree or root this will just clear out the list, so you can also call this
-// when a tree is detached to clear the list.
-//
-// This does NOT update the screen.
-
-nsresult
-nsNavHistoryResultTreeViewer::BuildVisibleList()
-{
- if (mResult) {
- // Any current visible elements need to be marked as invisible. However,
- // be careful to do this only when there is no result. We don't have owning
- // references to these objects, and if the result was detached and freed,
- // our pointers will be stale.
- for (PRUint32 i = 0; i < mVisibleElements.Length(); i ++)
- mVisibleElements[i]->mViewIndex = -1;
- }
- mVisibleElements.Clear();
-
- if (mResult->mRootNode && mTree) {
- ComputeShowSessions();
- return BuildVisibleSection(mResult->mRootNode, &mVisibleElements, 0);
- }
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::BuildVisibleSection
-//
-// This takes a container and recursively appends visible elements to the
-// given array. This is used to build the visible element list (with
-// mVisibleElements passed as the array), or portions thereof (with a
-// separate array that is merged with the main list later.
-//
-// aVisibleStartIndex is the visible index of the beginning of the 'aVisible'
-// array. When aVisible is mVisibleElements, this is 0. This is non-zero
-// when we are building up a sub-region for insertion. Then, this is the
-// index where the new array will be inserted into mVisibleElements. It is
-// used to compute each node's mViewIndex.
-
-nsresult
-nsNavHistoryResultTreeViewer::BuildVisibleSection(
- nsNavHistoryContainerResultNode* aContainer,
- VisibleList* aVisible,
- PRUint32 aVisibleStartIndex)
-{
- if (! aContainer->mExpanded)
- return NS_OK; // nothing to do
- for (PRInt32 i = 0; i < aContainer->mChildren.Count(); i ++) {
- nsNavHistoryResultNode* cur = aContainer->mChildren[i];
-
- // collapse all duplicates starting from here
- if (mCollapseDuplicates) {
- PRUint32 showThis;
- while (i < aContainer->mChildren.Count() - 1 &&
- CanCollapseDuplicates(cur, aContainer->mChildren[i+1], &showThis)) {
- if (showThis) {
- // collapse the first and use the second
- cur->mViewIndex = -1;
- cur = aContainer->mChildren[i + 1];
- } else {
- // collapse the second and use the first
- aContainer->mChildren[i + 1]->mViewIndex = -1;
- }
- i ++;
- }
- }
-
- // don't display separators when sorted
- if (cur->IsSeparator()) {
- if (aContainer->GetSortType() != nsINavHistoryQueryOptions::SORT_BY_NONE) {
- cur->mViewIndex = -1;
- continue;
- }
- }
-
- // add item
- cur->mViewIndex = aVisibleStartIndex + aVisible->Length();
- if (! aVisible->AppendElement(cur))
- return NS_ERROR_OUT_OF_MEMORY;
-
- // recursively do containers
- if (cur->IsContainer()) {
- nsNavHistoryContainerResultNode* curContainer = cur->GetAsContainer();
- if (curContainer->mExpanded && curContainer->mChildren.Count() > 0) {
- nsresult rv = BuildVisibleSection(curContainer, aVisible,
- aVisibleStartIndex);
- NS_ENSURE_SUCCESS(rv, rv);
- }
- }
- }
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::CountVisibleRowsForItem
-//
-// This counts how many rows an item takes in the tree, that is, the item
-// itself plus any nodes following it with an increased indent. This allows
-// you to figure out how many rows an item (=1) or a container with all of
-// its children takes.
-
-PRUint32
-nsNavHistoryResultTreeViewer::CountVisibleRowsForItem(
- nsNavHistoryResultNode* aNode)
-{
- NS_ASSERTION(aNode->mViewIndex >= 0, "Item is not visible, no rows to count");
- PRInt32 outerLevel = aNode->mIndentLevel;
- for (PRUint32 i = aNode->mViewIndex + 1; i < mVisibleElements.Length(); i ++) {
- if (mVisibleElements[i]->mIndentLevel <= outerLevel)
- return i - aNode->mViewIndex;
- }
- // this node plus its children occupy the bottom of the list
- return mVisibleElements.Length() - aNode->mViewIndex;
-}
-
-
-// nsNavHistoryResultTreeViewer::RefreshVisibleSection
-//
-// This is called by containers when they change and we need to update
-// everything about the container. We build a new visible section with the
-// container as a separate object so we first know how the list changes. This
-// way we only have to do one realloc/memcpy to update the list.
-//
-// We also try to be smart here about redrawing the screen.
-
-nsresult
-nsNavHistoryResultTreeViewer::RefreshVisibleSection(
- nsNavHistoryContainerResultNode* aContainer)
-{
- NS_ASSERTION(mResult, "Need to have a result to update");
- if (! mTree)
- return NS_OK;
-
- // The root node is invisible, so we can't check its index and indent level.
- // Therefore, special case it. This is easy because we just rebuild everything
- if (aContainer == mResult->mRootNode)
- return BuildVisibleList();
-
- // When the container is not the root, it better be visible if we are updating
- NS_ASSERTION(aContainer->mViewIndex >= 0 &&
- aContainer->mViewIndex < PRInt32(mVisibleElements.Length()),
- "Trying to expand a node that is not visible");
- NS_ASSERTION(mVisibleElements[aContainer->mViewIndex] == aContainer,
- "Visible index is out of sync!");
-
- PRUint32 startReplacement = aContainer->mViewIndex + 1;
- PRUint32 replaceCount = CountVisibleRowsForItem(aContainer) - 1;
-
- // Mark the removees as invisible
- PRUint32 i;
- for (i = startReplacement; i < replaceCount; i ++)
- mVisibleElements[startReplacement + i]->mViewIndex = -1;
-
- // Building the new list will set the new elements' visible indices.
- VisibleList newElements;
- nsresult rv = BuildVisibleSection(aContainer, &newElements, startReplacement);
- NS_ENSURE_SUCCESS(rv, rv);
-
- // actually update the visible list
- if (! mVisibleElements.ReplaceElementsAt(aContainer->mViewIndex + 1,
- replaceCount, newElements.Elements(), newElements.Length()))
- return NS_ERROR_OUT_OF_MEMORY;
-
- if (replaceCount == newElements.Length()) {
- // length is the same, just repaint the changed area
- if (replaceCount > 0)
- mTree->InvalidateRange(startReplacement, startReplacement + replaceCount - 1);
- } else {
- // If the new area is a different size, we'll have to renumber the elements
- // following the area.
- for (i = startReplacement + newElements.Length();
- i < mVisibleElements.Length(); i ++)
- mVisibleElements[i]->mViewIndex = i;
-
- // repaint the region that stayed the same, also including the container
- // element itself since its twisty could have changed.
- PRUint32 minLength;
- if (replaceCount > newElements.Length())
- minLength = newElements.Length();
- else
- minLength = replaceCount;
- mTree->InvalidateRange(startReplacement - 1, startReplacement + minLength - 1);
-
- // now update the number of elements
- mTree->RowCountChanged(startReplacement + minLength,
- newElements.Length() - replaceCount);
- }
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::CanCollapseDuplicates
-//
-// This returns true if the two results can be collapsed as duplicates.
-// *aShowThisOne will be either 0 or 1, indicating which of the duplicates
-// should be shown.
-
-PRBool
-nsNavHistoryResultTreeViewer::CanCollapseDuplicates(
- nsNavHistoryResultNode* aTop, nsNavHistoryResultNode* aNext,
- PRUint32* aShowThisOne)
-{
- if (! mCollapseDuplicates)
- return PR_FALSE;
- if (! aTop->IsVisit() || ! aNext->IsVisit())
- return PR_FALSE; // only collapse two visits
-
- nsNavHistoryVisitResultNode* topVisit = aTop->GetAsVisit();
- nsNavHistoryVisitResultNode* nextVisit = aNext->GetAsVisit();
-
- if (! topVisit->mURI.Equals(nextVisit->mURI))
- return PR_FALSE; // don't collapse nonmatching URIs
-
- // now we know we want to collapse, show the one with the more recent time
- *aShowThisOne = topVisit->mTime < nextVisit->mTime;
- return PR_TRUE;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetColumnType
-
-nsNavHistoryResultTreeViewer::ColumnType
-nsNavHistoryResultTreeViewer::GetColumnType(nsITreeColumn* col)
-{
- const PRUnichar* idConst;
- col->GetIdConst(&idConst);
- switch(idConst[0]) {
- case PRUnichar('t'):
- return Column_Title;
- case PRUnichar('u'):
- return Column_URI;
- case PRUnichar('d'):
- return Column_Date;
- case PRUnichar('v'):
- return Column_VisitCount;
- default:
- return Column_Unknown;
- }
-}
-
-
-// nsNavHistoryResultTreeViewer::SortTypeToColumnType
-//
-// Places whether it's ascending or descending into the given boolean buffer
-
-nsNavHistoryResultTreeViewer::ColumnType
-nsNavHistoryResultTreeViewer::SortTypeToColumnType(PRUint32 aSortType,
- PRBool* aDescending)
-{
- switch(aSortType) {
- case nsINavHistoryQueryOptions::SORT_BY_TITLE_ASCENDING:
- *aDescending = PR_FALSE;
- return Column_Title;
- case nsINavHistoryQueryOptions::SORT_BY_TITLE_DESCENDING:
- *aDescending = PR_TRUE;
- return Column_Title;
- case nsINavHistoryQueryOptions::SORT_BY_DATE_ASCENDING:
- *aDescending = PR_FALSE;
- return Column_Date;
- case nsINavHistoryQueryOptions::SORT_BY_DATE_DESCENDING:
- *aDescending = PR_TRUE;
- return Column_Date;
- case nsINavHistoryQueryOptions::SORT_BY_URI_ASCENDING:
- *aDescending = PR_FALSE;
- return Column_URI;
- case nsINavHistoryQueryOptions::SORT_BY_URI_DESCENDING:
- *aDescending = PR_TRUE;
- return Column_URI;
- case nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_ASCENDING:
- *aDescending = PR_FALSE;
- return Column_VisitCount;
- case nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_DESCENDING:
- *aDescending = PR_TRUE;
- return Column_VisitCount;
- default:
- *aDescending = PR_FALSE;
- return Column_Unknown;
- }
-}
-
-
-// nsNavHistoryResultTreeViewer::ItemInserted (nsINavHistoryResultViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::ItemInserted(
- nsINavHistoryContainerResultNode *aParent, nsINavHistoryResultNode *aItem,
- PRUint32 aNewIndex)
-{
- if (! mTree)
- return NS_OK; // nothing to do
- if (! mResult) {
- NS_NOTREACHED("Got an inserted message with no result");
- return NS_ERROR_UNEXPECTED;
- }
-
- nsRefPtr parent;
- aParent->QueryInterface(NS_GET_IID(nsNavHistoryContainerResultNode),
- getter_AddRefs(parent));
- if (! parent) {
- NS_NOTREACHED("Parent is not a concrete node");
- return NS_ERROR_UNEXPECTED;
- }
- nsCOMPtr item = do_QueryInterface(aItem);
- if (! aItem) {
- NS_NOTREACHED("Item is not a concrete node");
- return NS_ERROR_UNEXPECTED;
- }
-
- // don't display separators when sorted
- if (item->IsSeparator()) {
- if (parent->GetSortType() != nsINavHistoryQueryOptions::SORT_BY_NONE) {
- item->mViewIndex = -1;
- return NS_OK;
- }
- }
-
- // update parent when inserting the first item because twisty may have changed
- if (parent->mChildren.Count() == 1)
- ItemChanged(aParent);
-
- // compute the new view index of the item
- PRInt32 newViewIndex = -1;
- if (aNewIndex == 0) {
- // item is the first thing in our child list, it takes our index +1. Note
- // that this computation still works if the parent is an invisible root
- // node, because root_index + 1 = -1 + 1 = 0
- newViewIndex = parent->mViewIndex + 1;
- } else {
- // Here, we try to find the next visible element in the child list so we
- // can set the new visible index to be right before that. Note that we
- // have to search DOWN instead of up, because some siblings could have
- // children themselves that would be in the way.
- for (PRInt32 i = aNewIndex + 1; i < parent->mChildren.Count(); i ++) {
- if (parent->mChildren[i]->mViewIndex >= 0) {
- // the view indices of subsequent children have not been shifted
- // so the next item will have what should be our index
- newViewIndex = parent->mChildren[i]->mViewIndex;
- break;
- }
- }
- if (newViewIndex < 0) {
- // At the end of the child list without finding a visible sibling: This
- // is a little harder because we don't know how many rows the last item
- // in our list takes up (it could be a container with many children).
- PRUint32 lastRowCount =
- CountVisibleRowsForItem(parent->mChildren[aNewIndex - 1]);
- newViewIndex = parent->mChildren[aNewIndex - 1]->mViewIndex +
- lastRowCount;
- }
- }
-
- // Try collapsing with the previous node. Note that we do not have to try
- // to redraw the surrounding rows (which we normally would because session
- // boundaries may have changed) because when an item is merged, it will
- // always be in the same session.
- PRUint32 showThis;
- if (newViewIndex > 0 &&
- CanCollapseDuplicates(mVisibleElements[newViewIndex - 1],
- item, &showThis)) {
- if (showThis == 0) {
- // new node is invisible, collapsed with previous one
- item->mViewIndex = -1;
- return NS_OK;
- } else {
- // new node replaces the previous
- ItemReplaced(parent, mVisibleElements[newViewIndex - 1], item, 0);
- return NS_OK;
- }
- }
-
- // try collapsing with the next node (which is currently at the same index
- // we are trying to insert at)
- if (newViewIndex < PRInt32(mVisibleElements.Length()) &&
- CanCollapseDuplicates(item, mVisibleElements[newViewIndex],
- &showThis)) {
- if (showThis == 0) {
- // new node replaces the next node
- ItemReplaced(parent, mVisibleElements[newViewIndex], item, 0);
- return NS_OK;
- } else {
- // new node is invisible, replaced by next one
- item->mViewIndex = -1;
- return NS_OK;
- }
- }
-
- // no collapsing, insert new item
- item->mViewIndex = newViewIndex;
- mVisibleElements.InsertElementAt(newViewIndex, item);
- for (PRUint32 i = newViewIndex + 1; i < mVisibleElements.Length(); i ++)
- mVisibleElements[i]->mViewIndex = i;
- mTree->RowCountChanged(newViewIndex, 1);
-
- // Need to redraw the rows around this one because session boundaries may
- // have changed. For example, if we add a page to a session, the previous
- // page will need to be redrawn because it's session border will disappear.
- if (mShowSessions) {
- if (newViewIndex > 0)
- mTree->InvalidateRange(newViewIndex - 1, newViewIndex - 1);
- if (newViewIndex < PRInt32(mVisibleElements.Length()) - 1)
- mTree->InvalidateRange(newViewIndex + 1, newViewIndex + 1);
- }
-
- if (item->IsContainer() && item->GetAsContainer()->mExpanded)
- RefreshVisibleSection(item->GetAsContainer());
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::ItemRemoved (nsINavHistoryResultViewer)
-//
-// THIS FUNCTION DOES NOT HANDLE cases where a collapsed node is being
-// removed but the node it is collapsed with is not being removed (this
-// then just swap out the removee with it's collapsing partner). The only
-// time when we really remove things is when deleting URIs, which will
-// apply to all collapsees. This function is called sometimes when
-// resorting items. However, we won't do this when sorted by date because
-// dates will never change for visits, and date sorting is the only time
-// things are collapsed.
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::ItemRemoved(
- nsINavHistoryContainerResultNode *aParent, nsINavHistoryResultNode *aItem,
- PRUint32 aOldIndex)
-{
- NS_ASSERTION(mResult, "Got a notification but have no result!");
- if (! mTree)
- return NS_OK; // nothing to do
-
- nsCOMPtr item = do_QueryInterface(aItem);
- NS_ENSURE_TRUE(item, NS_ERROR_INVALID_ARG);
-
- PRInt32 oldViewIndex = item->mViewIndex;
- if (oldViewIndex < 0)
- return NS_OK; // item was already invisible, nothing to do
-
- // this may have been a container, in which case it has a lot of rows
- PRInt32 count = CountVisibleRowsForItem(item);
-
- // We really want tail recursion here, since we sometimes do another remove
- // after this when duplicates are being collapsed. This loop emulates that.
- while (PR_TRUE) {
- if (oldViewIndex > NS_STATIC_CAST(PRInt32, mVisibleElements.Length())) {
- NS_NOTREACHED("Trying to remove invalid row");
- return NS_OK;
- }
- mVisibleElements.RemoveElementsAt(oldViewIndex, count);
- for (PRUint32 i = oldViewIndex; i < mVisibleElements.Length(); i ++)
- mVisibleElements[i]->mViewIndex = i;
-
- mTree->RowCountChanged(oldViewIndex, -count);
-
- // the removal might have put two things together that should be collapsed
- if (oldViewIndex > 0 &&
- oldViewIndex < NS_STATIC_CAST(PRInt32, mVisibleElements.Length())) {
- PRUint32 showThisOne;
- if (CanCollapseDuplicates(mVisibleElements[oldViewIndex - 1],
- mVisibleElements[oldViewIndex], &showThisOne))
- {
- // Fake-tail-recurse to the beginning of this function to remove the
- // collapsed row. Note that we need to set the visible index to -1
- // before looping because we can never touch the row we're removing
- // (callers may have already destroyed it).
- oldViewIndex = oldViewIndex - 1 + showThisOne;
- mVisibleElements[oldViewIndex]->mViewIndex = -1;
- count = 1; // next time remove one row
- continue;
- }
- }
- break; // normal path: just remove once
- }
-
- // redraw parent because twisty may have changed
- PRBool hasChildren;
- aParent->GetHasChildren(&hasChildren);
- if (! hasChildren)
- ItemChanged(aParent);
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::ItemReplaced (nsINavHistoryResultViewer)
-//
-// Be careful, the parameter 'aIndex' here specifies the index in the
-// parent node of the item, not the visible index.
-//
-// This is called from the result when the item is replaced, but this object
-// calls this function internally also when duplicate collapsing changes.
-// In this case, aIndex will be 0, so we should be careful not to use the
-// value.
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::ItemReplaced(
- nsINavHistoryContainerResultNode* parent, nsINavHistoryResultNode* aOldItem,
- nsINavHistoryResultNode* aNewItem, PRUint32 aIndexDoNotUse)
-{
- if (! mTree)
- return NS_OK;
-
- PRInt32 viewIndex;
- aOldItem->GetViewIndex(&viewIndex);
- aNewItem->SetViewIndex(viewIndex);
- if (viewIndex >= 0 &&
- viewIndex < NS_STATIC_CAST(PRInt32, mVisibleElements.Length())) {
- nsCOMPtr newItem = do_QueryInterface(aNewItem);
- NS_ASSERTION(newItem, "Node is not one of our concrete ones");
- mVisibleElements[viewIndex] = newItem;
- }
- aOldItem->SetViewIndex(-1);
- mTree->InvalidateRow(viewIndex);
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::ItemChanged (nsINavHistoryResultViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::ItemChanged(nsINavHistoryResultNode *item)
-{
- NS_ASSERTION(mResult, "Got a notification but have no result!");
- PRInt32 viewIndex;
- item->GetViewIndex(&viewIndex);
- if (mTree && viewIndex >= 0)
- return mTree->InvalidateRow(viewIndex);
- return NS_OK; // nothing to refresh
-}
-
-
-// nsNavHistoryResultTreeViewer::ContainerOpened (nsINavHistoryResultViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::ContainerOpened(
- nsINavHistoryContainerResultNode *item)
-{
- NS_ASSERTION(mResult, "Got a notification but have no result!");
- if (! mTree || item < 0)
- return NS_OK; // nothing to do, container is not visible
- PRInt32 viewIndex;
- item->GetViewIndex(&viewIndex);
- if (viewIndex >= NS_STATIC_CAST(PRInt32, mVisibleElements.Length())) {
- // be paranoid about visible indices since others can change it
- NS_NOTREACHED("Invalid visible index");
- return NS_ERROR_UNEXPECTED;
- }
- return RefreshVisibleSection(
- NS_STATIC_CAST(nsNavHistoryContainerResultNode*, item));
-}
-
-
-// nsNavHistoryResultTreeViewer::ContainerClosed (nsINavHistoryResultViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::ContainerClosed(
- nsINavHistoryContainerResultNode *item)
-{
- NS_ASSERTION(mResult, "Got a notification but have no result!");
- if (! mTree || item < 0)
- return NS_OK; // nothing to do, container is not visible
-
- PRInt32 viewIndex;
- item->GetViewIndex(&viewIndex);
- if (viewIndex >= NS_STATIC_CAST(PRInt32, mVisibleElements.Length())) {
- // be paranoid about visible indices since others can change it
- NS_NOTREACHED("Invalid visible index");
- return NS_ERROR_UNEXPECTED;
- }
- return RefreshVisibleSection(
- NS_STATIC_CAST(nsNavHistoryContainerResultNode*, item));
-}
-
-
-// nsNavHistoryResultTreeViewer::InvalidateContainer (nsINavHistoryResultViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::InvalidateContainer(
- nsINavHistoryContainerResultNode* aItem)
-{
- NS_ASSERTION(mResult, "Got message but don't have a result!");
- if (! mTree)
- return NS_OK;
-
- return RefreshVisibleSection(
- NS_STATIC_CAST(nsNavHistoryContainerResultNode*, aItem));
-}
-
-
-// nsNavHistoryResultTreeViewer::InvalidateAll (nsINavHistoryResultViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::InvalidateAll()
-{
- NS_ASSERTION(mResult, "Got message but don't have a result!");
- if (! mTree)
- return NS_OK;
-
- PRInt32 oldRowCount = mVisibleElements.Length();
-
- // update flat list to new contents
- nsresult rv = BuildVisibleList();
- NS_ENSURE_SUCCESS(rv, rv);
-
- // redraw the tree, inserting new items
- rv = mTree->RowCountChanged(0, mVisibleElements.Length() - oldRowCount);
- NS_ENSURE_SUCCESS(rv, rv);
- return mTree->Invalidate();
-}
-
-
-// nsNavHistoryResultTreeViewer::SortingChanged (nsINavHistoryResultViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::SortingChanged(PRUint32 aSortingMode)
-{
- if (! mTree || ! mResult)
- return NS_OK;
-
- nsCOMPtr columns;
- nsresult rv = mTree->GetColumns(getter_AddRefs(columns));
- NS_ENSURE_SUCCESS(rv, rv);
-
- NS_NAMED_LITERAL_STRING(sortDirectionKey, "sortDirection");
-
- // clear old sorting indicator. Watch out: GetSortedColumn returns NS_OK
- // but null element if there is no sorted element
- nsCOMPtr column;
- rv = columns->GetSortedColumn(getter_AddRefs(column));
- NS_ENSURE_SUCCESS(rv, rv);
- if (column) {
- nsCOMPtr element;
- rv = column->GetElement(getter_AddRefs(element));
- NS_ENSURE_SUCCESS(rv, rv);
- element->SetAttribute(sortDirectionKey, EmptyString());
- }
-
- // set new sorting indicator by looking through all columns for ours
- if (aSortingMode == nsINavHistoryQueryOptions::SORT_BY_NONE)
- return NS_OK;
- PRBool desiredIsDescending;
- ColumnType desiredColumn = SortTypeToColumnType(aSortingMode,
- &desiredIsDescending);
- PRInt32 colCount;
- rv = columns->GetCount(&colCount);
- NS_ENSURE_SUCCESS(rv, rv);
- for (PRInt32 i = 0; i < colCount; i ++) {
- columns->GetColumnAt(i, getter_AddRefs(column));
- NS_ENSURE_SUCCESS(rv, rv);
- if (GetColumnType(column) == desiredColumn) {
- // found our desired one, set
- nsCOMPtr element;
- rv = column->GetElement(getter_AddRefs(element));
- NS_ENSURE_SUCCESS(rv, rv);
- if (desiredIsDescending)
- element->SetAttribute(sortDirectionKey, NS_LITERAL_STRING("descending"));
- else
- element->SetAttribute(sortDirectionKey, NS_LITERAL_STRING("ascending"));
- break;
- }
- }
-
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::Result (nsINavHistoryResultViewer)
-//
-// We store a pointer to the concrete object, so need to QI. We fail if the
-// given result object doesn't match our concrete one.
-//
-// @see SetTree
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::GetResult(nsINavHistoryResult** aResult)
-{
- *aResult = mResult;
- NS_IF_ADDREF(*aResult);
- return NS_OK;
-}
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::SetResult(nsINavHistoryResult* aResult)
-{
- if (aResult) {
- nsresult rv = aResult->QueryInterface(NS_GET_IID(nsNavHistoryResult),
- getter_AddRefs(mResult));
- NS_ENSURE_SUCCESS(rv, rv);
- } else {
- mResult = nsnull;
- }
- return FinishInit();
-}
-
-
-// nsNavHistoryResultTreeViewer::AddViewObserver (nsINavHistoryResultViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::AddViewObserver(
- nsINavHistoryResultViewObserver* aObserver, PRBool aOwnsWeak)
-{
- return mObservers.AppendWeakElement(aObserver, aOwnsWeak);
-}
-
-
-// nsNavHistoryResultTreeViewer::RemoveViewObserver (nsINavHistoryResultViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::RemoveViewObserver(
- nsINavHistoryResultViewObserver* aObserver)
-{
- return mObservers.RemoveWeakElement(aObserver);
-}
-
-
-// nsNavHistoryResultTreeViewer::CollapseDuplicates (nsINavHistoryResultTreeViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::GetCollapseDuplicates(PRBool* aCollapseDuplicates)
-{
- *aCollapseDuplicates = mCollapseDuplicates;
- return NS_OK;
-}
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::SetCollapseDuplicates(PRBool aCollapseDuplicates)
-{
- if ((aCollapseDuplicates && mCollapseDuplicates) ||
- (! aCollapseDuplicates && ! mCollapseDuplicates))
- return NS_OK; // no change
-
- mCollapseDuplicates = aCollapseDuplicates;
-
- if (mResult && mTree)
- InvalidateAll();
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetFlatItemCount (nsINavHistoryResultTreeViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::GetFlatItemCount(PRUint32 *aItemCount)
-{
- *aItemCount = mVisibleElements.Length();
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::NodeForTreeIndex (nsINavHistoryResultTreeViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::NodeForTreeIndex(
- PRUint32 index, nsINavHistoryResultNode** aResult)
-{
- if (index >= PRUint32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
- NS_ADDREF(*aResult = mVisibleElements[index]);
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::TreeIndexForNode (nsINavHistoryResultTreeViewer)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::TreeIndexForNode(nsINavHistoryResultNode* aNode,
- PRUint32* aResult)
-{
- nsresult rv;
- nsCOMPtr node = do_QueryInterface(aNode, &rv);
- NS_ENSURE_SUCCESS(rv, rv);
-
- if (node->mViewIndex < 0) {
- *aResult = nsINavHistoryResultTreeViewer::INDEX_INVISIBLE;
- } else {
- *aResult = node->mViewIndex;
- NS_ASSERTION(mVisibleElements[*aResult] == node,
- "Node's visible index and array out of sync");
- }
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetRowCount (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::GetRowCount(PRInt32 *aRowCount)
-{
- *aRowCount = mVisibleElements.Length();
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::Get/SetSelection (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::GetSelection(nsITreeSelection** aSelection)
-{
- if (! mSelection) {
- *aSelection = nsnull;
- return NS_ERROR_FAILURE;
- }
- NS_ADDREF(*aSelection = mSelection);
- return NS_OK;
-}
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::SetSelection(nsITreeSelection* aSelection)
-{
- mSelection = aSelection;
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetRowProperties (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::GetRowProperties(PRInt32 row,
- nsISupportsArray *properties)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
-
- nsNavHistoryResultNode *node = mVisibleElements[row];
-
- // Add the container property if it's applicable for this row.
- if (node->IsContainer()) {
- properties->AppendElement(nsNavHistory::sContainerAtom);
- }
-
- // Next handle properties for session information.
- if (! mShowSessions)
- return NS_OK; // don't need to bother to compute session boundaries
-
- switch (GetRowSessionStatus(row))
- {
- case Session_Start:
- properties->AppendElement(nsNavHistory::sSessionStartAtom);
- break;
- case Session_Continue:
- properties->AppendElement(nsNavHistory::sSessionContinueAtom);
- break;
- case Session_None:
- break;
- default:
- NS_NOTREACHED("Invalid session type");
- }
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetCellProperties (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::GetCellProperties(PRInt32 row, nsITreeColumn *col,
- nsISupportsArray *properties)
-{
- /*
- if (row < 0 || row >= mVisibleElements.Length())
- return NS_ERROR_INVALID_ARG;
-
- nsNavHistoryResultNode *node = mVisibleElements[row];
- PRInt64 folderId, bookmarksRootId, toolbarFolderId;
- node->GetFolderId(&folderId);
-
- nsCOMPtr bms(do_GetService(
- NS_NAVBOOKMARKSSERVICE_CONTRACTID));
- bms->GetBookmarksRoot(&bookmarksRootId);
- bms->GetToolbarFolder(&toolbarFolderId);
- if (bookmarksRootId == folderId)
- properties->AppendElement(nsNavHistory::sMenuRootAtom);
- else if (toolbarFolderId == folderId)
- properties->AppendElement(nsNavHistory::sToolbarFolderAtom);
-
- if (mShowSessions && node->mSessionID != 0) {
- if (row == 0 ||
- node->mSessionID != VisibleElementAt(row - 1)->mSessionID) {
- properties->AppendElement(nsNavHistory::sSessionStartAtom);
- } else {
- properties->AppendElement(nsNavHistory::sSessionContinueAtom);
- }
- }
- */
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetColumnProperties (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::GetColumnProperties(nsITreeColumn *col,
- nsISupportsArray *properties)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-// nsNavHistoryResultTreeViewer::IsContainer (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::IsContainer(PRInt32 row, PRBool *_retval)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
- *_retval = mVisibleElements[row]->IsContainer();
- if (*_retval) {
- // treat non-expandable queries as non-containers
- if (mVisibleElements[row]->IsQuery() &&
- ! mVisibleElements[row]->GetAsQuery()->CanExpand())
- *_retval = PR_FALSE;
- }
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::IsContainerOpen (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::IsContainerOpen(PRInt32 row, PRBool *_retval)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
- if (! mVisibleElements[row]->IsContainer())
- return NS_ERROR_INVALID_ARG;
-
- nsINavHistoryContainerResultNode* container =
- mVisibleElements[row]->GetAsContainer();
- return container->GetContainerOpen(_retval);
-}
-
-
-// nsNavHistoryResultTreeViewer::IsContainerEmpty (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::IsContainerEmpty(PRInt32 row, PRBool *_retval)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
- if (! mVisibleElements[row]->IsContainer())
- return NS_ERROR_INVALID_ARG;
-
- nsINavHistoryContainerResultNode* container =
- mVisibleElements[row]->GetAsContainer();
- PRBool hasChildren = PR_FALSE;
- nsresult rv = container->GetHasChildren(&hasChildren);
- *_retval = ! hasChildren;
- return rv;
-}
-
-
-// nsNavHistoryResultTreeViewer::IsSeparator (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::IsSeparator(PRInt32 row, PRBool *_retval)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
-
- *_retval = mVisibleElements[row]->IsSeparator();
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::IsSorted (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::IsSorted(PRBool *_retval)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-// nsNavHistoryResultTreeViewer::CanDrop (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::CanDrop(PRInt32 row, PRInt32 orientation,
- PRBool *_retval)
-{
- PRUint32 count = mObservers.Length();
- for (PRUint32 i = 0; i < count; ++i) {
- const nsCOMPtr &obs = mObservers[i];
- if (obs) {
- obs->CanDrop(row, orientation, _retval);
- if (*_retval) {
- break;
- }
- }
- }
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::Drop (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::Drop(PRInt32 row, PRInt32 orientation)
-{
- ENUMERATE_WEAKARRAY(mObservers, nsINavHistoryResultViewObserver,
- OnDrop(row, orientation))
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetParentIndex (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::GetParentIndex(PRInt32 row, PRInt32* _retval)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
- nsNavHistoryResultNode* parent = mVisibleElements[row]->mParent;
- if (! parent || parent->mViewIndex < 0)
- *_retval = -1;
- else
- *_retval = parent->mViewIndex;
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::HasNextSibling (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::HasNextSibling(PRInt32 row,
- PRInt32 afterIndex,
- PRBool* _retval)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
- if (row == PRInt32(mVisibleElements.Length()) - 1) {
- // this is the last thing in the list -> no next sibling
- *_retval = PR_FALSE;
- return NS_OK;
- }
- *_retval = (mVisibleElements[row]->mIndentLevel ==
- mVisibleElements[row + 1]->mIndentLevel);
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetLevel (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::GetLevel(PRInt32 row, PRInt32* _retval)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
- *_retval = mVisibleElements[row]->mIndentLevel;
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetImageSrc (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::GetImageSrc(PRInt32 row, nsITreeColumn *col,
- nsAString& _retval)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
-
- // only the first column has an image
- PRInt32 colIndex;
- col->GetIndex(&colIndex);
- if (colIndex != 0) {
- _retval.Truncate(0);
- return NS_OK;
- }
-
- nsNavHistoryResultNode* node = mVisibleElements[row];
-
- // Containers may or may not have favicons. If not, we will return nothing
- // as the image, and the style rule should pick up the default.
- // Separator rows never have icons.
- if (node->IsSeparator() ||
- (node->IsContainer() && node->mFaviconURI.IsEmpty())) {
- _retval.Truncate(0);
- return NS_OK;
- }
-
- // For consistency, we always return a favicon for non-containers, even if
- // it is just the default one.
- nsFaviconService* faviconService = nsFaviconService::GetFaviconService();
- NS_ENSURE_TRUE(faviconService, NS_ERROR_NO_INTERFACE);
-
- nsCAutoString spec;
- faviconService->GetFaviconSpecForIconString(
- mVisibleElements[row]->mFaviconURI, spec);
- CopyUTF8toUTF16(spec, _retval);
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetProgressMode (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::GetProgressMode(PRInt32 row,
- nsITreeColumn* col,
- PRInt32* _retval)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetCellValue (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::GetCellValue(
- PRInt32 row, nsITreeColumn *col, nsAString& _retval)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-// nsNavHistoryResultTreeViewer::GetCellText (nsITreeView)
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::GetCellText(PRInt32 row,
- nsITreeColumn *col,
- nsAString& _retval)
-{
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
- PRInt32 colIndex;
- col->GetIndex(&colIndex);
-
- nsNavHistoryResultNode* node = mVisibleElements[row];
-
- switch (GetColumnType(col)) {
- case Column_Title:
- {
- // title: normally, this is just the title, but we don't want empty
- // items in the tree view so return a special string if the title is
- // empty. Do it here so that callers can still get at the 0 length title
- // if they go through the "result" API.
- if (node->IsSeparator()) {
- _retval.Truncate(0);
- } else if (! node->mTitle.IsEmpty()) {
- _retval = NS_ConvertUTF8toUTF16(node->mTitle);
- } else {
- nsXPIDLString value;
- nsresult rv =
- nsNavHistory::GetHistoryService()->GetBundle()->GetStringFromName(
- NS_LITERAL_STRING("noTitle").get(), getter_Copies(value));
- NS_ENSURE_SUCCESS(rv, rv);
- _retval = value;
- }
-#if 0
- // this code is for debugging bookmark indices. It will prepend the
- // bookmark index to the title of each item.
- nsString newTitle;
- newTitle.AssignLiteral("(");
- newTitle.AppendInt(node->mBookmarkIndex);
- newTitle.AppendLiteral(") ");
- newTitle.Append(_retval);
- _retval = newTitle;
-#endif
- break;
- }
- case Column_URI:
- {
- if (node->IsURI())
- _retval = NS_ConvertUTF8toUTF16(node->mURI);
- else
- _retval.Truncate(0);
- break;
- }
- case Column_Date:
- {
- if (node->mTime == 0 || ! node->IsURI()) {
- // hosts and days shouldn't have a value for the date column. Actually,
- // you could argue this point, but looking at the results, seeing the
- // most recently visited date is not what I expect, and gives me no
- // information I know how to use. Only show this for URI-based items.
- _retval.Truncate(0);
- } else {
- if (GetRowSessionStatus(row) != Session_Continue)
- return FormatFriendlyTime(node->mTime, _retval);
- _retval.Truncate(0);
- break;
- }
- break;
- }
- case Column_VisitCount:
- {
- if (node->IsSeparator()) {
- _retval.Truncate(0);
- } else {
- _retval = NS_ConvertUTF8toUTF16(nsPrintfCString("%d", node->mAccessCount));
- }
- break;
- }
- default:
- return NS_ERROR_INVALID_ARG;
- }
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::SetTree (nsITreeView)
-//
-// This will get called when this view is attached to the tree to tell us
-// the box object, AND when the tree is being destroyed, with NULL.
-//
-// @see SetResult
-
-NS_IMETHODIMP nsNavHistoryResultTreeViewer::SetTree(nsITreeBoxObject* tree)
-{
- PRBool hasOldTree = (mTree != nsnull);
- mTree = tree;
-
- // do this before detaching from result when there is no tree. This ensures
- // that the visible indices of the elements in the result have been set to -1
- FinishInit();
-
- if (! tree && hasOldTree && mResult) {
- // detach from result when we are detaching from the tree. This breaks the
- // reference cycle between us and the result.
- mResult->SetViewer(nsnull);
- }
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::ToggleOpenState (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::ToggleOpenState(PRInt32 row)
-{
- if (! mResult)
- return NS_ERROR_UNEXPECTED;
- if (row < 0 || row >= PRInt32(mVisibleElements.Length()))
- return NS_ERROR_INVALID_ARG;
-
- ENUMERATE_WEAKARRAY(mObservers, nsINavHistoryResultViewObserver,
- OnToggleOpenState(row))
-
- nsNavHistoryResultNode* node = mVisibleElements[row];
- if (! node->IsContainer())
- return NS_OK; // not a container, nothing to do
- nsNavHistoryContainerResultNode* container = node->GetAsContainer();
-
- nsresult rv;
- if (container->mExpanded)
- rv = container->CloseContainer();
- else
- rv = container->OpenContainer();
- NS_ENSURE_SUCCESS(rv, rv);
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::CycleHeader (nsITreeView)
-//
-// If we already sorted by that column, the sorting is reversed, otherwise
-// we use the default sorting direction for that data type.
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::CycleHeader(nsITreeColumn* col)
-{
- if (! mResult)
- return NS_ERROR_UNEXPECTED;
-
- ENUMERATE_WEAKARRAY(mObservers, nsINavHistoryResultViewObserver,
- OnCycleHeader(col))
-
- PRInt32 colIndex;
- col->GetIndex(&colIndex);
-
- // Sometimes you want a tri-state sorting, and sometimes you don't. This
- // rule allows tri-state sorting when the root node is a folder. This will
- // catch the most common cases. When you are looking at folders, you want
- // the third state to reset the sorting to the natural bookmark order.
- // When you are looking at history, that third state has no meaning so we
- // try to disallow it.
- //
- // The problem occurs when you have a query that results in bookmark folders.
- // One example of this is the subscriptions view. In these cases, this rule
- // doesn't allow you to sort those sub-folders by their natural order.
- PRBool allowTriState = PR_FALSE;
- if (mResult->mRootNode->IsFolder())
- allowTriState = PR_TRUE;
-
- PRInt32 oldSort = mResult->mSortingMode;
- PRInt32 newSort;
- switch (GetColumnType(col)) {
- case Column_Title:
- if (oldSort == nsINavHistoryQueryOptions::SORT_BY_TITLE_ASCENDING) {
- newSort = nsINavHistoryQueryOptions::SORT_BY_TITLE_DESCENDING;
- } else {
- if (allowTriState && oldSort == nsINavHistoryQueryOptions::SORT_BY_TITLE_DESCENDING)
- newSort = nsINavHistoryQueryOptions::SORT_BY_NONE;
- else
- newSort = nsINavHistoryQueryOptions::SORT_BY_TITLE_ASCENDING;
- }
- break;
- case Column_URI:
- if (oldSort == nsINavHistoryQueryOptions::SORT_BY_URI_ASCENDING) {
- newSort = nsINavHistoryQueryOptions::SORT_BY_URI_DESCENDING;
- } else {
- if (allowTriState && oldSort == nsINavHistoryQueryOptions::SORT_BY_URI_DESCENDING)
- newSort = nsINavHistoryQueryOptions::SORT_BY_NONE;
- else
- newSort = nsINavHistoryQueryOptions::SORT_BY_URI_ASCENDING;
- }
- break;
- case Column_Date:
- if (oldSort == nsINavHistoryQueryOptions::SORT_BY_DATE_ASCENDING) {
- newSort = nsINavHistoryQueryOptions::SORT_BY_DATE_DESCENDING;
- } else {
- if (allowTriState && oldSort == nsINavHistoryQueryOptions::SORT_BY_DATE_DESCENDING)
- newSort = nsINavHistoryQueryOptions::SORT_BY_NONE;
- else
- newSort = nsINavHistoryQueryOptions::SORT_BY_DATE_ASCENDING;
- }
- break;
- case Column_VisitCount:
- // visit count default is unusual because we sort by descending by default
- // because you are most likely to be looking for highly visited sites when
- // you click it
- if (oldSort == nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_DESCENDING) {
- newSort = nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_ASCENDING;
- } else {
- if (allowTriState && oldSort == nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_ASCENDING)
- newSort = nsINavHistoryQueryOptions::SORT_BY_NONE;
- else
- newSort = nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_DESCENDING;
- }
- break;
- default:
- return NS_ERROR_INVALID_ARG;
- }
- return mResult->SetSortingMode(newSort);
-}
-
-
-// nsNavHistoryResultTreeViewer::SelectionChanged (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::SelectionChanged()
-{
- ENUMERATE_WEAKARRAY(mObservers, nsINavHistoryResultViewObserver,
- OnSelectionChanged())
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::CycleCell (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::CycleCell(PRInt32 row, nsITreeColumn* col)
-{
- ENUMERATE_WEAKARRAY(mObservers, nsINavHistoryResultViewObserver,
- OnCycleCell(row, col))
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::IsEditable (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::IsEditable(PRInt32 row, nsITreeColumn* col,
- PRBool* _retval)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-// nsNavHistoryResultTreeViewer::IsSelectable (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::IsSelectable(PRInt32 row, nsITreeColumn* col,
- PRBool* _retval)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-// nsNavHistoryResultTreeViewer::SetCellValue (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::SetCellValue(PRInt32 row, nsITreeColumn* col,
- const nsAString & value)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-// nsNavHistoryResultTreeViewer::SetCellText (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::SetCellText(PRInt32 row, nsITreeColumn* col,
- const nsAString & value)
-{
- return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-// nsNavHistoryResultTreeViewer::PerformAction (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::PerformAction(const PRUnichar* action)
-{
- ENUMERATE_WEAKARRAY(mObservers, nsINavHistoryResultViewObserver,
- OnPerformAction(action))
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::PerformActionOnRow (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::PerformActionOnRow(const PRUnichar* action,
- PRInt32 row)
-{
- ENUMERATE_WEAKARRAY(mObservers, nsINavHistoryResultViewObserver,
- OnPerformActionOnRow(action, row))
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::PerformActionOnCell (nsITreeView)
-
-NS_IMETHODIMP
-nsNavHistoryResultTreeViewer::PerformActionOnCell(const PRUnichar* action,
- PRInt32 row,
- nsITreeColumn* col)
-{
- ENUMERATE_WEAKARRAY(mObservers, nsINavHistoryResultViewObserver,
- OnPerformActionOnCell(action, row, col))
- return NS_OK;
-}
-
-
-// nsNavHistoryResultTreeViewer::FormatFriendlyTime
-
-nsresult
-nsNavHistoryResultTreeViewer::FormatFriendlyTime(PRTime aTime,
- nsAString& aResult)
-{
- // use navHistory's GetNow function for performance
- nsNavHistory* history = nsNavHistory::GetHistoryService();
- NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY);
- PRTime now = history->GetNow();
-
- const PRInt64 ago = now - aTime;
-
- /*
- * This code generates strings like "X minutes ago" when the time is very
- * recent. This looks much nicer, but we will have to redraw the list
- * periodically. I also found it a little strange watching the numbers in
- * the list change as I browse. For now, I'll leave this commented out,
- * perhaps we can revisit whether it is a good idea to do this and put in
- * the proper auto-refresh code so the numbers stay correct.
- *
- * To enable, you'll need to put these in places.properties:
- * 0MinutesAgo=<1 minute ago
- * 1MinutesAgo=1 minute ago
- * XMinutesAgo=%S minutes ago
-
- static const PRInt64 minuteThreshold = (PRInt64)1000000 * 60 * 60;
- if (ago > -10000000 && ago < minuteThreshold) {
- // show "X minutes ago"
- PRInt64 minutesAgo = NSToIntFloor(
- NS_STATIC_CAST(float, (ago / 1000000)) / 60.0);
-
- nsXPIDLString resultString;
- if (minutesAgo == 0) {
- nsresult rv = mBundle->GetStringFromName(
- NS_LITERAL_STRING("0MinutesAgo").get(), getter_Copies(resultString));
- NS_ENSURE_SUCCESS(rv, rv);
- } else if (minutesAgo == 1) {
- nsresult rv = mBundle->GetStringFromName(
- NS_LITERAL_STRING("1MinutesAgo").get(), getter_Copies(resultString));
- NS_ENSURE_SUCCESS(rv, rv);
- } else {
- nsAutoString minutesAgoString;
- minutesAgoString.AppendInt(minutesAgo);
- const PRUnichar* stringPtr = minutesAgoString.get();
- nsresult rv = mBundle->FormatStringFromName(
- NS_LITERAL_STRING("XMinutesAgo").get(),
- &stringPtr, 1, getter_Copies(resultString));
- NS_ENSURE_SUCCESS(rv, rv);
- }
- aResult = resultString;
- return NS_OK;
- } */
-
- // Check if it is today and only display the time. Only bother checking for
- // today if it's within the last 24 hours, since computing midnight is not
- // really cheap. Sometimes we may get dates in the future, so always show
- // those. Note the 10s slop in case the cached GetNow value in NavHistory is
- // out-of-date.
- nsDateFormatSelector dateFormat = nsIScriptableDateFormat::dateFormatShort;
- if (ago > -10000000 && ago < (PRInt64)1000000 * 24 * 60 * 60) {
- PRExplodedTime explodedTime;
- PR_ExplodeTime(aTime, PR_LocalTimeParameters, &explodedTime);
- explodedTime.tm_min =
- explodedTime.tm_hour =
- explodedTime.tm_sec =
- explodedTime.tm_usec = 0;
- PRTime midnight = PR_ImplodeTime(&explodedTime);
- if (aTime > midnight)
- dateFormat = nsIScriptableDateFormat::dateFormatNone;
- }
- nsAutoString resultString;
- history->GetDateFormatter()->FormatPRTime(history->GetLocale(), dateFormat,
- nsIScriptableDateFormat::timeFormatNoSeconds,
- aTime, resultString);
- aResult = resultString;
- return NS_OK;
-}
diff --git a/toolkit/components/places/src/nsNavHistoryResult.h b/toolkit/components/places/src/nsNavHistoryResult.h
index 2b389ee90ab6..2e58da6ac8ab 100644
--- a/toolkit/components/places/src/nsNavHistoryResult.h
+++ b/toolkit/components/places/src/nsNavHistoryResult.h
@@ -737,64 +737,4 @@ public:
{ *type = nsNavHistoryResultNode::RESULT_TYPE_SEPARATOR; return NS_OK; }
};
-
-// nsNavHistoryResultTreeViewer
-//
-
-class nsNavHistoryResultTreeViewer : public nsINavHistoryResultTreeViewer,
- public nsITreeView
-{
-public:
- nsNavHistoryResultTreeViewer();
- virtual ~nsNavHistoryResultTreeViewer() {}
-
- NS_DECL_ISUPPORTS
- NS_DECL_NSINAVHISTORYRESULTVIEWER
- NS_DECL_NSINAVHISTORYRESULTTREEVIEWER
- NS_DECL_NSITREEVIEW
-
-protected:
- nsRefPtr mResult;
- nsCOMPtr mTree; // will be null when no tree attached
- nsCOMPtr mSelection; // may be null
-
- PRBool mCollapseDuplicates;
-
- // This value indicates whether we should try to compute session boundaries.
- // It is cached so we don't have to compute it every time we want to get a
- // row style.
- PRBool mShowSessions;
- void ComputeShowSessions();
- enum SessionStatus { Session_None, Session_Start, Session_Continue };
- SessionStatus GetRowSessionStatus(PRInt32 row);
-
- // This list is used to map rows to nodes.
- typedef nsTArray< nsCOMPtr > VisibleList;
- VisibleList mVisibleElements;
- nsresult BuildVisibleList();
- nsresult BuildVisibleSection(nsNavHistoryContainerResultNode* aContainer,
- VisibleList* aVisible,
- PRUint32 aVisibleStartIndex);
- PRUint32 CountVisibleRowsForItem(nsNavHistoryResultNode* aNode);
- nsresult RefreshVisibleSection(nsNavHistoryContainerResultNode* aContainer);
-
- PRBool CanCollapseDuplicates(nsNavHistoryResultNode* aTop,
- nsNavHistoryResultNode* aNext,
- PRUint32* aShowThisOne);
-
- // external observers
- nsMaybeWeakPtrArray mObservers;
-
- nsresult FinishInit();
-
- // columns
- enum ColumnType { Column_Unknown = -1, Column_Title, Column_URI, Column_Date,
- Column_VisitCount };
- ColumnType GetColumnType(nsITreeColumn* col);
- ColumnType SortTypeToColumnType(PRUint32 aSortType,
- PRBool* aDescending = nsnull);
-
- nsresult FormatFriendlyTime(PRTime aTime, nsAString& aResult);
-};
-
#endif // nsNavHistoryResult_h_
diff --git a/toolkit/components/places/src/nsPlacesModule.cpp b/toolkit/components/places/src/nsPlacesModule.cpp
index 3ef22f9c0fa4..9c637272c511 100644
--- a/toolkit/components/places/src/nsPlacesModule.cpp
+++ b/toolkit/components/places/src/nsPlacesModule.cpp
@@ -8,7 +8,6 @@
#include "nsMorkHistoryImporter.h"
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsNavHistory, Init)
-NS_GENERIC_FACTORY_CONSTRUCTOR(nsNavHistoryResultTreeViewer)
NS_GENERIC_FACTORY_CONSTRUCTOR(nsAnnoProtocolHandler)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsAnnotationService, Init)
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsNavBookmarks, Init)
@@ -32,11 +31,6 @@ static const nsModuleComponentInfo components[] =
"@mozilla.org/autocomplete/search;1?name=history",
nsNavHistoryConstructor },
- { "History tree view",
- NS_NAVHISTORYRESULTTREEVIEWER_CID,
- NS_NAVHISTORYRESULTTREEVIEWER_CONTRACTID,
- nsNavHistoryResultTreeViewerConstructor },
-
{ "Page Annotation Service",
NS_ANNOTATIONSERVICE_CID,
NS_ANNOTATIONSERVICE_CONTRACTID,