/*******************************************************************************
* Copyright (c) 2000, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.ui;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.IDecoration;
import org.eclipse.jface.viewers.ILabelDecorator;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ILightweightLabelDecorator;
import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeHierarchy;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.NodeFinder;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.internal.corext.dom.Bindings;
import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
import org.eclipse.jdt.internal.corext.util.JdtFlags;
import org.eclipse.jdt.internal.corext.util.MethodOverrideTester;
import org.eclipse.jdt.internal.corext.util.SuperTypeHierarchyCache;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.viewsupport.ImageDescriptorRegistry;
import org.eclipse.jdt.internal.ui.viewsupport.ImageImageDescriptor;
/**
* LabelDecorator that decorates an method's image with override or implements overlays.
* The viewer using this decorator is responsible for updating the images on element changes.
*
* <p>
* This class may be instantiated; it is not intended to be subclassed.
* </p>
*
* @since 2.0
*
* @noextend This class is not intended to be subclassed by clients.
*/
public class OverrideIndicatorLabelDecorator implements ILabelDecorator, ILightweightLabelDecorator {
private ImageDescriptorRegistry fRegistry;
private boolean fUseNewRegistry= false;
/**
* Creates a decorator. The decorator creates an own image registry to cache
* images.
*/
public OverrideIndicatorLabelDecorator() {
this(null);
fUseNewRegistry= true;
}
/*
* Creates decorator with a shared image registry.
*
* @param registry The registry to use or <code>null</code> to use the Java plugin's
* image registry.
*/
/**
* Note: This constructor is for internal use only. Clients should not call this constructor.
*
* @param registry The registry to use.
* @noreference This method is not intended to be referenced by clients.
*/
public OverrideIndicatorLabelDecorator(ImageDescriptorRegistry registry) {
fRegistry= registry;
}
private ImageDescriptorRegistry getRegistry() {
if (fRegistry == null) {
fRegistry= fUseNewRegistry ? new ImageDescriptorRegistry() : JavaPlugin.getImageDescriptorRegistry();
}
return fRegistry;
}
/* (non-Javadoc)
* @see ILabelDecorator#decorateText(String, Object)
*/
public String decorateText(String text, Object element) {
return text;
}
/* (non-Javadoc)
* @see ILabelDecorator#decorateImage(Image, Object)
*/
public Image decorateImage(Image image, Object element) {
if (image == null)
return null;
int adornmentFlags= computeAdornmentFlags(element);
if (adornmentFlags != 0) {
ImageDescriptor baseImage= new ImageImageDescriptor(image);
Rectangle bounds= image.getBounds();
return getRegistry().get(new JavaElementImageDescriptor(baseImage, adornmentFlags, new Point(bounds.width, bounds.height)));
}
return image;
}
/**
* Note: This method is for internal use only. Clients should not call this method.
* @param element The element to decorate
* @return Resulting decorations (combination of JavaElementImageDescriptor.IMPLEMENTS
* and JavaElementImageDescriptor.OVERRIDES)
*
* @noreference This method is not intended to be referenced by clients.
*/
public int computeAdornmentFlags(Object element) {
if (element instanceof IMethod) {
try {
IMethod method= (IMethod) element;
if (!method.getJavaProject().isOnClasspath(method)) {
return 0;
}
int flags= method.getFlags();
if (!method.isConstructor() && !Flags.isPrivate(flags) && !Flags.isStatic(flags)) {
int res= getOverrideIndicators(method);
if (res != 0 && Flags.isSynchronized(flags)) {
return res | JavaElementImageDescriptor.SYNCHRONIZED;
}
return res;
}
} catch (JavaModelException e) {
if (!e.isDoesNotExist()) {
JavaPlugin.log(e);
}
}
}
return 0;
}
/**
* Note: This method is for internal use only. Clients should not call this method.
*
* @param method The element to decorate
* @return Resulting decorations (combination of JavaElementImageDescriptor.IMPLEMENTS and
* JavaElementImageDescriptor.OVERRIDES)
* @throws JavaModelException if accessing a Java Model element fails
* @noreference This method is not intended to be referenced by clients.
*/
protected int getOverrideIndicators(IMethod method) throws JavaModelException {
CompilationUnit astRoot= SharedASTProvider.getAST(method.getTypeRoot(), SharedASTProvider.WAIT_ACTIVE_ONLY, null);
if (astRoot != null) {
int res= findInHierarchyWithAST(astRoot, method);
if (res != -1) {
return res;
}
}
IType type= method.getDeclaringType();
MethodOverrideTester methodOverrideTester= SuperTypeHierarchyCache.getMethodOverrideTester(type);
IMethod defining= methodOverrideTester.findOverriddenMethod(method, true);
if (defining != null) {
if (JdtFlags.isAbstract(defining)) {
return JavaElementImageDescriptor.IMPLEMENTS;
} else {
return JavaElementImageDescriptor.OVERRIDES;
}
}
return 0;
}
private int findInHierarchyWithAST(CompilationUnit astRoot, IMethod method) throws JavaModelException {
ASTNode node= NodeFinder.perform(astRoot, method.getNameRange());
if (node instanceof SimpleName && node.getParent() instanceof MethodDeclaration) {
IMethodBinding binding= ((MethodDeclaration) node.getParent()).resolveBinding();
if (binding != null) {
IMethodBinding defining= Bindings.findOverriddenMethod(binding, true);
if (defining != null) {
if (JdtFlags.isAbstract(defining)) {
return JavaElementImageDescriptor.IMPLEMENTS;
} else {
return JavaElementImageDescriptor.OVERRIDES;
}
}
return 0;
}
}
return -1;
}
/**
* Note: This method is for internal use only. Clients should not call this method.
*
* @param type The declaring type of the method to decorate.
* @param hierarchy The type hierarchy of the declaring type.
* @param name The name of the method to find.
* @param paramTypes The parameter types of the method to find.
* @return The resulting decoration.
* @throws JavaModelException if accessing a Java Model element fails
* @deprecated Not used anymore. This method is not accurate for methods in generic types.
*
* @noreference This method is not intended to be referenced by clients.
*/
protected int findInHierarchy(IType type, ITypeHierarchy hierarchy, String name, String[] paramTypes) throws JavaModelException {
IType superClass= hierarchy.getSuperclass(type);
if (superClass != null) {
IMethod res= JavaModelUtil.findMethodInHierarchy(hierarchy, superClass, name, paramTypes, false);
if (res != null && !Flags.isPrivate(res.getFlags()) && JavaModelUtil.isVisibleInHierarchy(res, type.getPackageFragment())) {
if (JdtFlags.isAbstract(res)) {
return JavaElementImageDescriptor.IMPLEMENTS;
} else {
return JavaElementImageDescriptor.OVERRIDES;
}
}
}
IType[] interfaces= hierarchy.getSuperInterfaces(type);
for (int i= 0; i < interfaces.length; i++) {
IMethod res= JavaModelUtil.findMethodInHierarchy(hierarchy, interfaces[i], name, paramTypes, false);
if (res != null) {
if (JdtFlags.isAbstract(res)) {
return JavaElementImageDescriptor.IMPLEMENTS;
} else {
return JavaElementImageDescriptor.OVERRIDES;
}
}
}
return 0;
}
/* (non-Javadoc)
* @see IBaseLabelProvider#addListener(ILabelProviderListener)
*/
public void addListener(ILabelProviderListener listener) {
}
/* (non-Javadoc)
* @see IBaseLabelProvider#dispose()
*/
public void dispose() {
if (fRegistry != null && fUseNewRegistry) {
fRegistry.dispose();
}
}
/* (non-Javadoc)
* @see IBaseLabelProvider#isLabelProperty(Object, String)
*/
public boolean isLabelProperty(Object element, String property) {
return true;
}
/* (non-Javadoc)
* @see IBaseLabelProvider#removeListener(ILabelProviderListener)
*/
public void removeListener(ILabelProviderListener listener) {
}
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ILightweightLabelDecorator#decorate(java.lang.Object, org.eclipse.jface.viewers.IDecoration)
*/
public void decorate(Object element, IDecoration decoration) {
int adornmentFlags= computeAdornmentFlags(element);
if ((adornmentFlags & JavaElementImageDescriptor.IMPLEMENTS) != 0) {
if ((adornmentFlags & JavaElementImageDescriptor.SYNCHRONIZED) != 0) {
decoration.addOverlay(JavaPluginImages.DESC_OVR_SYNCH_AND_IMPLEMENTS);
} else {
decoration.addOverlay(JavaPluginImages.DESC_OVR_IMPLEMENTS);
}
} else if ((adornmentFlags & JavaElementImageDescriptor.OVERRIDES) != 0) {
if ((adornmentFlags & JavaElementImageDescriptor.SYNCHRONIZED) != 0) {
decoration.addOverlay(JavaPluginImages.DESC_OVR_SYNCH_AND_OVERRIDES);
} else {
decoration.addOverlay(JavaPluginImages.DESC_OVR_OVERRIDES);
}
}
}
}