/*******************************************************************************
* Copyright (c) 2000, 2009 IBM Corporation 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:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.ui.views.markers.internal;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import org.eclipse.help.HelpSystem;
import org.eclipse.help.IContext;
import org.eclipse.help.IContextProvider;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSourceAdapter;
import org.eclipse.swt.dnd.DragSourceEvent;
import org.eclipse.swt.dnd.DragSourceListener;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.HelpEvent;
import org.eclipse.swt.events.HelpListener;
import org.eclipse.swt.events.TreeAdapter;
import org.eclipse.swt.events.TreeEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.core.commands.operations.IUndoContext;
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.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.mapping.ResourceMapping;
import org.eclipse.core.resources.mapping.ResourceMappingContext;
import org.eclipse.core.resources.mapping.ResourceTraversal;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.window.Window;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchCommandConstants;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.XMLMemento;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.actions.ContributionItemFactory;
import org.eclipse.ui.actions.SelectionProviderAction;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.ide.ResourceUtil;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.Policy;
import org.eclipse.ui.keys.IBindingService;
import org.eclipse.ui.operations.RedoActionHandler;
import org.eclipse.ui.operations.UndoActionHandler;
import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.MarkerTransfer;
import org.eclipse.ui.part.ShowInContext;
import org.eclipse.ui.preferences.ViewPreferencesAction;
import org.eclipse.ui.progress.IWorkbenchSiteProgressService;
import org.eclipse.ui.progress.WorkbenchJob;
import org.eclipse.ui.views.markers.internal.MarkerAdapter.MarkerCategory;
import org.eclipse.ui.views.tasklist.ITaskListResourceAdapter;
/**
* MarkerView is the abstract super class of the marker based views.
*
*/
public abstract class MarkerView extends TableView {
private static final String TAG_SELECTION = "selection"; //$NON-NLS-1$
private static final String TAG_MARKER = "marker"; //$NON-NLS-1$
private static final String TAG_RESOURCE = "resource"; //$NON-NLS-1$
private static final String TAG_ID = "id"; //$NON-NLS-1$
private static final String TAG_FILTERS_SECTION = "filters"; //$NON-NLS-1$
private static final String TAG_FILTER_ENTRY = "filter"; //$NON-NLS-1$
private static final String MENU_FILTERS_GROUP = "group.filter";//$NON-NLS-1$
private static final String MENU_SHOW_IN_GROUP = "group.showIn";//$NON-NLS-1$
// Section from a 3.1 or earlier workbench
private static final String OLD_FILTER_SECTION = "filter"; //$NON-NLS-1$
static final Object MARKER_UPDATE_FAMILY = new Object();
class MarkerProcessJob extends Job {
/**
* Create a new instance of the receiver.
*/
MarkerProcessJob() {
super(MarkerMessages.MarkerView_processUpdates);
setSystem(true);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
*/
protected IStatus run(IProgressMonitor monitor) {
updateForContentsRefresh(monitor);
return Status.OK_STATUS;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.progress.WorkbenchJob#shouldRun()
*/
public boolean shouldRun() {
// Do not run if the change came in before there is a viewer
return PlatformUI.isWorkbenchRunning();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
*/
public boolean belongsTo(Object family) {
return MARKER_UPDATE_FAMILY == family;
}
}
MarkerProcessJob markerProcessJob = new MarkerProcessJob();
private class UpdateJob extends WorkbenchJob {
private class MarkerDescriptor {
String description;
String folder;
String resource;
int line;
MarkerDescriptor(ConcreteMarker marker) {
description = marker.getDescription();
folder = marker.getFolder();
resource = marker.getResourceName();
line = marker.getLine();
}
boolean isEquivalentTo(ConcreteMarker marker) {
return marker.getDescription().equals(description)
&& marker.getFolder().equals(folder)
&& marker.getResourceName().equals(resource)
&& marker.getLine() == line;
}
}
private Collection categoriesToExpand = new HashSet();
private Collection preservedSelection = new ArrayList();
UpdateJob() {
super(MarkerMessages.MarkerView_queueing_updates);
setSystem(true);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor)
*/
public IStatus runInUIThread(IProgressMonitor monitor) {
if (getViewer().getControl().isDisposed()) {
return Status.CANCEL_STATUS;
}
if (monitor.isCanceled())
return Status.CANCEL_STATUS;
getViewer().refresh(true);
Tree tree = getTree();
if (tree != null && !tree.isDisposed()) {
updateStatusMessage();
updateTitle();
// Expand all if the list is small
if (getCurrentMarkers().getSize() < 20) {
getViewer().expandAll();
} else {// Reexpand the old categories
MarkerCategory[] categories = getMarkerAdapter()
.getCategories();
if (categories == null)
categoriesToExpand.clear();
else {
if (categories.length == 1) {// Expand if there is
// only
// one
getViewer().expandAll();
categoriesToExpand.clear();
if (monitor.isCanceled())
return Status.CANCEL_STATUS;
categoriesToExpand.add(categories[0].getName());
} else {
Collection newCategories = new HashSet();
for (int i = 0; i < categories.length; i++) {
if (monitor.isCanceled())
return Status.CANCEL_STATUS;
MarkerCategory category = categories[i];
if (categoriesToExpand.contains(category
.getName())) {
getViewer().expandToLevel(category,
AbstractTreeViewer.ALL_LEVELS);
newCategories.add(category.getName());
}
}
categoriesToExpand = newCategories;
}
}
}
}
if (preservedSelection.size() > 0) {
Collection newSelection = new ArrayList();
ConcreteMarker[] markers = getCurrentMarkers().toArray();
for (int i = 0; i < markers.length; i++) {
Iterator preserved = preservedSelection.iterator();
while (preserved.hasNext()) {
MarkerDescriptor next = (MarkerDescriptor) preserved
.next();
if (next.isEquivalentTo(markers[i])) {
newSelection.add(markers[i]);
continue;
}
}
}
getViewer().setSelection(
new StructuredSelection(newSelection.toArray()), true);
preservedSelection.clear();
}
if (getViewer().getTree().getItemCount() > 0)
getViewer().getTree().setTopItem(
getViewer().getTree().getItem(0));
return Status.OK_STATUS;
}
/**
* Add the category to the list of expanded categories.
*
* @param category
*/
public void addExpandedCategory(MarkerCategory category) {
categoriesToExpand.add(category.getName());
}
/**
* Remove the category from the list of expanded ones.
*
* @param category
*/
public void removeExpandedCategory(MarkerCategory category) {
categoriesToExpand.remove(category.getName());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
*/
public boolean belongsTo(Object family) {
return family == MARKER_UPDATE_FAMILY;
}
/**
* Preserve the selection for reselection after the next update.
*
* @param selection
*/
public void saveSelection(ISelection selection) {
preservedSelection.clear();
if (selection instanceof IStructuredSelection) {
IStructuredSelection structured = (IStructuredSelection) selection;
Iterator iterator = structured.iterator();
while (iterator.hasNext()) {
MarkerNode next = (MarkerNode) iterator.next();
if (next.isConcrete()) {
preservedSelection.add(new MarkerDescriptor(next
.getConcreteRepresentative()));
}
}
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.progress.WorkbenchJob#shouldRun()
*/
public boolean shouldRun() {
return !getMarkerAdapter().isBuilding();
}
}
private UpdateJob updateJob = new UpdateJob();
// A private field for keeping track of the number of markers
// before the busy testing started
private int preBusyMarkers = 0;
protected Object[] focusElements;
private Clipboard clipboard;
IResourceChangeListener markerUpdateListener = new IResourceChangeListener() {
/*
* (non-Javadoc)
*
* @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
*/
public void resourceChanged(IResourceChangeEvent event) {
if (!hasMarkerDelta(event))
return;
if (event.getType() == IResourceChangeEvent.POST_BUILD) {
scheduleMarkerUpdate(Util.SHORT_DELAY);
return;
}
// After 30 seconds do updates anyways
IWorkbenchSiteProgressService progressService = getProgressService();
if (progressService == null)
markerProcessJob.schedule(Util.LONG_DELAY);
else
getProgressService()
.schedule(markerProcessJob, Util.LONG_DELAY);
}
/**
* Returns whether or not the given even contains marker deltas for this
* view.
*
* @param event
* the resource change event
* @return <code>true</code> if the event contains at least one
* relevant marker delta
* @since 3.3
*/
private boolean hasMarkerDelta(IResourceChangeEvent event) {
String[] markerTypes = getMarkerTypes();
for (int i = 0; i < markerTypes.length; i++) {
if (event.findMarkerDeltas(markerTypes[i], true).length > 0) {
return true;
}
}
return false;
}
};
private class ContextProvider implements IContextProvider {
public int getContextChangeMask() {
return SELECTION;
}
public IContext getContext(Object target) {
String contextId = null;
// See if there is a context registered for the current selection
ConcreteMarker marker = getSelectedConcreteMarker();
if (marker != null) {
contextId = IDE.getMarkerHelpRegistry().getHelp(
marker.getMarker());
}
if (contextId == null) {
contextId = getStaticContextId();
}
return HelpSystem.getContext(contextId);
}
/**
* Return the currently selected concrete marker or <code>null</code>
* if there isn't one.
*
* @return ConcreteMarker
*/
private ConcreteMarker getSelectedConcreteMarker() {
IStructuredSelection selection = (IStructuredSelection) getViewer()
.getSelection();
if (selection.isEmpty())
return null;
if (selection.getFirstElement() instanceof ConcreteMarker)
return (ConcreteMarker) selection.getFirstElement();
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.help.IContextProvider#getSearchExpression(java.lang.Object)
*/
public String getSearchExpression(Object target) {
return null;
}
}
private ContextProvider contextProvider = new ContextProvider();
protected ActionCopyMarker copyAction;
protected ActionPasteMarker pasteAction;
protected SelectionProviderAction revealAction;
protected SelectionProviderAction openAction;
protected SelectionProviderAction deleteAction;
protected SelectionProviderAction selectAllAction;
protected SelectionProviderAction propertiesAction;
protected UndoActionHandler undoAction;
protected RedoActionHandler redoAction;
private ISelectionListener focusListener = new ISelectionListener() {
public void selectionChanged(IWorkbenchPart part, ISelection selection) {
MarkerView.this.focusSelectionChanged(part, selection);
}
};
private int totalMarkers = 0;
private MarkerFilter[] markerFilters = new MarkerFilter[0];
// A cache of the enabled filters
private MarkerFilter[] enabledFilters = null;
private MenuManager filtersMenu;
private MenuManager showInMenu;
private IPropertyChangeListener workingSetListener;
private MarkerAdapter adapter;
private IPropertyChangeListener preferenceListener;
/**
* Create a new instance of the receiver,
*/
public MarkerView() {
super();
preferenceListener = new IPropertyChangeListener() {
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
*/
public void propertyChange(PropertyChangeEvent event) {
if (event.getProperty().equals(getFiltersPreferenceName())) {
loadFiltersPreferences();
clearEnabledFilters();
refreshForFocusUpdate();
}
}
};
IDEWorkbenchPlugin.getDefault().getPreferenceStore()
.addPropertyChangeListener(preferenceListener);
}
/**
* Get the current markers for the receiver.
*
* @return MarkerList
*/
public MarkerList getCurrentMarkers() {
return getMarkerAdapter().getCurrentMarkers();
}
/**
* Get the marker adapter for the receiver.
*
* @return MarkerAdapter
*/
protected MarkerAdapter getMarkerAdapter() {
return adapter;
}
/**
* Update for the change in the contents.
*
* @param monitor
*/
public void updateForContentsRefresh(IProgressMonitor monitor) {
updateJob.cancel();
getMarkerAdapter().buildAllMarkers(monitor);
getProgressService().schedule(updateJob);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.IViewPart#init(org.eclipse.ui.IViewSite,
* org.eclipse.ui.IMemento)
*/
public void init(IViewSite site, IMemento memento) throws PartInitException {
super.init(site, memento);
IWorkbenchSiteProgressService progressService = getProgressService();
if (progressService != null) {
getProgressService().showBusyForFamily(
ResourcesPlugin.FAMILY_MANUAL_BUILD);
getProgressService().showBusyForFamily(
ResourcesPlugin.FAMILY_AUTO_BUILD);
getProgressService().showBusyForFamily(MARKER_UPDATE_FAMILY);
}
loadFiltersPreferences();
}
/**
* Load the filters preference.
*/
private void loadFiltersPreferences() {
String preference = IDEWorkbenchPlugin.getDefault()
.getPreferenceStore().getString(getFiltersPreferenceName());
if (preference.equals(IPreferenceStore.STRING_DEFAULT_DEFAULT)) {
createDefaultFilter();
return;
}
StringReader reader = new StringReader(preference);
try {
restoreFilters(XMLMemento.createReadRoot(reader));
} catch (WorkbenchException e) {
IDEWorkbenchPlugin.log(e.getLocalizedMessage(), e);
}
}
/**
* Update for filter changes. Save the preference and clear the enabled
* cache.
*/
void updateForFilterChanges() {
XMLMemento memento = XMLMemento.createWriteRoot(TAG_FILTERS_SECTION);
writeFiltersSettings(memento);
StringWriter writer = new StringWriter();
try {
memento.save(writer);
} catch (IOException e) {
IDEWorkbenchPlugin.getDefault().getLog().log(Util.errorStatus(e));
}
IDEWorkbenchPlugin.getDefault().getPreferenceStore().putValue(
getFiltersPreferenceName(), writer.toString());
IDEWorkbenchPlugin.getDefault().savePluginPreferences();
clearEnabledFilters();
refreshFilterMenu();
refreshViewer();
}
/**
* Write the filter settings to the memento.
*
* @param memento
*/
protected void writeFiltersSettings(XMLMemento memento) {
MarkerFilter[] filters = getUserFilters();
for (int i = 0; i < filters.length; i++) {
IMemento child = memento.createChild(TAG_FILTER_ENTRY, filters[i]
.getName());
filters[i].saveFilterSettings(child);
}
}
/**
* Get the name of the filters preference for instances of the receiver.
*
* @return String
*/
abstract String getFiltersPreferenceName();
/**
* Restore the filters from the mimento.
*
* @param memento
*/
void restoreFilters(IMemento memento) {
IMemento[] sections = null;
if (memento != null) {
sections = memento.getChildren(TAG_FILTER_ENTRY);
}
if (sections == null) {
// Check if we have an old filter setting around
IDialogSettings mainSettings = getDialogSettings();
IDialogSettings filtersSection = mainSettings
.getSection(OLD_FILTER_SECTION);
if (filtersSection != null) {
MarkerFilter markerFilter = createFilter(MarkerMessages.MarkerFilter_defaultFilterName);
markerFilter.restoreFilterSettings(filtersSection);
setFilters(new MarkerFilter[] { markerFilter });
}
} else {
MarkerFilter[] newFilters = new MarkerFilter[sections.length];
for (int i = 0; i < sections.length; i++) {
newFilters[i] = createFilter(sections[i].getID());
newFilters[i].restoreState(sections[i]);
}
setFilters(newFilters);
}
if (markerFilters.length == 0) {// Make sure there is at least a default
createDefaultFilter();
}
}
/**
* Create a default filter for the receiver.
*
*/
private void createDefaultFilter() {
MarkerFilter filter = createFilter(MarkerMessages.MarkerFilter_defaultFilterName);
setFilters(new MarkerFilter[] { filter });
}
/**
* Create a filter called name.
*
* @param name
* @return MarkerFilter
*/
protected abstract MarkerFilter createFilter(String name);
/**
* Return the memento tag for the receiver.
*
* @return String
*/
protected abstract String getSectionTag();
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.internal.tableview.TableView#createPartControl(org.eclipse.swt.widgets.Composite)
*/
public void createPartControl(Composite parent) {
clipboard = new Clipboard(parent.getDisplay());
super.createPartControl(parent);
initDragAndDrop();
getSite().getPage().addSelectionListener(focusListener);
focusSelectionChanged(getSite().getPage().getActivePart(), getSite()
.getPage().getSelection());
PlatformUI.getWorkbench().getWorkingSetManager()
.addPropertyChangeListener(getWorkingSetListener());
// Set help on the view itself
getViewer().getControl().addHelpListener(new HelpListener() {
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.events.HelpListener#helpRequested(org.eclipse.swt.events.HelpEvent)
*/
public void helpRequested(HelpEvent e) {
IContext context = contextProvider.getContext(getViewer()
.getControl());
PlatformUI.getWorkbench().getHelpSystem().displayHelp(context);
}
});
// Hook up to the resource changes after all widget have been created
ResourcesPlugin.getWorkspace().addResourceChangeListener(
markerUpdateListener,
IResourceChangeEvent.POST_CHANGE
| IResourceChangeEvent.PRE_BUILD
| IResourceChangeEvent.POST_BUILD);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
*/
public Object getAdapter(Class adaptable) {
if (adaptable.equals(IContextProvider.class)) {
return contextProvider;
}
if (adaptable.equals(IShowInSource.class)) {
return new IShowInSource() {
public ShowInContext getShowInContext() {
ISelection selection = getViewer().getSelection();
if (!(selection instanceof IStructuredSelection)) {
return null;
}
IStructuredSelection structured = (IStructuredSelection) selection;
Iterator markerIterator = structured.iterator();
List newSelection = new ArrayList();
while (markerIterator.hasNext()) {
ConcreteMarker element = (ConcreteMarker) markerIterator
.next();
newSelection.add(element.getResource());
}
return new ShowInContext(getViewer().getInput(),
new StructuredSelection(newSelection));
}
};
}
return super.getAdapter(adaptable);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.markers.internal.TableView#viewerSelectionChanged(org.eclipse.jface.viewers.IStructuredSelection)
*/
protected void viewerSelectionChanged(IStructuredSelection selection) {
Object[] rawSelection = selection.toArray();
List markers = new ArrayList();
for (int idx = 0; idx < rawSelection.length; idx++) {
if (rawSelection[idx] instanceof ConcreteMarker)
markers.add(((ConcreteMarker) rawSelection[idx]).getMarker());
}
setSelection(new StructuredSelection(markers));
updateStatusMessage(selection);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.internal.tableview.TableView#dispose()
*/
public void dispose() {
super.dispose();
cancelJobs();
ResourcesPlugin.getWorkspace().removeResourceChangeListener(
markerUpdateListener);
PlatformUI.getWorkbench().getWorkingSetManager()
.removePropertyChangeListener(workingSetListener);
IDEWorkbenchPlugin.getDefault().getPreferenceStore()
.removePropertyChangeListener(preferenceListener);
getSite().getPage().removeSelectionListener(focusListener);
// dispose of selection provider actions (may not have been created yet
// if createPartControls was never called)
if (openAction != null) {
openAction.dispose();
copyAction.dispose();
selectAllAction.dispose();
deleteAction.dispose();
revealAction.dispose();
propertiesAction.dispose();
undoAction.dispose();
redoAction.dispose();
clipboard.dispose();
}
if (showInMenu != null) {
showInMenu.dispose();
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.internal.tableview.TableView#createActions()
*/
protected void createActions() {
revealAction = new ActionRevealMarker(this, getViewer());
openAction = new ActionOpenMarker(this, getViewer());
copyAction = new ActionCopyMarker(this, getViewer());
copyAction.setClipboard(clipboard);
copyAction.setProperties(getSortingFields());
pasteAction = new ActionPasteMarker(this, getViewer(), getMarkerName());
pasteAction.setClipboard(clipboard);
pasteAction.setPastableTypes(getMarkerTypes());
deleteAction = new ActionRemoveMarker(this, getViewer(),
getMarkerName());
selectAllAction = new ActionSelectAll(this);
propertiesAction = new ActionMarkerProperties(this, getViewer(),
getMarkerName());
IUndoContext undoContext = getUndoContext();
undoAction = new UndoActionHandler(getSite(), undoContext);
redoAction = new RedoActionHandler(getSite(), undoContext);
super.createActions();
setFilterAction(new FiltersAction(this));
setPreferencesAction(new ViewPreferencesAction() {
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.preferences.ViewPreferencesAction#openViewPreferencesDialog()
*/
public void openViewPreferencesDialog() {
openPreferencesDialog(getMarkerEnablementPreferenceName(),
getMarkerLimitPreferenceName());
}
});
}
/**
* Open a dialog to set the preferences.
*
* @param markerEnablementPreferenceName
* @param markerLimitPreferenceName
*/
private void openPreferencesDialog(String markerEnablementPreferenceName,
String markerLimitPreferenceName) {
Dialog dialog = new MarkerViewPreferenceDialog(getSite()
.getWorkbenchWindow().getShell(),
markerEnablementPreferenceName, markerLimitPreferenceName,
MarkerMessages.MarkerPreferences_DialogTitle);
if (dialog.open() == Window.OK) {
refreshViewer();
}
}
/**
* Get the name of the marker enablement preference.
*
* @return String
*/
abstract String getMarkerLimitPreferenceName();
abstract String[] getMarkerTypes();
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.internal.tableview.TableView#initToolBar(org.eclipse.jface.action.IToolBarManager)
*/
protected void initToolBar(IToolBarManager tbm) {
tbm.add(deleteAction);
tbm.add(getFilterAction());
tbm.update(false);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.internal.tableview.TableView#registerGlobalActions(org.eclipse.ui.IActionBars)
*/
protected void registerGlobalActions(IActionBars actionBars) {
copyAction.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_COPY);
pasteAction.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_PASTE);
deleteAction.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_DELETE);
selectAllAction.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_SELECT_ALL);
propertiesAction.setActionDefinitionId(IWorkbenchCommandConstants.FILE_PROPERTIES);
undoAction.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_UNDO);
redoAction.setActionDefinitionId(IWorkbenchCommandConstants.EDIT_REDO);
actionBars.setGlobalActionHandler(ActionFactory.COPY.getId(),
copyAction);
actionBars.setGlobalActionHandler(ActionFactory.PASTE.getId(),
pasteAction);
actionBars.setGlobalActionHandler(ActionFactory.DELETE.getId(),
deleteAction);
actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(),
selectAllAction);
actionBars.setGlobalActionHandler(ActionFactory.PROPERTIES.getId(),
propertiesAction);
actionBars.setGlobalActionHandler(ActionFactory.UNDO.getId(),
undoAction);
actionBars.setGlobalActionHandler(ActionFactory.REDO.getId(),
redoAction);
}
protected void initDragAndDrop() {
int operations = DND.DROP_COPY;
Transfer[] transferTypes = new Transfer[] {
MarkerTransfer.getInstance(), TextTransfer.getInstance() };
DragSourceListener listener = new DragSourceAdapter() {
public void dragSetData(DragSourceEvent event) {
performDragSetData(event);
}
public void dragFinished(DragSourceEvent event) {
}
};
getViewer().addDragSupport(operations, transferTypes, listener);
}
/**
* The user is attempting to drag marker data. Add the appropriate data to
* the event depending on the transfer type.
*/
private void performDragSetData(DragSourceEvent event) {
if (MarkerTransfer.getInstance().isSupportedType(event.dataType)) {
event.data = getSelectedMarkers();
return;
}
if (TextTransfer.getInstance().isSupportedType(event.dataType)) {
List selection = ((IStructuredSelection) getViewer().getSelection())
.toList();
try {
IMarker[] markers = new IMarker[selection.size()];
selection.toArray(markers);
if (markers != null) {
event.data = copyAction.createMarkerReport(markers);
}
} catch (ArrayStoreException e) {
}
}
}
/**
* Get the array of selected markers.
*
* @return IMarker[]
*/
private IMarker[] getSelectedMarkers() {
Object[] selection = ((IStructuredSelection) getViewer().getSelection())
.toArray();
ArrayList markers = new ArrayList();
for (int i = 0; i < selection.length; i++) {
if (selection[i] instanceof ConcreteMarker) {
markers.add(((ConcreteMarker) selection[i]).getMarker());
}
}
return (IMarker[]) markers.toArray(new IMarker[markers.size()]);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.internal.tableview.TableView#fillContextMenu(org.eclipse.jface.action.IMenuManager)
*/
protected void fillContextMenu(IMenuManager manager) {
if (manager == null) {
return;
}
manager.add(openAction);
createShowInMenu(manager);
manager.add(new Separator());
manager.add(copyAction);
pasteAction.updateEnablement();
manager.add(pasteAction);
if (canBeEditable()) {
manager.add(deleteAction);
}
manager.add(selectAllAction);
fillContextMenuAdditions(manager);
manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
manager.add(new Separator());
manager.add(propertiesAction);
}
/**
* Return whether or not any of the types in the receiver can be editable.
*
* @return <code>true</code> if it is possible to have an editable marker
* in this view.
*/
boolean canBeEditable() {
return true;
}
/**
* Fill the context menu for the receiver.
*
* @param manager
*/
abstract void fillContextMenuAdditions(IMenuManager manager);
/**
* Get the filters for the receiver.
*
* @return MarkerFilter[]
*/
protected final MarkerFilter[] getUserFilters() {
return markerFilters;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.internal.tableview.TableView#handleOpenEvent(org.eclipse.jface.viewers.OpenEvent)
*/
protected void handleOpenEvent(OpenEvent event) {
if (openAction.isEnabled()) {
openAction.run();
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.internal.tableview.TableView#saveSelection(org.eclipse.ui.IMemento)
*/
protected void saveSelection(IMemento memento) {
IStructuredSelection selection = (IStructuredSelection) getViewer()
.getSelection();
IMemento selectionMem = memento.createChild(TAG_SELECTION);
for (Iterator iterator = selection.iterator(); iterator.hasNext();) {
Object next = iterator.next();
if (!(next instanceof ConcreteMarker)) {
continue;
}
ConcreteMarker marker = (ConcreteMarker) next;
IMemento elementMem = selectionMem.createChild(TAG_MARKER);
elementMem.putString(TAG_RESOURCE, marker.getMarker().getResource()
.getFullPath().toString());
elementMem.putString(TAG_ID, String.valueOf(marker.getMarker()
.getId()));
}
}
protected abstract String[] getRootTypes();
/**
* @param part
* @param selection
*/
protected void focusSelectionChanged(IWorkbenchPart part,
ISelection selection) {
List selectedElements = new ArrayList();
if (part instanceof IEditorPart) {
IEditorPart editor = (IEditorPart) part;
IFile file = ResourceUtil.getFile(editor.getEditorInput());
if (file == null) {
IEditorInput editorInput = editor.getEditorInput();
if (editorInput != null) {
Object mapping = editorInput
.getAdapter(ResourceMapping.class);
if (mapping != null) {
selectedElements.add(mapping);
}
}
} else {
selectedElements.add(file);
}
} else {
if (selection instanceof IStructuredSelection) {
for (Iterator iterator = ((IStructuredSelection) selection)
.iterator(); iterator.hasNext();) {
Object object = iterator.next();
if (object instanceof IAdaptable) {
ITaskListResourceAdapter taskListResourceAdapter;
Object adapter = ((IAdaptable) object)
.getAdapter(ITaskListResourceAdapter.class);
if (adapter != null
&& adapter instanceof ITaskListResourceAdapter) {
taskListResourceAdapter = (ITaskListResourceAdapter) adapter;
} else {
taskListResourceAdapter = DefaultMarkerResourceAdapter
.getDefault();
}
IResource resource = taskListResourceAdapter
.getAffectedResource((IAdaptable) object);
if (resource == null) {
Object mapping = ((IAdaptable) object)
.getAdapter(ResourceMapping.class);
if (mapping != null) {
selectedElements.add(mapping);
}
} else {
selectedElements.add(resource);
}
}
}
}
}
updateFocusMarkers(selectedElements.toArray());
}
/**
* Update the focus resources of the filters.
*
* @param elements
*/
protected final void updateFilterSelection(Object[] elements) {
Collection resourceCollection = new ArrayList();
for (int i = 0; i < elements.length; i++) {
if (elements[i] instanceof IResource) {
resourceCollection.add(elements[i]);
} else {
addResources(resourceCollection,
((ResourceMapping) elements[i]));
}
}
IResource[] resources = new IResource[resourceCollection.size()];
resourceCollection.toArray(resources);
for (int i = 0; i < markerFilters.length; i++) {
markerFilters[i].setFocusResource(resources);
}
Iterator systemFilters = MarkerSupportRegistry.getInstance()
.getRegisteredFilters().iterator();
while (systemFilters.hasNext()) {
MarkerFilter filter = (MarkerFilter) systemFilters.next();
filter.setFocusResource(resources);
}
}
/**
* Add the resources for the mapping to resources.
*
* @param resources
* @param mapping
*/
private void addResources(Collection resources, ResourceMapping mapping) {
try {
ResourceTraversal[] traversals = mapping.getTraversals(
ResourceMappingContext.LOCAL_CONTEXT,
new NullProgressMonitor());
for (int i = 0; i < traversals.length; i++) {
ResourceTraversal traversal = traversals[i];
IResource[] result = traversal.getResources();
for (int j = 0; j < result.length; j++) {
resources.add(result[j]);
}
}
} catch (CoreException e) {
Policy.handle(e);
return;
}
}
protected abstract String getStaticContextId();
/**
* Update the focus markers for the supplied elements.
*
* @param elements
*/
void updateFocusMarkers(Object[] elements) {
boolean updateNeeded = updateNeeded(focusElements, elements);
if (updateNeeded) {
focusElements = elements;
refreshForFocusUpdate();
}
}
private boolean updateNeeded(Object[] oldElements, Object[] newElements) {
// determine if an update if refiltering is required
MarkerFilter[] filters = getEnabledFilters();
boolean updateNeeded = false;
for (int i = 0; i < filters.length; i++) {
MarkerFilter filter = filters[i];
if (!filter.isEnabled()) {
continue;
}
int onResource = filter.getOnResource();
if (onResource == MarkerFilter.ON_ANY
|| onResource == MarkerFilter.ON_WORKING_SET) {
continue;
}
if (newElements == null || newElements.length < 1) {
continue;
}
if (oldElements == null || oldElements.length < 1) {
return true;
}
if (Arrays.equals(oldElements, newElements)) {
continue;
}
if (onResource == MarkerFilter.ON_ANY_IN_SAME_CONTAINER) {
Collection oldProjects = MarkerFilter
.getProjectsAsCollection(oldElements);
Collection newProjects = MarkerFilter
.getProjectsAsCollection(newElements);
if (oldProjects.size() == newProjects.size()) {
if (newProjects.containsAll(oldProjects)) {
continue;
}
}
return true;
}
updateNeeded = true;// We are updating as there is nothing to stop
// us
}
return updateNeeded;
}
void updateTitle() {
String status = Util.EMPTY_STRING;
int filteredCount = getCurrentMarkers().getItemCount();
int totalCount = getTotalMarkers();
if (filteredCount == totalCount) {
status = NLS.bind(MarkerMessages.filter_itemsMessage, new Integer(
totalCount));
} else {
status = NLS.bind(MarkerMessages.filter_matchedMessage,
new Integer(filteredCount), new Integer(totalCount));
}
setContentDescription(status);
}
/**
* Updates the message displayed in the status line. This method is invoked
* in the following cases:
* <ul>
* <li>when this view is first created</li>
* <li>when new elements are added</li>
* <li>when something is deleted</li>
* <li>when the filters change</li>
* </ul>
* <p>
* By default, this method calls
* <code>updateStatusMessage(IStructuredSelection)</code> with the current
* selection or <code>null</code>. Classes wishing to override this
* functionality, should just override the method
* <code>updateStatusMessage(IStructuredSelection)</code>.
* </p>
*/
protected void updateStatusMessage() {
ISelection selection = getViewer().getSelection();
if (selection instanceof IStructuredSelection) {
updateStatusMessage((IStructuredSelection) selection);
} else {
updateStatusMessage(null);
}
}
/**
* Updates that message displayed in the status line. If the selection
* parameter is <code>null</code> or its size is 0, the status area is
* blanked out. If only 1 marker is selected, the status area is updated
* with the contents of the message attribute of this marker. In other cases
* (more than one marker is selected) the status area indicates how many
* items have been selected.
* <p>
* This method may be overwritten.
* </p>
* <p>
* This method is called whenever a selection changes in this view.
* </p>
*
* @param selection
* a valid selection or <code>null</code>
*/
protected void updateStatusMessage(IStructuredSelection selection) {
String message = ""; //$NON-NLS-1$
if (selection == null || selection.size() == 0) {
// Show stats on all items in the view
message = updateSummaryVisible();
} else if (selection.size() == 1) {
// Use the Message attribute of the marker
Object first = selection.getFirstElement();
if (first instanceof ConcreteMarker) {
message = ((ConcreteMarker) first).getDescription();
}
} else if (selection.size() > 1) {
// Show stats on only those items in the selection
message = updateSummarySelected(selection);
}
getViewSite().getActionBars().getStatusLineManager()
.setMessage(message);
}
/**
* @param selection
* @return the summary status message
*/
protected String updateSummarySelected(IStructuredSelection selection) {
// Show how many items selected
return MessageFormat.format(
MarkerMessages.marker_statusSummarySelected,
new Object[] { new Integer(selection.size()) });
}
/**
* @return the update summary
*/
protected String updateSummaryVisible() {
return ""; //$NON-NLS-1$
}
/**
* Open a dialog on the filters
*
*/
public final void openFiltersDialog() {
DialogMarkerFilter dialog = createFiltersDialog();
if (dialog.open() == Window.OK) {
MarkerFilter[] result = dialog.getFilters();
if (result == null) {
return;
}
if (result.length == 0) {
setFilters(new MarkerFilter[] { createFilter(MarkerMessages.MarkerFilter_defaultFilterName) });
} else {
setFilters(result);
}
updateForFilterChanges();
}
}
/**
* Refresh the contents of the viewer.
*/
public void refreshViewer() {
scheduleMarkerUpdate(Util.SHORT_DELAY);
}
/**
* Set the filters to newFilters.
*
* @param newFilters
*/
void setFilters(MarkerFilter[] newFilters) {
markerFilters = newFilters;
}
/**
* Clear the cache of enabled filters.
*
*/
void clearEnabledFilters() {
enabledFilters = null;
}
/**
* Refresh the contents of the filter sub menu.
*/
private void refreshFilterMenu() {
if (filtersMenu == null) {
return;
}
filtersMenu.removeAll();
MarkerFilter[] filters = getAllFilters();
for (int i = 0; i < filters.length; i++) {
filtersMenu.add(new FilterEnablementAction(filters[i], this));
}
}
/**
* Open a filter dialog on the receiver.
*/
protected abstract DialogMarkerFilter createFiltersDialog();
/**
* Given a selection of IMarker, reveals the corresponding elements in the
* viewer
*
* @param structuredSelection
* @param reveal
*/
public void setSelection(IStructuredSelection structuredSelection,
boolean reveal) {
TreeViewer viewer = getViewer();
List newSelection = new ArrayList(structuredSelection.size());
for (Iterator i = structuredSelection.iterator(); i.hasNext();) {
Object next = i.next();
if (next instanceof IMarker) {
ConcreteMarker marker = getCurrentMarkers().getMarker(
(IMarker) next);
if (marker != null) {
newSelection.add(marker);
}
}
}
if (viewer != null) {
viewer.setSelection(new StructuredSelection(newSelection), reveal);
}
}
protected MarkerList getVisibleMarkers() {
return getCurrentMarkers();
}
/**
* Returns the total number of markers. Should not be called while the
* marker list is still updating.
*
* @return the total number of markers in the workspace (including
* everything that doesn't pass the filters)
*/
int getTotalMarkers() {
// The number of visible markers should never exceed the total number of
// markers in
// the workspace. If this assertation fails, it probably indicates some
// sort of concurrency problem
// (most likely, getTotalMarkers was called while we were still
// computing the marker lists)
// Assert.isTrue(totalMarkers >= currentMarkers.getItemCount());
return totalMarkers;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.part.WorkbenchPart#showBusy(boolean)
*/
public void showBusy(boolean busy) {
super.showBusy(busy);
if (busy) {
preBusyMarkers = totalMarkers;
} else {// Only bold if there has been a change in count
if (totalMarkers != preBusyMarkers) {
getProgressService().warnOfContentChange();
}
}
}
/**
* Get the filters that are currently enabled.
*
* @return MarkerFilter[]
*/
MarkerFilter[] getEnabledFilters() {
if (enabledFilters == null) {
Collection filters = findEnabledFilters();
enabledFilters = new MarkerFilter[filters.size()];
filters.toArray(enabledFilters);
}
return enabledFilters;
}
/**
* Find the filters enabled in the view.
*
* @return Collection of MarkerFilter
*/
protected Collection findEnabledFilters() {
MarkerFilter[] allFilters = getAllFilters();
ArrayList filters = new ArrayList(0);
for (int i = 0; i < allFilters.length; i++) {
if (allFilters[i].isEnabled()) {
filters.add(allFilters[i]);
}
}
return filters;
}
/**
* Get all of the filters applied to the receiver.
*
* @return MarkerFilter[]
*/
MarkerFilter[] getAllFilters() {
return getUserFilters();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.markers.internal.TableView#addDropDownContributions(org.eclipse.jface.action.IMenuManager)
*/
void addDropDownContributions(IMenuManager menu) {
super.addDropDownContributions(menu);
menu.add(new Separator(MENU_FILTERS_GROUP));
// Don't add in the filters until they are set
filtersMenu = new MenuManager(MarkerMessages.filtersSubMenu_title);
refreshFilterMenu();
menu.appendToGroup(MENU_FILTERS_GROUP, filtersMenu);
}
/**
* Create the show in menu if there is a single selection.
*
* @param menu
*/
void createShowInMenu(IMenuManager menu) {
ISelection selection = getViewer().getSelection();
if (!(selection instanceof IStructuredSelection)) {
return;
}
IStructuredSelection structured = (IStructuredSelection) selection;
if (!Util.isSingleConcreteSelection(structured)) {
return;
}
menu.add(new Separator(MENU_SHOW_IN_GROUP));
// Don't add in the filters until they are set
String showInLabel = IDEWorkbenchMessages.Workbench_showIn;
IBindingService bindingService = (IBindingService) PlatformUI
.getWorkbench().getAdapter(IBindingService.class);
if (bindingService != null) {
String keyBinding = bindingService
.getBestActiveBindingFormattedFor(IWorkbenchCommandConstants.NAVIGATE_SHOW_IN_QUICK_MENU);
if (keyBinding != null) {
showInLabel += '\t' + keyBinding;
}
}
showInMenu = new MenuManager(showInLabel);
showInMenu.add(ContributionItemFactory.VIEWS_SHOW_IN
.create(getViewSite().getWorkbenchWindow()));
menu.appendToGroup(MENU_SHOW_IN_GROUP, showInMenu);
}
/**
* Refresh the marker counts
*
* @param monitor
*/
void refreshMarkerCounts(IProgressMonitor monitor) {
monitor.subTask(MarkerMessages.MarkerView_refreshing_counts);
try {
totalMarkers = MarkerList.compute(getMarkerTypes()).length;
} catch (CoreException e) {
Policy.handle(e);
return;
}
}
/**
* Returns the marker limit or -1 if unlimited
*
* @return int
*/
int getMarkerLimit() {
// If limits are enabled return it. Otherwise return -1
if (IDEWorkbenchPlugin.getDefault().getPreferenceStore().getBoolean(
getMarkerEnablementPreferenceName())) {
return IDEWorkbenchPlugin.getDefault().getPreferenceStore().getInt(
getMarkerLimitPreferenceName());
}
return -1;
}
/**
* Get the name of the marker limit preference.
*
* @return String
*/
abstract String getMarkerEnablementPreferenceName();
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.markers.internal.TableView#createViewerInput()
*/
Object createViewerInput() {
adapter = new MarkerAdapter(this);
return adapter;
}
/**
* Add a listener for the end of the update.
*
* @param listener
*/
public void addUpdateFinishListener(IJobChangeListener listener) {
updateJob.addJobChangeListener(listener);
}
/**
* Remove a listener for the end of the update.
*
* @param listener
*/
public void removeUpdateFinishListener(IJobChangeListener listener) {
updateJob.removeJobChangeListener(listener);
}
/**
* Create a listener for working set changes.
*
* @return IPropertyChangeListener
*/
private IPropertyChangeListener getWorkingSetListener() {
workingSetListener = new IPropertyChangeListener() {
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
*/
public void propertyChange(PropertyChangeEvent event) {
clearEnabledFilters();
refreshViewer();
}
};
return workingSetListener;
}
/**
* Schedule an update of the markers with a delay of time
*
* @param time
*/
void scheduleMarkerUpdate(int time) {
cancelJobs();
getProgressService().schedule(markerProcessJob, time);
}
/**
* Cancel the pending jobs in the receiver.
*/
private void cancelJobs() {
markerProcessJob.cancel();
updateJob.cancel();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.views.markers.internal.TableView#createTree(org.eclipse.swt.widgets.Composite)
*/
protected Tree createTree(Composite parent) {
Tree tree = super.createTree(parent);
tree.addTreeListener(new TreeAdapter() {
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.events.TreeAdapter#treeCollapsed(org.eclipse.swt.events.TreeEvent)
*/
public void treeCollapsed(TreeEvent e) {
updateJob.removeExpandedCategory((MarkerCategory) e.item
.getData());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.events.TreeAdapter#treeExpanded(org.eclipse.swt.events.TreeEvent)
*/
public void treeExpanded(TreeEvent e) {
updateJob
.addExpandedCategory((MarkerCategory) e.item.getData());
}
});
return tree;
}
/**
* The focus elements have changed. Update accordingly.
*/
private void refreshForFocusUpdate() {
if (focusElements != null) {
updateFilterSelection(focusElements);
refreshViewer();
}
}
/**
* Save the current selection in the update for reselection after update.
*/
protected void preserveSelection() {
updateJob.saveSelection(getViewer().getSelection());
}
/**
* Return the string name of the specific type of marker shown in this view.
*/
protected abstract String getMarkerName();
/**
* Return the undo context associated with operations performed in this
* view. By default, return the workspace undo context. Subclasses should
* override if a more specific undo context should be used.
*/
protected IUndoContext getUndoContext() {
return (IUndoContext) ResourcesPlugin.getWorkspace().getAdapter(
IUndoContext.class);
}
}