/*******************************************************************************
* 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;
}
}