Attachment #94976 for bug #219540




		sorter.sort(new EmptyViewer(), tasks);
	}

	public void test2LevelSort() {
		final TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective());
		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(TaskListTableSorter.SortByIndex.PRIORITY);
		sorter.setSortByIndex2(TaskListTableSorter.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()));
	}

}

Lines 35-40 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/TaskListTableSorter.java (-18 / +100 lines)
35		35
36	private SortByIndex sortByIndex = SortByIndex.PRIORITY;	36	private SortByIndex sortByIndex = SortByIndex.PRIORITY;
37		37
		38	private int sortDirection2 = DEFAULT_SORT_DIRECTION;
		39
		40	private SortByIndex sortByIndex2 = SortByIndex.DATE_CREATED;
		41
38	private final TaskListView view;	42	private final TaskListView view;
39		43
40	private final TaskKeyComparator taskKeyComparator = new TaskKeyComparator();	44	private final TaskKeyComparator taskKeyComparator = new TaskKeyComparator();
Lines 127-156 Link Here
127		131
128	private int compareElements(AbstractTaskContainer element1, AbstractTaskContainer element2) {	132	private int compareElements(AbstractTaskContainer element1, AbstractTaskContainer element2) {
129	if (SortByIndex.PRIORITY.equals(sortByIndex)) {	133	if (SortByIndex.PRIORITY.equals(sortByIndex)) {
130	int result = this.sortDirection * element1.getPriority().compareTo(element2.getPriority());	134	int result = sortByPriority(element1, element2, sortDirection);
131	if (result != 0) {	135	if (result != 0) {
132	return result;	136	return result;
133	}	137	}
134	return sortBySummary(element1, element2);	138	if (SortByIndex.DATE_CREATED.equals(sortByIndex2)) {
135		139	return sortByDate(element1, element2, sortDirection2);
		140	} else {
		141	if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
		142	return sortBySummary(element1, element2, sortDirection2);
		143	} else {
		144	return result;
		145	}
		146	}
136	} else if (SortByIndex.DATE_CREATED.equals(sortByIndex)) {	147	} else if (SortByIndex.DATE_CREATED.equals(sortByIndex)) {
137	AbstractTask t1 = null;	148	int result = sortByDate(element1, element2, sortDirection);
138	AbstractTask t2 = null;	149	if (result != 0) {
139	if (element1 instanceof AbstractTask) {	150	return result;
140	t1 = (AbstractTask) element1;	151	}
141	}	152	if (SortByIndex.PRIORITY.equals(sortByIndex2)) {
142	if (element2 instanceof AbstractTask) {	153	return sortByPriority(element1, element2, sortDirection2);
143	t2 = (AbstractTask) element2;	154	} else {
144	}	155	if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
145	if (t1 != null && t2 != null) {	156	return sortBySummary(element1, element2, sortDirection2);
146	if (t1.getCreationDate() != null) {	157	} else {
147	return t1.getCreationDate().compareTo(t2.getCreationDate());	158	return result;
148	}	159	}
149	}	160	}
150	} else {	161	} else {
151	return sortBySummary(element1, element2);	162	int result = sortBySummary(element1, element2, sortDirection);
		163	if (result != 0) {
		164	return result;
		165	}
		166	if (SortByIndex.DATE_CREATED.equals(sortByIndex2)) {
		167	return sortByDate(element1, element2, sortDirection2);
		168	} else {
		169	if (SortByIndex.PRIORITY.equals(sortByIndex2)) {
		170	return sortByPriority(element1, element2, sortDirection2);
		171	} else {
		172	return result;
		173	}
		174	}
152	}	175	}
153	return 0;
154	}	176	}
155		177
156	/**	178	/**
Lines 160-171 Link Here
160	* @param element2	182	* @param element2
161	* @return sort order	183	* @return sort order
162	*/	184	*/
163	private int sortBySummary(AbstractTaskContainer element1, AbstractTaskContainer element2) {	185	private int sortBySummary(AbstractTaskContainer element1, AbstractTaskContainer element2, int sortDirection) {
164	return this.sortDirection	186	return sortDirection
165	* taskKeyComparator.compare(getSortableFromElement(element1), getSortableFromElement(element2));	187	* taskKeyComparator.compare(getSortableFromElement(element1), getSortableFromElement(element2));
166	}	188	}
167		189
168	/**	190	/**
		191	* Determine the sort order of two tasks by priority
		192	*
		193	* @param element1
		194	* @param element2
		195	* @return sort order
		196	*/
		197	private int sortByPriority(AbstractTaskContainer element1, AbstractTaskContainer element2, int sortDirection) {
		198	return sortDirection * element1.getPriority().compareTo(element2.getPriority());
		199	}
		200
		201	/**
		202	* Determine the sort order of two tasks by creation date
		203	*
		204	* @param element1
		205	* @param element2
		206	* @return sort order
		207	*/
		208	private int sortByDate(AbstractTaskContainer element1, AbstractTaskContainer element2, int sortDirection) {
		209	AbstractTask t1 = null;
		210	AbstractTask t2 = null;
		211	if (element1 instanceof AbstractTask) {
		212	t1 = (AbstractTask) element1;
		213	}
		214	if (element2 instanceof AbstractTask) {
		215	t2 = (AbstractTask) element2;
		216	}
		217	if (t1 != null && t2 != null) {
		218	if (t1.getCreationDate() != null) {
		219	return sortDirection * t1.getCreationDate().compareTo(t2.getCreationDate());
		220	}
		221	}
		222	return 0;
		223	}
		224
		225	/**
169	* Return a sortable string in the format "key: summary"	226	* Return a sortable string in the format "key: summary"
170	*	227	*
171	* @param element	228	* @param element
Lines 228-231 Link Here
228	}	285	}
229	}	286	}
230		287
		288	public SortByIndex getSortByIndex2() {
		289	return sortByIndex2;
		290	}
		291
		292	public void setSortByIndex2(SortByIndex sortByIndex) {
		293	SortByIndex oldValue = this.sortByIndex2;
		294	this.sortByIndex2 = sortByIndex;
		295	if (!oldValue.equals(sortByIndex)) {
		296	view.getViewer().refresh();
		297	}
		298
		299	}
		300
		301	public int getSortDirection2() {
		302	return sortDirection2;
		303	}
		304
		305	public void setSortDirection2(int sortDirection) {
		306	int oldValue = this.sortDirection2;
		307	this.sortDirection2 = sortDirection;
		308	if (oldValue != this.sortDirection2) {
		309	view.getViewer().refresh();
		310	}
		311	}
		312
231	}	313	}




/*******************************************************************************
 * 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.views;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IMenuCreator;
import org.eclipse.jface.action.Separator;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter.SortByIndex;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;

/**
 * @author Mik Kersten
 */
class SortyByDropDownAction extends Action implements IMenuCreator {

	private final TaskListView taskListView;

	private static final String LABEL = "Sort by";

	private Action byPriority;

	private Action bySummary;

	private Action byDateCreated;

	private Menu dropDownMenu = null;

	public SortyByDropDownAction(TaskListView taskListView) {
		super();
		this.taskListView = taskListView;
		setText(LABEL);
		setToolTipText(LABEL);
		setMenuCreator(this);
	}

	public void dispose() {
		if (dropDownMenu != null) {
			dropDownMenu.dispose();
			dropDownMenu = null;
		}
	}

	public Menu getMenu(Control parent) {
		if (dropDownMenu != null) {
			dropDownMenu.dispose();
		}
		dropDownMenu = new Menu(parent);
		addActionsToMenu();
		return dropDownMenu;
	}

	public Menu getMenu(Menu parent) {
		if (dropDownMenu != null) {
			dropDownMenu.dispose();
		}
		dropDownMenu = new Menu(parent);
		addActionsToMenu();
		return dropDownMenu;
	}

	public void addActionsToMenu() {
		byPriority = new Action("", AS_CHECK_BOX) {
			@Override
			public void run() {
				taskListView.getSorter().setSortByIndex(SortByIndex.PRIORITY);
				byPriority.setChecked(true);
				bySummary.setChecked(false);
				byDateCreated.setChecked(false);
			}
		};
		byPriority.setEnabled(true);
		byPriority.setText("Priority");
		byPriority.setImageDescriptor(TasksUiImages.PRIORITY_1);
		new ActionContributionItem(byPriority).fill(dropDownMenu, -1);

		bySummary = new Action("", AS_CHECK_BOX) {
			@Override
			public void run() {
				taskListView.getSorter().setSortByIndex(SortByIndex.SUMMARY);
				byPriority.setChecked(false);
				bySummary.setChecked(true);
				byDateCreated.setChecked(false);
			}
		};
		bySummary.setEnabled(true);
		bySummary.setText("Summary");
		new ActionContributionItem(bySummary).fill(dropDownMenu, -1);

		byDateCreated = new Action("", AS_CHECK_BOX) {
			@Override
			public void run() {
				taskListView.getSorter().setSortByIndex(SortByIndex.DATE_CREATED);
				byPriority.setChecked(false);
				bySummary.setChecked(false);
				byDateCreated.setChecked(true);
			}
		};
		byDateCreated.setEnabled(true);
		byDateCreated.setText("Date Created");
		byDateCreated.setImageDescriptor(TasksUiImages.CALENDAR_SMALL);
		new ActionContributionItem(byDateCreated).fill(dropDownMenu, -1);

		new Separator().fill(dropDownMenu, -1);

		Action reverse = new Action("", AS_CHECK_BOX) {
			@Override
			public void run() {
				taskListView.getSorter().setSortDirection(taskListView.getSorter().getSortDirection() * -1);
				setChecked(taskListView.getSorter().getSortDirection() < 0);
			}
		};
		reverse.setEnabled(true);
		reverse.setText("Descending");
		reverse.setChecked(taskListView.getSorter().getSortDirection() < 0);
		new ActionContributionItem(reverse).fill(dropDownMenu, -1);

		switch (taskListView.getSorter().getSortByIndex()) {
		case PRIORITY:
			byPriority.setChecked(true);
			break;
		case SUMMARY:
			bySummary.setChecked(true);
			break;
		case DATE_CREATED:
			byDateCreated.setChecked(true);
			break;
		}
	}

	@Override
	public void run() {
		this.setChecked(isChecked());
	}
}




import org.eclipse.mylyn.internal.tasks.ui.actions.TaskActivateAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.TaskDeactivateAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.TaskListElementPropertiesAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.TaskListSortAction;
import org.eclipse.mylyn.internal.tasks.ui.util.TaskDragSourceListener;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter.SortByIndex;
import org.eclipse.mylyn.internal.tasks.ui.wizards.NewLocalTaskWizard;


	private PriorityDropDownAction filterOnPriorityAction;

	private TaskListSortAction sortDialogAction;

	private PresentationDropDownSelectionAction presentationDropDownSelectionAction;


		manager.add(collapseAll);
		manager.add(expandAll);
		manager.add(new Separator(ID_SEPARATOR_FILTERS));
		manager.add(sortDialogAction);
		manager.add(filterOnPriorityAction);
		manager.add(filterCompleteTask);
		//manager.add(filterArchiveCategory);

		synchronizeAutomatically = new SynchronizeAutomaticallyAction();
		openPreferencesAction = new OpenTasksUiPreferencesAction();
		//filterArchiveCategory = new FilterArchiveContainerAction(this);

		sortDialogAction = new TaskListSortAction(getSite(), this);

		filterOnPriorityAction = new PriorityDropDownAction(this);
		linkWithEditorAction = new LinkWithEditorAction(this);
		presentationDropDownSelectionAction = new PresentationDropDownSelectionAction(this);

	}

	public void setManualFiltersEnabled(boolean enabled) {
		sortDialogAction.setEnabled(enabled);
		filterOnPriorityAction.setEnabled(enabled);
		filterCompleteTask.setEnabled(enabled);
		//filterArchiveCategory.setEnabled(enabled);




/*******************************************************************************
 * 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.dialogs;

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

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

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

	private Button[] ascendingButtons;

	private Button[] descendingButtons;

	private final String[] propertyText;

	private boolean dirty = false;

	private final TaskListView taskListView;

	public TaskListSortDialog(IShellProvider parentShell, TaskListView taskListView) {
		super(parentShell);
		propertyText = new String[3];
		propertyText[0] = "Priority";
		propertyText[1] = "Summary";
		propertyText[2] = "Date_Created";
		this.taskListView = taskListView;
	}

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

		initializeDialogUnits(composite);

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

		Label sortByLabel = new Label(prioritiesArea, SWT.NULL);
		sortByLabel.setText("Sort by:");
		GridData data = new GridData();
		data.horizontalSpan = 3;
		sortByLabel.setLayoutData(data);

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

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

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

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

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

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

		}
		super.okPressed();
	}

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

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

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

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

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

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

}




/*******************************************************************************
 * Copyright (c) 2004, 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.actions;

import org.eclipse.jface.action.Action;
import org.eclipse.mylyn.internal.tasks.ui.dialogs.TaskListSortDialog;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.ui.IWorkbenchPartSite;

public class TaskListSortAction extends Action {

	private final TaskListSortDialog dialog;

	public TaskListSortAction(IWorkbenchPartSite site, TaskListView taskListView) {
		super("Task Sort Order");
		setEnabled(true);
		dialog = new TaskListSortDialog(site, taskListView);
	}

	@Override
	public void run() {
		dialog.open();
	}

}

Return to bug 219540

Lines 112-115 Link Here

(-)src/org/eclipse/mylyn/tasks/tests/TableSorterTest.java (+48 lines)
112	sorter.sort(new EmptyViewer(), tasks);	112	sorter.sort(new EmptyViewer(), tasks);
113	}	113	}
114		114
		115	public void test2LevelSort() {
		116	final TaskListTableSorter sorter = new TaskListTableSorter(TaskListView.getFromActivePerspective());
		117	final MockTask[] tasks = new MockTask[5];
		118	tasks[0] = new MockTask("local", "4", "c");
		119	tasks[1] = new MockTask("local", "1", "b");
		120	tasks[2] = new MockTask("local", "11", "a");
		121	tasks[2].setPriority("P1");
		122	tasks[3] = new MockTask("local", "3", "c");
		123	tasks[4] = new MockTask("local", "5", "a");
		124
		125	// sort by PRIORITY then by SUMMARY
		126	sorter.setSortByIndex(TaskListTableSorter.SortByIndex.PRIORITY);
		127	sorter.setSortByIndex2(TaskListTableSorter.SortByIndex.SUMMARY);
		128	sorter.sort(new EmptyViewer(), tasks);
		129	assertTrue("11".equals(tasks[0].getTaskKey()) && "a".equals(tasks[0].getSummary()));
		130	assertTrue("1".equals(tasks[1].getTaskKey()) && "b".equals(tasks[1].getSummary()));
		131	assertTrue("3".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
		132	assertTrue("4".equals(tasks[3].getTaskKey()) && "c".equals(tasks[3].getSummary()));
		133	assertTrue("5".equals(tasks[4].getTaskKey()) && "a".equals(tasks[4].getSummary()));
		134
		135	// sort by PRIORITY then by SUMMARY descending
		136	sorter.setSortDirection2(-1);
		137	sorter.sort(new EmptyViewer(), tasks);
		138	assertTrue("11".equals(tasks[0].getTaskKey()) && "a".equals(tasks[0].getSummary()));
		139	assertTrue("1".equals(tasks[4].getTaskKey()) && "b".equals(tasks[4].getSummary()));
		140	assertTrue("3".equals(tasks[3].getTaskKey()) && "c".equals(tasks[3].getSummary()));
		141	assertTrue("4".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
		142	assertTrue("5".equals(tasks[1].getTaskKey()) && "a".equals(tasks[1].getSummary()));
		143
		144	// sort by PRIORITY descending then by SUMMARY descending
		145	sorter.setSortDirection(-1);
		146	sorter.sort(new EmptyViewer(), tasks);
		147	assertTrue("11".equals(tasks[4].getTaskKey()) && "a".equals(tasks[4].getSummary()));
		148	assertTrue("1".equals(tasks[3].getTaskKey()) && "b".equals(tasks[3].getSummary()));
		149	assertTrue("3".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
		150	assertTrue("4".equals(tasks[1].getTaskKey()) && "c".equals(tasks[1].getSummary()));
		151	assertTrue("5".equals(tasks[0].getTaskKey()) && "a".equals(tasks[0].getSummary()));
		152
		153	// sort by PRIORITY descending then by SUMMARY
		154	sorter.setSortDirection2(1);
		155	sorter.sort(new EmptyViewer(), tasks);
		156	assertTrue("11".equals(tasks[4].getTaskKey()) && "a".equals(tasks[4].getSummary()));
		157	assertTrue("1".equals(tasks[0].getTaskKey()) && "b".equals(tasks[0].getSummary()));
		158	assertTrue("3".equals(tasks[1].getTaskKey()) && "c".equals(tasks[1].getSummary()));
		159	assertTrue("4".equals(tasks[2].getTaskKey()) && "c".equals(tasks[2].getSummary()));
		160	assertTrue("5".equals(tasks[3].getTaskKey()) && "a".equals(tasks[3].getSummary()));
		161	}
		162
115	}	163	}

Removed Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/views/SortyByDropDownAction.java (-143 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.views;
10
11	import org.eclipse.jface.action.Action;
12	import org.eclipse.jface.action.ActionContributionItem;
13	import org.eclipse.jface.action.IMenuCreator;
14	import org.eclipse.jface.action.Separator;
15	import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
16	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListTableSorter.SortByIndex;
17	import org.eclipse.swt.widgets.Control;
18	import org.eclipse.swt.widgets.Menu;
19
20	/**
21	* @author Mik Kersten
22	*/
23	class SortyByDropDownAction extends Action implements IMenuCreator {
24
25	private final TaskListView taskListView;
26
27	private static final String LABEL = "Sort by";
28
29	private Action byPriority;
30
31	private Action bySummary;
32
33	private Action byDateCreated;
34
35	private Menu dropDownMenu = null;
36
37	public SortyByDropDownAction(TaskListView taskListView) {
38	super();
39	this.taskListView = taskListView;
40	setText(LABEL);
41	setToolTipText(LABEL);
42	setMenuCreator(this);
43	}
44
45	public void dispose() {
46	if (dropDownMenu != null) {
47	dropDownMenu.dispose();
48	dropDownMenu = null;
49	}
50	}
51
52	public Menu getMenu(Control parent) {
53	if (dropDownMenu != null) {
54	dropDownMenu.dispose();
55	}
56	dropDownMenu = new Menu(parent);
57	addActionsToMenu();
58	return dropDownMenu;
59	}
60
61	public Menu getMenu(Menu parent) {
62	if (dropDownMenu != null) {
63	dropDownMenu.dispose();
64	}
65	dropDownMenu = new Menu(parent);
66	addActionsToMenu();
67	return dropDownMenu;
68	}
69
70	public void addActionsToMenu() {
71	byPriority = new Action("", AS_CHECK_BOX) {
72	@Override
73	public void run() {
74	taskListView.getSorter().setSortByIndex(SortByIndex.PRIORITY);
75	byPriority.setChecked(true);
76	bySummary.setChecked(false);
77	byDateCreated.setChecked(false);
78	}
79	};
80	byPriority.setEnabled(true);
81	byPriority.setText("Priority");
82	byPriority.setImageDescriptor(TasksUiImages.PRIORITY_1);
83	new ActionContributionItem(byPriority).fill(dropDownMenu, -1);
84
85	bySummary = new Action("", AS_CHECK_BOX) {
86	@Override
87	public void run() {
88	taskListView.getSorter().setSortByIndex(SortByIndex.SUMMARY);
89	byPriority.setChecked(false);
90	bySummary.setChecked(true);
91	byDateCreated.setChecked(false);
92	}
93	};
94	bySummary.setEnabled(true);
95	bySummary.setText("Summary");
96	new ActionContributionItem(bySummary).fill(dropDownMenu, -1);
97
98	byDateCreated = new Action("", AS_CHECK_BOX) {
99	@Override
100	public void run() {
101	taskListView.getSorter().setSortByIndex(SortByIndex.DATE_CREATED);
102	byPriority.setChecked(false);
103	bySummary.setChecked(false);
104	byDateCreated.setChecked(true);
105	}
106	};
107	byDateCreated.setEnabled(true);
108	byDateCreated.setText("Date Created");
109	byDateCreated.setImageDescriptor(TasksUiImages.CALENDAR_SMALL);
110	new ActionContributionItem(byDateCreated).fill(dropDownMenu, -1);
111
112	new Separator().fill(dropDownMenu, -1);
113
114	Action reverse = new Action("", AS_CHECK_BOX) {
115	@Override
116	public void run() {
117	taskListView.getSorter().setSortDirection(taskListView.getSorter().getSortDirection() * -1);
118	setChecked(taskListView.getSorter().getSortDirection() < 0);
119	}
120	};
121	reverse.setEnabled(true);
122	reverse.setText("Descending");
123	reverse.setChecked(taskListView.getSorter().getSortDirection() < 0);
124	new ActionContributionItem(reverse).fill(dropDownMenu, -1);
125
126	switch (taskListView.getSorter().getSortByIndex()) {
127	case PRIORITY:
128	byPriority.setChecked(true);
129	break;
130	case SUMMARY:
131	bySummary.setChecked(true);
132	break;
133	case DATE_CREATED:
134	byDateCreated.setChecked(true);
135	break;
136	}
137	}
138
139	@Override
140	public void run() {
141	this.setChecked(isChecked());
142	}
143	}