Attachment #90583 for bug #216150

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




/*******************************************************************************
 * 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 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 RepositorySearchResultView bugPage;	24	private RepositorySearchResultView bugPage;
25		25
		26	private 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.TasksUiImages;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.tasks.core.AbstractTask;

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 Frank Becker (https://bugs.eclipse.org/bugs/show_bug.cgi?taskId=216150)
 */
public class RepositorySearchResultView extends AbstractTextSearchViewPage implements IAdaptable {


	public static final int ORDER_PRIORITY = 1;

	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 SearchResultSortAction sortByPriorityAction;

	private SearchResultSortAction sortByDescriptionAction;

	private SearchResultSortAction sortByDateCreated;

	private SearchResultSortAction sortByPriorityAction2;

	private SearchResultSortAction sortByDescriptionAction2;

	private SearchResultSortAction sortByDateCreated2;

	private OpenSearchResultAction openInEditorAction;

	private CreateQueryFromSearchAction addTaskListAction;
	
	private SearchResultSortDirection sortDirection;
	
	private SearchResultSortDirection sortDirection2;

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

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

		groupByAction = new Action(){
			
			@Override


		// 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.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.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")
	public Object getAdapter(Class adapter) {
		return getAdapterDelegate(adapter);

	@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 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 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 RepositorySearchResultView bugPage;

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

Lines 63-68 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/AllTasksTests.java (+1 lines)
63	suite.addTestSuite(AbstractTaskDataHandlerTest.class);	63	suite.addTestSuite(AbstractTaskDataHandlerTest.class);
64	suite.addTestSuite(OrphanedTasksTest.class);	64	suite.addTestSuite(OrphanedTasksTest.class);
65	suite.addTestSuite(TaskWorkingSetTest.class);	65	suite.addTestSuite(TaskWorkingSetTest.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.MockRepositoryTask;
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 MockRepositoryTask[] tasks = new MockRepositoryTask[5];
		tasks[0] = new MockRepositoryTask("local", "4", "c");
		tasks[1] = new MockRepositoryTask("local", "1", "b");
		tasks[2] = new MockRepositoryTask("local", "11", "a");
		tasks[2].setPriority("P1");
		tasks[3] = new MockRepositoryTask("local", "3", "c");
		tasks[4] = new MockRepositoryTask("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()));
	}
}

Return to bug 216150

Removed Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/SearchResultSorterDescription.java (-73 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.internal.tasks.ui.search;
10
11	import org.eclipse.jface.viewers.Viewer;
12	import org.eclipse.jface.viewers.ViewerSorter;
13	import org.eclipse.mylyn.internal.tasks.ui.views.TaskKeyComparator;
14	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter;
15	import org.eclipse.mylyn.tasks.core.AbstractTask;
16
17	/**
18	* Sorts search results by summary.
19	*
20	* @author Rob Elves
21	*/
22	public class SearchResultSorterDescription extends ViewerSorter {
23
24	private TaskKeyComparator taskKeyComparator = new TaskKeyComparator();
25
26	/**
27	* Returns a negative, zero, or positive number depending on whether the first bug's summary goes before, is the
28	* same as, or goes after the second element's summary.
29	* <p>
30	*
31	* @see org.eclipse.jface.viewers.ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object,
32	* java.lang.Object)
33	*/
34	@Override
35	public int compare(Viewer viewer, Object e1, Object e2) {
36	try {
37
38	AbstractTask entry1 = (AbstractTask) e1;
39	AbstractTask entry2 = (AbstractTask) e2;
40	// NOTE we just comparing ids here, once summary and taskId separated
41	// they should have their own column/sorter.
42	return taskKeyComparator.compare(TaskListTableSorter.getSortableFromElement(entry1),
43	TaskListTableSorter.getSortableFromElement(entry2));
44	// return taskKeyComparator.compare(entry1.getDescription(),
45	// entry2.getDescription());
46	} catch (Exception ignored) {
47	// do nothing
48	}
49
50	// if that didn't work, use the default compare method
51	return super.compare(viewer, e1, e2);
52	}
53
54	/**
55	* Returns the category of the given element. The category is a number used to allocate elements to bins; the bins
56	* are arranged in ascending numeric order. The elements within a bin are arranged via a second level sort
57	* criterion.
58	* <p>
59	*
60	* @see org.eclipse.jface.viewers.ViewerSorter#category(Object)
61	*/
62	@Override
63	public int category(Object element) {
64	try {
65	AbstractTask hit = (AbstractTask) element;
66	return Integer.parseInt(hit.getTaskId());
67	} catch (Exception ignored) {
68	// ignore if
69	}
70	// if that didn't work, use the default category method
71	return super.category(element);
72	}
73	}

Lines 16-21 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/RepositorySearchResultView.java (-20 / +110 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.TasksUiImages;	28	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
27	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;	29	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
28	import org.eclipse.mylyn.tasks.core.AbstractTask;	30	import org.eclipse.mylyn.tasks.core.AbstractTask;
Lines 30-36 Link Here
30	import org.eclipse.mylyn.tasks.core.TaskRepository;	32	import org.eclipse.mylyn.tasks.core.TaskRepository;
31	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	33	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
32	import org.eclipse.mylyn.tasks.ui.TasksUiUtil;	34	import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
33	import org.eclipse.search.internal.ui.SearchMessages;
34	import org.eclipse.search.ui.IContextMenuConstants;	35	import org.eclipse.search.ui.IContextMenuConstants;
35	import org.eclipse.search.ui.text.AbstractTextSearchViewPage;	36	import org.eclipse.search.ui.text.AbstractTextSearchViewPage;
36	import org.eclipse.search.ui.text.Match;	37	import org.eclipse.search.ui.text.Match;
Lines 47-52 Link Here
47	*	48	*
48	* @author Rob Elves	49	* @author Rob Elves
49	* @author Mik Kersten	50	* @author Mik Kersten
		51	* @author Frank Becker (https://bugs.eclipse.org/bugs/show_bug.cgi?taskId=216150)
50	*/	52	*/
51	public class RepositorySearchResultView extends AbstractTextSearchViewPage implements IAdaptable {	53	public class RepositorySearchResultView extends AbstractTextSearchViewPage implements IAdaptable {
52		54
Lines 55-87 Link Here
55	public static final int ORDER_PRIORITY = 1;	57	public static final int ORDER_PRIORITY = 1;
56		58
57	public static final int ORDER_DESCRIPTION = 2;	59	public static final int ORDER_DESCRIPTION = 2;
58		60
59	public static final int ORDER_SEVERITY = 3;	61	public static final int ORDER_DATE_CREATED = 3;
60
61	public static final int ORDER_STATUS = 4;
62
63	public static final int ORDER_ID = 5;
64		62
65	public static final int ORDER_DEFAULT = ORDER_PRIORITY;	63	public static final int ORDER_DEFAULT = ORDER_PRIORITY;
66		64
		65	public static final int ORDER2_DEFAULT = ORDER_DESCRIPTION;
		66
67	private static final String KEY_SORTING = TasksUiPlugin.ID_PLUGIN + ".search.resultpage.sorting"; //$NON-NLS-1$	67	private static final String KEY_SORTING = TasksUiPlugin.ID_PLUGIN + ".search.resultpage.sorting"; //$NON-NLS-1$
68		68
		69	private static final String KEY_SORTING2 = TasksUiPlugin.ID_PLUGIN + ".search.resultpage.sorting.then"; //$NON-NLS-1$
		70
69	private SearchResultContentProvider searchResultProvider;	71	private SearchResultContentProvider searchResultProvider;
70		72
71	private int currentSortOrder;	73	private int currentSortOrder;
72		74
		75	private int currentSortOrder2;
		76
73	private SearchResultSortAction sortByPriorityAction;	77	private SearchResultSortAction sortByPriorityAction;
74		78
75	private SearchResultSortAction sortByDescriptionAction;	79	private SearchResultSortAction sortByDescriptionAction;
76		80
		81	private SearchResultSortAction sortByDateCreated;
		82
		83	private SearchResultSortAction sortByPriorityAction2;
		84
		85	private SearchResultSortAction sortByDescriptionAction2;
		86
		87	private SearchResultSortAction sortByDateCreated2;
		88
77	private OpenSearchResultAction openInEditorAction;	89	private OpenSearchResultAction openInEditorAction;
78		90
79	private CreateQueryFromSearchAction addTaskListAction;	91	private CreateQueryFromSearchAction addTaskListAction;
		92
		93	private SearchResultSortDirection sortDirection;
		94
		95	private SearchResultSortDirection sortDirection2;
80		96
81	private static final String[] SHOW_IN_TARGETS = new String[] { IPageLayout.ID_RES_NAV };	97	private static final String[] SHOW_IN_TARGETS = new String[] { IPageLayout.ID_RES_NAV };
82		98
83	private Action groupByAction;	99	private Action groupByAction;
84		100
		101	private TaskSearchResultSorter taskSearchResultSorter;
		102
85	private static final IShowInTargetList SHOW_IN_TARGET_LIST = new IShowInTargetList() {	103	private static final IShowInTargetList SHOW_IN_TARGET_LIST = new IShowInTargetList() {
86	public String[] getShowInTargetIds() {	104	public String[] getShowInTargetIds() {
87	return SHOW_IN_TARGETS;	105	return SHOW_IN_TARGETS;
Lines 92-104 Link Here
92	// Only use the table layout.	110	// Only use the table layout.
93	super(FLAG_LAYOUT_TREE);	111	super(FLAG_LAYOUT_TREE);
94		112
95	sortByPriorityAction = new SearchResultSortAction("Task Priority", this, ORDER_PRIORITY);	113	sortByPriorityAction = new SearchResultSortAction("Priority", this, ORDER_PRIORITY, false);
96	sortByDescriptionAction = new SearchResultSortAction("Task Summary", this, ORDER_DESCRIPTION);	114	sortByPriorityAction.setImageDescriptor(TasksUiImages.PRIORITY_1);
		115	sortByDescriptionAction = new SearchResultSortAction("Summary", this, ORDER_DESCRIPTION, false);
		116	sortByDateCreated = new SearchResultSortAction("Date Created", this, ORDER_DATE_CREATED, false);
		117	sortByDateCreated.setImageDescriptor(TasksUiImages.CALENDAR_SMALL);
97	currentSortOrder = ORDER_DEFAULT;	118	currentSortOrder = ORDER_DEFAULT;
		119	sortByPriorityAction2 = new SearchResultSortAction("Priority", this, ORDER_PRIORITY, true);
		120	sortByPriorityAction2.setImageDescriptor(TasksUiImages.PRIORITY_1);
		121	sortByDescriptionAction2 = new SearchResultSortAction("Summary", this, ORDER_DESCRIPTION, true);
		122	sortByDateCreated2 = new SearchResultSortAction("Date Created", this, ORDER_DATE_CREATED, true);
		123	sortByDateCreated2.setImageDescriptor(TasksUiImages.CALENDAR_SMALL);
		124	currentSortOrder2 = ORDER2_DEFAULT;
		125	sortDirection = new SearchResultSortDirection("Descending", this, false);
		126	sortDirection2 = new SearchResultSortDirection("Descending", this, true);
98		127
99	openInEditorAction = new OpenSearchResultAction("Open in Editor", this);	128	openInEditorAction = new OpenSearchResultAction("Open in Editor", this);
100	addTaskListAction = new CreateQueryFromSearchAction("Create Query from Search...", this);	129	addTaskListAction = new CreateQueryFromSearchAction("Create Query from Search...", this);
101		130
102	groupByAction = new Action(){	131	groupByAction = new Action(){
103		132
104	@Override	133	@Override
Lines 152-158 Link Here
152		181
153	// Set the order when the search view is loading so that the items are	182	// Set the order when the search view is loading so that the items are
154	// sorted right away	183	// sorted right away
		184	taskSearchResultSorter = new TaskSearchResultSorter();
		185	viewer.setSorter(taskSearchResultSorter);
155	setSortOrder(currentSortOrder);	186	setSortOrder(currentSortOrder);
		187	setSortOrder2(currentSortOrder2);
156	}	188	}
157		189
158	@Override	190	@Override
Lines 205-233 Link Here
205	* The new category to sort by	237	* The new category to sort by
206	*/	238	*/
207	public void setSortOrder(int sortOrder) {	239	public void setSortOrder(int sortOrder) {
208	StructuredViewer viewer = getViewer();
209
210	switch (sortOrder) {	240	switch (sortOrder) {
211	case ORDER_ID:
212	viewer.setSorter(new SearchResultSorterId());
213	break;
214	case ORDER_DESCRIPTION:	241	case ORDER_DESCRIPTION:
215	viewer.setSorter(new SearchResultSorterDescription());	242	taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
216	break;	243	break;
217	case ORDER_PRIORITY:	244	case ORDER_PRIORITY:
218	viewer.setSorter(new SearchResultSorterPriority());	245	taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
		246	break;
		247	case ORDER_DATE_CREATED:
		248	taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.DATE_CREATED);
219	break;	249	break;
220	default:	250	default:
221	// If the setting is not one of the four valid ones,	251	// If the setting is not one of the four valid ones,
222	// use the default order setting.	252	// use the default order setting.
223	sortOrder = ORDER_DEFAULT;	253	sortOrder = ORDER_DEFAULT;
224	viewer.setSorter(new SearchResultSorterPriority());	254	taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
225	break;	255	break;
226	}	256	}
227	currentSortOrder = sortOrder;	257	currentSortOrder = sortOrder;
228	getSettings().put(KEY_SORTING, currentSortOrder);	258	getSettings().put(KEY_SORTING, currentSortOrder);
		259	getViewer().refresh();
		260	}
		261
		262	public void setSortOrder2(int sortOrder) {
		263	switch (sortOrder) {
		264	case ORDER_DESCRIPTION:
		265	taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.SUMMARY);
		266	break;
		267	case ORDER_PRIORITY:
		268	taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.PRIORITY);
		269	break;
		270	case ORDER_DATE_CREATED:
		271	taskSearchResultSorter.setSortByIndex(TaskComparator.SortByIndex.DATE_CREATED);
		272	break;
		273	default:
		274	// If the setting is not one of the four valid ones,
		275	// use the default order setting.
		276	sortOrder = ORDER_DEFAULT;
		277	taskSearchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.PRIORITY);
		278	break;
		279	}
		280	currentSortOrder2 = sortOrder;
		281	getSettings().put(KEY_SORTING2, currentSortOrder2);
		282	getViewer().refresh();
		283	}
		284
		285	public void setSortDirection(int sortDirection) {
		286	taskSearchResultSorter.setSortDirection(sortDirection);
		287	getViewer().refresh();
		288	}
		289
		290	public int getSortDirection() {
		291	return taskSearchResultSorter.getSortDirection();
		292	}
		293
		294	public void setSortDirection2(int sortDirection) {
		295	taskSearchResultSorter.setSortDirection2(sortDirection);
		296	getViewer().refresh();
229	}	297	}
230		298
		299	public int getSortDirection2() {
		300	return taskSearchResultSorter.getSortDirection2();
		301	}
		302
231	@SuppressWarnings("unchecked")	303	@SuppressWarnings("unchecked")
232	public Object getAdapter(Class adapter) {	304	public Object getAdapter(Class adapter) {
233	return getAdapterDelegate(adapter);	305	return getAdapterDelegate(adapter);
Lines 252-266 Link Here
252	@Override	324	@Override
253	protected void fillContextMenu(IMenuManager menuManager) {	325	protected void fillContextMenu(IMenuManager menuManager) {
254	super.fillContextMenu(menuManager);	326	super.fillContextMenu(menuManager);
255	MenuManager sortMenuManager = new MenuManager(SearchMessages.SortDropDownAction_label);	327	MenuManager sortMenuManager = new MenuManager("First Sort by");
256	sortMenuManager.add(sortByPriorityAction);	328	sortMenuManager.add(sortByPriorityAction);
257	sortMenuManager.add(sortByDescriptionAction);	329	sortMenuManager.add(sortByDescriptionAction);
		330	sortMenuManager.add(sortByDateCreated);
		331	sortMenuManager.add(new Separator());
		332	sortMenuManager.add(sortDirection);
258		333
259	sortByPriorityAction.setChecked(currentSortOrder == sortByPriorityAction.getSortOrder());	334	sortByPriorityAction.setChecked(currentSortOrder == sortByPriorityAction.getSortOrder());
260	sortByDescriptionAction.setChecked(currentSortOrder == sortByDescriptionAction.getSortOrder());	335	sortByDescriptionAction.setChecked(currentSortOrder == sortByDescriptionAction.getSortOrder());
		336	sortByDateCreated.setChecked(currentSortOrder == sortByDateCreated.getSortOrder());
		337	sortDirection.setChecked(getSortDirection() < 0);
		338
		339	MenuManager sortMenuManager2 = new MenuManager("Then Sort by");
		340	sortMenuManager2.add(sortByPriorityAction2);
		341	sortMenuManager2.add(sortByDescriptionAction2);
		342	sortMenuManager2.add(sortByDateCreated2);
		343	sortMenuManager2.add(new Separator());
		344	sortMenuManager2.add(sortDirection2);
		345
		346	sortByPriorityAction2.setChecked(currentSortOrder2 == sortByPriorityAction2.getSortOrder());
		347	sortByDescriptionAction2.setChecked(currentSortOrder2 == sortByDescriptionAction2.getSortOrder());
		348	sortByDateCreated2.setChecked(currentSortOrder2 == sortByDateCreated2.getSortOrder());
		349	sortDirection2.setChecked(getSortDirection2() < 0);
261		350
262	// Add the new context menu items	351	// Add the new context menu items
263	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager);	352	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager);
		353	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager2);
264	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, groupByAction);	354	menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, groupByAction);
265		355
266	menuManager.appendToGroup(IContextMenuConstants.GROUP_OPEN, openInEditorAction);	356	menuManager.appendToGroup(IContextMenuConstants.GROUP_OPEN, openInEditorAction);
Lines 309-312 Link Here
309	}	399	}
310	}	400	}
311		401
312	}	402	}

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.MockRepositoryTask;
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 MockRepositoryTask[] tasks = new MockRepositoryTask[5];
57	tasks[0] = new MockRepositoryTask("local", "4", "c");
58	tasks[1] = new MockRepositoryTask("local", "1", "b");
59	tasks[2] = new MockRepositoryTask("local", "11", "a");
60	tasks[2].setPriority("P1");
61	tasks[3] = new MockRepositoryTask("local", "3", "c");
62	tasks[4] = new MockRepositoryTask("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	}