/*******************************************************************************
* 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.callhierarchy;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.IDLTKLanguageToolkit;
import org.eclipse.dltk.core.IMember;
import org.eclipse.dltk.core.IMethod;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.search.IDLTKSearchScope;
import org.eclipse.dltk.internal.corext.callhierarchy.CallHierarchy;
import org.eclipse.dltk.internal.corext.callhierarchy.CallLocation;
import org.eclipse.dltk.internal.corext.callhierarchy.MethodWrapper;
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.refactoring.RefactorActionGroup;
import org.eclipse.dltk.internal.ui.dnd.DelegatingDropAdapter;
import org.eclipse.dltk.internal.ui.dnd.ResourceTransferDragAdapter;
import org.eclipse.dltk.internal.ui.editor.EditorUtility;
import org.eclipse.dltk.internal.ui.scriptview.SelectionTransferDragAdapter;
import org.eclipse.dltk.ui.DLTKUIPlugin;
import org.eclipse.dltk.ui.IContextMenuConstants;
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.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.dialogs.IDialogSettings;
import org.eclipse.jface.util.LocalSelectionTransfer;
import org.eclipse.jface.util.TransferDragSourceListener;
import org.eclipse.jface.util.TransferDropTargetListener;
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.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
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.Label;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPartListener2;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchPartSite;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.ActionContext;
import org.eclipse.ui.actions.ActionGroup;
import org.eclipse.ui.contexts.IContextActivation;
import org.eclipse.ui.contexts.IContextService;
import org.eclipse.ui.part.PageBook;
import org.eclipse.ui.part.ResourceTransfer;
import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.texteditor.ITextEditor;
/**
* This is the main view for the callers plugin. It builds a tree of
* callers/callees and allows the user to double click an entry to go to the
* selected method.
*
*/
public class CallHierarchyViewPart extends ViewPart
implements ICallHierarchyViewPart, ISelectionChangedListener {
private class CallHierarchySelectionProvider
extends SelectionProviderMediator {
public CallHierarchySelectionProvider(StructuredViewer[] viewers) {
super(viewers, null);
}
@Override
public ISelection getSelection() {
ISelection selection = super.getSelection();
if (!selection.isEmpty()) {
return CallHierarchyUI.convertSelection(selection);
}
return selection;
}
}
private static final String DIALOGSTORE_VIEWORIENTATION = "CallHierarchyViewPart.orientation"; //$NON-NLS-1$
private static final String DIALOGSTORE_CALL_MODE = "CallHierarchyViewPart.call_mode"; //$NON-NLS-1$
/**
* The key to be used is
* <code>DIALOGSTORE_RATIO + fCurrentOrientation</code>.
*/
private static final String DIALOGSTORE_RATIO = "CallHierarchyViewPart.ratio"; //$NON-NLS-1$
static final int VIEW_ORIENTATION_VERTICAL = 0;
static final int VIEW_ORIENTATION_HORIZONTAL = 1;
static final int VIEW_ORIENTATION_SINGLE = 2;
static final int VIEW_ORIENTATION_AUTOMATIC = 3;
static final int CALL_MODE_CALLERS = 0;
static final int CALL_MODE_CALLEES = 1;
static final String GROUP_SEARCH_SCOPE = "MENU_SEARCH_SCOPE"; //$NON-NLS-1$
static final String ID_CALL_HIERARCHY = "org.eclipse.dltk.callhierarchy.view"; //$NON-NLS-1$
private static final String GROUP_FOCUS = "group.focus"; //$NON-NLS-1$
private static final int PAGE_EMPTY = 0;
private static final int PAGE_VIEWER = 1;
private Label fNoHierarchyShownLabel;
private PageBook fPagebook;
private IDialogSettings fDialogSettings;
private int fCurrentOrientation;
int fOrientation = CallHierarchyViewPart.VIEW_ORIENTATION_AUTOMATIC;
private int fCurrentCallMode;
private MethodWrapper fCalleeRoot;
private MethodWrapper fCallerRoot;
private IMemento fMemento;
private IMethod fShownMethod;
private CallHierarchySelectionProvider fSelectionProviderMediator;
private List fMethodHistory;
private LocationViewer fLocationViewer;
private SashForm fHierarchyLocationSplitter;
private Clipboard fClipboard;
private SearchScopeActionGroup fSearchScopeActions;
private ToggleOrientationAction[] fToggleOrientationActions;
private ToggleCallModeAction[] fToggleCallModeActions;
private CallHierarchyFiltersActionGroup fFiltersActionGroup;
private HistoryDropDownAction fHistoryDropDownAction;
private RefreshAction fRefreshAction;
private OpenLocationAction fOpenLocationAction;
private FocusOnSelectionAction fFocusOnSelectionAction;
private CopyCallHierarchyAction fCopyAction;
private CancelSearchAction fCancelSearchAction;
private CompositeActionGroup fActionGroups;
private CallHierarchyViewer fCallHierarchyViewer;
private boolean fShowCallDetails;
protected Composite fParent;
private IPartListener2 fPartListener;
private IContextActivation fContextActivation;
public CallHierarchyViewPart() {
super();
fDialogSettings = DLTKUIPlugin.getDefault().getDialogSettings();
fMethodHistory = new ArrayList();
}
@Override
public void setFocus() {
fPagebook.setFocus();
}
/**
* Sets the history entries
*/
public void setHistoryEntries(IMethod[] elems) {
fMethodHistory.clear();
for (int i = 0; i < elems.length; i++) {
fMethodHistory.add(elems[i]);
}
updateHistoryEntries();
}
/**
* Gets all history entries.
*/
public IMethod[] getHistoryEntries() {
if (fMethodHistory.size() > 0) {
updateHistoryEntries();
}
return (IMethod[]) fMethodHistory
.toArray(new IMethod[fMethodHistory.size()]);
}
/**
* Method setMethod.
*
* @param method
*/
public void setMethod(IMethod method) {
if (method == null) {
showPage(CallHierarchyViewPart.PAGE_EMPTY);
return;
}
if (!method.equals(fShownMethod)) {
addHistoryEntry(method);
}
this.fShownMethod = method;
refresh();
}
public void setInputElements(IMember[] members) {
// IMember[] oldMembers= fInputElements;
// fInputElements= members;
if (members == null || members.length == 0) {
showPage(PAGE_EMPTY);
return;
}
if (members.length == 1 && members[0] instanceof IMethod) {
this.fShownMethod = (IMethod) members[0];
}
refresh();
}
public IMethod getMethod() {
return fShownMethod;
}
public MethodWrapper getCurrentMethodWrapper() {
if (fCurrentCallMode == CallHierarchyViewPart.CALL_MODE_CALLERS) {
return fCallerRoot;
} else {
return fCalleeRoot;
}
}
/**
* called from ToggleOrientationAction.
*
* @param orientation
* VIEW_ORIENTATION_HORIZONTAL or VIEW_ORIENTATION_VERTICAL
*/
void setOrientation(int orientation) {
if (fCurrentOrientation != orientation) {
if ((fLocationViewer != null)
&& !fLocationViewer.getControl().isDisposed()
&& (fHierarchyLocationSplitter != null)
&& !fHierarchyLocationSplitter.isDisposed()) {
if (orientation == CallHierarchyViewPart.VIEW_ORIENTATION_SINGLE) {
setShowCallDetails(false);
} else {
if (fCurrentOrientation == CallHierarchyViewPart.VIEW_ORIENTATION_SINGLE) {
setShowCallDetails(true);
}
boolean horizontal = orientation == CallHierarchyViewPart.VIEW_ORIENTATION_HORIZONTAL;
fHierarchyLocationSplitter.setOrientation(
horizontal ? SWT.HORIZONTAL : SWT.VERTICAL);
}
fHierarchyLocationSplitter.layout();
}
updateCheckedState();
fCurrentOrientation = orientation;
restoreSplitterRatio();
}
}
private void updateCheckedState() {
for (int i = 0; i < fToggleOrientationActions.length; i++) {
fToggleOrientationActions[i]
.setChecked(fOrientation == fToggleOrientationActions[i]
.getOrientation());
}
}
/**
* called from ToggleCallModeAction.
*
* @param mode
* CALL_MODE_CALLERS or CALL_MODE_CALLEES
*/
void setCallMode(int mode) {
if (fCurrentCallMode != mode) {
for (int i = 0; i < fToggleCallModeActions.length; i++) {
fToggleCallModeActions[i].setChecked(
mode == fToggleCallModeActions[i].getMode());
}
fCurrentCallMode = mode;
fDialogSettings.put(CallHierarchyViewPart.DIALOGSTORE_CALL_MODE,
mode);
updateView();
}
}
public IDLTKSearchScope getSearchScope() {
return fSearchScopeActions.getSearchScope();
}
public void setShowCallDetails(boolean show) {
fShowCallDetails = show;
showOrHideCallDetailsView();
}
private void initDragAndDrop() {
addDragAdapters(fCallHierarchyViewer);
addDropAdapters(fCallHierarchyViewer);
addDropAdapters(fLocationViewer);
// 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.getTransfer() });
dropTarget.addDropListener(new CallHierarchyTransferDropAdapter(this,
fCallHierarchyViewer));
}
private void addDropAdapters(StructuredViewer viewer) {
Transfer[] transfers = new Transfer[] {
LocalSelectionTransfer.getTransfer() };
int ops = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK
| DND.DROP_DEFAULT;
TransferDropTargetListener[] dropListeners = new TransferDropTargetListener[] {
new CallHierarchyTransferDropAdapter(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.getTransfer(),
ResourceTransfer.getInstance() };
TransferDragSourceListener[] dragListeners = new TransferDragSourceListener[] {
new SelectionTransferDragAdapter(viewer),
new ResourceTransferDragAdapter(viewer) };
// viewer.addDragSupport(ops, transfers, new
// DLTKViewerDragAdapter(viewer, dragListeners));
}
@Override
public void createPartControl(Composite parent) {
fParent = parent;
addResizeListener(parent);
fPagebook = new PageBook(parent, SWT.NONE);
// Page 1: Viewers
createHierarchyLocationSplitter(fPagebook);
createCallHierarchyViewer(fHierarchyLocationSplitter);
createLocationViewer(fHierarchyLocationSplitter);
// Page 2: Nothing selected
fNoHierarchyShownLabel = new Label(fPagebook,
SWT.TOP + SWT.LEFT + SWT.WRAP);
fNoHierarchyShownLabel
.setText(CallHierarchyMessages.CallHierarchyViewPart_empty); //
initDragAndDrop();
showPage(CallHierarchyViewPart.PAGE_EMPTY);
// PlatformUI.getWorkbench().getHelpSystem().setHelp(fPagebook,
// IJavaHelpContextIds.CALL_HIERARCHY_VIEW);
if (DLTKCore.DEBUG) {
System.err.println("Add help support here..."); //$NON-NLS-1$
}
fSelectionProviderMediator = new CallHierarchySelectionProvider(
new StructuredViewer[] { fCallHierarchyViewer,
fLocationViewer });
IStatusLineManager slManager = getViewSite().getActionBars()
.getStatusLineManager();
fSelectionProviderMediator
.addSelectionChangedListener(new StatusBarUpdater(slManager));
getSite().setSelectionProvider(fSelectionProviderMediator);
fCallHierarchyViewer.initContextMenu(
menu -> fillCallHierarchyViewerContextMenu(menu), getSite(),
fSelectionProviderMediator);
fClipboard = new Clipboard(parent.getDisplay());
makeActions();
fillViewMenu();
fillActionBars();
initOrientation();
initCallMode();
if (fMemento != null) {
restoreState(fMemento);
}
restoreSplitterRatio();
addPartListener();
IContextService ctxService = getSite()
.getService(IContextService.class);
if (ctxService != null) {
fContextActivation = ctxService
.activateContext(DLTKUIPlugin.CONTEXT_VIEWS);
}
}
private void restoreSplitterRatio() {
String ratio = fDialogSettings.get(
CallHierarchyViewPart.DIALOGSTORE_RATIO + fCurrentOrientation);
if (ratio == null) {
return;
}
int intRatio = Integer.parseInt(ratio);
fHierarchyLocationSplitter
.setWeights(new int[] { intRatio, 1000 - intRatio });
}
private void saveSplitterRatio() {
if (fHierarchyLocationSplitter != null
&& !fHierarchyLocationSplitter.isDisposed()) {
int[] weigths = fHierarchyLocationSplitter.getWeights();
int ratio = (weigths[0] * 1000) / (weigths[0] + weigths[1]);
String key = CallHierarchyViewPart.DIALOGSTORE_RATIO
+ fCurrentOrientation;
fDialogSettings.put(key, ratio);
}
}
private void addPartListener() {
fPartListener = new IPartListener2() {
@Override
public void partActivated(IWorkbenchPartReference partRef) {
}
@Override
public void partBroughtToTop(IWorkbenchPartReference partRef) {
}
@Override
public void partClosed(IWorkbenchPartReference partRef) {
if (CallHierarchyViewPart.ID_CALL_HIERARCHY
.equals(partRef.getId())) {
saveViewSettings();
}
}
@Override
public void partDeactivated(IWorkbenchPartReference partRef) {
if (CallHierarchyViewPart.ID_CALL_HIERARCHY
.equals(partRef.getId())) {
saveViewSettings();
}
}
@Override
public void partOpened(IWorkbenchPartReference partRef) {
}
@Override
public void partHidden(IWorkbenchPartReference partRef) {
}
@Override
public void partVisible(IWorkbenchPartReference partRef) {
}
@Override
public void partInputChanged(IWorkbenchPartReference partRef) {
}
};
getViewSite().getPage().addPartListener(fPartListener);
}
protected void saveViewSettings() {
saveSplitterRatio();
fDialogSettings.put(CallHierarchyViewPart.DIALOGSTORE_VIEWORIENTATION,
fOrientation);
}
private void addResizeListener(Composite parent) {
parent.addControlListener(new ControlListener() {
@Override
public void controlMoved(ControlEvent e) {
}
@Override
public void controlResized(ControlEvent e) {
computeOrientation();
}
});
}
void computeOrientation() {
saveSplitterRatio();
fDialogSettings.put(CallHierarchyViewPart.DIALOGSTORE_VIEWORIENTATION,
fOrientation);
if (fOrientation != CallHierarchyViewPart.VIEW_ORIENTATION_AUTOMATIC) {
setOrientation(fOrientation);
} else {
if (fOrientation == CallHierarchyViewPart.VIEW_ORIENTATION_SINGLE) {
return;
}
Point size = fParent.getSize();
if (size.x != 0 && size.y != 0) {
if (size.x > size.y) {
setOrientation(
CallHierarchyViewPart.VIEW_ORIENTATION_HORIZONTAL);
} else {
setOrientation(
CallHierarchyViewPart.VIEW_ORIENTATION_VERTICAL);
}
}
}
}
private void showPage(int page) {
if (page == CallHierarchyViewPart.PAGE_EMPTY) {
fPagebook.showPage(fNoHierarchyShownLabel);
} else {
fPagebook.showPage(fHierarchyLocationSplitter);
}
}
/**
* Restores the type hierarchy settings from a memento.
*/
private void restoreState(IMemento memento) {
fSearchScopeActions.restoreState(memento);
}
private void initCallMode() {
int mode;
try {
mode = fDialogSettings
.getInt(CallHierarchyViewPart.DIALOGSTORE_CALL_MODE);
if ((mode < 0) || (mode > 1)) {
mode = CallHierarchyViewPart.CALL_MODE_CALLERS;
}
} catch (NumberFormatException e) {
mode = CallHierarchyViewPart.CALL_MODE_CALLERS;
}
// force the update
fCurrentCallMode = -1;
// will fill the main tool bar
setCallMode(mode);
}
private void initOrientation() {
try {
fOrientation = fDialogSettings
.getInt(CallHierarchyViewPart.DIALOGSTORE_VIEWORIENTATION);
if ((fOrientation < 0) || (fOrientation > 3)) {
fOrientation = CallHierarchyViewPart.VIEW_ORIENTATION_AUTOMATIC;
}
} catch (NumberFormatException e) {
fOrientation = CallHierarchyViewPart.VIEW_ORIENTATION_AUTOMATIC;
}
// force the update
fCurrentOrientation = -1;
setOrientation(fOrientation);
}
private void fillViewMenu() {
IActionBars actionBars = getViewSite().getActionBars();
IMenuManager viewMenu = actionBars.getMenuManager();
viewMenu.add(new Separator());
for (int i = 0; i < fToggleCallModeActions.length; i++) {
viewMenu.add(fToggleCallModeActions[i]);
}
viewMenu.add(new Separator());
MenuManager layoutSubMenu = new MenuManager(
CallHierarchyMessages.CallHierarchyViewPart_layout_menu);
for (int i = 0; i < fToggleOrientationActions.length; i++) {
layoutSubMenu.add(fToggleOrientationActions[i]);
}
viewMenu.add(layoutSubMenu);
}
/**
*
*/
@Override
public void dispose() {
if (fContextActivation != null) {
IContextService ctxService = getSite()
.getService(IContextService.class);
if (ctxService != null) {
ctxService.deactivateContext(fContextActivation);
}
}
if (fActionGroups != null) {
fActionGroups.dispose();
}
if (fClipboard != null) {
fClipboard.dispose();
}
if (fPartListener != null) {
getViewSite().getPage().removePartListener(fPartListener);
fPartListener = null;
}
super.dispose();
}
/**
* Goes to the selected entry, without updating the order of history
* entries.
*/
public void gotoHistoryEntry(IMethod entry) {
if (fMethodHistory.contains(entry)) {
setMethod(entry);
}
}
/*
* (non-Javadoc) Method declared on IViewPart.
*/
@Override
public void init(IViewSite site, IMemento memento)
throws PartInitException {
super.init(site, memento);
fMemento = memento;
}
/**
*
*/
public void refresh() {
setCalleeRoot(null);
setCallerRoot(null);
updateView();
}
@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;
}
fSearchScopeActions.saveState(memento);
}
@Override
public void selectionChanged(SelectionChangedEvent e) {
if (e.getSelectionProvider() == fCallHierarchyViewer) {
methodSelectionChanged(e.getSelection());
}
}
/**
* @param selection
*/
private void methodSelectionChanged(ISelection selection) {
if (selection instanceof IStructuredSelection
&& ((IStructuredSelection) selection).size() == 1) {
Object selectedElement = ((IStructuredSelection) selection)
.getFirstElement();
if (selectedElement instanceof MethodWrapper) {
MethodWrapper methodWrapper = (MethodWrapper) selectedElement;
revealElementInEditor(methodWrapper, fCallHierarchyViewer);
updateLocationsView(methodWrapper);
} else {
updateLocationsView(null);
}
} else {
updateLocationsView(null);
}
}
private void revealElementInEditor(Object elem, Viewer originViewer) {
// only allow revealing when the type hierarchy is the active pagae
// no revealing after selection events due to model changes
if (getSite().getPage().getActivePart() != this) {
return;
}
if (fSelectionProviderMediator.getViewerInFocus() != originViewer) {
return;
}
if (elem instanceof MethodWrapper) {
CallLocation callLocation = CallHierarchy.getCallLocation(elem);
if (callLocation != null) {
IEditorPart editorPart = CallHierarchyUI
.isOpenInEditor(callLocation);
if (editorPart != null) {
getSite().getPage().bringToTop(editorPart);
if (editorPart instanceof ITextEditor) {
ITextEditor editor = (ITextEditor) editorPart;
editor.selectAndReveal(callLocation.getStart(),
(callLocation.getEnd()
- callLocation.getStart()));
}
}
} else {
IEditorPart editorPart = CallHierarchyUI.isOpenInEditor(elem);
getSite().getPage().bringToTop(editorPart);
EditorUtility.revealInEditor(editorPart,
((MethodWrapper) elem).getMember());
}
} else if (elem instanceof IModelElement) {
IEditorPart editorPart = EditorUtility.isOpenInEditor(elem);
if (editorPart != null) {
// getSite().getPage().removePartListener(fPartListener);
getSite().getPage().bringToTop(editorPart);
EditorUtility.revealInEditor(editorPart, (IModelElement) elem);
// getSite().getPage().addPartListener(fPartListener);
}
}
}
/**
* {@inheritDoc}
*/
@Override
public <T> T getAdapter(Class<T> adapter) {
// if (adapter == IContextProvider.class) {
// return JavaUIHelp.getHelpContextProvider(this,
// IJavaHelpContextIds.CALL_HIERARCHY_VIEW);
// }
if (DLTKCore.DEBUG) {
System.err.println("Add help support here..."); //$NON-NLS-1$
}
return super.getAdapter(adapter);
}
/**
* Returns the current selection.
*/
protected ISelection getSelection() {
StructuredViewer viewerInFocus = fSelectionProviderMediator
.getViewerInFocus();
if (viewerInFocus != null) {
return viewerInFocus.getSelection();
}
return StructuredSelection.EMPTY;
}
protected void fillLocationViewerContextMenu(IMenuManager menu) {
DLTKUIPlugin.createStandardGroups(menu);
menu.appendToGroup(IContextMenuConstants.GROUP_SHOW,
fOpenLocationAction);
menu.appendToGroup(IContextMenuConstants.GROUP_SHOW, fRefreshAction);
}
protected void handleKeyEvent(KeyEvent event) {
if (event.stateMask == 0) {
if (event.keyCode == SWT.F5) {
if ((fRefreshAction != null) && fRefreshAction.isEnabled()) {
fRefreshAction.run();
return;
}
}
}
}
private IActionBars getActionBars() {
return getViewSite().getActionBars();
}
private void setCalleeRoot(MethodWrapper calleeRoot) {
this.fCalleeRoot = calleeRoot;
}
private MethodWrapper getCalleeRoot() {
if (fCalleeRoot == null) {
fCalleeRoot = CallHierarchy.getDefault()
.getCalleeRoot(fShownMethod);
}
return fCalleeRoot;
}
private void setCallerRoot(MethodWrapper callerRoot) {
this.fCallerRoot = callerRoot;
}
private MethodWrapper getCallerRoot() {
if (fCallerRoot == null) {
fCallerRoot = CallHierarchy.getDefault()
.getCallerRoot(fShownMethod);
}
return fCallerRoot;
}
/**
* Adds the entry if new. Inserted at the beginning of the history entries
* list.
*/
private void addHistoryEntry(IModelElement entry) {
if (fMethodHistory.contains(entry)) {
fMethodHistory.remove(entry);
}
fMethodHistory.add(0, entry);
fHistoryDropDownAction.setEnabled(!fMethodHistory.isEmpty());
}
/**
* @param parent
*/
private void createLocationViewer(Composite parent) {
fLocationViewer = new LocationViewer(parent);
fLocationViewer.getControl().addKeyListener(createKeyListener());
fLocationViewer.initContextMenu(
menu -> fillLocationViewerContextMenu(menu),
CallHierarchyViewPart.ID_CALL_HIERARCHY, getSite());
}
private void createHierarchyLocationSplitter(Composite parent) {
fHierarchyLocationSplitter = new SashForm(parent, SWT.NONE);
fHierarchyLocationSplitter.addKeyListener(createKeyListener());
}
private void createCallHierarchyViewer(Composite parent) {
fCallHierarchyViewer = new CallHierarchyViewer(parent, this);
fCallHierarchyViewer.addKeyListener(createKeyListener());
fCallHierarchyViewer.addSelectionChangedListener(this);
}
/**
* @param menu
*/
protected void fillCallHierarchyViewerContextMenu(IMenuManager menu) {
DLTKUIPlugin.createStandardGroups(menu);
menu.appendToGroup(IContextMenuConstants.GROUP_SHOW, fRefreshAction);
menu.appendToGroup(IContextMenuConstants.GROUP_SHOW,
new Separator(CallHierarchyViewPart.GROUP_FOCUS));
if (fFocusOnSelectionAction.canActionBeAdded()) {
menu.appendToGroup(CallHierarchyViewPart.GROUP_FOCUS,
fFocusOnSelectionAction);
}
if (fCopyAction.canActionBeAdded()) {
menu.appendToGroup(CallHierarchyViewPart.GROUP_FOCUS, fCopyAction);
}
fActionGroups.setContext(new ActionContext(getSelection()));
fActionGroups.fillContextMenu(menu);
fActionGroups.setContext(null);
}
private void fillActionBars() {
IActionBars actionBars = getActionBars();
IToolBarManager toolBar = actionBars.getToolBarManager();
fActionGroups.fillActionBars(actionBars);
toolBar.add(fCancelSearchAction);
for (int i = 0; i < fToggleCallModeActions.length; i++) {
toolBar.add(fToggleCallModeActions[i]);
}
toolBar.add(fHistoryDropDownAction);
}
private KeyListener createKeyListener() {
KeyListener keyListener = new KeyAdapter() {
@Override
public void keyReleased(KeyEvent event) {
handleKeyEvent(event);
}
};
return keyListener;
}
/**
*
*/
private void makeActions() {
fRefreshAction = new RefreshAction(this);
fOpenLocationAction = new OpenLocationAction(this, getSite());
fLocationViewer.addOpenListener(event -> fOpenLocationAction.run());
fFocusOnSelectionAction = new FocusOnSelectionAction(this);
fCopyAction = new CopyCallHierarchyAction(this, fClipboard,
fCallHierarchyViewer);
fSearchScopeActions = new SearchScopeActionGroup(this,
fDialogSettings) {
@Override
protected IDLTKLanguageToolkit getLangaugeToolkit() {
return getMethodLanguageToolkit();
}
};
fFiltersActionGroup = new CallHierarchyFiltersActionGroup(this,
fCallHierarchyViewer);
fHistoryDropDownAction = new HistoryDropDownAction(this);
fHistoryDropDownAction.setEnabled(false);
fCancelSearchAction = new CancelSearchAction(this);
setCancelEnabled(false);
fToggleOrientationActions = new ToggleOrientationAction[] {
new ToggleOrientationAction(this,
CallHierarchyViewPart.VIEW_ORIENTATION_VERTICAL),
new ToggleOrientationAction(this,
CallHierarchyViewPart.VIEW_ORIENTATION_HORIZONTAL),
new ToggleOrientationAction(this,
CallHierarchyViewPart.VIEW_ORIENTATION_AUTOMATIC),
new ToggleOrientationAction(this,
CallHierarchyViewPart.VIEW_ORIENTATION_SINGLE) };
fToggleCallModeActions = new ToggleCallModeAction[] {
new ToggleCallModeAction(this,
CallHierarchyViewPart.CALL_MODE_CALLERS),
new ToggleCallModeAction(this,
CallHierarchyViewPart.CALL_MODE_CALLEES) };
fActionGroups = new CompositeActionGroup(
new ActionGroup[] { new OpenEditorActionGroup(this),
new OpenViewActionGroup(this), new CCPActionGroup(this),
// new GenerateActionGroup(this),
new RefactorActionGroup(this, null),
// new DLTKSearchActionGroup(this),
fSearchScopeActions, fFiltersActionGroup });
}
protected IDLTKLanguageToolkit getMethodLanguageToolkit() {
if (getMethod() != null) {
return DLTKLanguageManager.getLanguageToolkit(getMethod());
}
return null;
}
private void showOrHideCallDetailsView() {
if (fShowCallDetails) {
fHierarchyLocationSplitter.setMaximizedControl(null);
} else {
fHierarchyLocationSplitter
.setMaximizedControl(fCallHierarchyViewer.getControl());
}
}
private void updateLocationsView(MethodWrapper methodWrapper) {
if (methodWrapper != null
&& methodWrapper.getMethodCall().hasCallLocations()) {
fLocationViewer
.setInput(methodWrapper.getMethodCall().getCallLocations());
} else {
fLocationViewer.clearViewer();
}
}
private void updateHistoryEntries() {
for (int i = fMethodHistory.size() - 1; i >= 0; i--) {
IMethod method = (IMethod) fMethodHistory.get(i);
if (!method.exists()) {
fMethodHistory.remove(i);
}
}
fHistoryDropDownAction.setEnabled(!fMethodHistory.isEmpty());
}
/**
* Method updateView.
*/
private void updateView() {
if ((fShownMethod != null)) {
showPage(CallHierarchyViewPart.PAGE_VIEWER);
CallHierarchy.getDefault().setSearchScope(getSearchScope());
String elementName = ScriptElementLabels.getDefault()
.getElementLabel(fShownMethod,
ScriptElementLabels.ALL_DEFAULT);
String scopeDescription = fSearchScopeActions.getFullDescription();
String[] args = new String[] { elementName, scopeDescription };
// set input to null so that setSorter does not cause a refresh on
// the old contents:
fCallHierarchyViewer.setInput(null);
if (fCurrentCallMode == CallHierarchyViewPart.CALL_MODE_CALLERS) {
setContentDescription(Messages.format(
CallHierarchyMessages.CallHierarchyViewPart_callsToMethod,
args));
fCallHierarchyViewer.setComparator(new ViewerComparator()); // bug
// 111423:
// sort
// caller
// hierarchy
// alphabetically
fCallHierarchyViewer.setMethodWrapper(getCallerRoot());
} else {
setContentDescription(Messages.format(
CallHierarchyMessages.CallHierarchyViewPart_callsFromMethod,
args));
fCallHierarchyViewer.setComparator(null);
fCallHierarchyViewer.setMethodWrapper(getCalleeRoot());
}
}
}
static CallHierarchyViewPart findAndShowCallersView(
IWorkbenchPartSite site) {
IWorkbenchPage workbenchPage = site.getPage();
CallHierarchyViewPart callersView = null;
try {
callersView = (CallHierarchyViewPart) workbenchPage
.showView(CallHierarchyViewPart.ID_CALL_HIERARCHY);
} catch (PartInitException e) {
DLTKUIPlugin.log(e);
}
return callersView;
}
/**
* Cancels the caller/callee search jobs that are currently running.
*/
void cancelJobs() {
fCallHierarchyViewer.cancelJobs();
}
/**
* Sets the enablement state of the cancel button.
*
* @param enabled
*/
void setCancelEnabled(boolean enabled) {
fCancelSearchAction.setEnabled(enabled);
}
}