Java tutorial
/******************************************************************************* * Copyright (c) 2009 STMicroelectronics. * 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: * Marzia Maugeri <marzia.maugeri@st.com> - initial API and implementation *******************************************************************************/ package org.eclipse.linuxtools.dataviewers.abstractviewers; import java.util.Comparator; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.Status; import org.eclipse.jface.dialogs.IDialogSettings; import org.eclipse.jface.viewers.Viewer; import org.eclipse.jface.viewers.ViewerComparator; import org.eclipse.linuxtools.dataviewers.STDataViewersActivator; import org.eclipse.swt.widgets.Item; /** * This comparator is used to reorder the elements provided by the content provider. */ public class STDataViewersComparator extends ViewerComparator implements Comparator<Object> { /** Maximum number of sorters */ public static final int MAX_DEPTH = 4; /** Tag for ascending direction when sorting */ public static final int ASCENDING = 1; /** Tag for reverse direction when sorting */ public static final int DESCENDING = -1; protected final Item[] columns; protected int[] priorities; protected int[] directions; /** * Copy Constructor * @param other */ public STDataViewersComparator(STDataViewersComparator other) { this(other.getColumns(), other.getPriorities(), other.getDirections()); } /** * Constructor * @param properties the columns properties of the viewer */ public STDataViewersComparator(Item[] columns) { this(columns, null, null); } /** * Constructor * @param properties * @param defaultPriorities * @param defaultDirections */ public STDataViewersComparator(Item[] columns, int[] priorities, int[] directions) { this.columns = columns; if (priorities == null || directions == null) { this.priorities = new int[columns.length]; this.directions = new int[columns.length]; resetState(); } else { if (priorities.length == columns.length && directions.length == columns.length) { this.priorities = priorities; this.directions = directions; } else { STDataViewersActivator.getDefault().getLog() .log(new Status(IStatus.WARNING, STDataViewersActivator.PLUGIN_ID, "Invalid parameters:" + " priorities and/or directions number don't match with" + " viewer's columns count. Applying defaults settings.")); resetState(); } } } public void setPriorities(int[] priorities) { this.priorities = priorities; } public void setDirections(int[] directions) { this.directions = directions; } /** * Reset the priorities to the default ones */ private void resetPriorites() { for (int i = 0; i < this.priorities.length; i++) { this.priorities[i] = i; } } /** * Reset the directions to the default ones */ private void resetDirections() { for (int i = 0; i < this.directions.length; i++) { this.directions[i] = getField(this.columns[i]).getDefaultDirection(); } } /** * Resets the directions and priorities of the sorters */ public void resetState() { resetDirections(); resetPriorites(); } /** * Change the direction of the first sorter */ public void reverseTopPriority() { directions[priorities[0]] *= -1; } /** * Sets the top-level sorter * @param property */ public void setTopPriority(final Item column, final ISTDataViewersField field) { for (int i = 0; i < columns.length; i++) { if (columns[i].equals(column)) { setTopPriority(i, field); return; } } } /** * Sets the top-level sorter * @param priority */ public void setTopPriority(final int priority, final ISTDataViewersField field) { if (priority < 0 || priority >= priorities.length) { return; } int index = -1; for (int i = 0; i < priorities.length; i++) { if (priorities[i] == priority) { index = i; } } if (index == -1) { resetState(); return; } // shift the array for (int i = index; i > 0; i--) { priorities[i] = priorities[i - 1]; } priorities[0] = priority; directions[priority] = field.getDefaultDirection(); } /** Changes the direction of the top-priority sorter * * @param direction */ public void setTopPriorityDirection(int direction) { if (direction == ASCENDING || direction == DESCENDING) { directions[priorities[0]] = direction; } } /** * @return the direction of the top-level sorter */ public int getTopPriorityDirection() { return directions[priorities[0]]; } /** * @return the index of the top-level sorter */ public int getTopPriority() { return priorities[0]; } /** * Return the field at the top priority. * * @return IField */ public Item getTopColumn() { return columns[getTopPriority()]; } /** * NOTE: defensive programming: return a copy of the array * @return the current priorities */ public int[] getPriorities() { int[] copy = new int[priorities.length]; System.arraycopy(priorities, 0, copy, 0, copy.length); return copy; } /** * NOTE: defensive programming: return a copy of the array * @return the current directions */ public int[] getDirections() { int[] copy = new int[directions.length]; System.arraycopy(directions, 0, copy, 0, copy.length); return copy; } /* * (non-Javadoc) * * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ public int compare(Object o1, Object o2) { return compare(o1, o2, 0, true); } /* * (non-Javadoc) * @see org.eclipse.jface.viewers.ViewerComparator#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object) */ public int compare(Viewer viewer, Object e1, Object e2) { return compare(e1, e2, 0, true); } /** * Compare obj1 and obj2 at depth. If continueSearching continue searching * below depth to continue the comparison. * * @param obj1 * @param obj2 * @param depth * @param continueSearching * @return int */ protected int compare(Object obj1, Object obj2, int depth, boolean continueSearching) { if (depth >= priorities.length) { return 0; } int column = priorities[depth]; ISTDataViewersField property = getField(columns[column]); int result; if (directions[column] >= 0) result = property.compare(obj1, obj2); else result = property.compare(obj2, obj1); if (result == 0 && continueSearching) return compare(obj1, obj2, depth + 1, continueSearching); return result; } protected ISTDataViewersField getField(Item column) { return (ISTDataViewersField) column.getData(); } /** * @return IField[] an array of fields */ public Item[] getColumns() { return columns; } /** * Saves the sort order preferences of the user * in the given {@link IDialogSettings} * @param dialogSettings */ public void saveState(IDialogSettings dialogSettings) { if (dialogSettings == null) { return; } IDialogSettings settings = dialogSettings.getSection(STDataViewersSettings.TAG_SECTION_SORTER); if (settings == null) { settings = dialogSettings.addNewSection(STDataViewersSettings.TAG_SECTION_SORTER); } for (int i = 0; i < priorities.length; i++) { settings.put(STDataViewersSettings.TAG_SORTER_PRIORITY_ + i, priorities[i]); settings.put(STDataViewersSettings.TAG_SORTER_DIRECTION_ + i, directions[i]); } } /** Restore the sort order preferences of the user * from the given {@link IDialogSettings} * @param dialogSettings */ public void restoreState(IDialogSettings dialogSettings) { if (dialogSettings == null) { // no settings section resetState(); return; } IDialogSettings settings = dialogSettings.getSection(STDataViewersSettings.TAG_SECTION_SORTER); if (settings == null) { // no settings saved resetState(); return; } try { for (int i = 0; i < priorities.length; i++) { String priority = settings.get(STDataViewersSettings.TAG_SORTER_PRIORITY_ + i); if (priority == null) { // no priority data resetState(); return; } int colIndex = Integer.parseInt(priority); //Make sure it is not old data from a different sized array if (colIndex < columns.length) { priorities[i] = colIndex; } else { // data from a different sized array resetState(); return; } String direction = settings.get(STDataViewersSettings.TAG_SORTER_DIRECTION_ + i); if (direction == null) { // no direction data resetState(); return; } directions[i] = Integer.parseInt(direction); } } catch (NumberFormatException e) { // invalid entry resetState(); return; } } }