null turns sorting off.
*
@@ -182,211 +149,9 @@
public void setSorter(ViewerSorter sorter) {
if (sorter != null && sorter instanceof CommonViewerSorter)
((CommonViewerSorter) sorter).setContentService(contentService);
-
- if (sorter == null || sorter instanceof TreeViewerSorter)
- super.setSorter(sorter);
- else /* we wrap the sorter for convenience (now we can always cast to TreeViewerSorter) */
- super.setSorter(new DelegateTreeViewerSorter(sorter));
+ super.setSorter(sorter);
}
-
- // Had to pull down the following code to tap into the sorting
-
- /**
- * Adds the given child elements to this viewer as children of the given
- * parent element.
- * - * EXPERIMENTAL. Not to be used except by JDT. This method was added to - * support JDT's explorations into grouping by working sets, which requires - * viewers to support multiple equal elements. See bug 76482 for more - * details. This support will likely be removed in Eclipse 3.2 in favour of - * proper support for multiple equal elements. - *
- * - * @param widget - * the widget for the parent element - * @param parentElement - * the parent element - * @param childElements - * the child elements to add - * @since 3.1 - */ - protected void internalAdd(Widget widget, Object parentElement, - Object[] childElements) { - - // optimization! - // if the widget is not expanded we just invalidate the subtree - if (widget instanceof Item) { - Item ti = (Item) widget; - if (!getExpanded(ti)) { - boolean needDummy = isExpandable(parentElement); - boolean haveDummy = false; - // remove all children - Item[] items = getItems(ti); - for (int i = 0; i < items.length; i++) { - if (items[i].getData() != null) { - disassociate(items[i]); - items[i].dispose(); - } else { - if (needDummy && !haveDummy) { - haveDummy = true; - } else { - items[i].dispose(); - } - } - } - // append a dummy if necessary - if (needDummy && !haveDummy) - newItem(ti, SWT.NULL, -1); - return; - } - } - - if (childElements.length > 0) { - Object[] filtered = filter(childElements); - if (getSorter() != null) - ((TreeViewerSorter) getSorter()).sort(this, parentElement, - filtered); - createAddedElements(widget, parentElement, filtered); - } - } - - /** - * See if element is the data of one of the elements in items. - * - * @param items - * @param element - * @returntrue if the element matches.
- */
- private boolean itemExists(Item[] items, Object element) {
- if (usingElementMap())// if we can do a constant time lookup find it
- return findItem(element) != null;
- for (int i = 0; i < items.length; i++) {
- if (items[i].getData().equals(element))
- return true;
- }
- return false;
- }
-
- /**
- * Create the new elements in the parent widget. If the child already exists
- * do nothing.
- *
- * @param widget
- * @param elements
- * Sorted list of elements to add.
- */
- private void createAddedElements(Widget widget, Object parent,
- Object[] elements) {
-
- if (elements.length == 1) {
- if (equals(elements[0], widget.getData()))
- return;
- }
-
- // safe caste due to setSorter();
- TreeViewerSorter sorter = (TreeViewerSorter) getSorter();
- Item[] items = getChildren(widget);
-
- // As the items are sorted already we optimize for a
- // start position
- int lastInsertion = 0;
-
- // Optimize for the empty case
- if (items.length == 0) {
- for (int i = 0; i < elements.length; i++) {
- createTreeItem(widget, elements[i], -1);
- }
- return;
- }
-
- for (int i = 0; i < elements.length; i++) {
- boolean newItem = true;
- Object element = elements[i];
- int index;
- if (getSorter() == null) {
- if (itemExists(items, element)) {
- refresh(element);
- newItem = false;
- }
- index = -1;
- } else {
- lastInsertion = insertionPosition(items, lastInsertion, sorter,
- parent, element);
- // As we are only searching the original array we keep track of
- // those positions only
- if (lastInsertion == items.length)
- index = -1;
- else {// See if we should just refresh
- while (lastInsertion < items.length
- && sorter.compare(this, parent, element,
- items[lastInsertion].getData()) == 0) {
- // As we cannot assume the sorter is consistent with
- // equals() - therefore we can
- // just check against the item prior to this index (if
- // any)
- if (items[lastInsertion].getData().equals(element)) {
- // refresh the element in case it has new children
- refresh(element);
- newItem = false;
- }
- lastInsertion++;// We had an insertion so increment
- }
- // Did we get to the end?
- if (lastInsertion == items.length)
- index = -1;
- else
- index = lastInsertion + i; // Add the index as the
- // array is growing
- }
- }
- if (newItem)
- createTreeItem(widget, element, index);
- }
- }
-
- /**
- * Returns the index where the item should be inserted. It uses sorter to
- * determine the correct position, if sorter is not assigned, returns the
- * index of the element after the last.
- *
- * @param items
- * the items to search
- * @param lastInsertion
- * the start index to start search for position from this allows
- * optimising search for multiple elements that are sorted
- * themself.
- * @param element
- * element to find position for.
- * @return the index to use when inserting the element.
- *
- */
-
- private int insertionPosition(Item[] items, int lastInsertion,
- TreeViewerSorter sorter, Object parent, Object element) {
-
- int size = items.length;
- if (getSorter() == null)
- return size;
- int min = lastInsertion, max = size - 1;
-
- while (min <= max) {
- int mid = (min + max) / 2;
- Object data = items[mid].getData();
- int compare = sorter.compare(this, parent, data, element);
- if (compare == 0) {
- return mid;// Return if we already match
- }
- if (compare < 0)
- min = mid + 1;
- else
- max = mid - 1;
- }
- return min;
-
- }
-
- // End of pulled down code
-
+
/**
* * Adds DND support to the Navigator. Uses hooks into the extensible Index: src/org/eclipse/ui/navigator/TreeViewerSorter.java =================================================================== RCS file: src/org/eclipse/ui/navigator/TreeViewerSorter.java diff -N src/org/eclipse/ui/navigator/TreeViewerSorter.java --- src/org/eclipse/ui/navigator/TreeViewerSorter.java 3 Feb 2006 20:24:36 -0000 1.1 +++ /dev/null 1 Jan 1970 00:00:00 -0000 @@ -1,93 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2006 IBM Corporation and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * IBM Corporation - initial API and implementation - ******************************************************************************/ - -package org.eclipse.ui.navigator; - -import org.eclipse.jface.viewers.Viewer; -import org.eclipse.jface.viewers.ViewerSorter; - -/** - * - * Provides context sensitive sorting of elements based on their parent in the - * tree. - * - *
- * Clients may extend this class. - *
- * - *- * EXPERIMENTAL. This class or interface has been added as - * part of a work in progress. There is a guarantee neither that this API will - * work nor that it will remain the same. Please do not use this API without - * consulting with the Platform/UI team. - *
- * - * @since 3.2 - * - */ -public class TreeViewerSorter extends ViewerSorter { - - /** - * Sorts the given elements in-place taking into account the parent of the - * elements, modifying the given array. - *
- * The default implementation of this method uses the java.util.Arrays#sort
- * algorithm on the given array, calling compare to compare
- * elements, and the parent does not affect sorting algorithm.
- *
- * Subclasses may reimplement this method to provide a more optimized - * implementation. - *
- *- * - * - * @param viewer - * the viewer - * @param parent - * The parent element in the tree of both children. - * @param elements - * the elements to sort - */ - public void sort(final Viewer viewer, final Object parent, Object[] elements) { - super.sort(viewer, elements); - } - - /** - * Returns a negative, zero, or positive number depending on whether the - * first element is less than, equal to, or greater than the second element. - *
- * The default implementation of this method is based on comparing the
- * elements' categories as computed by the category framework
- * method. Elements within the same category are further subjected to a case
- * insensitive compare of their label strings, either as computed by the
- * content viewer's label provider, or their toString values
- * in other cases. Subclasses may override.
- *
0 if the first element is equal
- * to the second element; and a positive number if the first element
- * is greater than the second element
- */
- public int compare(Viewer viewer, Object parent, Object e1, Object e2) {
- return super.compare(viewer, e1, e2);
- }
-
-}
#P org.eclipse.jface
Index: src/org/eclipse/jface/viewers/AbstractTreeViewer.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jface/src/org/eclipse/jface/viewers/AbstractTreeViewer.java,v
retrieving revision 1.79
diff -u -r1.79 AbstractTreeViewer.java
--- src/org/eclipse/jface/viewers/AbstractTreeViewer.java 26 Jan 2006 15:47:36 -0000 1.79
+++ src/org/eclipse/jface/viewers/AbstractTreeViewer.java 6 Feb 2006 00:44:28 -0000
@@ -201,6 +201,7 @@
}
ViewerSorter sorter = getSorter ();
+ TreePath parentPath = internalGetSorterParentPath(widget, sorter);
Item[] items = getChildren(widget);
//As the items are sorted already we optimize for a
@@ -227,12 +228,12 @@
index = -1;
}
else{
- lastInsertion = insertionPosition(items,sorter,lastInsertion, element);
+ lastInsertion = insertionPosition(items,sorter,lastInsertion, element, parentPath);
//As we are only searching the original array we keep track of those positions only
if(lastInsertion == items.length)
index = -1;
else{//See if we should just refresh
- while(lastInsertion < items.length && sorter.compare(this,element,items[lastInsertion].getData()) == 0){
+ while(lastInsertion < items.length && internalCompare(sorter,parentPath,element,items[lastInsertion].getData()) == 0){
//As we cannot assume the sorter is consistent with equals() - therefore we can
// just check against the item prior to this index (if any)
if (items[lastInsertion].getData().equals(element)) {
@@ -285,12 +286,14 @@
* themself.
* @param element
* element to find position for.
+ * @param parentPath the tree path for the element's parent or null
+ * if the element is a root element or the sorter is not a {@link TreePathViewerSorter}
* @return the index to use when inserting the element.
*
*/
- private int insertionPosition(Item[] items, ViewerSorter sorter, int lastInsertion, Object element) {
-
+ private int insertionPosition(Item[] items, ViewerSorter sorter, int lastInsertion, Object element, TreePath parentPath) {
+
int size = items.length;
if (sorter == null)
return size;
@@ -299,7 +302,7 @@
while (min <= max) {
int mid = (min + max) / 2;
Object data = items[mid].getData();
- int compare = sorter.compare(this, data, element);
+ int compare = internalCompare(sorter, parentPath, data, element);
if (compare == 0) {
return mid;//Return if we already match
}
@@ -343,7 +346,7 @@
*/
protected int indexForElement(Widget parent, Object element) {
ViewerSorter sorter = getSorter();
-
+ TreePath parentPath = internalGetSorterParentPath(parent, sorter);
Item[] items = getChildren(parent);
int count = items.length;
@@ -355,7 +358,7 @@
while (min <= max) {
int mid = (min + max) / 2;
Object data = items[mid].getData();
- int compare = sorter.compare(this, data, element);
+ int compare = internalCompare(sorter, parentPath, data, element);
if (compare == 0) {
// find first item > element
while (compare == 0) {
@@ -364,7 +367,7 @@
break;
}
data = items[mid].getData();
- compare = sorter.compare(this, data, element);
+ compare = internalCompare(sorter, parentPath, data, element);
}
return mid;
}
@@ -377,6 +380,108 @@
}
/**
+ * Return the tree path that should be used as the parent path for the
+ * given widget and sorter. A null is returned if either
+ * the sorter is not a {@link TreePathViewerSorter} or if the parent
+ * widget is not an {@link Item} (i.e. is the root of the tree).
+ *
+ * @param parent the parent widget
+ * @param sorter the sorter
+ * @return the tree path that should be used as the parent path for the
+ * given widget and sorter
+ */
+ private TreePath internalGetSorterParentPath(Widget parent, ViewerSorter sorter) {
+ TreePath path;
+ if (sorter instanceof TreePathViewerSorter && parent instanceof Item) {
+ Item item = (Item) parent;
+ path = getTreePathFromItem(item);
+ } else {
+ path = null;
+ }
+ return path;
+ }
+
+ /**
+ * Compare the two elements using the given sorter. If the
+ * sorter is a {@link TreePathViewerSorter}, the provided
+ * tree path will be used. If the tree path is null and the
+ * sorter is a tree path sorter, then the elements are root elements
+ * @param sorter the sorter
+ * @param parentPath the path of the elements' parent
+ * @param e1 the first element
+ * @param e2 the seocnd element
+ * @return the result of comparing the two elements
+ */
+ private int internalCompare(ViewerSorter sorter, TreePath parentPath, Object e1, Object e2) {
+ if (sorter instanceof TreePathViewerSorter) {
+ TreePathViewerSorter tpvs = (TreePathViewerSorter) sorter;
+ return tpvs.compare(this, parentPath, e1, e2);
+ }
+ return sorter.compare(this, e1, e2);
+ }
+
+ /**
+ * Return the sorted children for the given tree path. The
+ * path is relative to the viewer input.
+ * A path of null indicates that the children for
+ * the input of the viewer are desired.
+ * @param parentPath the parent path
+ * @return the sorted children
+ * @since 3.2
+ */
+ protected Object[] getSortedChildren(TreePath parentPath) {
+ ViewerSorter sorter = getSorter();
+ Object parent;
+ if (parentPath == null) {
+ parent = getInput();
+ } else {
+ parent = parentPath.getLastSegment();
+ }
+ if (sorter instanceof TreePathViewerSorter) {
+ TreePathViewerSorter tpvs = (TreePathViewerSorter) sorter;
+ Object[] result = getFilteredChildren(parent);
+ // be sure we're not modifying the original array from the model
+ result = (Object[]) result.clone();
+ tpvs.sort(this, parentPath, result);
+ return result;
+ }
+ return super.getSortedChildren(parent);
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jface.viewers.StructuredViewer#getSortedChildren(java.lang.Object)
+ */
+ protected Object[] getSortedChildren(Object parent) {
+ ViewerSorter sorter = getSorter();
+ if (sorter instanceof TreePathViewerSorter) {
+ Widget w = internalGetWidgetToSelect(parent);
+ if (w != null)
+ return getSortedChildren(w, parent);
+ }
+ return super.getSortedChildren(parent);
+ }
+
+ /**
+ * Get the sorted children for the parent using a
+ * {@link TreePathViewerSorter} if there is one and
+ * {@link StructuredViewer#getSortedChildren(Object)} if there isn't.
+ *
+ * @param widget
+ * the widget for the parent
+ * @param parent
+ * the parent element
+ * @return the sorted children
+ */
+ private Object[] getSortedChildren(Widget widget, Object parent) {
+ ViewerSorter sorter = getSorter();
+ TreePath parentPath = internalGetSorterParentPath(widget, sorter);
+ if (sorter instanceof TreePathViewerSorter) {
+ return getSortedChildren(parentPath);
+ }
+ return super.getSortedChildren(parent);
+ }
+
+ /**
* Adds the given child element to this viewer as a child of the given
* parent element. If this viewer does not have a sorter, the element is
* added at the end of the parent's list of children; otherwise, the
@@ -514,7 +619,7 @@
Object d = widget.getData();
if (d != null) {
Object parentElement = d;
- Object[] children = getSortedChildren(parentElement);
+ Object[] children = getSortedChildren(widget, parentElement);
for (int i = 0; i < children.length; i++) {
createTreeItem(widget, children[i], -1);
}
@@ -1953,7 +2058,7 @@
// If the children weren't passed in, get them now since they're needed
// below.
if (elementChildren == null) {
- elementChildren = getSortedChildren(parent);
+ elementChildren = getSortedChildren(widget, parent);
}
Control tree = getControl();
@@ -2083,7 +2188,7 @@
}
}
- /**
+ /**
* Updates the "+"/"-" icon of the tree node from the given element. It
* calls isExpandable to determine whether an element is
* expandable.
Index: src/org/eclipse/jface/viewers/TreePathViewerSorter.java
===================================================================
RCS file: src/org/eclipse/jface/viewers/TreePathViewerSorter.java
diff -N src/org/eclipse/jface/viewers/TreePathViewerSorter.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/org/eclipse/jface/viewers/TreePathViewerSorter.java 1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,109 @@
+/*******************************************************************************
+ * Copyright (c) 2006 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ ******************************************************************************/
+
+package org.eclipse.jface.viewers;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * A viewer sorter that is provded extra context in the form of the path of the
+ * parent element of the elements being sorted.
+ *
+ * @since 3.2
+ */
+public class TreePathViewerSorter extends ViewerSorter {
+
+ /**
+ * Provide a category for the given element that will have the given parent
+ * path when it is added to the viewer. The provided path is
+ * relative to the viewer input. The parent path will
+ * be null when the elements are root elements.
+ *
+ * By default, the this method calls
+ * {@link ViewerSorter#category(Object)}. Subclasses may override.
+ *
+ * @param parentPath
+ * the parent path for the element
+ * @param element
+ * the element
+ * @return the category of the element
+ */
+ public int category(TreePath parentPath, Object element) {
+ return category(element);
+ }
+
+ /**
+ * Compare the givcen elements that will have the given parent
+ * path when they are added to the viewer. The provided path is
+ * relative to the viewer input. The parent path will
+ * be null when the elements are root elements.
+ *
+ * By default, the this method calls
+ * {@link ViewerSorter#sort(Viewer, Object[])}. Subclasses may override.
+ * @param viewer the viewer
+ * @param parentPath the parent path for the two elements
+ * @param e1 the first element
+ * @param e2 the second element
+ * @return a negative number if the first element is less than the
+ * second element; the value 0 if the first element is
+ * equal to the second element; and a positive
+ */
+ public int compare(Viewer viewer, TreePath parentPath, Object e1, Object e2) {
+ return compare(viewer, e1, e2);
+ }
+
+ /**
+ * Returns whether this viewer sorter would be affected
+ * by a change to the given property of the given element.
+ * The provided path is
+ * relative to the viewer input. The parent path will
+ * be null when the elements are root elements.
+ *
+ * The default implementation of this method calls
+ * {@link ViewerSorter#isSorterProperty(Object, String)}.
+ * Subclasses may reimplement.
+ * @param parentPath the parent path of the element
+ * @param element the element
+ * @param property the property
+ * @return true if the sorting would be affected,
+ * and false if it would be unaffected
+ */
+ public boolean isSorterProperty(TreePath parentPath, Object element, String property) {
+ return isSorterProperty(element, property);
+ }
+
+ /**
+ * Sorts the given elements in-place, modifying the given array.
+ * The provided path is
+ * relative to the viewer input. The parent path will
+ * be null when the elements are root elements.
+ *
+ * The default implementation of this method uses the + * java.util.Arrays#sort algorithm on the given array, + * calling {@link #compare(Viewer, TreePath, Object, Object)} to compare elements. + *
+ *+ * Subclasses may reimplement this method to provide a more optimized implementation. + *
+ * + * @param viewer the viewer + * @param parentPath the parent path of the given elements + * @param elements the elements to sort + */ + public void sort(final Viewer viewer, final TreePath parentPath, Object[] elements) { + Arrays.sort(elements, new Comparator() { + public int compare(Object a, Object b) { + return TreePathViewerSorter.this.compare(viewer, parentPath, a, b); + } + }); + } +}