Attachment #89058 for bug #217344

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





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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.mylyn.internal.tasks.ui.TaskListColorsAndFonts;
import org.eclipse.mylyn.internal.tasks.ui.TaskSearchPage;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskActivationHistory;

import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListFilteredTree;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.internal.tasks.ui.workingsets.TaskWorkingSetUpdater;
import org.eclipse.mylyn.internal.tasks.ui.workingsets.WorkingSetLabelComparator;
import org.eclipse.mylyn.tasks.core.AbstractTask;
import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.tasks.core.TaskList;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.search.internal.ui.SearchDialog;

import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.FilteredItemsSelectionDialog;
import org.eclipse.ui.dialogs.IWorkingSetEditWizard;
import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog;
import org.eclipse.ui.dialogs.SearchPattern;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;


	private static final String SHOW_COMPLETED_TASKS_SETTING = "ShowCompletedTasks";

	private static final String IS_USING_WINDOW_WORKING_SET_SETTING = "IsUsingWindowWorkingSet";

	private static final String WORKING_SET_NAME_SETTING = "WorkingSetName";

	private boolean openInBrowser;

	public boolean getOpenInBrowser() {

		}
	}

	/**
	 * Caches the window working set
	 */
	private final IWorkingSet windowWorkingSet;

	/**
	 * Set of filtered working sets
	 */
	private IWorkingSet selectedWorkingSet;

	/**
	 * Refilters if the current working set content has changed
	 */
	private IPropertyChangeListener workingSetListener = new IPropertyChangeListener() {

		public void propertyChange(PropertyChangeEvent event) {
			if (event.getProperty().equals(IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE)) {
				if (event.getNewValue().equals(selectedWorkingSet)) {
					applyFilter();
				}
			}
		}

	};

	private TaskElementLabelProvider labelProvider;

	public TaskSelectionDialog(Shell parent) {

		setSelectionHistory(new TaskSelectionHistory());

		labelProvider = new TaskElementLabelProvider(false);

		setListLabelProvider(labelProvider);

//		setListLabelProvider(new DecoratingLabelProvider(labelProvider, PlatformUI.getWorkbench()
//				.getDecoratorManager()
//				.getLabelDecorator()));

			}
			setInitialPattern(text);
		}

		windowWorkingSet = window.getActivePage().getAggregateWorkingSet();
		selectedWorkingSet = windowWorkingSet;

		PlatformUI.getWorkbench().getWorkingSetManager().addPropertyChangeListener(workingSetListener);
	}

	private boolean showExtendedOpeningOptions;

	protected void fillViewMenu(IMenuManager menuManager) {
		super.fillViewMenu(menuManager);
		menuManager.add(showCompletedTasksAction);
		menuManager.add(new Separator());

		// Fill existing tasks working sets
		menuManager.add(new SelectWorkingSetAction());
		final DeselectWorkingSetAction deselectAction = new DeselectWorkingSetAction();
		menuManager.add(deselectAction);
		final EditWorkingSetAction editAction = new EditWorkingSetAction();
		menuManager.add(editAction);
		menuManager.add(new Separator("lruActions"));
		final FilterWorkingSetAction windowWorkingSetAction = new FilterWorkingSetAction(windowWorkingSet, 1);
		menuManager.add(windowWorkingSetAction);

		menuManager.addMenuListener(new IMenuListener() {

			private List<ActionContributionItem> lruActions = new ArrayList<ActionContributionItem>();

			public void menuAboutToShow(IMenuManager manager) {
				deselectAction.setEnabled(selectedWorkingSet != null);
				editAction.setEnabled(selectedWorkingSet != null && selectedWorkingSet.isEditable());

				// Remove previous LRU actions
				for (ActionContributionItem action : lruActions) {
					manager.remove(action);
				}
				lruActions.clear();

				// Adds actual LRU actions
				IWorkingSet[] workingSets = PlatformUI.getWorkbench().getWorkingSetManager().getRecentWorkingSets();
				Arrays.sort(workingSets, new WorkingSetLabelComparator());
				int count = 2;
				for (IWorkingSet workingSet : workingSets) {
					if (workingSet.getId().equalsIgnoreCase(TaskWorkingSetUpdater.ID_TASK_WORKING_SET)) {
						IAction action = new FilterWorkingSetAction(workingSet, count++);
						if (workingSet.equals(selectedWorkingSet)) {
							action.setChecked(true);
						}
						ActionContributionItem ci = new ActionContributionItem(action);
						lruActions.add(ci);
						manager.appendToGroup("lruActions", ci);
					}
				}
				windowWorkingSetAction.setChecked(windowWorkingSet.equals(selectedWorkingSet));
			}

		});
	}

	/**
	 * All working set filter changes should be made through this method; ensures proper history handling and triggers
	 * refiltering
	 */
	private void setSelectedWorkingSet(IWorkingSet workingSet) {
		selectedWorkingSet = workingSet;
		if (workingSet != null) {
			PlatformUI.getWorkbench().getWorkingSetManager().addRecentWorkingSet(workingSet);
		}
		applyFilter();
	}

	private boolean showCompletedTasks;


	}

	private class SelectWorkingSetAction extends Action {

		public SelectWorkingSetAction() {
			super("Select &Working Set...", IAction.AS_PUSH_BUTTON);
		}

		@Override
		public void run() {
			IWorkingSetSelectionDialog dlg = PlatformUI.getWorkbench()
					.getWorkingSetManager()
					.createWorkingSetSelectionDialog(getShell(), false,
							new String[] { TaskWorkingSetUpdater.ID_TASK_WORKING_SET });
			if (selectedWorkingSet != null) {
				dlg.setSelection(new IWorkingSet[] { selectedWorkingSet });
			}
			if (dlg.open() == Window.OK) {
				IWorkingSet[] selection = dlg.getSelection();
				if (selection.length == 0) {
					setSelectedWorkingSet(null);
				} else {
					setSelectedWorkingSet(selection[0]);
				}
			}
		}
	}

	private class DeselectWorkingSetAction extends Action {

		public DeselectWorkingSetAction() {
			super("&Deselect Working Set", IAction.AS_PUSH_BUTTON);
		}

		@Override
		public void run() {
			setSelectedWorkingSet(null);
		}
	}

	private class EditWorkingSetAction extends Action {

		public EditWorkingSetAction() {
			super("&Edit Active Working Set...", IAction.AS_PUSH_BUTTON);
		}

		@Override
		public void run() {
			IWorkingSetEditWizard wizard = PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSetEditWizard(
					selectedWorkingSet);
			if (wizard != null) {
				WizardDialog dlg = new WizardDialog(getShell(), wizard);
				dlg.open();
			}
		}
	}

	private class FilterWorkingSetAction extends Action {

		private IWorkingSet workingSet;

		public FilterWorkingSetAction(IWorkingSet workingSet, int shortcutKeyNumber) {
			super("", IAction.AS_RADIO_BUTTON);
			this.workingSet = workingSet;
			if (shortcutKeyNumber >= 1 && shortcutKeyNumber <= 9) {
				setText("&" + String.valueOf(shortcutKeyNumber) + " " + workingSet.getLabel());
			} else {
				setText(workingSet.getLabel());
			}
			setImageDescriptor(workingSet.getImageDescriptor());
		}

		@Override
		public void run() {
			setSelectedWorkingSet(workingSet);
		}
	}

	@Override
	protected Control createExtendedContentArea(Composite parent) {
		if (!showExtendedOpeningOptions) {


	@Override
	public boolean close() {
		PlatformUI.getWorkbench().getWorkingSetManager().removePropertyChangeListener(workingSetListener);
		if (openInBrowserCheck != null) {
			openInBrowser = openInBrowserCheck.getSelection();
		}


	private class TasksFilter extends ItemsFilter {

		private final boolean showCompletedTasks;

		/**
		 * Stores the task containers from selected working set; empty, which can come from no working set selection or
		 * working set with no task containers selected, means no filtering
		 */
		private final Set<AbstractTaskContainer> elements;

		private Set<AbstractTask> allTasksFromWorkingSets;

		public TasksFilter(boolean showCompletedTasks, IWorkingSet selectedWorkingSet) {
			super(new SearchPattern());
			// Little hack to force always a match inside any part of task text
			patternMatcher.setPattern("*" + patternMatcher.getPattern());
			this.showCompletedTasks = showCompletedTasks;

			elements = new HashSet<AbstractTaskContainer>();
			if (selectedWorkingSet != null) {
				for (IAdaptable adaptable : selectedWorkingSet.getElements()) {
					AbstractTaskContainer container = (AbstractTaskContainer) adaptable.getAdapter(AbstractTaskContainer.class);
					if (container != null) {
						elements.add(container);
					}
				}
			}
		}

		@Override

				return false;
			}
			if (filter instanceof TasksFilter) {
				TasksFilter tasksFilter = (TasksFilter) filter;
				if (!showCompletedTasks && tasksFilter.showCompletedTasks) {
					return false;
				}
				if (elements.isEmpty()) {
					return true;
				}
				if (tasksFilter.elements.isEmpty()) {
					return false;
				}
				return elements.containsAll(tasksFilter.elements);
			}
			return true;
		}

				return false;
			}
			if (filter instanceof TasksFilter) {
				TasksFilter tasksFilter = (TasksFilter) filter;
				if (showCompletedTasks != tasksFilter.showCompletedTasks) {
					return false;
				}
				return elements.equals(tasksFilter.elements);
			}
			return true;
		}

			if (!showCompletedTasks && ((AbstractTask) item).isCompleted()) {
				return false;
			}
			if (!elements.isEmpty()) {
				if (allTasksFromWorkingSets == null) {
					populateTasksFromWorkingSets();
				}
				if (!allTasksFromWorkingSets.contains(item)) {
					return false;
				}
			}
			return matches(labelProvider.getText(item));
		}

		private void populateTasksFromWorkingSets() {
			allTasksFromWorkingSets = new HashSet<AbstractTask>(1000);
			for (AbstractTaskContainer container : elements) {
				allTasksFromWorkingSets.addAll(container.getChildren());
			}
		}
	}

	@Override
	protected ItemsFilter createFilter() {
		return new TasksFilter(showCompletedTasks, selectedWorkingSet);
	}

	/**

			section = settings.addNewSection(TASK_SELECTION_DIALOG_SECTION);
			section.put(OPEN_IN_BROWSER_SETTING, false);
			section.put(SHOW_COMPLETED_TASKS_SETTING, true);
			section.put(IS_USING_WINDOW_WORKING_SET_SETTING, true);
			section.put(WORKING_SET_NAME_SETTING, "");
		}
		return section;
	}

		openInBrowser = settings.getBoolean(OPEN_IN_BROWSER_SETTING);
		showCompletedTasks = settings.getBoolean(SHOW_COMPLETED_TASKS_SETTING);
		showCompletedTasksAction.setChecked(showCompletedTasks);
		boolean isUsingWindowWorkingSet = settings.getBoolean(IS_USING_WINDOW_WORKING_SET_SETTING);
		if (isUsingWindowWorkingSet) {
			selectedWorkingSet = windowWorkingSet;
		} else {
			String workingSetName = settings.get(WORKING_SET_NAME_SETTING);
			if (workingSetName != null) {
				selectedWorkingSet = PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(workingSetName);
			}
		}
		super.restoreDialog(settings);
	}


	protected void storeDialog(IDialogSettings settings) {
		settings.put(OPEN_IN_BROWSER_SETTING, openInBrowser);
		settings.put(SHOW_COMPLETED_TASKS_SETTING, showCompletedTasks);
		settings.put(IS_USING_WINDOW_WORKING_SET_SETTING, selectedWorkingSet == windowWorkingSet);
		if (selectedWorkingSet == null) {
			settings.put(WORKING_SET_NAME_SETTING, "");
		} else {
			settings.put(WORKING_SET_NAME_SETTING, selectedWorkingSet.getName());
		}
		super.storeDialog(settings);
	}





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

import java.text.Collator;
import java.util.Comparator;

import org.eclipse.ui.IWorkingSet;

/**
 * @author Willian Mitsuda
 */
public class WorkingSetLabelComparator implements Comparator<IWorkingSet> {

	public int compare(IWorkingSet ws1, IWorkingSet ws2) {
		return Collator.getInstance().compare(ws1.getLabel(), ws2.getLabel());
	}

}

Return to bug 217344

Lines 8-30 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/actions/TaskSelectionDialog.java (-7 / +257 lines)
8		8
9	package org.eclipse.mylyn.internal.tasks.ui.actions;	9	package org.eclipse.mylyn.internal.tasks.ui.actions;
10		10
		11	import java.util.ArrayList;
		12	import java.util.Arrays;
11	import java.util.Comparator;	13	import java.util.Comparator;
12	import java.util.HashSet;	14	import java.util.HashSet;
		15	import java.util.List;
13	import java.util.Set;	16	import java.util.Set;
14		17
15	import org.eclipse.core.runtime.CoreException;	18	import org.eclipse.core.runtime.CoreException;
		19	import org.eclipse.core.runtime.IAdaptable;
16	import org.eclipse.core.runtime.IProgressMonitor;	20	import org.eclipse.core.runtime.IProgressMonitor;
17	import org.eclipse.core.runtime.IStatus;	21	import org.eclipse.core.runtime.IStatus;
18	import org.eclipse.core.runtime.Status;	22	import org.eclipse.core.runtime.Status;
19	import org.eclipse.core.runtime.SubProgressMonitor;	23	import org.eclipse.core.runtime.SubProgressMonitor;
20	import org.eclipse.jface.action.Action;	24	import org.eclipse.jface.action.Action;
		25	import org.eclipse.jface.action.ActionContributionItem;
21	import org.eclipse.jface.action.IAction;	26	import org.eclipse.jface.action.IAction;
		27	import org.eclipse.jface.action.IMenuListener;
22	import org.eclipse.jface.action.IMenuManager;	28	import org.eclipse.jface.action.IMenuManager;
		29	import org.eclipse.jface.action.Separator;
23	import org.eclipse.jface.dialogs.IDialogSettings;	30	import org.eclipse.jface.dialogs.IDialogSettings;
24	import org.eclipse.jface.layout.GridDataFactory;	31	import org.eclipse.jface.layout.GridDataFactory;
25	import org.eclipse.jface.layout.GridLayoutFactory;	32	import org.eclipse.jface.layout.GridLayoutFactory;
26	import org.eclipse.jface.text.ITextSelection;	33	import org.eclipse.jface.text.ITextSelection;
		34	import org.eclipse.jface.util.IPropertyChangeListener;
		35	import org.eclipse.jface.util.PropertyChangeEvent;
27	import org.eclipse.jface.viewers.ISelection;	36	import org.eclipse.jface.viewers.ISelection;
		37	import org.eclipse.jface.window.Window;
		38	import org.eclipse.jface.wizard.WizardDialog;
28	import org.eclipse.mylyn.internal.tasks.ui.TaskListColorsAndFonts;	39	import org.eclipse.mylyn.internal.tasks.ui.TaskListColorsAndFonts;
29	import org.eclipse.mylyn.internal.tasks.ui.TaskSearchPage;	40	import org.eclipse.mylyn.internal.tasks.ui.TaskSearchPage;
30	import org.eclipse.mylyn.internal.tasks.ui.views.TaskActivationHistory;	41	import org.eclipse.mylyn.internal.tasks.ui.views.TaskActivationHistory;
Lines 32-38 Link Here
32	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;	43	import org.eclipse.mylyn.internal.tasks.ui.views.TaskElementLabelProvider;
33	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListFilteredTree;	44	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListFilteredTree;
34	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;	45	import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
		46	import org.eclipse.mylyn.internal.tasks.ui.workingsets.TaskWorkingSetUpdater;
		47	import org.eclipse.mylyn.internal.tasks.ui.workingsets.WorkingSetLabelComparator;
35	import org.eclipse.mylyn.tasks.core.AbstractTask;	48	import org.eclipse.mylyn.tasks.core.AbstractTask;
		49	import org.eclipse.mylyn.tasks.core.AbstractTaskContainer;
36	import org.eclipse.mylyn.tasks.core.TaskList;	50	import org.eclipse.mylyn.tasks.core.TaskList;
37	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;	51	import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
38	import org.eclipse.search.internal.ui.SearchDialog;	52	import org.eclipse.search.internal.ui.SearchDialog;
Lines 43-50 Link Here
43	import org.eclipse.swt.widgets.Shell;	57	import org.eclipse.swt.widgets.Shell;
44	import org.eclipse.ui.IMemento;	58	import org.eclipse.ui.IMemento;
45	import org.eclipse.ui.IWorkbenchWindow;	59	import org.eclipse.ui.IWorkbenchWindow;
		60	import org.eclipse.ui.IWorkingSet;
		61	import org.eclipse.ui.IWorkingSetManager;
46	import org.eclipse.ui.PlatformUI;	62	import org.eclipse.ui.PlatformUI;
47	import org.eclipse.ui.dialogs.FilteredItemsSelectionDialog;	63	import org.eclipse.ui.dialogs.FilteredItemsSelectionDialog;
		64	import org.eclipse.ui.dialogs.IWorkingSetEditWizard;
		65	import org.eclipse.ui.dialogs.IWorkingSetSelectionDialog;
48	import org.eclipse.ui.dialogs.SearchPattern;	66	import org.eclipse.ui.dialogs.SearchPattern;
49	import org.eclipse.ui.forms.events.HyperlinkAdapter;	67	import org.eclipse.ui.forms.events.HyperlinkAdapter;
50	import org.eclipse.ui.forms.events.HyperlinkEvent;	68	import org.eclipse.ui.forms.events.HyperlinkEvent;
Lines 65-70 Link Here
65		83
66	private static final String SHOW_COMPLETED_TASKS_SETTING = "ShowCompletedTasks";	84	private static final String SHOW_COMPLETED_TASKS_SETTING = "ShowCompletedTasks";
67		85
		86	private static final String IS_USING_WINDOW_WORKING_SET_SETTING = "IsUsingWindowWorkingSet";
		87
		88	private static final String WORKING_SET_NAME_SETTING = "WorkingSetName";
		89
68	private boolean openInBrowser;	90	private boolean openInBrowser;
69		91
70	public boolean getOpenInBrowser() {	92	public boolean getOpenInBrowser() {
Lines 146-151 Link Here
146	}	168	}
147	}	169	}
148		170
		171	/**
		172	* Caches the window working set
		173	*/
		174	private final IWorkingSet windowWorkingSet;
		175
		176	/**
		177	* Set of filtered working sets
		178	*/
		179	private IWorkingSet selectedWorkingSet;
		180
		181	/**
		182	* Refilters if the current working set content has changed
		183	*/
		184	private IPropertyChangeListener workingSetListener = new IPropertyChangeListener() {
		185
		186	public void propertyChange(PropertyChangeEvent event) {
		187	if (event.getProperty().equals(IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE)) {
		188	if (event.getNewValue().equals(selectedWorkingSet)) {
		189	applyFilter();
		190	}
		191	}
		192	}
		193
		194	};
		195
149	private TaskElementLabelProvider labelProvider;	196	private TaskElementLabelProvider labelProvider;
150		197
151	public TaskSelectionDialog(Shell parent) {	198	public TaskSelectionDialog(Shell parent) {
Lines 153-161 Link Here
153	setSelectionHistory(new TaskSelectionHistory());	200	setSelectionHistory(new TaskSelectionHistory());
154		201
155	labelProvider = new TaskElementLabelProvider(false);	202	labelProvider = new TaskElementLabelProvider(false);
156		203
157	setListLabelProvider(labelProvider);	204	setListLabelProvider(labelProvider);
158		205
159	// setListLabelProvider(new DecoratingLabelProvider(labelProvider, PlatformUI.getWorkbench()	206	// setListLabelProvider(new DecoratingLabelProvider(labelProvider, PlatformUI.getWorkbench()
160	// .getDecoratorManager()	207	// .getDecoratorManager()
161	// .getLabelDecorator()));	208	// .getLabelDecorator()));
Lines 174-179 Link Here
174	}	221	}
175	setInitialPattern(text);	222	setInitialPattern(text);
176	}	223	}
		224
		225	windowWorkingSet = window.getActivePage().getAggregateWorkingSet();
		226	selectedWorkingSet = windowWorkingSet;
		227
		228	PlatformUI.getWorkbench().getWorkingSetManager().addPropertyChangeListener(workingSetListener);
177	}	229	}
178		230
179	private boolean showExtendedOpeningOptions;	231	private boolean showExtendedOpeningOptions;
Lines 192-197 Link Here
192	protected void fillViewMenu(IMenuManager menuManager) {	244	protected void fillViewMenu(IMenuManager menuManager) {
193	super.fillViewMenu(menuManager);	245	super.fillViewMenu(menuManager);
194	menuManager.add(showCompletedTasksAction);	246	menuManager.add(showCompletedTasksAction);
		247	menuManager.add(new Separator());
		248
		249	// Fill existing tasks working sets
		250	menuManager.add(new SelectWorkingSetAction());
		251	final DeselectWorkingSetAction deselectAction = new DeselectWorkingSetAction();
		252	menuManager.add(deselectAction);
		253	final EditWorkingSetAction editAction = new EditWorkingSetAction();
		254	menuManager.add(editAction);
		255	menuManager.add(new Separator("lruActions"));
		256	final FilterWorkingSetAction windowWorkingSetAction = new FilterWorkingSetAction(windowWorkingSet, 1);
		257	menuManager.add(windowWorkingSetAction);
		258
		259	menuManager.addMenuListener(new IMenuListener() {
		260
		261	private List<ActionContributionItem> lruActions = new ArrayList<ActionContributionItem>();
		262
		263	public void menuAboutToShow(IMenuManager manager) {
		264	deselectAction.setEnabled(selectedWorkingSet != null);
		265	editAction.setEnabled(selectedWorkingSet != null && selectedWorkingSet.isEditable());
		266
		267	// Remove previous LRU actions
		268	for (ActionContributionItem action : lruActions) {
		269	manager.remove(action);
		270	}
		271	lruActions.clear();
		272
		273	// Adds actual LRU actions
		274	IWorkingSet[] workingSets = PlatformUI.getWorkbench().getWorkingSetManager().getRecentWorkingSets();
		275	Arrays.sort(workingSets, new WorkingSetLabelComparator());
		276	int count = 2;
		277	for (IWorkingSet workingSet : workingSets) {
		278	if (workingSet.getId().equalsIgnoreCase(TaskWorkingSetUpdater.ID_TASK_WORKING_SET)) {
		279	IAction action = new FilterWorkingSetAction(workingSet, count++);
		280	if (workingSet.equals(selectedWorkingSet)) {
		281	action.setChecked(true);
		282	}
		283	ActionContributionItem ci = new ActionContributionItem(action);
		284	lruActions.add(ci);
		285	manager.appendToGroup("lruActions", ci);
		286	}
		287	}
		288	windowWorkingSetAction.setChecked(windowWorkingSet.equals(selectedWorkingSet));
		289	}
		290
		291	});
		292	}
		293
		294	/**
		295	* All working set filter changes should be made through this method; ensures proper history handling and triggers
		296	* refiltering
		297	*/
		298	private void setSelectedWorkingSet(IWorkingSet workingSet) {
		299	selectedWorkingSet = workingSet;
		300	if (workingSet != null) {
		301	PlatformUI.getWorkbench().getWorkingSetManager().addRecentWorkingSet(workingSet);
		302	}
		303	applyFilter();
195	}	304	}
196		305
197	private boolean showCompletedTasks;	306	private boolean showCompletedTasks;
Lines 210-215 Link Here
210		319
211	}	320	}
212		321
		322	private class SelectWorkingSetAction extends Action {
		323
		324	public SelectWorkingSetAction() {
		325	super("Select &Working Set...", IAction.AS_PUSH_BUTTON);
		326	}
		327
		328	@Override
		329	public void run() {
		330	IWorkingSetSelectionDialog dlg = PlatformUI.getWorkbench()
		331	.getWorkingSetManager()
		332	.createWorkingSetSelectionDialog(getShell(), false,
		333	new String[] { TaskWorkingSetUpdater.ID_TASK_WORKING_SET });
		334	if (selectedWorkingSet != null) {
		335	dlg.setSelection(new IWorkingSet[] { selectedWorkingSet });
		336	}
		337	if (dlg.open() == Window.OK) {
		338	IWorkingSet[] selection = dlg.getSelection();
		339	if (selection.length == 0) {
		340	setSelectedWorkingSet(null);
		341	} else {
		342	setSelectedWorkingSet(selection[0]);
		343	}
		344	}
		345	}
		346	}
		347
		348	private class DeselectWorkingSetAction extends Action {
		349
		350	public DeselectWorkingSetAction() {
		351	super("&Deselect Working Set", IAction.AS_PUSH_BUTTON);
		352	}
		353
		354	@Override
		355	public void run() {
		356	setSelectedWorkingSet(null);
		357	}
		358	}
		359
		360	private class EditWorkingSetAction extends Action {
		361
		362	public EditWorkingSetAction() {
		363	super("&Edit Active Working Set...", IAction.AS_PUSH_BUTTON);
		364	}
		365
		366	@Override
		367	public void run() {
		368	IWorkingSetEditWizard wizard = PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSetEditWizard(
		369	selectedWorkingSet);
		370	if (wizard != null) {
		371	WizardDialog dlg = new WizardDialog(getShell(), wizard);
		372	dlg.open();
		373	}
		374	}
		375	}
		376
		377	private class FilterWorkingSetAction extends Action {
		378
		379	private IWorkingSet workingSet;
		380
		381	public FilterWorkingSetAction(IWorkingSet workingSet, int shortcutKeyNumber) {
		382	super("", IAction.AS_RADIO_BUTTON);
		383	this.workingSet = workingSet;
		384	if (shortcutKeyNumber >= 1 && shortcutKeyNumber <= 9) {
		385	setText("&" + String.valueOf(shortcutKeyNumber) + " " + workingSet.getLabel());
386	} else {
387	setText(workingSet.getLabel());
388	}
389	setImageDescriptor(workingSet.getImageDescriptor());
390	}
391
392	@Override
393	public void run() {
394	setSelectedWorkingSet(workingSet);
395	}
396	}
397
213	@Override	398	@Override
214	protected Control createExtendedContentArea(Composite parent) {	399	protected Control createExtendedContentArea(Composite parent) {
215	if (!showExtendedOpeningOptions) {	400	if (!showExtendedOpeningOptions) {
Lines 242-247 Link Here
242		427
243	@Override	428	@Override
244	public boolean close() {	429	public boolean close() {
		430	PlatformUI.getWorkbench().getWorkingSetManager().removePropertyChangeListener(workingSetListener);
245	if (openInBrowserCheck != null) {	431	if (openInBrowserCheck != null) {
246	openInBrowser = openInBrowserCheck.getSelection();	432	openInBrowser = openInBrowserCheck.getSelection();
247	}	433	}
Lines 250-262 Link Here
250		436
251	private class TasksFilter extends ItemsFilter {	437	private class TasksFilter extends ItemsFilter {
252		438
253	private boolean showCompletedTasks;	439	private final boolean showCompletedTasks;
		440
		441	/**
		442	* Stores the task containers from selected working set; empty, which can come from no working set selection or
		443	* working set with no task containers selected, means no filtering
		444	*/
		445	private final Set<AbstractTaskContainer> elements;
		446
		447	private Set<AbstractTask> allTasksFromWorkingSets;
254		448
255	public TasksFilter(boolean showCompletedTasks) {	449	public TasksFilter(boolean showCompletedTasks, IWorkingSet selectedWorkingSet) {
256	super(new SearchPattern());	450	super(new SearchPattern());
257	// Little hack to force always a match inside any part of task text	451	// Little hack to force always a match inside any part of task text
258	patternMatcher.setPattern("*" + patternMatcher.getPattern());	452	patternMatcher.setPattern("*" + patternMatcher.getPattern());
259	this.showCompletedTasks = showCompletedTasks;	453	this.showCompletedTasks = showCompletedTasks;
		454
		455	elements = new HashSet<AbstractTaskContainer>();
		456	if (selectedWorkingSet != null) {
		457	for (IAdaptable adaptable : selectedWorkingSet.getElements()) {
		458	AbstractTaskContainer container = (AbstractTaskContainer) adaptable.getAdapter(AbstractTaskContainer.class);
		459	if (container != null) {
		460	elements.add(container);
		461	}
		462	}
		463	}
260	}	464	}
261		465
262	@Override	466	@Override
Lines 265-271 Link Here
265	return false;	469	return false;
266	}	470	}
267	if (filter instanceof TasksFilter) {	471	if (filter instanceof TasksFilter) {
268	return showCompletedTasks == ((TasksFilter) filter).showCompletedTasks;	472	TasksFilter tasksFilter = (TasksFilter) filter;
		473	if (!showCompletedTasks && tasksFilter.showCompletedTasks) {
		474	return false;
		475	}
		476	if (elements.isEmpty()) {
		477	return true;
		478	}
		479	if (tasksFilter.elements.isEmpty()) {
		480	return false;
		481	}
		482	return elements.containsAll(tasksFilter.elements);
269	}	483	}
270	return true;	484	return true;
271	}	485	}
Lines 276-282 Link Here
276	return false;	490	return false;
277	}	491	}
278	if (filter instanceof TasksFilter) {	492	if (filter instanceof TasksFilter) {
279	return showCompletedTasks == ((TasksFilter) filter).showCompletedTasks;	493	TasksFilter tasksFilter = (TasksFilter) filter;
		494	if (showCompletedTasks != tasksFilter.showCompletedTasks) {
		495	return false;
		496	}
		497	return elements.equals(tasksFilter.elements);
280	}	498	}
281	return true;	499	return true;
282	}	500	}
Lines 294-306 Link Here
294	if (!showCompletedTasks && ((AbstractTask) item).isCompleted()) {	512	if (!showCompletedTasks && ((AbstractTask) item).isCompleted()) {
295	return false;	513	return false;
296	}	514	}
		515	if (!elements.isEmpty()) {
		516	if (allTasksFromWorkingSets == null) {
		517	populateTasksFromWorkingSets();
		518	}
		519	if (!allTasksFromWorkingSets.contains(item)) {
		520	return false;
		521	}
		522	}
297	return matches(labelProvider.getText(item));	523	return matches(labelProvider.getText(item));
298	}	524	}
		525
		526	private void populateTasksFromWorkingSets() {
		527	allTasksFromWorkingSets = new HashSet<AbstractTask>(1000);
		528	for (AbstractTaskContainer container : elements) {
		529	allTasksFromWorkingSets.addAll(container.getChildren());
		530	}
		531	}
299	}	532	}
300		533
301	@Override	534	@Override
302	protected ItemsFilter createFilter() {	535	protected ItemsFilter createFilter() {
303	return new TasksFilter(showCompletedTasks);	536	return new TasksFilter(showCompletedTasks, selectedWorkingSet);
304	}	537	}
305		538
306	/**	539	/**
Lines 339-344 Link Here
339	section = settings.addNewSection(TASK_SELECTION_DIALOG_SECTION);	572	section = settings.addNewSection(TASK_SELECTION_DIALOG_SECTION);
340	section.put(OPEN_IN_BROWSER_SETTING, false);	573	section.put(OPEN_IN_BROWSER_SETTING, false);
341	section.put(SHOW_COMPLETED_TASKS_SETTING, true);	574	section.put(SHOW_COMPLETED_TASKS_SETTING, true);
		575	section.put(IS_USING_WINDOW_WORKING_SET_SETTING, true);
		576	section.put(WORKING_SET_NAME_SETTING, "");
342	}	577	}
343	return section;	578	return section;
344	}	579	}
Lines 348-353 Link Here
348	openInBrowser = settings.getBoolean(OPEN_IN_BROWSER_SETTING);	583	openInBrowser = settings.getBoolean(OPEN_IN_BROWSER_SETTING);
349	showCompletedTasks = settings.getBoolean(SHOW_COMPLETED_TASKS_SETTING);	584	showCompletedTasks = settings.getBoolean(SHOW_COMPLETED_TASKS_SETTING);
350	showCompletedTasksAction.setChecked(showCompletedTasks);	585	showCompletedTasksAction.setChecked(showCompletedTasks);
		586	boolean isUsingWindowWorkingSet = settings.getBoolean(IS_USING_WINDOW_WORKING_SET_SETTING);
		587	if (isUsingWindowWorkingSet) {
		588	selectedWorkingSet = windowWorkingSet;
		589	} else {
		590	String workingSetName = settings.get(WORKING_SET_NAME_SETTING);
		591	if (workingSetName != null) {
		592	selectedWorkingSet = PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(workingSetName);
		593	}
		594	}
351	super.restoreDialog(settings);	595	super.restoreDialog(settings);
352	}	596	}
353		597
Lines 355-360 Link Here
355	protected void storeDialog(IDialogSettings settings) {	599	protected void storeDialog(IDialogSettings settings) {
356	settings.put(OPEN_IN_BROWSER_SETTING, openInBrowser);	600	settings.put(OPEN_IN_BROWSER_SETTING, openInBrowser);
357	settings.put(SHOW_COMPLETED_TASKS_SETTING, showCompletedTasks);	601	settings.put(SHOW_COMPLETED_TASKS_SETTING, showCompletedTasks);
		602	settings.put(IS_USING_WINDOW_WORKING_SET_SETTING, selectedWorkingSet == windowWorkingSet);
		603	if (selectedWorkingSet == null) {
		604	settings.put(WORKING_SET_NAME_SETTING, "");
		605	} else {
		606	settings.put(WORKING_SET_NAME_SETTING, selectedWorkingSet.getName());
		607	}
358	super.storeDialog(settings);	608	super.storeDialog(settings);
359	}	609	}
360		610

Added Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/workingsets/WorkingSetLabelComparator.java (+25 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.workingsets;
10
11	import java.text.Collator;
12	import java.util.Comparator;
13
14	import org.eclipse.ui.IWorkingSet;
15
16	/**
17	* @author Willian Mitsuda
18	*/
19	public class WorkingSetLabelComparator implements Comparator<IWorkingSet> {
20
21	public int compare(IWorkingSet ws1, IWorkingSet ws2) {
22	return Collator.getInstance().compare(ws1.getLabel(), ws2.getLabel());
23	}
24
25	}