| /******************************************************************************* |
| * 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 |
| * |
| *******************************************************************************/ |
| package org.eclipse.dltk.internal.ui.typehierarchy; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.dltk.core.DLTKCore; |
| import org.eclipse.dltk.core.IMember; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.IType; |
| import org.eclipse.dltk.core.ITypeHierarchy; |
| import org.eclipse.dltk.core.ModelException; |
| import org.eclipse.dltk.internal.corext.util.Messages; |
| import org.eclipse.dltk.internal.ui.actions.CCPActionGroup; |
| import org.eclipse.dltk.internal.ui.actions.CompositeActionGroup; |
| 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.workingsets.WorkingSetFilterActionGroup; |
| import org.eclipse.dltk.ui.DLTKUIPlugin; |
| import org.eclipse.dltk.ui.IContextMenuConstants; |
| import org.eclipse.dltk.ui.ITypeHierarchyViewPart; |
| import org.eclipse.dltk.ui.MembersOrderPreferenceCache; |
| import org.eclipse.dltk.ui.PreferenceConstants; |
| import org.eclipse.dltk.ui.ScriptElementLabels; |
| import org.eclipse.dltk.ui.actions.OpenEditorActionGroup; |
| import org.eclipse.dltk.ui.actions.OpenViewActionGroup; |
| import org.eclipse.dltk.ui.actions.SelectAllAction; |
| import org.eclipse.dltk.ui.util.ExceptionHandler; |
| import org.eclipse.dltk.ui.viewsupport.IViewPartInputProvider; |
| import org.eclipse.dltk.ui.viewsupport.ScriptUILabelProvider; |
| import org.eclipse.dltk.ui.viewsupport.SelectionProviderMediator; |
| import org.eclipse.dltk.ui.viewsupport.StatusBarUpdater; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.IStatusLineManager; |
| import org.eclipse.jface.action.IToolBarManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.Separator; |
| import org.eclipse.jface.action.ToolBarManager; |
| import org.eclipse.jface.dialogs.IDialogSettings; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.jface.util.PropertyChangeEvent; |
| import org.eclipse.jface.viewers.IBasicPropertyConstants; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.StructuredViewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.custom.CLabel; |
| import org.eclipse.swt.custom.SashForm; |
| import org.eclipse.swt.custom.ViewForm; |
| import org.eclipse.swt.events.ControlEvent; |
| import org.eclipse.swt.events.ControlListener; |
| import org.eclipse.swt.events.FocusEvent; |
| import org.eclipse.swt.events.FocusListener; |
| import org.eclipse.swt.events.KeyAdapter; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.events.KeyListener; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.ScrollBar; |
| import org.eclipse.swt.widgets.ToolBar; |
| import org.eclipse.ui.IActionBars; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.IPageLayout; |
| import org.eclipse.ui.IPartListener2; |
| import org.eclipse.ui.IViewSite; |
| import org.eclipse.ui.IWorkbenchActionConstants; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchPartReference; |
| import org.eclipse.ui.IWorkingSet; |
| import org.eclipse.ui.IWorkingSetManager; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.actions.ActionContext; |
| import org.eclipse.ui.actions.ActionFactory; |
| 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.IShowInTargetList; |
| import org.eclipse.ui.part.PageBook; |
| import org.eclipse.ui.part.ShowInContext; |
| import org.eclipse.ui.part.ViewPart; |
| |
| /** |
| * view showing the super types/sub types of its input. |
| */ |
| public class TypeHierarchyViewPart extends ViewPart |
| implements ITypeHierarchyViewPart, IViewPartInputProvider { |
| |
| public static final int VIEW_ID_TYPE = 2; |
| public static final int VIEW_ID_SUPER = 0; |
| public static final int VIEW_ID_SUB = 1; |
| |
| public static final int VIEW_ORIENTATION_VERTICAL = 0; |
| public static final int VIEW_ORIENTATION_HORIZONTAL = 1; |
| public static final int VIEW_ORIENTATION_SINGLE = 2; |
| public static final int VIEW_ORIENTATION_AUTOMATIC = 3; |
| |
| private static final String DIALOGSTORE_HIERARCHYVIEW = "TypeHierarchyViewPart.hierarchyview"; //$NON-NLS-1$ |
| private static final String DIALOGSTORE_VIEWORIENTATION = "TypeHierarchyViewPart.orientation"; //$NON-NLS-1$ |
| |
| private static final String TAG_INPUT = "input"; //$NON-NLS-1$ |
| private static final String TAG_VIEW = "view"; //$NON-NLS-1$ |
| private static final String TAG_ORIENTATION = "orientation"; //$NON-NLS-1$ |
| private static final String TAG_RATIO = "ratio"; //$NON-NLS-1$ |
| private static final String TAG_SELECTION = "selection"; //$NON-NLS-1$ |
| private static final String TAG_VERTICAL_SCROLL = "vertical_scroll"; //$NON-NLS-1$ |
| |
| private static final String GROUP_FOCUS = "group.focus"; //$NON-NLS-1$ |
| |
| // the selected type in the hierarchy view |
| private IType fSelectedType; |
| // input element or null |
| private IModelElement fInputElement; |
| |
| // history of input elements. No duplicates |
| private ArrayList<IModelElement> fInputHistory; |
| |
| private IMemento fMemento; |
| private IDialogSettings fDialogSettings; |
| |
| private TypeHierarchyLifeCycle fHierarchyLifeCycle; |
| private ITypeHierarchyLifeCycleListener fTypeHierarchyLifeCycleListener; |
| |
| private IPropertyChangeListener fPropertyChangeListener; |
| |
| private SelectionProviderMediator fSelectionProviderMediator; |
| private ISelectionChangedListener fSelectionChangedListener; |
| private IPartListener2 fPartListener; |
| |
| private int fCurrentOrientation; |
| int fOrientation = VIEW_ORIENTATION_AUTOMATIC; |
| boolean fInComputeOrientation = false; |
| |
| private boolean fLinkingEnabled; |
| private boolean fSelectInEditor; |
| |
| private boolean fIsVisible; |
| private boolean fNeedRefresh; |
| private boolean fIsEnableMemberFilter; |
| private boolean fIsRefreshRunnablePosted; |
| |
| private int fCurrentViewerIndex; |
| private TypeHierarchyViewer[] fAllViewers; |
| |
| private MethodsViewer fMethodsViewer; |
| |
| private SashForm fTypeMethodsSplitter; |
| private PageBook fViewerbook; |
| private PageBook fPagebook; |
| |
| private Label fNoHierarchyShownLabel; |
| private Label fEmptyTypesViewer; |
| |
| private ViewForm fTypeViewerViewForm; |
| private ViewForm fMethodViewerViewForm; |
| |
| private CLabel fMethodViewerPaneLabel; |
| private ScriptUILabelProvider fPaneLabelProvider; |
| private Composite fParent; |
| |
| private ToggleViewAction[] fViewActions; |
| private ToggleLinkingAction fToggleLinkingAction; |
| private HistoryDropDownAction fHistoryDropDownAction; |
| private ToggleOrientationAction[] fToggleOrientationActions; |
| private EnableMemberFilterAction fEnableMemberFilterAction; |
| private ShowQualifiedTypeNamesAction fShowQualifiedTypeNamesAction; |
| private FocusOnTypeAction fFocusOnTypeAction; |
| private FocusOnSelectionAction fFocusOnSelectionAction; |
| private CompositeActionGroup fActionGroups; |
| private SelectAllAction fSelectAllAction; |
| |
| private WorkingSetFilterActionGroup fWorkingSetActionGroup; |
| private Job fRestoreStateJob; |
| private IContextActivation fContextActivation; |
| |
| protected IPreferenceStore getPreferenceStore() { |
| return DLTKUIPlugin.getDefault().getPreferenceStore(); |
| } |
| |
| public TypeHierarchyViewPart() { |
| fSelectedType = null; |
| fInputElement = null; |
| fIsVisible = false; |
| fIsRefreshRunnablePosted = false; |
| fSelectInEditor = true; |
| fRestoreStateJob = null; |
| |
| fHierarchyLifeCycle = new TypeHierarchyLifeCycle(); |
| fTypeHierarchyLifeCycleListener = (typeHierarchy, |
| changedTypes) -> doTypeHierarchyChanged(typeHierarchy, |
| changedTypes); |
| fHierarchyLifeCycle.addChangedListener(fTypeHierarchyLifeCycleListener); |
| |
| fPropertyChangeListener = event -> doPropertyChange(event); |
| // getPreferenceStore().addPropertyChangeListener(fPropertyChangeListener |
| // ); |
| |
| fIsEnableMemberFilter = false; |
| |
| fInputHistory = new ArrayList<>(); |
| fAllViewers = null; |
| |
| fViewActions = new ToggleViewAction[] { |
| new ToggleViewAction(this, VIEW_ID_TYPE), |
| new ToggleViewAction(this, VIEW_ID_SUPER), |
| new ToggleViewAction(this, VIEW_ID_SUB) }; |
| |
| fDialogSettings = DLTKUIPlugin.getDefault().getDialogSettings(); |
| |
| fHistoryDropDownAction = new HistoryDropDownAction(this); |
| fHistoryDropDownAction.setEnabled(false); |
| |
| fToggleOrientationActions = new ToggleOrientationAction[] { |
| new ToggleOrientationAction(this, VIEW_ORIENTATION_VERTICAL), |
| new ToggleOrientationAction(this, VIEW_ORIENTATION_HORIZONTAL), |
| new ToggleOrientationAction(this, VIEW_ORIENTATION_AUTOMATIC), |
| new ToggleOrientationAction(this, VIEW_ORIENTATION_SINGLE) }; |
| |
| fEnableMemberFilterAction = new EnableMemberFilterAction(this, false); |
| fShowQualifiedTypeNamesAction = new ShowQualifiedTypeNamesAction(this, |
| false); |
| |
| fFocusOnTypeAction = new FocusOnTypeAction(this); |
| |
| // TODO: DLTK: Please fix this to support |
| // DLTKLanguageManager.createScriptUILabelProvider() |
| fPaneLabelProvider = new ScriptUILabelProvider(); |
| |
| fFocusOnSelectionAction = new FocusOnSelectionAction(this); |
| |
| fPartListener = new IPartListener2() { |
| @Override |
| public void partVisible(IWorkbenchPartReference ref) { |
| IWorkbenchPart part = ref.getPart(false); |
| if (part == TypeHierarchyViewPart.this) { |
| visibilityChanged(true); |
| } |
| } |
| |
| @Override |
| public void partHidden(IWorkbenchPartReference ref) { |
| IWorkbenchPart part = ref.getPart(false); |
| if (part == TypeHierarchyViewPart.this) { |
| visibilityChanged(false); |
| } |
| } |
| |
| @Override |
| public void partActivated(IWorkbenchPartReference ref) { |
| IWorkbenchPart part = ref.getPart(false); |
| if (part instanceof IEditorPart) |
| editorActivated((IEditorPart) part); |
| } |
| |
| @Override |
| public void partInputChanged(IWorkbenchPartReference ref) { |
| IWorkbenchPart part = ref.getPart(false); |
| if (part instanceof IEditorPart) |
| editorActivated((IEditorPart) part); |
| } |
| |
| @Override |
| public void partBroughtToTop(IWorkbenchPartReference ref) { |
| } |
| |
| @Override |
| public void partClosed(IWorkbenchPartReference ref) { |
| } |
| |
| @Override |
| public void partDeactivated(IWorkbenchPartReference ref) { |
| } |
| |
| @Override |
| public void partOpened(IWorkbenchPartReference ref) { |
| } |
| }; |
| |
| fSelectionChangedListener = event -> doSelectionChanged(event); |
| |
| fLinkingEnabled = getPreferenceStore() |
| .getBoolean(PreferenceConstants.LINK_TYPEHIERARCHY_TO_EDITOR); |
| } |
| |
| /** |
| * Method doPropertyChange. |
| * |
| * @param event |
| */ |
| protected void doPropertyChange(PropertyChangeEvent event) { |
| String property = event.getProperty(); |
| if (fMethodsViewer != null) { |
| if (MembersOrderPreferenceCache |
| .isMemberOrderProperty(event.getProperty())) { |
| fMethodsViewer.refresh(); |
| } |
| } |
| if (IWorkingSetManager.CHANGE_WORKING_SET_CONTENT_CHANGE |
| .equals(property)) { |
| updateHierarchyViewer(true); |
| updateTitle(); |
| } |
| } |
| |
| /** |
| * Adds the entry if new. Inserted at the beginning of the history entries |
| * list. |
| * |
| * @param entry |
| * The new entry |
| */ |
| private void addHistoryEntry(IModelElement entry) { |
| if (fInputHistory.contains(entry)) { |
| fInputHistory.remove(entry); |
| } |
| fInputHistory.add(0, entry); |
| fHistoryDropDownAction.setEnabled(true); |
| } |
| |
| private void updateHistoryEntries() { |
| for (int i = fInputHistory.size() - 1; i >= 0; i--) { |
| IModelElement type = fInputHistory.get(i); |
| if (!type.exists()) { |
| fInputHistory.remove(i); |
| } |
| } |
| fHistoryDropDownAction.setEnabled(!fInputHistory.isEmpty()); |
| } |
| |
| /** |
| * Goes to the selected entry, without updating the order of history |
| * entries. |
| * |
| * @param entry |
| * The entry to open |
| */ |
| public void gotoHistoryEntry(IModelElement entry) { |
| if (fInputHistory.contains(entry)) { |
| updateInput(entry); |
| } |
| } |
| |
| /** |
| * Gets all history entries. |
| * |
| * @return All history entries |
| */ |
| public IModelElement[] getHistoryEntries() { |
| if (fInputHistory.size() > 0) { |
| updateHistoryEntries(); |
| } |
| return fInputHistory.toArray(new IModelElement[fInputHistory.size()]); |
| } |
| |
| /** |
| * Sets the history entries |
| * |
| * @param elems |
| * The history elements to set |
| */ |
| public void setHistoryEntries(IModelElement[] elems) { |
| fInputHistory.clear(); |
| for (int i = 0; i < elems.length; i++) { |
| fInputHistory.add(elems[i]); |
| } |
| updateHistoryEntries(); |
| } |
| |
| /** |
| * Selects an member in the methods list or in the current hierarchy. |
| * |
| * @param member |
| * The member to select |
| */ |
| public void selectMember(IMember member) { |
| fSelectInEditor = false; |
| if (member.getElementType() != IModelElement.TYPE) { |
| Control methodControl = fMethodsViewer.getControl(); |
| if (methodControl != null && !methodControl.isDisposed()) { |
| methodControl.setFocus(); |
| } |
| |
| fMethodsViewer.setSelection(new StructuredSelection(member), true); |
| } else { |
| Control viewerControl = getCurrentViewer().getControl(); |
| if (viewerControl != null && !viewerControl.isDisposed()) { |
| viewerControl.setFocus(); |
| } |
| |
| if (!member.equals(fSelectedType)) { |
| getCurrentViewer().setSelection(new StructuredSelection(member), |
| true); |
| } |
| } |
| fSelectInEditor = true; |
| } |
| |
| /** |
| * @return The input type |
| * @deprecated |
| */ |
| @Override |
| @Deprecated |
| public IType getInput() { |
| if (fInputElement instanceof IType) { |
| return (IType) fInputElement; |
| } |
| return null; |
| } |
| |
| /** |
| * Sets the input to a new type |
| * |
| * @param type |
| * The new input type |
| * @deprecated |
| */ |
| @Override |
| @Deprecated |
| public void setInput(IType type) { |
| setInputElement(type); |
| } |
| |
| /** |
| * Returns the input element of the type hierarchy. Can be of type |
| * <code>IType</code> or <code>IPackageFragment</code> |
| * |
| * @return the input element |
| */ |
| @Override |
| public IModelElement getInputElement() { |
| return fInputElement; |
| } |
| |
| /** |
| * Sets the input to a new element. |
| * |
| * @param element |
| * the input element |
| */ |
| @Override |
| public void setInputElement(IModelElement element) { |
| IMember memberToSelect = null; |
| if (element != null) { |
| if (element instanceof IMember) { |
| if (element.getElementType() != IModelElement.TYPE) { |
| memberToSelect = (IMember) element; |
| element = memberToSelect.getDeclaringType(); |
| |
| } |
| if (element == null || !element.exists()) { |
| MessageDialog.openError(getSite().getShell(), |
| TypeHierarchyMessages.TypeHierarchyViewPart_error_title, |
| TypeHierarchyMessages.TypeHierarchyViewPart_error_message); |
| return; |
| } |
| } else { |
| int kind = element.getElementType(); |
| if (kind != IModelElement.SCRIPT_PROJECT |
| && kind != IModelElement.PROJECT_FRAGMENT) { |
| element = null; |
| DLTKUIPlugin.logErrorMessage( |
| "Invalid type hierarchy input type.");//$NON-NLS-1$ |
| } |
| } |
| } |
| if (element != null && !element.equals(fInputElement)) { |
| addHistoryEntry(element); |
| } |
| |
| updateInput(element); |
| if (memberToSelect != null) { |
| selectMember(memberToSelect); |
| } |
| } |
| |
| /* |
| * Changes the input to a new type |
| * |
| * @param inputElement |
| */ |
| private void updateInput(IModelElement inputElement) { |
| IModelElement prevInput = fInputElement; |
| |
| synchronized (this) { |
| if (fRestoreStateJob != null) { |
| fRestoreStateJob.cancel(); |
| try { |
| fRestoreStateJob.join(); |
| } catch (InterruptedException e) { |
| // ignore |
| } finally { |
| fRestoreStateJob = null; |
| } |
| } |
| } |
| |
| // Make sure the UI got repainted before we execute a long running |
| // operation. This can be removed if we refresh the hierarchy in a |
| // separate thread. |
| // Work-araound for http://dev.eclipse.org/bugs/show_bug.cgi?id=30881 |
| processOutstandingEvents(); |
| if (inputElement == null) { |
| clearInput(); |
| } else { |
| fInputElement = inputElement; |
| try { |
| fHierarchyLifeCycle.ensureRefreshedTypeHierarchy(inputElement, |
| DLTKUIPlugin.getActiveWorkbenchWindow()); |
| // fHierarchyLifeCycle.ensureRefreshedTypeHierarchy(inputElement, |
| // getSite().getWorkbenchWindow()); |
| } catch (InvocationTargetException e) { |
| ExceptionHandler.handle(e, getSite().getShell(), |
| TypeHierarchyMessages.TypeHierarchyViewPart_exception_title, |
| TypeHierarchyMessages.TypeHierarchyViewPart_exception_message); |
| clearInput(); |
| return; |
| } catch (InterruptedException e) { |
| return; |
| } |
| |
| if (inputElement.getElementType() != IModelElement.TYPE) { |
| setView(VIEW_ID_TYPE); |
| } |
| // turn off member filtering |
| fSelectInEditor = false; |
| setMemberFilter(null); |
| internalSelectType(null, false); // clear selection |
| fIsEnableMemberFilter = false; |
| if (!inputElement.equals(prevInput)) { |
| updateHierarchyViewer(true); |
| } |
| IType root = getSelectableType(inputElement); |
| internalSelectType(root, true); |
| updateMethodViewer(root); |
| updateToolbarButtons(); |
| updateTitle(); |
| enableMemberFilter(false); |
| fPagebook.showPage(fTypeMethodsSplitter); |
| fSelectInEditor = true; |
| } |
| } |
| |
| private void processOutstandingEvents() { |
| Display display = getDisplay(); |
| if (display != null && !display.isDisposed()) |
| display.update(); |
| } |
| |
| private void clearInput() { |
| fInputElement = null; |
| fHierarchyLifeCycle.freeHierarchy(); |
| |
| updateHierarchyViewer(false); |
| updateToolbarButtons(); |
| } |
| |
| /* |
| * @see IWorbenchPart#setFocus |
| */ |
| @Override |
| public void setFocus() { |
| fPagebook.setFocus(); |
| } |
| |
| /* |
| * @see IWorkbenchPart#dispose |
| */ |
| @Override |
| public void dispose() { |
| if (fContextActivation != null) { |
| IContextService ctxService = getSite() |
| .getService(IContextService.class); |
| if (ctxService != null) { |
| ctxService.deactivateContext(fContextActivation); |
| } |
| } |
| fHierarchyLifeCycle.freeHierarchy(); |
| fHierarchyLifeCycle |
| .removeChangedListener(fTypeHierarchyLifeCycleListener); |
| fPaneLabelProvider.dispose(); |
| |
| if (fMethodsViewer != null) { |
| fMethodsViewer.dispose(); |
| } |
| |
| if (fPropertyChangeListener != null) { |
| DLTKUIPlugin.getDefault().getPreferenceStore() |
| .removePropertyChangeListener(fPropertyChangeListener); |
| fPropertyChangeListener = null; |
| } |
| |
| getSite().getPage().removePartListener(fPartListener); |
| |
| if (fActionGroups != null) |
| fActionGroups.dispose(); |
| |
| if (fWorkingSetActionGroup != null) { |
| fWorkingSetActionGroup.dispose(); |
| } |
| |
| super.dispose(); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public <T> T getAdapter(Class<T> key) { |
| if (key == IShowInSource.class) { |
| return (T) getShowInSource(); |
| } |
| if (key == IShowInTargetList.class) { |
| return (T) (IShowInTargetList) () -> new String[] { |
| DLTKUIPlugin.ID_SCRIPT_EXPLORER, IPageLayout.ID_RES_NAV }; |
| } |
| // if (key == IContextProvider.class) { |
| // return JavaUIHelp.getHelpContextProvider(this, |
| // IJavaHelpContextIds.TYPE_HIERARCHY_VIEW); |
| // } |
| return super.getAdapter(key); |
| } |
| |
| private Control createTypeViewerControl(Composite parent) { |
| fViewerbook = new PageBook(parent, SWT.NULL); |
| |
| KeyListener keyListener = createKeyListener(); |
| |
| // Create the viewers |
| TypeHierarchyViewer superTypesViewer = new SuperTypeHierarchyViewer( |
| fViewerbook, fHierarchyLifeCycle, this, getPreferenceStore()); |
| initializeTypesViewer(superTypesViewer, keyListener, |
| IContextMenuConstants.TARGET_ID_SUPERTYPES_VIEW); |
| |
| TypeHierarchyViewer subTypesViewer = new SubTypeHierarchyViewer( |
| fViewerbook, fHierarchyLifeCycle, this, getPreferenceStore()); |
| initializeTypesViewer(subTypesViewer, keyListener, |
| IContextMenuConstants.TARGET_ID_SUBTYPES_VIEW); |
| |
| TypeHierarchyViewer vajViewer = new TraditionalHierarchyViewer( |
| fViewerbook, fHierarchyLifeCycle, this, getPreferenceStore()); |
| initializeTypesViewer(vajViewer, keyListener, |
| IContextMenuConstants.TARGET_ID_HIERARCHY_VIEW); |
| |
| fAllViewers = new TypeHierarchyViewer[3]; |
| fAllViewers[VIEW_ID_SUPER] = superTypesViewer; |
| fAllViewers[VIEW_ID_SUB] = subTypesViewer; |
| fAllViewers[VIEW_ID_TYPE] = vajViewer; |
| |
| int currViewerIndex; |
| try { |
| currViewerIndex = fDialogSettings.getInt(DIALOGSTORE_HIERARCHYVIEW); |
| if (currViewerIndex < 0 || currViewerIndex > 2) { |
| currViewerIndex = VIEW_ID_TYPE; |
| } |
| } catch (NumberFormatException e) { |
| currViewerIndex = VIEW_ID_TYPE; |
| } |
| |
| fEmptyTypesViewer = new Label(fViewerbook, |
| SWT.TOP | SWT.LEFT | SWT.WRAP); |
| |
| for (int i = 0; i < fAllViewers.length; i++) { |
| fAllViewers[i].setInput(fAllViewers[i]); |
| } |
| |
| // force the update |
| fCurrentViewerIndex = -1; |
| setView(currViewerIndex); |
| |
| return fViewerbook; |
| } |
| |
| private KeyListener createKeyListener() { |
| return new KeyAdapter() { |
| @Override |
| public void keyReleased(KeyEvent event) { |
| if (event.stateMask == 0) { |
| if (event.keyCode == SWT.F5) { |
| ITypeHierarchy hierarchy = fHierarchyLifeCycle |
| .getHierarchy(); |
| if (hierarchy != null) { |
| fHierarchyLifeCycle.typeHierarchyChanged(hierarchy); |
| doTypeHierarchyChangedOnViewers(null); |
| } |
| updateHierarchyViewer(false); |
| return; |
| } |
| } |
| } |
| }; |
| } |
| |
| private void initializeTypesViewer(final TypeHierarchyViewer typesViewer, |
| KeyListener keyListener, String cotextHelpId) { |
| typesViewer.getControl().setVisible(false); |
| typesViewer.getControl().addKeyListener(keyListener); |
| typesViewer.initContextMenu( |
| menu -> fillTypesViewerContextMenu(typesViewer, menu), |
| cotextHelpId, getSite()); |
| typesViewer.addPostSelectionChangedListener(fSelectionChangedListener); |
| typesViewer.setQualifiedTypeName(isShowQualifiedTypeNames()); |
| typesViewer.setWorkingSetFilter( |
| fWorkingSetActionGroup.getWorkingSetFilter()); |
| } |
| |
| private Control createMethodViewerControl(Composite parent) { |
| fMethodsViewer = new MethodsViewer(parent, fHierarchyLifeCycle, this, |
| getPreferenceStore()); |
| fMethodsViewer.initContextMenu( |
| menu -> fillMethodsViewerContextMenu(menu), |
| IContextMenuConstants.TARGET_ID_MEMBERS_VIEW, getSite()); |
| fMethodsViewer |
| .addPostSelectionChangedListener(fSelectionChangedListener); |
| |
| Control control = fMethodsViewer.getTable(); |
| control.addKeyListener(createKeyListener()); |
| control.addFocusListener(new FocusListener() { |
| @Override |
| public void focusGained(FocusEvent e) { |
| fSelectAllAction.setEnabled(true); |
| } |
| |
| @Override |
| public void focusLost(FocusEvent e) { |
| fSelectAllAction.setEnabled(false); |
| } |
| }); |
| |
| return control; |
| } |
| |
| // private void initDragAndDrop() { |
| // for (int i= 0; i < fAllViewers.length; i++) { |
| // addDragAdapters(fAllViewers[i]); |
| // addDropAdapters(fAllViewers[i]); |
| // } |
| // addDragAdapters(fMethodsViewer); |
| // fMethodsViewer.addDropSupport(DND.DROP_NONE, new Transfer[0], new |
| // DropTargetAdapter()); |
| // |
| // //DND on empty hierarchy |
| // DropTarget dropTarget = new DropTarget(fPagebook, DND.DROP_MOVE | |
| // DND.DROP_COPY | DND.DROP_LINK | DND.DROP_DEFAULT); |
| // dropTarget.setTransfer(new Transfer[] { |
| // LocalSelectionTransfer.getInstance() }); |
| // dropTarget.addDropListener(new TypeHierarchyTransferDropAdapter(this, |
| // fAllViewers[0])); |
| // } |
| // |
| // private void addDropAdapters(AbstractTreeViewer viewer) { |
| // Transfer[] transfers= new Transfer[] { |
| // LocalSelectionTransfer.getInstance() }; |
| // int ops= DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK | |
| // DND.DROP_DEFAULT; |
| // |
| // TransferDropTargetListener[] dropListeners= new |
| // TransferDropTargetListener[] { |
| // new TypeHierarchyTransferDropAdapter(this, viewer) |
| // }; |
| // viewer.addDropSupport(ops, transfers, new |
| // DelegatingDropAdapter(dropListeners)); |
| // } |
| // |
| // private void addDragAdapters(StructuredViewer viewer) { |
| // int ops= DND.DROP_COPY | DND.DROP_LINK; |
| // Transfer[] transfers= new Transfer[] { |
| // LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance()}; |
| // |
| // TransferDragSourceListener[] dragListeners= new |
| // TransferDragSourceListener[] { |
| // new SelectionTransferDragAdapter(viewer), |
| // new ResourceTransferDragAdapter(viewer) |
| // }; |
| // viewer.addDragSupport(ops, transfers, new JdtViewerDragAdapter(viewer, |
| // dragListeners)); |
| // } |
| |
| /** |
| * Returns the inner component in a workbench part. |
| * |
| * @see IWorkbenchPart#createPartControl(Composite) |
| */ |
| @Override |
| public void createPartControl(Composite container) { |
| fParent = container; |
| addResizeListener(container); |
| |
| fPagebook = new PageBook(container, SWT.NONE); |
| fWorkingSetActionGroup = new WorkingSetFilterActionGroup(getSite(), |
| fPropertyChangeListener); |
| |
| // page 1 of page book (no hierarchy label) |
| |
| fNoHierarchyShownLabel = new Label(fPagebook, |
| SWT.TOP + SWT.LEFT + SWT.WRAP); |
| fNoHierarchyShownLabel |
| .setText(TypeHierarchyMessages.TypeHierarchyViewPart_empty); |
| |
| // page 2 of page book (viewers) |
| |
| fTypeMethodsSplitter = new SashForm(fPagebook, SWT.VERTICAL); |
| fTypeMethodsSplitter.setVisible(false); |
| |
| fTypeViewerViewForm = new ViewForm(fTypeMethodsSplitter, SWT.NONE); |
| |
| Control typeViewerControl = createTypeViewerControl( |
| fTypeViewerViewForm); |
| fTypeViewerViewForm.setContent(typeViewerControl); |
| |
| fMethodViewerViewForm = new ViewForm(fTypeMethodsSplitter, SWT.NONE); |
| fTypeMethodsSplitter.setWeights(new int[] { 35, 65 }); |
| |
| Control methodViewerPart = createMethodViewerControl( |
| fMethodViewerViewForm); |
| fMethodViewerViewForm.setContent(methodViewerPart); |
| |
| fMethodViewerPaneLabel = new CLabel(fMethodViewerViewForm, SWT.NONE); |
| fMethodViewerViewForm.setTopLeft(fMethodViewerPaneLabel); |
| |
| ToolBar methodViewerToolBar = new ToolBar(fMethodViewerViewForm, |
| SWT.FLAT | SWT.WRAP); |
| fMethodViewerViewForm.setTopCenter(methodViewerToolBar); |
| |
| // initDragAndDrop(); |
| |
| MenuManager menu = new MenuManager(); |
| menu.add(fFocusOnTypeAction); |
| fNoHierarchyShownLabel |
| .setMenu(menu.createContextMenu(fNoHierarchyShownLabel)); |
| |
| fPagebook.showPage(fNoHierarchyShownLabel); |
| |
| try { |
| fOrientation = fDialogSettings.getInt(DIALOGSTORE_VIEWORIENTATION); |
| if (fOrientation < 0 || fOrientation > 3) { |
| fOrientation = VIEW_ORIENTATION_AUTOMATIC; |
| } |
| } catch (NumberFormatException e) { |
| fOrientation = VIEW_ORIENTATION_AUTOMATIC; |
| } |
| // force the update |
| fCurrentOrientation = -1; |
| // will fill the main tool bar |
| setOrientation(fOrientation); |
| |
| if (fMemento != null) { // restore state before creating action |
| restoreLinkingEnabled(fMemento); |
| } |
| fToggleLinkingAction = new ToggleLinkingAction(this); |
| |
| // set the filter menu items |
| IActionBars actionBars = getViewSite().getActionBars(); |
| IMenuManager viewMenu = actionBars.getMenuManager(); |
| for (int i = 0; i < fViewActions.length; i++) { |
| ToggleViewAction action = fViewActions[i]; |
| viewMenu.add(action); |
| action.setEnabled(false); |
| } |
| viewMenu.add(new Separator()); |
| |
| fWorkingSetActionGroup.fillViewMenu(viewMenu); |
| |
| viewMenu.add(new Separator()); |
| |
| IMenuManager layoutSubMenu = new MenuManager( |
| TypeHierarchyMessages.TypeHierarchyViewPart_layout_submenu); |
| viewMenu.add(layoutSubMenu); |
| for (int i = 0; i < fToggleOrientationActions.length; i++) { |
| layoutSubMenu.add(fToggleOrientationActions[i]); |
| } |
| viewMenu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS)); |
| viewMenu.add(fShowQualifiedTypeNamesAction); |
| viewMenu.add(fToggleLinkingAction); |
| |
| // fill the method viewer tool bar |
| ToolBarManager lowertbmanager = new ToolBarManager(methodViewerToolBar); |
| lowertbmanager.add(fEnableMemberFilterAction); |
| lowertbmanager.add(new Separator()); |
| fMethodsViewer.contributeToToolBar(lowertbmanager); |
| lowertbmanager.update(true); |
| |
| // selection provider |
| int nHierarchyViewers = fAllViewers.length; |
| StructuredViewer[] trackedViewers = new StructuredViewer[nHierarchyViewers |
| + 1]; |
| for (int i = 0; i < nHierarchyViewers; i++) { |
| trackedViewers[i] = fAllViewers[i]; |
| } |
| trackedViewers[nHierarchyViewers] = fMethodsViewer; |
| fSelectionProviderMediator = new SelectionProviderMediator( |
| trackedViewers, getCurrentViewer()); |
| IStatusLineManager slManager = getViewSite().getActionBars() |
| .getStatusLineManager(); |
| fSelectionProviderMediator |
| .addSelectionChangedListener(new StatusBarUpdater(slManager)); |
| |
| getSite().setSelectionProvider(fSelectionProviderMediator); |
| getSite().getPage().addPartListener(fPartListener); |
| |
| // see http://bugs.eclipse.org/bugs/show_bug.cgi?id=33657 |
| IModelElement input = null; // determineInputElement(); |
| if (fMemento != null) { |
| restoreState(fMemento, input); |
| } else if (input != null) { |
| setInputElement(input); |
| } else { |
| setViewerVisibility(false); |
| } |
| |
| // PlatformUI.getWorkbench().getHelpSystem().setHelp(fPagebook, |
| // IJavaHelpContextIds.TYPE_HIERARCHY_VIEW); |
| |
| fActionGroups = new CompositeActionGroup( |
| new ActionGroup[] { new NewWizardsActionGroup(this.getSite()), |
| new OpenEditorActionGroup(this), |
| new OpenViewActionGroup(this), new CCPActionGroup(this), |
| // new GenerateActionGroup(this), |
| new RefactorActionGroup(this, |
| null) /* |
| * , new DLTKSearchActionGroup(this, |
| * getLanguageToolkit()) |
| */ |
| }); |
| |
| fActionGroups.fillActionBars(actionBars); |
| fSelectAllAction = new SelectAllAction(fMethodsViewer); |
| |
| actionBars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), |
| fSelectAllAction); |
| IContextService ctxService = getSite() |
| .getService(IContextService.class); |
| if (ctxService != null) { |
| fContextActivation = ctxService |
| .activateContext(DLTKUIPlugin.CONTEXT_VIEWS); |
| } |
| } |
| |
| private void addResizeListener(Composite parent) { |
| parent.addControlListener(new ControlListener() { |
| @Override |
| public void controlMoved(ControlEvent e) { |
| } |
| |
| @Override |
| public void controlResized(ControlEvent e) { |
| computeOrientation(); |
| } |
| }); |
| } |
| |
| void computeOrientation() { |
| // fix for bug: 63268 error while activating view |
| // avoid recursive calls of compute orientation |
| if (fInComputeOrientation) { |
| return; |
| } |
| fInComputeOrientation = true; |
| try { |
| if (fOrientation != VIEW_ORIENTATION_AUTOMATIC) { |
| setOrientation(fOrientation); |
| } else { |
| if (fOrientation == VIEW_ORIENTATION_SINGLE) |
| return; |
| Point size = fParent.getSize(); |
| if (size.x != 0 && size.y != 0) { |
| if (size.x > size.y) |
| setOrientation(VIEW_ORIENTATION_HORIZONTAL); |
| else |
| setOrientation(VIEW_ORIENTATION_VERTICAL); |
| } |
| } |
| } finally { |
| fInComputeOrientation = false; |
| } |
| } |
| |
| /** |
| * called from ToggleOrientationAction. |
| * |
| * @param orientation |
| * VIEW_ORIENTATION_SINGLE, VIEW_ORIENTATION_HORIZONTAL or |
| * VIEW_ORIENTATION_VERTICAL |
| */ |
| public void setOrientation(int orientation) { |
| if (fCurrentOrientation != orientation) { |
| boolean methodViewerNeedsUpdate = false; |
| |
| if (fMethodViewerViewForm != null |
| && !fMethodViewerViewForm.isDisposed() |
| && fTypeMethodsSplitter != null |
| && !fTypeMethodsSplitter.isDisposed()) { |
| if (orientation == VIEW_ORIENTATION_SINGLE) { |
| fMethodViewerViewForm.setVisible(false); |
| enableMemberFilter(false); |
| updateMethodViewer(null); |
| } else { |
| if (fCurrentOrientation == VIEW_ORIENTATION_SINGLE) { |
| fMethodViewerViewForm.setVisible(true); |
| methodViewerNeedsUpdate = true; |
| } |
| boolean horizontal = orientation == VIEW_ORIENTATION_HORIZONTAL; |
| fTypeMethodsSplitter.setOrientation( |
| horizontal ? SWT.HORIZONTAL : SWT.VERTICAL); |
| } |
| updateMainToolbar(orientation); |
| fTypeMethodsSplitter.layout(); |
| } |
| updateCheckedState(); |
| if (methodViewerNeedsUpdate) { |
| updateMethodViewer(fSelectedType); |
| } |
| fDialogSettings.put(DIALOGSTORE_VIEWORIENTATION, orientation); |
| fCurrentOrientation = orientation; |
| |
| } |
| } |
| |
| private void updateCheckedState() { |
| for (int i = 0; i < fToggleOrientationActions.length; i++) { |
| fToggleOrientationActions[i] |
| .setChecked(fOrientation == fToggleOrientationActions[i] |
| .getOrientation()); |
| } |
| } |
| |
| private void updateMainToolbar(int orientation) { |
| IActionBars actionBars = getViewSite().getActionBars(); |
| IToolBarManager tbmanager = actionBars.getToolBarManager(); |
| |
| if (orientation == VIEW_ORIENTATION_HORIZONTAL) { |
| clearMainToolBar(tbmanager); |
| ToolBar typeViewerToolBar = new ToolBar(fTypeViewerViewForm, |
| SWT.FLAT | SWT.WRAP); |
| fillMainToolBar(new ToolBarManager(typeViewerToolBar)); |
| fTypeViewerViewForm.setTopLeft(typeViewerToolBar); |
| } else { |
| fTypeViewerViewForm.setTopLeft(null); |
| fillMainToolBar(tbmanager); |
| } |
| } |
| |
| private void fillMainToolBar(IToolBarManager tbmanager) { |
| tbmanager.removeAll(); |
| for (int i = 0; i < fViewActions.length; i++) { |
| tbmanager.add(fViewActions[i]); |
| } |
| tbmanager.add(fHistoryDropDownAction); |
| tbmanager.update(false); |
| } |
| |
| private void clearMainToolBar(IToolBarManager tbmanager) { |
| tbmanager.removeAll(); |
| tbmanager.update(false); |
| } |
| |
| /* |
| * Creates the context menu for the hierarchy viewers |
| */ |
| private void fillTypesViewerContextMenu(TypeHierarchyViewer viewer, |
| IMenuManager menu) { |
| DLTKUIPlugin.createStandardGroups(menu); |
| |
| menu.appendToGroup(IContextMenuConstants.GROUP_SHOW, |
| new Separator(GROUP_FOCUS)); |
| // viewer entries |
| viewer.contributeToContextMenu(menu); |
| |
| if (fFocusOnSelectionAction.canActionBeAdded()) |
| menu.appendToGroup(GROUP_FOCUS, fFocusOnSelectionAction); |
| menu.appendToGroup(GROUP_FOCUS, fFocusOnTypeAction); |
| |
| fActionGroups.setContext(new ActionContext( |
| getSite().getSelectionProvider().getSelection())); |
| fActionGroups.fillContextMenu(menu); |
| fActionGroups.setContext(null); |
| } |
| |
| /* |
| * Creates the context menu for the method viewer |
| */ |
| private void fillMethodsViewerContextMenu(IMenuManager menu) { |
| DLTKUIPlugin.createStandardGroups(menu); |
| // viewer entries |
| fMethodsViewer.contributeToContextMenu(menu); |
| fActionGroups.setContext(new ActionContext( |
| getSite().getSelectionProvider().getSelection())); |
| fActionGroups.fillContextMenu(menu); |
| fActionGroups.setContext(null); |
| } |
| |
| /* |
| * Toggles between the empty viewer page and the hierarchy |
| */ |
| private void setViewerVisibility(boolean showHierarchy) { |
| if (showHierarchy) { |
| fViewerbook.showPage(getCurrentViewer().getControl()); |
| } else { |
| fViewerbook.showPage(fEmptyTypesViewer); |
| } |
| } |
| |
| /* |
| * Sets the member filter. <code>null</code> disables member filtering. |
| */ |
| private void setMemberFilter(IMember[] memberFilter) { |
| Assert.isNotNull(fAllViewers); |
| for (int i = 0; i < fAllViewers.length; i++) { |
| fAllViewers[i].setMemberFilter(memberFilter); |
| } |
| } |
| |
| private IType getSelectableType(IModelElement elem) { |
| if (elem.getElementType() != IModelElement.TYPE) { |
| return getCurrentViewer().getTreeRootType(); |
| } else { |
| return (IType) elem; |
| } |
| } |
| |
| private void internalSelectType(IMember elem, boolean reveal) { |
| TypeHierarchyViewer viewer = getCurrentViewer(); |
| viewer.removePostSelectionChangedListener(fSelectionChangedListener); |
| viewer.setSelection(elem != null ? new StructuredSelection(elem) |
| : StructuredSelection.EMPTY, reveal); |
| viewer.addPostSelectionChangedListener(fSelectionChangedListener); |
| } |
| |
| /* |
| * When the input changed or the hierarchy pane becomes visible, |
| * <code>updateHierarchyViewer<code> brings up the correct view and |
| * refreshes the current tree |
| */ |
| private void updateHierarchyViewer(final boolean doExpand) { |
| if (fInputElement == null) { |
| fNoHierarchyShownLabel |
| .setText(TypeHierarchyMessages.TypeHierarchyViewPart_empty); |
| fPagebook.showPage(fNoHierarchyShownLabel); |
| } else { |
| if (getCurrentViewer().containsElements() != null) { |
| Runnable runnable = () -> { |
| final TypeHierarchyViewer viewer = getCurrentViewer(); |
| ((TypeHierarchyContentProvider) viewer.getContentProvider()) |
| .resetState(); |
| viewer.updateContent(doExpand); // refresh |
| }; |
| BusyIndicator.showWhile(getDisplay(), runnable); |
| if (!isChildVisible(fViewerbook, |
| getCurrentViewer().getControl())) { |
| setViewerVisibility(true); |
| } |
| } else { |
| fEmptyTypesViewer.setText(Messages.format( |
| TypeHierarchyMessages.TypeHierarchyViewPart_nodecl, |
| fInputElement.getElementName())); |
| setViewerVisibility(false); |
| } |
| } |
| } |
| |
| private void updateMethodViewer(final IType input) { |
| if (!fIsEnableMemberFilter |
| && fCurrentOrientation != VIEW_ORIENTATION_SINGLE) { |
| if (input == fMethodsViewer.getInput()) { |
| if (input != null) { |
| Runnable runnable = () -> fMethodsViewer.refresh(); |
| BusyIndicator.showWhile(getDisplay(), runnable); |
| } |
| } else { |
| if (input != null) { |
| fMethodViewerPaneLabel |
| .setText(fPaneLabelProvider.getText(input)); |
| fMethodViewerPaneLabel |
| .setImage(fPaneLabelProvider.getImage(input)); |
| } else { |
| fMethodViewerPaneLabel.setText(""); //$NON-NLS-1$ |
| fMethodViewerPaneLabel.setImage(null); |
| } |
| Runnable runnable = () -> fMethodsViewer.setInput(input); |
| BusyIndicator.showWhile(getDisplay(), runnable); |
| } |
| } |
| } |
| |
| protected void doSelectionChanged(SelectionChangedEvent e) { |
| if (e.getSelectionProvider() == fMethodsViewer) { |
| methodSelectionChanged(e.getSelection()); |
| } else { |
| typeSelectionChanged(e.getSelection()); |
| } |
| } |
| |
| private void methodSelectionChanged(ISelection sel) { |
| if (sel instanceof IStructuredSelection) { |
| List<?> selected = ((IStructuredSelection) sel).toList(); |
| int nSelected = selected.size(); |
| if (fIsEnableMemberFilter) { |
| IMember[] memberFilter = null; |
| if (nSelected > 0) { |
| memberFilter = new IMember[nSelected]; |
| selected.toArray(memberFilter); |
| } |
| setMemberFilter(memberFilter); |
| updateHierarchyViewer(true); |
| updateTitle(); |
| internalSelectType(fSelectedType, true); |
| } |
| if (nSelected == 1 && fSelectInEditor) { |
| revealElementInEditor(selected.get(0), fMethodsViewer); |
| } |
| } |
| } |
| |
| private void typeSelectionChanged(ISelection sel) { |
| if (sel instanceof IStructuredSelection) { |
| List<?> selected = ((IStructuredSelection) sel).toList(); |
| int nSelected = selected.size(); |
| if (nSelected != 0) { |
| List<IType> types = new ArrayList<>(nSelected); |
| for (int i = nSelected - 1; i >= 0; i--) { |
| Object elem = selected.get(i); |
| if (elem instanceof IType) { |
| if (!types.contains(elem)) { |
| types.add((IType) elem); |
| } |
| } else if (elem instanceof CumulativeType.Part) { |
| final CumulativeType.Part part = (CumulativeType.Part) elem; |
| if (!types.contains(part.type)) { |
| types.add(part.type); |
| } |
| } |
| } |
| if (types.size() == 1) { |
| fSelectedType = types.get(0); |
| updateMethodViewer(fSelectedType); |
| } else if (types.size() == 0) { |
| // method selected, no change |
| } |
| if (nSelected == 1 && fSelectInEditor) { |
| revealElementInEditor(selected.get(0), getCurrentViewer()); |
| } |
| } else { |
| fSelectedType = null; |
| updateMethodViewer(null); |
| } |
| } |
| } |
| |
| private void revealElementInEditor(Object elem, |
| StructuredViewer originViewer) { |
| // only allow revealing when the type hierarchy is the active page |
| // no revealing after selection events due to model changes |
| |
| if (getSite().getPage().getActivePart() != this) { |
| return; |
| } |
| |
| if (fSelectionProviderMediator.getViewerInFocus() != originViewer) { |
| return; |
| } |
| |
| IEditorPart editorPart = EditorUtility.isOpenInEditor(elem); |
| if (editorPart != null && (elem instanceof IModelElement)) { |
| getSite().getPage().removePartListener(fPartListener); |
| getSite().getPage().bringToTop(editorPart); |
| EditorUtility.revealInEditor(editorPart, (IModelElement) elem); |
| getSite().getPage().addPartListener(fPartListener); |
| } |
| } |
| |
| private Display getDisplay() { |
| if (fPagebook != null && !fPagebook.isDisposed()) { |
| return fPagebook.getDisplay(); |
| } |
| return null; |
| } |
| |
| private boolean isChildVisible(Composite pb, Control child) { |
| Control[] children = pb.getChildren(); |
| for (int i = 0; i < children.length; i++) { |
| if (children[i] == child && children[i].isVisible()) |
| return true; |
| } |
| return false; |
| } |
| |
| private void updateTitle() { |
| String viewerTitle = getCurrentViewer().getTitle(); |
| |
| String tooltip; |
| String title; |
| if (fInputElement != null) { |
| IWorkingSet workingSet = fWorkingSetActionGroup.getWorkingSet(); |
| if (workingSet == null) { |
| String[] args = new String[] { viewerTitle, |
| ScriptElementLabels.getDefault().getElementLabel( |
| fInputElement, |
| ScriptElementLabels.ALL_DEFAULT) }; |
| title = Messages.format( |
| TypeHierarchyMessages.TypeHierarchyViewPart_title, |
| args); |
| tooltip = Messages.format( |
| TypeHierarchyMessages.TypeHierarchyViewPart_tooltip, |
| args); |
| } else { |
| String[] args = new String[] { viewerTitle, |
| ScriptElementLabels.getDefault().getElementLabel( |
| fInputElement, ScriptElementLabels.ALL_DEFAULT), |
| workingSet.getLabel() }; |
| title = Messages.format( |
| TypeHierarchyMessages.TypeHierarchyViewPart_ws_title, |
| args); |
| tooltip = Messages.format( |
| TypeHierarchyMessages.TypeHierarchyViewPart_ws_tooltip, |
| args); |
| } |
| } else { |
| title = ""; //$NON-NLS-1$ |
| tooltip = viewerTitle; |
| } |
| setContentDescription(title); |
| setTitleToolTip(tooltip); |
| } |
| |
| private void updateToolbarButtons() { |
| boolean isType = fInputElement instanceof IType; |
| for (int i = 0; i < fViewActions.length; i++) { |
| ToggleViewAction action = fViewActions[i]; |
| if (action.getViewerIndex() == VIEW_ID_TYPE) { |
| action.setEnabled(fInputElement != null); |
| } else { |
| action.setEnabled(isType); |
| } |
| } |
| } |
| |
| /* |
| * Sets the current view (see view id) called from ToggleViewAction. Must be |
| * called after creation of the view part. |
| */ |
| public void setView(int viewerIndex) { |
| Assert.isNotNull(fAllViewers); |
| if (viewerIndex < fAllViewers.length |
| && fCurrentViewerIndex != viewerIndex) { |
| fCurrentViewerIndex = viewerIndex; |
| |
| updateHierarchyViewer(true); |
| if (fInputElement != null) { |
| ISelection currSelection = getCurrentViewer().getSelection(); |
| if (currSelection == null || currSelection.isEmpty()) { |
| internalSelectType(getSelectableType(fInputElement), false); |
| currSelection = getCurrentViewer().getSelection(); |
| } |
| if (!fIsEnableMemberFilter) { |
| typeSelectionChanged(currSelection); |
| } |
| } |
| updateTitle(); |
| |
| fDialogSettings.put(DIALOGSTORE_HIERARCHYVIEW, viewerIndex); |
| getCurrentViewer().getTree().setFocus(); |
| } |
| for (int i = 0; i < fViewActions.length; i++) { |
| ToggleViewAction action = fViewActions[i]; |
| action.setChecked(fCurrentViewerIndex == action.getViewerIndex()); |
| } |
| } |
| |
| /** |
| * Gets the current active view index. |
| * |
| * @return The index of the current viewer |
| */ |
| public int getViewIndex() { |
| return fCurrentViewerIndex; |
| } |
| |
| private TypeHierarchyViewer getCurrentViewer() { |
| return fAllViewers[fCurrentViewerIndex]; |
| } |
| |
| /** |
| * called from EnableMemberFilterAction. Must be called after creation of |
| * the view part. |
| * |
| * @param on |
| * <code>true</code> to turn the member filter on |
| */ |
| public void enableMemberFilter(boolean on) { |
| if (on != fIsEnableMemberFilter) { |
| fIsEnableMemberFilter = on; |
| if (!on) { |
| IType methodViewerInput = (IType) fMethodsViewer.getInput(); |
| setMemberFilter(null); |
| updateHierarchyViewer(true); |
| updateTitle(); |
| |
| if (methodViewerInput != null && getCurrentViewer() |
| .isElementShown(methodViewerInput)) { |
| // avoid that the method view changes content by selecting |
| // the previous input |
| internalSelectType(methodViewerInput, true); |
| } else if (fSelectedType != null) { |
| // choose a input that exists |
| internalSelectType(fSelectedType, true); |
| updateMethodViewer(fSelectedType); |
| } |
| } else { |
| methodSelectionChanged(fMethodsViewer.getSelection()); |
| } |
| } |
| fEnableMemberFilterAction.setChecked(on); |
| } |
| |
| /** |
| * called from ShowQualifiedTypeNamesAction. Must be called after creation |
| * of the view part. |
| * |
| * @param on |
| * <code>true</code> to enable qualified type names |
| */ |
| public void showQualifiedTypeNames(boolean on) { |
| if (fAllViewers == null) { |
| return; |
| } |
| for (int i = 0; i < fAllViewers.length; i++) { |
| fAllViewers[i].setQualifiedTypeName(on); |
| } |
| } |
| |
| private boolean isShowQualifiedTypeNames() { |
| return fShowQualifiedTypeNamesAction.isChecked(); |
| } |
| |
| /** |
| * Called from ITypeHierarchyLifeCycleListener. Can be called from any |
| * thread |
| * |
| * @param typeHierarchy |
| * Hierarchy that has changed |
| * @param changedTypes |
| * Types in the hierarchy that have change or <code>null</code> |
| * if the full hierarchy has changed |
| */ |
| protected void doTypeHierarchyChanged( |
| final TypeHierarchyLifeCycle typeHierarchy, |
| final IType[] changedTypes) { |
| if (!fIsVisible) { |
| fNeedRefresh = true; |
| return; |
| } |
| if (fIsRefreshRunnablePosted) { |
| return; |
| } |
| |
| Display display = getDisplay(); |
| if (display != null) { |
| fIsRefreshRunnablePosted = true; |
| display.asyncExec(() -> { |
| try { |
| if (fPagebook != null && !fPagebook.isDisposed()) { |
| doTypeHierarchyChangedOnViewers(changedTypes); |
| } |
| } finally { |
| fIsRefreshRunnablePosted = false; |
| } |
| }); |
| } |
| } |
| |
| protected void doTypeHierarchyChangedOnViewers(IType[] changedTypes) { |
| if (fHierarchyLifeCycle.getHierarchy() == null |
| || !fHierarchyLifeCycle.getHierarchy().exists()) { |
| clearInput(); |
| } else { |
| if (changedTypes == null) { |
| // hierarchy change |
| try { |
| fHierarchyLifeCycle.ensureRefreshedTypeHierarchy( |
| fInputElement, getSite().getWorkbenchWindow()); |
| } catch (InvocationTargetException e) { |
| ExceptionHandler.handle(e, getSite().getShell(), |
| TypeHierarchyMessages.TypeHierarchyViewPart_exception_title, |
| TypeHierarchyMessages.TypeHierarchyViewPart_exception_message); |
| clearInput(); |
| return; |
| } catch (InterruptedException e) { |
| return; |
| } |
| fMethodsViewer.refresh(); |
| updateHierarchyViewer(false); |
| } else { |
| // elements in hierarchy modified |
| Object methodViewerInput = fMethodsViewer.getInput(); |
| fMethodsViewer.refresh(); |
| fMethodViewerPaneLabel |
| .setText(fPaneLabelProvider.getText(methodViewerInput)); |
| fMethodViewerPaneLabel.setImage( |
| fPaneLabelProvider.getImage(methodViewerInput)); |
| if (getCurrentViewer().isMethodFiltering()) { |
| if (changedTypes.length == 1) { |
| getCurrentViewer().refresh(changedTypes[0]); |
| } else { |
| updateHierarchyViewer(false); |
| } |
| } else { |
| getCurrentViewer().update(changedTypes, |
| new String[] { IBasicPropertyConstants.P_TEXT, |
| IBasicPropertyConstants.P_IMAGE }); |
| } |
| } |
| } |
| } |
| |
| /* |
| * @see IViewPart#init |
| */ |
| @Override |
| public void init(IViewSite site, IMemento memento) |
| throws PartInitException { |
| super.init(site, memento); |
| fMemento = memento; |
| } |
| |
| /* |
| * @see ViewPart#saveState(IMemento) |
| */ |
| @Override |
| public void saveState(IMemento memento) { |
| if (fPagebook == null) { |
| // part has not been created |
| if (fMemento != null) { // Keep the old state; |
| memento.putMemento(fMemento); |
| } |
| return; |
| } |
| if (fInputElement != null) { |
| String handleIndentifier = fInputElement.getHandleIdentifier(); |
| memento.putString(TAG_INPUT, handleIndentifier); |
| } |
| memento.putInteger(TAG_VIEW, getViewIndex()); |
| memento.putInteger(TAG_ORIENTATION, fOrientation); |
| int weigths[] = fTypeMethodsSplitter.getWeights(); |
| int ratio = (weigths[0] * 1000) / (weigths[0] + weigths[1]); |
| memento.putInteger(TAG_RATIO, ratio); |
| |
| ScrollBar bar = getCurrentViewer().getTree().getVerticalBar(); |
| int position = bar != null ? bar.getSelection() : 0; |
| memento.putInteger(TAG_VERTICAL_SCROLL, position); |
| |
| IModelElement selection = toModelElement( |
| ((IStructuredSelection) getCurrentViewer().getSelection()) |
| .getFirstElement()); |
| if (selection != null) { |
| memento.putString(TAG_SELECTION, selection.getHandleIdentifier()); |
| } |
| |
| fWorkingSetActionGroup.saveState(memento); |
| |
| fMethodsViewer.saveState(memento); |
| |
| saveLinkingEnabled(memento); |
| } |
| |
| private void saveLinkingEnabled(IMemento memento) { |
| memento.putInteger(PreferenceConstants.LINK_TYPEHIERARCHY_TO_EDITOR, |
| fLinkingEnabled ? 1 : 0); |
| } |
| |
| /** |
| * @param element |
| * @return |
| */ |
| private IModelElement toModelElement(Object element) { |
| if (element instanceof IModelElement) { |
| return (IModelElement) element; |
| } else if (element instanceof CumulativeType) { |
| return ((CumulativeType) element).getFirst(); |
| } else if (element instanceof CumulativeType.Part) { |
| return ((CumulativeType.Part) element).type; |
| } |
| return null; |
| } |
| |
| /* |
| * Restores the type hierarchy settings from a memento. |
| */ |
| private void restoreState(final IMemento memento, |
| IModelElement defaultInput) { |
| IModelElement input = defaultInput; |
| String elementId = memento.getString(TAG_INPUT); |
| if (elementId != null) { |
| input = DLTKCore.create(elementId); |
| if (input != null && !input.exists()) { |
| input = null; |
| } |
| } |
| if (input == null) { |
| doRestoreState(memento, input); |
| } else { |
| final IModelElement hierarchyInput = input; |
| |
| synchronized (this) { |
| String label = Messages.format( |
| TypeHierarchyMessages.TypeHierarchyViewPart_restoreinput, |
| hierarchyInput.getElementName()); |
| fNoHierarchyShownLabel.setText(label); |
| |
| fRestoreStateJob = new Job(label) { |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| try { |
| doRestoreInBackground(memento, hierarchyInput, |
| monitor); |
| } catch (ModelException e) { |
| return e.getStatus(); |
| } catch (OperationCanceledException e) { |
| return Status.CANCEL_STATUS; |
| } |
| return Status.OK_STATUS; |
| } |
| }; |
| fRestoreStateJob.schedule(); |
| } |
| } |
| } |
| |
| private void doRestoreInBackground(final IMemento memento, |
| final IModelElement hierarchyInput, IProgressMonitor monitor) |
| throws ModelException { |
| fHierarchyLifeCycle.doHierarchyRefresh(hierarchyInput, monitor); |
| if (!monitor.isCanceled()) { |
| Display.getDefault().asyncExec(() -> { |
| // running async: check first if view still exists |
| if (fPagebook != null && !fPagebook.isDisposed()) { |
| doRestoreState(memento, hierarchyInput); |
| } |
| }); |
| } |
| } |
| |
| final void doRestoreState(IMemento memento, IModelElement input) { |
| synchronized (this) { |
| if (fRestoreStateJob == null) { |
| return; |
| } |
| fRestoreStateJob = null; |
| } |
| |
| fWorkingSetActionGroup.restoreState(memento); |
| setInputElement(input); |
| |
| Integer viewerIndex = memento.getInteger(TAG_VIEW); |
| if (viewerIndex != null) { |
| setView(viewerIndex.intValue()); |
| } |
| Integer orientation = memento.getInteger(TAG_ORIENTATION); |
| if (orientation != null) { |
| fOrientation = orientation.intValue(); |
| } |
| computeOrientation(); |
| updateCheckedState(); |
| |
| Integer ratio = memento.getInteger(TAG_RATIO); |
| if (ratio != null) { |
| fTypeMethodsSplitter.setWeights( |
| new int[] { ratio.intValue(), 1000 - ratio.intValue() }); |
| } |
| ScrollBar bar = getCurrentViewer().getTree().getVerticalBar(); |
| if (bar != null) { |
| Integer vScroll = memento.getInteger(TAG_VERTICAL_SCROLL); |
| if (vScroll != null) { |
| bar.setSelection(vScroll.intValue()); |
| } |
| } |
| fMethodsViewer.restoreState(memento); |
| } |
| |
| private void restoreLinkingEnabled(IMemento memento) { |
| Integer val = memento |
| .getInteger(PreferenceConstants.LINK_TYPEHIERARCHY_TO_EDITOR); |
| if (val != null) { |
| fLinkingEnabled = val.intValue() != 0; |
| } |
| } |
| |
| /** |
| * view part becomes visible |
| * |
| * @param isVisible |
| */ |
| protected void visibilityChanged(boolean isVisible) { |
| fIsVisible = isVisible; |
| if (isVisible && fNeedRefresh) { |
| doTypeHierarchyChangedOnViewers(null); |
| } |
| fNeedRefresh = false; |
| } |
| |
| /** |
| * Link selection to active editor. |
| * |
| * @param editor |
| * The activated editor |
| */ |
| protected void editorActivated(IEditorPart editor) { |
| if (!isLinkingEnabled()) { |
| return; |
| } |
| if (fInputElement == null) { |
| // no type hierarchy shown |
| return; |
| } |
| |
| IModelElement elem = editor.getEditorInput() |
| .getAdapter(IModelElement.class); |
| try { |
| IType type = null; |
| if (elem instanceof ISourceModule) { |
| // Take the first type: |
| IType[] allTypes = ((ISourceModule) elem).getTypes(); |
| if (allTypes.length > 0) { |
| type = allTypes[0]; |
| } |
| } |
| if (type != null) { |
| internalSelectType(type, true); |
| if (getCurrentViewer().getSelection().isEmpty()) { |
| updateMethodViewer(null); |
| } else { |
| updateMethodViewer(type); |
| } |
| } |
| } catch (ModelException e) { |
| DLTKUIPlugin.log(e); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @seeorg.eclipse.jdt.internal.ui.viewsupport.IViewPartInputProvider# |
| * getViewPartInput() |
| */ |
| @Override |
| public Object getViewPartInput() { |
| return fInputElement; |
| } |
| |
| /** |
| * @return Returns the <code>IShowInSource</code> for this view. |
| */ |
| protected IShowInSource getShowInSource() { |
| return () -> new ShowInContext(null, |
| getSite().getSelectionProvider().getSelection()); |
| } |
| |
| boolean isLinkingEnabled() { |
| return fLinkingEnabled; |
| } |
| |
| public void setLinkingEnabled(boolean enabled) { |
| fLinkingEnabled = enabled; |
| getPreferenceStore().setValue( |
| PreferenceConstants.LINK_TYPEHIERARCHY_TO_EDITOR, enabled); |
| |
| if (enabled) { |
| IEditorPart editor = getSite().getPage().getActiveEditor(); |
| if (editor != null) { |
| editorActivated(editor); |
| } |
| } |
| } |
| |
| public void clearNeededRefresh() { |
| fNeedRefresh = false; |
| } |
| |
| } |