dlg.setMessage("&Select a task to activate (? = any character, * = any String):");

		IDialogSettings settings = TasksUiPlugin.getDefault().getDialogSettings();

		IDialogSettings dlgSettings = settings.getSection(ACTIVATE_TASK_ACTION_DIALOG_SETTINGS);

		if (dlgSettings == null) {

			dlgSettings = settings.addNewSection(ACTIVATE_TASK_ACTION_DIALOG_SETTINGS);

		}

		dlg.setDialogBoundsSettings(dlgSettings, Dialog.DIALOG_PERSISTLOCATION | Dialog.DIALOG_PERSISTSIZE);

		IDialogSettings settings = TasksUiPlugin.getDefault().getDialogSettings();

		if (dlg.open() != Window.OK) {

		IDialogSettings dlgSettings = settings.getSection(OPEN_TASK_ACTION_DIALOG_SETTINGS);

		if (dlgSettings == null) {

			dlgSettings = settings.addNewSection(OPEN_TASK_ACTION_DIALOG_SETTINGS);

		}

		dlg.setDialogBoundsSettings(dlgSettings, Dialog.DIALOG_PERSISTLOCATION | Dialog.DIALOG_PERSISTSIZE);

		dlg.setOpenInBrowser(dlgSettings.getBoolean(SHOW_IN_BROWSER_SETTING));

		int ret = dlg.open();

		dlgSettings.put(SHOW_IN_BROWSER_SETTING, dlg.getOpenInBrowser());

		if (ret != Window.OK) {

import java.util.ArrayList;

import java.util.Comparator;

import java.util.Collections;

import org.eclipse.jface.viewers.ArrayContentProvider;

import org.eclipse.jface.viewers.DecoratingLabelProvider;

import org.eclipse.jface.viewers.IOpenListener;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.mylyn.internal.tasks.ui.views.TaskActivationHistory;

import org.eclipse.jface.viewers.OpenEvent;

import org.eclipse.mylyn.internal.tasks.ui.views.TaskDetailLabelProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerComparator;

import org.eclipse.jface.viewers.ViewerFilter;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.dialogs.SelectionStatusDialog;

import org.eclipse.ui.dialogs.FilteredItemsSelectionDialog;

import org.eclipse.ui.dialogs.SearchPattern;

public class TaskSelectionDialog extends SelectionStatusDialog {

public class TaskSelectionDialog extends FilteredItemsSelectionDialog {

	private Button openInBrowserCheck;

	private static final String TASK_SELECTION_DIALOG_SECTION = "TaskSelectionDialogSection";

	private static final String OPEN_IN_BROWSER_SETTING = "OpenInBrowser";

	private static final String SHOW_COMPLETED_TASKS_SETTING = "ShowCompletedTasks";

	private boolean openInBrowser;

	public boolean getOpenInBrowser() {

		return openInBrowser;

	}

	public void setOpenInBrowser(boolean openInBrowser) {

		this.openInBrowser = openInBrowser;

	}

	 * Implements a {@link ViewFilter} based on content typed in the filter field

	 * 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 static class TaskFilter extends ViewerFilter {

	private class TaskSelectionHistory extends SelectionHistory {

		private Pattern pattern;

		/**

		 * Mylyn's task activation history

		 */

		private TaskActivationHistory history = TasksUiPlugin.getTaskListManager().getTaskActivationHistory();

		public void setFilterText(String filterText) {

		@Override

			if (filterText.trim().equals("")) {

		public synchronized void accessed(Object object) {

				pattern = null;

			history.addTask((AbstractTask) object);

			} else {

				filterText = filterText.replace("\\", "\\\\");

				filterText = filterText.replace(".", "\\.");

				filterText = filterText.replace("*", ".*");

				filterText = filterText.replace("?", ".?");

				pattern = Pattern.compile(filterText, Pattern.CASE_INSENSITIVE);

			}

		public boolean select(Viewer viewer, Object parentElement, Object element) {

		public synchronized boolean contains(Object object) {

			if (pattern == null) {

			return history.containsTask((AbstractTask) object);

				return TasksUiPlugin.getTaskListManager().getTaskActivationHistory().getPreviousTasks().contains(

						element);

			}

			if (element instanceof AbstractTask) {

				AbstractTask repositoryTask = (AbstractTask) element;

				String taskString = repositoryTask.getTaskKey() + ": " + repositoryTask.getSummary();

				return pattern.matcher(taskString).find();

			} else if (element instanceof AbstractTask) {

				String taskString = ((AbstractTask) element).getSummary();

				return pattern.matcher(taskString).find();

			}

			return false;

	private TableViewer viewer;

		@Override

		public synchronized boolean remove(Object object) {

			return history.removeTask((AbstractTask) object);

		}

		@Override

		public synchronized boolean isEmpty() {

			return !history.hasPrevious();

		}

	private Button openInBrowserCheck;

		@Override

		public void load(IMemento memento) {

			// do nothing because tasklist history handles this

		}

	private boolean openInBrowser;

		@Override

		public void save(IMemento memento) {

			// do nothing because tasklist history handles this

		}

	public boolean getOpenInBrowser() {

		@Override

		return openInBrowser;

		protected Object restoreItemFromMemento(IMemento memento) {

	}

			// do nothing because tasklist history handles this

			return null;

		}

	public void setOpenInBrowser(boolean openInBrowser) {

		@Override

		this.openInBrowser = openInBrowser;

		protected void storeItemToMemento(Object item, IMemento memento) {

			// do nothing because tasklist history handles this

		}

		@Override

		public synchronized Object[] getHistoryItems() {

			return history.getPreviousTasks().toArray();

		}

		setShellStyle(getShellStyle() | SWT.RESIZE);

		setSelectionHistory(new TaskSelectionHistory());

		labelProvider = new TaskElementLabelProvider(true);

		setListLabelProvider(new DecoratingLabelProvider(labelProvider, PlatformUI.getWorkbench()

				.getDecoratorManager()

				.getLabelDecorator()));

		setDetailsLabelProvider(new TaskDetailLabelProvider());

		setSeparatorLabel("Task list 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();

			int n = text.indexOf('\n');

			if (n > -1) {

				text.substring(0, n);

			}

			setInitialPattern(text);

		}

	protected Control createDialogArea(Composite parent) {

	protected void fillViewMenu(IMenuManager menuManager) {

		Composite area = (Composite) super.createDialogArea(parent);

		super.fillViewMenu(menuManager);

		menuManager.add(showCompletedTasksAction);

	}

		Label message = new Label(area, SWT.NONE);

	private boolean showCompletedTasks;

		message.setText("&Select a task to open (? = any character, * = any String):");

		final Text filterText = new Text(area, SWT.SINGLE | SWT.BORDER);

		filterText.setLayoutData(new GridData(SWT.FILL, SWT.DEFAULT, true, false));

		Label matches = new Label(area, SWT.NONE);

		matches.setText("&Matching tasks:");

		viewer = new TableViewer(area, SWT.SINGLE | SWT.BORDER);

		Control control = viewer.getControl();

		GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);

		control.setLayoutData(gd);

		gd.widthHint = 400;

		gd.heightHint = 200;

		if (showOpenInBrowserOption) {

			openInBrowserCheck = new Button(area, SWT.CHECK);

			openInBrowserCheck.setText("Open with &Browser");

			openInBrowserCheck.setSelection(openInBrowser);

		}

		final TaskElementLabelProvider labelProvider = new TaskElementLabelProvider(true);

		viewer.setLabelProvider(labelProvider);

		viewer.setContentProvider(new ArrayContentProvider());

		// Compute all existing tasks or query hits (if corresponding task does

		// not exist yet...)

		Set<AbstractTaskContainer> allTasks = new HashSet<AbstractTaskContainer>();

		TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();

		allTasks.addAll(taskList.getAllTasks());

		for (AbstractRepositoryQuery query : taskList.getQueries()) {

			allTasks.addAll(query.getChildren());

		}

		// Compute the task navigation history (in recent-to-older order)

		final List<AbstractTask> taskHistory = new ArrayList<AbstractTask>(TasksUiPlugin.getTaskListManager()

				.getTaskActivationHistory()

				.getPreviousTasks());

		Collections.reverse(taskHistory);

		// Compute the task set who will be presented on dialog; the trick to

		// make the task history appear first on the list is to add them before

		// all other tasks; being a LinkedHashSet, it will not be duplicated

		// (this is VERY IMPORTANT)

		Set<AbstractTaskContainer> taskSet = new LinkedHashSet<AbstractTaskContainer>(taskHistory);

		taskSet.addAll(allTasks);

		viewer.setInput(taskSet);

		final TaskSelectionDialog.TaskFilter filter = new TaskSelectionDialog.TaskFilter();

		viewer.addFilter(filter);

		viewer.setComparator(new ViewerComparator() {

			private AbstractTask getCorrespondingTask(Object o) {

				if (o instanceof AbstractTask) {

					return (AbstractTask) o;

				}

				return null;

			}

			@Override

	private class ShowCompletedTasksAction extends Action {

			public int compare(Viewer viewer, Object e1, Object e2) {

				AbstractTask t1 = getCorrespondingTask(e1);

				AbstractTask t2 = getCorrespondingTask(e2);

				boolean isInHistory1 = taskHistory.contains(t1);

				boolean isInHistory2 = taskHistory.contains(t2);

				// Being on task history takes precedence...

				if (isInHistory1 && !isInHistory2) {

					return -1;

				}

				if (!isInHistory1 && isInHistory2) {

					return 1;

				}

				// Both are in task history; who is more recent?

				if (isInHistory1 && isInHistory2) {

					return taskHistory.indexOf(t1) - taskHistory.indexOf(t2);

				}

				// Both are not in task history; sort by summary...

		public ShowCompletedTasksAction() {

				return labelProvider.getText(e1).compareTo(labelProvider.getText(e2));

			super("Show &Completed Tasks", IAction.AS_CHECK_BOX);

			}

		}

		});

		@Override

		viewer.addOpenListener(new IOpenListener() {

		public void run() {

			showCompletedTasks = isChecked();

			applyFilter();

		}

			public void open(OpenEvent event) {

	}

				if (getOkButton().getEnabled()) {

					okPressed();

				}

			}

		});

	@Override

	protected Control createExtendedContentArea(Composite parent) {

		if (!showOpenInBrowserOption) {

			return null;

		}

		filterText.addKeyListener(new KeyAdapter() {

		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("Open with &Browser");

		openInBrowserCheck.setSelection(openInBrowser);

			@Override

		return composite;

			public void keyPressed(KeyEvent e) {

	}

				if (e.keyCode == SWT.ARROW_DOWN) {

					viewer.getControl().setFocus();

	@Override

				}

	public boolean close() {

			}

		if (openInBrowserCheck != null) {

			openInBrowser = openInBrowserCheck.getSelection();

		}

		return super.close();

	}

		});

	private class TasksFilter extends ItemsFilter {

		filterText.addModifyListener(new ModifyListener() {

			public void modifyText(ModifyEvent e) {

		private boolean showCompletedTasks;

				filter.setFilterText(filterText.getText());

				viewer.refresh(false);

		public TasksFilter(boolean showCompletedTasks) {

				Object first = viewer.getElementAt(0);

			super(new SearchPattern());

				if (first != null) {

			// Little hack to force always a match inside any part of task text

					viewer.setSelection(new StructuredSelection(first));

			patternMatcher.setPattern("*" + patternMatcher.getPattern());

				}

			this.showCompletedTasks = showCompletedTasks;

		}

		@Override

		public boolean isSubFilter(ItemsFilter filter) {

			if (!super.isSubFilter(filter)) {

				return false;

		});

		@Override

		IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();

		public boolean equalsFilter(ItemsFilter filter) {

		ISelection selection = window.getSelectionService().getSelection();

			if (!super.equalsFilter(filter)) {

		if (selection instanceof ITextSelection) {

				return false;

			String text = ((ITextSelection) selection).getText();

			}

			int n = text.indexOf('\n');

			if (filter instanceof TasksFilter) {

			if (n > -1) {

				return showCompletedTasks == ((TasksFilter) filter).showCompletedTasks;

				text.substring(0, n);

			}

			return true;

		}

		@Override

		public boolean isConsistentItem(Object item) {

			return item instanceof AbstractTask;

		}

		@Override

		public boolean matchItem(Object item) {

			if (!(item instanceof AbstractTask)) {

				return false;

			filterText.setText(text);

			if (!showCompletedTasks && ((AbstractTask) item).isCompleted()) {

			filterText.setSelection(0, text.length());

				return false;

			}

			return matches(labelProvider.getText(item));

		}

	}

	@Override

	protected ItemsFilter createFilter() {

		return new TasksFilter(showCompletedTasks);

	}

	/**

	 * Caches all tasks; populated at first access

	 */

	private Set<AbstractTask> allTasks;

	@Override

	protected void fillContentProvider(AbstractContentProvider contentProvider, ItemsFilter itemsFilter,

			IProgressMonitor progressMonitor) throws CoreException {

		progressMonitor.beginTask("Search for tasks", 100);

		if (allTasks == null) {

			allTasks = new HashSet<AbstractTask>();

			TaskList taskList = TasksUiPlugin.getTaskListManager().getTaskList();

			allTasks.addAll(taskList.getAllTasks());

		return area;

		SubProgressMonitor subMonitor = new SubProgressMonitor(progressMonitor, 90);

		subMonitor.beginTask("Scanning tasks", allTasks.size());

		for (AbstractTask task : allTasks) {

			contentProvider.add(task, itemsFilter);

			subMonitor.worked(1);

		}

		subMonitor.done();

		progressMonitor.done();

	protected void computeResult() {

	protected IDialogSettings getDialogSettings() {

		setResult(((IStructuredSelection) viewer.getSelection()).toList());

		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);

		}

		return section;

	public boolean close() {

	protected void restoreDialog(IDialogSettings settings) {

		if (openInBrowserCheck != null) {

		openInBrowser = settings.getBoolean(OPEN_IN_BROWSER_SETTING);

			openInBrowser = openInBrowserCheck.getSelection();

		showCompletedTasks = settings.getBoolean(SHOW_COMPLETED_TASKS_SETTING);

		showCompletedTasksAction.setChecked(showCompletedTasks);

		super.restoreDialog(settings);

	}

	@Override

	protected void storeDialog(IDialogSettings settings) {

		settings.put(OPEN_IN_BROWSER_SETTING, openInBrowser);

		settings.put(SHOW_COMPLETED_TASKS_SETTING, showCompletedTasks);

		super.storeDialog(settings);

	}

	@Override

	public String getElementName(Object item) {

		return labelProvider.getText(item);

	}

	/**

	 * Sort tasks by summary

	 */

	@SuppressWarnings("unchecked")

	@Override

	protected Comparator getItemsComparator() {

		return new Comparator() {

			public int compare(Object o1, Object o2) {

				return labelProvider.getText(o1).compareTo(labelProvider.getText(o2));

			}

		};

	}

	@Override

	protected IStatus validateItem(Object item) {

		if (item instanceof AbstractTask) {

			return Status.OK_STATUS;

		return super.close();

		return new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, "Selected item is not a task");

		return history;

		return Collections.unmodifiableList(history);

		IDialogSettings settings = TasksUiPlugin.getDefault().getDialogSettings();

		if (dialog.open() != Window.OK) {

		IDialogSettings dlgSettings = settings.getSection(OPEN_TASK_ACTION_DIALOG_SETTINGS);

		if (dlgSettings == null) {

			dlgSettings = settings.addNewSection(OPEN_TASK_ACTION_DIALOG_SETTINGS);

		}

		dialog.setDialogBoundsSettings(dlgSettings, Dialog.DIALOG_PERSISTLOCATION | Dialog.DIALOG_PERSISTSIZE);

		int ret = dialog.open();

		if (ret != Window.OK) {