Attachment #166009 for bug #236850




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

import org.eclipse.jface.text.IDocumentExtension3;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.jface.text.TextPresentation;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.text.TextUtilities;

import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.ILocalVariable;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IOpenable;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.SourceRange;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;

	 * @see AbstractInfoView#computeInput(Object)
	 */
	protected Object computeInput(Object input) {
		//TODO: never used?
		if (getControl() == null || ! (input instanceof IJavaElement))
			return null;


				}

				HTMLPrinter.addSmallHeader(buffer, getInfoText(member, constantValue, true));

				try {
					ISourceRange nameRange= ((IMember)curr).getNameRange();
					if (SourceRange.isAvailable(nameRange)) {
						ITypeRoot typeRoot= ((IMember)curr).getTypeRoot();
						Region hoverRegion= new Region(nameRange.getOffset(), nameRange.getLength());
						buffer.append("<br>"); //$NON-NLS-1$
						JavadocHover.addAnnotations(buffer, curr, typeRoot, hoverRegion);
					}
				} catch (JavaModelException e) {
					// no annotations this time...
				}
				
				Reader reader;
				try {
					String content= JavadocContentAccess2.getHTMLContent(member, true);

				if (reader != null) {
					HTMLPrinter.addParagraph(buffer, reader);
				}

			} else if (curr.getElementType() == IJavaElement.LOCAL_VARIABLE || curr.getElementType() == IJavaElement.TYPE_PARAMETER) {
				HTMLPrinter.addSmallHeader(buffer, getInfoText(curr, null, true));
				if (curr instanceof ILocalVariable) {
					ISourceRange nameRange= ((ILocalVariable) curr).getNameRange();
					ITypeRoot typeRoot= ((IMember) curr.getParent()).getTypeRoot();
					Region hoverRegion= new Region(nameRange.getOffset(), nameRange.getLength());
					buffer.append("<br>"); //$NON-NLS-1$
					JavadocHover.addAnnotations(buffer, curr, typeRoot, hoverRegion);
				}
			}
		}


		}

		StringBuffer buf= new StringBuffer();
		JavadocHover.addImageAndLabel(buf, imageName, 16, 16, label.toString(), 20, 2);
		return buf.toString();
	}


					return null;

				VariableDeclarationFragment fieldDecl= ASTNodeSearchUtil.getFieldDeclarationFragmentNode(constantField, ast);
				if (fieldDecl == null)
					return null;
				Expression initializer= fieldDecl.getInitializer();
				if (initializer == null)
					return null;

			 * @see org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks.ILinkHandler#handleExternalLink(java.net.URL, org.eclipse.swt.widgets.Display)
			 */
			public boolean handleExternalLink(final URL url, Display display) {
				if (fCurrent == null || (fCurrent.getInputElement() instanceof URL && !url.toExternalForm().equals(((URL) fCurrent.getInputElement()).toExternalForm()))) {
					fCurrent= new URLBrowserInput(fCurrent, url);

					if (fBackAction != null) {




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

import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.net.URISyntaxException;
import java.net.URL;

import org.osgi.framework.Bundle;

import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Platform;

import org.eclipse.jface.action.Action;


import org.eclipse.ui.editors.text.EditorsUI;

import org.eclipse.jdt.core.IAnnotatable;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.CharacterLiteral;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.IAnnotationBinding;
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.jdt.core.dom.IMemberValuePairBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
import org.eclipse.jdt.core.dom.NodeFinder;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;

import org.eclipse.jdt.internal.corext.javadoc.JavaDocLocations;

			 * @see org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks.ILinkHandler#handleInlineJavadocLink(org.eclipse.jdt.core.IJavaElement)
			 */
			public void handleInlineJavadocLink(IJavaElement linkTarget) {
				JavadocBrowserInformationControlInput hoverInfo= getHoverInfo(new IJavaElement[] { linkTarget }, null, null, (JavadocBrowserInformationControlInput) control.getInput());
				if (control.hasDelayedInputChangeListener())
					control.notifyDelayedInputChange(hoverInfo);
				else

		if (elements == null || elements.length == 0)
			return null;

		return getHoverInfo(elements, getEditorInputJavaElement(), hoverRegion, null);
		if (elements.length == 1 && elements[0].getElementType() == IJavaElement.FIELD) {
			constantValue= getConstantValue((IField) elements[0], hoverRegion);
			if (constantValue != null)
				constantValue= HTMLPrinter.convertToHTMLContent(constantValue);
		} else {
			constantValue= null;
		}

		return getHoverInfo(elements, constantValue, null);
	}

	/**
	 * Computes the hover info.
	 *
	 * @param elements the resolved elements
	 * @param editorInputElement the editor input, or <code>null</code>
	 * @param hoverRegion the text range of the hovered word, or <code>null</code>
	 * @param previousInput the previous input, or <code>null</code>
	 * @return the HTML hover info for the given element(s) or <code>null</code> if no information is available
	 * @since 3.4
	 */
	private static JavadocBrowserInformationControlInput getHoverInfo(IJavaElement[] elements, ITypeRoot editorInputElement, IRegion hoverRegion, JavadocBrowserInformationControlInput previousInput) {
		int nResults= elements.length;
		StringBuffer buffer= new StringBuffer();
		boolean hasContents= false;

				HTMLPrinter.startBulletList(buffer);
				IJavaElement curr= elements[i];
				if (curr instanceof IMember || curr.getElementType() == IJavaElement.LOCAL_VARIABLE) {
					String label= JavaElementLabels.getElementLabel(curr, getHeaderFlags(curr));
					String link;
					try {
						String uri= JavaElementLinks.createURI(JavaElementLinks.JAVADOC_SCHEME, curr);
						link= JavaElementLinks.createLink(uri, label);
					} catch (URISyntaxException e) {
						JavaPlugin.log(e);
						link= label;
					}
					HTMLPrinter.addBullet(buffer, link);
					hasContents= true;
				}
				HTMLPrinter.endBulletList(buffer);


			element= elements[0];
			if (element instanceof IMember) {
				HTMLPrinter.addSmallHeader(buffer, getInfoText(element, editorInputElement, hoverRegion, true));
				buffer.append("<br>"); //$NON-NLS-1$
				addAnnotations(buffer, element, editorInputElement, hoverRegion);
				IMember member= (IMember) element;
				HTMLPrinter.addSmallHeader(buffer, getInfoText(member, constantValue, true));
				Reader reader;
				try {
//					reader= JavadocContentAccess.getHTMLContentReader(member, true, true);

				hasContents= true;

			} else if (element.getElementType() == IJavaElement.LOCAL_VARIABLE || element.getElementType() == IJavaElement.TYPE_PARAMETER) {
				addAnnotations(buffer, element, editorInputElement, hoverRegion);
				HTMLPrinter.addSmallHeader(buffer, getInfoText(element, editorInputElement, hoverRegion, true));
				hasContents= true;
			}
			leadingImageWidth= 20;

		return null;
	}

	private static String getInfoText(IJavaElement element, ITypeRoot editorInputElement, IRegion hoverRegion, boolean allowImage) {
		long flags= getHeaderFlags(element);
		switch (element.getElementType()) {
			case IJavaElement.LOCAL_VARIABLE:
				flags= LOCAL_VARIABLE_FLAGS;
				break;
			case IJavaElement.TYPE_PARAMETER:
				flags= TYPE_PARAMETER_FLAGS;
				break;
			default:
				flags= LABEL_FLAGS;
				break;
		}
		StringBuffer label= new StringBuffer(JavaElementLinks.getElementLabel(element, flags));
		
		if (element.getElementType() == IJavaElement.FIELD) {
			String constantValue= getConstantValue((IField) element, editorInputElement, hoverRegion);
			if (constantValue != null) {
				constantValue= HTMLPrinter.convertToHTMLContent(constantValue);
				IJavaProject javaProject= element.getJavaProject();
				if (JavaCore.INSERT.equals(javaProject.getOption(DefaultCodeFormatterConstants.FORMATTER_INSERT_SPACE_BEFORE_ASSIGNMENT_OPERATOR, true)))
					label.append(' ');

				label.append(constantValue);
			}
		}
		
//		if (element.getElementType() == IJavaElement.METHOD) {
//			IMethod method= (IMethod)element;
//			//TODO: add default value for annotation type members, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=249016
//		}

		String imageName= null;
		if (allowImage) {

		}

		StringBuffer buf= new StringBuffer();
		addImageAndLabel(buf, element, imageName, 16, 16, label.toString(), 20, 2);
		return buf.toString();
	}

	private static long getHeaderFlags(IJavaElement element) {
		switch (element.getElementType()) {
			case IJavaElement.LOCAL_VARIABLE:
				return LOCAL_VARIABLE_FLAGS;
			case IJavaElement.TYPE_PARAMETER:
				return TYPE_PARAMETER_FLAGS;
			default:
				return LABEL_FLAGS;
		}
	}

	/*
	 * @since 3.4
	 */

	 * Returns the constant value for the given field.
	 *
	 * @param field the field
	 * @param editorInputElement the editor input element
	 * @param hoverRegion the hover region in the editor
	 * @return the constant value for the given field or <code>null</code> if none
	 * @since 3.4
	 */
	private static String getConstantValue(IField field, ITypeRoot editorInputElement, IRegion hoverRegion) {
		if (!isStaticFinal(field))
			return null;

		ASTNode node= getHoveredASTNode(editorInputElement, hoverRegion);
		if (node == null)
			return null;
		
		Object constantValue= null;
		if (node.getNodeType() == ASTNode.SIMPLE_NAME) {
		CompilationUnit unit= SharedASTProvider.getAST(typeRoot, SharedASTProvider.WAIT_ACTIVE_ONLY, null);
		if (unit == null)
			return null;

		ASTNode node= NodeFinder.perform(unit, hoverRegion.getOffset(), hoverRegion.getLength());
		if (node != null && node.getNodeType() == ASTNode.SIMPLE_NAME) {
			IBinding binding= ((SimpleName)node).resolveBinding();
			if (binding != null && binding.getKind() == IBinding.VARIABLE) {
				IVariableBinding variableBinding= (IVariableBinding)binding;

			return null;

		if (constantValue instanceof String) {
			return getEscapedStringLiteral((String) constantValue);
			result.append('"');
			String stringConstant= (String)constantValue;
			if (stringConstant.length() > 80) {
				result.append(stringConstant.substring(0, 80));
				result.append(JavaElementLabels.ELLIPSIS_STRING);
			} else {
				result.append(stringConstant);
			}
			result.append('"');
			return result.toString();

		} else if (constantValue instanceof Character) {
			String constantResult= getEscapedCharacterLiteral(((Character) constantValue).charValue());

			char charValue= ((Character) constantValue).charValue();
			String hexString= Integer.toHexString(charValue);

		}
	}

	private static ASTNode getHoveredASTNode(ITypeRoot editorInputElement, IRegion hoverRegion) {
		if (editorInputElement == null)
			return null;

		CompilationUnit unit= SharedASTProvider.getAST(editorInputElement, SharedASTProvider.WAIT_ACTIVE_ONLY, null);
		if (unit == null)
			return null;
		
		return NodeFinder.perform(unit, hoverRegion.getOffset(),	hoverRegion.getLength());
	}

	private static String getEscapedStringLiteral(String stringValue) {
		StringLiteral stringLiteral= AST.newAST(AST.JLS3).newStringLiteral();
		stringLiteral.setLiteralValue(stringValue);
		String stringConstant= stringLiteral.getEscapedValue();
		if (stringConstant.length() > 80) {
			return stringConstant.substring(0, 80) + JavaElementLabels.ELLIPSIS_STRING;
		} else {
			return stringConstant;
		}
	}

	private static String getEscapedCharacterLiteral(char ch) {
		CharacterLiteral characterLiteral= AST.newAST(AST.JLS3).newCharacterLiteral();
		characterLiteral.setCharValue(ch);
		return characterLiteral.getEscapedValue();
	}
	
	/**
	 * Creates and returns a formatted message for the given
	 * constant with its hex value.

		return null;
	}

	public static void addImageAndLabel(StringBuffer buf, String imageSrcPath, int imageWidth, int imageHeight, String label, int labelLeft, int labelTop) {
		addImageAndLabel(buf, null, imageSrcPath, imageWidth, imageHeight, label, labelLeft, labelTop);
	}
	
	public static void addImageAndLabel(StringBuffer buf, IJavaElement element, String imageSrcPath, int imageWidth, int imageHeight, String label, int labelLeft, int labelTop) {
		buf.append("<div style='word-wrap: break-word; position: relative; "); //$NON-NLS-1$
		
		if (imageSrcPath != null) {
			buf.append("margin-left: ").append(labelLeft).append("px; "); //$NON-NLS-1$ //$NON-NLS-2$
			buf.append("padding-top: ").append(labelTop).append("px; "); //$NON-NLS-1$ //$NON-NLS-2$
		}

		buf.append("'>"); //$NON-NLS-1$
		if (imageSrcPath != null) {
			if (element != null) {
				try {
					String uri= JavaElementLinks.createURI(JavaElementLinks.OPEN_LINK_SCHEME, element);
					buf.append("<a href='").append(uri).append("'>");  //$NON-NLS-1$//$NON-NLS-2$
				} catch (URISyntaxException e) {
					element= null; // no link
				}
			}
			StringBuffer imageStyle= new StringBuffer("border:none; position: absolute; "); //$NON-NLS-1$
			imageStyle.append("width: ").append(imageWidth).append("px; "); //$NON-NLS-1$ //$NON-NLS-2$
			imageStyle.append("height: ").append(imageHeight).append("px; "); //$NON-NLS-1$ //$NON-NLS-2$
			imageStyle.append("left: ").append(- labelLeft - 1).append("px; "); //$NON-NLS-1$ //$NON-NLS-2$
			imageStyle.append("left: ").append(imageLeft).append("px; "); //$NON-NLS-1$ //$NON-NLS-2$

			// hack for broken transparent PNG support in IE 6, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=223900 :
			buf.append("<!--[if lte IE 6]><![if gte IE 5.5]>\n"); //$NON-NLS-1$
			String tooltip= JavaHoverMessages.JavadocHover_openDeclaration;
			buf.append("<span alt='").append(tooltip).append("' style=\"").append(imageStyle). //$NON-NLS-1$ //$NON-NLS-2$
					append("filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='").append(imageSrcPath).append("')\"></span>\n"); //$NON-NLS-1$ //$NON-NLS-2$
			buf.append("<![endif]><![endif]-->\n"); //$NON-NLS-1$

			buf.append("<!--[if !IE]>-->\n"); //$NON-NLS-1$
			buf.append("<img alt='").append(tooltip).append("' style='").append(imageStyle).append("' src='").append(imageSrcPath).append("'/>\n"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
			buf.append("<!--<![endif]-->\n"); //$NON-NLS-1$
			buf.append("<!--[if gte IE 7]>\n"); //$NON-NLS-1$
			buf.append("<img alt='").append(tooltip).append("' style='").append(imageStyle).append("' src='").append(imageSrcPath).append("'/>\n"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
			buf.append("<![endif]-->\n"); //$NON-NLS-1$
			if (element != null) {
				buf.append("</a>"); //$NON-NLS-1$
			}
		}
		
		buf.append("<div style='word-wrap:break-word;"); //$NON-NLS-1$
		if (imageName != null) {
			buf.append("margin-left: ").append(labelLeft).append("px; "); //$NON-NLS-1$ //$NON-NLS-2$
			buf.append("margin-top: ").append(labelTop).append("px; "); //$NON-NLS-1$ //$NON-NLS-2$
		}
		buf.append("'>"); //$NON-NLS-1$
		buf.append(label);
		
		buf.append("</div>"); //$NON-NLS-1$
	}

	public static void addAnnotations(StringBuffer buf, IJavaElement element, ITypeRoot editorInputElement, IRegion hoverRegion) {
		if (element instanceof IAnnotatable) {
			try {
				String annotationString= getAnnotations(element, editorInputElement, hoverRegion);
				if (annotationString != null) {
					buf.append("<div style='margin-bottom: 5px;'>"); //$NON-NLS-1$
					buf.append(annotationString);
					buf.append("</div>"); //$NON-NLS-1$
				}
			} catch (JavaModelException e) {
				// no annotations this time...
				buf.append("<br>"); //$NON-NLS-1$
			} catch (URISyntaxException e) {
				// no annotations this time...
				buf.append("<br>"); //$NON-NLS-1$
			}
		}
	}

	private static String getAnnotations(IJavaElement element, ITypeRoot editorInputElement, IRegion hoverRegion) throws URISyntaxException, JavaModelException {
		if (!(element instanceof IAnnotatable))
			return null;
		
		if (((IAnnotatable)element).getAnnotations().length == 0)
			return null;
		
		IBinding binding;
		ASTNode node= getHoveredASTNode(editorInputElement, hoverRegion);
		
		if (node == null) {
			ASTParser p= ASTParser.newParser(AST.JLS3);
			p.setProject(element.getJavaProject());
			try {
				binding= p.createBindings(new IJavaElement[] { element }, null)[0];
			} catch (OperationCanceledException e) {
				return null;
			}
			
		} else {
			if (node.getNodeType() != ASTNode.SIMPLE_NAME)
				return null;
			
			binding= ((SimpleName)node).resolveBinding();
		}
		
		if (binding == null)
			return null;
		
		IAnnotationBinding[] annotations= binding.getAnnotations();
		if (annotations.length == 0)
			return null;
		
		StringBuffer buf= new StringBuffer();
		for (int i= 0; i < annotations.length; i++) {
			//TODO: skip annotations that don't have an @Documented annotation?
			addAnnotation(buf, element, annotations[i]);
			buf.append("<br>"); //$NON-NLS-1$
		}
		
		return buf.toString();
	}

	private static void addAnnotation(StringBuffer buf, IJavaElement element, IAnnotationBinding annotation) throws URISyntaxException {
		String uri= JavaElementLinks.createURI(JavaElementLinks.JAVADOC_SCHEME, annotation.getAnnotationType().getJavaElement());
		buf.append('@');
		addLink(buf, uri, annotation.getName());
		
		IMemberValuePairBinding[] mvPairs= annotation.getDeclaredMemberValuePairs();
		if (mvPairs.length > 0) {
			buf.append('(');
			for (int j= 0; j < mvPairs.length; j++) {
				if (j > 0) {
					buf.append(JavaElementLabels.COMMA_STRING);
				}
				IMemberValuePairBinding mvPair= mvPairs[j];
				String memberURI= JavaElementLinks.createURI(JavaElementLinks.JAVADOC_SCHEME, mvPair.getMethodBinding().getJavaElement());
				addLink(buf, memberURI, mvPair.getName());
				buf.append('=');
				addValue(buf, element, mvPair.getValue());
			}
			buf.append(')');
		}
	}

	private static void addValue(StringBuffer buf, IJavaElement element, Object value) throws URISyntaxException {
		if (value instanceof ITypeBinding) {
			ITypeBinding typeBinding= (ITypeBinding)value;
			IJavaElement type= typeBinding.getJavaElement();
			String typeLabel= JavaElementLinks.getElementLabel(type, LABEL_FLAGS, true);
			buf.append(typeLabel).append(".class"); //$NON-NLS-1$
			
		} else if (value instanceof IVariableBinding) { // only enum constants
			IVariableBinding variableBinding= (IVariableBinding)value;
			IJavaElement variable= variableBinding.getJavaElement();
			String uri= JavaElementLinks.createURI(JavaElementLinks.JAVADOC_SCHEME, variable);
			String name= variable.getElementName();
			addLink(buf, uri, name);
				
		} else if (value instanceof IAnnotationBinding) {
			IAnnotationBinding annotationBinding= (IAnnotationBinding)value;
			addAnnotation(buf, element, annotationBinding);
			
		} else if (value instanceof String) {
			buf.append(getEscapedStringLiteral((String)value));
			
		} else if (value instanceof Character) {
			buf.append(getEscapedCharacterLiteral(((Character)value).charValue()));
			
		} else if (value instanceof Object[]) {
			Object[] values= (Object[])value;
			buf.append('{');
			for (int i= 0; i < values.length; i++) {
				if (i > 0) {
					buf.append(JavaElementLabels.COMMA_STRING);
				}
				addValue(buf, element, values[i]);
			}
			buf.append('}');
			
		} else { // primitive types (except char) or null
			buf.append(String.valueOf(value));
		}
	}

	private static StringBuffer addLink(StringBuffer buf, String uri, String label) {
		return buf.append(JavaElementLinks.createLink(uri, label));
	}
}





import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.ILocalVariable;


		public String getElementName(IJavaElement element) {
			String elementName= element.getElementName();
			if (element.equals(fElement)) { // linking to the member itself would be a no-op
				return elementName;
			}
			if (elementName.length() == 0) { // anonymous

			}
			try {
				String uri= createURI(JAVADOC_SCHEME, element);
				return createHeaderLink(uri, elementName);
			} catch (URISyntaxException e) {
				JavaPlugin.log(e);
				return elementName;
			}
		}

		private String createLink(String uri, String elementName) {
			return "<a class='header' href='" + uri + ("'>" + elementName + "</a>"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}

		protected String getGT() {
			return "&gt;"; //$NON-NLS-1$
		}

			String typeName= super.getSimpleTypeName(enclosingElement, typeSig);
			try {
				String uri= createURI(JAVADOC_SCHEME, enclosingElement, typeName, null, null);
				return createHeaderLink(uri, typeName);
			} catch (URISyntaxException e) {
				JavaPlugin.log(e);
				return typeName;

					JavaPlugin.log(e);
				}
			}
			if (element instanceof IAnnotation) {
				element= element.getParent();
			}
			
			if (element instanceof ILocalVariable) {
				element= element.getAncestor(IJavaElement.TYPE);
			} else if (element instanceof ITypeParameter) {

	}

	/**
	 * Creates a link with the given URI and label text.
	 * 
	 * @param uri the URI
	 * @param label the label
	 * @return the HTML link
	 * @since 3.6
	 */
	public static String createLink(String uri, String label) {
		return "<a href='" + uri + "'>" + label + "</a>"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}
	
	/**
	 * Creates a header link with the given URI and label text.
	 * 
	 * @param uri the URI
	 * @param label the label
	 * @return the HTML link
	 * @since 3.6
	 */
	public static String createHeaderLink(String uri, String label) {
		return "<a class='header' href='" + uri + "'>" + label + "</a>"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}
	
	/**
	 * Returns the label for a Java element with the flags as defined by {@link JavaElementLabels}.
	 * Referenced element names in the label (except the given element's name) are rendered as 
	 * header links.
	 *
	 * @param element the element to render
	 * @param flags the rendering flags

	 * @since 3.5
	 */
	public static String getElementLabel(IJavaElement element, long flags) {
		return getElementLabel(element, flags, false);
	}

	/**
	 * Returns the label for a Java element with the flags as defined by {@link JavaElementLabels}.
	 * Referenced element names in the label are rendered as header links.
	 * If <code>linkAllNames</code> is <code>false</code>, don't link the name of the given element
	 *
	 * @param element the element to render
	 * @param flags the rendering flags
	 * @param linkAllNames if <code>true</code>, link all names; if <code>false</code>, link all names except original element's name
	 * @return the label of the Java element
	 * @since 3.6
	 */
	public static String getElementLabel(IJavaElement element, long flags, boolean linkAllNames) {
		StringBuffer buf= new StringBuffer();

		if (!Strings.USE_TEXT_PROCESSOR) {
			new JavaElementLinkedLabelComposer(linkAllNames ? null : element, buf).appendElementLabel(element, flags);
			return Strings.markJavaElementLabelLTR(buf.toString());
		} else {
			String label= JavaElementLabels.getElementLabel(element, flags);

Return to bug 236850

Lines 1-5 Link Here

(-)ui/org/eclipse/jdt/internal/ui/infoviews/JavadocView.java (-3 / +31 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 76-81 Link Here
76	import org.eclipse.jface.text.IDocumentExtension3;	76	import org.eclipse.jface.text.IDocumentExtension3;
77	import org.eclipse.jface.text.ITextSelection;	77	import org.eclipse.jface.text.ITextSelection;
78	import org.eclipse.jface.text.ITypedRegion;	78	import org.eclipse.jface.text.ITypedRegion;
		79	import org.eclipse.jface.text.Region;
79	import org.eclipse.jface.text.TextPresentation;	80	import org.eclipse.jface.text.TextPresentation;
80	import org.eclipse.jface.text.TextSelection;	81	import org.eclipse.jface.text.TextSelection;
81	import org.eclipse.jface.text.TextUtilities;	82	import org.eclipse.jface.text.TextUtilities;
Lines 103-114 Link Here
103	import org.eclipse.jdt.core.IField;	104	import org.eclipse.jdt.core.IField;
104	import org.eclipse.jdt.core.IJavaElement;	105	import org.eclipse.jdt.core.IJavaElement;
105	import org.eclipse.jdt.core.IJavaProject;	106	import org.eclipse.jdt.core.IJavaProject;
		107	import org.eclipse.jdt.core.ILocalVariable;
106	import org.eclipse.jdt.core.IMember;	108	import org.eclipse.jdt.core.IMember;
107	import org.eclipse.jdt.core.IOpenable;	109	import org.eclipse.jdt.core.IOpenable;
108	import org.eclipse.jdt.core.IPackageFragmentRoot;	110	import org.eclipse.jdt.core.IPackageFragmentRoot;
		111	import org.eclipse.jdt.core.ISourceRange;
109	import org.eclipse.jdt.core.ITypeRoot;	112	import org.eclipse.jdt.core.ITypeRoot;
110	import org.eclipse.jdt.core.JavaCore;	113	import org.eclipse.jdt.core.JavaCore;
111	import org.eclipse.jdt.core.JavaModelException;	114	import org.eclipse.jdt.core.JavaModelException;
		115	import org.eclipse.jdt.core.SourceRange;
112	import org.eclipse.jdt.core.dom.AST;	116	import org.eclipse.jdt.core.dom.AST;
113	import org.eclipse.jdt.core.dom.ASTNode;	117	import org.eclipse.jdt.core.dom.ASTNode;
114	import org.eclipse.jdt.core.dom.ASTParser;	118	import org.eclipse.jdt.core.dom.ASTParser;
Lines 893-898 Link Here
893	* @see AbstractInfoView#computeInput(Object)	897	* @see AbstractInfoView#computeInput(Object)
894	*/	898	*/
895	protected Object computeInput(Object input) {	899	protected Object computeInput(Object input) {
		900	//TODO: never used?
896	if (getControl() == null \|\| ! (input instanceof IJavaElement))	901	if (getControl() == null \|\| ! (input instanceof IJavaElement))
897	return null;	902	return null;
898		903
Lines 1062-1067 Link Here
1062	}	1067	}
1063		1068
1064	HTMLPrinter.addSmallHeader(buffer, getInfoText(member, constantValue, true));	1069	HTMLPrinter.addSmallHeader(buffer, getInfoText(member, constantValue, true));
		1070
		1071	try {
		1072	ISourceRange nameRange= ((IMember)curr).getNameRange();
		1073	if (SourceRange.isAvailable(nameRange)) {
		1074	ITypeRoot typeRoot= ((IMember)curr).getTypeRoot();
		1075	Region hoverRegion= new Region(nameRange.getOffset(), nameRange.getLength());
		1076	buffer.append("<br>"); //$NON-NLS-1$
		1077	JavadocHover.addAnnotations(buffer, curr, typeRoot, hoverRegion);
		1078	}
		1079	} catch (JavaModelException e) {
		1080	// no annotations this time...
		1081	}
		1082
1065	Reader reader;	1083	Reader reader;
1066	try {	1084	try {
1067	String content= JavadocContentAccess2.getHTMLContent(member, true);	1085	String content= JavadocContentAccess2.getHTMLContent(member, true);
Lines 1095-1102 Link Here
1095	if (reader != null) {	1113	if (reader != null) {
1096	HTMLPrinter.addParagraph(buffer, reader);	1114	HTMLPrinter.addParagraph(buffer, reader);
1097	}	1115	}
		1116
1098	} else if (curr.getElementType() == IJavaElement.LOCAL_VARIABLE \|\| curr.getElementType() == IJavaElement.TYPE_PARAMETER) {	1117	} else if (curr.getElementType() == IJavaElement.LOCAL_VARIABLE \|\| curr.getElementType() == IJavaElement.TYPE_PARAMETER) {
1099	HTMLPrinter.addSmallHeader(buffer, getInfoText(curr, null, true));	1118	HTMLPrinter.addSmallHeader(buffer, getInfoText(curr, null, true));
		1119	if (curr instanceof ILocalVariable) {
		1120	ISourceRange nameRange= ((ILocalVariable) curr).getNameRange();
		1121	ITypeRoot typeRoot= ((IMember) curr.getParent()).getTypeRoot();
		1122	Region hoverRegion= new Region(nameRange.getOffset(), nameRange.getLength());
		1123	buffer.append("<br>"); //$NON-NLS-1$
		1124	JavadocHover.addAnnotations(buffer, curr, typeRoot, hoverRegion);
		1125	}
1100	}	1126	}
1101	}	1127	}
1102		1128
Lines 1137-1143 Link Here
1137	}	1163	}
1138		1164
1139	StringBuffer buf= new StringBuffer();	1165	StringBuffer buf= new StringBuffer();
1140	JavadocHover.addImageAndLabel(buf, imageName, 16, 16, 8, 5, label.toString(), 22, 0);	1166	JavadocHover.addImageAndLabel(buf, imageName, 16, 16, label.toString(), 20, 2);
1141	return buf.toString();	1167	return buf.toString();
1142	}	1168	}
1143		1169
Lines 1288-1293 Link Here
1288	return null;	1314	return null;
1289		1315
1290	VariableDeclarationFragment fieldDecl= ASTNodeSearchUtil.getFieldDeclarationFragmentNode(constantField, ast);	1316	VariableDeclarationFragment fieldDecl= ASTNodeSearchUtil.getFieldDeclarationFragmentNode(constantField, ast);
		1317	if (fieldDecl == null)
		1318	return null;
1291	Expression initializer= fieldDecl.getInitializer();	1319	Expression initializer= fieldDecl.getInitializer();
1292	if (initializer == null)	1320	if (initializer == null)
1293	return null;	1321	return null;
Lines 1491-1497 Link Here
1491	* @see org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks.ILinkHandler#handleExternalLink(java.net.URL, org.eclipse.swt.widgets.Display)	1519	* @see org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks.ILinkHandler#handleExternalLink(java.net.URL, org.eclipse.swt.widgets.Display)
1492	*/	1520	*/
1493	public boolean handleExternalLink(final URL url, Display display) {	1521	public boolean handleExternalLink(final URL url, Display display) {
1494	if (fCurrent == null \|\| !url.equals(fCurrent.getInputElement())) {	1522	if (fCurrent == null \|\| (fCurrent.getInputElement() instanceof URL && !url.toExternalForm().equals(((URL) fCurrent.getInputElement()).toExternalForm()))) {
1495	fCurrent= new URLBrowserInput(fCurrent, url);	1523	fCurrent= new URLBrowserInput(fCurrent, url);
1496		1524
1497	if (fBackAction != null) {	1525	if (fBackAction != null) {

Lines 24-29 Link Here

(-)ui/org/eclipse/jdt/internal/ui/viewsupport/JavaElementLinks.java (-10 / +50 lines)
24		24
25	import org.eclipse.core.runtime.IProgressMonitor;	25	import org.eclipse.core.runtime.IProgressMonitor;
26		26
		27	import org.eclipse.jdt.core.IAnnotation;
27	import org.eclipse.jdt.core.IField;	28	import org.eclipse.jdt.core.IField;
28	import org.eclipse.jdt.core.IJavaElement;	29	import org.eclipse.jdt.core.IJavaElement;
29	import org.eclipse.jdt.core.ILocalVariable;	30	import org.eclipse.jdt.core.ILocalVariable;
Lines 103-109 Link Here
103		104
104	public String getElementName(IJavaElement element) {	105	public String getElementName(IJavaElement element) {
105	String elementName= element.getElementName();	106	String elementName= element.getElementName();
106	if (fElement.equals(element)) { // linking to the member itself would be a no-op	107	if (element.equals(fElement)) { // linking to the member itself would be a no-op
107	return elementName;	108	return elementName;
108	}	109	}
109	if (elementName.length() == 0) { // anonymous	110	if (elementName.length() == 0) { // anonymous
Lines 111-127 Link Here
111	}	112	}
112	try {	113	try {
113	String uri= createURI(JAVADOC_SCHEME, element);	114	String uri= createURI(JAVADOC_SCHEME, element);
114	return createLink(uri, elementName);	115	return createHeaderLink(uri, elementName);
115	} catch (URISyntaxException e) {	116	} catch (URISyntaxException e) {
116	JavaPlugin.log(e);	117	JavaPlugin.log(e);
117	return elementName;	118	return elementName;
118	}	119	}
119	}	120	}
120		121
121	private String createLink(String uri, String elementName) {
122	return "<a class='header' href='" + uri + ("'>" + elementName + "</a>"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
123	}
124
125	protected String getGT() {	122	protected String getGT() {
126	return ">"; //$NON-NLS-1$	123	return ">"; //$NON-NLS-1$
127	}	124	}
Lines 134-140 Link Here
134	String typeName= super.getSimpleTypeName(enclosingElement, typeSig);	131	String typeName= super.getSimpleTypeName(enclosingElement, typeSig);
135	try {	132	try {
136	String uri= createURI(JAVADOC_SCHEME, enclosingElement, typeName, null, null);	133	String uri= createURI(JAVADOC_SCHEME, enclosingElement, typeName, null, null);
137	return createLink(uri, typeName);	134	return createHeaderLink(uri, typeName);
138	} catch (URISyntaxException e) {	135	} catch (URISyntaxException e) {
139	JavaPlugin.log(e);	136	JavaPlugin.log(e);
140	return typeName;	137	return typeName;
Lines 319-325 Link Here
319	JavaPlugin.log(e);	316	JavaPlugin.log(e);
320	}	317	}
321	}	318	}
322		319	if (element instanceof IAnnotation) {
		320	element= element.getParent();
		321	}
		322
323	if (element instanceof ILocalVariable) {	323	if (element instanceof ILocalVariable) {
324	element= element.getAncestor(IJavaElement.TYPE);	324	element= element.getAncestor(IJavaElement.TYPE);
325	} else if (element instanceof ITypeParameter) {	325	} else if (element instanceof ITypeParameter) {
Lines 459-466 Link Here
459	}	459	}
460		460
461	/**	461	/**
		462	* Creates a link with the given URI and label text.
		463	*
		464	* @param uri the URI
		465	* @param label the label
		466	* @return the HTML link
		467	* @since 3.6
		468	*/
		469	public static String createLink(String uri, String label) {
		470	return "<a href='" + uri + "'>" + label + "</a>"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		471	}
		472
		473	/**
		474	* Creates a header link with the given URI and label text.
		475	*
		476	* @param uri the URI
		477	* @param label the label
		478	* @return the HTML link
		479	* @since 3.6
		480	*/
		481	public static String createHeaderLink(String uri, String label) {
		482	return "<a class='header' href='" + uri + "'>" + label + "</a>"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		483	}
		484
		485	/**
462	* Returns the label for a Java element with the flags as defined by {@link JavaElementLabels}.	486	* Returns the label for a Java element with the flags as defined by {@link JavaElementLabels}.
463	* Referenced element names in the label (except the given element's name) are rendered as Javadoc links.	487	* Referenced element names in the label (except the given element's name) are rendered as
		488	* header links.
464	*	489	*
465	* @param element the element to render	490	* @param element the element to render
466	* @param flags the rendering flags	491	* @param flags the rendering flags
Lines 468-477 Link Here
468	* @since 3.5	493	* @since 3.5
469	*/	494	*/
470	public static String getElementLabel(IJavaElement element, long flags) {	495	public static String getElementLabel(IJavaElement element, long flags) {
		496	return getElementLabel(element, flags, false);
		497	}
		498
		499	/**
		500	* Returns the label for a Java element with the flags as defined by {@link JavaElementLabels}.
		501	* Referenced element names in the label are rendered as header links.
		502	* If <code>linkAllNames</code> is <code>false</code>, don't link the name of the given element
		503	*
		504	* @param element the element to render
		505	* @param flags the rendering flags
		506	* @param linkAllNames if <code>true</code>, link all names; if <code>false</code>, link all names except original element's name
		507	* @return the label of the Java element
		508	* @since 3.6
		509	*/
		510	public static String getElementLabel(IJavaElement element, long flags, boolean linkAllNames) {
471	StringBuffer buf= new StringBuffer();	511	StringBuffer buf= new StringBuffer();
472		512
473	if (!Strings.USE_TEXT_PROCESSOR) {	513	if (!Strings.USE_TEXT_PROCESSOR) {
474	new JavaElementLinkedLabelComposer(element, buf).appendElementLabel(element, flags);	514	new JavaElementLinkedLabelComposer(linkAllNames ? null : element, buf).appendElementLabel(element, flags);
475	return Strings.markJavaElementLabelLTR(buf.toString());	515	return Strings.markJavaElementLabelLTR(buf.toString());
476	} else {	516	} else {
477	String label= JavaElementLabels.getElementLabel(element, flags);	517	String label= JavaElementLabels.getElementLabel(element, flags);