org.eclipse.mylyn.tasks.ui/src/org/eclipse/mylyn/internal/tasks/ui/actions/TaskSelectionDialog.java

/*******************************************************************************
 * Copyright (c) 2004, 2013 Willian Mitsuda and others.
 * 
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * https://www.eclipse.org/legal/epl-2.0
 * 
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Willian Mitsuda - initial API and implementation
 *     Tasktop Technologies - improvements
 *     Eugene Kuleshov - improvements
 *     Benjamin Muskalla - fix for bug 291992
 *******************************************************************************/

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
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.IDialogConstants;
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.commons.ui.compatibility.CommonColors;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.TaskActivationHistory;
import org.eclipse.mylyn.internal.tasks.core.TaskList;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.search.SearchUtil;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskDetailLabelProvider;
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.ITask;
import org.eclipse.mylyn.tasks.core.ITaskContainer;
import org.eclipse.mylyn.tasks.ui.TaskElementLabelProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
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;
import org.eclipse.ui.forms.widgets.ImageHyperlink;

import com.google.common.base.Strings;

/**
 * @author Willian Mitsuda
 * @author Mik Kersten
 * @author Eugene Kuleshov
 * @author Shawn Minto
 */
public class TaskSelectionDialog extends FilteredItemsSelectionDialog {

	private class DeselectWorkingSetAction extends Action {

		public DeselectWorkingSetAction() {
			super(Messages.TaskSelectionDialog_Deselect_Working_Set, IAction.AS_PUSH_BUTTON);
		}

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

	private class EditWorkingSetAction extends Action {

		public EditWorkingSetAction() {
			super(Messages.TaskSelectionDialog_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 final IWorkingSet workingSet;

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

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

	private class SelectWorkingSetAction extends Action {

		public SelectWorkingSetAction() {
			super(Messages.TaskSelectionDialog_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 ShowCompletedTasksAction extends Action {

		public ShowCompletedTasksAction() {
			super(Messages.TaskSelectionDialog_Show_Completed_Tasks, IAction.AS_CHECK_BOX);
		}

		@Override
		public void run() {
			showCompletedTasks = isChecked();
			applyFilter();
		}

	}

	private class TaskHistoryItemsComparator implements Comparator<Object> {

		Map<AbstractTask, Integer> positionByTask = new HashMap<AbstractTask, Integer>();

		public TaskHistoryItemsComparator(List<AbstractTask> history) {
			for (int i = 0; i < history.size(); i++) {
				positionByTask.put(history.get(i), i);
			}
		}

		public int compare(Object o1, Object o2) {
			Integer p1 = positionByTask.get(o1);
			Integer p2 = positionByTask.get(o2);
			if (p1 != null && p2 != null) {
				return p2.compareTo(p1);
			}
			return labelProvider.getText(o1).compareTo(labelProvider.getText(o2));
		}

	}

	/**
	 * Integrates {@link FilteredItemsSelectionDialog} history management with Mylyn's task list activation history
	 * <p>
	 * Due to {@link SelectionHistory} use of memento-based history storage, many methods are overridden
	 */
	private class TaskSelectionHistory extends SelectionHistory {

		@Override
		public synchronized void accessed(Object object) {
			// ignore, handled by TaskActivationHistory
		}

		@Override
		public synchronized boolean contains(Object object) {
			return history.contains(object);
		}

		@Override
		public synchronized Object[] getHistoryItems() {
			return history.toArray();
		}

		@Override
		public synchronized boolean isEmpty() {
			return history.isEmpty();
		}

		@Override
		public void load(IMemento memento) {
			// do nothing because tasklist history handles this
		}

		@Override
		public synchronized boolean remove(Object object) {
			taskActivationHistory.removeTask((ITask) object);
			return history.remove(object);
		}

		@Override
		protected Object restoreItemFromMemento(IMemento memento) {
			// do nothing because tasklist history handles this
			return null;
		}

		@Override
		public void save(IMemento memento) {
			// do nothing because tasklist history handles this
		}

		@Override
		protected void storeItemToMemento(Object item, IMemento memento) {
			// do nothing because tasklist history handles this
		}
	}

	/**
	 * Supports filtering of completed tasks.
	 */
	private class TasksFilter extends ItemsFilter {

		private Set<ITask> allTasksFromWorkingSets;

		/**
		 * 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 final boolean showCompletedTasks;

		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()); //$NON-NLS-1$
			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
		public boolean equalsFilter(ItemsFilter filter) {
			if (!super.equalsFilter(filter)) {
				return false;
			}
			if (filter instanceof TasksFilter) {
				TasksFilter tasksFilter = (TasksFilter) filter;
				if (showCompletedTasks != tasksFilter.showCompletedTasks) {
					return false;
				}
				return elements.equals(tasksFilter.elements);
			}
			return true;
		}

		@Override
		public boolean isConsistentItem(Object item) {
			return item instanceof ITask;
		}

		@Override
		public boolean isSubFilter(ItemsFilter filter) {
			if (!super.isSubFilter(filter)) {
				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;
		}

		@Override
		public boolean matchItem(Object item) {
			if (!(item instanceof ITask)) {
				return false;
			}
			if (!showCompletedTasks && ((ITask) 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<ITask>(1000);
			for (ITaskContainer container : elements) {
				allTasksFromWorkingSets.addAll(container.getChildren());
			}
		}
	}

	private static final int SEARCH_ID = IDialogConstants.CLIENT_ID + 1;

	private static final int CREATE_ID = SEARCH_ID + 1;

	private static final String IS_USING_WINDOW_WORKING_SET_SETTING = "IsUsingWindowWorkingSet"; //$NON-NLS-1$

	private static final String OPEN_IN_BROWSER_SETTING = "OpenInBrowser"; //$NON-NLS-1$

	private static final String SHOW_COMPLETED_TASKS_SETTING = "ShowCompletedTasks"; //$NON-NLS-1$

	private static final String TASK_SELECTION_DIALOG_SECTION = "TaskSelectionDialogSection"; //$NON-NLS-1$

	private static final String WORKING_SET_NAME_SETTING = "WorkingSetName"; //$NON-NLS-1$

	/**
	 * Caches all tasks; populated at first access
	 */
	private Set<AbstractTask> allTasks;

	private Button createTaskButton;

	/**
	 * Mylyn's task activation history
	 */
	private final LinkedHashSet<AbstractTask> history;

	private final TaskHistoryItemsComparator itemsComparator;

	private final TaskElementLabelProvider labelProvider;

	private boolean needsCreateTask;

	private boolean openInBrowser;

	private Button openInBrowserCheck;

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

	private boolean showCompletedTasks;

	private final ShowCompletedTasksAction showCompletedTasksAction;

	private boolean showExtendedOpeningOptions;

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

	/**
	 * Refilters if the current working set content has changed
	 */
	private final 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 final TaskActivationHistory taskActivationHistory;

	public TaskSelectionDialog(Shell parent) {
		this(parent, false);
	}

	public TaskSelectionDialog(Shell parent, boolean multi) {
		super(parent, multi);
		this.taskActivationHistory = TasksUiPlugin.getTaskActivityManager().getTaskActivationHistory();
		this.history = new LinkedHashSet<AbstractTask>(taskActivationHistory.getPreviousTasks());
		this.itemsComparator = new TaskHistoryItemsComparator(new ArrayList<AbstractTask>(history));
		this.needsCreateTask = true;
		this.labelProvider = new TaskElementLabelProvider(false);
		this.showCompletedTasksAction = new ShowCompletedTasksAction();

		setSelectionHistory(new TaskSelectionHistory());
		setListLabelProvider(labelProvider);

		setDetailsLabelProvider(new TaskDetailLabelProvider());
		setSeparatorLabel(TaskListView.LABEL_VIEW + Messages.TaskSelectionDialog__matches);

		// If there is a text selection, use it as the initial filter
		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
		ISelection selection = window.getSelectionService().getSelection();
		if (selection instanceof ITextSelection) {
			// Get only get first line
			String text = ((ITextSelection) selection).getText();
			text = Strings.nullToEmpty(text);
			int n = text.indexOf('\n');
			if (n > -1) {
				text = text.substring(0, n);
			}
			setInitialPattern(text);
		}

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

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

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

	@Override
	protected Control createButtonBar(Composite parent) {
		Composite composite = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.numColumns = 0; // create
		layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
		layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
		layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
		layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);

		composite.setLayout(layout);
		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		// create help control if needed
		if (isHelpAvailable()) {
			createHelpControl(composite);
		}
		if (needsCreateTask) {
			createTaskButton = createButton(composite, CREATE_ID, Messages.TaskSelectionDialog_New_Task_, true);
			createTaskButton.addSelectionListener(new SelectionListener() {

				public void widgetDefaultSelected(SelectionEvent e) {
					// ignore
				}

				public void widgetSelected(SelectionEvent e) {
					close();
					new NewTaskAction().run();
				}
			});
		}

		createAdditionalButtons(composite);

		Label filler = new Label(composite, SWT.NONE);
		filler.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
		layout.numColumns++;
		super.createButtonsForButtonBar(composite); // cancel button

		return composite;
	}

	/**
	 * Allows to add new buttons at the bottom of this dialog next to New Task button
	 *
	 * @param parent
	 *            the parent composite to contain the button bar
	 */
	protected void createAdditionalButtons(Composite parent) {
		// we don't want to add any new button
	}

	@Override
	protected Control createExtendedContentArea(Composite parent) {
		if (!showExtendedOpeningOptions) {
			return null;
		}

		Composite composite = new Composite(parent, SWT.NONE);
		composite.setLayout(GridLayoutFactory.swtDefaults().margins(0, 5).create());
		composite.setLayoutData(GridDataFactory.fillDefaults().create());

		openInBrowserCheck = new Button(composite, SWT.CHECK);
		openInBrowserCheck.setText(Messages.TaskSelectionDialog_Open_with_Browser);
		openInBrowserCheck.setSelection(openInBrowser);

		if (SearchUtil.supportsTaskSearch()) {
			ImageHyperlink openHyperlink = new ImageHyperlink(composite, SWT.NONE);
			openHyperlink.setText(TaskListFilteredTree.LABEL_SEARCH);
			openHyperlink.setForeground(CommonColors.HYPERLINK_WIDGET);
			openHyperlink.setUnderlined(true);
			openHyperlink.addHyperlinkListener(new HyperlinkAdapter() {

				@Override
				public void linkActivated(HyperlinkEvent e) {
					getShell().close();
					SearchUtil.openSearchDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow());
				}

			});
		}
		return composite;
	}

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

	@Override
	protected void fillContentProvider(AbstractContentProvider contentProvider, ItemsFilter itemsFilter,
			IProgressMonitor progressMonitor) throws CoreException {
		progressMonitor.beginTask(Messages.TaskSelectionDialog_Search_for_tasks, 100);

		if (allTasks == null) {
			allTasks = new HashSet<AbstractTask>();
			TaskList taskList = TasksUiPlugin.getTaskList();
			allTasks.addAll(taskList.getAllTasks());
		}
		progressMonitor.worked(10);

		SubProgressMonitor subMonitor = new SubProgressMonitor(progressMonitor, 90);
		subMonitor.beginTask(Messages.TaskSelectionDialog_Scanning_tasks, allTasks.size());
		for (ITask task : allTasks) {
			contentProvider.add(task, itemsFilter);
			subMonitor.worked(1);
		}
		subMonitor.done();

		progressMonitor.done();
	}

	@Override
	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")); //$NON-NLS-1$
		final FilterWorkingSetAction windowWorkingSetAction = new FilterWorkingSetAction(windowWorkingSet, 1);
		menuManager.add(windowWorkingSetAction);

		menuManager.addMenuListener(new IMenuListener() {

			private final 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); //$NON-NLS-1$
					}
				}
				windowWorkingSetAction.setChecked(windowWorkingSet.equals(selectedWorkingSet));
			}

		});
	}

	@Override
	protected IDialogSettings getDialogSettings() {
		IDialogSettings settings = TasksUiPlugin.getDefault().getDialogSettings();
		IDialogSettings section = settings.getSection(TASK_SELECTION_DIALOG_SECTION);
		if (section == null) {
			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, ""); //$NON-NLS-1$
		}
		return section;
	}

	@Override
	public String getElementName(Object item) {
		return labelProvider.getText(item);
	}

	/**
	 * Sort tasks by summary
	 */
	@SuppressWarnings("rawtypes")
	@Override
	protected Comparator getItemsComparator() {
		return itemsComparator;
	}

	public boolean getOpenInBrowser() {
		return openInBrowser;
	}

	public boolean getShowExtendedOpeningOptions() {
		return showExtendedOpeningOptions;
	}

	public boolean needsCreateTask() {
		return needsCreateTask;
	}

	@Override
	protected void restoreDialog(IDialogSettings settings) {
		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);
	}

	public void setNeedsCreateTask(boolean value) {
		needsCreateTask = value;
	}

	public void setOpenInBrowser(boolean openInBrowser) {
		this.openInBrowser = openInBrowser;
	}

	/**
	 * 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();
	}

	public void setShowExtendedOpeningOptions(boolean showExtendedOpeningOptions) {
		this.showExtendedOpeningOptions = showExtendedOpeningOptions;
	}

	@Override
	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, ""); //$NON-NLS-1$
		} else {
			settings.put(WORKING_SET_NAME_SETTING, selectedWorkingSet.getName());
		}
		super.storeDialog(settings);
	}

	@Override
	protected IStatus validateItem(Object item) {
		if (item instanceof ITask) {
			return Status.OK_STATUS;
		}
		return new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
				Messages.TaskSelectionDialog_Selected_item_is_not_a_task);
	}

}