| /******************************************************************************* |
| * Copyright (c) 2000, 2007 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 |
| * |
| |
| * (report 36180: Callers/Callees view) |
| *******************************************************************************/ |
| package org.eclipse.dltk.internal.ui.callhierarchy; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.dltk.core.IMember; |
| import org.eclipse.dltk.core.IMethod; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.ISourceRange; |
| import org.eclipse.dltk.core.ModelException; |
| 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.IDLTKStatusConstants; |
| import org.eclipse.dltk.internal.ui.actions.OpenActionUtil; |
| import org.eclipse.dltk.internal.ui.editor.EditorUtility; |
| import org.eclipse.dltk.ui.DLTKUIPlugin; |
| import org.eclipse.dltk.ui.util.ExceptionHandler; |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.util.OpenStrategy; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.texteditor.ITextEditor; |
| |
| |
| public class CallHierarchyUI { |
| private static final int DEFAULT_MAX_CALL_DEPTH= 10; |
| private static final String PREF_MAX_CALL_DEPTH = "PREF_MAX_CALL_DEPTH"; //$NON-NLS-1$ |
| |
| private static CallHierarchyUI fgInstance; |
| |
| private CallHierarchyUI() { |
| // Do nothing |
| } |
| |
| public static CallHierarchyUI getDefault() { |
| if (fgInstance == null) { |
| fgInstance = new CallHierarchyUI(); |
| } |
| |
| return fgInstance; |
| } |
| |
| /** |
| * Returns the maximum tree level allowed |
| * @return int |
| */ |
| public int getMaxCallDepth() { |
| int maxCallDepth; |
| |
| IPreferenceStore settings = DLTKUIPlugin.getDefault().getPreferenceStore(); |
| maxCallDepth = settings.getInt(PREF_MAX_CALL_DEPTH); |
| if (maxCallDepth < 1 || maxCallDepth > 99) { |
| maxCallDepth= DEFAULT_MAX_CALL_DEPTH; |
| } |
| |
| return maxCallDepth; |
| } |
| |
| public void setMaxCallDepth(int maxCallDepth) { |
| IPreferenceStore settings = DLTKUIPlugin.getDefault().getPreferenceStore(); |
| settings.setValue(PREF_MAX_CALL_DEPTH, maxCallDepth); |
| } |
| |
| public static void jumpToMember(IModelElement element) { |
| if (element != null) { |
| try { |
| IEditorPart methodEditor = EditorUtility.openInEditor(element, true); |
| EditorUtility.revealInEditor(methodEditor, element); |
| } catch (ModelException e) { |
| DLTKUIPlugin.log(e); |
| } catch (PartInitException e) { |
| DLTKUIPlugin.log(e); |
| } |
| } |
| } |
| |
| public static void jumpToLocation(CallLocation callLocation) { |
| try { |
| IEditorPart methodEditor = EditorUtility.openInEditor(callLocation.getMember(), |
| false); |
| |
| if (methodEditor instanceof ITextEditor) { |
| ITextEditor editor = (ITextEditor) methodEditor; |
| editor.selectAndReveal(callLocation.getStart(), |
| (callLocation.getEnd() - callLocation.getStart())); |
| } |
| } catch (ModelException e) { |
| DLTKUIPlugin.log(e); |
| } catch (PartInitException e) { |
| DLTKUIPlugin.log(e); |
| } |
| } |
| |
| /** |
| * @return <code>true</code> iff no error occurred while trying to |
| * open the editor, <code>false</code> iff an error dialog was raised. |
| */ |
| public static boolean openInEditor(Object element, Shell shell, String title) { |
| CallLocation callLocation= CallHierarchy.getCallLocation(element); |
| |
| try { |
| IModelElement enclosingMember; |
| int selectionStart; |
| int selectionLength; |
| |
| if (callLocation != null) { |
| enclosingMember= callLocation.getMember(); |
| selectionStart= callLocation.getStart(); |
| selectionLength= callLocation.getEnd() - selectionStart; |
| } else if (element instanceof MethodWrapper) { |
| enclosingMember= ((MethodWrapper) element).getMember(); |
| ISourceRange selectionRange= null; |
| if( enclosingMember instanceof IMember ) { |
| selectionRange = ((IMember)enclosingMember).getNameRange(); |
| } |
| if (selectionRange == null && enclosingMember instanceof IMember) |
| selectionRange= ((IMember)enclosingMember).getSourceRange(); |
| if (selectionRange == null) |
| return true; |
| selectionStart= selectionRange.getOffset(); |
| selectionLength= selectionRange.getLength(); |
| } else { |
| return true; |
| } |
| |
| boolean activateOnOpen = OpenStrategy.activateOnOpen(); |
| |
| IEditorPart methodEditor = EditorUtility.openInEditor(enclosingMember, activateOnOpen); |
| |
| if (methodEditor instanceof ITextEditor) { |
| ITextEditor editor = (ITextEditor) methodEditor; |
| editor.selectAndReveal(selectionStart, selectionLength); |
| } |
| return true; |
| } catch (ModelException e) { |
| DLTKUIPlugin.log(new Status(IStatus.ERROR, DLTKUIPlugin.getPluginId(), |
| IDLTKStatusConstants.INTERNAL_ERROR, |
| CallHierarchyMessages.CallHierarchyUI_open_in_editor_error_message, e)); |
| |
| ErrorDialog.openError(shell, title, |
| CallHierarchyMessages.CallHierarchyUI_open_in_editor_error_message, |
| e.getStatus()); |
| return false; |
| } catch (PartInitException x) { |
| String name; |
| if (callLocation != null) |
| name= callLocation.getCalledMember().getElementName(); |
| else if (element instanceof MethodWrapper) |
| name= ((MethodWrapper) element).getName(); |
| else |
| name= ""; //$NON-NLS-1$ |
| MessageDialog.openError(shell, title, |
| Messages.format( |
| CallHierarchyMessages.CallHierarchyUI_open_in_editor_error_messageArgs, |
| new String[] { name, x.getMessage() })); |
| return false; |
| } |
| } |
| |
| public static IEditorPart isOpenInEditor(Object elem) { |
| IModelElement modelElement= null; |
| if (elem instanceof MethodWrapper) { |
| modelElement= ((MethodWrapper) elem).getMember(); |
| } else if (elem instanceof CallLocation) { |
| modelElement= ((CallLocation) elem).getCalledMember(); |
| } |
| if (modelElement != null) { |
| return EditorUtility.isOpenInEditor(modelElement); |
| } |
| return null; |
| } |
| |
| /** |
| * Converts the input to a possible input candidates |
| */ |
| public static IModelElement[] getCandidates(Object input) { |
| if (!(input instanceof IModelElement)) { |
| return null; |
| } |
| IModelElement elem= (IModelElement) input; |
| if (elem.getElementType() == IModelElement.METHOD) { |
| return new IModelElement[] { elem }; |
| } |
| return null; |
| } |
| |
| public static CallHierarchyViewPart open(IModelElement[] candidates, IWorkbenchWindow window, String partID) { |
| Assert.isTrue(candidates != null && candidates.length != 0); |
| |
| IModelElement input= null; |
| if (candidates.length > 1) { |
| String title= CallHierarchyMessages.CallHierarchyUI_selectionDialog_title; |
| String message= CallHierarchyMessages.CallHierarchyUI_selectionDialog_message; |
| input= OpenActionUtil.selectModelElement(candidates, window.getShell(), title, message); |
| } else { |
| input= candidates[0]; |
| } |
| if (input == null) |
| return null; |
| |
| return openInViewPart(window, input, partID); |
| } |
| |
| private static void openEditor(Object input, boolean activate) throws PartInitException, ModelException { |
| IEditorPart part= EditorUtility.openInEditor(input, activate); |
| if (input instanceof IModelElement) |
| EditorUtility.revealInEditor(part, (IModelElement) input); |
| } |
| |
| private static CallHierarchyViewPart openInViewPart(IWorkbenchWindow window, IModelElement input, String partID) { |
| IWorkbenchPage page= window.getActivePage(); |
| try { |
| CallHierarchyViewPart result= (CallHierarchyViewPart)page.showView(partID); |
| result.setMethod((IMethod)input); |
| openEditor(input, false); |
| return result; |
| } catch (CoreException e) { |
| ExceptionHandler.handle(e, window.getShell(), |
| CallHierarchyMessages.CallHierarchyUI_error_open_view, e.getMessage()); |
| } |
| return null; |
| } |
| |
| /** |
| * Converts an ISelection (containing MethodWrapper instances) to an ISelection |
| * with the MethodWrapper's replaced by their corresponding IMembers. If the selection |
| * contains elements which are not MethodWrapper instances or not already IMember instances |
| * they are discarded. |
| * @param selection The selection to convert. |
| * @return An ISelection containing IMember's in place of MethodWrapper instances. |
| */ |
| static ISelection convertSelection(ISelection selection) { |
| if (selection.isEmpty()) { |
| return selection; |
| } |
| |
| if (selection instanceof IStructuredSelection) { |
| IStructuredSelection structuredSelection= (IStructuredSelection) selection; |
| List modelElements= new ArrayList(); |
| for (Iterator iter= structuredSelection.iterator(); iter.hasNext();) { |
| Object element= iter.next(); |
| if (element instanceof MethodWrapper) { |
| IModelElement member= ((MethodWrapper)element).getMember(); |
| if (member != null) { |
| modelElements.add(member); |
| } |
| } else if (element instanceof IMember) { |
| modelElements.add(element); |
| } else if (element instanceof CallLocation) { |
| IModelElement member = ((CallLocation) element).getMember(); |
| modelElements.add(member); |
| } |
| } |
| return new StructuredSelection(modelElements); |
| } |
| return StructuredSelection.EMPTY; |
| } |
| } |
