001: /*******************************************************************************
002: * Copyright (c) 2006, 2007 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jface.viewers;
011:
012: import java.util.Arrays;
013: import java.util.Comparator;
014:
015: /**
016: * A viewer sorter that is provided extra context in the form of the path of the
017: * parent element of the elements being sorted.
018: *
019: * @since 3.2
020: */
021: public class TreePathViewerSorter extends ViewerSorter {
022:
023: /**
024: * Provide a category for the given element that will have the given parent
025: * path when it is added to the viewer. The provided path is
026: * relative to the viewer input. The parent path will
027: * be <code>null</code> when the elements are root elements.
028: * <p>
029: * By default, the this method calls
030: * {@link ViewerSorter#category(Object)}. Subclasses may override.
031: *
032: * @param parentPath
033: * the parent path for the element
034: * @param element
035: * the element
036: * @return the category of the element
037: */
038: public int category(TreePath parentPath, Object element) {
039: return category(element);
040: }
041:
042: /**
043: * Compare the given elements that will have the given parent
044: * path when they are added to the viewer. The provided path is
045: * relative to the viewer input. The parent path will
046: * be <code>null</code> when the elements are root elements.
047: * <p>
048: * By default, the this method calls
049: * {@link ViewerSorter#sort(Viewer, Object[])}. Subclasses may override.
050: * @param viewer the viewer
051: * @param parentPath the parent path for the two elements
052: * @param e1 the first element
053: * @param e2 the second element
054: * @return a negative number if the first element is less than the
055: * second element; the value <code>0</code> if the first element is
056: * equal to the second element; and a positive
057: */
058: public int compare(Viewer viewer, TreePath parentPath, Object e1,
059: Object e2) {
060: return compare(viewer, e1, e2);
061: }
062:
063: /**
064: * Returns whether this viewer sorter would be affected
065: * by a change to the given property of the given element.
066: * The provided path is
067: * relative to the viewer input. The parent path will
068: * be <code>null</code> when the elements are root elements.
069: * <p>
070: * The default implementation of this method calls
071: * {@link ViewerSorter#isSorterProperty(Object, String)}.
072: * Subclasses may reimplement.
073: * @param parentPath the parent path of the element
074: * @param element the element
075: * @param property the property
076: * @return <code>true</code> if the sorting would be affected,
077: * and <code>false</code> if it would be unaffected
078: */
079: public boolean isSorterProperty(TreePath parentPath,
080: Object element, String property) {
081: return isSorterProperty(element, property);
082: }
083:
084: /**
085: * Sorts the given elements in-place, modifying the given array.
086: * The provided path is
087: * relative to the viewer input. The parent path will
088: * be <code>null</code> when the elements are root elements.
089: * <p>
090: * The default implementation of this method uses the
091: * java.util.Arrays#sort algorithm on the given array,
092: * calling {@link #compare(Viewer, TreePath, Object, Object)} to compare elements.
093: * </p>
094: * <p>
095: * Subclasses may reimplement this method to provide a more optimized implementation.
096: * </p>
097: *
098: * @param viewer the viewer
099: * @param parentPath the parent path of the given elements
100: * @param elements the elements to sort
101: */
102: public void sort(final Viewer viewer, final TreePath parentPath,
103: Object[] elements) {
104: Arrays.sort(elements, new Comparator() {
105: public int compare(Object a, Object b) {
106: return TreePathViewerSorter.this.compare(viewer,
107: parentPath, a, b);
108: }
109: });
110: }
111: }
|