Attachment #95415 for bug #216150

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

Lines 63-68 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/AllTasksTests.java (+1 lines)
63	suite.addTestSuite(OrphanedTasksTest.class);	63	suite.addTestSuite(OrphanedTasksTest.class);
64	suite.addTestSuite(TaskWorkingSetTest.class);	64	suite.addTestSuite(TaskWorkingSetTest.class);
65	suite.addTestSuite(TaskActivationHistoryTest.class);	65	suite.addTestSuite(TaskActivationHistoryTest.class);
		66	suite.addTestSuite(TaskSearchResultSorterTest.class);
66	// $JUnit-END$	67	// $JUnit-END$
67		68
68	// suite.addTestSuite(BackgroundSaveTest.class);	69	// suite.addTestSuite(BackgroundSaveTest.class);




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers 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
 *******************************************************************************/

package org.eclipse.mylyn.tasks.tests;

import junit.framework.TestCase;

import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.mylyn.internal.tasks.ui.TaskComparator;
import org.eclipse.mylyn.internal.tasks.ui.search.TaskSearchResultSorter;
import org.eclipse.mylyn.tasks.tests.connector.MockTask;
import org.eclipse.swt.widgets.Control;

public class TaskSearchResultSorterTest extends TestCase {

	public class EmptyViewer extends Viewer {
		public EmptyViewer() {
		}

		@Override
		public Control getControl() {
			return null;
		}

		@Override
		public Object getInput() {
			return null;
		}

		@Override
		public ISelection getSelection() {
			return null;
		}

		@Override
		public void refresh() {
		}

		@Override
		public void setInput(Object input) {
		}

		@Override
		public void setSelection(ISelection selection, boolean reveal) {
		}
	}

	public void test2LevelSort() throws Exception {
		final TaskSearchResultSorter sorter = new TaskSearchResultSorter();
		final MockTask[] tasks = new MockTask[5];
		tasks[0] = new MockTask("local", "4", "c");
		tasks[1] = new MockTask("local", "1", "b");
		tasks[2] = new MockTask("local", "11", "a");
		tasks[2].setPriority("P1");
		tasks[3] = new MockTask("local", "3", "c");
		tasks[4] = new MockTask("local", "5", "a");

		// sort by PRIORITY then by SUMMARY
		sorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
		sorter.setSortByIndex2(TaskComparator.SortByIndex.SUMMARY);
		sorter.sort(new EmptyViewer(), tasks);
		assertTrue("11".equals(tasks[0].getTaskKey()) && "a".equals(tasks[0].getSummary()));
		assertTrue("1".equals(tasks[1].getTaskKey()) && "b".equals(tasks[1].getSummary()));
		assertTrue("3".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
		assertTrue("4".equals(tasks[3].getTaskKey()) && "c".equals(tasks[3].getSummary()));
		assertTrue("5".equals(tasks[4].getTaskKey()) && "a".equals(tasks[4].getSummary()));

		// sort by PRIORITY then by SUMMARY descending
		sorter.setSortDirection2(-1);
		sorter.sort(new EmptyViewer(), tasks);
		assertTrue("11".equals(tasks[0].getTaskKey()) && "a".equals(tasks[0].getSummary()));
		assertTrue("1".equals(tasks[4].getTaskKey()) && "b".equals(tasks[4].getSummary()));
		assertTrue("3".equals(tasks[3].getTaskKey()) && "c".equals(tasks[3].getSummary()));
		assertTrue("4".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
		assertTrue("5".equals(tasks[1].getTaskKey()) && "a".equals(tasks[1].getSummary()));

		// sort by PRIORITY descending then by SUMMARY descending
		sorter.setSortDirection(-1);
		sorter.sort(new EmptyViewer(), tasks);
		assertTrue("11".equals(tasks[4].getTaskKey()) && "a".equals(tasks[4].getSummary()));
		assertTrue("1".equals(tasks[3].getTaskKey()) && "b".equals(tasks[3].getSummary()));
		assertTrue("3".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
		assertTrue("4".equals(tasks[1].getTaskKey()) && "c".equals(tasks[1].getSummary()));
		assertTrue("5".equals(tasks[0].getTaskKey()) && "a".equals(tasks[0].getSummary()));

		// sort by PRIORITY descending then by SUMMARY
		sorter.setSortDirection2(1);
		sorter.sort(new EmptyViewer(), tasks);
		assertTrue("11".equals(tasks[4].getTaskKey()) && "a".equals(tasks[4].getSummary()));
		assertTrue("1".equals(tasks[0].getTaskKey()) && "b".equals(tasks[0].getSummary()));
		assertTrue("3".equals(tasks[1].getTaskKey()) && "c".equals(tasks[1].getSummary()));
		assertTrue("4".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
		assertTrue("5".equals(tasks[3].getTaskKey()) && "a".equals(tasks[3].getSummary()));
	}
}




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers 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
 *******************************************************************************/

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.views.TaskKeyComparator;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;
import org.eclipse.mylyn.tasks.core.AbstractTask;

/**
 * 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 {
			AbstractTask hit = (AbstractTask) 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 23-28 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/SearchResultSortAction.java (-2 / +9 lines)
23	/** The view where the Bugzilla search results are displayed. */	23	/** The view where the Bugzilla search results are displayed. */
24	private final RepositorySearchResultView bugPage;	24	private final RepositorySearchResultView bugPage;
25		25
		26	private final boolean secondLevel;
		27
26	/**	28	/**
27	* Constructor	29	* Constructor
28	*	30	*
Lines 33-42 Link Here
33	* @param sortOrder	35	* @param sortOrder
34	* The category that this class sorts Bugzilla search results by	36	* The category that this class sorts Bugzilla search results by
35	*/	37	*/
36	public SearchResultSortAction(String label, RepositorySearchResultView page, int sortOrder) {	38	public SearchResultSortAction(String label, RepositorySearchResultView page, int sortOrder, boolean level2) {
37	super(label);	39	super(label);
38	bugPage = page;	40	bugPage = page;
39	bugSortOrder = sortOrder;	41	bugSortOrder = sortOrder;
		42	secondLevel = level2;
40	}	43	}
41		44
42	/**	45	/**
Lines 44-50 Link Here
44	*/	47	*/
45	@Override	48	@Override
46	public void run() {	49	public void run() {
47	bugPage.setSortOrder(bugSortOrder);	50	if (secondLevel) {
		51	bugPage.setSortOrder2(bugSortOrder);
		52	} else {
		53	bugPage.setSortOrder(bugSortOrder);
		54	}
48	}	55	}
49		56
50	/**	57	/**




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers 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
 *******************************************************************************/

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.AbstractTask;

/**
 * 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 {
			AbstractTask hit1 = (AbstractTask) e1;
			AbstractTask hit2 = (AbstractTask) 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 {
			AbstractTask hit = (AbstractTask) 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);
	}
}




import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.viewers.DecoratingLabelProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;

import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.mylyn.internal.tasks.core.UnmatchedTaskContainer;
import org.eclipse.mylyn.internal.tasks.ui.AddExistingTaskJob;
import org.eclipse.mylyn.internal.tasks.ui.TaskComparator;
import org.eclipse.mylyn.internal.tasks.ui.TaskListPatternFilter;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;

import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
import org.eclipse.search.internal.ui.SearchMessages;
import org.eclipse.search.ui.IContextMenuConstants;
import org.eclipse.search.ui.text.AbstractTextSearchViewPage;
import org.eclipse.search.ui.text.Match;

 * @author Rob Elves
 * @author Mik Kersten
 * @author Shawn Minto
 * @author Frank Becker (https://bugs.eclipse.org/bugs/show_bug.cgi?taskId=216150)
 */
public class RepositorySearchResultView extends AbstractTextSearchViewPage implements IAdaptable {



	public static final int ORDER_DESCRIPTION = 2;

	public static final int ORDER_DATE_CREATED = 3;

	public static final int ORDER_STATUS = 4;

	public static final int ORDER_ID = 5;

	public static final int ORDER_DEFAULT = ORDER_PRIORITY;

	public static final int ORDER2_DEFAULT = ORDER_DESCRIPTION;

	private static final String KEY_SORTING = TasksUiPlugin.ID_PLUGIN + ".search.resultpage.sorting"; //$NON-NLS-1$

	private static final String KEY_SORTING2 = TasksUiPlugin.ID_PLUGIN + ".search.resultpage.sorting.then"; //$NON-NLS-1$

	private SearchResultContentProvider searchResultProvider;

	private int currentSortOrder;

	private int currentSortOrder2;

	private final SearchResultSortAction sortByPriorityAction;

	private final SearchResultSortAction sortByDescriptionAction;

	private final SearchResultSortAction sortByDateCreated;

	private final SearchResultSortAction sortByPriorityAction2;

	private final SearchResultSortAction sortByDescriptionAction2;

	private final SearchResultSortAction sortByDateCreated2;

	private final OpenSearchResultAction openInEditorAction;

	private final CreateQueryFromSearchAction addTaskListAction;

	private final SearchResultSortDirection sortDirection;

	private final SearchResultSortDirection sortDirection2;

	private static final String[] SHOW_IN_TARGETS = new String[] { IPageLayout.ID_RES_NAV };

	private final Action groupByAction;

	private TaskSearchResultSorter taskSearchResultSorter;

	private static final IShowInTargetList SHOW_IN_TARGET_LIST = new IShowInTargetList() {
		public String[] getShowInTargetIds() {
			return SHOW_IN_TARGETS;

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

		sortByPriorityAction = new SearchResultSortAction("Priority", this, ORDER_PRIORITY, false);
		sortByPriorityAction.setImageDescriptor(TasksUiImages.PRIORITY_1);
		sortByDescriptionAction = new SearchResultSortAction("Summary", this, ORDER_DESCRIPTION, false);
		sortByDateCreated = new SearchResultSortAction("Date Created", this, ORDER_DATE_CREATED, false);
		sortByDateCreated.setImageDescriptor(TasksUiImages.CALENDAR_SMALL);
		currentSortOrder = ORDER_DEFAULT;
		sortByPriorityAction2 = new SearchResultSortAction("Priority", this, ORDER_PRIORITY, true);
		sortByPriorityAction2.setImageDescriptor(TasksUiImages.PRIORITY_1);
		sortByDescriptionAction2 = new SearchResultSortAction("Summary", this, ORDER_DESCRIPTION, true);
		sortByDateCreated2 = new SearchResultSortAction("Date Created", this, ORDER_DATE_CREATED, true);
		sortByDateCreated2.setImageDescriptor(TasksUiImages.CALENDAR_SMALL);
		currentSortOrder2 = ORDER2_DEFAULT;
		sortDirection = new SearchResultSortDirection("Descending", this, false);
		sortDirection2 = new SearchResultSortDirection("Descending", this, true);

		openInEditorAction = new OpenSearchResultAction("Open in Editor", this);
		addTaskListAction = new CreateQueryFromSearchAction("Create Query from Search...", this);


		// Set the order when the search view is loading so that the items are
		// sorted right away
		taskSearchResultSorter = new TaskSearchResultSorter();
		viewer.setSorter(taskSearchResultSorter);
		setSortOrder(currentSortOrder);
		setSortOrder2(currentSortOrder2);
	}

	@Override

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

		switch (sortOrder) {
		case ORDER_ID:
			viewer.setSorter(new SearchResultSorterId());
			break;
		case ORDER_DESCRIPTION:
			taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
			break;
		case ORDER_PRIORITY:
			taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
			break;
		case ORDER_DATE_CREATED:
			taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.DATE_CREATED);
			break;
		default:
			// If the setting is not one of the four valid ones,
			// use the default order setting.
			sortOrder = ORDER_DEFAULT;
			taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
			break;
		}
		currentSortOrder = sortOrder;
		getSettings().put(KEY_SORTING, currentSortOrder);

		getViewer().refresh();
	}

	public void setSortOrder2(int sortOrder) {
		switch (sortOrder) {
		case ORDER_DESCRIPTION:
			taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.SUMMARY);
			break;
		case ORDER_PRIORITY:
			taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.PRIORITY);
			break;
		case ORDER_DATE_CREATED:
			taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.DATE_CREATED);
			break;
		default:
			// If the setting is not one of the four valid ones,
			// use the default order setting.
			sortOrder = ORDER_DEFAULT;
			taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.PRIORITY);
			break;
		}
		currentSortOrder2 = sortOrder;
		getSettings().put(KEY_SORTING2, currentSortOrder2);
		getViewer().refresh();
	}

	public void setSortDirection(int sortDirection) {
		taskSearchResultSorter.setSortDirection(sortDirection);
		getViewer().refresh();
	}

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

	public void setSortDirection2(int sortDirection) {
		taskSearchResultSorter.setSortDirection2(sortDirection);
		getViewer().refresh();
	}

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

	@SuppressWarnings("unchecked")

	@Override
	protected void fillContextMenu(IMenuManager menuManager) {
		super.fillContextMenu(menuManager);
		MenuManager sortMenuManager = new MenuManager("First Sort by");
		sortMenuManager.add(sortByPriorityAction);
		sortMenuManager.add(sortByDescriptionAction);
		sortMenuManager.add(sortByDateCreated);
		sortMenuManager.add(new Separator());
		sortMenuManager.add(sortDirection);

		sortByPriorityAction.setChecked(currentSortOrder == sortByPriorityAction.getSortOrder());
		sortByDescriptionAction.setChecked(currentSortOrder == sortByDescriptionAction.getSortOrder());
		sortByDateCreated.setChecked(currentSortOrder == sortByDateCreated.getSortOrder());
		sortDirection.setChecked(getSortDirection() < 0);

		MenuManager sortMenuManager2 = new MenuManager("Then Sort by");
		sortMenuManager2.add(sortByPriorityAction2);
		sortMenuManager2.add(sortByDescriptionAction2);
		sortMenuManager2.add(sortByDateCreated2);
		sortMenuManager2.add(new Separator());
		sortMenuManager2.add(sortDirection2);

		sortByPriorityAction2.setChecked(currentSortOrder2 == sortByPriorityAction2.getSortOrder());
		sortByDescriptionAction2.setChecked(currentSortOrder2 == sortByDescriptionAction2.getSortOrder());
		sortByDateCreated2.setChecked(currentSortOrder2 == sortByDateCreated2.getSortOrder());
		sortDirection2.setChecked(getSortDirection2() < 0);

		// Add the new context menu items
		menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager);
		menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager2);
		menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, groupByAction);

		menuManager.appendToGroup(IContextMenuConstants.GROUP_OPEN, openInEditorAction);




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers 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
 *******************************************************************************/

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.AbstractTask;

/**
 * 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
			AbstractTask entry1 = (AbstractTask) e1;
			Integer id1 = Integer.parseInt(entry1.getTaskId());

			// cast the other object and get its bug taskId
			AbstractTask entry2 = (AbstractTask) 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 {
			AbstractTask hit = (AbstractTask) 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, 2007 Mylyn project committers 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
 *******************************************************************************/

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

import java.util.Comparator;

import org.eclipse.mylyn.internal.tasks.ui.views.TaskKeyComparator;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;

/**
 * @author Frank Becker
 */

public class TaskComparator implements Comparator<AbstractTaskContainer> {
	public enum SortByIndex {
		PRIORITY, SUMMARY, DATE_CREATED;
	}

	private static final int DEFAULT_SORT_DIRECTION = 1;

	private int sortDirection = DEFAULT_SORT_DIRECTION;

	private SortByIndex sortByIndex = SortByIndex.PRIORITY;

	private static final int DEFAULT_SORT_DIRECTION2 = 1;

	private int sortDirection2 = DEFAULT_SORT_DIRECTION2;

	private SortByIndex sortByIndex2 = SortByIndex.SUMMARY;

	private final TaskKeyComparator taskKeyComparator = new TaskKeyComparator();

	public int compare(AbstractTaskContainer element1, AbstractTaskContainer 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 {
					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(AbstractTaskContainer element1, AbstractTaskContainer element2, int sortDirection) {
		return sortDirection
				* taskKeyComparator.compare(getSortableFromElement(element1), getSortableFromElement(element2));
//		return sortDirection * (element1.getSummary().compareTo(element2.getSummary()));
	}

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

	/**
	 * Determine the sort order of two tasks by creation date
	 * 
	 * @param element1
	 * @param element2
	 * @return sort order
	 */
	private int sortByDate(AbstractTaskContainer element1, AbstractTaskContainer 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) {
			if (t1.getCreationDate() != null) {
				return sortDirection * t1.getCreationDate().compareTo(t2.getCreationDate());
			}
		}
		return 0;
	}

	/**
	 * Return a array of values to pass to taskKeyComparator.compare() for sorting
	 * 
	 * @param element
	 * @return String array[component, taskId, summary]
	 */
	public static String[] getSortableFromElement(AbstractTaskContainer element) {
		final String a[] = new String[] { "", null, element.getSummary() };

		if (element instanceof AbstractTask) {
			AbstractTask task1 = (AbstractTask) element;
			if (task1.getTaskKey() != null) {
				a[1] = task1.getTaskKey();
			}
		}
		return a;
	}

	public int getSortDirection() {
		return sortDirection;
	}

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

	public SortByIndex getSortByIndex() {
		return sortByIndex;
	}

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

	public int getSortDirection2() {
		return sortDirection2;
	}

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

	public SortByIndex getSortByIndex2() {
		return sortByIndex2;
	}

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

}




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers 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
 *******************************************************************************/

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.TaskComparator;
import org.eclipse.mylyn.internal.tasks.ui.TaskComparator.SortByIndex;
import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;

/**
 * @author Frank Becker
 */

public class TaskSearchResultSorter extends ViewerSorter {

	private final TaskComparator taskComparator = new TaskComparator();

	@Override
	public int compare(Viewer viewer, Object e1, Object e2) {
		if (e1 instanceof AbstractTaskContainer && e2 instanceof AbstractTaskContainer) {
			AbstractTaskContainer entry1 = (AbstractTaskContainer) e1;
			AbstractTaskContainer entry2 = (AbstractTaskContainer) e2;
			return taskComparator.compare(entry1, entry2);
		} else {
			return super.compare(viewer, e1, e2);
		}
	}

	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);
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers 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
 *******************************************************************************/

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

import org.eclipse.jface.action.Action;

/**
 * This class set the sorts direction of the search results.
 * 
 * @author Frank Becker
 */
public class SearchResultSortDirection extends Action {

	/** The view where the Bugzilla search results are displayed. */
	private final RepositorySearchResultView bugPage;

	private final boolean secondLevel;

	/**
	 * Constructor
	 * 
	 * @param label
	 *            The string used as the text for the action, or null if there is no text
	 * @param page
	 *            The view where the Bugzilla search results are displayed.
	 * @param sortOrder
	 *            The category that this class sorts Bugzilla search results by
	 */
	public SearchResultSortDirection(String label, RepositorySearchResultView page, boolean level2) {
		super(label);
		bugPage = page;
		secondLevel = level2;
	}

	/**
	 * Reorder the Bugzilla search results.
	 */
	@Override
	public void run() {
		if (secondLevel) {
			bugPage.setSortDirection2(bugPage.getSortDirection2() * -1);
			setChecked(bugPage.getSortDirection2() < 0);
		} else {
			bugPage.setSortDirection(bugPage.getSortDirection() * -1);
			setChecked(bugPage.getSortDirection() < 0);
		}
	}
}

Return to bug 216150

Added Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TaskSearchResultSorterTest.java (+101 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2007 Mylyn project committers and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/
8
9	package org.eclipse.mylyn.tasks.tests;
10
11	import junit.framework.TestCase;
12
13	import org.eclipse.jface.viewers.ISelection;
14	import org.eclipse.jface.viewers.Viewer;
15	import org.eclipse.mylyn.internal.tasks.ui.TaskComparator;
16	import org.eclipse.mylyn.internal.tasks.ui.search.TaskSearchResultSorter;
17	import org.eclipse.mylyn.tasks.tests.connector.MockTask;
18	import org.eclipse.swt.widgets.Control;
19
20	public class TaskSearchResultSorterTest extends TestCase {
21
22	public class EmptyViewer extends Viewer {
23	public EmptyViewer() {
24	}
25
26	@Override
27	public Control getControl() {
28	return null;
29	}
30
31	@Override
32	public Object getInput() {
33	return null;
34	}
35
36	@Override
37	public ISelection getSelection() {
38	return null;
39	}
40
41	@Override
42	public void refresh() {
43	}
44
45	@Override
46	public void setInput(Object input) {
47	}
48
49	@Override
50	public void setSelection(ISelection selection, boolean reveal) {
51	}
52	}
53
54	public void test2LevelSort() throws Exception {
55	final TaskSearchResultSorter sorter = new TaskSearchResultSorter();
56	final MockTask[] tasks = new MockTask[5];
57	tasks[0] = new MockTask("local", "4", "c");
58	tasks[1] = new MockTask("local", "1", "b");
59	tasks[2] = new MockTask("local", "11", "a");
60	tasks[2].setPriority("P1");
61	tasks[3] = new MockTask("local", "3", "c");
62	tasks[4] = new MockTask("local", "5", "a");
63
64	// sort by PRIORITY then by SUMMARY
65	sorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
66	sorter.setSortByIndex2(TaskComparator.SortByIndex.SUMMARY);
67	sorter.sort(new EmptyViewer(), tasks);
68	assertTrue("11".equals(tasks[0].getTaskKey()) && "a".equals(tasks[0].getSummary()));
69	assertTrue("1".equals(tasks[1].getTaskKey()) && "b".equals(tasks[1].getSummary()));
70	assertTrue("3".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
71	assertTrue("4".equals(tasks[3].getTaskKey()) && "c".equals(tasks[3].getSummary()));
72	assertTrue("5".equals(tasks[4].getTaskKey()) && "a".equals(tasks[4].getSummary()));
73
74	// sort by PRIORITY then by SUMMARY descending
75	sorter.setSortDirection2(-1);
76	sorter.sort(new EmptyViewer(), tasks);
77	assertTrue("11".equals(tasks[0].getTaskKey()) && "a".equals(tasks[0].getSummary()));
78	assertTrue("1".equals(tasks[4].getTaskKey()) && "b".equals(tasks[4].getSummary()));
79	assertTrue("3".equals(tasks[3].getTaskKey()) && "c".equals(tasks[3].getSummary()));
80	assertTrue("4".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
81	assertTrue("5".equals(tasks[1].getTaskKey()) && "a".equals(tasks[1].getSummary()));
82
83	// sort by PRIORITY descending then by SUMMARY descending
84	sorter.setSortDirection(-1);
85	sorter.sort(new EmptyViewer(), tasks);
86	assertTrue("11".equals(tasks[4].getTaskKey()) && "a".equals(tasks[4].getSummary()));
87	assertTrue("1".equals(tasks[3].getTaskKey()) && "b".equals(tasks[3].getSummary()));
88	assertTrue("3".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
89	assertTrue("4".equals(tasks[1].getTaskKey()) && "c".equals(tasks[1].getSummary()));
90	assertTrue("5".equals(tasks[0].getTaskKey()) && "a".equals(tasks[0].getSummary()));
91
92	// sort by PRIORITY descending then by SUMMARY
93	sorter.setSortDirection2(1);
94	sorter.sort(new EmptyViewer(), tasks);
95	assertTrue("11".equals(tasks[4].getTaskKey()) && "a".equals(tasks[4].getSummary()));
96	assertTrue("1".equals(tasks[0].getTaskKey()) && "b".equals(tasks[0].getSummary()));
97	assertTrue("3".equals(tasks[1].getTaskKey()) && "c".equals(tasks[1].getSummary()));
98	assertTrue("4".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
99	assertTrue("5".equals(tasks[3].getTaskKey()) && "a".equals(tasks[3].getSummary()));
100	}
101	}

Lines 16-21 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/RepositorySearchResultView.java (-17 / +108 lines)
16	import org.eclipse.jface.action.Action;	16	import org.eclipse.jface.action.Action;
17	import org.eclipse.jface.action.IMenuManager;	17	import org.eclipse.jface.action.IMenuManager;
18	import org.eclipse.jface.action.MenuManager;	18	import org.eclipse.jface.action.MenuManager;
		19	import org.eclipse.jface.action.Separator;
19	import org.eclipse.jface.viewers.DecoratingLabelProvider;	20	import org.eclipse.jface.viewers.DecoratingLabelProvider;
20	import org.eclipse.jface.viewers.StructuredSelection;	21	import org.eclipse.jface.viewers.StructuredSelection;
21	import org.eclipse.jface.viewers.StructuredViewer;	22	import org.eclipse.jface.viewers.StructuredViewer;
Lines 23-28 Link Here
23	import org.eclipse.jface.viewers.TreeViewer;	24	import org.eclipse.jface.viewers.TreeViewer;
24	import org.eclipse.mylyn.internal.tasks.core.UnmatchedTaskContainer;	25	import org.eclipse.mylyn.internal.tasks.core.UnmatchedTaskContainer;
25	import org.eclipse.mylyn.internal.tasks.ui.AddExistingTaskJob;	26	import org.eclipse.mylyn.internal.tasks.ui.AddExistingTaskJob;
		27	import org.eclipse.mylyn.internal.tasks.ui.TaskComparator;
26	import org.eclipse.mylyn.internal.tasks.ui.TaskListPatternFilter;	28	import org.eclipse.mylyn.internal.tasks.ui.TaskListPatternFilter;
27	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;	29	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
28	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;	30	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
Lines 31-37 Link Here
31	import org.eclipse.mylyn.tasks.core.TaskRepository;	33	import org.eclipse.mylyn.tasks.core.TaskRepository;
32	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	34	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
33	import org.eclipse.mylyn.tasks.ui.TasksUiUtil;	35	import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
34	import org.eclipse.search.internal.ui.SearchMessages;
35	import org.eclipse.search.ui.IContextMenuConstants;	36	import org.eclipse.search.ui.IContextMenuConstants;
36	import org.eclipse.search.ui.text.AbstractTextSearchViewPage;	37	import org.eclipse.search.ui.text.AbstractTextSearchViewPage;
37	import org.eclipse.search.ui.text.Match;	38	import org.eclipse.search.ui.text.Match;
Lines 54-59 Link Here
54	* @author Rob Elves	55	* @author Rob Elves
55	* @author Mik Kersten	56	* @author Mik Kersten
56	* @author Shawn Minto	57	* @author Shawn Minto
		58	* @author Frank Becker (https://bugs.eclipse.org/bugs/show_bug.cgi?taskId=216150)
57	*/	59	*/
58	public class RepositorySearchResultView extends AbstractTextSearchViewPage implements IAdaptable {	60	public class RepositorySearchResultView extends AbstractTextSearchViewPage implements IAdaptable {
59		61
Lines 63-94 Link Here
63		65
64	public static final int ORDER_DESCRIPTION = 2;	66	public static final int ORDER_DESCRIPTION = 2;
65		67
66	public static final int ORDER_SEVERITY = 3;	68	public static final int ORDER_DATE_CREATED = 3;
67
68	public static final int ORDER_STATUS = 4;
69
70	public static final int ORDER_ID = 5;
71		69
72	public static final int ORDER_DEFAULT = ORDER_PRIORITY;	70	public static final int ORDER_DEFAULT = ORDER_PRIORITY;
73		71
		72	public static final int ORDER2_DEFAULT = ORDER_DESCRIPTION;
		73
74	private static final String KEY_SORTING = TasksUiPlugin.ID_PLUGIN + ".search.resultpage.sorting"; //$NON-NLS-1$	74	private static final String KEY_SORTING = TasksUiPlugin.ID_PLUGIN + ".search.resultpage.sorting"; //$NON-NLS-1$
75		75
		76	private static final String KEY_SORTING2 = TasksUiPlugin.ID_PLUGIN + ".search.resultpage.sorting.then"; //$NON-NLS-1$
		77
76	private SearchResultContentProvider searchResultProvider;	78	private SearchResultContentProvider searchResultProvider;
77		79
78	private int currentSortOrder;	80	private int currentSortOrder;
79		81
		82	private int currentSortOrder2;
		83
80	private final SearchResultSortAction sortByPriorityAction;	84	private final SearchResultSortAction sortByPriorityAction;
81		85
82	private final SearchResultSortAction sortByDescriptionAction;	86	private final SearchResultSortAction sortByDescriptionAction;
83		87
		88	private final SearchResultSortAction sortByDateCreated;
		89
		90	private final SearchResultSortAction sortByPriorityAction2;
		91
		92	private final SearchResultSortAction sortByDescriptionAction2;
		93
		94	private final SearchResultSortAction sortByDateCreated2;
		95
84	private final OpenSearchResultAction openInEditorAction;	96	private final OpenSearchResultAction openInEditorAction;
85		97
86	private final CreateQueryFromSearchAction addTaskListAction;	98	private final CreateQueryFromSearchAction addTaskListAction;
87		99
		100	private final SearchResultSortDirection sortDirection;
		101
		102	private final SearchResultSortDirection sortDirection2;
		103
88	private static final String[] SHOW_IN_TARGETS = new String[] { IPageLayout.ID_RES_NAV };	104	private static final String[] SHOW_IN_TARGETS = new String[] { IPageLayout.ID_RES_NAV };
89		105
90	private final Action groupByAction;	106	private final Action groupByAction;
91		107
		108	private TaskSearchResultSorter taskSearchResultSorter;
		109
92	private static final IShowInTargetList SHOW_IN_TARGET_LIST = new IShowInTargetList() {	110	private static final IShowInTargetList SHOW_IN_TARGET_LIST = new IShowInTargetList() {
93	public String[] getShowInTargetIds() {	111	public String[] getShowInTargetIds() {
94	return SHOW_IN_TARGETS;	112	return SHOW_IN_TARGETS;
Lines 99-107 Link Here
99	// Only use the table layout.	117	// Only use the table layout.
100	super(FLAG_LAYOUT_TREE);	118	super(FLAG_LAYOUT_TREE);
101		119
102	sortByPriorityAction = new SearchResultSortAction("Task Priority", this, ORDER_PRIORITY);	120	sortByPriorityAction = new SearchResultSortAction("Priority", this, ORDER_PRIORITY, false);
103	sortByDescriptionAction = new SearchResultSortAction("Task Summary", this, ORDER_DESCRIPTION);	121	sortByPriorityAction.setImageDescriptor(TasksUiImages.PRIORITY_1);
		122	sortByDescriptionAction = new SearchResultSortAction("Summary", this, ORDER_DESCRIPTION, false);
		123	sortByDateCreated = new SearchResultSortAction("Date Created", this, ORDER_DATE_CREATED, false);
		124	sortByDateCreated.setImageDescriptor(TasksUiImages.CALENDAR_SMALL);
104	currentSortOrder = ORDER_DEFAULT;	125	currentSortOrder = ORDER_DEFAULT;
		126	sortByPriorityAction2 = new SearchResultSortAction("Priority", this, ORDER_PRIORITY, true);
		127	sortByPriorityAction2.setImageDescriptor(TasksUiImages.PRIORITY_1);
		128	sortByDescriptionAction2 = new SearchResultSortAction("Summary", this, ORDER_DESCRIPTION, true);
		129	sortByDateCreated2 = new SearchResultSortAction("Date Created", this, ORDER_DATE_CREATED, true);
		130	sortByDateCreated2.setImageDescriptor(TasksUiImages.CALENDAR_SMALL);
		131	currentSortOrder2 = ORDER2_DEFAULT;
		132	sortDirection = new SearchResultSortDirection("Descending", this, false);
		133	sortDirection2 = new SearchResultSortDirection("Descending", this, true);
105		134
106	openInEditorAction = new OpenSearchResultAction("Open in Editor", this);	135	openInEditorAction = new OpenSearchResultAction("Open in Editor", this);
107	addTaskListAction = new CreateQueryFromSearchAction("Create Query from Search...", this);	136	addTaskListAction = new CreateQueryFromSearchAction("Create Query from Search...", this);
Lines 159-165 Link Here
159		188
160	// Set the order when the search view is loading so that the items are	189	// Set the order when the search view is loading so that the items are
161	// sorted right away	190	// sorted right away
		191	taskSearchResultSorter = new TaskSearchResultSorter();
		192	viewer.setSorter(taskSearchResultSorter);
162	setSortOrder(currentSortOrder);	193	setSortOrder(currentSortOrder);
		194	setSortOrder2(currentSortOrder2);
163	}	195	}
164		196
165	@Override	197	@Override
Lines 230-256 Link Here
230	* The new category to sort by	262	* The new category to sort by
231	*/	263	*/
232	public void setSortOrder(int sortOrder) {	264	public void setSortOrder(int sortOrder) {
233	StructuredViewer viewer = getViewer();
234
235	switch (sortOrder) {	265	switch (sortOrder) {
236	case ORDER_ID:
237	viewer.setSorter(new SearchResultSorterId());
238	break;
239	case ORDER_DESCRIPTION:	266	case ORDER_DESCRIPTION:
240	viewer.setSorter(new SearchResultSorterDescription());	267	taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
241	break;	268	break;
242	case ORDER_PRIORITY:	269	case ORDER_PRIORITY:
243	viewer.setSorter(new SearchResultSorterPriority());	270	taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
		271	break;
		272	case ORDER_DATE_CREATED:
		273	taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.DATE_CREATED);
244	break;	274	break;
245	default:	275	default:
246	// If the setting is not one of the four valid ones,	276	// If the setting is not one of the four valid ones,
247	// use the default order setting.	277	// use the default order setting.
248	sortOrder = ORDER_DEFAULT;	278	sortOrder = ORDER_DEFAULT;
249	viewer.setSorter(new SearchResultSorterPriority());	279	taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
250	break;	280	break;
251	}	281	}
252	currentSortOrder = sortOrder;	282	currentSortOrder = sortOrder;
253	getSettings().put(KEY_SORTING, currentSortOrder);	283	getSettings().put(KEY_SORTING, currentSortOrder);
		284
		285	getViewer().refresh();
		286	}
		287
		288	public void setSortOrder2(int sortOrder) {
		289	switch (sortOrder) {
		290	case ORDER_DESCRIPTION:
		291	taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.SUMMARY);
		292	break;
		293	case ORDER_PRIORITY:
		294	taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.PRIORITY);
		295	break;
		296	case ORDER_DATE_CREATED:
		297	taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.DATE_CREATED);
		298	break;
		299	default:
		300	// If the setting is not one of the four valid ones,
		301	// use the default order setting.
		302	sortOrder = ORDER_DEFAULT;
		303	taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.PRIORITY);
		304	break;
		305	}
		306	currentSortOrder2 = sortOrder;
		307	getSettings().put(KEY_SORTING2, currentSortOrder2);
		308	getViewer().refresh();
		309	}
		310
		311	public void setSortDirection(int sortDirection) {
		312	taskSearchResultSorter.setSortDirection(sortDirection);
		313	getViewer().refresh();
		314	}
		315
		316	public int getSortDirection() {
		317	return taskSearchResultSorter.getSortDirection();
		318	}
		319
		320	public void setSortDirection2(int sortDirection) {
		321	taskSearchResultSorter.setSortDirection2(sortDirection);
		322	getViewer().refresh();
		323	}
		324
		325	public int getSortDirection2() {
		326	return taskSearchResultSorter.getSortDirection2();
254	}	327	}
255		328
256	@SuppressWarnings("unchecked")	329	@SuppressWarnings("unchecked")
Lines 276-290 Link Here
276	@Override	349	@Override
277	protected void fillContextMenu(IMenuManager menuManager) {	350	protected void fillContextMenu(IMenuManager menuManager) {
278	super.fillContextMenu(menuManager);	351	super.fillContextMenu(menuManager);
279	MenuManager sortMenuManager = new MenuManager(SearchMessages.SortDropDownAction_label);	352	MenuManager sortMenuManager = new MenuManager("First Sort by");
280	sortMenuManager.add(sortByPriorityAction);	353	sortMenuManager.add(sortByPriorityAction);
281	sortMenuManager.add(sortByDescriptionAction);	354	sortMenuManager.add(sortByDescriptionAction);
		355	sortMenuManager.add(sortByDateCreated);
		356	sortMenuManager.add(new Separator());
		357	sortMenuManager.add(sortDirection);
282		358
283	sortByPriorityAction.setChecked(currentSortOrder == sortByPriorityAction.getSortOrder());	359	sortByPriorityAction.setChecked(currentSortOrder == sortByPriorityAction.getSortOrder());
284	sortByDescriptionAction.setChecked(currentSortOrder == sortByDescriptionAction.getSortOrder());	360	sortByDescriptionAction.setChecked(currentSortOrder == sortByDescriptionAction.getSortOrder());
		361	sortByDateCreated.setChecked(currentSortOrder == sortByDateCreated.getSortOrder());
		362	sortDirection.setChecked(getSortDirection() < 0);
		363
		364	MenuManager sortMenuManager2 = new MenuManager("Then Sort by");
		365	sortMenuManager2.add(sortByPriorityAction2);
		366	sortMenuManager2.add(sortByDescriptionAction2);
		367	sortMenuManager2.add(sortByDateCreated2);
		368	sortMenuManager2.add(new Separator());
		369	sortMenuManager2.add(sortDirection2);
		370
		371	sortByPriorityAction2.setChecked(currentSortOrder2 == sortByPriorityAction2.getSortOrder());
		372	sortByDescriptionAction2.setChecked(currentSortOrder2 == sortByDescriptionAction2.getSortOrder());
		373	sortByDateCreated2.setChecked(currentSortOrder2 == sortByDateCreated2.getSortOrder());
		374	sortDirection2.setChecked(getSortDirection2() < 0);
285		375
286	// Add the new context menu items	376	// Add the new context menu items
287	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager);	377	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager);
		378	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager2);
288	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, groupByAction);	379	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, groupByAction);
289		380
290	menuManager.appendToGroup(IContextMenuConstants.GROUP_OPEN, openInEditorAction);	381	menuManager.appendToGroup(IContextMenuConstants.GROUP_OPEN, openInEditorAction);