/*******************************************************************************
* Copyright (c) 2000, 2017 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.dltk.ui.browsing;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExecutableExtension;
import org.eclipse.core.runtime.IPath;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IDLTKLanguageToolkit;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IPackageDeclaration;
import org.eclipse.dltk.core.IScriptFolder;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.internal.ui.actions.BuildActionGroup;
import org.eclipse.dltk.internal.ui.actions.CCPActionGroup;
import org.eclipse.dltk.internal.ui.actions.CompositeActionGroup;
import org.eclipse.dltk.internal.ui.actions.ImportActionGroup;
import org.eclipse.dltk.internal.ui.actions.NewWizardsActionGroup;
import org.eclipse.dltk.internal.ui.actions.refactoring.RefactorActionGroup;
import org.eclipse.dltk.internal.ui.editor.EditorUtility;
import org.eclipse.dltk.internal.ui.search.SearchUtil;
import org.eclipse.dltk.internal.ui.workingsets.WorkingSetFilterActionGroup;
import org.eclipse.dltk.ui.DLTKUIPlugin;
import org.eclipse.dltk.ui.IWorkingCopyManager;
import org.eclipse.dltk.ui.ModelElementLabelProvider;
import org.eclipse.dltk.ui.ModelElementSorter;
import org.eclipse.dltk.ui.ScriptElementImageProvider;
import org.eclipse.dltk.ui.ScriptElementLabels;
import org.eclipse.dltk.ui.actions.CustomFiltersActionGroup;
import org.eclipse.dltk.ui.actions.OpenEditorActionGroup;
import org.eclipse.dltk.ui.actions.OpenViewActionGroup;
import org.eclipse.dltk.ui.actions.SearchActionGroup;
import org.eclipse.dltk.ui.infoviews.AbstractInfoView;
import org.eclipse.dltk.ui.viewsupport.AppearanceAwareLabelProvider;
import org.eclipse.dltk.ui.viewsupport.DecoratingModelLabelProvider;
import org.eclipse.dltk.ui.viewsupport.IViewPartInputProvider;
import org.eclipse.dltk.ui.viewsupport.ProblemTableViewer;
import org.eclipse.dltk.ui.viewsupport.ScriptUILabelProvider;
import org.eclipse.dltk.ui.viewsupport.StatusBarUpdater;
import org.eclipse.dltk.ui.viewsupport.StyledDecoratingModelLabelProvider;
import org.eclipse.jface.action.IAction;
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.text.ITextSelection;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.IContentProvider;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.search.internal.ui.Messages;
import org.eclipse.search.ui.ISearchResultViewPart;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPartListener2;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.IWorkingSetManager;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionContext;
import org.eclipse.ui.actions.ActionGroup;
import org.eclipse.ui.contexts.IContextActivation;
import org.eclipse.ui.contexts.IContextService;
import org.eclipse.ui.part.IShowInSource;
import org.eclipse.ui.part.ShowInContext;
import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.texteditor.ITextEditor;
public abstract class ScriptBrowsingPart extends ViewPart
implements IMenuListener, ISelectionListener, IViewPartInputProvider,
IExecutableExtension {
private static final String TAG_SELECTED_ELEMENTS = "selectedElements"; //$NON-NLS-1$
private static final String TAG_SELECTED_ELEMENT = "selectedElement"; //$NON-NLS-1$
private static final String TAG_LOGICAL_PACKAGE = "logicalPackage"; //$NON-NLS-1$
private static final String TAG_SELECTED_ELEMENT_PATH = "selectedElementPath"; //$NON-NLS-1$
private ScriptUILabelProvider fLabelProvider;
private ILabelProvider fTitleProvider;
private StructuredViewer fViewer;
private IMemento fMemento;
private ScriptElementTypeComparator fTypeComparator;
// Actions
private WorkingSetFilterActionGroup fWorkingSetFilterActionGroup;
private boolean fHasWorkingSetFilter = true;
private boolean fHasCustomFilter = true;
private OpenEditorActionGroup fOpenEditorGroup;
private CCPActionGroup fCCPActionGroup;
private BuildActionGroup fBuildActionGroup;
private ToggleLinkingAction fToggleLinkingAction;
protected CompositeActionGroup fActionGroups;
private IContextActivation fContextActivation;
// Filters
private CustomFiltersActionGroup fCustomFiltersActionGroup;
protected IWorkbenchPart fPreviousSelectionProvider;
protected Object fPreviousSelectedElement;
// Linking
private boolean fLinkingEnabled;
/*
* Ensure selection changed events being processed only if initiated by user
* interaction with this part.
*/
private boolean fProcessSelectionEvents = true;
private IPartListener2 fPartListener = new IPartListener2() {
@Override
public void partActivated(IWorkbenchPartReference ref) {
}
@Override
public void partBroughtToTop(IWorkbenchPartReference ref) {
}
@Override
public void partInputChanged(IWorkbenchPartReference ref) {
}
@Override
public void partClosed(IWorkbenchPartReference ref) {
}
@Override
public void partDeactivated(IWorkbenchPartReference ref) {
}
@Override
public void partOpened(IWorkbenchPartReference ref) {
}
@Override
public void partVisible(IWorkbenchPartReference ref) {
if (ref != null && ref.getId() == getSite().getId()) {
fProcessSelectionEvents = true;
IWorkbenchPage page = getSite().getWorkbenchWindow()
.getActivePage();
if (page != null)
selectionChanged(page.getActivePart(), page.getSelection());
}
}
@Override
public void partHidden(IWorkbenchPartReference ref) {
if (ref != null && ref.getId() == getSite().getId())
fProcessSelectionEvents = false;
}
};
private IDLTKLanguageToolkit fToolkit;
public ScriptBrowsingPart() {
super();
initLinkingEnabled();
}
/*
* Implements method from IViewPart.
*/
@Override
public void init(IViewSite site, IMemento memento)
throws PartInitException {
super.init(site, memento);
fMemento = memento;
}
/*
* Implements method from IViewPart.
*/
@Override
public void saveState(IMemento memento) {
if (fViewer == null) {
// part has not been created
if (fMemento != null) // Keep the old state;
memento.putMemento(fMemento);
return;
}
if (fHasWorkingSetFilter)
fWorkingSetFilterActionGroup.saveState(memento);
if (fHasCustomFilter)
fCustomFiltersActionGroup.saveState(memento);
saveSelectionState(memento);
saveLinkingEnabled(memento);
}
private void saveLinkingEnabled(IMemento memento) {
memento.putInteger(getLinkToEditorKey(), fLinkingEnabled ? 1 : 0);
}
private void saveSelectionState(IMemento memento) {
Object elements[] = ((IStructuredSelection) fViewer.getSelection())
.toArray();
if (elements.length > 0) {
IMemento selectionMem = memento.createChild(TAG_SELECTED_ELEMENTS);
for (int i = 0; i < elements.length; i++) {
IMemento elementMem = selectionMem
.createChild(TAG_SELECTED_ELEMENT);
Object o = elements[i];
if (o instanceof IModelElement)
elementMem.putString(TAG_SELECTED_ELEMENT_PATH,
((IModelElement) elements[i])
.getHandleIdentifier());
else if (o instanceof LogicalPackage) {
IScriptFolder[] packages = ((LogicalPackage) o)
.getScriptFolders();
for (int j = 0; j < packages.length; j++) {
IMemento packageMem = elementMem
.createChild(TAG_LOGICAL_PACKAGE);
packageMem.putString(TAG_SELECTED_ELEMENT_PATH,
packages[j].getHandleIdentifier());
}
}
}
}
}
protected void restoreState(IMemento memento) {
if (fHasWorkingSetFilter)
fWorkingSetFilterActionGroup.restoreState(memento);
if (fHasCustomFilter)
fCustomFiltersActionGroup.restoreState(memento);
if (fHasCustomFilter || fHasWorkingSetFilter) {
fViewer.getControl().setRedraw(false);
fViewer.refresh();
fViewer.getControl().setRedraw(true);
}
}
private ISelection restoreSelectionState(IMemento memento) {
if (memento == null)
return null;
IMemento childMem;
childMem = memento.getChild(TAG_SELECTED_ELEMENTS);
if (childMem != null) {
ArrayList list = new ArrayList();
IMemento[] elementMem = childMem.getChildren(TAG_SELECTED_ELEMENT);
for (int i = 0; i < elementMem.length; i++) {
String javaElementHandle = elementMem[i]
.getString(TAG_SELECTED_ELEMENT_PATH);
if (javaElementHandle == null) {
// logical package
IMemento[] packagesMem = elementMem[i]
.getChildren(TAG_LOGICAL_PACKAGE);
LogicalPackage lp = null;
for (int j = 0; j < packagesMem.length; j++) {
javaElementHandle = packagesMem[j]
.getString(TAG_SELECTED_ELEMENT_PATH);
Object pack = DLTKCore.create(javaElementHandle);
if (pack instanceof IScriptFolder
&& ((IScriptFolder) pack).exists()) {
if (lp == null)
lp = new LogicalPackage((IScriptFolder) pack);
else
lp.add((IScriptFolder) pack);
}
}
if (lp != null)
list.add(lp);
} else {
IModelElement element = DLTKCore.create(javaElementHandle);
if (element != null && element.exists())
list.add(element);
}
}
return new StructuredSelection(list);
}
return null;
}
private void restoreLinkingEnabled(IMemento memento) {
Integer val = memento.getInteger(getLinkToEditorKey());
if (val != null) {
fLinkingEnabled = val.intValue() != 0;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.
* widgets .Composite)
*/
@Override
public void createPartControl(Composite parent) {
Assert.isTrue(fViewer == null);
fTypeComparator = new ScriptElementTypeComparator();
// Setup viewer
fViewer = createViewer(parent);
initDragAndDrop();
fLabelProvider = createLabelProvider();
fViewer.setLabelProvider(createDelegatingLabelProvider(fLabelProvider));
fViewer.setComparator(createModelElementComparator());
fViewer.setUseHashlookup(true);
fTitleProvider = createTitleProvider();
createContextMenu();
getSite().setSelectionProvider(fViewer);
if (fMemento != null) { // initialize linking state before creating the
// actions
restoreLinkingEnabled(fMemento);
}
createActions(); // call before registering for selection changes
addKeyListener();
if (fMemento != null)
restoreState(fMemento);
getSite().setSelectionProvider(fViewer);
// Status line
IStatusLineManager slManager = getViewSite().getActionBars()
.getStatusLineManager();
fViewer.addSelectionChangedListener(createStatusBarUpdater(slManager));
hookViewerListeners();
// Filters
addFilters();
// Initialize viewer input
fViewer.setContentProvider(createContentProvider());
setInitialInput();
// Initialize selection
setInitialSelection();
fMemento = null;
// Listen to page changes
getViewSite().getPage().addPostSelectionListener(this);
getViewSite().getPage().addPartListener(fPartListener);
fillActionBars(getViewSite().getActionBars());
IContextService ctxService = getSite()
.getService(IContextService.class);
if (ctxService != null) {
fContextActivation = ctxService
.activateContext(DLTKUIPlugin.CONTEXT_VIEWS);
}
setHelp();
}
@SuppressWarnings("unchecked")
@Override
public <T> T getAdapter(Class<T> key) {
if (key == IShowInSource.class) {
return (T) getShowInSource();
}
// if (key == IContextProvider.class)
// return JavaUIHelp.getHelpContextProvider(this, getHelpContextId());
return super.getAdapter(key);
}
/**
* Returns the <code>IShowInSource</code> for this view.
*
* @return returns the <code>IShowInSource</code>
*/
protected IShowInSource getShowInSource() {
return () -> new ShowInContext(null,
getSite().getSelectionProvider().getSelection());
}
/**
* @since 5.2
*/
protected ILabelProvider createDelegatingLabelProvider(
ScriptUILabelProvider provider) {
DecoratingModelLabelProvider labelprovider = createDecoratingLabelProvider(
provider);
if (labelprovider != null)
return labelprovider;
return new StyledDecoratingModelLabelProvider(provider);
}
/**
* @deprecated override
* org.eclipse.dltk.ui.browsing.ScriptBrowsingPart.createDelegatingLabelProvider
* (ScriptUILabelProvider) instead
*/
@Deprecated
protected DecoratingModelLabelProvider createDecoratingLabelProvider(
ScriptUILabelProvider provider) {
// XXX: Work in progress for problem decorator being a workbench
// decorator//
// return new ExcludingDecoratingLabelProvider(provider, decorationMgr,
// "org.eclipse.jdt.ui.problem.decorator"); //$NON-NLS-1$
return null;
}
protected ModelElementSorter createModelElementComparator() {
return new ModelElementSorter();
}
protected StatusBarUpdater createStatusBarUpdater(
IStatusLineManager slManager) {
return new StatusBarUpdater(slManager);
}
protected void createContextMenu() {
MenuManager menuManager = new MenuManager("#PopupMenu"); //$NON-NLS-1$
menuManager.setRemoveAllWhenShown(true);
menuManager.addMenuListener(this);
Menu contextMenu = menuManager.createContextMenu(fViewer.getControl());
fViewer.getControl().setMenu(contextMenu);
getSite().registerContextMenu(menuManager, fViewer);
}
protected void initDragAndDrop() {
// int ops = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
// // drop
// Transfer[] dropTransfers = new Transfer[] { LocalSelectionTransfer
// .getInstance() };
// TransferDropTargetListener[] dropListeners = new
// TransferDropTargetListener[] { new SelectionTransferDropAdapter(
// fViewer) };
// fViewer.addDropSupport(ops | DND.DROP_DEFAULT, dropTransfers,
// new DelegatingDropAdapter(dropListeners));
//
// // Drag
// Transfer[] dragTransfers = new Transfer[] {
// LocalSelectionTransfer.getInstance(),
// ResourceTransfer.getInstance() };
// TransferDragSourceListener[] dragListeners = new
// TransferDragSourceListener[] {
// new SelectionTransferDragAdapter(fViewer),
// new ResourceTransferDragAdapter(fViewer) };
// fViewer.addDragSupport(ops, dragTransfers, new DLTKViewerDragAdapter(
// fViewer, dragListeners));
}
protected void fillActionBars(IActionBars actionBars) {
IToolBarManager toolBar = actionBars.getToolBarManager();
fillToolBar(toolBar);
if (fHasWorkingSetFilter)
fWorkingSetFilterActionGroup
.fillActionBars(getViewSite().getActionBars());
actionBars.updateActionBars();
fActionGroups.fillActionBars(actionBars);
if (fHasCustomFilter)
fCustomFiltersActionGroup.fillActionBars(actionBars);
IMenuManager menu = actionBars.getMenuManager();
menu.add(fToggleLinkingAction);
}
// ---- IWorkbenchPart
// ------------------------------------------------------
@Override
public void setFocus() {
fViewer.getControl().setFocus();
}
@Override
public void dispose() {
if (fContextActivation != null) {
IContextService ctxService = getSite()
.getService(IContextService.class);
if (ctxService != null) {
ctxService.deactivateContext(fContextActivation);
}
}
if (fViewer != null) {
getViewSite().getPage().removePostSelectionListener(this);
getViewSite().getPage().removePartListener(fPartListener);
fViewer = null;
}
if (fActionGroups != null)
fActionGroups.dispose();
if (fWorkingSetFilterActionGroup != null) {
fWorkingSetFilterActionGroup.dispose();
}
super.dispose();
}
/**
* Adds the KeyListener
*/
protected void addKeyListener() {
fViewer.getControl().addKeyListener(new KeyAdapter() {
@Override
public void keyReleased(KeyEvent event) {
handleKeyReleased(event);
}
});
}
protected void handleKeyReleased(KeyEvent event) {
if (event.stateMask != 0)
return;
int key = event.keyCode;
if (key == SWT.F5) {
IAction action = fBuildActionGroup.getRefreshAction();
if (action.isEnabled())
action.run();
}
}
// ---- Adding Action to Toolbar -------------------------------------------
protected void fillToolBar(IToolBarManager tbm) {
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.jface.action.IMenuListener#menuAboutToShow(org.eclipse.jface
* .action.IMenuManager)
*/
@Override
public void menuAboutToShow(IMenuManager menu) {
DLTKUIPlugin.createStandardGroups(menu);
IStructuredSelection selection = (IStructuredSelection) fViewer
.getSelection();
int size = selection.size();
Object element = selection.getFirstElement();
if (size == 1)
addOpenNewWindowAction(menu, element);
fActionGroups.setContext(new ActionContext(selection));
fActionGroups.fillContextMenu(menu);
fActionGroups.setContext(null);
}
private void addOpenNewWindowAction(IMenuManager menu, Object element) {
if (element instanceof IModelElement) {
element = ((IModelElement) element).getResource();
}
if (!(element instanceof IContainer))
return;
// menu.appendToGroup(IContextMenuConstants.GROUP_OPEN,
// new PatchedOpenInNewWindowAction(
// getSite().getWorkbenchWindow(), (IContainer) element));
}
protected IDLTKLanguageToolkit getToolkit() {
return this.fToolkit;
}
protected void createActions() {
fActionGroups = new CompositeActionGroup(
new ActionGroup[] { new NewWizardsActionGroup(this.getSite()),
fOpenEditorGroup = new OpenEditorActionGroup(this),
new OpenViewActionGroup(this),
fCCPActionGroup = new CCPActionGroup(this),
// new GenerateActionGroup(this),
new RefactorActionGroup(this, null),
new ImportActionGroup(this),
fBuildActionGroup = new BuildActionGroup(this),
new SearchActionGroup(this, this.getToolkit()) });
if (fHasWorkingSetFilter) {
String viewId = getConfigurationElement().getAttribute("id"); //$NON-NLS-1$
Assert.isNotNull(viewId);
IPropertyChangeListener workingSetListener = event -> doWorkingSetChanged(
event);
fWorkingSetFilterActionGroup = new WorkingSetFilterActionGroup(
getSite(), workingSetListener);
fViewer.addFilter(
fWorkingSetFilterActionGroup.getWorkingSetFilter());
}
// Custom filter group
if (fHasCustomFilter)
fCustomFiltersActionGroup = new CustomFiltersActionGroup(this,
fViewer);
fToggleLinkingAction = new ToggleLinkingAction(this);
}
private void doWorkingSetChanged(PropertyChangeEvent event) {
String property = event.getProperty();
if (IWorkingSetManager.CHANGE_WORKING_SET_NAME_CHANGE.equals(property))
updateTitle();
else if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE
.equals(property)) {
updateTitle();
fViewer.getControl().setRedraw(false);
fViewer.refresh();
fViewer.getControl().setRedraw(true);
}
}
/**
* Returns the shell to use for opening dialogs. Used in this class, and in
* the actions.
*
* @return returns the shell
*/
Shell getShell() {
return fViewer.getControl().getShell();
}
protected final Display getDisplay() {
return fViewer.getControl().getDisplay();
}
/**
* Returns the selection provider.
*
* @return the selection provider
*/
ISelectionProvider getSelectionProvider() {
return fViewer;
}
/**
* Answers if the given <code>element</code> is a valid input for this part.
*
* @param element
* the object to test
* @return <code>true</code> if the given element is a valid input
*/
abstract protected boolean isValidInput(Object element);
/**
* Answers if the given <code>element</code> is a valid element for this
* part.
*
* @param element
* the object to test
* @return <code>true</code> if the given element is a valid element
*/
protected boolean isValidElement(Object element) {
if (!(element instanceof IModelElement)) {
return false;
}
Object input = getViewer().getInput();
if (input == null)
return false;
if (input instanceof Collection)
return ((Collection) input).contains(element);
else
return input.equals(element);
}
private boolean isInputResetBy(Object newInput, Object input,
IWorkbenchPart part) {
if (newInput == null)
return part == fPreviousSelectionProvider;
if (input instanceof IModelElement && newInput instanceof IModelElement)
return getTypeComparator().compare(newInput, input) > 0;
if ((newInput instanceof List) && (part instanceof PackagesView))
return true;
else
return false;
}
private boolean isInputResetBy(IWorkbenchPart part) {
if (!(part instanceof ScriptBrowsingPart))
return true;
Object thisInput = getViewer().getInput();
Object partInput = ((ScriptBrowsingPart) part).getViewer().getInput();
if (thisInput instanceof Collection)
thisInput = ((Collection) thisInput).iterator().next();
if (partInput instanceof Collection)
partInput = ((Collection) partInput).iterator().next();
if (thisInput instanceof IModelElement
&& partInput instanceof IModelElement)
return getTypeComparator().compare(partInput, thisInput) > 0;
else
return true;
}
protected boolean isAncestorOf(Object ancestor, Object element) {
if (element instanceof IModelElement
&& ancestor instanceof IModelElement)
return !element.equals(ancestor) && internalIsAncestorOf(
(IModelElement) ancestor, (IModelElement) element);
if (element instanceof IModelElement && ancestor instanceof List) {
List l = (List) ancestor;
for (Iterator iterator = l.iterator(); iterator.hasNext();) {
IModelElement anc = (IModelElement) iterator.next();
if (element.equals(anc)
&& internalIsAncestorOf(anc, (IModelElement) element)) {
return true;
}
}
}
return false;
}
private boolean internalIsAncestorOf(IModelElement ancestor,
IModelElement element) {
if (element != null)
return element.equals(ancestor)
|| internalIsAncestorOf(ancestor, element.getParent());
else
return false;
}
private boolean isSearchResultView(IWorkbenchPart part) {
return SearchUtil.isSearchPlugInActivated()
&& part instanceof ISearchResultViewPart;
}
protected boolean needsToProcessSelectionChanged(IWorkbenchPart part,
ISelection selection) {
if (!fProcessSelectionEvents || part == this || isSearchResultView(part)
|| part instanceof AbstractInfoView) {
if (part == this)
fPreviousSelectionProvider = part;
return false;
}
return true;
}
@Override
public void selectionChanged(IWorkbenchPart part, ISelection selection) {
if (!needsToProcessSelectionChanged(part, selection))
return;
if (fToggleLinkingAction.isChecked() && (part instanceof ITextEditor)) {
setSelectionFromEditor(part, selection);
return;
}
if (!(selection instanceof IStructuredSelection))
return;
// Set selection
Object selectedElement = getSingleElementFromSelection(selection);
if (selectedElement != null
&& (part == null || part.equals(fPreviousSelectionProvider))
&& selectedElement.equals(fPreviousSelectedElement))
return;
fPreviousSelectedElement = selectedElement;
Object currentInput = getViewer().getInput();
if (selectedElement != null && selectedElement.equals(currentInput)) {
Object elementToSelect = findElementToSelect(selectedElement);
if (elementToSelect != null && getTypeComparator()
.compare(selectedElement, elementToSelect) < 0)
setSelection(new StructuredSelection(elementToSelect), true);
else if (elementToSelect == null && (this instanceof MembersView)) {
setSelection(StructuredSelection.EMPTY, true);
fPreviousSelectedElement = StructuredSelection.EMPTY;
}
fPreviousSelectionProvider = part;
return;
}
// Clear input if needed
if (part != fPreviousSelectionProvider && selectedElement != null
&& !selectedElement.equals(currentInput)
&& isInputResetBy(selectedElement, currentInput, part)) {
if (!isAncestorOf(selectedElement, currentInput))
setInput(null);
fPreviousSelectionProvider = part;
return;
} else if (selection.isEmpty() && !isInputResetBy(part)) {
fPreviousSelectionProvider = part;
return;
} else if (selectedElement == null
&& part == fPreviousSelectionProvider) {
setInput(null);
fPreviousSelectionProvider = part;
return;
}
fPreviousSelectionProvider = part;
// Adjust input and set selection and
adjustInputAndSetSelection(selectedElement);
}
void setHasWorkingSetFilter(boolean state) {
fHasWorkingSetFilter = state;
}
void setHasCustomSetFilter(boolean state) {
fHasCustomFilter = state;
}
protected Object getInput() {
return fViewer.getInput();
}
protected void setInput(Object input) {
setViewerInput(input);
updateTitle();
}
boolean isLinkingEnabled() {
return fLinkingEnabled;
}
private void initLinkingEnabled() {
fLinkingEnabled = DLTKUIPlugin.getDefault().getPreferenceStore()
.getBoolean(getLinkToEditorKey());
}
private void setViewerInput(Object input) {
fProcessSelectionEvents = false;
fViewer.setInput(input);
fProcessSelectionEvents = true;
}
void updateTitle() {
setTitleToolTip(getToolTipText(fViewer.getInput()));
}
/**
* Returns the tool tip text for the given element.
*
* @param element
* the element
* @return the tooltip for the element
*/
String getToolTipText(Object element) {
String result;
if (!(element instanceof IResource)) {
result = ScriptElementLabels.getDefault().getTextLabel(element,
AppearanceAwareLabelProvider.DEFAULT_TEXTFLAGS);
} else {
IPath path = ((IResource) element).getFullPath();
if (path.isRoot()) {
result = getConfigurationElement().getAttribute("name"); //$NON-NLS-1$
} else {
result = path.makeRelative().toString();
}
}
if (fWorkingSetFilterActionGroup == null
|| fWorkingSetFilterActionGroup.getWorkingSet() == null)
return result;
IWorkingSet ws = fWorkingSetFilterActionGroup.getWorkingSet();
String wsstr = Messages.format(
ScriptBrowsingMessages.JavaBrowsingPart_toolTip,
new String[] { ws.getLabel() });
if (result.length() == 0)
return wsstr;
return Messages.format(ScriptBrowsingMessages.JavaBrowsingPart_toolTip2,
new String[] { result, ws.getLabel() });
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.part.WorkbenchPart#getTitleToolTip()
*/
@Override
public String getTitleToolTip() {
if (fViewer == null)
return super.getTitleToolTip();
return getToolTipText(fViewer.getInput());
}
protected final StructuredViewer getViewer() {
return fViewer;
}
protected final void setViewer(StructuredViewer viewer) {
fViewer = viewer;
}
protected ScriptUILabelProvider createLabelProvider() {
return new AppearanceAwareLabelProvider(
AppearanceAwareLabelProvider.DEFAULT_TEXTFLAGS,
AppearanceAwareLabelProvider.DEFAULT_IMAGEFLAGS
| ScriptElementImageProvider.SMALL_ICONS,
DLTKUIPlugin.getDefault().getPreferenceStore());
}
protected ILabelProvider createTitleProvider() {
return new ModelElementLabelProvider(
ModelElementLabelProvider.SHOW_BASICS
| ModelElementLabelProvider.SHOW_SMALL_ICONS);
}
protected final ILabelProvider getLabelProvider() {
return fLabelProvider;
}
protected final ILabelProvider getTitleProvider() {
return fTitleProvider;
}
/**
* Creates the viewer of this part.
*
* @param parent
* the parent for the viewer
* @return the created viewer
*/
protected StructuredViewer createViewer(Composite parent) {
return new ProblemTableViewer(parent, SWT.MULTI);
}
protected int getLabelProviderFlags() {
return ModelElementLabelProvider.SHOW_BASICS
| ModelElementLabelProvider.SHOW_OVERLAY_ICONS
| ModelElementLabelProvider.SHOW_SMALL_ICONS
| ModelElementLabelProvider.SHOW_VARIABLE
| ModelElementLabelProvider.SHOW_PARAMETERS;
}
/**
* Adds filters the viewer of this part.
*/
protected void addFilters() {
// default is to have no filters
}
/**
* Creates the content provider of this part.
*
* @return the content provider
*/
protected IContentProvider createContentProvider() {
return new ScriptBrowsingContentProvider(true, this, this.getToolkit());
}
protected void setInitialInput() {
// Use the selection, if any
ISelection selection = getSite().getPage().getSelection();
Object input = getSingleElementFromSelection(selection);
if (!(input instanceof IModelElement)) {
// Use the input of the page
input = getSite().getPage().getInput();
if (!(input instanceof IModelElement)
&& input instanceof IAdaptable)
input = ((IAdaptable) input).getAdapter(IModelElement.class);
}
setInput(findInputForJavaElement((IModelElement) input));
}
protected void setInitialSelection() {
// Use the selection, if any
Object input;
IWorkbenchPage page = getSite().getPage();
ISelection selection = null;
if (page != null)
selection = page.getSelection();
if (selection instanceof ITextSelection) {
IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench()
.getActiveWorkbenchWindow();
IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage();
if (activePage != null) {
Object part = activePage.getActivePart();
if (part instanceof IEditorPart) {
setSelectionFromEditor((IEditorPart) part);
if (fViewer.getSelection() != null)
return;
}
}
}
// Use saved selection from memento
if (selection == null || selection.isEmpty())
selection = restoreSelectionState(fMemento);
if (selection == null || selection.isEmpty()) {
// Use the input of the page
input = getSite().getPage().getInput();
if (!(input instanceof IModelElement)) {
if (input instanceof IAdaptable)
input = ((IAdaptable) input)
.getAdapter(IModelElement.class);
else
return;
}
selection = new StructuredSelection(input);
}
selectionChanged(null, selection);
}
protected final void setHelp() {
// JavaUIHelp.setHelp(fViewer, getHelpContextId());
}
/**
* Returns the context ID for the Help system
*
* @return the string used as ID for the Help context
*/
abstract protected String getHelpContextId();
/**
* Returns the preference key for the link to editor setting.
*
* @return the string used as key into the preference store
*/
abstract protected String getLinkToEditorKey();
/**
* Adds additional listeners to this view. This method can be overridden but
* should call super.
*/
protected void hookViewerListeners() {
fViewer.addPostSelectionChangedListener(event -> {
if (!fProcessSelectionEvents)
return;
fPreviousSelectedElement = getSingleElementFromSelection(
event.getSelection());
IWorkbenchPage page = getSite().getPage();
if (page == null)
return;
if (page.equals(DLTKUIPlugin.getActivePage())
&& ScriptBrowsingPart.this.equals(page.getActivePart())) {
linkToEditor((IStructuredSelection) event.getSelection());
}
});
fViewer.addOpenListener(event -> {
IAction open = fOpenEditorGroup.getOpenAction();
if (open.isEnabled()) {
open.run();
restoreSelection();
}
});
}
void restoreSelection() {
// Default is to do nothing
}
void adjustInputAndSetSelection(Object o) {
if (!(o instanceof IModelElement || o instanceof List)) {
if (o == null)
setInput(null);
setSelection(StructuredSelection.EMPTY, true);
return;
}
if (o instanceof IModelElement) {
IModelElement je = (IModelElement) o;
IModelElement elementToSelect = findElementToSelect(je);
IModelElement newInput = findInputForJavaElement(je);
IModelElement oldInput = null;
if (getInput() instanceof IModelElement)
oldInput = (IModelElement) getInput();
if (elementToSelect == null && !isValidInput(newInput)
&& (newInput == null && !isAncestorOf(je, oldInput)))
// Clear input
setInput(null);
else if (mustSetNewInput(elementToSelect, oldInput, newInput)) {
// Adjust input to selection
setInput(newInput);
}
if (elementToSelect != null && elementToSelect.exists())
setSelection(new StructuredSelection(elementToSelect), true);
else
setSelection(StructuredSelection.EMPTY, true);
} else {
setSelection(new StructuredSelection(o), true);
setInput(o);
}
}
/**
* Compute if a new input must be set.
*
* @param elementToSelect
* the element to select
* @param oldInput
* old input
* @param newInput
* new input
* @return <code>true</code> if the input has to be set
* @since 3.0
*/
private boolean mustSetNewInput(IModelElement elementToSelect,
IModelElement oldInput, IModelElement newInput) {
return (newInput == null || !newInput.equals(oldInput))
&& (elementToSelect == null || oldInput == null
|| (!((elementToSelect instanceof IPackageDeclaration)
&& (elementToSelect.getParent()
.equals(oldInput.getParent()))
&& (!isAncestorOf(getViewPartInput(),
elementToSelect)))));
}
/**
* Finds the closest Java element which can be used as input for this part
* and has the given Java element as child
*
* @param je
* the Java element for which to search the closest input
* @return the closest Java element used as input for this part
*/
protected IModelElement findInputForJavaElement(IModelElement je) {
if (je == null || !je.exists())
return null;
if (isValidInput(je))
return je;
return findInputForJavaElement(je.getParent());
}
protected final Object findElementToSelect(Object obj) {
if (obj instanceof IModelElement)
return findElementToSelect((IModelElement) obj);
else if (obj instanceof List) {
return obj;
}
return null;
}
/**
* Finds the element which has to be selected in this part.
*
* @param je
* the Java element which has the focus
* @return returns the element to select
*/
abstract protected IModelElement findElementToSelect(IModelElement je);
protected final Object getSingleElementFromSelection(ISelection selection) {
if (!(selection instanceof IStructuredSelection) || selection.isEmpty())
return null;
Iterator iter = ((IStructuredSelection) selection).iterator();
Object firstElement = iter.next();
if (!(firstElement instanceof IModelElement)) {
if (firstElement instanceof IMarker)
firstElement = ((IMarker) firstElement).getResource();
if (firstElement instanceof IAdaptable) {
IModelElement je = ((IAdaptable) firstElement)
.getAdapter(IModelElement.class);
if (je == null && firstElement instanceof IFile) {
IContainer parent = ((IFile) firstElement).getParent();
if (parent != null)
return parent.getAdapter(IModelElement.class);
else
return null;
} else
return je;
} else
return firstElement;
}
Object currentInput = getViewer().getInput();
List elements = new ArrayList();
if (currentInput == null || !currentInput
.equals(findInputForJavaElement((IModelElement) firstElement)))
if (iter.hasNext() && selection instanceof StructuredSelection) {
// multi-selection and view is empty
return ((StructuredSelection) selection).toList();
} else
// OK: single selection and view is empty
return firstElement;
// be nice to multi-selection
while (iter.hasNext()) {
Object element = iter.next();
if (!(element instanceof IModelElement))
return null;
if (!currentInput
.equals(findInputForJavaElement((IModelElement) element)))
return null;
}
return firstElement;
}
/**
* Gets the typeComparator.
*
* @return Returns a JavaElementTypeComparator
*/
protected Comparator getTypeComparator() {
return fTypeComparator;
}
/**
* Links to editor (if option enabled)
*
* @param selection
* the selection
*/
private void linkToEditor(IStructuredSelection selection) {
Object obj = selection.getFirstElement();
if (selection.size() == 1) {
IEditorPart part = EditorUtility.isOpenInEditor(obj);
if (part != null) {
IWorkbenchPage page = getSite().getPage();
page.bringToTop(part);
if (obj instanceof IModelElement)
EditorUtility.revealInEditor(part, (IModelElement) obj);
}
}
}
void setSelectionFromEditor(IWorkbenchPart part) {
if (!fProcessSelectionEvents || !linkBrowsingViewSelectionToEditor()
|| !(part instanceof IEditorPart))
return;
IWorkbenchPartSite site = part.getSite();
if (site == null)
return;
ISelectionProvider provider = site.getSelectionProvider();
if (provider != null)
setSelectionFromEditor(part, provider.getSelection());
}
private void setSelectionFromEditor(IWorkbenchPart part,
ISelection selection) {
if (part instanceof IEditorPart) {
IModelElement element = null;
if (selection instanceof IStructuredSelection) {
Object obj = getSingleElementFromSelection(selection);
if (obj instanceof IModelElement)
element = (IModelElement) obj;
}
IEditorInput ei = ((IEditorPart) part).getEditorInput();
if (selection instanceof ITextSelection) {
int offset = ((ITextSelection) selection).getOffset();
element = getElementAt(ei, offset);
}
if (element != null) {
adjustInputAndSetSelection(element);
return;
}
if (ei instanceof IFileEditorInput) {
IFile file = ((IFileEditorInput) ei).getFile();
IModelElement je = file.getAdapter(IModelElement.class);
if (je == null) {
IContainer container = ((IFileEditorInput) ei).getFile()
.getParent();
if (container != null)
je = container.getAdapter(IModelElement.class);
}
if (je == null) {
setSelection(null, false);
return;
}
adjustInputAndSetSelection(je);
} /*
* else if (ei instanceof IClassFileEditorInput) { IClassFile cf
* = ((IClassFileEditorInput) ei).getClassFile();
* adjustInputAndSetSelection(cf); }
*/
}
}
/**
* Returns the element contained in the EditorInput
*
* @param input
* the editor input
* @return the input element
*/
Object getElementOfInput(IEditorInput input) {
if (input instanceof IFileEditorInput)
return ((IFileEditorInput) input).getFile();
if (input != null)
return DLTKUIPlugin.getEditorInputModelElement(input);
return null;
}
void setSelection(ISelection selection, boolean reveal) {
if (selection != null && selection.equals(fViewer.getSelection()))
return;
fProcessSelectionEvents = false;
fViewer.setSelection(selection, reveal);
fProcessSelectionEvents = true;
}
/**
* @param input
* the editor input
* @param offset
* the offset in the file
* @return the element at the given offset
*/
protected IModelElement getElementAt(IEditorInput input, int offset) {
IWorkingCopyManager manager = DLTKUIPlugin.getDefault()
.getWorkingCopyManager();
ISourceModule unit = manager.getWorkingCopy(input);
if (unit != null)
try {
if (unit.isConsistent())
return unit.getElementAt(offset);
else {
/*
* XXX: We should set the selection later when the CU is
* reconciled. see
* https://bugs.eclipse.org/bugs/show_bug.cgi?id=51290
*/
}
} catch (ModelException ex) {
// fall through
}
return null;
}
// protected IType getTypeForCU(ISourceModule cu) {
// // Use primary type if possible
// IType primaryType = cu.findPrimaryType();
// if (primaryType != null)
// return primaryType;
//
// // Use first top-level type
// try {
// IType[] types = cu.getTypes();
// if (types.length > 0)
// return types[0];
// else
// return null;
// } catch (ModelException ex) {
// return null;
// }
// }
void setProcessSelectionEvents(boolean state) {
fProcessSelectionEvents = state;
}
/*
* (non-Javadoc)
*
* @seeorg.eclipse.jdt.internal.ui.viewsupport.IViewPartInputProvider#
* getViewPartInput()
*/
@Override
public Object getViewPartInput() {
if (fViewer != null) {
return fViewer.getInput();
}
return null;
}
protected void setActionGroups(CompositeActionGroup actionGroups) {
fActionGroups = actionGroups;
}
protected void setBuildActionGroup(BuildActionGroup actionGroup) {
fBuildActionGroup = actionGroup;
}
protected void setCCPActionGroup(CCPActionGroup actionGroup) {
fCCPActionGroup = actionGroup;
}
protected void setCustomFiltersActionGroup(
CustomFiltersActionGroup customFiltersActionGroup) {
fCustomFiltersActionGroup = customFiltersActionGroup;
}
protected boolean hasCustomFilter() {
return fHasCustomFilter;
}
protected boolean hasWorkingSetFilter() {
return fHasWorkingSetFilter;
}
protected void setOpenEditorGroup(OpenEditorActionGroup openEditorGroup) {
fOpenEditorGroup = openEditorGroup;
}
protected OpenEditorActionGroup getOpenEditorGroup() {
return fOpenEditorGroup;
}
protected BuildActionGroup getBuildActionGroup() {
return fBuildActionGroup;
}
protected CCPActionGroup getCCPActionGroup() {
return fCCPActionGroup;
}
private boolean linkBrowsingViewSelectionToEditor() {
return isLinkingEnabled();
}
public void setLinkingEnabled(boolean enabled) {
fLinkingEnabled = enabled;
DLTKUIPlugin.getDefault().getPreferenceStore()
.setValue(getLinkToEditorKey(), enabled);
if (enabled) {
IEditorPart editor = getSite().getPage().getActiveEditor();
if (editor != null) {
setSelectionFromEditor(editor);
}
}
}
@Override
public void setInitializationData(IConfigurationElement config,
String propertyName, Object data) {
super.setInitializationData(config, propertyName, data);
String nature = null;
if (data instanceof String) {
nature = (String) data;
} else if (data instanceof Map) {
nature = (String) ((Map) data).get("nature"); //$NON-NLS-1$
}
if (nature != null) {
this.fToolkit = DLTKLanguageManager.getLanguageToolkit(nature);
} else {
throw new RuntimeException(
ScriptBrowsingMessages.ScriptBrowsingPart_natureAttributeMustBeSpecifiedAndCorrect);
}
}
}