Attachment #130300 for bug #216150

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

Lines 6-11 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/messages.properties (+3 lines)
6	RepositorySearchResultView_Create_Query_from_Search_=Create Query from Search...	6	RepositorySearchResultView_Create_Query_from_Search_=Create Query from Search...
7	RepositorySearchResultView_Filter_Completed_Tasks=Filter Completed Tasks	7	RepositorySearchResultView_Filter_Completed_Tasks=Filter Completed Tasks
8	RepositorySearchResultView_Group_By_Owner=Group By Owner	8	RepositorySearchResultView_Group_By_Owner=Group By Owner
		9	RepositorySearchResultView_Group_By_Complete=Group By Complete
9	RepositorySearchResultView_Open_in_Editor=Open in Editor	10	RepositorySearchResultView_Open_in_Editor=Open in Editor
10	RepositorySearchResultView_Open_Search_with_Browser_Label=Open Search with Browser	11	RepositorySearchResultView_Open_Search_with_Browser_Label=Open Search with Browser
11	RepositorySearchResultView_Refine_Search_=Refine Search...	12	RepositorySearchResultView_Refine_Search_=Refine Search...
Lines 25-27 Link Here
25	SearchResultTreeContentProvider_Complete=Complete	26	SearchResultTreeContentProvider_Complete=Complete
26	SearchResultTreeContentProvider_Incomplete=Incomplete	27	SearchResultTreeContentProvider_Incomplete=Incomplete
27	SearchResultTreeContentProvider__unknown_=<unknown>	28	SearchResultTreeContentProvider__unknown_=<unknown>
		29
		30	SearchResultSortAction_Sort_Label=Sort...

Lines 41-46 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/Messages.java (+4 lines)
41		41
42	public static String RepositorySearchResultView_Group_By_Owner;	42	public static String RepositorySearchResultView_Group_By_Owner;
43		43
		44	public static String RepositorySearchResultView_Group_By_Complete;
		45
44	public static String RepositorySearchResultView_Open_in_Editor;	46	public static String RepositorySearchResultView_Open_in_Editor;
45		47
46	public static String RepositorySearchResultView_Open_Search_with_Browser_Label;	48	public static String RepositorySearchResultView_Open_Search_with_Browser_Label;
Lines 72-75 Link Here
72	public static String SearchResultTreeContentProvider_Incomplete;	74	public static String SearchResultTreeContentProvider_Incomplete;
73		75
74	public static String SearchResultTreeContentProvider__unknown_;	76	public static String SearchResultTreeContentProvider__unknown_;
		77
		78	public static String SearchResultSortAction_Sort_Label;
75	}	79	}

Lines 12-17 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/SearchResultSortAction.java (-16 / +13 lines)
12	package org.eclipse.mylyn.internal.tasks.ui.search;	12	package org.eclipse.mylyn.internal.tasks.ui.search;
13		13
14	import org.eclipse.jface.action.Action;	14	import org.eclipse.jface.action.Action;
		15	import org.eclipse.jface.window.IShellProvider;
		16	import org.eclipse.jface.window.Window;
		17	import org.eclipse.mylyn.internal.tasks.ui.dialogs.TaskCompareDialog;
15		18
16	/**	19	/**
17	* This class sorts search results by a supplied category.	20	* This class sorts search results by a supplied category.
Lines 20-30 Link Here
20	*/	23	*/
21	public class SearchResultSortAction extends Action {	24	public class SearchResultSortAction extends Action {
22		25
23	/** The category that this class sorts Bugzilla search results by. */	26	private final TaskCompareDialog dialog;
24	private final int bugSortOrder;
25		27
26	/** The view where the Bugzilla search results are displayed. */	28	SearchResultSorter searchResultSorter;
27	private final RepositorySearchResultView bugPage;
28		29
29	/**	30	/**
30	* Constructor	31	* Constructor
Lines 36-45 Link Here
36	* @param sortOrder	37	* @param sortOrder
37	* The category that this class sorts Bugzilla search results by	38	* The category that this class sorts Bugzilla search results by
38	*/	39	*/
39	public SearchResultSortAction(String label, RepositorySearchResultView page, int sortOrder) {	40	public SearchResultSortAction(IShellProvider site, SearchResultSorter searchResultSorter) {
40	super(label);	41	super(Messages.SearchResultSortAction_Sort_Label);
41	bugPage = page;	42	setEnabled(true);
42	bugSortOrder = sortOrder;	43	dialog = new TaskCompareDialog(site, searchResultSorter.getTaskComparator());
		44	this.searchResultSorter = searchResultSorter;
43	}	45	}
44		46
45	/**	47	/**
Lines 47-59 Link Here
47	*/	49	*/
48	@Override	50	@Override
49	public void run() {	51	public void run() {
50	bugPage.setSortOrder(bugSortOrder);	52	if (dialog.open() == Window.OK) {
51	}	53	searchResultSorter.refreshView();
52		54	}
53	/**
54	* Returns the category that this class sorts Bugzilla search results by.
55	*/
56	public int getSortOrder() {
57	return bugSortOrder;
58	}	55	}
59	}	56	}





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

/**
 * Sorts search results.
 * 
 * @author Rob Elves
 * @author Frank Becker
 */
public class SearchResultSorter extends ViewerSorter {

	private final RepositorySearchResultView view;

	private final TaskComparator taskComparator = new TaskComparator();

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

	/**
	 * Returns a negative, zero, or positive number depending on whether the first bug's taskId is less than, equal to,
	 * or greater than the second bug's taskId.
	 * <p>
	 * 
	 * @see org.eclipse.jface.viewers.ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object,

	 */
	@Override
	public int compare(Viewer viewer, Object e1, Object e2) {
		if (e1 instanceof ITask && e2 instanceof ITask) {
			ITask entry1 = (ITask) e1;
			ITask entry2 = (ITask) e2;
			return taskComparator.compare(entry1, entry2);
		} else {
			return super.compare(viewer, e1, e2);
			return taskKeyComparator.compare(TaskComparator.getSortableFromElement(entry1),
					TaskComparator.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);
	}

	/**

			ITask hit = (ITask) element;
			return Integer.parseInt(hit.getTaskId());
		} catch (Exception ignored) {
			// ignore if there is a problem
		}
		// if that didn't work, use the default category method
		return super.category(element);
	}

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

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

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

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

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

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

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

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

	public TaskComparator getTaskComparator() {
		return taskComparator;
	}

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




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

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

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

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

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

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




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

		}
	}

	public static final int ORDER_PRIORITY = 1;

	public static final int ORDER_DESCRIPTION = 2;

	public static final int ORDER_SEVERITY = 3;

	public static final int ORDER_STATUS = 4;

	public static final int ORDER_ID = 5;

	public static final int ORDER_DEFAULT = ORDER_PRIORITY;

	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.sorting2"; //$NON-NLS-1$

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

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

	private SearchResultContentProvider searchResultProvider;

	private final OpenSearchResultAction openInEditorAction;



	private final OpenWithBrowserAction openSearchWithBrowserAction;

	private SearchResultSorter searchResultSorter;

	private SearchResultSortAction sortByDialogAction;

	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(Messages.RepositorySearchResultView_Task_Priority, this,
				ORDER_PRIORITY);
		sortByDescriptionAction = new SearchResultSortAction(Messages.RepositorySearchResultView_Task_Summary, this,
				ORDER_DESCRIPTION);
		currentSortOrder = ORDER_DEFAULT;

		openInEditorAction = new OpenSearchResultAction(Messages.RepositorySearchResultView_Open_in_Editor, this);
		createQueryAction = new CreateQueryFromSearchAction(
				Messages.RepositorySearchResultView_Create_Query_from_Search_, this);


		groupingActions = new ArrayList<GroupingAction>();
		new GroupingAction(Messages.RepositorySearchResultView_Group_By_Owner, GroupBy.OWNER);
//		new GroupingAction(Messages.RepositorySearchResultView_Group_By_Complete, GroupBy.COMPLETION);

		filterActions = new ArrayList<FilteringAction>();
		new FilteringAction(Messages.RepositorySearchResultView_Filter_Completed_Tasks, new ViewerFilter() {

		DecoratingLabelProvider labelProvider = new DecoratingLabelProvider(new SearchResultsLabelProvider(
				searchResultProvider, viewer), PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator());
		viewer.setLabelProvider(labelProvider);
		searchResultSorter = new SearchResultSorter(this);
		viewer.setSorter(searchResultSorter);
		sortByDialogAction = new SearchResultSortAction(getSite(), searchResultSorter);

		// Set the order when the search view is loading so that the items are
		// sorted right away
		restoreCurrentSortOrder2Preference();

		toolTip = new TaskListToolTip(viewer.getControl());
	}


		super.dispose();
	}

	/**
	 * Sets the new sorting category, and reorders all of the tasks.
	 * 
	 * @param sortOrder
	 *            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:
			viewer.setSorter(new SearchResultSorter());
			break;
		case ORDER_PRIORITY:
			viewer.setSorter(new SearchResultSorterPriority());
			break;
		default:
			// If the setting is not one of the four valid ones,
			// use the default order setting.
			sortOrder = ORDER_DEFAULT;
			viewer.setSorter(new SearchResultSorterPriority());
			break;
		}
		currentSortOrder = sortOrder;
		getSettings().put(KEY_SORTING, currentSortOrder);
	}

	@SuppressWarnings("unchecked")
	public Object getAdapter(Class adapter) {
		return getAdapterDelegate(adapter);

		super.fillContextMenu(menuManager);

		// open actions

		menuManager.appendToGroup(IContextMenuConstants.GROUP_OPEN, openInEditorAction);

		// Add to Task List menu

		menuManager.appendToGroup(IContextMenuConstants.GROUP_SEARCH, refineSearchAction);
		menuManager.appendToGroup(IContextMenuConstants.GROUP_SEARCH, openSearchWithBrowserAction);

		menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortByDialogAction);

		MenuManager sortMenuManager = new MenuManager(Messages.RepositorySearchResultView_Sort_by);
		sortMenuManager.add(sortByPriorityAction);
		sortMenuManager.add(sortByDescriptionAction);

		sortByPriorityAction.setChecked(currentSortOrder == sortByPriorityAction.getSortOrder());
		sortByDescriptionAction.setChecked(currentSortOrder == sortByDescriptionAction.getSortOrder());

		menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenuManager);
		for (Action action : groupingActions) {
			menuManager.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, action);
		}

		}
	}

	public void restoreCurrentSortOrder2Preference() {
		int restoredSortIndex = 0;
		int restoredSortDirection = 1;
		int restoredSortIndex2 = 2;
		int restoredSortDirection2 = 1;
		String preferenceString = getSettings().get(KEY_SORTING);

		if (preferenceString != null) {
			try {
				restoredSortIndex = Integer.parseInt(preferenceString);
			} catch (NumberFormatException e) {
				restoredSortIndex = 0;
			}
		}
		preferenceString = getSettings().get(KEY_SORTINGDIRECTION);
		if (preferenceString != null) {
			try {
				restoredSortDirection = Integer.parseInt(preferenceString);
			} catch (NumberFormatException e) {
				restoredSortDirection = 1;
			}
		}
		preferenceString = getSettings().get(KEY_SORTING2);
		if (preferenceString != null) {
			try {
				restoredSortIndex2 = Integer.parseInt(preferenceString);
			} catch (NumberFormatException e) {
				restoredSortIndex2 = 2;
			}
		}
		preferenceString = getSettings().get(KEY_SORTINGDIRECTION2);
		if (preferenceString != null) {
			try {
				restoredSortDirection2 = Integer.parseInt(preferenceString);
			} catch (NumberFormatException e) {
				restoredSortDirection2 = 1;
			}
		}

		switch (restoredSortIndex) {
		case 1:
			searchResultSorter.setSortByIndex(TaskComparator.SortByIndex.SUMMARY);
			break;
		case 2:
			searchResultSorter.setSortByIndex(TaskComparator.SortByIndex.DATE_CREATED);
			break;
		case 3:
			searchResultSorter.setSortByIndex(TaskComparator.SortByIndex.TASK_ID);
			break;
		default:
			searchResultSorter.setSortByIndex(TaskComparator.SortByIndex.PRIORITY);
		}

		searchResultSorter.setSortDirection(restoredSortDirection2);
		switch (restoredSortIndex2) {
		case 1:
			searchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.SUMMARY);
			break;
		case 2:
			searchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.DATE_CREATED);
			break;
		case 3:
			searchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.TASK_ID);
			break;
		default:
			searchResultSorter.setSortByIndex2(TaskComparator.SortByIndex.PRIORITY);
		}
		searchResultSorter.setSortDirection(restoredSortDirection);
		searchResultSorter.setSortDirection2(restoredSortDirection2);
	}

	public void setCurrentSortOrder2Preference() {
		getSettings().put(KEY_SORTINGDIRECTION, searchResultSorter.getSortDirection());
		switch (searchResultSorter.getSortByIndex()) {
		case SUMMARY:
			getSettings().put(KEY_SORTING, 1);
			break;
		case DATE_CREATED:
			getSettings().put(KEY_SORTING, 2);
			break;
		case TASK_ID:
			getSettings().put(KEY_SORTING, 3);
			break;
		default:
			getSettings().put(KEY_SORTING, 0);
		}

		getSettings().put(KEY_SORTINGDIRECTION2, searchResultSorter.getSortDirection2());
		switch (searchResultSorter.getSortByIndex2()) {
		case SUMMARY:
			getSettings().put(KEY_SORTING2, 1);
			break;
		case DATE_CREATED:
			getSettings().put(KEY_SORTING2, 2);
			break;
		case TASK_ID:
			getSettings().put(KEY_SORTING2, 3);
			break;
		default:
			getSettings().put(KEY_SORTING2, 0);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Tasktop Technologies - initial API and implementation
 *******************************************************************************/

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

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

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

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

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

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

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

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

Added Link Here

(-).refactorings/2009/3/13/refactorings.history (+4 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<session version="1.0">
3	<refactoring accessors="true" comment="Delete 2 element(s) from project 'org.eclipse.mylyn.tasks.ui' - Original project: 'org.eclipse.mylyn.tasks.ui' - Original elements: org.eclipse.mylyn.internal.tasks.ui.search.SearchResultSorterId.java org.eclipse.mylyn.internal.tasks.ui.search.SearchResultSorterPriority.java" description="Delete elements" element1="/src<org.eclipse.mylyn.internal.tasks.ui.search{SearchResultSorterId.java" element2="/src<org.eclipse.mylyn.internal.tasks.ui.search{SearchResultSorterPriority.java" elements="2" flags="589830" id="org.eclipse.jdt.ui.delete" resources="0" stamp="1238277505401" subPackages="false" version="1.0"/>
4	</session>

Added Link Here

(-).refactorings/2009/3/13/refactorings.index (+1 lines)
1	1238277505401 Delete elements

Return to bug 216150

Lines 13-35 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/SearchResultSorter.java (-22 / +61 lines)
13		13
14	import org.eclipse.jface.viewers.Viewer;	14	import org.eclipse.jface.viewers.Viewer;
15	import org.eclipse.jface.viewers.ViewerSorter;	15	import org.eclipse.jface.viewers.ViewerSorter;
16	import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
17	import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;	16	import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
18	import org.eclipse.mylyn.internal.tasks.ui.views.TaskKeyComparator;	17	import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator.SortByIndex;
19	import org.eclipse.mylyn.tasks.core.ITask;	18	import org.eclipse.mylyn.tasks.core.ITask;
20		19
21	/**	20	/**
22	* Sorts search results by summary.	21	* Sorts search results.
23	*	22	*
24	* @author Rob Elves	23	* @author Rob Elves
		24	* @author Frank Becker
25	*/	25	*/
26	public class SearchResultSorter extends ViewerSorter {	26	public class SearchResultSorter extends ViewerSorter {
27		27
28	private final TaskKeyComparator taskKeyComparator = new TaskKeyComparator();	28	private final RepositorySearchResultView view;
		29
		30	private final TaskComparator taskComparator = new TaskComparator();
		31
		32	public SearchResultSorter(RepositorySearchResultView view) {
		33	super();
		34	this.view = view;
		35	}
29		36
30	/**	37	/**
31	* Returns a negative, zero, or positive number depending on whether the first bug's summary goes before, is the	38	* Returns a negative, zero, or positive number depending on whether the first bug's taskId is less than, equal to,
32	* same as, or goes after the second element's summary.	39	* or greater than the second bug's taskId.
33	* <p>	40	* <p>
34	*	41	*
35	* @see org.eclipse.jface.viewers.ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object,	42	* @see org.eclipse.jface.viewers.ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object,
Lines 37-58 Link Here
37	*/	44	*/
38	@Override	45	@Override
39	public int compare(Viewer viewer, Object e1, Object e2) {	46	public int compare(Viewer viewer, Object e1, Object e2) {
40	try {	47	if (e1 instanceof ITask && e2 instanceof ITask) {
41		48	ITask entry1 = (ITask) e1;
42	AbstractTask entry1 = (AbstractTask) e1;	49	ITask entry2 = (ITask) e2;
43	AbstractTask entry2 = (AbstractTask) e2;	50	return taskComparator.compare(entry1, entry2);
44	// NOTE we just comparing ids here, once summary and taskId separated	51	} else {
45	// they should have their own column/sorter.	52	return super.compare(viewer, e1, e2);
46	return taskKeyComparator.compare(TaskComparator.getSortableFromElement(entry1),
47	TaskComparator.getSortableFromElement(entry2));
48	// return taskKeyComparator.compare(entry1.getDescription(),
49	// entry2.getDescription());
50	} catch (Exception ignored) {
51	// do nothing
52	}	53	}
53
54	// if that didn't work, use the default compare method
55	return super.compare(viewer, e1, e2);
56	}	54	}
57		55
58	/**	56	/**
Lines 69-77 Link Here
69	ITask hit = (ITask) element;	67	ITask hit = (ITask) element;
70	return Integer.parseInt(hit.getTaskId());	68	return Integer.parseInt(hit.getTaskId());
71	} catch (Exception ignored) {	69	} catch (Exception ignored) {
72	// ignore if	70	// ignore if there is a problem
73	}	71	}
74	// if that didn't work, use the default category method	72	// if that didn't work, use the default category method
75	return super.category(element);	73	return super.category(element);
76	}	74	}
		75
		76	public int getSortDirection() {
		77	return taskComparator.getSortDirection();
		78	}
		79
		80	public void setSortDirection(int sortDirection) {
		81	taskComparator.setSortDirection(sortDirection);
		82	}
		83
		84	public SortByIndex getSortByIndex() {
		85	return taskComparator.getSortByIndex();
		86	}
		87
		88	public void setSortByIndex(SortByIndex sortByIndex) {
		89	taskComparator.setSortByIndex(sortByIndex);
		90	}
		91
		92	public int getSortDirection2() {
		93	return taskComparator.getSortDirection2();
		94	}
		95
		96	public void setSortDirection2(int sortDirection) {
		97	taskComparator.setSortDirection2(sortDirection);
		98	}
		99
		100	public SortByIndex getSortByIndex2() {
		101	return taskComparator.getSortByIndex2();
		102	}
		103
		104	public void setSortByIndex2(SortByIndex sortByIndex) {
		105	taskComparator.setSortByIndex2(sortByIndex);
		106	}
		107
		108	public TaskComparator getTaskComparator() {
		109	return taskComparator;
		110	}
		111
		112	public void refreshView() {
		113	view.setCurrentSortOrder2Preference();
		114	view.getViewer().refresh();
		115	}
77	}	116	}

Removed Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/search/SearchResultSorterPriority.java (-65 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2008 Tasktop Technologies 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	* Contributors:
9	* Tasktop Technologies - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylyn.internal.tasks.ui.search;
13
14	import org.eclipse.jface.viewers.Viewer;
15	import org.eclipse.jface.viewers.ViewerSorter;
16	import org.eclipse.mylyn.tasks.core.ITask;
17
18	/**
19	* Sorts results of Bugzilla search by bug priority.
20	*
21	* @author Rob Elves (modifications)
22	*/
23	public class SearchResultSorterPriority extends ViewerSorter {
24
25	/**
26	* Returns a negative, zero, or positive number depending on whether the first bug's priority goes before, is the
27	* same as, or goes after the second element's priority.
28	* <p>
29	*
30	* @see org.eclipse.jface.viewers.ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object,
31	* java.lang.Object)
32	*/
33	@Override
34	public int compare(Viewer viewer, Object e1, Object e2) {
35	try {
36	ITask hit1 = (ITask) e1;
37	ITask hit2 = (ITask) e2;
38	return hit1.getPriority().compareTo(hit2.getPriority());
39	} catch (Exception ignored) {
40	// do nothing
41	}
42	// if that didn't work, use the default compare method
43	return super.compare(viewer, e1, e2);
44	}
45
46	/**
47	* Returns the category of the given element. The category is a number used to allocate elements to bins; the bins
48	* are arranged in ascending numeric order. The elements within a bin are arranged via a second level sort
49	* criterion.
50	* <p>
51	*
52	* @see org.eclipse.jface.viewers.ViewerSorter#category(Object)
53	*/
54	@Override
55	public int category(Object element) {
56	try {
57	ITask hit = (ITask) element;
58	return Integer.parseInt(hit.getTaskId());
59	} catch (Exception ignored) {
60	// ignore if there is a problem
61	}
62	// if that didn't work, use the default category method
63	return super.category(element);
64	}
65	}