Attachment #4600 for bug #36520

View | Details | Raw Unified | Return to bug 36520
Collapse All | Expand All




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 *
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.corext.callhierarchy;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.StringTokenizer;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.callhierarchy.ICallHierarchyPreferencesConstants;
import org.eclipse.jdt.internal.ui.util.StringMatcher;
import org.eclipse.jface.preference.IPreferenceStore;

public class CallHierarchy {
    private static final String PREF_USE_FILTERS = "PREF_USE_FILTERS";
    private static final String PREF_FILTERS_LIST = "PREF_FILTERS_LIST";

    private static final String DEFAULT_IGNORE_FILTERS = "java.*,javax.*";
    private static CallHierarchy fgInstance;
    private IJavaSearchScope fSearchScope;
    private StringMatcher[] fFilters;

    public static CallHierarchy getDefault() {
        if (fgInstance == null) {
            fgInstance = new CallHierarchy();
        }

        return fgInstance;
    }

    /**
     * @return
     */
    public boolean isSearchForCalleesUsingImplementorsEnabled() {
        IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();

        return settings.getBoolean(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLEE_SEARCH);
    }

    /**
     * @return
     */
    public boolean isSearchForCallersUsingImplementorsEnabled() {
        IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();

        return settings.getBoolean(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH);
    }

    /**
     * @param method
     *
     * @return
     */
    public Collection getImplementingMethods(IMethod method) {
        if (isSearchForCalleesUsingImplementorsEnabled()) {
            IJavaElement[] result = Implementors.getInstance().searchForImplementors(new IJavaElement[] {
                        method
                    }, new NullProgressMonitor());

            if ((result != null) && (result.length > 0)) {
                return Arrays.asList(result);
            }
        }

        return new ArrayList(0);
    }

    /**
     * @param method
     *
     * @return
     */
    public Collection getInterfaceMethods(IMethod method) {
        if (isSearchForCallersUsingImplementorsEnabled()) {
            IJavaElement[] result = Implementors.getInstance().searchForInterfaces(new IJavaElement[] {
                        method
                    }, new NullProgressMonitor());

            if ((result != null) && (result.length > 0)) {
                return Arrays.asList(result);
            }
        }

        return new ArrayList(0);
    }

    public MethodWrapper getCallerRoot(IMethod method) {
        return new CallerMethodWrapper(null, new MethodCall(method));
    }

    public MethodWrapper getCalleeRoot(IMethod method) {
        return new CalleeMethodWrapper(null, new MethodCall(method));
    }

    public static CallLocation getCallLocation(Object element) {
        CallLocation callLocation = null;

        if (element instanceof MethodWrapper) {
            MethodWrapper methodWrapper = (MethodWrapper) element;
            MethodCall methodCall = methodWrapper.getMethodCall();

            if (methodCall != null) {
                callLocation = methodCall.getFirstCallLocation();
            }
        } else if (element instanceof CallLocation) {
            callLocation = (CallLocation) element;
        }

        return callLocation;
    }

    public IJavaSearchScope getSearchScope() {
        if (fSearchScope != null) {
            return fSearchScope;
        }

        Utility.logDebug("No search scope was set");

        return SearchEngine.createWorkspaceScope();
    }

    public void setSearchScope(IJavaSearchScope searchScope) {
        this.fSearchScope = searchScope;
    }

    /**
     * Checks whether the fully qualified name is ignored by the set filters.
     *
     * @param fullyQualifiedName
     *
     * @return True if the fully qualified name is ignored.
     */
    public boolean isIgnored(String fullyQualifiedName) {
        if ((getIgnoreFilters() != null) && (getIgnoreFilters().length > 0)) {
            for (int i = 0; i < getIgnoreFilters().length; i++) {
                String fullyQualifiedName1 = fullyQualifiedName;

                if (getIgnoreFilters()[i].match(fullyQualifiedName1)) {
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * @return
     */
    public boolean isFilterEnabled() {
        IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();
        return settings.getBoolean(PREF_USE_FILTERS);
    }

    /**
     * @param b
     */
    public void setFilterEnabled(boolean filterEnabled) {
        IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();
        settings.setValue(PREF_USE_FILTERS, filterEnabled);
    }
    
    /**
     * Returns the current filters as a string.
     *
     * @return
     */
    public String getFilters() {
        IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();

        return settings.getString(PREF_FILTERS_LIST);
    }

    public void setFilters(String filters) {
        fFilters = null;

        IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();
        settings.setValue(PREF_FILTERS_LIST, filters);
    }

    /**
     * Returns filters for packages which should not be included in the search results.
     *
     * @return StringMatcher[]
     */
    private StringMatcher[] getIgnoreFilters() {
        if (fFilters == null) {
            String filterString = null;

            if (isFilterEnabled()) {
                filterString = getFilters();

                if (filterString == null) {
                    filterString = DEFAULT_IGNORE_FILTERS;
                }
            }

            if (filterString != null) {
                fFilters = parseList(filterString);
            } else {
                fFilters = null;
            }
        }

        return fFilters;
    }

    /**
     * Parses the comma separated string into an array of StringMatcher objects
     *
     * @return list
     */
    private static StringMatcher[] parseList(String listString) {
        List list = new ArrayList(10);
        StringTokenizer tokenizer = new StringTokenizer(listString, ","); //$NON-NLS-1$

        while (tokenizer.hasMoreTokens()) {
            String textFilter = tokenizer.nextToken();
            list.add(new StringMatcher(textFilter, false, false));
        }

        return (StringMatcher[]) list.toArray(new StringMatcher[list.size()]);
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 *
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.corext.callhierarchy;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jdt.core.IBuffer;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.JavaModelException;

/**
 * @author jl
 */
public class CallLocation implements IAdaptable {
    private IMember fCalledMember;
    private IMember fMember;
    private String fCallText;
    private int fEnd;
    private int fStart;

    /**
     * @param method
     * @param cu
     * @param start
     * @param end
     */
    public CallLocation(IMember member, IMember calledMember, int start, int end) {
        this.fMember = member;
        this.fCalledMember = calledMember;
        this.fStart = start;
        this.fEnd = end;

        fCallText = initializeCallText();
    }

    /**
     * @return IMethod
     */
    public IMember getCalledMember() {
        return fCalledMember;
    }

    /**
     *
     */
    public int getEnd() {
        return fEnd;
    }

    public IMember getMember() {
        return fMember;
    }

    /**
     *
     */
    public int getStart() {
        return fStart;
    }

    public String toString() {
        return fCallText;
    }

    private String initializeCallText() {
        try {
            ICompilationUnit compilationUnit = fMember.getCompilationUnit();

            if ((fMember != null) && (compilationUnit != null)) {
                IBuffer buffer = compilationUnit.getBuffer();

                return buffer.getText(fStart, (fEnd - fStart));
            } else {
                return fMember.getOpenable().getBuffer().getText(fStart, (fEnd - fStart));
            }
        } catch (JavaModelException e) {
            Utility.logError("CallLocation::toString: Error creating text", e);

            return "- error -";
        }
    }

    public Object getAdapter(Class adapter) {
        if (IJavaElement.class.isAssignableFrom(adapter)) {
            return getMember();
        }

        return null;
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 *
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.corext.callhierarchy;

import java.util.HashMap;
import java.util.Map;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IType;

/**
 * @author jl
 */
class CallSearchResultCollector {
    private Map fCalledMembers;

    public CallSearchResultCollector() {
        this.fCalledMembers = createCalledMethodsData();
    }

    public Map getCallers() {
        return fCalledMembers;
    }

    protected void addMember(IMember member, IMember calledMember, int start, int end) {
        if ((member != null) && (calledMember != null)) {
            if (!isIgnored(calledMember)) {
                MethodCall methodCall = (MethodCall) fCalledMembers.get(calledMember.getHandleIdentifier());

                if (methodCall == null) {
                    methodCall = new MethodCall(calledMember);
                    fCalledMembers.put(calledMember.getHandleIdentifier(), methodCall);
                }

                methodCall.addCallLocation(new CallLocation(member, calledMember, start,
                        end));
            }
        }
    }

    protected Map createCalledMethodsData() {
        return new HashMap();
    }

    /**
     * Method isIgnored.
     * @param enclosingElement
     * @return boolean
     */
    private boolean isIgnored(IMember enclosingElement) {
        String fullyQualifiedName = getTypeOfElement(enclosingElement)
                                        .getFullyQualifiedName();

        return CallHierarchy.getDefault().isIgnored(fullyQualifiedName);
    }

    private IType getTypeOfElement(IMember element) {
        if (element.getElementType() == IJavaElement.TYPE) {
            return (IType) element;
        }

        return element.getDeclaringType();
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.corext.callhierarchy;

import java.util.Collection;
import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.ConstructorInvocation;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
import org.eclipse.jdt.core.dom.SuperMethodInvocation;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.internal.corext.dom.Binding2JavaModel;

/**
 * @author jl
 */
class CalleeAnalyzerVisitor extends ASTVisitor {
    private CallSearchResultCollector fSearchResults;
    private IMethod fMethod;
    private IProgressMonitor fProgressMonitor;
    private int fMethodEndPosition;
    private int fMethodStartPosition;

    CalleeAnalyzerVisitor(IMethod method, IProgressMonitor progressMonitor) {
        fSearchResults = new CallSearchResultCollector();
        this.fMethod = method;
        this.fProgressMonitor = progressMonitor;

        try {
            ISourceRange sourceRange = method.getSourceRange();
            this.fMethodStartPosition = sourceRange.getOffset();
            this.fMethodEndPosition = fMethodStartPosition + sourceRange.getLength();
        } catch (JavaModelException jme) {
            Utility.logError("Error getting start and end of method: " +
                fMethod.getElementName(), jme);
        }
    }

    /**
     * Method getCallees.
     *
     * @return CallerElement
     */
    public Map getCallees() {
        return fSearchResults.getCallers();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
     */
    public boolean visit(ClassInstanceCreation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveConstructorBinding(), node);

        return true;
    }

    /**
     * Find all constructor invocations (<code>this(...)</code>) from the called method.
     * Since we only traverse into the AST on the wanted method declaration, this method
     * should not hit on more constructor invocations than those in the wanted method.
     *
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConstructorInvocation)
     */
    public boolean visit(ConstructorInvocation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveConstructorBinding(), node);

        return true;
    }

    /**
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
     */
    public boolean visit(MethodDeclaration node) {
        return isNodeWithinMethod(node);
    }

    /**
     * Find all method invocations from the called method. Since we only traverse into
     * the AST on the wanted method declaration, this method should not hit on more
     * method invocations than those in the wanted method.
     *
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
     */
    public boolean visit(MethodInvocation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveMethodBinding(), node);

        return true;
    }

    /**
     * Find invocations of the supertype's constructor from the called method
     * (=constructor). Since we only traverse into the AST on the wanted method
     * declaration, this method should not hit on more method invocations than those in
     * the wanted method.
     *
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperConstructorInvocation)
     */
    public boolean visit(SuperConstructorInvocation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveConstructorBinding(), node);

        return true;
    }

    /**
     * Find all method invocations from the called method. Since we only traverse into
     * the AST on the wanted method declaration, this method should not hit on more
     * method invocations than those in the wanted method.
     *
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
     */
    public boolean visit(SuperMethodInvocation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveMethodBinding(), node);

        return true;
    }

    /**
     * Adds the specified method binding to the search results.
     *
     * @param calledMethodBinding
     * @param node
     */
    protected void addMethodCall(IMethodBinding calledMethodBinding, ASTNode node) {
        try {
            if (calledMethodBinding != null) {
                fProgressMonitor.worked(1);

                ITypeBinding calledTypeBinding = calledMethodBinding.getDeclaringClass();
                IType calledType = null;

                if (!calledTypeBinding.isAnonymous()) {
                    calledType = Binding2JavaModel.find(calledTypeBinding,
                            fMethod.getJavaProject());
                } else {
                    calledType = Binding2JavaModel.find(calledTypeBinding.getInterfaces()[0],
                            fMethod.getJavaProject());
                }

                IMethod calledMethod = Binding2JavaModel.findIncludingSupertypes(calledMethodBinding,
                        calledType,
                        new SubProgressMonitor(fProgressMonitor, 100,
                            SubProgressMonitor.SUPPRESS_SUBTASK_LABEL));

                if ((calledMethod != null) && calledType.isInterface()) {
                    calledMethod = findImplementingMethods(calledMethod);
                }

                if (!isIgnoredBySearchScope(calledMethod)) {
                    fSearchResults.addMember(fMethod, calledMethod,
                        node.getStartPosition(),
                        node.getStartPosition() + node.getLength());
                }
            }
        } catch (JavaModelException jme) {
            Utility.logError("Error adding callee search result", jme);
        }
    }

    /**
     * @param enclosingElement
     *
     * @return
     */
    private boolean isIgnoredBySearchScope(IMethod enclosingElement) {
        if (enclosingElement != null) {
            return !getSearchScope().encloses(enclosingElement);
        } else {
            return false;
        }
    }

    private IJavaSearchScope getSearchScope() {
        return CallHierarchy.getDefault().getSearchScope();
    }

    private boolean isNodeWithinMethod(ASTNode node) {
        int nodeStartPosition = node.getStartPosition();
        int nodeEndPosition = nodeStartPosition + node.getLength();

        if (nodeStartPosition < fMethodStartPosition) {
            return false;
        }

        if (nodeEndPosition > fMethodEndPosition) {
            return false;
        }

        return true;
    }

    /**
     * @param calledMethod
     */
    private IMethod findImplementingMethods(IMethod calledMethod) {
        Collection implementingMethods = CallHierarchy.getDefault()
                                                        .getImplementingMethods(calledMethod);

        if ((implementingMethods.size() == 0) || (implementingMethods.size() > 1)) {
            return calledMethod;
        } else {
            return (IMethod) implementingMethods.iterator().next();
        }
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.corext.callhierarchy;

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.CompilationUnit;

/**
 * @author jl
 */
class CalleeMethodWrapper extends MethodWrapper {
    private Comparator fMethodWrapperComparator = new MethodWrapperComparator();

    private class MethodWrapperComparator implements Comparator {
        /* (non-Javadoc)
         * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
         */
        public int compare(Object o1, Object o2) {
            MethodWrapper m1 = (MethodWrapper) o1;
            MethodWrapper m2 = (MethodWrapper) o2;

            CallLocation callLocation1 = m1.getMethodCall().getFirstCallLocation();
            CallLocation callLocation2 = m2.getMethodCall().getFirstCallLocation();

            if ((callLocation1 != null) && (callLocation2 != null)) {
                if (callLocation1.getStart() == callLocation2.getStart()) {
                    return callLocation1.getEnd() - callLocation2.getEnd();
                }

                return callLocation1.getStart() - callLocation2.getStart();
            }

            return 0;
        }
    }

    /**
     * Constructor for CalleeMethodWrapper.
     * @param parent
     * @param method
     */
    public CalleeMethodWrapper(MethodWrapper parent, MethodCall methodCall) {
        super(parent, methodCall);
    }

    /* Returns the calls sorted after the call location
     * @see dk.kamstruplinnet.callers.search.MethodWrapper#getCalls()
     */
    public MethodWrapper[] getCalls() {
        MethodWrapper[] result = super.getCalls();
        Arrays.sort(result, fMethodWrapperComparator);

        return result;
    }

    /* (non-Javadoc)
     * @see dk.kamstruplinnet.callers.search.MethodWrapper#getTaskName()
     */
    protected String getTaskName() {
        return null;
    }

    /**
     * @see dk.kamstruplinnet.callers.CallerMethodWrapper#createMethodWrapper(org.eclipse.jdt.core.IMethod)
     */
    protected MethodWrapper createMethodWrapper(MethodCall methodCall) {
        return new CalleeMethodWrapper(this, methodCall);
    }

    /**
     * Find callees called from the current method.
     * @see dk.kamstruplinnet.callers.MethodWrapper#findChildren()
     */
    protected Map findChildren(IProgressMonitor progressMonitor) {
        if (getMember().getElementType() == IJavaElement.METHOD) {
            CalleeAnalyzerVisitor visitor = new CalleeAnalyzerVisitor((IMethod) getMember(),
                    progressMonitor);
            ICompilationUnit icu = getMember().getCompilationUnit();
        
            if (icu != null) {
                CompilationUnit cu = AST.parseCompilationUnit(icu, true);
                cu.accept(visitor);
            }
        
            return visitor.getCallees();
        } else {
            return new HashMap();
        }
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.corext.callhierarchy;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;

/**
 * @author jl
 */
class CallerMethodWrapper extends MethodWrapper {
    public CallerMethodWrapper(MethodWrapper parent, MethodCall methodCall) {
        super(parent, methodCall);
    }

    protected IJavaSearchScope getSearchScope() {
        return CallHierarchy.getDefault().getSearchScope();
    }

    protected String getTaskName() {
        return "Finding callers...";
    }

    /**
     * @see dk.kamstruplinnet.callers.CallerMethodWrapper#createMethodWrapper(org.eclipse.jdt.core.IMethod)
     */
    protected MethodWrapper createMethodWrapper(MethodCall methodCall) {
        return new CallerMethodWrapper(this, methodCall);
    }

    /**
     * @see dk.kamstruplinnet.callers.MethodWrapper#findChildren()
     * @return The result of the search for children
     */
    protected Map findChildren(IProgressMonitor progressMonitor) {
        try {
            MethodReferencesSearchCollector searchCollector = new MethodReferencesSearchCollector();
            SearchEngine searchEngine = new SearchEngine();

            for (Iterator iter = getMembers().iterator();
                        iter.hasNext() && !progressMonitor.isCanceled();) {
                IMember member = (IMember) iter.next();
                searchCollector.setProgressMonitor(new SubProgressMonitor(
                        progressMonitor, 10, SubProgressMonitor.SUPPRESS_SUBTASK_LABEL));
                searchEngine.search(ResourcesPlugin.getWorkspace(), member,
                    IJavaSearchConstants.REFERENCES, getSearchScope(), searchCollector);
            }

            return searchCollector.getCallers();
        } catch (JavaModelException e) {
            Utility.logError("Error finding callers", e);

            return new HashMap(0);
        }
    }

    /**
     * Returns a collection of IMember instances representing what to search for 
     */
    private Collection getMembers() {
        Collection result = new ArrayList();

        result.add(getMember());
        if (getMember().getElementType() == IJavaElement.METHOD) {
            result.addAll(CallHierarchy.getDefault().getInterfaceMethods((IMethod) getMember()));
        }

        return result;
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.corext.callhierarchy;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.eclipse.jdt.core.IMember;

/**
 * @author jl
 */
public class MethodCall {
    private IMember fMember;
    private List fCallLocations;

    /**
     * @param enclosingElement
     */
    public MethodCall(IMember enclosingElement) {
        this.fMember = enclosingElement;
    }

    /**
     *
     */
    public Collection getCallLocations() {
        return fCallLocations;
    }

    public CallLocation getFirstCallLocation() {
        if ((fCallLocations != null) && !fCallLocations.isEmpty()) {
            return (CallLocation) fCallLocations.get(0);
        } else {
            return null;
        }
    }

    /**
     * @return Object
     */
    public Object getKey() {
        return getMember().getHandleIdentifier();
    }

    /**
     *
     */
    public IMember getMember() {
        return fMember;
    }

    /**
     * @param location
     */
    public void addCallLocation(CallLocation location) {
        if (fCallLocations == null) {
            fCallLocations = new ArrayList();
        }

        fCallLocations.add(location);
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.corext.callhierarchy;

import java.util.Map;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.search.IJavaSearchResultCollector;

/**
 * @author jl
 */
class MethodReferencesSearchCollector implements IJavaSearchResultCollector {
    private CallSearchResultCollector fSearchResults;
    private IProgressMonitor fProgressMonitor;
    private boolean fRequireExactMatch = true;

    MethodReferencesSearchCollector() {
        fSearchResults = new CallSearchResultCollector();
    }

    public Map getCallers() {
        return fSearchResults.getCallers();
    }

    /**
     * @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#getProgressMonitor()
     */
    public IProgressMonitor getProgressMonitor() {
        return fProgressMonitor;
    }

    /**
     * @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#aboutToStart()
     */
    public void aboutToStart() {}

    /**
     * @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#accept(org.eclipse.core.resources.IResource, int, int, org.eclipse.jdt.core.IJavaElement, int)
     */
    public void accept(IResource resource, int start, int end,
        IJavaElement enclosingElement, int accuracy) throws CoreException {
        if (fRequireExactMatch && (accuracy != IJavaSearchResultCollector.EXACT_MATCH)) {
            return;
        }

        if (enclosingElement != null && enclosingElement instanceof IMember) {
            IMember member= (IMember) enclosingElement;
            switch (enclosingElement.getElementType()) {
                case IJavaElement.METHOD:
                case IJavaElement.TYPE:
                case IJavaElement.FIELD:
                    fSearchResults.addMember(member, member, start, end);
                    break;
            }
        }
    }

    /**
     * @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#done()
     */
    public void done() {}

    /**
     * @param monitor
     */
    void setProgressMonitor(SubProgressMonitor monitor) {
        this.fProgressMonitor = monitor;
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 *
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.corext.callhierarchy;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;

/**
 * This class represents the general parts of a method call (either to or from a
 * method).
 *
 * @author jl
 */
public abstract class MethodWrapper implements IAdaptable {
    private Map fElements = null;

    /*
     * A cache of previously found methods. This cache should be searched
     * before adding a "new" method object reference to the list of elements.
     * This way previously found methods won't be searched again.
     */
    private Map fMethodCache;
    private MethodCall fMethodCall;
    private MethodWrapper fParent;
    private int fLevel;

    /**
     * Constructor CallerElement.
     */
    public MethodWrapper(MethodWrapper parent, MethodCall methodCall) {
        super();

        if (methodCall == null) {
            throw new IllegalArgumentException("Parameter method cannot be null");
        }

        if (parent == null) {
            setMethodCache(new HashMap());
            fLevel = 1;
        } else {
            setMethodCache(parent.getMethodCache());
            fLevel = parent.getLevel() + 1;
        }

        this.fMethodCall = methodCall;
        this.fParent = parent;
    }

    public Object getAdapter(Class adapter) {
        if (adapter == IMethod.class) {
            if (getMember().getElementType() == IJavaElement.METHOD) {
                return getMember();
            } else {
                return null;
            }
        } else {
            if (IJavaElement.class.isAssignableFrom(adapter)) {
                return getMember();
            }
        }

        return null;
    }

    /**
     * Method getCallerElements.
     * @return The child caller elements of this element
     */
    public MethodWrapper[] getCalls() {
        if (fElements == null) {
            doFindChildren();
        }

        MethodWrapper[] result = new MethodWrapper[fElements.size()];
        int i = 0;

        for (Iterator iter = fElements.keySet().iterator(); iter.hasNext();) {
            MethodCall methodCall = getMethodCallFromMap(fElements, iter.next());
            result[i++] = createMethodWrapper(methodCall);
        }

        return result;
    }

    /**
     * @return int
     */
    public int getLevel() {
        return fLevel;
    }

    /**
     * Method getMethod.
     * @return Object
     */
    public IMember getMember() {
        return getMethodCall().getMember();
    }

    /**
     * @return MethodCall
     */
    public MethodCall getMethodCall() {
        return fMethodCall;
    }

    /**
     * Method getName.
     */
    public String getName() {
        if (getMethodCall() != null) {
            return getMethodCall().getMember().getElementName();
        } else {
            return "";
        }
    }

    /**
     * Method getParent.
     * @return
     */
    public MethodWrapper getParent() {
        return fParent;
    }

    public boolean equals(Object oth) {
        if (this == oth) {
            return true;
        }

        if (oth == null) {
            return false;
        }

        if (oth.getClass() != getClass()) {
            return false;
        }

        MethodWrapper other = (MethodWrapper) oth;

        if (this.fParent == null) {
            if (other.fParent != null) {
                return false;
            }
        } else {
            if (!this.fParent.equals(other.fParent)) {
                return false;
            }
        }

        if (this.getMethodCall() == null) {
            if (other.getMethodCall() != null) {
                return false;
            }
        } else {
            if (!this.getMethodCall().equals(other.getMethodCall())) {
                return false;
            }
        }

        return true;
    }

    public int hashCode() {
        final int PRIME = 1000003;
        int result = 0;

        if (fParent != null) {
            result = (PRIME * result) + fParent.hashCode();
        }

        if (getMethodCall() != null) {
            result = (PRIME * result) + getMethodCall().getMember().hashCode();
        }

        return result;
    }

    /**
     * @see java.lang.Object#toString()
     */
    public String toString() {
        String result;

        result = "CallerElement[name=" + getName() + ", children=";

        if (fElements == null) {
            result += "unknown]";
        } else {
            result += (fElements.size() + "]");
        }

        return result;
    }

    private void setMethodCache(Map methodCache) {
        fMethodCache = methodCache;
    }

    protected abstract String getTaskName();

    private void addCallToCache(MethodCall methodCall) {
        Map cachedCalls = lookupMethod(this.getMethodCall());
        cachedCalls.put(methodCall.getKey(), methodCall);
    }

    /**
     * Method createMethodWrapper.
     * @param method
     * @return MethodWrapper
     */
    protected abstract MethodWrapper createMethodWrapper(MethodCall methodCall);

    private void doFindChildren() {
        Map existingResults = lookupMethod(getMethodCall());

        if (existingResults != null) {
            fElements = new HashMap();
            fElements.putAll(existingResults);
        } else {
            initCalls();

            try {
                IProgressMonitor progressMonitor = getProgressMonitor();

                if (progressMonitor != null) {
                    progressMonitor.beginTask(getTaskName(), IProgressMonitor.UNKNOWN);
                }

                try {
                    performSearch(progressMonitor);
                } finally {
                    if (progressMonitor != null) {
                        progressMonitor.done();
                    }
                }

                //                ModalContext.run(getRunnableWithProgress(), true, getProgressMonitor(),
                //                    Display.getCurrent());
            } catch (Exception e) {
                Utility.logError("Error searching in modal context", e);
            }
        }
    }

    /**
     * Determines if the method represents a recursion call (i.e. whether the
     * method call is already in the cache.)
     *
     * @return True if the call is part of a recursion
     */
    public boolean isRecursive() {
        MethodWrapper current = getParent();

        while (current != null) {
            if (getMember().getHandleIdentifier().equals(current.getMember()
                                                                        .getHandleIdentifier())) {
                return true;
            }

            current = current.getParent();
        }

        return false;
    }

    /**
     * This method finds the children of the current IMethod (either callers or
     * callees, depending on the concrete subclass.
     * @return The result of the search for children
     */
    protected abstract Map findChildren(IProgressMonitor progressMonitor);

    private Map getMethodCache() {
        return fMethodCache;
    }

    private void initCalls() {
        this.fElements = new HashMap();

        initCacheForMethod();
    }

    /**
     * Looks up a previously created search result in the "global" cache.
     * @param method
     * @return List List of previously found search results
     */
    private Map lookupMethod(MethodCall methodCall) {
        return (Map) getMethodCache().get(methodCall.getKey());
    }

    private void performSearch(IProgressMonitor progressMonitor) {
        fElements = findChildren(progressMonitor);

        for (Iterator iter = fElements.keySet().iterator(); iter.hasNext();) {
            MethodCall methodCall = getMethodCallFromMap(fElements, iter.next());
            addCallToCache(methodCall);
        }
    }

    private MethodCall getMethodCallFromMap(Map elements, Object key) {
        return (MethodCall) elements.get(key);
    }

    private IProgressMonitor getProgressMonitor() {
        // TODO: Figure out what to do with progress monitors
        return new NullProgressMonitor();
    }

    private void initCacheForMethod() {
        Map cachedCalls = new HashMap();
        getMethodCache().put(this.getMethodCall().getKey(), cachedCalls);
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.viewers.ISelection;

import org.eclipse.ui.IEditorActionDelegate;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PartInitException;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.actions.OpenActionUtil;
import org.eclipse.jdt.internal.ui.actions.SelectionConverter;
import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;

/**
 * @see IEditorActionDelegate
 */
public abstract class AbstractGotoActionDelegate implements IEditorActionDelegate {
    private IEditorPart fEditor;

    public AbstractGotoActionDelegate() {}

    /**
     * @see IEditorActionDelegate#setActiveEditor
     */
    public void setActiveEditor(IAction action, IEditorPart targetEditor) {
        this.fEditor = targetEditor;
    }

    /**
     * @see IEditorActionDelegate#run
     */
    public void run(IAction action) {
        clearErrorMessage();

        if (fEditor instanceof JavaEditor) {
            try {
                IJavaElement element = SelectionConverter.codeResolve((JavaEditor) fEditor,
                        getShell(), "Title - TODO", "Message - TODO");

                if (element != null) {
                    IJavaElement[] members = internalSearchForMembers(element,
                            getProgressMonitor());

                    if (members != null) {
                        if (members.length == 0) {
                            IJavaElement foundElement = OpenActionUtil.selectJavaElement(members,
                                    getShell(), getSelectMethodTitle(),
                                    getSelectMethodMessage());

                            if (foundElement != null) {
                                OpenActionUtil.open(foundElement, true);
                            }
                        } else {
                            showInfoMessage(getNoResultsMessage());
                        }
                    }
                }
            } catch (JavaModelException e) {
                Utility.logError("Error finding/jumping to method", e);
            } catch (PartInitException e) {
                Utility.logError("Error finding/jumping to method", e);
            }
        }
    }

    private Shell getShell() {
        return JavaPlugin.getActiveWorkbenchWindow().getShell();
    }

    /**
     * @see IEditorActionDelegate#selectionChanged
     */
    public void selectionChanged(IAction action, ISelection selection) {}

    protected abstract String getEmptySelectionMessage();

    protected abstract String getNoResultsMessage();

    protected abstract String getSelectMethodMessage();

    protected abstract String getSelectMethodTitle();

    protected abstract String getTaskName();

    protected IJavaElement[] internalSearchForMembers(IJavaElement element,
        IProgressMonitor progressMonitor) {
        if (progressMonitor == null) {
            progressMonitor = new NullProgressMonitor();
        }

        progressMonitor.beginTask(getTaskName(), IProgressMonitor.UNKNOWN);

        IJavaElement[] result = null;

        try {
            result = searchForMembers(element, progressMonitor);
        } finally {
            progressMonitor.done();
        }

        return result;
    }

    protected abstract IJavaElement[] searchForMembers(IJavaElement element,
        IProgressMonitor progressMonitor);

    private IProgressMonitor getProgressMonitor() {
        return new NullProgressMonitor();

        //        return getStatusLineManager().getProgressMonitor();
    }

    private IStatusLineManager getStatusLineManager() {
        IStatusLineManager statusLineManager = fEditor.getEditorSite().getActionBars()
                                                      .getStatusLineManager();
        statusLineManager.setCancelEnabled(true);

        return statusLineManager;
    }

    private void clearErrorMessage() {
        showErrorMessage(null);
    }

    private void showErrorMessage(String msg) {
        getStatusLineManager().setErrorMessage(msg);
    }

    private void showInfoMessage(String msg) {
        getStatusLineManager().setMessage(msg);
        clearErrorMessage();
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.StringTokenizer;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.OpenStrategy;
import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.texteditor.ITextEditor;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;

import org.eclipse.jdt.ui.JavaUI;

import org.eclipse.jdt.internal.ui.IJavaStatusConstants;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;

import org.eclipse.jdt.internal.corext.callhierarchy.Implementors;

public class CallHierarchy implements IPropertyChangeListener {
    private static CallHierarchy fInstance;
    private IJavaSearchScope fSearchScope;
    private int fMaxCallDepth = -1;

    private CallHierarchy() {
        JavaPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(this);
    }

    public static CallHierarchy getDefault() {
        if (fInstance == null) {
            fInstance = new CallHierarchy();
        }

        return fInstance;
    }

    /**
     * Parses the comma separated string into an array of strings
     *
     * @return list
     */
    public static String[] parseList(String listString) {
        List list = new ArrayList(10);
        StringTokenizer tokenizer = new StringTokenizer(listString, ","); //$NON-NLS-1$

        while (tokenizer.hasMoreTokens()) {
            String token = tokenizer.nextToken();
            list.add(token);
        }

        return (String[]) list.toArray(new String[list.size()]);
    }

    /**
     * Returns filters for packages which should not be included in the search
     * results.
     * @return String[]
     */
    public String[] getIgnoreFilters() {
        IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();

        if (settings.getBoolean(ICallHierarchyPreferencesConstants.PREF_USE_FILTERS)) {
            String[] strings = CallHierarchy.parseList(settings.getString(
                        ICallHierarchyPreferencesConstants.PREF_ACTIVE_FILTERS_LIST));

            return strings;
        } else {
            return null;
        }
    }

    /**
     * Returns the maximum tree level allowed
     * @return int
     */
    public int getMaxCallDepth() {
        if (fMaxCallDepth == -1) {
            IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();

            fMaxCallDepth = settings.getInt(ICallHierarchyPreferencesConstants.PREF_MAX_CALL_DEPTH);
        }

        return fMaxCallDepth;
    }

    /**
     * @return
     */
    public IProgressMonitor getProgressMonitor() {
        //        IProgressMonitor progressMonitor = getStatusLineManager().getProgressMonitor();
        return new NullProgressMonitor();
    }

    /**
     * @return
     */
    public boolean isSearchForCalleesUsingImplementorsEnabled() {
        IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();

        return settings.getBoolean(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLEE_SEARCH);
    }

    /**
     * @return
     */
    public boolean isSearchForCallersUsingImplementorsEnabled() {
        IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();

        return settings.getBoolean(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH);
    }

    public void setSearchScope(IJavaSearchScope searchScope) {
        this.fSearchScope = searchScope;
    }

    public IJavaSearchScope getSearchScope() {
        if (fSearchScope != null) {
            return fSearchScope;
        }

        Utility.logDebug("No search scope was set");

        return SearchEngine.createWorkspaceScope();
    }

    public void initializeDefaultBasePreferences(IPreferenceStore store) {
        store.setDefault(ICallHierarchyPreferencesConstants.PREF_MAX_CALL_DEPTH, 10);
        store.setDefault(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH,
            false);
        store.setDefault(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLEE_SEARCH,
            false);
    }

    public void initializeDefaultFilterPreferences(IPreferenceStore store) {
        store.setDefault(ICallHierarchyPreferencesConstants.PREF_ACTIVE_FILTERS_LIST,
            "javax.*,java.*");
        store.setDefault(ICallHierarchyPreferencesConstants.PREF_INACTIVE_FILTERS_LIST,
            "com.ibm.*,com.sun.*,org.omg.*,sun.*,sunw.*"); //$NON-NLS-1$
        store.setDefault(ICallHierarchyPreferencesConstants.PREF_USE_FILTERS, true);
    }

    public void initializeDefaultPreferences(IPreferenceStore store) {
        initializeDefaultBasePreferences(store);
        initializeDefaultFilterPreferences(store);
    }

    /**
     * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(PropertyChangeEvent)
     */
    public void propertyChange(PropertyChangeEvent event) {
        if (event.getProperty().equals(ICallHierarchyPreferencesConstants.PREF_MAX_CALL_DEPTH)) {
            fMaxCallDepth = ((Integer) event.getNewValue()).intValue();
        }
    }

    /**
     * This method removes this class as a property change listener on the plugin's preference
     * store.
     *
     * TODO: Does this class ever receive shutdown messages?
     */
    public void shutdown() {
        JavaPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(this);
    }

    private IStatusLineManager getStatusLineManager() {
        IStatusLineManager statusLineManager = PlatformUI.getWorkbench()
                                                         .getActiveWorkbenchWindow()
                                                         .getActivePage()
                                                         .findView(CallHierarchyViewPart.CALLERS_VIEW_ID)
                                                         .getViewSite().getActionBars()
                                                         .getStatusLineManager();
        statusLineManager.setCancelEnabled(true);

        return statusLineManager;
    }

    /**
     * @param method
     * @return
     */
    public Collection getInterfaceMethods(IMethod method) {
        if (isSearchForCallersUsingImplementorsEnabled()) {
            IJavaElement[] result = Implementors.getInstance().searchForInterfaces(new IJavaElement[] {
                        method
                    }, new NullProgressMonitor());
    
            if ((result != null) && (result.length > 0)) {
                return Arrays.asList(result);
            }
        }
    
        return new ArrayList(0);
    }

    /**
     * @param method
     * @return
     */
    public Collection getImplementingMethods(IMethod method) {
        if (isSearchForCalleesUsingImplementorsEnabled()) {
            IJavaElement[] result = Implementors.getInstance().searchForImplementors(new IJavaElement[] {
                        method
                    }, new NullProgressMonitor());
    
            if ((result != null) && (result.length > 0)) {
                return Arrays.asList(result);
            }
        }
    
        return new ArrayList(0);
    }

    public MethodWrapper getCallerRoot(IMethod method) {
        return new CallerMethodWrapper(null, new MethodCall(method));
    }

    public MethodWrapper getCalleeRoot(IMethod method) {
        return new CalleeMethodWrapper(null, new MethodCall(method));
    }

    public static void jumpToMember(IJavaElement element) {
        if (element != null) {
            try {
                IEditorPart methodEditor = EditorUtility.openInEditor(element, true);
                JavaUI.revealInEditor(methodEditor, (IJavaElement) element);
            } catch (JavaModelException e) {
                Utility.logError("Error getting underlying resource", e);
            } catch (PartInitException e) {
                Utility.logError("Error opening editor", e);
            }
        }
    }

    static CallLocation getCallLocation(Object element) {
        CallLocation callLocation = null;

        if (element instanceof MethodWrapper) {
            MethodWrapper methodWrapper = (MethodWrapper) element;
            MethodCall methodCall = methodWrapper.getMethodCall();

            if (methodCall != null) {
                callLocation = methodCall.getFirstCallLocation();
            }
        } else if (element instanceof CallLocation) {
            callLocation = (CallLocation) element;
        }

        return callLocation;
    }

    public static void openInEditor(Object element, Shell shell, String title) {
        CallLocation callLocation= null;
        if (element instanceof CallLocation) {
            callLocation= (CallLocation) element;
        } else if (element instanceof CallLocation) {
            callLocation= getCallLocation(element);
        }

        if (callLocation == null) {
            return;
        }

        try {
            boolean activateOnOpen = OpenStrategy.activateOnOpen();

            IEditorPart methodEditor = EditorUtility.openInEditor(callLocation.getMember(),
                    activateOnOpen);

            if (methodEditor instanceof ITextEditor) {
                ITextEditor editor = (ITextEditor) methodEditor;
                editor.selectAndReveal(callLocation.getStart(),
                    (callLocation.getEnd() - callLocation.getStart()));
            }
        } catch (JavaModelException e) {
            JavaPlugin.log(new Status(IStatus.ERROR, JavaPlugin.getPluginId(),
                    IJavaStatusConstants.INTERNAL_ERROR,
                    CallHierarchyMessages.getString(
                        "CallHierarchy.open_in_editor.error.message"), e)); //$NON-NLS-1$

            ErrorDialog.openError(shell, title,
                CallHierarchyMessages.getString(
                    "CallHierarchy.open_in_editor.error.messageProblems"), //$NON-NLS-1$
                e.getStatus());
        } catch (PartInitException x) {
            String name = callLocation.getCalledMember().getElementName();
            MessageDialog.openError(shell,
                CallHierarchyMessages.getString(
                    "CallHierarchy.open_in_editor.error.messageProblems"), //$NON-NLS-1$
                CallHierarchyMessages.getFormattedString(
                    "CallHierarchy.open_in_editor.error.messageArgs", //$NON-NLS-1$
                    new String[] { name, x.getMessage() }));
        }
    }

    /**
     * @param elem
     * @return
     */
    public static IEditorPart isOpenInEditor(Object elem) {
        IJavaElement javaElement= null;
        if (elem instanceof MethodWrapper) {
            javaElement= ((MethodWrapper) elem).getMember();
        } else if (elem instanceof CallLocation) {
            javaElement= ((CallLocation) elem).getCalledMember();
        }
        if (javaElement != null) {
            return EditorUtility.isOpenInEditor(javaElement);
        }
        return null;
    }
}




 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jdt.core.IJavaElement;

class CallHierarchyContentProvider implements ITreeContentProvider {
    private final static Object[] EMPTY_ARRAY = new Object[0];
    private TreeViewer fViewer;

    }

    private boolean isMaxCallDepthExceeded(MethodWrapper methodWrapper) {
        return methodWrapper.getLevel() > CallHierarchyUI.getDefault().getMaxCallDepth();
    }

    /**




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.util.Assert;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.actions.ActionGroup;

/**
 * Action group to add the filter action to a view part's toolbar
 * menu.
 * <p>
 * This class may be instantiated; it is not intended to be subclassed.
 * </p>
 * 
 * @since 2.0
 */
public class CallHierarchyFiltersActionGroup extends ActionGroup {

    class ShowFilterDialogAction extends Action {
        ShowFilterDialogAction() {
            setText(CallHierarchyMessages.getString("ShowFilterDialogAction.text")); //$NON-NLS-1$
            setImageDescriptor(JavaPluginImages.DESC_CLCL_FILTER);
        }
        
        public void run() {
            openDialog();
        }
    }

    private IViewPart fPart;
    private StructuredViewer fViewer;

    /**
     * Creates a new <code>CustomFiltersActionGroup</code>.
     * 
     * @param part      the view part that owns this action group
     * @param viewer    the viewer to be filtered
     */
    public CallHierarchyFiltersActionGroup(IViewPart part, StructuredViewer viewer) {
        Assert.isNotNull(part);
        Assert.isNotNull(viewer);
        fPart= part;
        fViewer= viewer;
    }

    /* (non-Javadoc)
     * Method declared on ActionGroup.
     */
    public void fillActionBars(IActionBars actionBars) {
        fillToolBar(actionBars.getToolBarManager());
        fillViewMenu(actionBars.getMenuManager());
    }

    private void fillToolBar(IToolBarManager toolBar) {
    }

    private void fillViewMenu(IMenuManager viewMenu) {
        viewMenu.add(new Separator("filters")); //$NON-NLS-1$
        viewMenu.add(new ShowFilterDialogAction());
    }

    /* (non-Javadoc)
     * Method declared on ActionGroup.
     */
    public void dispose() {
        super.dispose();
    }
    
    // ---------- dialog related code ----------

    private void openDialog() {
        FiltersDialog dialog= new FiltersDialog(
            fPart.getViewSite().getShell());
        
        dialog.open();
    }
}

Lines 13-23 Link Here

(-)ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyLabelProvider.java (-4 / +3 lines)
13		13
14	import java.util.Collection;	14	import java.util.Collection;
15		15
16	import org.eclipse.swt.graphics.Image;	16	import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;
17
18	import org.eclipse.jface.viewers.LabelProvider;
19
20	import org.eclipse.jdt.ui.JavaElementLabelProvider;	17	import org.eclipse.jdt.ui.JavaElementLabelProvider;
		18	import org.eclipse.jface.viewers.LabelProvider;
		19	import org.eclipse.swt.graphics.Image;
21		20
22	class CallHierarchyLabelProvider extends LabelProvider {	21	class CallHierarchyLabelProvider extends LabelProvider {
23	private JavaElementLabelProvider fJavaElementLabelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_BASICS);	22	private JavaElementLabelProvider fJavaElementLabelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_BASICS);




# 			(report 36180: Callers/Callees view)
###############################################################################

CallHierarchyPreferenceFilterPage.description=Filters
CallHierarchyPreferenceFilterPage.use.package.filters=Use package filters
CallHierarchyPreferenceFilterPage.defined.package.filters=Defined package filters
CallHierarchyPreferenceFilterPage.add.filter=Add filter
CallHierarchyPreferenceFilterPage.add.filter.tooltip=Add filter (tooltip)
CallHierarchyPreferenceFilterPage.add.package=Add package
CallHierarchyPreferenceFilterPage.add.package.tooltip=Add package (tooltip)
CallHierarchyPreferenceFilterPage.remove.filter=Remove filter
CallHierarchyPreferenceFilterPage.remove.filter.tooltip=Remove filter (tooltip)
CallHierarchyPreferenceFilterPage.enable.all=Enable all
CallHierarchyPreferenceFilterPage.enable.all.tooltip=Enable all (tooltip)
CallHierarchyPreferenceFilterPage.disable.all=Disable all
CallHierarchyPreferenceFilterPage.disable.all.tooltip=Disable all (tooltip)
CallHierarchyPreferenceFilterPage.invalid.input=Invalid input
CallHierarchyPreferenceFilterPage.addpackagedialog.title=addpackagedialog.title
CallHierarchyPreferenceFilterPage.addpackagedialog.error.message=addpackagedialog.error.message
CallHierarchyPreferenceFilterPage.addpackagedialog.message=addpackagedialog.message
CallHierarchyPreferenceFilterPage.label.defaultpackage=label.defaultpackage
CallHierarchyViewPart.empty=No method has been selected.
ToggleCallModeAction.callers.tooltip=Show the Caller Hierarchy
ToggleCallModeAction.callers.label=Caller Hierarchy

ToggleJavaLabelFormatAction.long.label=Long format
ToggleOrientationAction.vertical.label=Vertical View Orientation
ToggleOrientationAction.horizontal.label=Horizontal View Orientation
ToggleOrientationAction.single.label=Hierarchy View Only
ShowFilterDialogAction.text= &Filters...
FiltersDialog.filter= Filter Calls
FiltersDialog.filterOnNames= Filter on path names:
FiltersDialog.maxCallDepth= Max call depth:
FiltersDialog.titleMaxCallDepthInvalid= Error
FiltersDialog.messageMaxCallDepthInvalid= The max call depth must be in range [1..99]




 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jface.preference.BooleanFieldEditor;
import org.eclipse.jface.preference.FieldEditorPreferencePage;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.IntegerFieldEditor;

import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;

import org.eclipse.jdt.internal.ui.JavaPlugin;

/**
 * @see PreferencePage
 */

     * Set the default preferences for this page.
     */
    public static void initDefaults(IPreferenceStore store) {
        CallHierarchyUI.getDefault().initializeDefaultBasePreferences(store);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.preference.FieldEditorPreferencePage#createFieldEditors()
     */
    protected void createFieldEditors() {
        IntegerFieldEditor maxCallDepth = new IntegerFieldEditor(ICallHierarchyPreferencesConstants.PREF_MAX_CALL_DEPTH,
                "&Max call depth", getFieldEditorParent());
        maxCallDepth.setValidRange(1, 99);
        addField(maxCallDepth);

        BooleanFieldEditor useImplementorsForCallerSearch = new BooleanFieldEditor(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH,
                "Search for &callers using the Implementors plugin",
                getFieldEditorParent());

                "Sea&rch for callees using the Implementors plugin",
                getFieldEditorParent());
        addField(useImplementorsForCalleeSearch);

        // This should be reenabled when the openInEditor(Object, boolean) method is made API.
        //        BooleanFieldEditor activateEditorOnSelect = new BooleanFieldEditor(ICallersConstants.PREF_ACTIVATE_EDITOR_ON_SELECT,
        //                "&Activate editor on select", getFieldEditorParent());
        //        addField(activateEditorOnSelect);
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.corext.callhierarchy.CallHierarchy;
import org.eclipse.jdt.internal.corext.callhierarchy.CallLocation;
import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;
import org.eclipse.jdt.internal.ui.IJavaStatusConstants;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jface.action.IStatusLineManager;
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.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.texteditor.ITextEditor;

/**
 * @author jl
 */
class CallHierarchyUI {
    private static final int DEFAULT_MAX_CALL_DEPTH= 10;    
    private static final String PREF_MAX_CALL_DEPTH = "PREF_MAX_CALL_DEPTH";

    private static CallHierarchyUI fgInstance;

    private CallHierarchyUI() { }

    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 = JavaPlugin.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 = JavaPlugin.getDefault().getPreferenceStore();
        settings.setValue(PREF_MAX_CALL_DEPTH, maxCallDepth);
    }
    
    public void initializeDefaultBasePreferences(IPreferenceStore store) {
        store.setDefault(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH,
            false);
        store.setDefault(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLEE_SEARCH,
            false);
    }

    private IStatusLineManager getStatusLineManager() {
        IStatusLineManager statusLineManager = PlatformUI.getWorkbench()
                                                         .getActiveWorkbenchWindow()
                                                         .getActivePage()
                                                         .findView(CallHierarchyViewPart.CALLERS_VIEW_ID)
                                                         .getViewSite().getActionBars()
                                                         .getStatusLineManager();
        statusLineManager.setCancelEnabled(true);

        return statusLineManager;
    }

    public static void jumpToMember(IJavaElement element) {
        if (element != null) {
            try {
                IEditorPart methodEditor = EditorUtility.openInEditor(element, true);
                JavaUI.revealInEditor(methodEditor, (IJavaElement) element);
            } catch (JavaModelException e) {
                Utility.logError("Error getting underlying resource", e);
            } catch (PartInitException e) {
                Utility.logError("Error opening editor", e);
            }
        }
    }

    public static void openInEditor(Object element, Shell shell, String title) {
        CallLocation callLocation= null;
        if (element instanceof CallLocation) {
            callLocation= (CallLocation) element;
        } else if (element instanceof CallLocation) {
            callLocation= CallHierarchy.getCallLocation(element);
        }

        if (callLocation == null) {
            return;
        }

        try {
            boolean activateOnOpen = OpenStrategy.activateOnOpen();

            IEditorPart methodEditor = EditorUtility.openInEditor(callLocation.getMember(),
                    activateOnOpen);

            if (methodEditor instanceof ITextEditor) {
                ITextEditor editor = (ITextEditor) methodEditor;
                editor.selectAndReveal(callLocation.getStart(),
                    (callLocation.getEnd() - callLocation.getStart()));
            }
        } catch (JavaModelException e) {
            JavaPlugin.log(new Status(IStatus.ERROR, JavaPlugin.getPluginId(),
                    IJavaStatusConstants.INTERNAL_ERROR,
                    CallHierarchyMessages.getString(
                        "CallHierarchyUI.open_in_editor.error.message"), e)); //$NON-NLS-1$

            ErrorDialog.openError(shell, title,
                CallHierarchyMessages.getString(
                    "CallHierarchyUI.open_in_editor.error.messageProblems"), //$NON-NLS-1$
                e.getStatus());
        } catch (PartInitException x) {
            String name = callLocation.getCalledMember().getElementName();
            MessageDialog.openError(shell,
                CallHierarchyMessages.getString(
                    "CallHierarchyUI.open_in_editor.error.messageProblems"), //$NON-NLS-1$
                CallHierarchyMessages.getFormattedString(
                    "CallHierarchyUI.open_in_editor.error.messageArgs", //$NON-NLS-1$
                    new String[] { name, x.getMessage() }));
        }
    }

    /**
     * @param elem
     * @return
     */
    public static IEditorPart isOpenInEditor(Object elem) {
        IJavaElement javaElement= null;
        if (elem instanceof MethodWrapper) {
            javaElement= ((MethodWrapper) elem).getMember();
        } else if (elem instanceof CallLocation) {
            javaElement= ((CallLocation) elem).getCalledMember();
        }
        if (javaElement != null) {
            return EditorUtility.isOpenInEditor(javaElement);
        }
        return null;
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 *
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
 *             (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.internal.corext.callhierarchy.CallHierarchy;
import org.eclipse.jdt.internal.corext.callhierarchy.CallLocation;
import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;
import org.eclipse.jdt.ui.IContextMenuConstants;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.ui.actions.OpenViewActionGroup;
import org.eclipse.jdt.ui.actions.RefactorActionGroup;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;

import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IMemento;

import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.texteditor.ITextEditor;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.search.IJavaSearchScope;

import org.eclipse.jdt.ui.IContextMenuConstants;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.ui.actions.CustomFiltersActionGroup;
import org.eclipse.jdt.ui.actions.OpenViewActionGroup;
import org.eclipse.jdt.ui.actions.RefactorActionGroup;

import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;

/**
 * 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.

    private int fCurrentOrientation;
    private int fCurrentCallMode;
    private int fCurrentJavaLabelFormat;
    private MethodWrapper fCalleeRoot;
    private MethodWrapper fCallerRoot;
    private IMemento fMemento;
    private IMethod fShownMethod;
    private SelectionProviderMediator fSelectionProviderMediator;
    private List fMethodHistory;
    private ListViewer fLocationViewer;
    private Menu fLocationContextMenu;
    private Menu fTreeContextMenu;
    private SashForm fHierarchyLocationSplitter;
    private SearchScopeActionGroup fSearchScopeActions;
    private ToggleOrientationAction[] fToggleOrientationActions;
    private ToggleCallModeAction[] fToggleCallModeActions;
    private ToggleJavaLabelFormatAction[] fToggleJavaLabelFormatActions;
    private CallHierarchyFiltersActionGroup fFiltersActionGroup;
    private HistoryDropDownAction fHistoryDropDownAction;
    private RefreshAction fRefreshAction;
    private OpenDeclarationAction fOpenDeclarationAction;

     */
    public void setMethod(IMethod method) {
        if (method == null) {
            showPage(PAGE_EMPTY);

            return;
        }


        showPage(PAGE_EMPTY);

        fSelectionProviderMediator = new SelectionProviderMediator(new Viewer[] {
                    fCallHierarchyViewer, fLocationViewer
                });

        IStatusLineManager slManager = getViewSite().getActionBars().getStatusLineManager();
        fSelectionProviderMediator.addSelectionChangedListener(new StatusBarUpdater(
                slManager));
        getSite().setSelectionProvider(fSelectionProviderMediator);

        makeActions();

     * @param b
     */
    private void enableActions(boolean enabled) {
        fLocationContextMenu.setEnabled(enabled);

        // TODO: Is it possible to disable the actions on the toolbar and on the view menu? 
    }


     */
    public void dispose() {
        disposeMenu(fTreeContextMenu);
        disposeMenu(fLocationContextMenu);

        super.dispose();
    }

            Object structuredSelection = ((IStructuredSelection) selection).getFirstElement();

            if (structuredSelection instanceof IMember) {
                CallHierarchyUI.jumpToMember((IMember) structuredSelection);
            } else if (structuredSelection instanceof MethodWrapper) {
                MethodWrapper methodWrapper = (MethodWrapper) structuredSelection;

                CallHierarchyUI.jumpToMember(methodWrapper.getMember());
            } else if (structuredSelection instanceof CallLocation) {
                CallHierarchyUI.jumpToMember(((CallLocation) structuredSelection).getCalledMember());
            }
        }
    }

                if (firstCall != null) {
                    jumpToLocation(firstCall);
                } else {
                    CallHierarchyUI.jumpToMember(methodWrapper.getMember());
                }
            } else if (structuredSelection instanceof CallLocation) {
                jumpToLocation((CallLocation) structuredSelection);

    /**
     * @param selection
     */
    private void locationSelectionChanged(ISelection selection) {}
    }

    /**
     * @param selection


            if (selectedElement instanceof MethodWrapper) {
                MethodWrapper methodWrapper = (MethodWrapper) selectedElement;

                revealElementInEditor(methodWrapper, fCallHierarchyViewer);
                updateLocationsView(methodWrapper);
            } 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(),

                    }
                }
            } else {
                IEditorPart editorPart = CallHierarchyUI.isOpenInEditor(elem);
                getSite().getPage().bringToTop(editorPart);
                EditorUtility.revealInEditor(editorPart,
                    ((MethodWrapper) elem).getMember());
            }
        } else if (elem instanceof IJavaElement) {
            IEditorPart editorPart = EditorUtility.isOpenInEditor(elem);

            if (editorPart != null) {
                //            getSite().getPage().removePartListener(fPartListener);
                getSite().getPage().bringToTop(editorPart);
                EditorUtility.revealInEditor(editorPart, (IJavaElement) elem);

                //            getSite().getPage().addPartListener(fPartListener);
            }
        }
    }


    protected void handleKeyEvent(KeyEvent event) {
        if (event.stateMask == 0) {
            //            if (event.keyCode == SWT.F3) {
            //                if ((fOpenDeclarationAction != null) &&
            //                            fOpenDeclarationAction.isEnabled()) {
            //                    fOpenDeclarationAction.run();
            //                    return;
            //                }
            //            } else 
            if (event.keyCode == SWT.F5) {
                if ((fRefreshAction != null) && fRefreshAction.isEnabled()) {
                    fRefreshAction.run();

                    return;
                        return;
                    }
                }
            }
        }
    }


        return getViewSite().getActionBars();
    }

    private void setCalleeRoot(MethodWrapper calleeRoot) {
        this.fCalleeRoot = calleeRoot;
    }

    private MethodWrapper getCalleeRoot() {
        if (fCalleeRoot == null) {
            fCalleeRoot = (MethodWrapper) CallHierarchy.getDefault().getCalleeRoot(fShownMethod);
        }

        return fCalleeRoot;
    }

    private void setCallerRoot(MethodWrapper callerRoot) {
        this.fCallerRoot = callerRoot;
    }

    private MethodWrapper getCallerRoot() {
        if (fCallerRoot == null) {
            fCallerRoot = (MethodWrapper) CallHierarchy.getDefault().getCallerRoot(fShownMethod);
        }

        return fCallerRoot;

        fLocationViewer.setLabelProvider(new LocationLabelProvider());
        fLocationViewer.setInput(new ArrayList());
        fLocationViewer.getControl().addKeyListener(createKeyListener());

        fOpenLocationAction = new OpenLocationAction(getSite());
        fLocationViewer.addOpenListener(new IOpenListener() {
                public void open(OpenEvent event) {
                    fOpenLocationAction.run();
                }
            });
        
//        fListViewer.addDoubleClickListener(this);

        //        fListViewer.addDoubleClickListener(this);
        MenuManager menuMgr = new MenuManager(); //$NON-NLS-1$
        menuMgr.setRemoveAllWhenShown(true);
        menuMgr.addMenuListener(new IMenuListener() {

                }
            });

        fLocationContextMenu = menuMgr.createContextMenu(fLocationViewer.getControl());
        fLocationViewer.getControl().setMenu(fLocationContextMenu);

        // Register viewer with site. This must be done before making the actions.
        getSite().registerContextMenu(menuMgr, fLocationViewer);

        fOpenDeclarationAction = new OpenDeclarationAction(this.getSite());
        fFocusOnSelectionAction = new FocusOnSelectionAction(this);
        fSearchScopeActions = new SearchScopeActionGroup(this);
        fFiltersActionGroup = new CallHierarchyFiltersActionGroup(this,
                fCallHierarchyViewer);
        fHistoryDropDownAction = new HistoryDropDownAction(this);
        fHistoryDropDownAction.setEnabled(false);


        fActionGroups = new CompositeActionGroup(new ActionGroup[] {
                    new OpenViewActionGroup(this), new RefactorActionGroup(this),
                    fSearchScopeActions, fFiltersActionGroup
                });
    }


    }

    static CallHierarchyViewPart findAndShowCallersView(IWorkbenchPartSite site) {
        IWorkbenchPage workbenchPage = site.getPage();
        CallHierarchyViewPart callersView = null;

        try {
            callersView = (CallHierarchyViewPart) workbenchPage.showView(CallHierarchyViewPart.CALLERS_VIEW_ID);




 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;

import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.ui.IWorkbenchPartSite;

class CallHierarchyViewer extends TreeViewer {




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.jdt.core.IBuffer;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.JavaModelException;

class CallLocation implements IAdaptable {
    private IMember fCalledMember;
    private IMember fMember;
    private String fCallText;
    private int fEnd;
    private int fStart;

    /**
     * @param method
     * @param cu
     * @param start
     * @param end
     */
    public CallLocation(IMember member, IMember calledMember, int start, int end) {
        this.fMember = member;
        this.fCalledMember = calledMember;
        this.fStart = start;
        this.fEnd = end;

        fCallText = initializeCallText();
    }

    /**
     * @return IMethod
     */
    public IMember getCalledMember() {
        return fCalledMember;
    }

    /**
     *
     */
    public int getEnd() {
        return fEnd;
    }

    public IMember getMember() {
        return fMember;
    }

    /**
     *
     */
    public int getStart() {
        return fStart;
    }

    public String toString() {
        return fCallText;
    }

    private String initializeCallText() {
        try {
            ICompilationUnit compilationUnit = fMember.getCompilationUnit();

            if ((fMember != null) && (compilationUnit != null)) {
                IBuffer buffer = compilationUnit.getBuffer();

                return buffer.getText(fStart, (fEnd - fStart));
            } else {
                return fMember.getOpenable().getBuffer().getText(fStart, (fEnd - fStart));
            }
        } catch (JavaModelException e) {
            Utility.logError("CallLocation::toString: Error creating text", e);

            return "- error -";
        }
    }
    
    public Object getAdapter(Class adapter) {
        if (IJavaElement.class.isAssignableFrom(adapter)) {
            return getMember();
        }
        return null;
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IType;

class CallSearchResultCollector {
    private Map fCalledMembers;
    private String[] fPackageNames = null;

    public CallSearchResultCollector() {
        this.fCalledMembers = createCalledMethodsData();

        initializePackageFilters();
    }

    public Map getCallers() {
        return fCalledMembers;
    }

    protected void addMember(IMember member, IMember calledMember, int start, int end) {
        if ((member != null) && (calledMember != null)) {
            if (!isIgnored(calledMember)) {
                MethodCall methodCall = (MethodCall) fCalledMembers.get(calledMember.getHandleIdentifier());

                if (methodCall == null) {
                    methodCall = new MethodCall(calledMember);
                    fCalledMembers.put(calledMember.getHandleIdentifier(), methodCall);
                }

                methodCall.addCallLocation(new CallLocation(member, calledMember, start,
                        end));
            }
        }
    }

    protected Map createCalledMethodsData() {
        return new HashMap();
    }

    /**
     * Method isIgnored.
     * @param enclosingElement
     * @return boolean
     */
    private boolean isIgnored(IMember enclosingElement) {
        if ((fPackageNames != null) && (fPackageNames.length > 0)) {
            String fullyQualifiedName = getTypeOfElement(enclosingElement)
                                         .getFullyQualifiedName();

            for (int i = 0; i < fPackageNames.length; i++) {
                if (matchPackage(fullyQualifiedName, fPackageNames[i])) {
                    return true;
                }
            }
        }

        return false;
    }

    private IType getTypeOfElement(IMember element) {
        if (element.getElementType() == IJavaElement.TYPE) {
            return (IType) element;
        }
        return element.getDeclaringType();
    }

    /**
     * Method getPackageNames.
     * @param strings
     * @return String[]
     */
    private String[] getPackageNames(String[] filters) {
        if (filters != null) {
            for (int i = 0; i < filters.length; i++) {
                if (filters[i].endsWith(".*")) {
                    filters[i] = filters[i].substring(0, filters[i].length() - 2);
                }
            }
        }

        return filters;
    }

    private void initializePackageFilters() {
        String[] filters = CallHierarchy.getDefault().getIgnoreFilters();
        fPackageNames = getPackageNames(filters);
    }

    private boolean matchPackage(String fullyQualifiedName, String filter) {
        return fullyQualifiedName.startsWith(filter);
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.Collection;
import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.ConstructorInvocation;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
import org.eclipse.jdt.core.dom.SuperMethodInvocation;

import org.eclipse.jdt.internal.corext.dom.Binding2JavaModel;

class CalleeAnalyzerVisitor extends ASTVisitor {
    private CallSearchResultCollector fSearchResults;
    private IMethod fMethod;
    private IProgressMonitor fProgressMonitor;
    private int fMethodEndPosition;
    private int fMethodStartPosition;

    CalleeAnalyzerVisitor(IMethod method, IProgressMonitor progressMonitor) {
        fSearchResults = new CallSearchResultCollector();
        this.fMethod = method;
        this.fProgressMonitor = progressMonitor;

        try {
            ISourceRange sourceRange = method.getSourceRange();
            this.fMethodStartPosition = sourceRange.getOffset();
            this.fMethodEndPosition = fMethodStartPosition + sourceRange.getLength();
        } catch (JavaModelException jme) {
            Utility.logError("Error getting start and end of method: " +
                fMethod.getElementName(), jme);
        }
    }

    /**
     * Method getCallees.
     * @return CallerElement
     */
    public Map getCallees() {
        return fSearchResults.getCallers();
    }

    /* (non-Javadoc)
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
     */
    public boolean visit(ClassInstanceCreation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveConstructorBinding(), node);

        return true;
    }

    /**
     * Find all constructor invocations (<code>this(...)</code>) from the called method. Since we only traverse into the
     * AST on the wanted method declaration, this method should not hit on more constructor
     * invocations than those in the wanted method.
     *
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConstructorInvocation)
     */
    public boolean visit(ConstructorInvocation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveConstructorBinding(), node);

        return true;
    }

    /**
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
     */
    public boolean visit(MethodDeclaration node) {
        return isNodeWithinMethod(node);
    }

    /**
     * Find all method invocations from the called method. Since we only traverse into the
     * AST on the wanted method declaration, this method should not hit on more method
     * invocations than those in the wanted method.
     *
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
     */
    public boolean visit(MethodInvocation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveMethodBinding(), node);

        return true;
    }

    /**
     * Find invocations of the supertype's constructor from the called method (=constructor).
     * Since we only traverse into the AST on the wanted method declaration, this method should
     * not hit on more method invocations than those in the wanted method.
     *
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperConstructorInvocation)
     */
    public boolean visit(SuperConstructorInvocation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveConstructorBinding(), node);

        return true;
    }

    /**
     * Find all method invocations from the called method. Since we only traverse into the
     * AST on the wanted method declaration, this method should not hit on more method
     * invocations than those in the wanted method.
     *
     * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
     */
    public boolean visit(SuperMethodInvocation node) {
        if (!isNodeWithinMethod(node)) {
            return false;
        }

        addMethodCall(node.resolveMethodBinding(), node);

        return true;
    }

    /**
     * Adds the specified method binding to the search results.
     * @param calledMethodBinding
     * @param node
     */
    protected void addMethodCall(IMethodBinding calledMethodBinding, ASTNode node) {
        try {
            if (calledMethodBinding != null) {
                fProgressMonitor.worked(1);

                ITypeBinding calledTypeBinding = calledMethodBinding.getDeclaringClass();
                IType calledType = null;

                if (!calledTypeBinding.isAnonymous()) {
                    calledType = Binding2JavaModel.find(calledTypeBinding,
                            fMethod.getJavaProject());
                } else {
                    calledType = Binding2JavaModel.find(calledTypeBinding.getInterfaces()[0],
                            fMethod.getJavaProject());
                }

                IMethod calledMethod = Binding2JavaModel.findIncludingSupertypes(calledMethodBinding,
                        calledType,
                        new SubProgressMonitor(fProgressMonitor, 100,
                            SubProgressMonitor.SUPPRESS_SUBTASK_LABEL));

                if ((calledMethod != null) && calledType.isInterface()) {
                    calledMethod = findImplementingMethods(calledMethod);
                }

                if (!isIgnoredBySearchScope(calledMethod)) {
                    fSearchResults.addMember(fMethod, calledMethod,
                        node.getStartPosition(),
                        node.getStartPosition() + node.getLength());
                }
            }
        } catch (JavaModelException jme) {
            Utility.logError("Error adding callee search result", jme);
        }
    }

    /**
     * @param enclosingElement
     * @return
     */
    private boolean isIgnoredBySearchScope(IMethod enclosingElement) {
        if (enclosingElement != null) {
            return !CallHierarchy.getDefault().getSearchScope().encloses(enclosingElement);
        } else {
            return false;
        }
    }

    private boolean isNodeWithinMethod(ASTNode node) {
        int nodeStartPosition = node.getStartPosition();
        int nodeEndPosition = nodeStartPosition + node.getLength();

        if (nodeStartPosition < fMethodStartPosition) {
            return false;
        }

        if (nodeEndPosition > fMethodEndPosition) {
            return false;
        }

        return true;
    }

    /**
     * @param calledMethod
     */
    private IMethod findImplementingMethods(IMethod calledMethod) {
        Collection implementingMethods = CallHierarchy.getDefault()
                                                      .getImplementingMethods(calledMethod);

        if ((implementingMethods.size() == 0) || (implementingMethods.size() > 1)) {
            return calledMethod;
        } else {
            return (IMethod) implementingMethods.iterator().next();
        }
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.CompilationUnit;

class CalleeMethodWrapper extends MethodWrapper {
    private Comparator fMethodWrapperComparator = new MethodWrapperComparator();

    private class MethodWrapperComparator implements Comparator {
        /* (non-Javadoc)
         * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
         */
        public int compare(Object o1, Object o2) {
            MethodWrapper m1 = (MethodWrapper) o1;
            MethodWrapper m2 = (MethodWrapper) o2;

            CallLocation callLocation1 = m1.getMethodCall().getFirstCallLocation();
            CallLocation callLocation2 = m2.getMethodCall().getFirstCallLocation();

            if ((callLocation1 != null) && (callLocation2 != null)) {
                if (callLocation1.getStart() == callLocation2.getStart()) {
                    return callLocation1.getEnd() - callLocation2.getEnd();
                }

                return callLocation1.getStart() - callLocation2.getStart();
            }

            return 0;
        }
    }

    /**
     * Constructor for CalleeMethodWrapper.
     * @param parent
     * @param method
     */
    public CalleeMethodWrapper(MethodWrapper parent, MethodCall methodCall) {
        super(parent, methodCall);
    }

	/* Returns the calls sorted after the call location
	 * @see org.eclipse.jdt.internal.ui.callhierarchy.MethodWrapper#getCalls()
     */
    public MethodWrapper[] getCalls() {
        MethodWrapper[] result = super.getCalls();
        Arrays.sort(result, fMethodWrapperComparator);

        return result;
    }

	/* (non-Javadoc)
	 * @see org.eclipse.jdt.internal.ui.callhierarchy.MethodWrapper#getTaskName()
     */
    protected String getTaskName() {
        return null;
    }

	/**
	 * @see org.eclipse.jdt.internal.ui.callhierarchy.MethodWrapper#createMethodWrapper(org.eclipse.jdt.internal.ui.callhierarchy.MethodCall)
     */
    protected MethodWrapper createMethodWrapper(MethodCall methodCall) {
        return new CalleeMethodWrapper(this, methodCall);
    }

	/**
     * Find callees called from the current method.
	 * @see org.eclipse.jdt.internal.ui.callhierarchy.MethodWrapper#findChildren(org.eclipse.core.runtime.IProgressMonitor)
     */
    protected Map findChildren(IProgressMonitor progressMonitor) {
        if (getMember().getElementType() == IJavaElement.METHOD) {
            CalleeAnalyzerVisitor visitor = new CalleeAnalyzerVisitor((IMethod) getMember(),
                    progressMonitor);
            ICompilationUnit icu = getMember().getCompilationUnit();
        
            if (icu != null) {
                CompilationUnit cu = AST.parseCompilationUnit(icu, true);
                cu.accept(visitor);
            }
        
            return visitor.getCallees();
        } else {
            return new HashMap();
        }
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;

class CallerMethodWrapper extends MethodWrapper {
    public CallerMethodWrapper(MethodWrapper parent, MethodCall methodCall) {
        super(parent, methodCall);
    }

    protected IJavaSearchScope getSearchScope() {
        return CallHierarchy.getDefault().getSearchScope();
    }

    protected String getTaskName() {
        return "Finding callers...";
    }

	/**
	 * @see org.eclipse.jdt.internal.ui.callhierarchy.MethodWrapper#createMethodWrapper(org.eclipse.jdt.internal.ui.callhierarchy.MethodCall)
     */
    protected MethodWrapper createMethodWrapper(MethodCall methodCall) {
        return new CallerMethodWrapper(this, methodCall);
    }

	/**
	 * @see org.eclipse.jdt.internal.ui.callhierarchy.MethodWrapper#findChildren(org.eclipse.core.runtime.IProgressMonitor)
     * @return The result of the search for children
     */
    protected Map findChildren(IProgressMonitor progressMonitor) {
        try {
            MethodReferencesSearchCollector searchCollector = new MethodReferencesSearchCollector();
            SearchEngine searchEngine = new SearchEngine();

            for (Iterator iter = getMembers().iterator();
                        iter.hasNext() && !progressMonitor.isCanceled();) {
                IMember member = (IMember) iter.next();
                searchCollector.setProgressMonitor(new SubProgressMonitor(
                        progressMonitor, 10, SubProgressMonitor.SUPPRESS_SUBTASK_LABEL));
                searchEngine.search(ResourcesPlugin.getWorkspace(), member,
                    IJavaSearchConstants.REFERENCES, getSearchScope(), searchCollector);
            }

            return searchCollector.getCallers();
        } catch (JavaModelException e) {
            Utility.logError("Error finding callers", e);

            return new HashMap(0);
        }
    }

    /**
     * Returns a collection of IMember instances representing what to search for 
     */
    private Collection getMembers() {
        Collection result = new ArrayList();

        result.add(getMember());
        if (getMember().getElementType() == IJavaElement.METHOD) {
            result.addAll(CallHierarchy.getDefault().getInterfaceMethods((IMethod) getMember()));
        }

        return result;
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 *          (report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.jdt.internal.corext.callhierarchy.CallHierarchy;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

/**
 * @author jl
 */
public class FiltersDialog extends Dialog {
    private Button fFilterOnNames;
    private Text fNames;
    private Text fMaxCallDepth;

    private SelectionListener selectionListener = new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            FiltersDialog.this.widgetSelected(e);
        }
    };

    /**
     * @param parentShell
     */
    protected FiltersDialog(Shell parentShell) {
        super(parentShell);
    }

    /* (non-Javadoc)
     * Method declared on Dialog.
     */
    protected Control createDialogArea(Composite parent) {
        Composite superComposite = (Composite) super.createDialogArea(parent);

        Font font = parent.getFont();
        Composite composite = new Composite(superComposite, SWT.NONE);
        composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
        composite.setFont(font);

        GridLayout layout = new GridLayout();
        layout.numColumns = 2;
        composite.setLayout(layout);

        createNamesArea(composite);
        createMaxCallDepthArea(composite);
    
        updateUIFromFilter();
        
        return composite;
    }

    /* (non-Javadoc)
     * Method declared on Window.
     */
    protected void configureShell(Shell newShell) {
        super.configureShell(newShell);
        newShell.setText(CallHierarchyMessages.getString("FiltersDialog.filter")); //$NON-NLS-1$
//      TODO: WorkbenchHelp.setHelp(newShell, ITaskListHelpContextIds.FILTERS_DIALOG);
    }
    
    void createMaxCallDepthArea(Composite parent) {
        new Label(parent, SWT.NONE).setText(CallHierarchyMessages.getString("FiltersDialog.maxCallDepth"));
        
        fMaxCallDepth = new Text(parent, SWT.SINGLE | SWT.BORDER);
        fMaxCallDepth.setTextLimit(6);

        GridData gridData = new GridData();
        gridData.widthHint = convertWidthInCharsToPixels(10);
        fMaxCallDepth.setLayoutData(gridData);
        fMaxCallDepth.setFont(parent.getFont());
    }

    void createNamesArea(Composite parent) {
        fFilterOnNames = createCheckbox(parent,
                CallHierarchyMessages.getString("FiltersDialog.filterOnNames"),
                false); //$NON-NLS-1$
        fFilterOnNames.setLayoutData(new GridData());
        fNames= new Text(parent, SWT.SINGLE | SWT.BORDER);

        GridData gridData = new GridData();
        gridData.widthHint = convertWidthInCharsToPixels(30);
        fNames.setLayoutData(gridData);
        fNames.setFont(parent.getFont());
    }

    /**
     * Creates a check box button with the given parent and text.
     *
     * @param parent the parent composite
     * @param text the text for the check box
     * @param grabRow <code>true</code>to grab the remaining horizontal space,
     *        <code>false</code> otherwise
     *
     * @return the check box button
     */
    Button createCheckbox(Composite parent, String text, boolean grabRow) {
        Button button = new Button(parent, SWT.CHECK);

        if (grabRow) {
            GridData gridData = new GridData(GridData.FILL_HORIZONTAL);
            button.setLayoutData(gridData);
        }

        button.setText(text);
        button.addSelectionListener(selectionListener);
        button.setFont(parent.getFont());

        return button;
    }

    /**
     * Updates the enabled state of the widgetry.
     */
    void updateEnabledState() {
        fNames.setEnabled(fFilterOnNames.getSelection());
    }
    
    /**
     * Updates the given filter from the UI state.
     *
     * @param filter the filter to update
     */
    void updateFilterFromUI() {
        int maxCallDepth = Integer.parseInt(this.fMaxCallDepth.getText());

        CallHierarchyUI.getDefault().setMaxCallDepth(maxCallDepth);
        CallHierarchy.getDefault().setFilters(fNames.getText());
        CallHierarchy.getDefault().setFilterEnabled(fFilterOnNames.getSelection());
    }
    
    /**
     * Updates the UI state from the given filter.
     *
     * @param filter the filter to use
     */
    void updateUIFromFilter() {
      fMaxCallDepth.setText(""+CallHierarchyUI.getDefault().getMaxCallDepth()); //$NON-NLS-1$
      fNames.setText(CallHierarchy.getDefault().getFilters());
      fFilterOnNames.setSelection(CallHierarchy.getDefault().isFilterEnabled());
      updateEnabledState();
    }
    
    /**
     * Handles selection on a check box or combo box.
     */
    void widgetSelected(SelectionEvent e) {
        updateEnabledState();
    }
    
    /**
     * Updates the filter from the UI state.
     * Must be done here rather than by extending open()
     * because after super.open() is called, the widgetry is disposed.
     */
    protected void okPressed() {
        try {
            int maxCallDepth = Integer.parseInt(this.fMaxCallDepth.getText());
    
            if (maxCallDepth < 1 || maxCallDepth > 99) {
                throw new NumberFormatException();
            }           
            
            updateFilterFromUI();
            super.okPressed();
        }
        catch (NumberFormatException eNumberFormat) {
            MessageBox messageBox = new MessageBox(getShell(), 
                    SWT.OK | SWT.APPLICATION_MODAL | SWT.ICON_ERROR);
            messageBox.setText(CallHierarchyMessages.getString(
                    "FiltersDialog.titleMaxCallDepthInvalid")); //$NON-NLS-1$
            messageBox.setMessage(CallHierarchyMessages.getString(
                    "FiltersDialog.messageMaxCallDepthInvalid")); //$NON-NLS-1$
            messageBox.open();
    
            if (fMaxCallDepth.forceFocus()) {
                fMaxCallDepth.setSelection(0, fMaxCallDepth.getCharCount());
                fMaxCallDepth.showSelection();
            }
        }
    }
}




package org.eclipse.jdt.internal.ui.callhierarchy;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;
import org.eclipse.jdt.internal.ui.util.SelectionUtil;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;

class FocusOnSelectionAction extends Action {
    private CallHierarchyViewPart fPart;

    }

    public boolean canActionBeAdded() {
        Object element = SelectionUtil.getSingleElement(getSelection());

        IMethod method = null;
        

     * @see Action#run
     */
    public void run() {
        Object element = SelectionUtil.getSingleElement(getSelection());

        if (element instanceof MethodWrapper) {
            IMember member= ((MethodWrapper) element).getMember();

Lines 12-21 Link Here

(-)ui/org/eclipse/jdt/internal/ui/callhierarchy/ICallHierarchyPreferencesConstants.java (-4 lines)
12	package org.eclipse.jdt.internal.ui.callhierarchy;	12	package org.eclipse.jdt.internal.ui.callhierarchy;
13		13
14	public interface ICallHierarchyPreferencesConstants {	14	public interface ICallHierarchyPreferencesConstants {
15	public static final String PREF_USE_FILTERS = "PREF_USE_FILTERS";
16	public static final String PREF_INACTIVE_FILTERS_LIST = "PREF_INACTIVE_FILTERS_LIST";
17	public static final String PREF_ACTIVE_FILTERS_LIST = "PREF_ACTIVE_FILTERS_LIST";
18	public static final String PREF_MAX_CALL_DEPTH = "PREF_MAX_CALL_DEPTH";
19	public static final String PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH = "PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH";	15	public static final String PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH = "PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH";
20	public static final String PREF_USE_IMPLEMENTORS_FOR_CALLEE_SEARCH = "PREF_USE_IMPLEMENTORS_FOR_CALLEE_SEARCH";	16	public static final String PREF_USE_IMPLEMENTORS_FOR_CALLEE_SEARCH = "PREF_USE_IMPLEMENTORS_FOR_CALLEE_SEARCH";
21	}	17	}

Lines 11-16 Link Here

(-)ui/org/eclipse/jdt/internal/ui/callhierarchy/LocationLabelProvider.java (+1 lines)
11	******************************************************************************/	11	******************************************************************************/
12	package org.eclipse.jdt.internal.ui.callhierarchy;	12	package org.eclipse.jdt.internal.ui.callhierarchy;
13		13
		14	import org.eclipse.jdt.internal.corext.callhierarchy.CallLocation;
14	import org.eclipse.jface.viewers.LabelProvider;	15	import org.eclipse.jface.viewers.LabelProvider;
15		16
16	class LocationLabelProvider extends LabelProvider {	17	class LocationLabelProvider extends LabelProvider {




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.eclipse.jdt.core.IMember;

class MethodCall {
    private IMember fMember;
    private List fCallLocations;

    /**
     * @param enclosingElement
     */
    public MethodCall(IMember enclosingElement) {
        this.fMember = enclosingElement;
    }

    /**
     *
     */
    public Collection getCallLocations() {
        return fCallLocations;
    }

    public CallLocation getFirstCallLocation() {
        if ((fCallLocations != null) && !fCallLocations.isEmpty()) {
            return (CallLocation) fCallLocations.get(0);
        } else {
            return null;
        }
    }

    /**
     * @return Object
     */
    public Object getKey() {
        return getMember().getHandleIdentifier();
    }

    /**
     *
     */
    public IMember getMember() {
        return fMember;
    }

    /**
     * @param location
     */
    public void addCallLocation(CallLocation location) {
        if (fCallLocations == null) {
            fCallLocations = new ArrayList();
        }

        fCallLocations.add(location);
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.Map;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.search.IJavaSearchResultCollector;

class MethodReferencesSearchCollector implements IJavaSearchResultCollector {
    private CallSearchResultCollector fSearchResults;
    private IProgressMonitor fProgressMonitor;
    private boolean fRequireExactMatch = true;

    MethodReferencesSearchCollector() {
        fSearchResults = new CallSearchResultCollector();
    }

    public Map getCallers() {
        return fSearchResults.getCallers();
    }

    /**
     * @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#getProgressMonitor()
     */
    public IProgressMonitor getProgressMonitor() {
        return fProgressMonitor;
    }

    /**
     * @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#aboutToStart()
     */
    public void aboutToStart() {}

    /**
     * @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#accept(org.eclipse.core.resources.IResource, int, int, org.eclipse.jdt.core.IJavaElement, int)
     */
    public void accept(IResource resource, int start, int end,
        IJavaElement enclosingElement, int accuracy) throws CoreException {
        if (fRequireExactMatch && (accuracy != IJavaSearchResultCollector.EXACT_MATCH)) {
            return;
        }

        if (enclosingElement != null && enclosingElement instanceof IMember) {
            IMember member= (IMember) enclosingElement;
            switch (enclosingElement.getElementType()) {
                case IJavaElement.METHOD:
                case IJavaElement.TYPE:
                case IJavaElement.FIELD:
                    fSearchResults.addMember(member, member, start, end);
                    break;
            }
        }
    }

    /**
     * @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#done()
     */
    public void done() {}

    /**
     * @param monitor
     */
    void setProgressMonitor(SubProgressMonitor monitor) {
        this.fProgressMonitor = monitor;
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *   Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation 
 * 			(report 36180: Callers/Callees view)
 ******************************************************************************/
package org.eclipse.jdt.internal.ui.callhierarchy;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IMethod;

/**
 * This class represents the general parts of a method call (either to or from a
 * method).
 *
 */
public abstract class MethodWrapper implements IAdaptable {
    private Map fElements = null;

    /*
     * A cache of previously found methods. This cache should be searched
     * before adding a "new" method object reference to the list of elements.
     * This way previously found methods won't be searched again.
     */
    private Map fMethodCache;
    private MethodCall fMethodCall;
    private MethodWrapper fParent;
    private int fLevel;

    /**
     * Constructor CallerElement.
     */
    public MethodWrapper(MethodWrapper parent, MethodCall methodCall) {
        super();

        if (methodCall == null) {
            throw new IllegalArgumentException("Parameter method cannot be null");
        }

        if (parent == null) {
            setMethodCache(new HashMap());
            fLevel = 1;
        } else {
            setMethodCache(parent.getMethodCache());
            fLevel = parent.getLevel() + 1;
        }

        this.fMethodCall = methodCall;
        this.fParent = parent;
    }

    public Object getAdapter(Class adapter) {
        if (adapter == IMethod.class) {
            if (getMember().getElementType() == IJavaElement.METHOD) {
                return getMember();
            } else {
                return null;
            }
        } else {
            if (IJavaElement.class.isAssignableFrom(adapter)) {
                return getMember();
            }
        }

        return null;
    }

    /**
     * Method getCallerElements.
     * @return The child caller elements of this element
     */
    public MethodWrapper[] getCalls() {
        if (fElements == null) {
            doFindChildren();
        }

        MethodWrapper[] result = new MethodWrapper[fElements.size()];
        int i = 0;

        for (Iterator iter = fElements.keySet().iterator(); iter.hasNext();) {
            MethodCall methodCall = getMethodCallFromMap(fElements, iter.next());
            result[i++] = createMethodWrapper(methodCall);
        }

        return result;
    }

    /**
     * @return int
     */
    public int getLevel() {
        return fLevel;
    }

    /**
     * Method getMethod.
     * @return Object
     */
    public IMember getMember() {
        return getMethodCall().getMember();
    }

    /**
     * @return MethodCall
     */
    public MethodCall getMethodCall() {
        return fMethodCall;
    }

    /**
     * Method getName.
     */
    public String getName() {
        if (getMethodCall() != null) {
            return getMethodCall().getMember().getElementName();
        } else {
            return "";
        }
    }

    /**
     * Method getParent.
     * @return
     */
    public MethodWrapper getParent() {
        return fParent;
    }

    public boolean equals(Object oth) {
        if (this == oth) {
            return true;
        }

        if (oth == null) {
            return false;
        }

        if (oth.getClass() != getClass()) {
            return false;
        }

        MethodWrapper other = (MethodWrapper) oth;

        if (this.fParent == null) {
            if (other.fParent != null) {
                return false;
            }
        } else {
            if (!this.fParent.equals(other.fParent)) {
                return false;
            }
        }

        if (this.getMethodCall() == null) {
            if (other.getMethodCall() != null) {
                return false;
            }
        } else {
            if (!this.getMethodCall().equals(other.getMethodCall())) {
                return false;
            }
        }

        return true;
    }

    public int hashCode() {
        final int PRIME = 1000003;
        int result = 0;

        if (fParent != null) {
            result = (PRIME * result) + fParent.hashCode();
        }

        if (getMethodCall() != null) {
            result = (PRIME * result) + getMethodCall().getMember().hashCode();
        }

        return result;
    }

    /**
     * @see java.lang.Object#toString()
     */
    public String toString() {
        String result;

        result = "CallerElement[name=" + getName() + ", children=";

        if (fElements == null) {
            result += "unknown]";
        } else {
            result += (fElements.size() + "]");
        }

        return result;
    }

    private void setMethodCache(Map methodCache) {
        fMethodCache = methodCache;
    }

    protected abstract String getTaskName();

    private void addCallToCache(MethodCall methodCall) {
        Map cachedCalls = lookupMethod(this.getMethodCall());
        cachedCalls.put(methodCall.getKey(), methodCall);
    }

    /**
     * Method createMethodWrapper.
     * @param method
     * @return MethodWrapper
     */
    protected abstract MethodWrapper createMethodWrapper(MethodCall methodCall);

    private void doFindChildren() {
        Map existingResults = lookupMethod(getMethodCall());

        if (existingResults != null) {
            fElements = new HashMap();
            fElements.putAll(existingResults);
        } else {
            initCalls();

            IProgressMonitor progressMonitor = getProgressMonitor();

            if (progressMonitor != null) {
                progressMonitor.beginTask(getTaskName(), IProgressMonitor.UNKNOWN);
            }

            try {
                performSearch(progressMonitor);
            } finally {
                if (progressMonitor != null) {
                    progressMonitor.done();
                }
            }

            //                ModalContext.run(getRunnableWithProgress(), true, getProgressMonitor(),
            //                    Display.getCurrent());
        }
    }

    /**
     * Determines if the method represents a recursion call (i.e. whether the
     * method call is already in the cache.)
     *
     * @return True if the call is part of a recursion
     */
    public boolean isRecursive() {
        MethodWrapper current = getParent();

        while (current != null) {
            if (getMember().getHandleIdentifier().equals(current.getMember()
                                                                        .getHandleIdentifier())) {
                return true;
            }

            current = current.getParent();
        }

        return false;
    }

    /**
     * This method finds the children of the current IMethod (either callers or
     * callees, depending on the concrete subclass.
     * @return The result of the search for children
     */
    protected abstract Map findChildren(IProgressMonitor progressMonitor);

    private Map getMethodCache() {
        return fMethodCache;
    }

    private void initCalls() {
        this.fElements = new HashMap();

        initCacheForMethod();
    }

    /**
     * Looks up a previously created search result in the "global" cache.
     * @param method
     * @return List List of previously found search results
     */
    private Map lookupMethod(MethodCall methodCall) {
        return (Map) getMethodCache().get(methodCall.getKey());
    }

    private void performSearch(IProgressMonitor progressMonitor) {
        fElements = findChildren(progressMonitor);

        for (Iterator iter = fElements.keySet().iterator(); iter.hasNext();) {
            MethodCall methodCall = getMethodCallFromMap(fElements, iter.next());
            addCallToCache(methodCall);
        }
    }

    private MethodCall getMethodCallFromMap(Map elements, Object key) {
        return (MethodCall) elements.get(key);
    }

    private IProgressMonitor getProgressMonitor() {
        return CallHierarchy.getDefault().getProgressMonitor();
    }

    private void initCacheForMethod() {
        Map cachedCalls = new HashMap();
        getMethodCache().put(this.getMethodCall().getKey(), cachedCalls);
    }
}




import java.util.List;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;
import org.eclipse.jdt.internal.ui.util.SelectionUtil;
import org.eclipse.jdt.ui.actions.OpenAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.ui.IWorkbenchSite;

import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.ui.actions.OpenAction;

class OpenDeclarationAction extends OpenAction {
    public OpenDeclarationAction(IWorkbenchSite site) {
        super(site);
    }

    public boolean canActionBeAdded() {
        Object element = SelectionUtil.getSingleElement(getSelection());

        IMethod method = null;
        





import java.util.Iterator;

import org.eclipse.jdt.internal.corext.callhierarchy.CallLocation;
import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;
import org.eclipse.jdt.ui.actions.SelectionDispatchAction;
import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.ui.IWorkbenchSite;

import org.eclipse.jdt.ui.actions.SelectionDispatchAction;

class OpenLocationAction extends SelectionDispatchAction {
    public OpenLocationAction(IWorkbenchSite site) {
        super(site);

    }

    private void run(Object element) {
        CallHierarchyUI.openInEditor(element, getShell(), getDialogTitle());
    }

    private String getDialogTitle() {




import org.eclipse.jdt.internal.ui.JavaPlugin;

class Utility {
    /**
     * Returns the selected element if the selection
     * consists of a single element only.
     *
     * @param selection the selection
     * @return the selected first element or null
     *
     */
    public static Object getSingleElement(ISelection s) {
        if (!(s instanceof IStructuredSelection)) {
            return null;
        }

        IStructuredSelection selection = (IStructuredSelection) s;

        if (selection.size() != 1) {
            return null;
        }

        return selection.getFirstElement();
    }

    static void logDebug(String message) {
        if (JavaPlugin.getDefault().isDebugging()) {
            JavaPlugin.getDefault().getLog().log(new Status(IStatus.INFO,

Return to bug 36520

Added Link Here

(-)core (+240 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
10	* (report 36180: Callers/Callees view)
11	******************************************************************************/
12	package org.eclipse.jdt.internal.corext.callhierarchy;
13
14	import java.util.ArrayList;
15	import java.util.Arrays;
16	import java.util.Collection;
17	import java.util.List;
18	import java.util.StringTokenizer;
19
20	import org.eclipse.core.runtime.NullProgressMonitor;
21	import org.eclipse.jdt.core.IJavaElement;
22	import org.eclipse.jdt.core.IMethod;
23	import org.eclipse.jdt.core.search.IJavaSearchScope;
24	import org.eclipse.jdt.core.search.SearchEngine;
25	import org.eclipse.jdt.internal.ui.JavaPlugin;
26	import org.eclipse.jdt.internal.ui.callhierarchy.ICallHierarchyPreferencesConstants;
27	import org.eclipse.jdt.internal.ui.util.StringMatcher;
28	import org.eclipse.jface.preference.IPreferenceStore;
29
30	public class CallHierarchy {
31	private static final String PREF_USE_FILTERS = "PREF_USE_FILTERS";
32	private static final String PREF_FILTERS_LIST = "PREF_FILTERS_LIST";
33
34	private static final String DEFAULT_IGNORE_FILTERS = "java.,javax.";
35	private static CallHierarchy fgInstance;
36	private IJavaSearchScope fSearchScope;
37	private StringMatcher[] fFilters;
38
39	public static CallHierarchy getDefault() {
40	if (fgInstance == null) {
41	fgInstance = new CallHierarchy();
42	}
43
44	return fgInstance;
45	}
46
47	/**
48	* @return
49	*/
50	public boolean isSearchForCalleesUsingImplementorsEnabled() {
51	IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();
52
53	return settings.getBoolean(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLEE_SEARCH);
54	}
55
56	/**
57	* @return
58	*/
59	public boolean isSearchForCallersUsingImplementorsEnabled() {
60	IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();
61
62	return settings.getBoolean(ICallHierarchyPreferencesConstants.PREF_USE_IMPLEMENTORS_FOR_CALLER_SEARCH);
63	}
64
65	/**
66	* @param method
67	*
68	* @return
69	*/
70	public Collection getImplementingMethods(IMethod method) {
71	if (isSearchForCalleesUsingImplementorsEnabled()) {
72	IJavaElement[] result = Implementors.getInstance().searchForImplementors(new IJavaElement[] {
73	method
74	}, new NullProgressMonitor());
75
76	if ((result != null) && (result.length > 0)) {
77	return Arrays.asList(result);
78	}
79	}
80
81	return new ArrayList(0);
82	}
83
84	/**
85	* @param method
86	*
87	* @return
88	*/
89	public Collection getInterfaceMethods(IMethod method) {
90	if (isSearchForCallersUsingImplementorsEnabled()) {
91	IJavaElement[] result = Implementors.getInstance().searchForInterfaces(new IJavaElement[] {
92	method
93	}, new NullProgressMonitor());
94
95	if ((result != null) && (result.length > 0)) {
96	return Arrays.asList(result);
97	}
98	}
99
100	return new ArrayList(0);
101	}
102
103	public MethodWrapper getCallerRoot(IMethod method) {
104	return new CallerMethodWrapper(null, new MethodCall(method));
105	}
106
107	public MethodWrapper getCalleeRoot(IMethod method) {
108	return new CalleeMethodWrapper(null, new MethodCall(method));
109	}
110
111	public static CallLocation getCallLocation(Object element) {
112	CallLocation callLocation = null;
113
114	if (element instanceof MethodWrapper) {
115	MethodWrapper methodWrapper = (MethodWrapper) element;
116	MethodCall methodCall = methodWrapper.getMethodCall();
117
118	if (methodCall != null) {
119	callLocation = methodCall.getFirstCallLocation();
120	}
121	} else if (element instanceof CallLocation) {
122	callLocation = (CallLocation) element;
123	}
124
125	return callLocation;
126	}
127
128	public IJavaSearchScope getSearchScope() {
129	if (fSearchScope != null) {
130	return fSearchScope;
131	}
132
133	Utility.logDebug("No search scope was set");
134
135	return SearchEngine.createWorkspaceScope();
136	}
137
138	public void setSearchScope(IJavaSearchScope searchScope) {
139	this.fSearchScope = searchScope;
140	}
141
142	/**
143	* Checks whether the fully qualified name is ignored by the set filters.
144	*
145	* @param fullyQualifiedName
146	*
147	* @return True if the fully qualified name is ignored.
148	*/
149	public boolean isIgnored(String fullyQualifiedName) {
150	if ((getIgnoreFilters() != null) && (getIgnoreFilters().length > 0)) {
151	for (int i = 0; i < getIgnoreFilters().length; i++) {
152	String fullyQualifiedName1 = fullyQualifiedName;
153
154	if (getIgnoreFilters()[i].match(fullyQualifiedName1)) {
155	return true;
156	}
157	}
158	}
159
160	return false;
161	}
162
163	/**
164	* @return
165	*/
166	public boolean isFilterEnabled() {
167	IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();
168	return settings.getBoolean(PREF_USE_FILTERS);
169	}
170
171	/**
172	* @param b
173	*/
174	public void setFilterEnabled(boolean filterEnabled) {
175	IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();
176	settings.setValue(PREF_USE_FILTERS, filterEnabled);
177	}
178
179	/**
180	* Returns the current filters as a string.
181	*
182	* @return
183	*/
184	public String getFilters() {
185	IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();
186
187	return settings.getString(PREF_FILTERS_LIST);
188	}
189
190	public void setFilters(String filters) {
191	fFilters = null;
192
193	IPreferenceStore settings = JavaPlugin.getDefault().getPreferenceStore();
194	settings.setValue(PREF_FILTERS_LIST, filters);
195	}
196
197	/**
198	* Returns filters for packages which should not be included in the search results.
199	*
200	* @return StringMatcher[]
201	*/
202	private StringMatcher[] getIgnoreFilters() {
203	if (fFilters == null) {
204	String filterString = null;
205
206	if (isFilterEnabled()) {
207	filterString = getFilters();
208
209	if (filterString == null) {
210	filterString = DEFAULT_IGNORE_FILTERS;
211	}
212	}
213
214	if (filterString != null) {
215	fFilters = parseList(filterString);
216	} else {
217	fFilters = null;
218	}
219	}
220
221	return fFilters;
222	}
223
224	/**
225	* Parses the comma separated string into an array of StringMatcher objects
226	*
227	* @return list
228	*/
229	private static StringMatcher[] parseList(String listString) {
230	List list = new ArrayList(10);
231	StringTokenizer tokenizer = new StringTokenizer(listString, ","); //$NON-NLS-1$
232
233	while (tokenizer.hasMoreTokens()) {
234	String textFilter = tokenizer.nextToken();
235	list.add(new StringMatcher(textFilter, false, false));
236	}
237
238	return (StringMatcher[]) list.toArray(new StringMatcher[list.size()]);
239	}
240	}

Added Link Here

(-)core (+100 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
10	* (report 36180: Callers/Callees view)
11	******************************************************************************/
12	package org.eclipse.jdt.internal.corext.callhierarchy;
13
14	import org.eclipse.core.runtime.IAdaptable;
15	import org.eclipse.jdt.core.IBuffer;
16	import org.eclipse.jdt.core.ICompilationUnit;
17	import org.eclipse.jdt.core.IJavaElement;
18	import org.eclipse.jdt.core.IMember;
19	import org.eclipse.jdt.core.JavaModelException;
20
21	/**
22	* @author jl
23	*/
24	public class CallLocation implements IAdaptable {
25	private IMember fCalledMember;
26	private IMember fMember;
27	private String fCallText;
28	private int fEnd;
29	private int fStart;
30
31	/**
32	* @param method
33	* @param cu
34	* @param start
35	* @param end
36	*/
37	public CallLocation(IMember member, IMember calledMember, int start, int end) {
38	this.fMember = member;
39	this.fCalledMember = calledMember;
40	this.fStart = start;
41	this.fEnd = end;
42
43	fCallText = initializeCallText();
44	}
45
46	/**
47	* @return IMethod
48	*/
49	public IMember getCalledMember() {
50	return fCalledMember;
51	}
52
53	/**
54	*
55	*/
56	public int getEnd() {
57	return fEnd;
58	}
59
60	public IMember getMember() {
61	return fMember;
62	}
63
64	/**
65	*
66	*/
67	public int getStart() {
68	return fStart;
69	}
70
71	public String toString() {
72	return fCallText;
73	}
74
75	private String initializeCallText() {
76	try {
77	ICompilationUnit compilationUnit = fMember.getCompilationUnit();
78
79	if ((fMember != null) && (compilationUnit != null)) {
80	IBuffer buffer = compilationUnit.getBuffer();
81
82	return buffer.getText(fStart, (fEnd - fStart));
83	} else {
84	return fMember.getOpenable().getBuffer().getText(fStart, (fEnd - fStart));
85	}
86	} catch (JavaModelException e) {
87	Utility.logError("CallLocation::toString: Error creating text", e);
88
89	return "- error -";
90	}
91	}
92
93	public Object getAdapter(Class adapter) {
94	if (IJavaElement.class.isAssignableFrom(adapter)) {
95	return getMember();
96	}
97
98	return null;
99	}
100	}

Added Link Here

(-)core (+73 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
10	* (report 36180: Callers/Callees view)
11	******************************************************************************/
12	package org.eclipse.jdt.internal.corext.callhierarchy;
13
14	import java.util.HashMap;
15	import java.util.Map;
16	import org.eclipse.jdt.core.IJavaElement;
17	import org.eclipse.jdt.core.IMember;
18	import org.eclipse.jdt.core.IType;
19
20	/**
21	* @author jl
22	*/
23	class CallSearchResultCollector {
24	private Map fCalledMembers;
25
26	public CallSearchResultCollector() {
27	this.fCalledMembers = createCalledMethodsData();
28	}
29
30	public Map getCallers() {
31	return fCalledMembers;
32	}
33
34	protected void addMember(IMember member, IMember calledMember, int start, int end) {
35	if ((member != null) && (calledMember != null)) {
36	if (!isIgnored(calledMember)) {
37	MethodCall methodCall = (MethodCall) fCalledMembers.get(calledMember.getHandleIdentifier());
38
39	if (methodCall == null) {
40	methodCall = new MethodCall(calledMember);
41	fCalledMembers.put(calledMember.getHandleIdentifier(), methodCall);
42	}
43
44	methodCall.addCallLocation(new CallLocation(member, calledMember, start,
45	end));
46	}
47	}
48	}
49
50	protected Map createCalledMethodsData() {
51	return new HashMap();
52	}
53
54	/**
55	* Method isIgnored.
56	* @param enclosingElement
57	* @return boolean
58	*/
59	private boolean isIgnored(IMember enclosingElement) {
60	String fullyQualifiedName = getTypeOfElement(enclosingElement)
61	.getFullyQualifiedName();
62
63	return CallHierarchy.getDefault().isIgnored(fullyQualifiedName);
64	}
65
66	private IType getTypeOfElement(IMember element) {
67	if (element.getElementType() == IJavaElement.TYPE) {
68	return (IType) element;
69	}
70
71	return element.getDeclaringType();
72	}
73	}

Added Link Here

(-)core (+246 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
10	* (report 36180: Callers/Callees view)
11	******************************************************************************/
12	package org.eclipse.jdt.internal.corext.callhierarchy;
13
14	import java.util.Collection;
15	import java.util.Map;
16
17	import org.eclipse.core.runtime.IProgressMonitor;
18	import org.eclipse.core.runtime.SubProgressMonitor;
19	import org.eclipse.jdt.core.IMethod;
20	import org.eclipse.jdt.core.ISourceRange;
21	import org.eclipse.jdt.core.IType;
22	import org.eclipse.jdt.core.JavaModelException;
23	import org.eclipse.jdt.core.dom.ASTNode;
24	import org.eclipse.jdt.core.dom.ASTVisitor;
25	import org.eclipse.jdt.core.dom.ClassInstanceCreation;
26	import org.eclipse.jdt.core.dom.ConstructorInvocation;
27	import org.eclipse.jdt.core.dom.IMethodBinding;
28	import org.eclipse.jdt.core.dom.ITypeBinding;
29	import org.eclipse.jdt.core.dom.MethodDeclaration;
30	import org.eclipse.jdt.core.dom.MethodInvocation;
31	import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
32	import org.eclipse.jdt.core.dom.SuperMethodInvocation;
33	import org.eclipse.jdt.core.search.IJavaSearchScope;
34	import org.eclipse.jdt.internal.corext.dom.Binding2JavaModel;
35
36	/**
37	* @author jl
38	*/
39	class CalleeAnalyzerVisitor extends ASTVisitor {
40	private CallSearchResultCollector fSearchResults;
41	private IMethod fMethod;
42	private IProgressMonitor fProgressMonitor;
43	private int fMethodEndPosition;
44	private int fMethodStartPosition;
45
46	CalleeAnalyzerVisitor(IMethod method, IProgressMonitor progressMonitor) {
47	fSearchResults = new CallSearchResultCollector();
48	this.fMethod = method;
49	this.fProgressMonitor = progressMonitor;
50
51	try {
52	ISourceRange sourceRange = method.getSourceRange();
53	this.fMethodStartPosition = sourceRange.getOffset();
54	this.fMethodEndPosition = fMethodStartPosition + sourceRange.getLength();
55	} catch (JavaModelException jme) {
56	Utility.logError("Error getting start and end of method: " +
57	fMethod.getElementName(), jme);
58	}
59	}
60
61	/**
62	* Method getCallees.
63	*
64	* @return CallerElement
65	*/
66	public Map getCallees() {
67	return fSearchResults.getCallers();
68	}
69
70	/* (non-Javadoc)
71	* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
72	*/
73	public boolean visit(ClassInstanceCreation node) {
74	if (!isNodeWithinMethod(node)) {
75	return false;
76	}
77
78	addMethodCall(node.resolveConstructorBinding(), node);
79
80	return true;
81	}
82
83	/**
84	* Find all constructor invocations (<code>this(...)</code>) from the called method.
85	* Since we only traverse into the AST on the wanted method declaration, this method
86	* should not hit on more constructor invocations than those in the wanted method.
87	*
88	* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConstructorInvocation)
89	*/
90	public boolean visit(ConstructorInvocation node) {
91	if (!isNodeWithinMethod(node)) {
92	return false;
93	}
94
95	addMethodCall(node.resolveConstructorBinding(), node);
96
97	return true;
98	}
99
100	/**
101	* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
102	*/
103	public boolean visit(MethodDeclaration node) {
104	return isNodeWithinMethod(node);
105	}
106
107	/**
108	* Find all method invocations from the called method. Since we only traverse into
109	* the AST on the wanted method declaration, this method should not hit on more
110	* method invocations than those in the wanted method.
111	*
112	* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
113	*/
114	public boolean visit(MethodInvocation node) {
115	if (!isNodeWithinMethod(node)) {
116	return false;
117	}
118
119	addMethodCall(node.resolveMethodBinding(), node);
120
121	return true;
122	}
123
124	/**
125	* Find invocations of the supertype's constructor from the called method
126	* (=constructor). Since we only traverse into the AST on the wanted method
127	* declaration, this method should not hit on more method invocations than those in
128	* the wanted method.
129	*
130	* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperConstructorInvocation)
131	*/
132	public boolean visit(SuperConstructorInvocation node) {
133	if (!isNodeWithinMethod(node)) {
134	return false;
135	}
136
137	addMethodCall(node.resolveConstructorBinding(), node);
138
139	return true;
140	}
141
142	/**
143	* Find all method invocations from the called method. Since we only traverse into
144	* the AST on the wanted method declaration, this method should not hit on more
145	* method invocations than those in the wanted method.
146	*
147	* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
148	*/
149	public boolean visit(SuperMethodInvocation node) {
150	if (!isNodeWithinMethod(node)) {
151	return false;
152	}
153
154	addMethodCall(node.resolveMethodBinding(), node);
155
156	return true;
157	}
158
159	/**
160	* Adds the specified method binding to the search results.
161	*
162	* @param calledMethodBinding
163	* @param node
164	*/
165	protected void addMethodCall(IMethodBinding calledMethodBinding, ASTNode node) {
166	try {
167	if (calledMethodBinding != null) {
168	fProgressMonitor.worked(1);
169
170	ITypeBinding calledTypeBinding = calledMethodBinding.getDeclaringClass();
171	IType calledType = null;
172
173	if (!calledTypeBinding.isAnonymous()) {
174	calledType = Binding2JavaModel.find(calledTypeBinding,
175	fMethod.getJavaProject());
176	} else {
177	calledType = Binding2JavaModel.find(calledTypeBinding.getInterfaces()[0],
178	fMethod.getJavaProject());
179	}
180
181	IMethod calledMethod = Binding2JavaModel.findIncludingSupertypes(calledMethodBinding,
182	calledType,
183	new SubProgressMonitor(fProgressMonitor, 100,
184	SubProgressMonitor.SUPPRESS_SUBTASK_LABEL));
185
186	if ((calledMethod != null) && calledType.isInterface()) {
187	calledMethod = findImplementingMethods(calledMethod);
188	}
189
190	if (!isIgnoredBySearchScope(calledMethod)) {
191	fSearchResults.addMember(fMethod, calledMethod,
192	node.getStartPosition(),
193	node.getStartPosition() + node.getLength());
194	}
195	}
196	} catch (JavaModelException jme) {
197	Utility.logError("Error adding callee search result", jme);
198	}
199	}
200
201	/**
202	* @param enclosingElement
203	*
204	* @return
205	*/
206	private boolean isIgnoredBySearchScope(IMethod enclosingElement) {
207	if (enclosingElement != null) {
208	return !getSearchScope().encloses(enclosingElement);
209	} else {
210	return false;
211	}
212	}
213
214	private IJavaSearchScope getSearchScope() {
215	return CallHierarchy.getDefault().getSearchScope();
216	}
217
218	private boolean isNodeWithinMethod(ASTNode node) {
219	int nodeStartPosition = node.getStartPosition();
220	int nodeEndPosition = nodeStartPosition + node.getLength();
221
222	if (nodeStartPosition < fMethodStartPosition) {
223	return false;
224	}
225
226	if (nodeEndPosition > fMethodEndPosition) {
227	return false;
228	}
229
230	return true;
231	}
232
233	/**
234	* @param calledMethod
235	*/
236	private IMethod findImplementingMethods(IMethod calledMethod) {
237	Collection implementingMethods = CallHierarchy.getDefault()
238	.getImplementingMethods(calledMethod);
239
240	if ((implementingMethods.size() == 0) \|\| (implementingMethods.size() > 1)) {
241	return calledMethod;
242	} else {
243	return (IMethod) implementingMethods.iterator().next();
244	}
245	}
246	}

Added Link Here

(-)core (+108 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
10	* (report 36180: Callers/Callees view)
11	******************************************************************************/
12	package org.eclipse.jdt.internal.corext.callhierarchy;
13
14	import java.util.Arrays;
15	import java.util.Comparator;
16	import java.util.HashMap;
17	import java.util.Map;
18
19	import org.eclipse.core.runtime.IProgressMonitor;
20	import org.eclipse.jdt.core.ICompilationUnit;
21	import org.eclipse.jdt.core.IJavaElement;
22	import org.eclipse.jdt.core.IMethod;
23	import org.eclipse.jdt.core.dom.AST;
24	import org.eclipse.jdt.core.dom.CompilationUnit;
25
26	/**
27	* @author jl
28	*/
29	class CalleeMethodWrapper extends MethodWrapper {
30	private Comparator fMethodWrapperComparator = new MethodWrapperComparator();
31
32	private class MethodWrapperComparator implements Comparator {
33	/* (non-Javadoc)
34	* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
35	*/
36	public int compare(Object o1, Object o2) {
37	MethodWrapper m1 = (MethodWrapper) o1;
38	MethodWrapper m2 = (MethodWrapper) o2;
39
40	CallLocation callLocation1 = m1.getMethodCall().getFirstCallLocation();
41	CallLocation callLocation2 = m2.getMethodCall().getFirstCallLocation();
42
43	if ((callLocation1 != null) && (callLocation2 != null)) {
44	if (callLocation1.getStart() == callLocation2.getStart()) {
45	return callLocation1.getEnd() - callLocation2.getEnd();
46	}
47
48	return callLocation1.getStart() - callLocation2.getStart();
49	}
50
51	return 0;
52	}
53	}
54
55	/**
56	* Constructor for CalleeMethodWrapper.
57	* @param parent
58	* @param method
59	*/
60	public CalleeMethodWrapper(MethodWrapper parent, MethodCall methodCall) {
61	super(parent, methodCall);
62	}
63
64	/* Returns the calls sorted after the call location
65	* @see dk.kamstruplinnet.callers.search.MethodWrapper#getCalls()
66	*/
67	public MethodWrapper[] getCalls() {
68	MethodWrapper[] result = super.getCalls();
69	Arrays.sort(result, fMethodWrapperComparator);
70
71	return result;
72	}
73
74	/* (non-Javadoc)
75	* @see dk.kamstruplinnet.callers.search.MethodWrapper#getTaskName()
76	*/
77	protected String getTaskName() {
78	return null;
79	}
80
81	/**
82	* @see dk.kamstruplinnet.callers.CallerMethodWrapper#createMethodWrapper(org.eclipse.jdt.core.IMethod)
83	*/
84	protected MethodWrapper createMethodWrapper(MethodCall methodCall) {
85	return new CalleeMethodWrapper(this, methodCall);
86	}
87
88	/**
89	* Find callees called from the current method.
90	* @see dk.kamstruplinnet.callers.MethodWrapper#findChildren()
91	*/
92	protected Map findChildren(IProgressMonitor progressMonitor) {
93	if (getMember().getElementType() == IJavaElement.METHOD) {
94	CalleeAnalyzerVisitor visitor = new CalleeAnalyzerVisitor((IMethod) getMember(),
95	progressMonitor);
96	ICompilationUnit icu = getMember().getCompilationUnit();
97
98	if (icu != null) {
99	CompilationUnit cu = AST.parseCompilationUnit(icu, true);
100	cu.accept(visitor);
101	}
102
103	return visitor.getCallees();
104	} else {
105	return new HashMap();
106	}
107	}
108	}

Added Link Here

(-)core (+93 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
10	* (report 36180: Callers/Callees view)
11	******************************************************************************/
12	package org.eclipse.jdt.internal.corext.callhierarchy;
13
14	import java.util.ArrayList;
15	import java.util.Collection;
16	import java.util.HashMap;
17	import java.util.Iterator;
18	import java.util.Map;
19
20	import org.eclipse.core.resources.ResourcesPlugin;
21	import org.eclipse.core.runtime.IProgressMonitor;
22	import org.eclipse.core.runtime.SubProgressMonitor;
23	import org.eclipse.jdt.core.IJavaElement;
24	import org.eclipse.jdt.core.IMember;
25	import org.eclipse.jdt.core.IMethod;
26	import org.eclipse.jdt.core.JavaModelException;
27	import org.eclipse.jdt.core.search.IJavaSearchConstants;
28	import org.eclipse.jdt.core.search.IJavaSearchScope;
29	import org.eclipse.jdt.core.search.SearchEngine;
30
31	/**
32	* @author jl
33	*/
34	class CallerMethodWrapper extends MethodWrapper {
35	public CallerMethodWrapper(MethodWrapper parent, MethodCall methodCall) {
36	super(parent, methodCall);
37	}
38
39	protected IJavaSearchScope getSearchScope() {
40	return CallHierarchy.getDefault().getSearchScope();
41	}
42
43	protected String getTaskName() {
44	return "Finding callers...";
45	}
46
47	/**
48	* @see dk.kamstruplinnet.callers.CallerMethodWrapper#createMethodWrapper(org.eclipse.jdt.core.IMethod)
49	*/
50	protected MethodWrapper createMethodWrapper(MethodCall methodCall) {
51	return new CallerMethodWrapper(this, methodCall);
52	}
53
54	/**
55	* @see dk.kamstruplinnet.callers.MethodWrapper#findChildren()
56	* @return The result of the search for children
57	*/
58	protected Map findChildren(IProgressMonitor progressMonitor) {
59	try {
60	MethodReferencesSearchCollector searchCollector = new MethodReferencesSearchCollector();
61	SearchEngine searchEngine = new SearchEngine();
62
63	for (Iterator iter = getMembers().iterator();
64	iter.hasNext() && !progressMonitor.isCanceled();) {
65	IMember member = (IMember) iter.next();
66	searchCollector.setProgressMonitor(new SubProgressMonitor(
67	progressMonitor, 10, SubProgressMonitor.SUPPRESS_SUBTASK_LABEL));
68	searchEngine.search(ResourcesPlugin.getWorkspace(), member,
69	IJavaSearchConstants.REFERENCES, getSearchScope(), searchCollector);
70	}
71
72	return searchCollector.getCallers();
73	} catch (JavaModelException e) {
74	Utility.logError("Error finding callers", e);
75
76	return new HashMap(0);
77	}
78	}
79
80	/**
81	* Returns a collection of IMember instances representing what to search for
82	*/
83	private Collection getMembers() {
84	Collection result = new ArrayList();
85
86	result.add(getMember());
87	if (getMember().getElementType() == IJavaElement.METHOD) {
88	result.addAll(CallHierarchy.getDefault().getInterfaceMethods((IMethod) getMember()));
89	}
90
91	return result;
92	}
93	}

Added Link Here

(-)core (+84 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
10	* (report 36180: Callers/Callees view)
11	******************************************************************************/
12	package org.eclipse.jdt.internal.corext.callhierarchy;
13
14	import java.util.Map;
15
16	import org.eclipse.core.resources.IResource;
17	import org.eclipse.core.runtime.CoreException;
18	import org.eclipse.core.runtime.IProgressMonitor;
19	import org.eclipse.core.runtime.SubProgressMonitor;
20	import org.eclipse.jdt.core.IJavaElement;
21	import org.eclipse.jdt.core.IMember;
22	import org.eclipse.jdt.core.search.IJavaSearchResultCollector;
23
24	/**
25	* @author jl
26	*/
27	class MethodReferencesSearchCollector implements IJavaSearchResultCollector {
28	private CallSearchResultCollector fSearchResults;
29	private IProgressMonitor fProgressMonitor;
30	private boolean fRequireExactMatch = true;
31
32	MethodReferencesSearchCollector() {
33	fSearchResults = new CallSearchResultCollector();
34	}
35
36	public Map getCallers() {
37	return fSearchResults.getCallers();
38	}
39
40	/**
41	* @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#getProgressMonitor()
42	*/
43	public IProgressMonitor getProgressMonitor() {
44	return fProgressMonitor;
45	}
46
47	/**
48	* @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#aboutToStart()
49	*/
50	public void aboutToStart() {}
51
52	/**
53	* @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#accept(org.eclipse.core.resources.IResource, int, int, org.eclipse.jdt.core.IJavaElement, int)
54	*/
55	public void accept(IResource resource, int start, int end,
56	IJavaElement enclosingElement, int accuracy) throws CoreException {
57	if (fRequireExactMatch && (accuracy != IJavaSearchResultCollector.EXACT_MATCH)) {
58	return;
59	}
60
61	if (enclosingElement != null && enclosingElement instanceof IMember) {
62	IMember member= (IMember) enclosingElement;
63	switch (enclosingElement.getElementType()) {
64	case IJavaElement.METHOD:
65	case IJavaElement.TYPE:
66	case IJavaElement.FIELD:
67	fSearchResults.addMember(member, member, start, end);
68	break;
69	}
70	}
71	}
72
73	/**
74	* @see org.eclipse.jdt.core.search.IJavaSearchResultCollector#done()
75	*/
76	public void done() {}
77
78	/**
79	* @param monitor
80	*/
81	void setProgressMonitor(SubProgressMonitor monitor) {
82	this.fProgressMonitor = monitor;
83	}
84	}

Added Link Here

(-)core (+331 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Jesper Kamstrup Linnet (eclipse@kamstrup-linnet.dk) - initial API and implementation
10	* (report 36180: Callers/Callees view)
11	******************************************************************************/
12	package org.eclipse.jdt.internal.corext.callhierarchy;
13
14	import java.util.HashMap;
15	import java.util.Iterator;
16	import java.util.Map;
17	import org.eclipse.core.runtime.IAdaptable;
18	import org.eclipse.core.runtime.IProgressMonitor;
19	import org.eclipse.core.runtime.NullProgressMonitor;
20	import org.eclipse.jdt.core.IJavaElement;
21	import org.eclipse.jdt.core.IMember;
22	import org.eclipse.jdt.core.IMethod;
23
24	/**
25	* This class represents the general parts of a method call (either to or from a
26	* method).
27	*
28	* @author jl
29	*/
30	public abstract class MethodWrapper implements IAdaptable {
31	private Map fElements = null;
32
33	/*
34	* A cache of previously found methods. This cache should be searched
35	* before adding a "new" method object reference to the list of elements.
36	* This way previously found methods won't be searched again.
37	*/
38	private Map fMethodCache;
39	private MethodCall fMethodCall;
40	private MethodWrapper fParent;
41	private int fLevel;
42
43	/**
44	* Constructor CallerElement.
45	*/
46	public MethodWrapper(MethodWrapper parent, MethodCall methodCall) {
47	super();
48
49	if (methodCall == null) {
50	throw new IllegalArgumentException("Parameter method cannot be null");
51	}
52
53	if (parent == null) {
54	setMethodCache(new HashMap());
55	fLevel = 1;
56	} else {
57	setMethodCache(parent.getMethodCache());
58	fLevel = parent.getLevel() + 1;
59	}
60
61	this.fMethodCall = methodCall;
62	this.fParent = parent;
63	}
64
65	public Object getAdapter(Class adapter) {
66	if (adapter == IMethod.class) {
67	if (getMember().getElementType() == IJavaElement.METHOD) {
68	return getMember();
69	} else {
70	return null;
71	}
72	} else {
73	if (IJavaElement.class.isAssignableFrom(adapter)) {
74	return getMember();
75	}
76	}
77
78	return null;
79	}
80
81	/**
82	* Method getCallerElements.
83	* @return The child caller elements of this element
84	*/
85	public MethodWrapper[] getCalls() {
86	if (fElements == null) {
87	doFindChildren();
88	}
89
90	MethodWrapper[] result = new MethodWrapper[fElements.size()];
91	int i = 0;
92
93	for (Iterator iter = fElements.keySet().iterator(); iter.hasNext();) {
94	MethodCall methodCall = getMethodCallFromMap(fElements, iter.next());
95	result[i++] = createMethodWrapper(methodCall);
96	}
97
98	return result;
99	}
100
101	/**
102	* @return int
103	*/
104	public int getLevel() {
105	return fLevel;
106	}
107
108	/**
109	* Method getMethod.
110	* @return Object
111	*/
112	public IMember getMember() {
113	return getMethodCall().getMember();
114	}
115
116	/**
117	* @return MethodCall
118	*/
119	public MethodCall getMethodCall() {
120	return fMethodCall;
121	}
122
123	/**
124	* Method getName.
125	*/
126	public String getName() {
127	if (getMethodCall() != null) {
128	return getMethodCall().getMember().getElementName();
129	} else {
130	return "";
131	}
132	}
133
134	/**
135	* Method getParent.
136	* @return
137	*/
138	public MethodWrapper getParent() {
139	return fParent;
140	}
141
142	public boolean equals(Object oth) {
143	if (this == oth) {
144	return true;
145	}
146
147	if (oth == null) {
148	return false;
149	}
150
151	if (oth.getClass() != getClass()) {
152	return false;
153	}
154
155	MethodWrapper other = (MethodWrapper) oth;
156
157	if (this.fParent == null) {
158	if (other.fParent != null) {
159	return false;
160	}
161	} else {
162	if (!this.fParent.equals(other.fParent)) {
163	return false;
164	}
165	}
166
167	if (this.getMethodCall() == null) {
168	if (other.getMethodCall() != null) {
169	return false;
170	}
171	} else {
172	if (!this.getMethodCall().equals(other.getMethodCall())) {
173	return false;
174	}
175	}
176
177	return true;
178	}
179
180	public int hashCode() {
181	final int PRIME = 1000003;
182	int result = 0;
183
184	if (fParent != null) {
185	result = (PRIME * result) + fParent.hashCode();
186	}
187
188	if (getMethodCall() != null) {
189	result = (PRIME * result) + getMethodCall().getMember().hashCode();
190	}
191
192	return result;
193	}
194
195	/**
196	* @see java.lang.Object#toString()
197	*/
198	public String toString() {
199	String result;
200
201	result = "CallerElement[name=" + getName() + ", children=";
202
203	if (fElements == null) {
204	result += "unknown]";
205	} else {
206	result += (fElements.size() + "]");
207	}
208
209	return result;
210	}
211
212	private void setMethodCache(Map methodCache) {
213	fMethodCache = methodCache;
214	}
215
216	protected abstract String getTaskName();
217
218	private void addCallToCache(MethodCall methodCall) {
219	Map cachedCalls = lookupMethod(this.getMethodCall());
220	cachedCalls.put(methodCall.getKey(), methodCall);
221	}
222
223	/**
224	* Method createMethodWrapper.
225	* @param method
226	* @return MethodWrapper
227	*/
228	protected abstract MethodWrapper createMethodWrapper(MethodCall methodCall);
229
230	private void doFindChildren() {
231	Map existingResults = lookupMethod(getMethodCall());
232
233	if (existingResults != null) {
234	fElements = new HashMap();
235	fElements.putAll(existingResults);
236	} else {
237	initCalls();
238
239	try {
240	IProgressMonitor progressMonitor = getProgressMonitor();
241
242	if (progressMonitor != null) {
243	progressMonitor.beginTask(getTaskName(), IProgressMonitor.UNKNOWN);
244	}
245
246	try {
247	performSearch(progressMonitor);
248	} finally {
249	if (progressMonitor != null) {
250	progressMonitor.done();
251	}
252	}
253
254	// ModalContext.run(getRunnableWithProgress(), true, getProgressMonitor(),
255	// Display.getCurrent());
256	} catch (Exception e) {
257	Utility.logError("Error searching in modal context", e);
258	}
259	}
260	}
261
262	/**
263	* Determines if the method represents a recursion call (i.e. whether the
264	* method call is already in the cache.)
265	*
266	* @return True if the call is part of a recursion
267	*/
268	public boolean isRecursive() {
269	MethodWrapper current = getParent();
270
271	while (current != null) {
272	if (getMember().getHandleIdentifier().equals(current.getMember()
273	.getHandleIdentifier())) {
274	return true;
275	}
276
277	current = current.getParent();
278	}
279
280	return false;
281	}
282
283	/**
284	* This method finds the children of the current IMethod (either callers or
285	* callees, depending on the concrete subclass.
286	* @return The result of the search for children
287	*/
288	protected abstract Map findChildren(IProgressMonitor progressMonitor);
289
290	private Map getMethodCache() {
291	return fMethodCache;
292	}
293
294	private void initCalls() {
295	this.fElements = new HashMap();
296
297	initCacheForMethod();
298	}
299
300	/**
301	* Looks up a previously created search result in the "global" cache.
302	* @param method
303	* @return List List of previously found search results
304	*/
305	private Map lookupMethod(MethodCall methodCall) {
306	return (Map) getMethodCache().get(methodCall.getKey());
307	}
308
309	private void performSearch(IProgressMonitor progressMonitor) {
310	fElements = findChildren(progressMonitor);
311
312	for (Iterator iter = fElements.keySet().iterator(); iter.hasNext();) {
313	MethodCall methodCall = getMethodCallFromMap(fElements, iter.next());
314	addCallToCache(methodCall);
315	}
316	}
317
318	private MethodCall getMethodCallFromMap(Map elements, Object key) {
319	return (MethodCall) elements.get(key);
320	}
321
322	private IProgressMonitor getProgressMonitor() {
323	// TODO: Figure out what to do with progress monitors
324	return new NullProgressMonitor();
325	}
326
327	private void initCacheForMethod() {
328	Map cachedCalls = new HashMap();
329	getMethodCache().put(this.getMethodCall().getKey(), cachedCalls);
330	}
331	}

Lines 10-33 Link Here

(-)ui/org/eclipse/jdt/internal/ui/callhierarchy/CallHierarchyMessages.properties (-19 / +7 lines)
10	# (report 36180: Callers/Callees view)	10	# (report 36180: Callers/Callees view)
11	###############################################################################	11	###############################################################################
12		12
13	CallHierarchyPreferenceFilterPage.description=Filters
14	CallHierarchyPreferenceFilterPage.use.package.filters=Use package filters
15	CallHierarchyPreferenceFilterPage.defined.package.filters=Defined package filters
16	CallHierarchyPreferenceFilterPage.add.filter=Add filter
17	CallHierarchyPreferenceFilterPage.add.filter.tooltip=Add filter (tooltip)
18	CallHierarchyPreferenceFilterPage.add.package=Add package
19	CallHierarchyPreferenceFilterPage.add.package.tooltip=Add package (tooltip)
20	CallHierarchyPreferenceFilterPage.remove.filter=Remove filter
21	CallHierarchyPreferenceFilterPage.remove.filter.tooltip=Remove filter (tooltip)
22	CallHierarchyPreferenceFilterPage.enable.all=Enable all
23	CallHierarchyPreferenceFilterPage.enable.all.tooltip=Enable all (tooltip)
24	CallHierarchyPreferenceFilterPage.disable.all=Disable all
25	CallHierarchyPreferenceFilterPage.disable.all.tooltip=Disable all (tooltip)
26	CallHierarchyPreferenceFilterPage.invalid.input=Invalid input
27	CallHierarchyPreferenceFilterPage.addpackagedialog.title=addpackagedialog.title
28	CallHierarchyPreferenceFilterPage.addpackagedialog.error.message=addpackagedialog.error.message
29	CallHierarchyPreferenceFilterPage.addpackagedialog.message=addpackagedialog.message
30	CallHierarchyPreferenceFilterPage.label.defaultpackage=label.defaultpackage
31	CallHierarchyViewPart.empty=No method has been selected.	13	CallHierarchyViewPart.empty=No method has been selected.
32	ToggleCallModeAction.callers.tooltip=Show the Caller Hierarchy	14	ToggleCallModeAction.callers.tooltip=Show the Caller Hierarchy
33	ToggleCallModeAction.callers.label=Caller Hierarchy	15	ToggleCallModeAction.callers.label=Caller Hierarchy
Lines 39-42 Link Here
39	ToggleJavaLabelFormatAction.long.label=Long format	21	ToggleJavaLabelFormatAction.long.label=Long format
40	ToggleOrientationAction.vertical.label=Vertical View Orientation	22	ToggleOrientationAction.vertical.label=Vertical View Orientation
41	ToggleOrientationAction.horizontal.label=Horizontal View Orientation	23	ToggleOrientationAction.horizontal.label=Horizontal View Orientation
42	ToggleOrientationAction.single.label=Hierarchy View Only	24	ToggleOrientationAction.single.label=Hierarchy View Only
		25	ShowFilterDialogAction.text= &Filters...
		26	FiltersDialog.filter= Filter Calls
		27	FiltersDialog.filterOnNames= Filter on path names:
		28	FiltersDialog.maxCallDepth= Max call depth:
		29	FiltersDialog.titleMaxCallDepthInvalid= Error
		30	FiltersDialog.messageMaxCallDepthInvalid= The max call depth must be in range [1..99]