/*******************************************************************************
* Copyright (c) 2004, 2016 Tasktop Technologies 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
*
* Contributors:
* Tasktop Technologies - initial API and implementation
* Ken Sueda - improvements
* Eugene Kuleshov - improvements
* Frank Becker - improvements
*******************************************************************************/
package org.eclipse.mylyn.internal.tasks.ui.views;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Set;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.layout.TreeColumnLayout;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.LocalSelectionTransfer;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ColumnPixelData;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.commons.ui.PlatformUiUtil;
import org.eclipse.mylyn.commons.ui.compatibility.CommonThemes;
import org.eclipse.mylyn.commons.workbench.GradientDrawer;
import org.eclipse.mylyn.internal.commons.notifications.feed.ServiceMessage;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
import org.eclipse.mylyn.internal.tasks.ui.AbstractTaskListFilter;
import org.eclipse.mylyn.internal.tasks.ui.CategorizedPresentation;
import org.eclipse.mylyn.internal.tasks.ui.ITasksUiPreferenceConstants;
import org.eclipse.mylyn.internal.tasks.ui.MyTasksFilter;
import org.eclipse.mylyn.internal.tasks.ui.ScheduledPresentation;
import org.eclipse.mylyn.internal.tasks.ui.TaskArchiveFilter;
import org.eclipse.mylyn.internal.tasks.ui.TaskCompletionFilter;
import org.eclipse.mylyn.internal.tasks.ui.TaskPriorityFilter;
import org.eclipse.mylyn.internal.tasks.ui.TaskRepositoryUtil;
import org.eclipse.mylyn.internal.tasks.ui.TaskReviewArtifactFilter;
import org.eclipse.mylyn.internal.tasks.ui.TaskWorkingSetFilter;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.actions.CollapseAllAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.ExpandAllAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.FilterCompletedTasksAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.FilterMyTasksAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.GoUpAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.GroupSubTasksAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.LinkWithEditorAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.NewTaskAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.OpenTasksUiPreferencesAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.PresentationDropDownSelectionAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.ShowAllQueriesAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.ShowNonMatchingSubtasksAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.SynchronizeAutomaticallyAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.TaskListSortAction;
import org.eclipse.mylyn.internal.tasks.ui.actions.TaskListViewActionGroup;
import org.eclipse.mylyn.internal.tasks.ui.notifications.TaskListServiceMessageControl;
import org.eclipse.mylyn.internal.tasks.ui.search.AbstractSearchHandler;
import org.eclipse.mylyn.internal.tasks.ui.search.SearchUtil;
import org.eclipse.mylyn.internal.tasks.ui.util.TaskDragSourceListener;
import org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal;
import org.eclipse.mylyn.tasks.core.IRepositoryElement;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITask.PriorityLevel;
import org.eclipse.mylyn.tasks.core.ITaskActivationListener;
import org.eclipse.mylyn.tasks.core.ITaskActivityListener;
import org.eclipse.mylyn.tasks.core.ITaskContainer;
import org.eclipse.mylyn.tasks.core.TaskActivationAdapter;
import org.eclipse.mylyn.tasks.core.TaskActivityAdapter;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.ITasksUiConstants;
import org.eclipse.mylyn.tasks.ui.TaskElementLabelProvider;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditorInput;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTError;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.FileTransfer;
import org.eclipse.swt.dnd.RTFTransfer;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.dnd.URLTransfer;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPageListener;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.ISizeProvider;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.contexts.IContextService;
import org.eclipse.ui.handlers.CollapseAllHandler;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.part.DrillDownAdapter;
import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.IShowInTarget;
import org.eclipse.ui.part.IShowInTargetList;
import org.eclipse.ui.part.ShowInContext;
import org.eclipse.ui.progress.IWorkbenchSiteProgressService;
import org.eclipse.ui.themes.IThemeManager;
/**
* @author Mik Kersten
* @author Ken Sueda
* @author Eugene Kuleshov
* @author David Green
*/
public class TaskListView extends AbstractTaskListView implements IPropertyChangeListener, IShowInTarget {
private static final String ID_SEPARATOR_FILTERS = "filters"; //$NON-NLS-1$
private static final String ID_SEPARATOR_SEARCH = "search"; //$NON-NLS-1$
private static final String ID_SEPARATOR_TASKS = "tasks"; //$NON-NLS-1$
private static final String ID_SEPARATOR_CONTEXT = "context"; //$NON-NLS-1$
/**
* @deprecated Use {@link ITasksUiConstants#ID_VIEW_TASKS} instead
*/
@Deprecated
public static final String ID = ITasksUiConstants.ID_VIEW_TASKS;
public static final String LABEL_VIEW = Messages.TaskListView_Task_List;
private static final String MEMENTO_SORTER = "sorter"; //$NON-NLS-1$
private static final String MEMENTO_LINK_WITH_EDITOR = "linkWithEditor"; //$NON-NLS-1$
private static final String MEMENTO_PRESENTATION = "presentation"; //$NON-NLS-1$
private static final String LABEL_NO_TASKS = "no task active"; //$NON-NLS-1$
private final static int SIZE_MAX_SELECTION_HISTORY = 10;
static final String[] PRIORITY_LEVELS = { PriorityLevel.P1.toString(), PriorityLevel.P2.toString(),
PriorityLevel.P3.toString(), PriorityLevel.P4.toString(), PriorityLevel.P5.toString() };
public static final String[] PRIORITY_LEVEL_DESCRIPTIONS = { PriorityLevel.P1.getDescription(),
PriorityLevel.P2.getDescription(), PriorityLevel.P3.getDescription(), PriorityLevel.P4.getDescription(),
PriorityLevel.P5.getDescription() };
private static List<AbstractTaskListPresentation> presentationsPrimary = new ArrayList<AbstractTaskListPresentation>();
private static List<AbstractTaskListPresentation> presentationsSecondary = new ArrayList<AbstractTaskListPresentation>();
private boolean focusedMode;
private boolean linkWithEditor;
private final TaskListCellModifier taskListCellModifier = new TaskListCellModifier(this);
private IThemeManager themeManager;
private TaskListFilteredTree filteredTree;
private org.eclipse.mylyn.commons.ui.SelectionProviderAdapter selectionProvider;
private DrillDownAdapter drillDownAdapter;
private AbstractTaskContainer drilledIntoCategory;
private CollapseAllAction collapseAll;
private ExpandAllAction expandAll;
private FilterCompletedTasksAction filterCompleteTask;
private FilterMyTasksAction filterMyTasksAction;
private GroupSubTasksAction groupSubTasksAction;
private SynchronizeAutomaticallyAction synchronizeAutomatically;
private OpenTasksUiPreferencesAction openPreferencesAction;
private PriorityDropDownAction filterOnPriorityAction;
private TaskListSortAction sortDialogAction;
private NewTaskAction newTaskAction;
private LinkWithEditorAction linkWithEditorAction;
private final PresentationDropDownSelectionAction presentationDropDownSelectionAction = new PresentationDropDownSelectionAction(
this);
private ShowNonMatchingSubtasksAction showNonMatchingSubtasksAction;
private final TaskPriorityFilter filterPriority = new TaskPriorityFilter();
private final TaskCompletionFilter filterComplete = new TaskCompletionFilter();
private final TaskArchiveFilter filterArchive = new TaskArchiveFilter();
private final TaskReviewArtifactFilter filterArtifact = new TaskReviewArtifactFilter();
private final PresentationFilter filterPresentation = PresentationFilter.getInstance();
private final MyTasksFilter filterMyTasks = new MyTasksFilter();
private TaskWorkingSetFilter filterWorkingSet;
private final Set<AbstractTaskListFilter> filters = new HashSet<AbstractTaskListFilter>();
protected String[] columnNames = new String[] { Messages.TaskListView_Summary };
protected int[] columnWidths = new int[] { 200 };
private TreeColumn[] columns;
private IMemento taskListMemento;
private AbstractTaskListPresentation currentPresentation;
private TaskTableLabelProvider taskListTableLabelProvider;
private TaskListSorter tableSorter;
private TaskListViewActionGroup actionGroup;
private CustomTaskListDecorationDrawer customDrawer;
private TaskListServiceMessageControl serviceMessageControl;
private long lastExpansionTime;
private final IPageListener PAGE_LISTENER = new IPageListener() {
public void pageActivated(IWorkbenchPage page) {
filteredTree.indicateActiveTaskWorkingSet();
}
public void pageClosed(IWorkbenchPage page) {
// ignore
}
public void pageOpened(IWorkbenchPage page) {
// ignore
}
};
private final LinkedHashMap<String, IStructuredSelection> lastSelectionByTaskHandle = new LinkedHashMap<String, IStructuredSelection>(
SIZE_MAX_SELECTION_HISTORY);
/**
* True if the view should indicate that interaction monitoring is paused
*/
protected boolean isPaused = false;
private final ITaskActivityListener TASK_ACTIVITY_LISTENER = new TaskActivityAdapter() {
@Override
public void activityReset() {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
refreshJob.refresh();
}
});
}
};
private final ITaskActivationListener TASK_ACTIVATION_LISTENER = new TaskActivationAdapter() {
@Override
public void taskActivated(final ITask task) {
if (task != null) {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
updateDescription();
refresh(task);
selectedAndFocusTask(task);
filteredTree.indicateActiveTask(task);
}
});
}
}
@Override
public void taskDeactivated(final ITask task) {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
refresh(task);
updateDescription();
filteredTree.indicateNoActiveTask();
}
});
}
private void refresh(final ITask task) {
if (TaskListView.this.isScheduledPresentation()) {
refreshJob.refresh();
} else {
refreshJob.refreshElement(task);
}
}
};
private final IPropertyChangeListener THEME_CHANGE_LISTENER = new IPropertyChangeListener() {
public void propertyChange(PropertyChangeEvent event) {
if (event.getProperty().equals(IThemeManager.CHANGE_CURRENT_THEME)
|| CommonThemes.isCommonTheme(event.getProperty())) {
taskListTableLabelProvider.setCategoryBackgroundColor(
themeManager.getCurrentTheme().getColorRegistry().get(CommonThemes.COLOR_CATEGORY));
getViewer().refresh();
}
}
};
private final IPropertyChangeListener tasksUiPreferenceListener = new IPropertyChangeListener() {
public void propertyChange(PropertyChangeEvent event) {
if (ITasksUiPreferenceConstants.TASK_LIST_TOOL_TIPS_ENABLED.equals(event.getProperty())) {
updateTooltipEnablement();
}
if (event.getProperty().equals(ITasksUiPreferenceConstants.USE_STRIKETHROUGH_FOR_COMPLETED)
|| event.getProperty().equals(ITasksUiPreferenceConstants.OVERLAYS_INCOMING_TIGHT)) {
refreshJob.refresh();
}
if (event.getProperty().equals(ITasksUiPreferenceConstants.FILTER_HIDDEN)
|| event.getProperty().equals(ITasksUiPreferenceConstants.FILTER_NON_MATCHING)
|| event.getProperty().equals(ITasksUiPreferenceConstants.GROUP_SUBTASKS)) {
filterPresentation.updateSettings();
refresh(true);
if (showNonMatchingSubtasksAction != null) {
showNonMatchingSubtasksAction.update();
}
}
}
};
private TaskListToolTip taskListToolTip;
public static TaskListView getFromActivePerspective() {
if (PlatformUI.isWorkbenchRunning()) {
IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (activeWorkbenchWindow != null) {
IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage();
if (activePage != null) {
IViewPart view = activePage.findView(ITasksUiConstants.ID_VIEW_TASKS);
if (view instanceof TaskListView) {
return (TaskListView) view;
}
}
}
}
return null;
}
private static boolean initializedSynchronization;
public TaskListView() {
if (!initializedSynchronization) {
initializedSynchronization = true;
// trigger additional initialization when task list is first made visible.
TasksUiPlugin.getDefault().initializeNotificationsAndSynchronization();
}
}
@Override
public void dispose() {
super.dispose();
if (actionGroup != null) {
actionGroup.dispose();
}
TasksUiPlugin.getDefault().getServiceMessageManager().removeServiceMessageListener(serviceMessageControl);
TasksUiPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(tasksUiPreferenceListener);
if (refreshJob != null) {
refreshJob.dispose();
}
TasksUiPlugin.getTaskActivityManager().removeActivityListener(TASK_ACTIVITY_LISTENER);
TasksUiPlugin.getTaskActivityManager().removeActivationListener(TASK_ACTIVATION_LISTENER);
PlatformUI.getWorkbench().getWorkingSetManager().removePropertyChangeListener(this);
if (PlatformUI.getWorkbench().getActiveWorkbenchWindow() != null) {
PlatformUI.getWorkbench().getActiveWorkbenchWindow().removePageListener(PAGE_LISTENER);
}
final IThemeManager themeManager = getSite().getWorkbenchWindow().getWorkbench().getThemeManager();
if (themeManager != null) {
themeManager.removePropertyChangeListener(THEME_CHANGE_LISTENER);
}
if (editorListener != null) {
getSite().getPage().removePartListener(editorListener);
}
if (searchHandler != null) {
searchHandler.dispose();
}
}
private void updateDescription() {
ITask task = TasksUi.getTaskActivityManager().getActiveTask();
if (getSite() == null || getSite().getPage() == null) {
return;
}
IViewReference reference = getSite().getPage().findViewReference(ITasksUiConstants.ID_VIEW_TASKS);
boolean shouldSetDescription = false;
if (reference != null && reference.isFastView() && !getSite().getPage().isPartVisible(this)) {
shouldSetDescription = true;
}
if (task != null) {
setTitleToolTip(LABEL_VIEW + " (" + task.getSummary() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
if (shouldSetDescription) {
setContentDescription(task.getSummary());
} else {
setContentDescription(""); //$NON-NLS-1$
}
} else {
setTitleToolTip(LABEL_VIEW);
if (shouldSetDescription) {
setContentDescription(LABEL_NO_TASKS);
} else {
setContentDescription(""); //$NON-NLS-1$
}
}
}
@Override
public void init(IViewSite site, IMemento memento) throws PartInitException {
init(site);
this.taskListMemento = memento;
}
@Override
public void saveState(IMemento memento) {
if (tableSorter != null) {
IMemento child = memento.createChild(MEMENTO_SORTER);
tableSorter.saveState(child);
}
memento.putString(MEMENTO_LINK_WITH_EDITOR, Boolean.toString(linkWithEditor));
memento.putString(MEMENTO_PRESENTATION,
currentPresentation != null ? currentPresentation.getId() : CategorizedPresentation.ID);
if (filteredTree != null && filteredTree.getTextSearchControl() != null) {
filteredTree.getTextSearchControl().saveState(memento);
}
}
private void restoreState() {
if (taskListMemento != null) {
if (tableSorter != null) {
IMemento sorterMemento = taskListMemento.getChild(MEMENTO_SORTER);
if (sorterMemento != null) {
tableSorter.restoreState(sorterMemento);
}
}
applyPresentation(taskListMemento.getString(MEMENTO_PRESENTATION));
}
filterWorkingSet = new TaskWorkingSetFilter();
filterWorkingSet.updateWorkingSet(getSite().getPage().getAggregateWorkingSet());
filteredTree.setWorkingSetFilter(filterWorkingSet);
addFilter(filterWorkingSet);
addFilter(filterPriority);
if (TasksUiPlugin.getDefault()
.getPreferenceStore()
.contains(ITasksUiPreferenceConstants.FILTER_COMPLETE_MODE)) {
addFilter(filterComplete);
}
if (TasksUiPlugin.getDefault()
.getPreferenceStore()
.contains(ITasksUiPreferenceConstants.FILTER_MY_TASKS_MODE)) {
addFilter(filterMyTasks);
}
addFilter(filterPresentation);
addFilter(filterArchive);
addFilter(filterArtifact);
// Restore "link with editor" value; by default true
boolean linkValue = true;
if (taskListMemento != null && taskListMemento.getString(MEMENTO_LINK_WITH_EDITOR) != null) {
linkValue = Boolean.parseBoolean(taskListMemento.getString(MEMENTO_LINK_WITH_EDITOR));
}
setLinkWithEditor(linkValue);
if (taskListMemento != null && filteredTree.getTextSearchControl() != null) {
filteredTree.getTextSearchControl().restoreState(taskListMemento);
}
getViewer().refresh();
}
@Override
public void createPartControl(Composite parent) {
Composite body = new Composite(parent, SWT.NONE);
GridLayout layout = new GridLayout(1, false);
layout.marginHeight = 0;
layout.marginWidth = 0;
layout.horizontalSpacing = 0;
layout.verticalSpacing = 0;
layout.numColumns = 1;
body.setLayout(layout);
IWorkbenchSiteProgressService progress = (IWorkbenchSiteProgressService) getSite()
.getAdapter(IWorkbenchSiteProgressService.class);
if (progress != null) {
// show indicator for all running query synchronizations
progress.showBusyForFamily(ITasksCoreConstants.JOB_FAMILY_SYNCHRONIZATION);
}
this.selectionProvider = new org.eclipse.mylyn.commons.ui.SelectionProviderAdapter();
getSite().setSelectionProvider(selectionProvider);
themeManager = getSite().getWorkbenchWindow().getWorkbench().getThemeManager();
themeManager.addPropertyChangeListener(THEME_CHANGE_LISTENER);
searchHandler = SearchUtil.createSearchHandler();
filteredTree = new TaskListFilteredTree(body,
SWT.MULTI | SWT.VERTICAL | /* SWT.H_SCROLL | */SWT.V_SCROLL | SWT.NO_SCROLL | SWT.FULL_SELECTION,
searchHandler, getViewSite().getWorkbenchWindow());
// need to do initialize tooltip early for native tooltip disablement to take effect
taskListToolTip = new TaskListToolTip(getViewer().getControl());
updateTooltipEnablement();
getSite().registerContextMenu(TasksUiInternal.ID_MENU_ACTIVE_TASK, filteredTree.getActiveTaskMenuManager(),
selectionProvider);
filteredTree.setActiveTaskSelectionProvider(selectionProvider);
getViewer().addSelectionChangedListener(this.selectionProvider);
getViewer().getControl().addFocusListener(new FocusAdapter() {
@Override
public void focusGained(FocusEvent e) {
selectionProvider.setSelection(getViewer().getSelection());
}
});
filteredTree.getFilterControl().addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
updateFilterEnablement();
}
});
getViewer().getTree().setHeaderVisible(false);
getViewer().setUseHashlookup(true);
refreshJob = new TaskListRefreshJob(this, getViewer(), "Task List Refresh"); //$NON-NLS-1$
configureColumns(columnNames, columnWidths);
final IThemeManager themeManager = getSite().getWorkbenchWindow().getWorkbench().getThemeManager();
Color categoryBackground = themeManager.getCurrentTheme().getColorRegistry().get(CommonThemes.COLOR_CATEGORY);
taskListTableLabelProvider = new TaskTableLabelProvider(new TaskElementLabelProvider(true),
PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator(), categoryBackground);
getViewer().setLabelProvider(taskListTableLabelProvider);
CellEditor[] editors = new CellEditor[columnNames.length];
TextCellEditor textEditor = new TextCellEditor(getViewer().getTree());
((Text) textEditor.getControl()).setOrientation(SWT.LEFT_TO_RIGHT);
editors[0] = textEditor;
// editors[1] = new ComboBoxCellEditor(getViewer().getTree(),
// editors[2] = new CheckboxCellEditor();
getViewer().setCellEditors(editors);
getViewer().setCellModifier(taskListCellModifier);
tableSorter = new TaskListSorter();
getViewer().setSorter(tableSorter);
applyPresentation(CategorizedPresentation.ID);
drillDownAdapter = new DrillDownAdapter(getViewer());
getViewer().setInput(getViewSite());
final int activationImageOffset = PlatformUiUtil.getTreeImageOffset();
customDrawer = new CustomTaskListDecorationDrawer(activationImageOffset, false);
getViewer().getTree().addListener(SWT.EraseItem, customDrawer);
getViewer().getTree().addListener(SWT.PaintItem, customDrawer);
Listener expandListener = new Listener() {
public void handleEvent(Event event) {
lastExpansionTime = System.currentTimeMillis();
}
};
getViewer().getTree().addListener(SWT.Expand, expandListener);
getViewer().getTree().addListener(SWT.Collapse, expandListener);
getViewer().getTree().addMouseListener(new MouseAdapter() {
@Override
public void mouseUp(MouseEvent event) {
// avoid activation in case the event was actually triggered as a side-effect of a tree expansion
long currentTime = System.currentTimeMillis();
if (currentTime - lastExpansionTime < 150 && currentTime >= lastExpansionTime) {
return;
}
if (event.button == 3) {
// button3 is used for the context menu so we ignore the mouseDown Event
return;
}
// NOTE: need e.x offset for Linux/GTK, which does not see
// left-aligned items in tree
Object selectedNode = ((Tree) event.widget).getItem(new Point(event.x + 70, event.y));
if (selectedNode instanceof TreeItem) {
Object selectedObject = ((TreeItem) selectedNode).getData();
if (selectedObject instanceof ITask) {
if (event.x > activationImageOffset && event.x < activationImageOffset + 13) {
taskListCellModifier.toggleTaskActivation((TreeItem) selectedNode, event);
}
}
}
}
});
// TODO make these proper commands and move code into TaskListViewCommands
getViewer().getTree().addKeyListener(new KeyListener() {
public void keyPressed(KeyEvent e) {
if (e.keyCode == SWT.F2 && e.stateMask == 0) {
if (actionGroup.getRenameAction().isEnabled()) {
actionGroup.getRenameAction().run();
}
} else if ((e.keyCode & SWT.KEYCODE_BIT) != 0) {
// Do nothing here since it is key code
} else if (e.keyCode == SWT.ESC) {
taskListToolTip.hide();
} else if (e.keyCode == 'f' && e.stateMask == SWT.MOD1) {
filteredTree.getFilterControl().setFocus();
} else if (e.stateMask == 0) {
if (Character.isLetter((char) e.keyCode) || Character.isDigit((char) e.keyCode)) {
String string = new Character((char) e.keyCode).toString();
filteredTree.getFilterControl().setFocus();
filteredTree.getFilterControl().setText(string);
filteredTree.getFilterControl().setSelection(1, 1);
}
}
}
public void keyReleased(KeyEvent e) {
}
});
// update tooltip contents
getViewer().addSelectionChangedListener(new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
updateToolTip(true);
}
});
getViewer().getTree().addFocusListener(new FocusAdapter() {
@Override
public void focusLost(FocusEvent e) {
taskListToolTip.hide();
}
});
makeActions();
hookGlobalActions();
hookContextMenu();
hookOpenAction();
contributeToActionBars();
initHandlers();
new GradientDrawer(themeManager, getViewer()) {
@Override
protected boolean shouldApplyGradient(Event event) {
return event.item.getData() instanceof ITaskContainer && !(event.item.getData() instanceof ITask);
}
};
initDragAndDrop(parent);
expandToActiveTasks();
restoreState();
updateDescription();
IContextService contextSupport = (IContextService) getSite().getService(IContextService.class);
if (contextSupport != null) {
contextSupport.activateContext(ITasksUiConstants.ID_VIEW_TASKS);
}
getSite().getPage().addPartListener(editorListener);
// we need to update the icon here as the action was not created when the presentation was applied
updatePresentationSelectorImage();
PlatformUI.getWorkbench().getWorkingSetManager().addPropertyChangeListener(this);
TasksUiPlugin.getTaskActivityManager().addActivityListener(TASK_ACTIVITY_LISTENER);
TasksUiPlugin.getTaskActivityManager().addActivationListener(TASK_ACTIVATION_LISTENER);
TasksUiPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(tasksUiPreferenceListener);
serviceMessageControl = new TaskListServiceMessageControl(body);
List<TaskRepository> repos = TasksUi.getRepositoryManager().getAllRepositories();
boolean showMessage = true;
for (TaskRepository repository : repos) {
if (!repository.getConnectorKind().equals("local") //$NON-NLS-1$
&& !TaskRepositoryUtil.isAddAutomatically(repository.getRepositoryUrl())) {
showMessage = false;
break;
}
}
boolean showedWelcomeMessage = TasksUiPlugin.getDefault()
.getPreferenceStore()
.getBoolean(ITasksUiPreferenceConstants.WELCOME_MESSAGE);
if (showMessage && !showedWelcomeMessage) {
ServiceMessage message = new ServiceMessage("welcome"); //$NON-NLS-1$
message.setDescription(Messages.TaskListView_Welcome_Message);
message.setTitle(Messages.TaskListView_Welcome_Message_Title);
message.setImage(Dialog.DLG_IMG_MESSAGE_INFO);
serviceMessageControl.setMessage(message);
TasksUiPlugin.getDefault().getPreferenceStore().setValue(ITasksUiPreferenceConstants.WELCOME_MESSAGE,
Boolean.toString(true));
}
TasksUiPlugin.getDefault().getServiceMessageManager().addServiceMessageListener(serviceMessageControl);
// Need to do this because the page, which holds the active working set is not around on creation, see bug 203179
PlatformUI.getWorkbench().getActiveWorkbenchWindow().addPageListener(PAGE_LISTENER);
}
private void initHandlers() {
IHandlerService handlerService = (IHandlerService) getSite().getService(IHandlerService.class);
handlerService.activateHandler(CollapseAllHandler.COMMAND_ID, new CollapseAllHandler(getViewer()));
}
private void hookGlobalActions() {
IActionBars bars = getViewSite().getActionBars();
bars.setGlobalActionHandler(ActionFactory.DELETE.getId(), actionGroup.getDeleteAction());
bars.setGlobalActionHandler(ActionFactory.COPY.getId(), actionGroup.getCopyDetailsAction());
bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), actionGroup.getUndoAction());
bars.setGlobalActionHandler(ActionFactory.REDO.getId(), actionGroup.getRedoAction());
}
private void applyPresentation(String id) {
if (id != null) {
for (AbstractTaskListPresentation presentation : presentationsPrimary) {
if (id.equals(presentation.getId())) {
applyPresentation(presentation);
return;
}
}
for (AbstractTaskListPresentation presentation : presentationsSecondary) {
if (id.equals(presentation.getId())) {
applyPresentation(presentation);
return;
}
}
}
}
public void applyPresentation(AbstractTaskListPresentation presentation) {
try {
getViewer().getControl().setRedraw(false);
if (!filteredTree.getFilterString().equals("")) { //$NON-NLS-1$
filteredTree.getFilterControl().setText(""); //$NON-NLS-1$
}
AbstractTaskListContentProvider contentProvider = presentation.getContentProvider(this);
getViewer().setContentProvider(contentProvider);
refresh(true);
currentPresentation = presentation;
updatePresentationSelectorImage();
tableSorter.getTaskComparator().presentationChanged(presentation);
} finally {
getViewer().getControl().setRedraw(true);
}
}
private void updatePresentationSelectorImage() {
if (presentationDropDownSelectionAction != null && currentPresentation != null) {
presentationDropDownSelectionAction.setImageDescriptor(currentPresentation.getImageDescriptor());
}
for (IContributionItem item : getViewSite().getActionBars().getToolBarManager().getItems()) {
if (item instanceof ActionContributionItem) {
IAction action = ((ActionContributionItem) item).getAction();
if (action instanceof PresentationDropDownSelectionAction.PresentationSelectionAction) {
((PresentationDropDownSelectionAction.PresentationSelectionAction) action).update();
}
}
}
}
public AbstractTaskListPresentation getCurrentPresentation() {
return currentPresentation;
}
private void configureColumns(final String[] columnNames, final int[] columnWidths) {
TreeColumnLayout layout = (TreeColumnLayout) getViewer().getTree().getParent().getLayout();
getViewer().setColumnProperties(columnNames);
columns = new TreeColumn[columnNames.length];
for (int i = 0; i < columnNames.length; i++) {
columns[i] = new TreeColumn(getViewer().getTree(), 0);
columns[i].setText(columnNames[i]);
if (i == 0) {
layout.setColumnData(columns[i], new ColumnWeightData(100));
} else {
layout.setColumnData(columns[i], new ColumnPixelData(columnWidths[i]));
}
columns[i].addControlListener(new ControlListener() {
public void controlResized(ControlEvent e) {
for (int j = 0; j < columnWidths.length; j++) {
if (columns[j].equals(e.getSource())) {
columnWidths[j] = columns[j].getWidth();
}
}
}
public void controlMoved(ControlEvent e) {
// don't care if the control is moved
}
});
}
}
/**
* Tracks editor activation and jump to corresponding task, if applicable
*/
private final IPartListener editorListener = new IPartListener() {
private void jumpToEditor(IWorkbenchPart part) {
if (!linkWithEditor || !(part instanceof IEditorPart)) {
return;
}
jumpToEditorTask((IEditorPart) part);
}
public void partActivated(IWorkbenchPart part) {
if (part == TaskListView.this) {
updateDescription();
} else {
jumpToEditor(part);
}
}
public void partBroughtToTop(IWorkbenchPart part) {
}
public void partClosed(IWorkbenchPart part) {
}
public void partDeactivated(IWorkbenchPart part) {
if (part == TaskListView.this) {
IViewReference reference = getSite().getPage().findViewReference(ITasksUiConstants.ID_VIEW_TASKS);
if (reference != null && reference.isFastView()) {
updateDescription();
}
taskListToolTip.hide();
}
}
public void partOpened(IWorkbenchPart part) {
}
};
private void initDragAndDrop(Composite parent) {
Transfer[] dragTypes = new Transfer[] { LocalSelectionTransfer.getTransfer(), FileTransfer.getInstance() };
Transfer[] dropTypes = new Transfer[] { LocalSelectionTransfer.getTransfer(), FileTransfer.getInstance(),
TextTransfer.getInstance(), RTFTransfer.getInstance(), URLTransfer.getInstance() };
getViewer().addDragSupport(DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK, dragTypes,
new TaskDragSourceListener(getViewer()));
getViewer().addDropSupport(DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK | DND.DROP_DEFAULT, dropTypes,
new TaskListDropAdapter(getViewer()));
}
@Override
protected void expandToActiveTasks() {
final IWorkbench workbench = PlatformUI.getWorkbench();
workbench.getDisplay().asyncExec(new Runnable() {
public void run() {
ITask task = TasksUi.getTaskActivityManager().getActiveTask();
if (task != null) {
getViewer().expandToLevel(task, 0);
}
}
});
}
private void hookContextMenu() {
MenuManager menuManager = new MenuManager("#PopupMenu"); //$NON-NLS-1$
menuManager.setRemoveAllWhenShown(true);
menuManager.addMenuListener(new IMenuListener() {
public void menuAboutToShow(IMenuManager manager) {
actionGroup.fillContextMenu(manager);
}
});
Menu menu = menuManager.createContextMenu(getViewer().getControl());
getViewer().getControl().setMenu(menu);
getSite().registerContextMenu(menuManager, getViewer());
}
private void contributeToActionBars() {
IActionBars bars = getViewSite().getActionBars();
fillLocalPullDown(bars.getMenuManager());
fillLocalToolBar(bars.getToolBarManager());
}
private void fillLocalPullDown(IMenuManager manager) {
updateDrillDownActions();
manager.add(actionGroup.getGoUpAction());
manager.add(collapseAll);
manager.add(expandAll);
manager.add(new Separator(ID_SEPARATOR_FILTERS));
manager.add(sortDialogAction);
manager.add(filterOnPriorityAction);
manager.add(filterCompleteTask);
manager.add(filterMyTasksAction);
IMenuManager advancedMenu = new MenuManager(Messages.TaskListView_Advanced_Filters_Label);
advancedMenu.add(new ShowAllQueriesAction());
showNonMatchingSubtasksAction = new ShowNonMatchingSubtasksAction();
advancedMenu.add(showNonMatchingSubtasksAction);
advancedMenu.add(new Separator());
advancedMenu.add(groupSubTasksAction);
manager.add(advancedMenu);
manager.add(new Separator(ID_SEPARATOR_SEARCH));
manager.add(new GroupMarker(ID_SEPARATOR_TASKS));
manager.add(synchronizeAutomatically);
manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
manager.addMenuListener(new IMenuListener() {
public void menuAboutToShow(IMenuManager manager) {
filterOnPriorityAction.updateCheckedState();
}
});
manager.add(linkWithEditorAction);
manager.add(new Separator());
manager.add(openPreferencesAction);
}
private void fillLocalToolBar(IToolBarManager manager) {
manager.add(newTaskAction);
manager.add(new Separator());
addPresentations(manager);
manager.add(new Separator());
manager.add(new GroupMarker(ID_SEPARATOR_CONTEXT));
manager.add(new Separator());
manager.add(filterCompleteTask);
manager.add(filterMyTasksAction);
manager.add(collapseAll);
manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
}
private void addPresentations(IToolBarManager manager) {
for (AbstractTaskListPresentation presentation : TaskListView.getPresentations()) {
if (!presentation.isPrimary()) {
// at least one non primary presentation present
manager.add(presentationDropDownSelectionAction);
return;
}
}
// add toggle buttons for primary presentations
for (AbstractTaskListPresentation presentation : TaskListView.getPresentations()) {
manager.add(new PresentationDropDownSelectionAction.PresentationSelectionAction(this, presentation));
}
}
public List<IRepositoryElement> getSelectedTaskContainers() {
List<IRepositoryElement> selectedElements = new ArrayList<IRepositoryElement>();
for (Iterator<?> i = ((IStructuredSelection) getViewer().getSelection()).iterator(); i.hasNext();) {
Object object = i.next();
if (object instanceof ITaskContainer) {
selectedElements.add((IRepositoryElement) object);
}
}
return selectedElements;
}
private void makeActions() {
actionGroup = new TaskListViewActionGroup(this, drillDownAdapter);
actionGroup.getOpenAction().setViewer(getViewer());
collapseAll = new CollapseAllAction(this);
expandAll = new ExpandAllAction(this);
filterCompleteTask = new FilterCompletedTasksAction(this);
groupSubTasksAction = new GroupSubTasksAction();
synchronizeAutomatically = new SynchronizeAutomaticallyAction();
openPreferencesAction = new OpenTasksUiPreferencesAction();
//filterArchiveCategory = new FilterArchiveContainerAction(this);
filterMyTasksAction = new FilterMyTasksAction(this);
sortDialogAction = new TaskListSortAction(getSite(), this);
filterOnPriorityAction = new PriorityDropDownAction(this);
linkWithEditorAction = new LinkWithEditorAction(this);
newTaskAction = new NewTaskAction();
filteredTree.getViewer().addSelectionChangedListener(newTaskAction);
}
private void hookOpenAction() {
getViewer().addOpenListener(new IOpenListener() {
public void open(OpenEvent event) {
actionGroup.getOpenAction().run();
}
});
getViewer().addDoubleClickListener(new IDoubleClickListener() {
public void doubleClick(DoubleClickEvent event) {
if (TasksUiPlugin.getDefault()
.getPreferenceStore()
.getBoolean(ITasksUiPreferenceConstants.ACTIVATE_WHEN_OPENED)) {
AbstractTask selectedTask = getSelectedTask();
if (selectedTask != null && !selectedTask.isActive()) {
TasksUiInternal.activateTaskThroughCommand(selectedTask);
}
}
}
});
}
/**
* Passing the focus request to the viewer's control.
*/
@Override
public void setFocus() {
filteredTree.getViewer().getControl().setFocus();
}
public void refresh(boolean expandIfFocused) {
if (expandIfFocused && isFocusedMode() && isAutoExpandMode()) {
try {
getViewer().getControl().setRedraw(false);
refreshJob.refreshNow();
getViewer().expandAll();
} finally {
getViewer().getControl().setRedraw(true);
}
} else {
refreshJob.refreshNow();
}
}
@Override
public void refresh() {
refreshJob.refreshNow();
}
public TaskListToolTip getToolTip() {
return taskListToolTip;
}
@Override
public TreeViewer getViewer() {
return filteredTree.getViewer();
}
public TaskCompletionFilter getCompleteFilter() {
return filterComplete;
}
public TaskPriorityFilter getPriorityFilter() {
return filterPriority;
}
public void addFilter(AbstractTaskListFilter filter) {
if (!filters.contains(filter)) {
filters.add(filter);
}
}
public Set<AbstractTaskListFilter> clearFilters() {
HashSet<AbstractTaskListFilter> previousFilters = new HashSet<AbstractTaskListFilter>(getFilters());
previousFilters.remove(filterMyTasks);// this filter is always available for users to toggle
filters.clear();
filters.add(filterArchive);
filters.add(filterWorkingSet);
filters.add(filterPresentation);
boolean enableMyTasksFilter = TasksUiPlugin.getDefault()
.getPreferenceStore()
.getBoolean(ITasksUiPreferenceConstants.FILTER_MY_TASKS_MODE);
if (enableMyTasksFilter) {
filters.add(getMyTasksFilter());
}
return previousFilters;
}
public void removeFilter(AbstractTaskListFilter filter) {
filters.remove(filter);
}
public void updateDrillDownActions() {
actionGroup.updateDrillDownActions();
}
boolean isInRenameAction = false;
private TaskListRefreshJob refreshJob;
private boolean itemNotFoundExceptionLogged;
private AbstractSearchHandler searchHandler;
public void setInRenameAction(boolean b) {
isInRenameAction = b;
}
public void goIntoCategory() {
ISelection selection = getViewer().getSelection();
if (selection instanceof StructuredSelection) {
StructuredSelection structuredSelection = (StructuredSelection) selection;
Object element = structuredSelection.getFirstElement();
if (element instanceof ITaskContainer) {
drilledIntoCategory = (AbstractTaskContainer) element;
drillDownAdapter.goInto();
IActionBars bars = getViewSite().getActionBars();
bars.getToolBarManager().remove(actionGroup.getGoUpAction().getId());
bars.getToolBarManager().add(actionGroup.getGoUpAction());
bars.updateActionBars();
updateDrillDownActions();
}
}
}
public void goUpToRoot() {
drilledIntoCategory = null;
drillDownAdapter.goBack();
IActionBars bars = getViewSite().getActionBars();
bars.getToolBarManager().remove(GoUpAction.ID);
bars.updateActionBars();
updateDrillDownActions();
}
public AbstractTask getSelectedTask() {
ISelection selection = getViewer().getSelection();
if (selection.isEmpty()) {
return null;
}
if (selection instanceof StructuredSelection) {
StructuredSelection structuredSelection = (StructuredSelection) selection;
Object element = structuredSelection.getFirstElement();
if (element instanceof ITask) {
return (AbstractTask) structuredSelection.getFirstElement();
}
}
return null;
}
public static AbstractTask getSelectedTask(ISelection selection) {
if (selection instanceof StructuredSelection) {
StructuredSelection structuredSelection = (StructuredSelection) selection;
if (structuredSelection.size() != 1) {
return null;
}
Object element = structuredSelection.getFirstElement();
if (element instanceof ITask) {
return (AbstractTask) structuredSelection.getFirstElement();
}
}
return null;
}
public void indicatePaused(boolean paused) {
isPaused = paused;
IStatusLineManager statusLineManager = getViewSite().getActionBars().getStatusLineManager();
if (isPaused) {
statusLineManager.setMessage(CommonImages.getImage(TasksUiImages.TASKS_VIEW),
Messages.TaskListView_Mylyn_context_capture_paused);
setPartName(Messages.TaskListView__paused_ + LABEL_VIEW);
} else {
statusLineManager.setMessage(""); //$NON-NLS-1$
setPartName(LABEL_VIEW);
}
}
public AbstractTaskContainer getDrilledIntoCategory() {
return drilledIntoCategory;
}
@Override
public TaskListFilteredTree getFilteredTree() {
return filteredTree;
}
public void selectedAndFocusTask(ITask task) {
if (task == null || getViewer().getControl().isDisposed()) {
return;
}
saveSelection();
IStructuredSelection selection = restoreSelection(task);
try {
getViewer().setSelection(selection, true);
} catch (SWTError e) {
if (!itemNotFoundExceptionLogged) {
itemNotFoundExceptionLogged = true;
// It's probably not worth displaying this to the user since the item
// is not there in this case, so consider removing.
StatusHandler.log(
new Status(IStatus.WARNING, TasksUiPlugin.ID_PLUGIN, "Could not link Task List with editor", //$NON-NLS-1$
e));
}
}
}
/**
* Persists the path of a selection.
*/
private void saveSelection() {
IStructuredSelection selection = (IStructuredSelection) getViewer().getSelection();
if (selection.size() == 1 && selection.getFirstElement() instanceof ITask) {
// make sure the new selection is inserted at the end of the
// list
String handle = ((IRepositoryElement) selection.getFirstElement()).getHandleIdentifier();
lastSelectionByTaskHandle.remove(handle);
lastSelectionByTaskHandle.put(handle, selection);
if (lastSelectionByTaskHandle.size() > SIZE_MAX_SELECTION_HISTORY) {
Iterator<String> it = lastSelectionByTaskHandle.keySet().iterator();
it.next();
it.remove();
}
}
}
/**
* If <code>task</code> was previously selected, a tree selection is returned that references the same path that was
* previously selected.
*/
private IStructuredSelection restoreSelection(ITask task) {
IStructuredSelection selection = lastSelectionByTaskHandle.get(task.getHandleIdentifier());
if (selection != null) {
return selection;
} else {
return new StructuredSelection(task);
}
}
public Image[] getPirorityImages() {
Image[] images = new Image[PriorityLevel.values().length];
for (int i = 0; i < PriorityLevel.values().length; i++) {
images[i] = TasksUiImages.getImageForPriority(PriorityLevel.values()[i]);
}
return images;
}
@Override
public Set<AbstractTaskListFilter> getFilters() {
return filters;
}
public static String getCurrentPriorityLevel() {
if (TasksUiPlugin.getDefault().getPreferenceStore().contains(ITasksUiPreferenceConstants.FILTER_PRIORITY)) {
return TasksUiPlugin.getDefault()
.getPreferenceStore()
.getString(ITasksUiPreferenceConstants.FILTER_PRIORITY);
} else {
return PriorityLevel.P5.toString();
}
}
public TaskArchiveFilter getArchiveFilter() {
return filterArchive;
}
private void updateFilterEnablement() {
boolean enabled = !isFocusedMode();
if (enabled) {
String filterText = filteredTree.getFilterString();
if (filterText != null && filterText.length() > 0) {
enabled = false;
}
}
sortDialogAction.setEnabled(enabled);
filterOnPriorityAction.setEnabled(enabled);
filterCompleteTask.setEnabled(enabled);
//filterArchiveCategory.setEnabled(enabled);
}
@Override
public boolean isScheduledPresentation() {
return currentPresentation != null && ScheduledPresentation.ID.equals(currentPresentation.getId());
}
@Override
public boolean isFocusedMode() {
return focusedMode;
}
@Override
protected boolean isAutoExpandMode() {
return TasksUiPlugin.getDefault()
.getPreferenceStore()
.getBoolean(ITasksUiPreferenceConstants.AUTO_EXPAND_TASK_LIST);
}
public void setFocusedMode(boolean focusedMode) {
if (this.focusedMode == focusedMode) {
return;
}
this.focusedMode = focusedMode;
customDrawer.setFocusedMode(focusedMode);
IToolBarManager manager = getViewSite().getActionBars().getToolBarManager();
ToolBarManager toolBarManager = getToolBarManager(manager);
try {
if (toolBarManager != null) {
toolBarManager.getControl().setRedraw(false);
}
if (focusedMode && isAutoExpandMode()) {
manager.remove(FilterCompletedTasksAction.ID);
manager.remove(CollapseAllAction.ID);
} else if (manager.find(CollapseAllAction.ID) == null) {
manager.prependToGroup(ID_SEPARATOR_CONTEXT, collapseAll);
manager.prependToGroup(ID_SEPARATOR_CONTEXT, filterCompleteTask);
}
updateFilterEnablement();
getViewSite().getActionBars().updateActionBars();
} finally {
if (toolBarManager != null) {
toolBarManager.getControl().setRedraw(true);
}
}
}
private ToolBarManager getToolBarManager(IToolBarManager manager) {
if (manager instanceof ToolBarManager && ((ToolBarManager) manager).getControl() != null
&& !((ToolBarManager) manager).getControl().isDisposed()) {
return (ToolBarManager) manager;
}
return null;
}
public void displayPrioritiesAbove(String priority) {
filterPriority.displayPrioritiesAbove(priority);
getViewer().refresh();
}
public void propertyChange(PropertyChangeEvent event) {
String property = event.getProperty();
if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE.equals(property)
|| IWorkingSetManager.CHANGE_WORKING_SET_REMOVE.equals(property)) {
if (getSite() != null && getSite().getPage() != null) {
if (filterWorkingSet.updateWorkingSet(getSite().getPage().getAggregateWorkingSet())) {
try {
getViewer().getControl().setRedraw(false);
if (drilledIntoCategory != null) {
goUpToRoot();
}
getViewer().refresh();
if (isFocusedMode() && isAutoExpandMode()) {
getViewer().expandAll();
}
} finally {
getViewer().getControl().setRedraw(true);
}
}
}
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
filteredTree.indicateActiveTaskWorkingSet();
}
});
}
}
public void setLinkWithEditor(boolean linkWithEditor) {
this.linkWithEditor = linkWithEditor;
linkWithEditorAction.setChecked(linkWithEditor);
if (linkWithEditor) {
IEditorPart activeEditor = getSite().getPage().getActiveEditor();
if (activeEditor != null) {
jumpToEditorTask(activeEditor);
}
}
}
private void jumpToEditorTask(IEditorPart editor) {
IEditorInput input = editor.getEditorInput();
if (input instanceof TaskEditorInput) {
ITask task = ((TaskEditorInput) input).getTask();
ITask selected = getSelectedTask();
if (selected == null || !selected.equals(task)) {
selectedAndFocusTask(task);
}
}
}
@Override
protected void updateToolTip(boolean force) {
if (taskListToolTip != null && taskListToolTip.isVisible()) {
if (!force && taskListToolTip.isTriggeredByMouse()) {
return;
}
TreeItem[] selection = getViewer().getTree().getSelection();
if (selection != null && selection.length > 0) {
Rectangle bounds = selection[0].getBounds();
taskListToolTip.show(new Point(bounds.x + 1, bounds.y + 1));
}
}
}
/**
* This can be used for experimentally adding additional presentations, but note that this convention is extremely
* likely to change in the Mylyn 3.0 cycle.
*/
public static List<AbstractTaskListPresentation> getPresentations() {
List<AbstractTaskListPresentation> presentations = new ArrayList<AbstractTaskListPresentation>();
presentations.addAll(presentationsPrimary);
presentations.addAll(presentationsSecondary);
return presentations;
}
public static void addPresentation(AbstractTaskListPresentation presentation) {
if (presentation.isPrimary()) {
presentationsPrimary.add(presentation);
} else {
presentationsSecondary.add(presentation);
}
}
public TaskListSorter getSorter() {
return tableSorter;
}
public boolean show(ShowInContext context) {
ISelection selection = context.getSelection();
if (selection instanceof IStructuredSelection) {
getViewer().setSelection(selection, true);
return true;
}
return false;
}
private void updateTooltipEnablement() {
// Set to empty string to disable native tooltips (windows only?)
// bug#160897
// http://dev.eclipse.org/newslists/news.eclipse.platform.swt/msg29614.html
if (taskListToolTip != null) {
boolean enabled = TasksUiPlugin.getDefault()
.getPreferenceStore()
.getBoolean(ITasksUiPreferenceConstants.TASK_LIST_TOOL_TIPS_ENABLED);
taskListToolTip.setEnabled(enabled);
if (getViewer().getTree() != null && !getViewer().getTree().isDisposed()) {
getViewer().getTree().setToolTipText((enabled) ? "" : null); //$NON-NLS-1$
}
}
}
@SuppressWarnings("rawtypes")
@Override
public Object getAdapter(Class adapter) {
if (adapter == ISizeProvider.class) {
return new ISizeProvider() {
public int getSizeFlags(boolean width) {
if (width) {
return SWT.MIN;
}
return 0;
}
public int computePreferredSize(boolean width, int availableParallel, int availablePerpendicular,
int preferredResult) {
if (width) {
if (getViewSite().getActionBars().getToolBarManager() instanceof ToolBarManager) {
Point size = ((ToolBarManager) getViewSite().getActionBars().getToolBarManager())
.getControl().computeSize(SWT.DEFAULT, SWT.DEFAULT);
// leave some room for the view menu drop-down
return size.x + PlatformUiUtil.getViewMenuWidth();
}
}
return preferredResult;
}
};
} else if (adapter == IShowInTargetList.class) {
return new IShowInTargetList() {
public String[] getShowInTargetIds() {
return new String[] { "org.eclipse.team.ui.GenericHistoryView" }; //$NON-NLS-1$
}
};
} else if (adapter == IShowInSource.class) {
return new IShowInSource() {
public ShowInContext getShowInContext() {
return new ShowInContext(getViewer().getInput(), getViewer().getSelection());
}
};
}
return super.getAdapter(adapter);
}
public TaskListServiceMessageControl getServiceMessageControl() {
return serviceMessageControl;
}
public MyTasksFilter getMyTasksFilter() {
return filterMyTasks;
}
}