| /******************************************************************************* |
| * 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 org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.dltk.core.DLTKLanguageManager; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.IProjectFragment; |
| import org.eclipse.dltk.core.IScriptFolder; |
| import org.eclipse.dltk.core.IScriptProject; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.IType; |
| import org.eclipse.dltk.internal.corext.util.Messages; |
| import org.eclipse.dltk.internal.ui.actions.MultiActionGroup; |
| import org.eclipse.dltk.internal.ui.filters.LibraryFilter; |
| import org.eclipse.dltk.internal.ui.filters.NonScriptElementFilter; |
| import org.eclipse.dltk.ui.DLTKPluginImages; |
| import org.eclipse.dltk.ui.DLTKUIPlugin; |
| import org.eclipse.dltk.ui.ModelElementSorter; |
| import org.eclipse.dltk.ui.PreferenceConstants; |
| import org.eclipse.dltk.ui.ScriptElementLabels; |
| import org.eclipse.dltk.ui.actions.SelectAllAction; |
| import org.eclipse.dltk.ui.viewsupport.DecoratingModelLabelProvider; |
| import org.eclipse.dltk.ui.viewsupport.ProblemTableViewer; |
| import org.eclipse.dltk.ui.viewsupport.ProblemTreeViewer; |
| import org.eclipse.dltk.ui.viewsupport.ScriptUILabelProvider; |
| import org.eclipse.dltk.ui.viewsupport.StatusBarUpdater; |
| import org.eclipse.jface.action.Action; |
| import org.eclipse.jface.action.GroupMarker; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IContributionItem; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.IStatusLineManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.viewers.IContentProvider; |
| import org.eclipse.jface.viewers.ILabelDecorator; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.StructuredViewer; |
| import org.eclipse.jface.viewers.TableViewer; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.IViewSite; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.actions.ActionFactory; |
| |
| public class PackagesView extends ScriptBrowsingPart { |
| |
| private static final String TAG_VIEW_STATE = ".viewState"; //$NON-NLS-1$ |
| private static final int LIST_VIEW_STATE = 0; |
| private static final int TREE_VIEW_STATE = 1; |
| |
| private static class StatusBarUpdater4LogicalPackage extends |
| StatusBarUpdater { |
| |
| private StatusBarUpdater4LogicalPackage( |
| IStatusLineManager statusLineManager) { |
| super(statusLineManager); |
| } |
| |
| @Override |
| protected String formatMessage(ISelection sel) { |
| if (sel instanceof IStructuredSelection) { |
| IStructuredSelection selection = (IStructuredSelection) sel; |
| int nElements = selection.size(); |
| Object elem = selection.getFirstElement(); |
| if (nElements == 1 && (elem instanceof LogicalPackage)) |
| return formatLogicalPackageMessage((LogicalPackage) elem); |
| } |
| return super.formatMessage(sel); |
| } |
| |
| private String formatLogicalPackageMessage(LogicalPackage logicalPackage) { |
| IScriptFolder[] fragments = logicalPackage.getScriptFolders(); |
| StringBuffer buf = new StringBuffer(logicalPackage.getElementName()); |
| buf.append(ScriptElementLabels.CONCAT_STRING); |
| String message = ""; //$NON-NLS-1$ |
| boolean firstTime = true; |
| for (int i = 0; i < fragments.length; i++) { |
| IScriptFolder fragment = fragments[i]; |
| IModelElement element = fragment.getParent(); |
| if (element instanceof IProjectFragment) { |
| IProjectFragment root = (IProjectFragment) element; |
| String label = ScriptElementLabels |
| .getDefault() |
| .getElementLabel( |
| root, |
| ScriptElementLabels.DEFAULT_QUALIFIED |
| | ScriptElementLabels.ROOT_QUALIFIED); |
| if (firstTime) { |
| buf.append(label); |
| firstTime = false; |
| } else |
| message = Messages.format( |
| ScriptBrowsingMessages.StatusBar_concat, |
| new String[] { message, label }); |
| } |
| } |
| buf.append(message); |
| return buf.toString(); |
| } |
| } |
| |
| private SelectAllAction fSelectAllAction; |
| |
| private int fCurrViewState; |
| |
| private PackageViewerWrapper fWrappedViewer; |
| |
| private MultiActionGroup fSwitchActionGroup; |
| private boolean fLastInputWasProject; |
| |
| /** |
| * Adds filters the viewer of this part. |
| */ |
| @Override |
| protected void addFilters() { |
| super.addFilters(); |
| getViewer().addFilter(createNonJavaElementFilter()); |
| getViewer().addFilter(new LibraryFilter()); |
| } |
| |
| /** |
| * Creates new NonJavaElementFilter and overrides method select to allow for |
| * LogicalPackages. |
| * |
| * @return NonJavaElementFilter |
| */ |
| protected NonScriptElementFilter createNonJavaElementFilter() { |
| return new NonScriptElementFilter() { |
| @Override |
| public boolean select(Viewer viewer, Object parent, Object element) { |
| return ((element instanceof IModelElement) |
| || (element instanceof LogicalPackage) || (element instanceof IFolder)); |
| } |
| }; |
| } |
| |
| @Override |
| public void init(IViewSite site, IMemento memento) throws PartInitException { |
| super.init(site, memento); |
| // this must be created before all actions and filters |
| fWrappedViewer = new PackageViewerWrapper(); |
| restoreLayoutState(memento); |
| } |
| |
| private void restoreLayoutState(IMemento memento) { |
| if (memento == null) { |
| // read state from the preference store |
| IPreferenceStore store = DLTKUIPlugin.getDefault() |
| .getPreferenceStore(); |
| fCurrViewState = store.getInt(this.getViewSite().getId() |
| + TAG_VIEW_STATE); |
| } else { |
| // restore from memento |
| Integer integer = memento.getInteger(this.getViewSite().getId() |
| + TAG_VIEW_STATE); |
| if ((integer == null) || !isValidState(integer.intValue())) { |
| fCurrViewState = LIST_VIEW_STATE; |
| } else |
| fCurrViewState = integer.intValue(); |
| } |
| } |
| |
| private boolean isValidState(int state) { |
| return (state == LIST_VIEW_STATE) || (state == TREE_VIEW_STATE); |
| } |
| |
| /* |
| * @see org.eclipse.ui.IViewPart#saveState(org.eclipse.ui.IMemento) |
| */ |
| @Override |
| public void saveState(IMemento memento) { |
| super.saveState(memento); |
| memento.putInteger(this.getViewSite().getId() + TAG_VIEW_STATE, |
| fCurrViewState); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#createViewer(org.eclipse.swt.widgets.Composite) |
| */ |
| @Override |
| protected StructuredViewer createViewer(Composite parent) { |
| // Creates the viewer of this part dependent on the current layout. |
| StructuredViewer viewer; |
| if (isInListState()) |
| viewer = createTableViewer(parent); |
| else |
| viewer = createTreeViewer(parent); |
| |
| fWrappedViewer.setViewer(viewer); |
| return fWrappedViewer; |
| } |
| |
| @Override |
| public <T> T getAdapter(Class<T> key) { |
| // if (key == IShowInTargetList.class) { |
| // return new IShowInTargetList() { |
| // public String[] getShowInTargetIds() { |
| // return new String[] { DLTKUIPlugin.ID_PACKAGES, |
| // IPageLayout.ID_RES_NAV }; |
| // } |
| // }; |
| // } |
| return super.getAdapter(key); |
| } |
| |
| protected boolean isInListState() { |
| return fCurrViewState == LIST_VIEW_STATE; |
| } |
| |
| private ProblemTableViewer createTableViewer(Composite parent) { |
| return new PackagesViewTableViewer(parent, SWT.MULTI); |
| } |
| |
| private ProblemTreeViewer createTreeViewer(Composite parent) { |
| return new PackagesViewTreeViewer(parent, SWT.MULTI); |
| } |
| |
| /** |
| * Overrides the createContentProvider from JavaBrowsingPart Creates the |
| * content provider of this part. |
| */ |
| @Override |
| protected IContentProvider createContentProvider() { |
| if (isInListState()) |
| return new PackagesViewFlatContentProvider(fWrappedViewer |
| .getViewer()); |
| else |
| return new PackagesViewHierarchicalContentProvider(fWrappedViewer |
| .getViewer()); |
| } |
| |
| @Override |
| protected ScriptUILabelProvider createLabelProvider() { |
| if (isInListState()) |
| return createListLabelProvider(); |
| else |
| return createTreeLabelProvider(); |
| } |
| |
| private ScriptUILabelProvider createTreeLabelProvider() { |
| return new PackagesViewLabelProvider( |
| PackagesViewLabelProvider.HIERARCHICAL_VIEW_STATE); |
| } |
| |
| private ScriptUILabelProvider createListLabelProvider() { |
| return new PackagesViewLabelProvider( |
| PackagesViewLabelProvider.FLAT_VIEW_STATE); |
| } |
| |
| /** |
| * Returns the context ID for the Help system |
| * |
| * @return the string used as ID for the Help context |
| */ |
| @Override |
| protected String getHelpContextId() { |
| // return IJavaHelpContextIds.PACKAGES_BROWSING_VIEW; |
| return ""; //$NON-NLS-1$ |
| } |
| |
| @Override |
| protected String getLinkToEditorKey() { |
| return PreferenceConstants.LINK_BROWSING_PACKAGES_TO_EDITOR; |
| } |
| |
| /** |
| * Answers if the given <code>element</code> is a valid input for this |
| * part. |
| * |
| * @param element |
| * the object to test |
| * @return <true> if the given element is a valid input |
| */ |
| @Override |
| protected boolean isValidInput(Object element) { |
| if (element instanceof IScriptProject |
| || (element instanceof IProjectFragment && ((IModelElement) element) |
| .getElementName() != IProjectFragment.DEFAULT_PACKAGE_ROOT)) { |
| IScriptProject jProject = ((IModelElement) element) |
| .getScriptProject(); |
| if (jProject != null) |
| return DLTKLanguageManager.hasScriptNature(jProject |
| .getProject()); |
| } |
| return false; |
| } |
| |
| /** |
| * Answers if the given <code>element</code> is a valid element for this |
| * part. |
| * |
| * @param element |
| * the object to test |
| * @return <true> if the given element is a valid element |
| */ |
| @Override |
| protected boolean isValidElement(Object element) { |
| if (element instanceof IScriptFolder) { |
| IModelElement parent = ((IScriptFolder) element).getParent(); |
| if (parent != null) |
| return super.isValidElement(parent) |
| || super.isValidElement(parent.getScriptProject()); |
| } |
| return false; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#findElementToSelect(org.eclipse.jdt.core.IJavaElement) |
| */ |
| @Override |
| protected IModelElement findElementToSelect(IModelElement je) { |
| if (je == null) |
| return null; |
| |
| switch (je.getElementType()) { |
| case IModelElement.SCRIPT_FOLDER: |
| return je; |
| case IModelElement.SOURCE_MODULE: |
| return ((ISourceModule) je).getParent(); |
| case IModelElement.TYPE: |
| return ((IType) je).getScriptFolder(); |
| default: |
| return findElementToSelect(je.getParent()); |
| } |
| } |
| |
| /* |
| * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#setInput(java.lang.Object) |
| */ |
| @Override |
| protected void setInput(Object input) { |
| setViewerWrapperInput(input); |
| super.updateTitle(); |
| } |
| |
| private void setViewerWrapperInput(Object input) { |
| fWrappedViewer.setViewerInput(input); |
| } |
| |
| /** |
| * @see org.eclipse.jdt.internal.ui.browsing.ScriptBrowsingPart#fillActionBars(org.eclipse.ui.IActionBars) |
| */ |
| @Override |
| protected void fillActionBars(IActionBars actionBars) { |
| super.fillActionBars(actionBars); |
| fSwitchActionGroup.fillActionBars(actionBars); |
| } |
| |
| private void setUpViewer(StructuredViewer viewer) { |
| Assert.isTrue(viewer != null); |
| |
| ScriptUILabelProvider labelProvider = createLabelProvider(); |
| viewer.setLabelProvider(createDecoratingLabelProvider(labelProvider)); |
| |
| viewer.setComparator(createModelElementComparator()); |
| viewer.setUseHashlookup(true); |
| |
| createContextMenu(); |
| |
| // disapears when control disposed |
| addKeyListener(); |
| |
| // this methods only adds listeners to the viewer, |
| // these listenters disapear when the viewer is disposed |
| hookViewerListeners(); |
| |
| // Set content provider |
| viewer.setContentProvider(createContentProvider()); |
| // Disposed when viewer's Control is disposed |
| initDragAndDrop(); |
| |
| } |
| |
| // alter sorter to include LogicalPackages |
| @Override |
| protected ModelElementSorter createModelElementComparator() { |
| return new ModelElementSorter() { |
| @Override |
| public int category(Object element) { |
| if (element instanceof LogicalPackage) { |
| LogicalPackage cp = (LogicalPackage) element; |
| return super.category(cp.getScriptFolders()[0]); |
| } else |
| return super.category(element); |
| } |
| |
| @Override |
| public int compare(Viewer viewer, Object e1, Object e2) { |
| if (e1 instanceof LogicalPackage) { |
| LogicalPackage cp = (LogicalPackage) e1; |
| e1 = cp.getScriptFolders()[0]; |
| } |
| if (e2 instanceof LogicalPackage) { |
| LogicalPackage cp = (LogicalPackage) e2; |
| e2 = cp.getScriptFolders()[0]; |
| } |
| return super.compare(viewer, e1, e2); |
| } |
| }; |
| } |
| |
| @Override |
| protected StatusBarUpdater createStatusBarUpdater( |
| IStatusLineManager slManager) { |
| return new StatusBarUpdater4LogicalPackage(slManager); |
| } |
| |
| protected void setSiteSelectionProvider() { |
| getSite().setSelectionProvider(fWrappedViewer); |
| } |
| |
| @Override |
| void adjustInputAndSetSelection(Object o) { |
| if (!(o instanceof LogicalPackage)) { |
| super.adjustInputAndSetSelection(o); |
| return; |
| } |
| |
| LogicalPackage lp = (LogicalPackage) o; |
| if (!lp.getScriptProject().equals(getInput())) |
| setInput(lp.getScriptProject()); |
| |
| setSelection(new StructuredSelection(lp), true); |
| } |
| |
| // do the same thing as the JavaBrowsingPart but with wrapper |
| @Override |
| protected void createActions() { |
| super.createActions(); |
| |
| createSelectAllAction(); |
| |
| // create the switch action group |
| fSwitchActionGroup = createSwitchActionGroup(); |
| } |
| |
| private MultiActionGroup createSwitchActionGroup() { |
| |
| LayoutAction switchToFlatViewAction = new LayoutAction( |
| ScriptBrowsingMessages.PackagesView_flatLayoutAction_label, |
| LIST_VIEW_STATE); |
| LayoutAction switchToHierarchicalViewAction = new LayoutAction( |
| ScriptBrowsingMessages.PackagesView_HierarchicalLayoutAction_label, |
| TREE_VIEW_STATE); |
| DLTKPluginImages.setLocalImageDescriptors(switchToFlatViewAction, |
| "flatLayout.png"); //$NON-NLS-1$ |
| DLTKPluginImages.setLocalImageDescriptors( |
| switchToHierarchicalViewAction, "hierarchicalLayout.png"); //$NON-NLS-1$ |
| |
| return new LayoutActionGroup(new IAction[] { switchToFlatViewAction, |
| switchToHierarchicalViewAction }, fCurrViewState); |
| } |
| |
| private static class LayoutActionGroup extends MultiActionGroup { |
| |
| LayoutActionGroup(IAction[] actions, int index) { |
| super(actions, index); |
| } |
| |
| @Override |
| public void fillActionBars(IActionBars actionBars) { |
| // create new layout group |
| IMenuManager manager = actionBars.getMenuManager(); |
| final IContributionItem groupMarker = new GroupMarker("layout"); //$NON-NLS-1$ |
| manager.add(groupMarker); |
| IMenuManager newManager = new MenuManager( |
| ScriptBrowsingMessages.PackagesView_LayoutActionGroup_layout_label); |
| manager.appendToGroup("layout", newManager); //$NON-NLS-1$ |
| super.addActions(newManager); |
| } |
| } |
| |
| /** |
| * Switches between flat and hierarchical state. |
| */ |
| private class LayoutAction extends Action { |
| |
| private int fState; |
| |
| public LayoutAction(String text, int state) { |
| super(text, IAction.AS_RADIO_BUTTON); |
| fState = state; |
| // if (state == PackagesView.LIST_VIEW_STATE) |
| // PlatformUI.getWorkbench().getHelpSystem().setHelp(this, |
| // IJavaHelpContextIds.LAYOUT_FLAT_ACTION); |
| // else |
| // PlatformUI.getWorkbench().getHelpSystem().setHelp(this, |
| // IJavaHelpContextIds.LAYOUT_HIERARCHICAL_ACTION); |
| } |
| |
| @Override |
| public void run() { |
| switchViewer(fState); |
| } |
| } |
| |
| private void switchViewer(int state) { |
| // Indicate which viewer is to be used |
| if (fCurrViewState == state) |
| return; |
| else { |
| fCurrViewState = state; |
| IPreferenceStore store = DLTKUIPlugin.getDefault() |
| .getPreferenceStore(); |
| store.setValue(getViewSite().getId() + TAG_VIEW_STATE, state); |
| } |
| |
| // get the information from the existing viewer |
| StructuredViewer viewer = fWrappedViewer.getViewer(); |
| Object object = viewer.getInput(); |
| ISelection selection = viewer.getSelection(); |
| |
| // create and set up the new viewer |
| Control control = createViewer(fWrappedViewer.getControl().getParent()) |
| .getControl(); |
| |
| setUpViewer(fWrappedViewer); |
| |
| createSelectAllAction(); |
| |
| // add the selection information from old viewer |
| fWrappedViewer.setViewerInput(object); |
| fWrappedViewer.getControl().setFocus(); |
| fWrappedViewer.setSelection(selection, true); |
| |
| // dispose old viewer |
| viewer.getContentProvider().dispose(); |
| viewer.getControl().dispose(); |
| |
| // layout the new viewer |
| if (control != null && !control.isDisposed()) { |
| control.setVisible(true); |
| control.getParent().layout(true); |
| } |
| } |
| |
| private void createSelectAllAction() { |
| IActionBars actionBars = getViewSite().getActionBars(); |
| if (isInListState()) { |
| fSelectAllAction = new SelectAllAction((TableViewer) fWrappedViewer |
| .getViewer()); |
| actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), |
| fSelectAllAction); |
| } else { |
| actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), |
| null); |
| fSelectAllAction = null; |
| } |
| actionBars.updateActionBars(); |
| } |
| |
| @Override |
| protected IModelElement findInputForJavaElement(IModelElement je) { |
| // null check has to take place here as well (not only in |
| // findInputForJavaElement(IJavaElement, boolean) since we |
| // are accessing the Java element |
| if (je == null) |
| return null; |
| if (je.getElementType() == IModelElement.PROJECT_FRAGMENT |
| || je.getElementType() == IModelElement.SCRIPT_PROJECT) |
| return findInputForJavaElement(je, true); |
| else |
| return findInputForJavaElement(je, false); |
| |
| } |
| |
| protected IModelElement findInputForJavaElement(IModelElement je, |
| boolean canChangeInputType) { |
| if (je == null || !je.exists()) |
| return null; |
| |
| if (isValidInput(je)) { |
| |
| // don't update if input must be project (i.e. project is used as |
| // source folder) |
| if (canChangeInputType) |
| fLastInputWasProject = je.getElementType() == IModelElement.SCRIPT_PROJECT; |
| return je; |
| } else if (fLastInputWasProject) { |
| IProjectFragment packageFragmentRoot = (IProjectFragment) je |
| .getAncestor(IModelElement.PROJECT_FRAGMENT); |
| if (!packageFragmentRoot.isExternal()) |
| return je.getScriptProject(); |
| } |
| |
| return findInputForJavaElement(je.getParent(), canChangeInputType); |
| } |
| |
| /** |
| * Override the getText and getImage methods for the DecoratingLabelProvider |
| * to handel the decoration of logical packages. |
| * |
| * @see org.eclipse.jdt.internal.ui.browsing.ScriptBrowsingPart#createDecoratingLabelProvider(JavaUILabelProvider) |
| */ |
| @Override |
| protected DecoratingModelLabelProvider createDecoratingLabelProvider( |
| ScriptUILabelProvider provider) { |
| return new DecoratingModelLabelProvider(provider, false, isInListState()) { |
| |
| @Override |
| public String getText(Object element) { |
| if (element instanceof LogicalPackage) { |
| LogicalPackage el = (LogicalPackage) element; |
| return super.getText(el.getScriptFolders()[0]); |
| } else |
| return super.getText(element); |
| } |
| |
| @Override |
| public Image getImage(Object element) { |
| if (element instanceof LogicalPackage) { |
| LogicalPackage el = (LogicalPackage) element; |
| ILabelDecorator decorator = getLabelDecorator(); |
| IScriptFolder[] fragments = el.getScriptFolders(); |
| |
| Image image = super.getImage(el); |
| for (int i = 0; i < fragments.length; i++) { |
| IScriptFolder fragment = fragments[i]; |
| Image decoratedImage = decorator.decorateImage(image, |
| fragment); |
| if (decoratedImage != null) |
| image = decoratedImage; |
| } |
| return image; |
| } else |
| return super.getImage(element); |
| } |
| |
| }; |
| } |
| |
| /* |
| * Overridden from JavaBrowsingPart to handel LogicalPackages and tree |
| * structure. |
| * |
| * @see org.eclipse.jdt.internal.ui.browsing.JavaBrowsingPart#adjustInputAndSetSelection(org.eclipse.jdt.core.IJavaElement) |
| */ |
| void adjustInputAndSetSelection(IModelElement je) { |
| |
| IModelElement jElementToSelect = findElementToSelect(je); |
| LogicalPackagesProvider p = (LogicalPackagesProvider) fWrappedViewer |
| .getContentProvider(); |
| |
| Object elementToSelect = jElementToSelect; |
| if (jElementToSelect != null |
| && jElementToSelect.getElementType() == IModelElement.SCRIPT_FOLDER) { |
| IScriptFolder pkgFragment = (IScriptFolder) jElementToSelect; |
| elementToSelect = p.findLogicalPackage(pkgFragment); |
| if (elementToSelect == null) |
| elementToSelect = pkgFragment; |
| } |
| |
| IModelElement newInput = findInputForJavaElement(je); |
| if (elementToSelect == null && !isValidInput(newInput)) |
| setInput(null); |
| else if (elementToSelect == null |
| || getViewer().testFindItem(elementToSelect) == null) { |
| |
| // optimization, if you are in the same project but expansion hasn't |
| // happened |
| Object input = getViewer().getInput(); |
| if (elementToSelect != null && newInput != null) { |
| if (newInput.equals(input)) { |
| getViewer().reveal(elementToSelect); |
| // Adjust input to selection |
| } else { |
| setInput(newInput); |
| getViewer().reveal(elementToSelect); |
| } |
| } else |
| setInput(newInput); |
| |
| if (elementToSelect instanceof IScriptFolder) { |
| IScriptFolder pkgFragment = (IScriptFolder) elementToSelect; |
| elementToSelect = p.findLogicalPackage(pkgFragment); |
| if (elementToSelect == null) |
| elementToSelect = pkgFragment; |
| } |
| } |
| |
| ISelection selection; |
| if (elementToSelect != null) |
| selection = new StructuredSelection(elementToSelect); |
| else |
| selection = StructuredSelection.EMPTY; |
| setSelection(selection, true); |
| } |
| |
| } |