Attachment #116103 for bug #216150

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.core.WeekDateRange;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListInterestSorter;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter.SortByIndex;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.tests.connector.MockTask;
import org.eclipse.swt.widgets.Control;


	public void testRootTaskSorting() {
		TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective(),
				TaskComparator.SortByIndex.SUMMARY);

		ITask task = new LocalTask("1", "");
		TaskCategory category = new TaskCategory("cat");

		tasks[5] = new MockTask("local", "5", "a");

		TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective());
		sorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
		sorter.sort(new EmptyViewer(), tasks);

		assertEquals("1", tasks[0].getTaskKey());

		tasks[4] = new MockTask("local", "MYLN:5", "a");

		TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective());
		sorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
		sorter.sort(new EmptyViewer(), tasks);

		assertEquals("MYLN:1", tasks[0].getTaskKey());





package org.eclipse.mylyn.internal.tasks.ui.views;

import java.util.Date;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskCategory;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
import org.eclipse.mylyn.internal.tasks.core.ScheduledTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskGroup;
import org.eclipse.mylyn.internal.tasks.core.UncategorizedTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.UnmatchedTaskContainer;
import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
import org.eclipse.mylyn.tasks.core.IRepositoryElement;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITaskContainer;
import org.eclipse.ui.PlatformUI;

/**
 * @author Mik Kersten
 */
public class TaskListTableSorter extends ViewerSorter {
	public static final int DEFAULT_SORT_DIRECTION = 1;

	private int sortDirectionRootElement = DEFAULT_SORT_DIRECTION;
		PRIORITY, SUMMARY, DATE_CREATED;
	}

	private static final int DEFAULT_SORT_DIRECTION = 1;

	private int sortDirection = DEFAULT_SORT_DIRECTION;

	private SortByIndex sortByIndex = SortByIndex.PRIORITY;

	private int sortDirection2 = DEFAULT_SORT_DIRECTION;

	private SortByIndex sortByIndex2 = SortByIndex.DATE_CREATED;

	private final TaskListView view;

	private final TaskComparator taskComparator = new TaskComparator();

	public TaskListTableSorter(TaskListView view) {
		super();
		this.view = view;
	}

	public TaskListTableSorter(TaskListView view, TaskComparator.SortByIndex index) {
		super();
		this.view = view;
		taskComparator.setSortByIndex(index);
	}

	public void setColumn(String column) {

	 */
	@Override
	public int compare(Viewer compareViewer, Object o1, Object o2) {
		if (o1 instanceof AbstractTask && o2 instanceof AbstractTask) {
			// sort of the tasks within the container using ste setting from the Sortdialog
			ITask element1 = (ITask) o1;
			ITask element2 = (ITask) o2;

			return compareElements(element1, element2);
		} else if (o1 instanceof ScheduledTaskContainer && o2 instanceof ScheduledTaskContainer) {
			// scheduled Mode compare
			ScheduledTaskContainer dateRangeTaskContainer1 = (ScheduledTaskContainer) o1;
			ScheduledTaskContainer dateRangeTaskContainer2 = (ScheduledTaskContainer) o2;
			return this.sortDirectionRootElement
					* dateRangeTaskContainer1.getDateRange().compareTo(dateRangeTaskContainer2.getDateRange());
		} else if (o1 instanceof UnmatchedTaskContainer) {
			// UnmatchedTaskContainer is always the last entry
			return this.sortDirectionRootElement * -1;
		} else if (o2 instanceof UnmatchedTaskContainer) {
			// UnmatchedTaskContainer is always the last entry
			return this.sortDirectionRootElement * 1;
		} else if (o1 instanceof UncategorizedTaskContainer) {
			// UncategorizedTaskContainer is always the first entry
			return this.sortDirectionRootElement * 1;
		} else if (o2 instanceof UncategorizedTaskContainer) {
			// UncategorizedTaskContainer is always the first entry
			return this.sortDirectionRootElement * -1;
		} else if (o1 instanceof TaskGroup && o2 instanceof TaskGroup) {
			// support for the experimental grouping of tasks
			TaskGroup taskGroupTaskContainer1 = (TaskGroup) o1;
			TaskGroup taskGroupTaskContainer2 = (TaskGroup) o2;

			return this.sortDirectionRootElement
					* taskGroupTaskContainer1.getSummary().compareToIgnoreCase(taskGroupTaskContainer2.getSummary());
		} else if ((o1 instanceof AbstractTaskCategory || o1 instanceof RepositoryQuery)
				&& (o2 instanceof AbstractTaskCategory || o2 instanceof RepositoryQuery)) {
			AbstractTaskContainer taskContainer1 = (AbstractTaskContainer) o1;
			AbstractTaskContainer taskContainer2 = (AbstractTaskContainer) o2;
		if (!(o1 instanceof ITask) && o2 instanceof ITask) {
			return 1;
		}

			return this.sortDirectionRootElement
					* taskContainer1.getSummary().compareToIgnoreCase(taskContainer2.getSummary());
		}

		// if (o1 instanceof AbstractTaskContainer || o1 instanceof
		// AbstractRepositoryQuery) {
		if (!(o1 instanceof ITask)) {
			if (o2 instanceof ITaskContainer || o2 instanceof IRepositoryQuery) {

				return this.sortDirection
						* ((IRepositoryElement) o1).getSummary().compareToIgnoreCase(
								((IRepositoryElement) o2).getSummary());
			} else {
				return -1;
			}
		} else if (o1 instanceof ITaskContainer) {
			if (!(o2 instanceof ITask)) {
				return -1;
			} else if (o2 instanceof ITaskContainer) {
				IRepositoryElement element1 = (IRepositoryElement) o1;
				IRepositoryElement element2 = (IRepositoryElement) o2;

				return compareElements(element1, element2);
			}
		} else {
			return 0;
		}
		return 0;
	}

	private int compareElements(ITask element1, ITask element2) {
		return taskComparator.compare(element1, element2);
			int result = sortByPriority(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}

			if (SortByIndex.DATE_CREATED.equals(sortByIndex2)) {
				return sortByDate(element1, element2, sortDirection2);
			} else {
				if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
					return sortBySummary(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		} else if (SortByIndex.DATE_CREATED.equals(sortByIndex)) {
			int result = sortByDate(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}
			if (SortByIndex.PRIORITY.equals(sortByIndex2)) {
				return sortByPriority(element1, element2, sortDirection2);
			} else {
				if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
					return sortBySummary(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		} else {
			int result = sortBySummary(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}
			if (SortByIndex.DATE_CREATED.equals(sortByIndex2)) {
				return sortByDate(element1, element2, sortDirection2);
			} else {
				if (SortByIndex.PRIORITY.equals(sortByIndex2)) {
					return sortByPriority(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		}
	}

	/**
	 * Determine the sort order of two tasks by id/summary
	 * 
	 * @param element1
	 * @param element2
	 * @return sort order
	 */
	private int sortBySummary(IRepositoryElement element1, IRepositoryElement element2, int sortDirection) {
		return sortDirection
				* taskKeyComparator.compare(getSortableFromElement(element1), getSortableFromElement(element2));
	}

	/**
	 * Determine the sort order of two tasks by priority
	 * 
	 * @param element1
	 * @param element2
	 * @return sort order
	 */
	private int sortByPriority(IRepositoryElement element1, IRepositoryElement element2, int sortDirection) {
		return sortDirection
				* ((AbstractTaskContainer) element1).getPriority().compareTo(
						((AbstractTaskContainer) element2).getPriority());
	}

	/**
	 * Determine the sort order of two tasks by creation date
	 * 
	 * @param element1
	 * @param element2
	 * @return sort order
	 */
	private int sortByDate(IRepositoryElement element1, IRepositoryElement element2, int sortDirection) {
		AbstractTask t1 = null;
		AbstractTask t2 = null;
		if (element1 instanceof AbstractTask) {
			t1 = (AbstractTask) element1;
		}
		if (element2 instanceof AbstractTask) {
			t2 = (AbstractTask) element2;
		}
		if (t1 != null && t2 != null) {
			Date creationDate1 = t1.getCreationDate();
			if (creationDate1 != null) {
				Date creationDate2 = t2.getCreationDate();
				if (creationDate2 != null) {
					return sortDirection * creationDate1.compareTo(creationDate2);
				} else {
					return 1;
				}
			}
		}
		return 0;
	}

	/**

		return a;
	}

	public TaskComparator.SortByIndex getSortByIndex() {
		return taskComparator.getSortByIndex();
	}

	public void setSortByIndex(TaskComparator.SortByIndex sortByIndex) {
		TaskComparator.SortByIndex oldValue = taskComparator.getSortByIndex();
		this.sortByIndex = sortByIndex;
		if (!oldValue.equals(sortByIndex)) {
			taskComparator.setSortByIndex(sortByIndex);
		}

	}

	public int getSortDirection() {
		return taskComparator.getSortDirection();
	}

	public void setSortDirection(int sortDirection) {
		int oldValue = taskComparator.getSortDirection();
		if (oldValue != sortDirection) {
			taskComparator.setSortDirection(sortDirection);
			view.getViewer().refresh();
		}
	}

	public TaskComparator.SortByIndex getSortByIndex2() {
		return taskComparator.getSortByIndex2();
	}

	public void setSortByIndex2(TaskComparator.SortByIndex sortByIndex) {
		TaskComparator.SortByIndex oldValue = taskComparator.getSortByIndex2();
		this.sortByIndex2 = sortByIndex;
		if (!oldValue.equals(sortByIndex)) {
			taskComparator.setSortByIndex2(sortByIndex);
		}

	}

	public int getSortDirection2() {
		return taskComparator.getSortDirection2();
	}

	public void setSortDirection2(int sortDirection) {
		int oldValue = taskComparator.getSortDirection2();
		if (oldValue != sortDirection) {
			taskComparator.setSortDirection2(sortDirection);
		}
	}

	public int getSortDirectionRootElement() {
		return sortDirectionRootElement;
	}

	public void setSortDirectionRootElement(int sortDirection) {
		int oldValue = this.sortDirectionRootElement;
		this.sortDirectionRootElement = sortDirection;
		if (oldValue != this.sortDirectionRootElement) {
		}
	}

	public TaskComparator getTaskComparator() {
		return taskComparator;
	}

	public void refreshView() {
		view.getViewer().refresh();
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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

import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.action.Separator;
import org.eclipse.mylyn.internal.provisional.commons.ui.CommonImages;
import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;


		byPriority = new Action("", AS_CHECK_BOX) {
			@Override
			public void run() {
				taskListView.getSorter().setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
				byPriority.setChecked(true);
				bySummary.setChecked(false);
				byDateCreated.setChecked(false);

		bySummary = new Action("", AS_CHECK_BOX) {
			@Override
			public void run() {
				taskListView.getSorter().setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
				byPriority.setChecked(false);
				bySummary.setChecked(true);
				byDateCreated.setChecked(false);

		byDateCreated = new Action("", AS_CHECK_BOX) {
			@Override
			public void run() {
				taskListView.getSorter().setSortByIndex(TaskComparator.SortByIndex.DATE_CREATED);
				byPriority.setChecked(false);
				bySummary.setChecked(false);
				byDateCreated.setChecked(true);

Lines 104-114 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListView.java (-8 / +29 lines)
104	import org.eclipse.mylyn.internal.tasks.ui.actions.TaskListSortAction;	104	import org.eclipse.mylyn.internal.tasks.ui.actions.TaskListSortAction;
105	import org.eclipse.mylyn.internal.tasks.ui.commands.CollapseAllHandler;	105	import org.eclipse.mylyn.internal.tasks.ui.commands.CollapseAllHandler;
106	import org.eclipse.mylyn.internal.tasks.ui.editors.TaskListChangeAdapter;	106	import org.eclipse.mylyn.internal.tasks.ui.editors.TaskListChangeAdapter;
		107	import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
107	import org.eclipse.mylyn.internal.tasks.ui.util.TaskDragSourceListener;	108	import org.eclipse.mylyn.internal.tasks.ui.util.TaskDragSourceListener;
108	import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;	109	import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
109	import org.eclipse.mylyn.internal.tasks.ui.util.TreeWalker;	110	import org.eclipse.mylyn.internal.tasks.ui.util.TreeWalker;
110	import org.eclipse.mylyn.internal.tasks.ui.util.TreeWalker.TreeVisitor;	111	import org.eclipse.mylyn.internal.tasks.ui.util.TreeWalker.TreeVisitor;
111	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter.SortByIndex;
112	import org.eclipse.mylyn.internal.tasks.ui.workingsets.TaskWorkingSetUpdater;	112	import org.eclipse.mylyn.internal.tasks.ui.workingsets.TaskWorkingSetUpdater;
113	import org.eclipse.mylyn.tasks.core.IRepositoryElement;	113	import org.eclipse.mylyn.tasks.core.IRepositoryElement;
114	import org.eclipse.mylyn.tasks.core.IRepositoryQuery;	114	import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
Lines 298-303 Link Here
298		298
299	private static final String MEMENTO_KEY_SORT_DIRECTION = "sortDirection";	299	private static final String MEMENTO_KEY_SORT_DIRECTION = "sortDirection";
300		300
		301	private static final String MEMENTO_KEY_ROOT_SORT_DIRECTION = "rootSortDirection";
		302
301	private static final String MEMENTO_KEY_SORTER = "sorter";	303	private static final String MEMENTO_KEY_SORTER = "sorter";
302		304
303	private static final String MEMENTO_KEY_SORTER2 = "sorter2";	305	private static final String MEMENTO_KEY_SORTER2 = "sorter2";
Lines 761-766 Link Here
761	case DATE_CREATED:	763	case DATE_CREATED:
762	m.putInteger(MEMENTO_KEY_SORT_INDEX, 2);	764	m.putInteger(MEMENTO_KEY_SORT_INDEX, 2);
763	break;	765	break;
		766	case TASK_ID:
		767	m.putInteger(MEMENTO_KEY_SORT_INDEX, 3);
		768	break;
764	default:	769	default:
765	m.putInteger(MEMENTO_KEY_SORT_INDEX, 0);	770	m.putInteger(MEMENTO_KEY_SORT_INDEX, 0);
766	}	771	}
Lines 774-779 Link Here
774	case DATE_CREATED:	779	case DATE_CREATED:
775	m2.putInteger(MEMENTO_KEY_SORT_INDEX, 2);	780	m2.putInteger(MEMENTO_KEY_SORT_INDEX, 2);
776	break;	781	break;
		782	case TASK_ID:
		783	m.putInteger(MEMENTO_KEY_SORT_INDEX, 3);
		784	break;
777	default:	785	default:
778	m2.putInteger(MEMENTO_KEY_SORT_INDEX, 0);	786	m2.putInteger(MEMENTO_KEY_SORT_INDEX, 0);
779	}	787	}
Lines 781-786 Link Here
781	m2.putInteger(MEMENTO_KEY_SORT_DIRECTION, tableSorter.getSortDirection2());	789	m2.putInteger(MEMENTO_KEY_SORT_DIRECTION, tableSorter.getSortDirection2());
782	memento.putString(MEMENTO_LINK_WITH_EDITOR, Boolean.toString(linkWithEditor));	790	memento.putString(MEMENTO_LINK_WITH_EDITOR, Boolean.toString(linkWithEditor));
783	memento.putString(MEMENTO_PRESENTATION, currentPresentation.getId());	791	memento.putString(MEMENTO_PRESENTATION, currentPresentation.getId());
		792	memento.putInteger(MEMENTO_KEY_ROOT_SORT_DIRECTION, tableSorter.getSortDirectionRootElement());
784	}	793	}
785		794
786	private void restoreState() {	795	private void restoreState() {
Lines 803-815 Link Here
803	tableSorter.setSortDirection(sortDirection);	812	tableSorter.setSortDirection(sortDirection);
804	switch (restoredSortIndex) {	813	switch (restoredSortIndex) {
805	case 1:	814	case 1:
806	tableSorter.setSortByIndex(SortByIndex.SUMMARY);	815	tableSorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
807	break;	816	break;
808	case 2:	817	case 2:
809	tableSorter.setSortByIndex(SortByIndex.DATE_CREATED);	818	tableSorter.setSortByIndex(TaskComparator.SortByIndex.DATE_CREATED);
		819	break;
		820	case 3:
		821	tableSorter.setSortByIndex(TaskComparator.SortByIndex.TASK_ID);
810	break;	822	break;
811	default:	823	default:
812	tableSorter.setSortByIndex(SortByIndex.PRIORITY);	824	tableSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
813	}	825	}
814	}	826	}
815	}	827	}
Lines 826-843 Link Here
826	tableSorter.setSortDirection2(sortDirection);	838	tableSorter.setSortDirection2(sortDirection);
827	switch (restoredSortIndex) {	839	switch (restoredSortIndex) {
828	case 1:	840	case 1:
829	tableSorter.setSortByIndex2(SortByIndex.SUMMARY);	841	tableSorter.setSortByIndex2(TaskComparator.SortByIndex.SUMMARY);
830	break;	842	break;
831	case 2:	843	case 2:
832	tableSorter.setSortByIndex2(SortByIndex.DATE_CREATED);	844	tableSorter.setSortByIndex2(TaskComparator.SortByIndex.DATE_CREATED);
		845	break;
		846	case 3:
		847	tableSorter.setSortByIndex2(TaskComparator.SortByIndex.TASK_ID);
833	break;	848	break;
834	default:	849	default:
835	tableSorter.setSortByIndex2(SortByIndex.PRIORITY);	850	tableSorter.setSortByIndex2(TaskComparator.SortByIndex.PRIORITY);
836	}	851	}
837	}	852	}
838	}	853	}
839	}	854	}
840	applyPresentation(taskListMemento.getString(MEMENTO_PRESENTATION));	855	applyPresentation(taskListMemento.getString(MEMENTO_PRESENTATION));
		856	Integer sortOrder = taskListMemento.getInteger(MEMENTO_KEY_ROOT_SORT_DIRECTION);
		857	if (sortOrder != null) {
		858	tableSorter.setSortDirectionRootElement(sortOrder);
		859	} else {
		860	tableSorter.setSortDirectionRootElement(TaskListTableSorter.DEFAULT_SORT_DIRECTION);
		861	}
841	}	862	}
842		863
843	if (tableSorter == null) {	864	if (tableSorter == null) {
Lines 1477-1483 Link Here
1477	synchronizeAutomatically = new SynchronizeAutomaticallyAction();	1498	synchronizeAutomatically = new SynchronizeAutomaticallyAction();
1478	openPreferencesAction = new OpenTasksUiPreferencesAction();	1499	openPreferencesAction = new OpenTasksUiPreferencesAction();
1479	//filterArchiveCategory = new FilterArchiveContainerAction(this);	1500	//filterArchiveCategory = new FilterArchiveContainerAction(this);
1480	sortDialogAction = new TaskListSortAction(getSite(), this);	1501	sortDialogAction = new TaskListSortAction(getSite(), tableSorter);
1481	filterOnPriorityAction = new PriorityDropDownAction(this);	1502	filterOnPriorityAction = new PriorityDropDownAction(this);
1482	linkWithEditorAction = new LinkWithEditorAction(this);	1503	linkWithEditorAction = new LinkWithEditorAction(this);
1483	presentationDropDownSelectionAction = new PresentationDropDownSelectionAction(this);	1504	presentationDropDownSelectionAction = new PresentationDropDownSelectionAction(this);

Lines 1-2 Link Here

(-).refactorings/2008/10/43/refactorings.index (+2 lines)
1	1224453298513 Delete element	1	1224453298513 Delete element
2	1224737272005 Extract local variable 'repositoryPerson'	2	1224737272005 Extract local variable 'repositoryPerson'
		3	1224872029957 Delete elements
		4	1224875091596 Delete element

Lines 1-3 Link Here

(-).refactorings/2008/10/43/refactorings.history (-1 / +1 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<session version="1.0"> <refactoring accessors="true" comment="Delete 1 element(s) from project 'org.eclipse.mylyn.tasks.ui' - Original project: 'org.eclipse.mylyn.tasks.ui' - Original element: 'org.eclipse.mylyn.internal.tasks.ui.search.AbstractRepositorySearchQuery.java'" description="Delete element" element1="/src<org.eclipse.mylyn.internal.tasks.ui.search{AbstractRepositorySearchQuery.java" elements="1" flags="589830" id="org.eclipse.jdt.ui.delete" resources="0" stamp="1224453298513" subPackages="false" version="1.0"/> <refactoring comment="Extract local variable 'repositoryPerson' from expression 'getAttributeMapper().getRepositoryPerson(getTaskAttribute())' - Original project: 'org.eclipse.mylyn.tasks.ui' - Variable name: 'repositoryPerson' - Destination method: 'org.eclipse.mylyn.internal.tasks.ui.editors.PersonAttributeEditor.getValue()' - Variable expression: 'getAttributeMapper().getRepositoryPerson(getTaskAttribute())' - Replace occurrences of expression with variable" description="Extract local variable 'repositoryPerson'" final="false" id="org.eclipse.jdt.ui.extract.temp" input="/src<org.eclipse.mylyn.internal.tasks.ui.editors{PersonAttributeEditor.java" name="repositoryPerson" replace="true" selection="987 60" stamp="1224737272005" version="1.0"/>	2	<session version="1.0"> <refactoring accessors="true" comment="Delete 1 element(s) from project 'org.eclipse.mylyn.tasks.ui' - Original project: 'org.eclipse.mylyn.tasks.ui' - Original element: 'org.eclipse.mylyn.internal.tasks.ui.search.AbstractRepositorySearchQuery.java'" description="Delete element" element1="/src<org.eclipse.mylyn.internal.tasks.ui.search{AbstractRepositorySearchQuery.java" elements="1" flags="589830" id="org.eclipse.jdt.ui.delete" resources="0" stamp="1224453298513" subPackages="false" version="1.0"/> <refactoring comment="Extract local variable 'repositoryPerson' from expression 'getAttributeMapper().getRepositoryPerson(getTaskAttribute())' - Original project: 'org.eclipse.mylyn.tasks.ui' - Variable name: 'repositoryPerson' - Destination method: 'org.eclipse.mylyn.internal.tasks.ui.editors.PersonAttributeEditor.getValue()' - Variable expression: 'getAttributeMapper().getRepositoryPerson(getTaskAttribute())' - Replace occurrences of expression with variable" description="Extract local variable 'repositoryPerson'" final="false" id="org.eclipse.jdt.ui.extract.temp" input="/src<org.eclipse.mylyn.internal.tasks.ui.editors{PersonAttributeEditor.java" name="repositoryPerson" replace="true" selection="987 60" stamp="1224737272005" version="1.0"/> <refactoring accessors="true" comment="Delete 3 element(s) from project 'org.eclipse.mylyn.tasks.ui' - Original project: 'org.eclipse.mylyn.tasks.ui' - Original elements: org.eclipse.mylyn.internal.tasks.ui.search.SearchResultSorterDescription.java org.eclipse.mylyn.internal.tasks.ui.search.SearchResultSorterId.java org.eclipse.mylyn.internal.tasks.ui.search.SearchResultSorterPriority.java" description="Delete elements" element1="/src<org.eclipse.mylyn.internal.tasks.ui.search{SearchResultSorterDescription.java" element2="/src<org.eclipse.mylyn.internal.tasks.ui.search{SearchResultSorterId.java" element3="/src<org.eclipse.mylyn.internal.tasks.ui.search{SearchResultSorterPriority.java" elements="3" flags="589830" id="org.eclipse.jdt.ui.delete" resources="0" stamp="1224872029957" subPackages="false" version="1.0"/> <refactoring accessors="true" comment="Delete 1 element(s) from project 'org.eclipse.mylyn.tasks.ui' - Original project: 'org.eclipse.mylyn.tasks.ui' - Original element: 'org.eclipse.mylyn.internal.tasks.ui.dialogs.SortResultSortDialog.java'" description="Delete element" element1="/src<org.eclipse.mylyn.internal.tasks.ui.dialogs{SortResultSortDialog.java" elements="1" flags="589830" id="org.eclipse.jdt.ui.delete" resources="0" stamp="1224875091596" subPackages="false" version="1.0"/>
3	</session>	3	</session>

Lines 1-5 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/TaskListSortAction.java (-5 / +10 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2008 Tasktop Technologies and others.	2	* Copyright (c) 2004, 2008 Tasktop Technologies and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 12-19 Link Here
12	package org.eclipse.mylyn.internal.tasks.ui.actions;	12	package org.eclipse.mylyn.internal.tasks.ui.actions;
13		13
14	import org.eclipse.jface.action.Action;	14	import org.eclipse.jface.action.Action;
		15	import org.eclipse.jface.window.Window;
15	import org.eclipse.mylyn.internal.tasks.ui.dialogs.TaskListSortDialog;	16	import org.eclipse.mylyn.internal.tasks.ui.dialogs.TaskListSortDialog;
16	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;	17	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;
17	import org.eclipse.ui.IWorkbenchPartSite;	18	import org.eclipse.ui.IWorkbenchPartSite;
18		19
19	/**	20	/**
Lines 23-37 Link Here
23		24
24	private final TaskListSortDialog dialog;	25	private final TaskListSortDialog dialog;
25		26
26	public TaskListSortAction(IWorkbenchPartSite site, TaskListView taskListView) {	27	TaskListTableSorter taskListTableSorter;
		28
		29	public TaskListSortAction(IWorkbenchPartSite site, TaskListTableSorter taskListTableSorter) {
27	super("Sort...");	30	super("Sort...");
28	setEnabled(true);	31	setEnabled(true);
29	dialog = new TaskListSortDialog(site, taskListView);	32	dialog = new TaskListSortDialog(site, taskListTableSorter);
30	}	33	}
31		34
32	@Override	35	@Override
33	public void run() {	36	public void run() {
34	dialog.open();	37	if (dialog.open() == Window.OK) {
		38	taskListTableSorter.refreshView();
		39	}
35	}	40	}
36		41
37	}	42	}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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


package org.eclipse.mylyn.internal.tasks.ui.dialogs;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

import org.eclipse.jface.window.IShellProvider;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter.SortByIndex;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.dialogs.SelectionDialog;

public class TaskListSortDialog extends SelectionDialog {
	private Combo[] priorityCombos;

public class TaskListSortDialog extends TaskCompareDialog {

//	private final TaskListView taskListView;

	private Button ascendingRootButton;

	private Button descendingRootButton;

	private final TaskListTableSorter taskListTableSorter;

	public TaskListSortDialog(IShellProvider parentShell, TaskListTableSorter taskListTableSorter) {
		super(parentShell, taskListTableSorter.getTaskComparator());
		this.taskListTableSorter = taskListTableSorter;
		propertyText[0] = "Priority";
		propertyText[1] = "Summary";
		propertyText[2] = "Date Created";
		this.taskListView = taskListView;
		setTitle(TaskListView.LABEL_VIEW + " Sorting");
	}

	@Override
	protected void createDialogStartArea(Composite parent) {
		Label sortByHeader = new Label(parent, SWT.NULL);
		sortByHeader.setText("Sort order Container:");

		ascendingRootButton = new Button(parent, SWT.RADIO);
		ascendingRootButton.setText("Ascending");
		ascendingRootButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				markDirty();
			}
		});

		descendingRootButton = new Button(parent, SWT.RADIO);
		descendingRootButton.setText("Descending");
		descendingRootButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				markDirty();
			}
		});

		Label sortByLabel = new Label(parent, SWT.NULL);
		sortByLabel.setText("Sort order within a Container:");
		GridData data = new GridData();
		data.horizontalSpan = 3;
		sortByLabel.setLayoutData(data);

		ascendingButtons = new Button[2];
		descendingButtons = new Button[2];
		priorityCombos = new Combo[2];

		for (int i = 0; i < 2; i++) {
			final int index = i;
			Label numberLabel = new Label(prioritiesArea, SWT.NULL);
			numberLabel.setText("" + (i + 1) + ".");
			priorityCombos[i] = new Combo(prioritiesArea, SWT.READ_ONLY);
			priorityCombos[i].setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

			Composite directionGroup = new Composite(prioritiesArea, SWT.NONE);
			directionGroup.setLayout(new GridLayout(2, false));
			ascendingButtons[i] = new Button(directionGroup, SWT.RADIO);
			ascendingButtons[i].setText("Ascending");
			ascendingButtons[i].addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					markDirty();
				}
			});
			descendingButtons[i] = new Button(directionGroup, SWT.RADIO);
			descendingButtons[i].setText("Descending");
			descendingButtons[i].addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					markDirty();
				}
			});
			if (i < priorityCombos.length - 1) {
				priorityCombos[i].addSelectionListener(new SelectionAdapter() {
					@Override
					public void widgetSelected(SelectionEvent e) {
						int oldSelectionDirection = 1;
						if (descendingButtons[index].getSelection()) {
							oldSelectionDirection = -1;
						}
						ArrayList<String> oldSelectionList = new ArrayList<String>(
								Arrays.asList(priorityCombos[index].getItems()));
						oldSelectionList.removeAll(Arrays.asList(priorityCombos[index + 1].getItems()));
						if (oldSelectionList.size() != 1) {
							return;
						}
						String oldSelection = oldSelectionList.get(0);
						String newSelection = priorityCombos[index].getItem(priorityCombos[index].getSelectionIndex());
						if (oldSelection.equals(newSelection)) {
							return;
						}
						for (int j = index + 1; j < priorityCombos.length; j++) {
							int newSelectionIndex = priorityCombos[j].indexOf(newSelection);
							//this combo's current selection is equal to newSelection
							if (priorityCombos[j].getSelectionIndex() == newSelectionIndex) {
								priorityCombos[j].remove(newSelection);
								int insertionPoint = -1
										- Arrays.binarySearch(priorityCombos[j].getItems(), oldSelection,
												columnComparator);
								if (insertionPoint >= 0 && insertionPoint <= priorityCombos[j].getItemCount()) {
									priorityCombos[j].add(oldSelection, insertionPoint);
								} else {
									priorityCombos[j].add(oldSelection);
								}
								priorityCombos[j].select(priorityCombos[j].indexOf(oldSelection));
								ascendingButtons[index].setSelection(ascendingButtons[j].getSelection());
								descendingButtons[index].setSelection(descendingButtons[j].getSelection());
								ascendingButtons[j].setSelection(oldSelectionDirection == 1);
								descendingButtons[j].setSelection(oldSelectionDirection == -1);
							}
							//this combo contains newSelection
							else if (newSelectionIndex >= 0) {
								String currentText = priorityCombos[j].getText();
								priorityCombos[j].remove(newSelection);
								int insertionPoint = -1
										- Arrays.binarySearch(priorityCombos[j].getItems(), oldSelection,
												columnComparator);
								if (insertionPoint >= 0 && insertionPoint <= priorityCombos[j].getItemCount()) {
									priorityCombos[j].add(oldSelection, insertionPoint);
									priorityCombos[j].select(priorityCombos[j].indexOf(currentText));
								} else {
									priorityCombos[j].add(oldSelection);
								}
							}
						}
						markDirty();
					}
				});
			} else {
				priorityCombos[i].addSelectionListener(new SelectionAdapter() {
					@Override
					public void widgetSelected(SelectionEvent e) {
						markDirty();
					}
				});
			}

		}
		int a[] = new int[2];
		int b[] = new int[2];
		switch (taskListView.getSorter().getSortByIndex()) {
		case PRIORITY:
			a[0] = 0;
			break;
		case SUMMARY:
			a[0] = 1;
			break;
		case DATE_CREATED:
			a[0] = 2;
			break;
		}

		switch (taskListView.getSorter().getSortByIndex2()) {
		case PRIORITY:
			a[1] = 0;
			break;
		case SUMMARY:
			a[1] = 1;
			break;
		case DATE_CREATED:
			a[1] = 2;
			break;
		}
		b[0] = taskListView.getSorter().getSortDirection();
		b[1] = taskListView.getSorter().getSortDirection2();
		updateUI(a, b);
		return composite;
	}

	@Override
	protected void okPressed() {
		if (isDirty()) {
			if (descendingRootButton.getSelection()) {
				taskListTableSorter.setSortDirectionRootElement(-1);
							'_').toUpperCase()));
			taskListView.getSorter().setSortByIndex2(
					SortByIndex.valueOf(priorityCombos[1].getItem(priorityCombos[1].getSelectionIndex()).replace(' ',
							'_').toUpperCase()));
			if (descendingButtons[0].getSelection()) {
				taskListView.getSorter().setSortDirection(-1);
			} else {
				taskListView.getSorter().setSortDirection(1);
			}
			if (descendingButtons[1].getSelection()) {
				taskListView.getSorter().setSortDirection2(-1);
			} else {
				taskListTableSorter.setSortDirectionRootElement(1);
			}

		}
		super.okPressed();
	}

	@Override
	protected void updateUI(int[] priorities, int[] directions) {
		int headElementDirection = taskListTableSorter.getSortDirectionRootElement();
		super.updateUI(priorities, directions);
		ascendingRootButton.setSelection(headElementDirection == 1);
		descendingRootButton.setSelection(headElementDirection == -1);

	/**
	 * Sets the dirty flag to true.
	 */
	public void markDirty() {
		dirty = true;
	}

	private final Comparator<String> columnComparator = new Comparator<String>() {
		public int compare(String arg0, String arg1) {
			int index0 = -1;
			int index1 = -1;
			for (int i = 0; i < propertyText.length; i++) {
				if (propertyText[i].equals(arg0)) {
					index0 = i;
				}
				if (propertyText[i].equals(arg1)) {
					index1 = i;
				}
			}
			return index0 - index1;
		}
	};

	private void updateUI(int[] priorities, int[] directions) {
		ArrayList<String> availablePriorities = new ArrayList<String>(Arrays.asList(propertyText));

		for (int i = 0; i < priorityCombos.length; i++) {
			priorityCombos[i].removeAll();
			for (int j = 0; j < availablePriorities.size(); j++) {
				priorityCombos[i].add(availablePriorities.get(j));
			}
			priorityCombos[i].select(priorityCombos[i].indexOf(propertyText[priorities[i]]));
			availablePriorities.remove(propertyText[priorities[i]]);

			ascendingButtons[i].setSelection(directions[i] == 1);
			descendingButtons[i].setSelection(directions[i] == -1);
		}
	}

}




/*******************************************************************************
* Copyright (c) 2004, 2008 Tasktop Technologies 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:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.search;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskKeyComparator;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;
import org.eclipse.mylyn.tasks.core.ITask;

/**
 * Sorts search results by summary.
 * 
 * @author Rob Elves
 */
public class SearchResultSorterDescription extends ViewerSorter {

	private final TaskKeyComparator taskKeyComparator = new TaskKeyComparator();

	/**
	 * Returns a negative, zero, or positive number depending on whether the first bug's summary goes before, is the
	 * same as, or goes after the second element's summary.
	 * <p>
	 * 
	 * @see org.eclipse.jface.viewers.ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object,
	 *      java.lang.Object)
	 */
	@Override
	public int compare(Viewer viewer, Object e1, Object e2) {
		try {

			AbstractTask entry1 = (AbstractTask) e1;
			AbstractTask entry2 = (AbstractTask) e2;
			// NOTE we just comparing ids here, once summary and taskId separated
			// they should have their own column/sorter.
			return taskKeyComparator.compare(TaskListTableSorter.getSortableFromElement(entry1),
					TaskListTableSorter.getSortableFromElement(entry2));
			// return taskKeyComparator.compare(entry1.getDescription(),
			// entry2.getDescription());
		} catch (Exception ignored) {
			// do nothing
		}

		// if that didn't work, use the default compare method
		return super.compare(viewer, e1, e2);
	}

	/**
	 * Returns the category of the given element. The category is a number used to allocate elements to bins; the bins
	 * are arranged in ascending numeric order. The elements within a bin are arranged via a second level sort
	 * criterion.
	 * <p>
	 * 
	 * @see org.eclipse.jface.viewers.ViewerSorter#category(Object)
	 */
	@Override
	public int category(Object element) {
		try {
			ITask hit = (ITask) element;
			return Integer.parseInt(hit.getTaskId());
		} catch (Exception ignored) {
			// ignore if
		}
		// if that didn't work, use the default category method
		return super.category(element);
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/SearchResultSortAction.java (-17 / +14 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2008 Tasktop Technologies and others.	2	* Copyright (c) 2004, 2008 Tasktop Technologies and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 12-17 Link Here
12	package org.eclipse.mylyn.internal.tasks.ui.search;	12	package org.eclipse.mylyn.internal.tasks.ui.search;
13		13
14	import org.eclipse.jface.action.Action;	14	import org.eclipse.jface.action.Action;
		15	import org.eclipse.jface.window.IShellProvider;
		16	import org.eclipse.jface.window.Window;
		17	import org.eclipse.mylyn.internal.tasks.ui.dialogs.TaskCompareDialog;
15		18
16	/**	19	/**
17	* This class sorts search results by a supplied category.	20	* This class sorts search results by a supplied category.
Lines 20-30 Link Here
20	*/	23	*/
21	public class SearchResultSortAction extends Action {	24	public class SearchResultSortAction extends Action {
22		25
23	/** The category that this class sorts Bugzilla search results by. */	26	private final TaskCompareDialog dialog;
24	private final int bugSortOrder;
25		27
26	/** The view where the Bugzilla search results are displayed. */	28	SearchResultSorter searchResultSorter;
27	private final RepositorySearchResultView bugPage;
28		29
29	/**	30	/**
30	* Constructor	31	* Constructor
Lines 36-45 Link Here
36	* @param sortOrder	37	* @param sortOrder
37	* The category that this class sorts Bugzilla search results by	38	* The category that this class sorts Bugzilla search results by
38	*/	39	*/
39	public SearchResultSortAction(String label, RepositorySearchResultView page, int sortOrder) {	40	public SearchResultSortAction(IShellProvider site, SearchResultSorter searchResultSorter) {
40	super(label);	41	super("Sort...");
41	bugPage = page;	42	setEnabled(true);
42	bugSortOrder = sortOrder;	43	dialog = new TaskCompareDialog(site, searchResultSorter.getTaskComparator());
		44	this.searchResultSorter = searchResultSorter;
43	}	45	}
44		46
45	/**	47	/**
Lines 47-59 Link Here
47	*/	49	*/
48	@Override	50	@Override
49	public void run() {	51	public void run() {
50	bugPage.setSortOrder(bugSortOrder);	52	if (dialog.open() == Window.OK) {
51	}	53	searchResultSorter.refreshView();
52		54	}
53	/**
54	* Returns the category that this class sorts Bugzilla search results by.
55	*/
56	public int getSortOrder() {
57	return bugSortOrder;
58	}	55	}
59	}	56	}




/*******************************************************************************
* Copyright (c) 2004, 2008 Tasktop Technologies 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:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.search;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.mylyn.tasks.core.ITask;

/**
 * Sorts results of Bugzilla search by bug priority.
 * 
 * @author Rob Elves (modifications)
 */
public class SearchResultSorterPriority extends ViewerSorter {

	/**
	 * Returns a negative, zero, or positive number depending on whether the first bug's priority goes before, is the
	 * same as, or goes after the second element's priority.
	 * <p>
	 * 
	 * @see org.eclipse.jface.viewers.ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object,
	 *      java.lang.Object)
	 */
	@Override
	public int compare(Viewer viewer, Object e1, Object e2) {
		try {
			ITask hit1 = (ITask) e1;
			ITask hit2 = (ITask) e2;
			return hit1.getPriority().compareTo(hit2.getPriority());
		} catch (Exception ignored) {
			// do nothing
		}
		// if that didn't work, use the default compare method
		return super.compare(viewer, e1, e2);
	}

	/**
	 * Returns the category of the given element. The category is a number used to allocate elements to bins; the bins
	 * are arranged in ascending numeric order. The elements within a bin are arranged via a second level sort
	 * criterion.
	 * <p>
	 * 
	 * @see org.eclipse.jface.viewers.ViewerSorter#category(Object)
	 */
	@Override
	public int category(Object element) {
		try {
			ITask hit = (ITask) element;
			return Integer.parseInt(hit.getTaskId());
		} catch (Exception ignored) {
			// ignore if there is a problem
		}
		// if that didn't work, use the default category method
		return super.category(element);
	}
}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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

import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.actions.OpenTaskSearchAction;
import org.eclipse.mylyn.internal.tasks.ui.search.SearchResultTreeContentProvider.GroupBy;
import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListToolTip;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;

import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.search.internal.ui.SearchMessages;
import org.eclipse.search.ui.IContextMenuConstants;
import org.eclipse.search.ui.ISearchResult;
import org.eclipse.search.ui.text.AbstractTextSearchViewPage;


	private int currentSortOrder;

//	private final SearchResultSortAction sortByPriorityAction;
//
//	private final SearchResultSortAction sortByDescriptionAction;

	private SearchResultSortAction sortByDialogAction;

	private final OpenSearchResultAction openInEditorAction;


		}
	};

	private SearchResultSorter searchResultSorter;

	public RepositorySearchResultView() {
		// Only use the table layout.
		super(FLAG_LAYOUT_TREE);

//		sortByPriorityAction = new SearchResultSortAction("Task Priority", this, ORDER_PRIORITY);
//		sortByDescriptionAction = new SearchResultSortAction("Task Summary", this, ORDER_DESCRIPTION);

		currentSortOrder = ORDER_DEFAULT;

		openInEditorAction = new OpenSearchResultAction("Open in Editor", this);

				searchResultProvider, viewer), PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator());
		viewer.setLabelProvider(labelProvider);

		searchResultSorter = new SearchResultSorter(this);
		viewer.setSorter(searchResultSorter);
		sortByDialogAction = new SearchResultSortAction(getSite(), searchResultSorter);
		// Set the order when the search view is loading so that the items are
		// sorted right away
		setSortOrder(currentSortOrder);

	 *            The new category to sort by
	 */
	public void setSortOrder(int sortOrder) {
		StructuredViewer viewer = getViewer();

		switch (sortOrder) {
		case ORDER_ID:
			searchResultSorter.setSortByIndex(TaskComparator.SortByIndex.TASK_ID);
			break;
		case ORDER_DESCRIPTION:
			searchResultSorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
			break;
		case ORDER_PRIORITY:
			searchResultSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
			break;
		default:
			// If the setting is not one of the four valid ones,
			// use the default order setting.
			sortOrder = ORDER_DEFAULT;
			searchResultSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
			break;
		}
		currentSortOrder = sortOrder;
		getSettings().put(KEY_SORTING, currentSortOrder);
//		searchResultSorter.refresh(searchResultSorter.getRoot(), updateLabels);
		this.getViewer().refresh();
	}

	@SuppressWarnings("unchecked")

	@Override
	protected void fillContextMenu(IMenuManager menuManager) {
		super.fillContextMenu(menuManager);
//		MenuManager sortMenuManager = new MenuManager(SearchMessages.SortDropDownAction_label);
//		sortMenuManager.add(sortByPriorityAction);
//		sortMenuManager.add(sortByDescriptionAction);
//
//		sortByPriorityAction.setChecked(currentSortOrder == sortByPriorityAction.getSortOrder());
//		sortByDescriptionAction.setChecked(currentSortOrder == sortByDescriptionAction.getSortOrder());

		menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortByDialogAction);
		// Add the new context menu items
//		menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager);
		for (Action action : groupingActions) {
			menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, action);
		}




/*******************************************************************************
* Copyright (c) 2004, 2008 Tasktop Technologies 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:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.search;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.mylyn.tasks.core.ITask;

/**
 * Sorts search results (AbstractQueryHit) by taskId.
 */
public class SearchResultSorterId extends ViewerSorter {

	/**
	 * Returns a negative, zero, or positive number depending on whether the first bug's taskId is less than, equal to,
	 * or greater than the second bug's taskId.
	 * <p>
	 * 
	 * @see org.eclipse.jface.viewers.ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object,
	 *      java.lang.Object)
	 */
	@Override
	public int compare(Viewer viewer, Object e1, Object e2) {
		try {
			// cast the object and get its bug taskId
			ITask entry1 = (ITask) e1;
			Integer id1 = Integer.parseInt(entry1.getTaskId());

			// cast the other object and get its bug taskId
			ITask entry2 = (ITask) e2;
			Integer id2 = Integer.parseInt(entry2.getTaskId());

			// if neither is null, compare the bug taskId's
			if (id1 != null && id2 != null) {
				return id1.compareTo(id2);
			}
		} catch (Exception ignored) {
			// ignore if there is a problem
		}

		// if that didn't work, use the default compare method
		return super.compare(viewer, e1, e2);
	}

	/**
	 * Returns the category of the given element. The category is a number used to allocate elements to bins; the bins
	 * are arranged in ascending numeric order. The elements within a bin are arranged via a second level sort
	 * criterion.
	 * <p>
	 * 
	 * @see org.eclipse.jface.viewers.ViewerSorter#category(Object)
	 */
	@Override
	public int category(Object element) {
		try {
			ITask hit = (ITask) element;
			return Integer.parseInt(hit.getTaskId());
		} catch (Exception ignored) {
			// ignore
		}
		// if that didn't work, use the default category method
		return super.category(element);
	}
}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.util;

import java.util.Comparator;

import org.eclipse.mylyn.tasks.core.ITask;

public class TaskComparator implements Comparator<ITask> {

	public enum SortByIndex {
		PRIORITY, SUMMARY, DATE_CREATED, TASK_ID;
	}

	public static final int DEFAULT_SORT_DIRECTION = 1;

	private int sortDirection = DEFAULT_SORT_DIRECTION;

	private SortByIndex sortByIndex = SortByIndex.PRIORITY;

	private int sortDirection2 = DEFAULT_SORT_DIRECTION;

	private SortByIndex sortByIndex2 = SortByIndex.DATE_CREATED;

	public int compare(ITask element1, ITask element2) {
		if (SortByIndex.PRIORITY.equals(sortByIndex)) {
			int result = sortByPriority(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}

			if (SortByIndex.DATE_CREATED.equals(sortByIndex2)) {
				return sortByDate(element1, element2, sortDirection2);
			} else {
				if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
					return sortBySummary(element1, element2, sortDirection2);
				} else if (SortByIndex.TASK_ID.equals(sortByIndex2)) {
					return sortByID(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		} else if (SortByIndex.DATE_CREATED.equals(sortByIndex)) {
			int result = sortByDate(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}
			if (SortByIndex.PRIORITY.equals(sortByIndex2)) {
				return sortByPriority(element1, element2, sortDirection2);
			} else {
				if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
					return sortBySummary(element1, element2, sortDirection2);
				} else if (SortByIndex.TASK_ID.equals(sortByIndex2)) {
					return sortByID(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		} else if (SortByIndex.SUMMARY.equals(sortByIndex)) {
			int result = sortBySummary(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}
			if (SortByIndex.DATE_CREATED.equals(sortByIndex2)) {
				return sortByDate(element1, element2, sortDirection2);
			} else {
				if (SortByIndex.PRIORITY.equals(sortByIndex2)) {
					return sortByPriority(element1, element2, sortDirection2);
				} else if (SortByIndex.TASK_ID.equals(sortByIndex2)) {
					return sortByID(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		} else {
			int result = sortByID(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}
			if (SortByIndex.DATE_CREATED.equals(sortByIndex2)) {
				return sortByDate(element1, element2, sortDirection2);
			} else {
				if (SortByIndex.PRIORITY.equals(sortByIndex2)) {
					return sortByPriority(element1, element2, sortDirection2);
				} else if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
					return sortBySummary(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		}
	}

	private int sortBySummary(ITask element1, ITask element2, int sortDirection) {
		return sortDirection * (element1.getSummary().compareTo(element2.getSummary()));
	}

	private int sortByID(ITask element1, ITask element2, int sortDirection) {
		return sortDirection * (element1.getTaskId().compareTo(element2.getTaskId()));
	}

	private int sortByPriority(ITask element1, ITask element2, int sortDirection) {
		return sortDirection * (element1.getPriority().compareTo(element2.getPriority()));
	}

	private int sortByDate(ITask element1, ITask element2, int sortDirection) {
		return sortDirection * (element1.getCreationDate().compareTo(element2.getCreationDate()));
	}

	public SortByIndex getSortByIndex() {
		return sortByIndex;
	}

	public void setSortByIndex(SortByIndex sortByIndex) {
		this.sortByIndex = sortByIndex;
	}

	public int getSortDirection() {
		return sortDirection;
	}

	public void setSortDirection(int sortDirection) {
		this.sortDirection = sortDirection;
	}

	public SortByIndex getSortByIndex2() {
		return sortByIndex2;
	}

	public void setSortByIndex2(SortByIndex sortByIndex) {
		this.sortByIndex2 = sortByIndex;
	}

	public int getSortDirection2() {
		return sortDirection2;
	}

	public void setSortDirection2(int sortDirection) {
		this.sortDirection2 = sortDirection;
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.dialogs;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

import org.eclipse.jface.window.IShellProvider;
import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.ui.dialogs.SelectionDialog;

public class TaskCompareDialog extends SelectionDialog {
	private Combo[] priorityCombos;

	private Button[] ascendingButtons;

	private Button[] descendingButtons;

	private final String[] propertyText;

	private boolean dirty = false;

	private final TaskComparator taskComparator;

	public TaskCompareDialog(IShellProvider parentShell, TaskComparator taskComparator) {
		super(parentShell.getShell());
		propertyText = new String[4];
		propertyText[0] = "Priority";
		propertyText[1] = "Summary";
		propertyText[2] = "Date Created";
		propertyText[3] = "Task ID";
		this.taskComparator = taskComparator;
		setTitle(TaskListView.LABEL_VIEW + " Sorting");
	}

	protected void createDialogStartArea(Composite parent) {
		Label sortByLabel = new Label(parent, SWT.NULL);
		sortByLabel.setText("Sort order:");
		GridData data = new GridData();
		data.horizontalSpan = 3;
		sortByLabel.setLayoutData(data);
	}

	@Override
	protected Control createDialogArea(Composite parent) {
		Composite composite = (Composite) super.createDialogArea(parent);

		initializeDialogUnits(composite);

		Composite prioritiesArea = new Composite(composite, SWT.NULL);
		prioritiesArea.setLayout(new GridLayout(3, false));

		createDialogStartArea(prioritiesArea);

		ascendingButtons = new Button[2];
		descendingButtons = new Button[2];
		priorityCombos = new Combo[2];

		for (int i = 0; i < 2; i++) {
			final int index = i;
			Label numberLabel = new Label(prioritiesArea, SWT.NULL);
			numberLabel.setText("" + (i + 1) + ".");
			priorityCombos[i] = new Combo(prioritiesArea, SWT.READ_ONLY);
			priorityCombos[i].setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

			Composite directionGroup = new Composite(prioritiesArea, SWT.NONE);
			directionGroup.setLayout(new GridLayout(2, false));
			ascendingButtons[i] = new Button(directionGroup, SWT.RADIO);
			ascendingButtons[i].setText("Ascending");
			ascendingButtons[i].addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					markDirty();
				}
			});
			descendingButtons[i] = new Button(directionGroup, SWT.RADIO);
			descendingButtons[i].setText("Descending");
			descendingButtons[i].addSelectionListener(new SelectionAdapter() {
				@Override
				public void widgetSelected(SelectionEvent e) {
					markDirty();
				}
			});
			if (i < priorityCombos.length - 1) {
				priorityCombos[i].addSelectionListener(new SelectionAdapter() {
					@Override
					public void widgetSelected(SelectionEvent e) {
						int oldSelectionDirection = 1;
						if (descendingButtons[index].getSelection()) {
							oldSelectionDirection = -1;
						}
						ArrayList<String> oldSelectionList = new ArrayList<String>(
								Arrays.asList(priorityCombos[index].getItems()));
						oldSelectionList.removeAll(Arrays.asList(priorityCombos[index + 1].getItems()));
						if (oldSelectionList.size() != 1) {
							return;
						}
						String oldSelection = oldSelectionList.get(0);
						String newSelection = priorityCombos[index].getItem(priorityCombos[index].getSelectionIndex());
						if (oldSelection.equals(newSelection)) {
							return;
						}
						for (int j = index + 1; j < priorityCombos.length; j++) {
							int newSelectionIndex = priorityCombos[j].indexOf(newSelection);
							//this combo's current selection is equal to newSelection
							if (priorityCombos[j].getSelectionIndex() == newSelectionIndex) {
								priorityCombos[j].remove(newSelection);
								int insertionPoint = -1
										- Arrays.binarySearch(priorityCombos[j].getItems(), oldSelection,
												columnComparator);
								if (insertionPoint >= 0 && insertionPoint <= priorityCombos[j].getItemCount()) {
									priorityCombos[j].add(oldSelection, insertionPoint);
								} else {
									priorityCombos[j].add(oldSelection);
								}
								priorityCombos[j].select(priorityCombos[j].indexOf(oldSelection));
								ascendingButtons[index].setSelection(ascendingButtons[j].getSelection());
								descendingButtons[index].setSelection(descendingButtons[j].getSelection());
								ascendingButtons[j].setSelection(oldSelectionDirection == 1);
								descendingButtons[j].setSelection(oldSelectionDirection == -1);
							}
							//this combo contains newSelection
							else if (newSelectionIndex >= 0) {
								String currentText = priorityCombos[j].getText();
								priorityCombos[j].remove(newSelection);
								int insertionPoint = -1
										- Arrays.binarySearch(priorityCombos[j].getItems(), oldSelection,
												columnComparator);
								if (insertionPoint >= 0 && insertionPoint <= priorityCombos[j].getItemCount()) {
									priorityCombos[j].add(oldSelection, insertionPoint);
									priorityCombos[j].select(priorityCombos[j].indexOf(currentText));
								} else {
									priorityCombos[j].add(oldSelection);
								}
							}
						}
						markDirty();
					}
				});
			} else {
				priorityCombos[i].addSelectionListener(new SelectionAdapter() {
					@Override
					public void widgetSelected(SelectionEvent e) {
						markDirty();
					}
				});
			}

		}
		int a[] = new int[2];
		int b[] = new int[2];
		switch (taskComparator.getSortByIndex()) {
		case PRIORITY:
			a[0] = 0;
			break;
		case SUMMARY:
			a[0] = 1;
			break;
		case DATE_CREATED:
			a[0] = 2;
			break;
		case TASK_ID:
			a[0] = 3;
			break;
		}

		switch (taskComparator.getSortByIndex2()) {
		case PRIORITY:
			a[1] = 0;
			break;
		case SUMMARY:
			a[1] = 1;
			break;
		case DATE_CREATED:
			a[1] = 2;
			break;
		case TASK_ID:
			a[1] = 3;
			break;
		}
		b[0] = taskComparator.getSortDirection();
		b[1] = taskComparator.getSortDirection2();
		updateUI(a, b);
		return composite;
	}

	@Override
	protected void okPressed() {
		if (isDirty()) {
			taskComparator.setSortByIndex(TaskComparator.SortByIndex.valueOf(priorityCombos[0].getItem(
					priorityCombos[0].getSelectionIndex()).replace(' ', '_').toUpperCase()));
			taskComparator.setSortByIndex2(TaskComparator.SortByIndex.valueOf(priorityCombos[1].getItem(
					priorityCombos[1].getSelectionIndex()).replace(' ', '_').toUpperCase()));
			if (descendingButtons[0].getSelection()) {
				taskComparator.setSortDirection(-1);
			} else {
				taskComparator.setSortDirection(1);
			}
			if (descendingButtons[1].getSelection()) {
				taskComparator.setSortDirection2(-1);
			} else {
				taskComparator.setSortDirection2(1);
			}

		}
		super.okPressed();
	}

	/**
	 * @return boolean
	 */
	public boolean isDirty() {
		return dirty;
	}

	/**
	 * Sets the dirty flag to true.
	 */
	public void markDirty() {
		dirty = true;
	}

	private final Comparator<String> columnComparator = new Comparator<String>() {
		public int compare(String arg0, String arg1) {
			int index0 = -1;
			int index1 = -1;
			for (int i = 0; i < propertyText.length; i++) {
				if (propertyText[i].equals(arg0)) {
					index0 = i;
				}
				if (propertyText[i].equals(arg1)) {
					index1 = i;
				}
			}
			return index0 - index1;
		}
	};

	protected void updateUI(int[] priorities, int[] directions) {
		ArrayList<String> availablePriorities = new ArrayList<String>(Arrays.asList(propertyText));

		for (int i = 0; i < priorityCombos.length; i++) {
			priorityCombos[i].removeAll();
			for (int j = 0; j < availablePriorities.size(); j++) {
				priorityCombos[i].add(availablePriorities.get(j));
			}
			priorityCombos[i].select(priorityCombos[i].indexOf(propertyText[priorities[i]]));
			availablePriorities.remove(propertyText[priorities[i]]);
			ascendingButtons[i].setSelection(directions[i] == 1);
			descendingButtons[i].setSelection(directions[i] == -1);
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.search;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator.SortByIndex;
import org.eclipse.mylyn.tasks.core.ITask;

public class SearchResultSorter extends ViewerSorter {

	private final RepositorySearchResultView view;

	private final TaskComparator taskComparator = new TaskComparator();

	public SearchResultSorter(RepositorySearchResultView view) {
		super();
		this.view = view;
	}

	/**
	 * Returns a negative, zero, or positive number depending on whether the first bug's taskId is less than, equal to,
	 * or greater than the second bug's taskId.
	 * <p>
	 * 
	 * @see org.eclipse.jface.viewers.ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object,
	 *      java.lang.Object)
	 */
	@Override
	public int compare(Viewer viewer, Object e1, Object e2) {
		if (e1 instanceof ITask && e2 instanceof ITask) {
			ITask entry1 = (ITask) e1;
			ITask entry2 = (ITask) e2;
			return taskComparator.compare(entry1, entry2);
		} else {
			return super.compare(viewer, e1, e2);
		}
	}

	/**
	 * Returns the category of the given element. The category is a number used to allocate elements to bins; the bins
	 * are arranged in ascending numeric order. The elements within a bin are arranged via a second level sort
	 * criterion.
	 * <p>
	 * 
	 * @see org.eclipse.jface.viewers.ViewerSorter#category(Object)
	 */
	@Override
	public int category(Object element) {
		try {
			ITask hit = (ITask) element;
			return Integer.parseInt(hit.getTaskId());
		} catch (Exception ignored) {
			// ignore if there is a problem
		}
		// if that didn't work, use the default category method
		return super.category(element);
	}

	public int getSortDirection() {
		return taskComparator.getSortDirection();
	}

	public void setSortDirection(int sortDirection) {
		taskComparator.setSortDirection(sortDirection);
	}

	public SortByIndex getSortByIndex() {
		return taskComparator.getSortByIndex();
	}

	public void setSortByIndex(SortByIndex sortByIndex) {
		taskComparator.setSortByIndex(sortByIndex);
	}

	public int getSortDirection2() {
		return taskComparator.getSortDirection2();
	}

	public void setSortDirection2(int sortDirection) {
		taskComparator.setSortDirection2(sortDirection);
	}

	public SortByIndex getSortByIndex2() {
		return taskComparator.getSortByIndex2();
	}

	public void setSortByIndex2(SortByIndex sortByIndex) {
		taskComparator.setSortByIndex2(sortByIndex);
	}

	public TaskComparator getTaskComparator() {
		return taskComparator;
	}

	public void refreshView() {
		view.getViewer().refresh();
	}
}

Return to bug 216150

Lines 24-33 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TableSorterTest.java (-4 / +4 lines)
24	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;	24	import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
25	import org.eclipse.mylyn.internal.tasks.core.WeekDateRange;	25	import org.eclipse.mylyn.internal.tasks.core.WeekDateRange;
26	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;	26	import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
		27	import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
27	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListInterestSorter;	28	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListInterestSorter;
28	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;	29	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;
29	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;	30	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
30	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter.SortByIndex;
31	import org.eclipse.mylyn.tasks.core.ITask;	31	import org.eclipse.mylyn.tasks.core.ITask;
32	import org.eclipse.mylyn.tasks.tests.connector.MockTask;	32	import org.eclipse.mylyn.tasks.tests.connector.MockTask;
33	import org.eclipse.swt.widgets.Control;	33	import org.eclipse.swt.widgets.Control;
Lines 40-46 Link Here
40		40
41	public void testRootTaskSorting() {	41	public void testRootTaskSorting() {
42	TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective(),	42	TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective(),
43	TaskListTableSorter.SortByIndex.SUMMARY);	43	TaskComparator.SortByIndex.SUMMARY);
44		44
45	ITask task = new LocalTask("1", "");	45	ITask task = new LocalTask("1", "");
46	TaskCategory category = new TaskCategory("cat");	46	TaskCategory category = new TaskCategory("cat");
Lines 114-120 Link Here
114	tasks[5] = new MockTask("local", "5", "a");	114	tasks[5] = new MockTask("local", "5", "a");
115		115
116	TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective());	116	TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective());
117	sorter.setSortByIndex(SortByIndex.SUMMARY);	117	sorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
118	sorter.sort(new EmptyViewer(), tasks);	118	sorter.sort(new EmptyViewer(), tasks);
119		119
120	assertEquals("1", tasks[0].getTaskKey());	120	assertEquals("1", tasks[0].getTaskKey());
Lines 136-142 Link Here
136	tasks[4] = new MockTask("local", "MYLN:5", "a");	136	tasks[4] = new MockTask("local", "MYLN:5", "a");
137		137
138	TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective());	138	TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective());
139	sorter.setSortByIndex(SortByIndex.SUMMARY);	139	sorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
140	sorter.sort(new EmptyViewer(), tasks);	140	sorter.sort(new EmptyViewer(), tasks);
141		141
142	assertEquals("MYLN:1", tasks[0].getTaskKey());	142	assertEquals("MYLN:1", tasks[0].getTaskKey());