NEW - bug 212967: [patch] sorting of query nodes and archive categories in the task list

https://bugs.eclipse.org/bugs/show_bug.cgi?id=212967

4 files changed, 216 insertions, 106 deletions

diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/Messages.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/Messages.java
index 6fb0ba9a9..384f9d65b 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/Messages.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/Messages.java
@@ -27,21 +27,19 @@ public class Messages extends NLS {
 
 	public static String TaskCompareDialog_Ascending;
 
-	public static String TaskCompareDialog_DateCreated;
-
 	public static String TaskCompareDialog_Descending;
 
-	public static String TaskCompareDialog_Priority;
+	public static String TaskCompareDialog_Sort_by;
 
 	public static String TaskCompareDialog_Sorting;
 
-	public static String TaskCompareDialog_SortOrder;
+	public static String TaskCompareDialog_Tasks;
 
-	public static String TaskCompareDialog_Summary;
+	public static String TaskCompareDialog_Then_by;
 
-	public static String TaskCompareDialog_TaskID;
+	public static String TaskListSortDialog_Queries_and_Categories;
 
-	public static String TaskListSortDialog_Sort_order;
+	public static String TaskListSortDialog_Grouped_by;
 
 	public static String TaskListSortDialog_Title;
 
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/TaskCompareDialog.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/TaskCompareDialog.java
index ec9b5c124..4b8551694 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/TaskCompareDialog.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/TaskCompareDialog.java
@@ -16,9 +16,11 @@ import java.util.Arrays;
 import java.util.Comparator;
 
 import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.layout.GridDataFactory;
 import org.eclipse.jface.window.IShellProvider;
+import org.eclipse.mylyn.internal.tasks.ui.util.SortCriterion;
 import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator;
-import org.eclipse.mylyn.internal.tasks.ui.util.TaskComparator.SortByIndex;
+import org.eclipse.mylyn.internal.tasks.ui.util.SortCriterion.SortKey;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.events.SelectionAdapter;
 import org.eclipse.swt.events.SelectionEvent;
@@ -28,6 +30,7 @@ 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.Group;
 import org.eclipse.swt.widgets.Label;
 import org.eclipse.ui.dialogs.SelectionDialog;
 
@@ -48,9 +51,11 @@ public class TaskCompareDialog extends SelectionDialog {
 
 	private final TaskComparator taskComparator;
 
+	private String selectedValueLastCombo;
+
 	public TaskCompareDialog(IShellProvider parentShell, TaskComparator taskComparator) {
 		super(parentShell.getShell());
-		SortByIndex[] values = SortByIndex.values();
+		SortCriterion.SortKey[] values = SortCriterion.SortKey.values();
 		propertyText = new String[values.length];
 		for (int i = 0; i < values.length; i++) {
 			propertyText[i] = values[i].getLabel();
@@ -59,33 +64,34 @@ public class TaskCompareDialog extends SelectionDialog {
 		setTitle(Messages.TaskCompareDialog_Sorting);
 	}
 
-	protected void createDialogStartArea(Composite parent) {
-		Label sortByLabel = new Label(parent, SWT.NULL);
-		sortByLabel.setText(Messages.TaskCompareDialog_SortOrder);
-		GridData data = new GridData();
-		data.horizontalSpan = 3;
-		sortByLabel.setLayoutData(data);
-	}
-
 	@Override
 	protected Control createDialogArea(Composite parent) {
 		Composite composite = (Composite) super.createDialogArea(parent);
-
 		initializeDialogUnits(composite);
+		Control control = createContentArea(composite);
+		GridDataFactory.fillDefaults().grab(true, true).applyTo(control);
+		Dialog.applyDialogFont(parent);
+		return composite;
+	}
 
-		Composite prioritiesArea = new Composite(composite, SWT.NULL);
+	protected Control createContentArea(Composite parent) {
+		Group prioritiesArea = new Group(parent, SWT.NONE);
 		prioritiesArea.setLayout(new GridLayout(3, false));
+		prioritiesArea.setText(Messages.TaskCompareDialog_Tasks);
 
-		createDialogStartArea(prioritiesArea);
-
-		ascendingButtons = new Button[2];
-		descendingButtons = new Button[2];
-		priorityCombos = new Combo[2];
+		ascendingButtons = new Button[SortCriterion.kindCount];
+		descendingButtons = new Button[SortCriterion.kindCount];
+		priorityCombos = new Combo[SortCriterion.kindCount];
 
-		for (int i = 0; i < 2; i++) {
+		for (int i = 0; i < SortCriterion.kindCount; i++) {
 			final int index = i;
-			Label numberLabel = new Label(prioritiesArea, SWT.NULL);
-			numberLabel.setText("" + (i + 1) + "."); //$NON-NLS-1$ //$NON-NLS-2$
+			Label numberLabel = new Label(prioritiesArea, SWT.NONE);
+			if (i == 0) {
+				numberLabel.setText(Messages.TaskCompareDialog_Sort_by);
+			} else {
+				numberLabel.setText(Messages.TaskCompareDialog_Then_by);
+			}
+//			numberLabel.setText("" + (i + 1) + "."); //$NON-NLS-1$ //$NON-NLS-2$
 			priorityCombos[i] = new Combo(prioritiesArea, SWT.READ_ONLY);
 			priorityCombos[i].setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
 
@@ -107,56 +113,101 @@ public class TaskCompareDialog extends SelectionDialog {
 					markDirty();
 				}
 			});
-			if (i < priorityCombos.length - 1) {
+			if (i < priorityCombos.length) {
 				priorityCombos[i].addSelectionListener(new SelectionAdapter() {
 					@Override
 					public void widgetSelected(SelectionEvent e) {
-						int oldSelectionDirection = 1;
-						if (descendingButtons[index].getSelection()) {
-							oldSelectionDirection = -1;
-						}
+//						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;
+						if (index + 1 == SortCriterion.kindCount) {
+							oldSelection = selectedValueLastCombo;
+						} else {
+							oldSelectionList.removeAll(Arrays.asList(priorityCombos[index + 1].getItems()));
+							oldSelection = propertyText[SortKey.NONE.ordinal()];
+							if (oldSelectionList.size() == 1) {
+								oldSelection = oldSelectionList.get(0);
+							}
 						}
-						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);
+						if (index + 1 == SortCriterion.kindCount) {
+							selectedValueLastCombo = newSelection;
+						}
+						if (oldSelection.equals(propertyText[SortKey.NONE.ordinal()])) {
+							ascendingButtons[index].setEnabled(true);
+							descendingButtons[index].setEnabled(true);
+							if (index + 1 < SortCriterion.kindCount) {
+								priorityCombos[index + 1].setEnabled(true);
+								ArrayList<String> availablePriorities = new ArrayList<String>(
+										Arrays.asList(priorityCombos[index].getItems()));
+								availablePriorities.remove(newSelection);
+								for (int k = index + 1; k < SortCriterion.kindCount; k++) {
+									priorityCombos[k].removeAll();
+									for (int j = 0; j < availablePriorities.size(); j++) {
+										priorityCombos[k].add(availablePriorities.get(j));
+									}
+									priorityCombos[k].select(priorityCombos[k].indexOf(propertyText[SortKey.NONE.ordinal()]));
+								}
+							}
+						} else if (newSelection.equals(propertyText[SortKey.NONE.ordinal()])) {
+							ascendingButtons[index].setEnabled(false);
+							descendingButtons[index].setEnabled(false);
+							if (index + 1 < SortCriterion.kindCount) {
+								ArrayList<String> availablePriorities = new ArrayList<String>(
+										Arrays.asList(priorityCombos[index].getItems()));
+								for (int k = index + 1; k < SortCriterion.kindCount; k++) {
+									priorityCombos[k].setEnabled(true);
+									priorityCombos[k].removeAll();
+									for (int j = 0; j < availablePriorities.size(); j++) {
+										priorityCombos[k].add(availablePriorities.get(j));
+									}
+									priorityCombos[k].select(priorityCombos[k].indexOf(propertyText[SortKey.NONE.ordinal()]));
+									priorityCombos[k].setEnabled(false);
+									ascendingButtons[k].setEnabled(false);
+									descendingButtons[k].setEnabled(false);
 								}
-								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);
+						} else {
+							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));
+// remove the comment if you want to move the current ascending/descending 								
+//									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);
+									}
 								}
 							}
 						}
@@ -173,31 +224,21 @@ public class TaskCompareDialog extends SelectionDialog {
 			}
 
 		}
-		int a[] = new int[2];
-		int b[] = new int[2];
-		a[0] = taskComparator.getSortByIndex().ordinal();
-		a[1] = taskComparator.getSortByIndex2().ordinal();
-		b[0] = taskComparator.getSortDirection();
-		b[1] = taskComparator.getSortDirection2();
-		updateUI(a, b);
-		Dialog.applyDialogFont(composite);
-		return composite;
+		updateUI();
+		return prioritiesArea;
 	}
 
 	@Override
 	protected void okPressed() {
 		if (isDirty()) {
-			taskComparator.setSortByIndex(SortByIndex.valueOfLabel(priorityCombos[0].getText()));
-			taskComparator.setSortByIndex2(SortByIndex.valueOfLabel(priorityCombos[1].getText()));
-			if (descendingButtons[0].getSelection()) {
-				taskComparator.setSortDirection(-1);
-			} else {
-				taskComparator.setSortDirection(1);
-			}
-			if (descendingButtons[1].getSelection()) {
-				taskComparator.setSortDirection2(-1);
-			} else {
-				taskComparator.setSortDirection2(1);
+			for (int i = 0; i < SortCriterion.kindCount; i++) {
+				SortCriterion keyEntries = taskComparator.getSortCriterion(i);
+				keyEntries.setKey(SortKey.valueOfLabel(priorityCombos[i].getText()));
+				if (descendingButtons[i].getSelection()) {
+					keyEntries.setDirection(-1);
+				} else {
+					keyEntries.setDirection(1);
+				}
 			}
 		}
 		super.okPressed();
@@ -230,18 +271,41 @@ public class TaskCompareDialog extends SelectionDialog {
 		}
 	};
 
-	protected void updateUI(int[] priorities, int[] directions) {
+	protected void updateUI() {
 		ArrayList<String> availablePriorities = new ArrayList<String>(Arrays.asList(propertyText));
-
-		for (int i = 0; i < priorityCombos.length; i++) {
+		for (int i = 0; i < TaskComparator.CRITERIA_COUNT; i++) {
+			SortCriterion criterion = taskComparator.getSortCriterion(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);
+			priorityCombos[i].select(priorityCombos[i].indexOf(propertyText[criterion.getKey().ordinal()]));
+			ascendingButtons[i].setSelection(criterion.getDirection() == 1);
+			descendingButtons[i].setSelection(criterion.getDirection() == -1);
+			if (i == TaskComparator.CRITERIA_COUNT - 1) {
+				selectedValueLastCombo = propertyText[criterion.getKey().ordinal()];
+			}
+			if (criterion.getKey() != SortKey.NONE) {
+				availablePriorities.remove(propertyText[criterion.getKey().ordinal()]);
+			} else {
+				ascendingButtons[i].setEnabled(false);
+				descendingButtons[i].setEnabled(false);
+				for (int k = i + 1; k < TaskComparator.CRITERIA_COUNT; k++) {
+					for (int j = 0; j < availablePriorities.size(); j++) {
+						priorityCombos[k].add(availablePriorities.get(j));
+					}
+					priorityCombos[k].select(priorityCombos[k].indexOf(propertyText[SortKey.NONE.ordinal()]));
+					if (k == TaskComparator.CRITERIA_COUNT - 1) {
+						selectedValueLastCombo = propertyText[SortKey.NONE.ordinal()];
+					}
+					ascendingButtons[k].setSelection(taskComparator.getSortCriterion(k).getDirection() == 1);
+					descendingButtons[k].setSelection(taskComparator.getSortCriterion(k).getDirection() == -1);
+					priorityCombos[k].setEnabled(false);
+					ascendingButtons[k].setEnabled(false);
+					descendingButtons[k].setEnabled(false);
+				}
+				break;
+			}
 		}
 	}
 
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/TaskListSortDialog.java b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/TaskListSortDialog.java
index 36fe7ab10..5950670d5 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/TaskListSortDialog.java
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/TaskListSortDialog.java
@@ -7,36 +7,85 @@
  *
  * Contributors:
  *     Frank Becker - initial API and implementation
+ *     Tasktop Technologies - improvements
  *******************************************************************************/
 
 package org.eclipse.mylyn.internal.tasks.ui.dialogs;
 
-import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.layout.GridDataFactory;
+import org.eclipse.jface.layout.GridLayoutFactory;
 import org.eclipse.jface.window.IShellProvider;
+import org.eclipse.mylyn.internal.tasks.ui.views.TaskListSorter;
 import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
+import org.eclipse.mylyn.internal.tasks.ui.views.TaskListSorter.GroupBy;
 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.Combo;
 import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Group;
 import org.eclipse.swt.widgets.Label;
 
 /**
  * @author Frank Becker
+ * @author Steffen Pingel
  */
 public class TaskListSortDialog extends TaskCompareDialog {
 
+	private Combo modeCombo;
+
+	private final TaskListView taskListView;
+
 	public TaskListSortDialog(IShellProvider parentShell, TaskListView taskListView) {
 		super(parentShell, taskListView.getSorter().getComparator());
+		this.taskListView = taskListView;
 		setTitle(Messages.TaskListSortDialog_Title);
 	}
 
 	@Override
-	protected void createDialogStartArea(Composite parent) {
-		Label sortByLabel = new Label(parent, SWT.NULL);
-		sortByLabel.setText(Messages.TaskListSortDialog_Sort_order);
-		GridData data = new GridData();
-		data.horizontalSpan = 3;
-		sortByLabel.setLayoutData(data);
-		Dialog.applyDialogFont(parent);
+	protected Control createContentArea(Composite parent) {
+		Composite container = new Composite(parent, SWT.NONE);
+		container.setLayout(GridLayoutFactory.fillDefaults().create());
+
+		Group groupByComposite = new Group(container, SWT.NONE);
+		groupByComposite.setLayout(new GridLayout(2, false));
+		groupByComposite.setText(Messages.TaskListSortDialog_Queries_and_Categories);
+		GridDataFactory.fillDefaults().grab(true, false).applyTo(groupByComposite);
+
+		Label numberLabel = new Label(groupByComposite, SWT.NULL);
+		numberLabel.setText(Messages.TaskListSortDialog_Grouped_by);
+		modeCombo = new Combo(groupByComposite, SWT.READ_ONLY);
+		modeCombo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		GroupBy[] values = TaskListSorter.GroupBy.values();
+		for (GroupBy groupBy : values) {
+			modeCombo.add(groupBy.getLabel());
+		}
+		modeCombo.addSelectionListener(new SelectionAdapter() {
+			@Override
+			public void widgetSelected(SelectionEvent e) {
+				markDirty();
+			}
+		});
+		modeCombo.select(taskListView.getSorter().getGroupBy().ordinal());
+
+		Control child = super.createContentArea(container);
+		GridDataFactory.fillDefaults().grab(true, false).applyTo(child);
+
+		return container;
+	}
+
+	@Override
+	protected void okPressed() {
+		if (isDirty()) {
+			int selectionIndex = modeCombo.getSelectionIndex();
+			if (selectionIndex != -1) {
+				taskListView.getSorter().setGroupBy(TaskListSorter.GroupBy.values()[selectionIndex]);
+			}
+		}
+		super.okPressed();
 	}
 
 }
diff --git a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/messages.properties b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/messages.properties
index 1513d5c38..8f559f811 100644
--- a/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/messages.properties
+++ b/org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/dialogs/messages.properties
@@ -1,12 +1,11 @@
 TaskCompareDialog_Ascending=Ascending
-TaskCompareDialog_DateCreated=Date Created
 TaskCompareDialog_Descending=Descending
-TaskCompareDialog_Priority=Priority
+TaskCompareDialog_Sort_by=Sort by:
 TaskCompareDialog_Sorting=Sorting
-TaskCompareDialog_SortOrder=Sort order:
-TaskCompareDialog_Summary=Summary
-TaskCompareDialog_TaskID=Task ID
-TaskListSortDialog_Sort_order=Sort order for tasks\:
+TaskCompareDialog_Tasks=Tasks
+TaskCompareDialog_Then_by=Then by:
+TaskListSortDialog_Queries_and_Categories=Queries and Categories
+TaskListSortDialog_Grouped_by=Group by:
 TaskListSortDialog_Title=Task List Sorting
 
 TaskRepositoryCredentialsDialog_Enter_Credentials=Enter Credentials