| /******************************************************************************* |
| * Copyright (c) 2004 - 2005 University Of British Columbia 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: |
| * University Of British Columbia - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.mylar.java.ui.editor; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.jdt.core.ElementChangedEvent; |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.IElementChangedListener; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IJavaElementDelta; |
| import org.eclipse.jdt.core.IMember; |
| import org.eclipse.jdt.core.IParent; |
| import org.eclipse.jdt.core.ISourceRange; |
| import org.eclipse.jdt.core.ISourceReference; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.core.ToolFactory; |
| import org.eclipse.jdt.core.compiler.IScanner; |
| import org.eclipse.jdt.core.compiler.ITerminalSymbols; |
| import org.eclipse.jdt.core.compiler.InvalidInputException; |
| import org.eclipse.jdt.internal.ui.JavaPlugin; |
| import org.eclipse.jdt.internal.ui.javaeditor.ClassFileEditor; |
| import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor; |
| import org.eclipse.jdt.internal.ui.javaeditor.IClassFileEditorInput; |
| import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor; |
| import org.eclipse.jdt.internal.ui.text.DocumentCharacterIterator; |
| import org.eclipse.jdt.ui.IWorkingCopyManager; |
| import org.eclipse.jdt.ui.text.folding.IJavaFoldingStructureProvider; |
| import org.eclipse.jface.text.Assert; |
| import org.eclipse.jface.text.BadLocationException; |
| import org.eclipse.jface.text.IDocument; |
| import org.eclipse.jface.text.IRegion; |
| import org.eclipse.jface.text.Position; |
| import org.eclipse.jface.text.Region; |
| import org.eclipse.jface.text.source.Annotation; |
| import org.eclipse.jface.text.source.IAnnotationModel; |
| import org.eclipse.jface.text.source.projection.IProjectionListener; |
| import org.eclipse.jface.text.source.projection.IProjectionPosition; |
| import org.eclipse.jface.text.source.projection.ProjectionAnnotation; |
| import org.eclipse.jface.text.source.projection.ProjectionAnnotationModel; |
| import org.eclipse.jface.text.source.projection.ProjectionViewer; |
| import org.eclipse.mylar.core.IMylarElement; |
| import org.eclipse.mylar.core.MylarPlugin; |
| import org.eclipse.mylar.ui.MylarUiPlugin; |
| import org.eclipse.ui.texteditor.IDocumentProvider; |
| import org.eclipse.ui.texteditor.ITextEditor; |
| |
| |
| /** |
| * Copied from: DefaultJavaFoldingStructureProvider |
| * |
| * @author Mik Kersten |
| */ |
| @SuppressWarnings("unchecked") |
| public class AutoFoldingStructureProvider implements IProjectionListener, IJavaFoldingStructureProvider { |
| |
| public static final String ID = "org.eclipse.mylar.java.ui.editor.foldingprovider"; |
| |
| private void computeAdditions(IJavaElement element, Map map) { |
| boolean createProjection= false; |
| boolean collapse= false; |
| switch (element.getElementType()) { |
| case IJavaElement.IMPORT_CONTAINER: |
| collapse = true; |
| // collapse= fAllowCollapsing && fCollapseImportContainer; |
| createProjection= true; |
| break; |
| case IJavaElement.TYPE: |
| if (isInnerType((IType)element)) { |
| IMylarElement node = MylarPlugin.getContextManager().getElement(element.getHandleIdentifier()); |
| if (!MylarUiPlugin.getDefault().isGlobalFoldingEnabled()) { |
| collapse = false; |
| } else if (node == null || node.getDegreeOfInterest().isInteresting()) { |
| collapse = false; |
| } else { |
| collapse = true; |
| } |
| createProjection= true; |
| break; |
| } |
| // collapse= fAllowCollapsing && fCollapseInnerTypes && isInnerType((IType) element); |
| createProjection= true; |
| break; |
| case IJavaElement.METHOD: |
| IMylarElement node = MylarPlugin.getContextManager().getElement(element.getHandleIdentifier()); |
| if (!MylarUiPlugin.getDefault().isGlobalFoldingEnabled()) { |
| collapse = false; |
| } else if (node == null || node.getDegreeOfInterest().isInteresting()) { |
| collapse = false; |
| } else { |
| collapse = true; |
| } |
| createProjection= true; |
| break; |
| default: |
| collapse = true; |
| // collapse= fAllowCollapsing && fCollapseMethods; |
| // createProjection= true; |
| // break; |
| } |
| |
| if (createProjection) { |
| IRegion[] regions= computeProjectionRanges(element); |
| if (regions != null) { |
| // comments |
| for (int i= 0; i < regions.length - 1; i++) { |
| Position position= createProjectionPosition(regions[i], null); |
| boolean commentCollapse; |
| if (position != null) { |
| if (i == 0 && (regions.length > 2 || fHasHeaderComment) && element == fFirstType) { |
| commentCollapse= fAllowCollapsing && fCollapseHeaderComments; |
| } else { |
| commentCollapse= fAllowCollapsing && fCollapseJavadoc; |
| } |
| map.put(new JavaProjectionAnnotation(element, commentCollapse, true), position); |
| } |
| } |
| // code |
| Position position= createProjectionPosition(regions[regions.length - 1], element); |
| if (position != null) |
| map.put(new JavaProjectionAnnotation(element, collapse, false), position); |
| } |
| } |
| } |
| |
| private void initializePreferences() { |
| // IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore(); |
| // fCollapseInnerTypes= store.getBoolean(PreferenceConstants.EDITOR_FOLDING_INNERTYPES); |
| // fCollapseImportContainer= store.getBoolean(PreferenceConstants.EDITOR_FOLDING_IMPORTS); |
| fCollapseJavadoc= true ;//store.getBoolean(PreferenceConstants.EDITOR_FOLDING_JAVADOC); |
| // fCollapseMethods= store.getBoolean(PreferenceConstants.EDITOR_FOLDING_METHODS); XXX never used |
| fCollapseHeaderComments= true; //store.getBoolean(PreferenceConstants.EDITOR_FOLDING_HEADERS); |
| } |
| |
| /* |
| ************ COPIED FROM: DefaultJavaFoldingStructureProvider **************** |
| */ |
| |
| private static final class JavaProjectionAnnotation extends ProjectionAnnotation { |
| |
| private IJavaElement fJavaElement; |
| private boolean fIsComment; |
| |
| public JavaProjectionAnnotation(IJavaElement element, boolean isCollapsed, boolean isComment) { |
| super(isCollapsed); |
| fJavaElement= element; |
| fIsComment= isComment; |
| } |
| |
| public IJavaElement getElement() { |
| return fJavaElement; |
| } |
| |
| public void setElement(IJavaElement element) { |
| fJavaElement= element; |
| } |
| |
| public boolean isComment() { |
| return fIsComment; |
| } |
| |
| public void setIsComment(boolean isComment) { |
| fIsComment= isComment; |
| } |
| |
| @Override |
| public String toString() { |
| return "JavaProjectionAnnotation:\n" + //$NON-NLS-1$ |
| "\telement: \t"+fJavaElement.toString()+"\n" + //$NON-NLS-1$ //$NON-NLS-2$ |
| "\tcollapsed: \t" + isCollapsed() + "\n" + //$NON-NLS-1$ //$NON-NLS-2$ |
| "\tcomment: \t" + fIsComment + "\n"; //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } |
| |
| private static final class Tuple { |
| JavaProjectionAnnotation annotation; |
| Position position; |
| Tuple(JavaProjectionAnnotation annotation, Position position) { |
| this.annotation= annotation; |
| this.position= position; |
| } |
| } |
| |
| private class ElementChangedListener implements IElementChangedListener { |
| |
| /* |
| * @see org.eclipse.jdt.core.IElementChangedListener#elementChanged(org.eclipse.jdt.core.ElementChangedEvent) |
| */ |
| public void elementChanged(ElementChangedEvent e) { |
| IJavaElementDelta delta= findElement(fInput, e.getDelta()); |
| if (delta != null) |
| processDelta(delta); |
| } |
| |
| private IJavaElementDelta findElement(IJavaElement target, IJavaElementDelta delta) { |
| |
| if (delta == null || target == null) |
| return null; |
| |
| IJavaElement element= delta.getElement(); |
| |
| if (element.getElementType() > IJavaElement.CLASS_FILE) |
| return null; |
| |
| if (target.equals(element)) |
| return delta; |
| |
| IJavaElementDelta[] children= delta.getAffectedChildren(); |
| |
| for (int i= 0; i < children.length; i++) { |
| IJavaElementDelta d= findElement(target, children[i]); |
| if (d != null) |
| return d; |
| } |
| |
| return null; |
| } |
| } |
| |
| /** |
| * Projection position that will return two foldable regions: one folding away |
| * the region from after the '/**' to the beginning of the content, the other |
| * from after the first content line until after the comment. |
| * |
| * @since 3.1 |
| */ |
| private static final class CommentPosition extends Position implements IProjectionPosition { |
| CommentPosition(int offset, int length) { |
| super(offset, length); |
| } |
| |
| /* |
| * @see org.eclipse.jface.text.source.projection.IProjectionPosition#computeFoldingRegions(org.eclipse.jface.text.IDocument) |
| */ |
| public IRegion[] computeProjectionRegions(IDocument document) throws BadLocationException { |
| DocumentCharacterIterator sequence= new DocumentCharacterIterator(document, offset, offset + length); |
| int prefixEnd= 0; |
| int contentStart= findFirstContent(sequence, prefixEnd); |
| |
| int firstLine= document.getLineOfOffset(offset + prefixEnd); |
| int captionLine= document.getLineOfOffset(offset + contentStart); |
| int lastLine= document.getLineOfOffset(offset + length); |
| |
| Assert.isTrue(firstLine <= captionLine, "first folded line is greater than the caption line"); //$NON-NLS-1$ |
| Assert.isTrue(captionLine <= lastLine, "caption line is greater than the last folded line"); //$NON-NLS-1$ |
| |
| IRegion preRegion; |
| if (firstLine < captionLine) { |
| // preRegion= new Region(offset + prefixEnd, contentStart - prefixEnd); |
| int preOffset= document.getLineOffset(firstLine); |
| IRegion preEndLineInfo= document.getLineInformation(captionLine); |
| int preEnd= preEndLineInfo.getOffset(); |
| preRegion= new Region(preOffset, preEnd - preOffset); |
| } else { |
| preRegion= null; |
| } |
| |
| if (captionLine < lastLine) { |
| int postOffset= document.getLineOffset(captionLine + 1); |
| IRegion postRegion= new Region(postOffset, offset + length - postOffset); |
| |
| if (preRegion == null) |
| return new IRegion[] { postRegion }; |
| |
| return new IRegion[] { preRegion, postRegion }; |
| } |
| |
| if (preRegion != null) |
| return new IRegion[] { preRegion }; |
| |
| return null; |
| } |
| |
| /** |
| * Finds the offset of the first identifier part within <code>content</code>. |
| * Returns 0 if none is found. |
| * |
| * @param content the content to search |
| * @return the first index of a unicode identifier part, or zero if none can |
| * be found |
| */ |
| private int findFirstContent(final CharSequence content, int prefixEnd) { |
| int lenght= content.length(); |
| for (int i= prefixEnd; i < lenght; i++) { |
| if (Character.isUnicodeIdentifierPart(content.charAt(i))) |
| return i; |
| } |
| return 0; |
| } |
| |
| // /** |
| // * Finds the offset of the first identifier part within <code>content</code>. |
| // * Returns 0 if none is found. |
| // * |
| // * @param content the content to search |
| // * @return the first index of a unicode identifier part, or zero if none can |
| // * be found |
| // */ |
| // private int findPrefixEnd(final CharSequence content) { |
| // // return the index after the leading '/*' or '/**' |
| // int len= content.length(); |
| // int i= 0; |
| // while (i < len && isWhiteSpace(content.charAt(i))) |
| // i++; |
| // if (len >= i + 2 && content.charAt(i) == '/' && content.charAt(i + 1) == '*') |
| // if (len >= i + 3 && content.charAt(i + 2) == '*') |
| // return i + 3; |
| // else |
| // return i + 2; |
| // else |
| // return i; |
| // } |
| // |
| // private boolean isWhiteSpace(char c) { |
| // return c == ' ' || c == '\t'; |
| // } |
| |
| /* |
| * @see org.eclipse.jface.text.source.projection.IProjectionPosition#computeCaptionOffset(org.eclipse.jface.text.IDocument) |
| */ |
| public int computeCaptionOffset(IDocument document) { |
| // return 0; |
| DocumentCharacterIterator sequence= new DocumentCharacterIterator(document, offset, offset + length); |
| return findFirstContent(sequence, 0); |
| } |
| } |
| |
| /** |
| * Projection position that will return two foldable regions: one folding away |
| * the lines before the one containing the simple name of the java element, one |
| * folding away any lines after the caption. |
| * |
| * @since 3.1 |
| */ |
| private static final class JavaElementPosition extends Position implements IProjectionPosition { |
| |
| private final IMember fMember; |
| |
| public JavaElementPosition(int offset, int length, IMember member) { |
| super(offset, length); |
| Assert.isNotNull(member); |
| fMember= member; |
| } |
| |
| /* |
| * @see org.eclipse.jface.text.source.projection.IProjectionPosition#computeFoldingRegions(org.eclipse.jface.text.IDocument) |
| */ |
| public IRegion[] computeProjectionRegions(IDocument document) throws BadLocationException { |
| int nameStart= offset; |
| try { |
| /* The member's name range may not be correct. However, |
| * reconciling would trigger another element delta which would |
| * lead to reentrant situations. Therefore, we optimistically |
| * assume that the name range is correct, but double check the |
| * received lines below. */ |
| ISourceRange nameRange= fMember.getNameRange(); |
| if (nameRange != null) |
| nameStart= nameRange.getOffset(); |
| |
| } catch (JavaModelException e) { |
| // ignore and use default |
| } |
| |
| int firstLine= document.getLineOfOffset(offset); |
| int captionLine= document.getLineOfOffset(nameStart); |
| int lastLine= document.getLineOfOffset(offset + length); |
| |
| /* see comment above - adjust the caption line to be inside the |
| * entire folded region, and rely on later element deltas to correct |
| * the name range. */ |
| if (captionLine < firstLine) |
| captionLine= firstLine; |
| if (captionLine > lastLine) |
| captionLine= lastLine; |
| |
| IRegion preRegion; |
| if (firstLine < captionLine) { |
| int preOffset= document.getLineOffset(firstLine); |
| IRegion preEndLineInfo= document.getLineInformation(captionLine); |
| int preEnd= preEndLineInfo.getOffset(); |
| preRegion= new Region(preOffset, preEnd - preOffset); |
| } else { |
| preRegion= null; |
| } |
| |
| if (captionLine < lastLine) { |
| int postOffset= document.getLineOffset(captionLine + 1); |
| IRegion postRegion= new Region(postOffset, offset + length - postOffset); |
| |
| if (preRegion == null) |
| return new IRegion[] { postRegion }; |
| |
| return new IRegion[] { preRegion, postRegion }; |
| } |
| |
| if (preRegion != null) |
| return new IRegion[] { preRegion }; |
| |
| return null; |
| } |
| |
| /* |
| * @see org.eclipse.jface.text.source.projection.IProjectionPosition#computeCaptionOffset(org.eclipse.jface.text.IDocument) |
| */ |
| public int computeCaptionOffset(IDocument document) throws BadLocationException { |
| int nameStart= offset; |
| try { |
| // need a reconcile here? |
| ISourceRange nameRange= fMember.getNameRange(); |
| if (nameRange != null) |
| nameStart= nameRange.getOffset(); |
| } catch (JavaModelException e) { |
| // ignore and use default |
| } |
| |
| return nameStart - offset; |
| } |
| |
| } |
| |
| private IDocument fCachedDocument; |
| |
| private ITextEditor fEditor; |
| private ProjectionViewer fViewer; |
| private IJavaElement fInput; |
| private IElementChangedListener fElementListener; |
| |
| private boolean fAllowCollapsing= false; |
| private boolean fCollapseJavadoc= false; |
| // private boolean fCollapseImportContainer= true; |
| // private boolean fCollapseInnerTypes= true; |
| // private boolean fCollapseMethods= false; |
| |
| private boolean fCollapseHeaderComments= true; |
| |
| /* caches for header comment extraction. */ |
| private IType fFirstType; |
| private boolean fHasHeaderComment; |
| |
| |
| public AutoFoldingStructureProvider() { |
| // no initialization needed |
| } |
| |
| public void install(ITextEditor editor, ProjectionViewer viewer) { |
| if (editor instanceof JavaEditor) { |
| fEditor= editor; |
| fViewer= viewer; |
| fViewer.addProjectionListener(this); |
| } |
| } |
| |
| public void uninstall() { |
| if (isInstalled()) { |
| projectionDisabled(); |
| fViewer.removeProjectionListener(this); |
| fViewer= null; |
| fEditor= null; |
| } |
| } |
| |
| protected boolean isInstalled() { |
| return fEditor != null; |
| } |
| |
| /* |
| * @see org.eclipse.jface.text.source.projection.IProjectionListener#projectionEnabled() |
| */ |
| public void projectionEnabled() { |
| // http://home.ott.oti.com/teams/wswb/anon/out/vms/index.html |
| // projectionEnabled messages are not always paired with projectionDisabled |
| // i.e. multiple enabled messages may be sent out. |
| // we have to make sure that we disable first when getting an enable |
| // message. |
| projectionDisabled(); |
| |
| if (fEditor instanceof JavaEditor) { |
| initialize(); |
| fElementListener= new ElementChangedListener(); |
| JavaCore.addElementChangedListener(fElementListener); |
| } |
| } |
| |
| /* |
| * @see org.eclipse.jface.text.source.projection.IProjectionListener#projectionDisabled() |
| */ |
| public void projectionDisabled() { |
| fCachedDocument= null; |
| if (fElementListener != null) { |
| JavaCore.removeElementChangedListener(fElementListener); |
| fElementListener= null; |
| } |
| } |
| |
| public void initialize() { |
| |
| if (!isInstalled()) |
| return; |
| |
| initializePreferences(); |
| |
| try { |
| |
| IDocumentProvider provider= fEditor.getDocumentProvider(); |
| fCachedDocument= provider.getDocument(fEditor.getEditorInput()); |
| fAllowCollapsing= true; |
| |
| fFirstType= null; |
| fHasHeaderComment= false; |
| |
| if (fEditor instanceof CompilationUnitEditor) { |
| IWorkingCopyManager manager= JavaPlugin.getDefault().getWorkingCopyManager(); |
| fInput= manager.getWorkingCopy(fEditor.getEditorInput()); |
| } else if (fEditor instanceof ClassFileEditor) { |
| IClassFileEditorInput editorInput= (IClassFileEditorInput) fEditor.getEditorInput(); |
| fInput= editorInput.getClassFile(); |
| } |
| |
| if (fInput != null) { |
| ProjectionAnnotationModel model= (ProjectionAnnotationModel) fEditor.getAdapter(ProjectionAnnotationModel.class); |
| if (model != null) { |
| |
| if (fInput instanceof ICompilationUnit) { |
| ICompilationUnit unit= (ICompilationUnit) fInput; |
| synchronized (unit) { |
| try { |
| unit.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| } catch (JavaModelException e) { |
| MylarPlugin.log(e, "could not initialize"); |
| } |
| } |
| } |
| |
| Map additions= computeAdditions((IParent) fInput); |
| model.removeAllAnnotations(); |
| model.replaceAnnotations(null, additions); |
| } |
| } |
| |
| } finally { |
| fCachedDocument= null; |
| fAllowCollapsing= false; |
| |
| fFirstType= null; |
| fHasHeaderComment= false; |
| } |
| } |
| |
| |
| private Map computeAdditions(IParent parent) { |
| Map map= new LinkedHashMap(); // use a linked map to maintain ordering of comments |
| try { |
| computeAdditions(parent.getChildren(), map); |
| } catch (JavaModelException e) { |
| } |
| return map; |
| } |
| |
| private void computeAdditions(IJavaElement[] elements, Map map) throws JavaModelException { |
| for (int i= 0; i < elements.length; i++) { |
| IJavaElement element= elements[i]; |
| |
| computeAdditions(element, map); |
| |
| if (element instanceof IParent) { |
| IParent parent= (IParent) element; |
| computeAdditions(parent.getChildren(), map); |
| } |
| } |
| } |
| |
| private boolean isInnerType(IType type) { |
| |
| try { |
| return type.isMember(); |
| } catch (JavaModelException x) { |
| IJavaElement parent= type.getParent(); |
| if (parent != null) { |
| int parentType= parent.getElementType(); |
| return (parentType != IJavaElement.COMPILATION_UNIT && parentType != IJavaElement.CLASS_FILE); |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Computes the projection ranges for a given <code>IJavaElement</code>. |
| * More than one range may be returned if the element has a leading comment |
| * which gets folded separately. If there are no foldable regions, |
| * <code>null</code> is returned. |
| * |
| * @param element the java element that can be folded |
| * @return the regions to be folded, or <code>null</code> if there are |
| * none |
| */ |
| private IRegion[] computeProjectionRanges(IJavaElement element) { |
| |
| try { |
| if (element instanceof ISourceReference) { |
| ISourceReference reference= (ISourceReference) element; |
| ISourceRange range= reference.getSourceRange(); |
| |
| String contents= reference.getSource(); |
| if (contents == null) |
| return null; |
| |
| List regions= new ArrayList(); |
| if (fFirstType == null && element instanceof IType) { |
| fFirstType= (IType) element; |
| IRegion headerComment= computeHeaderComment(fFirstType); |
| if (headerComment != null) { |
| regions.add(headerComment); |
| fHasHeaderComment= true; |
| } |
| } |
| |
| IScanner scanner= ToolFactory.createScanner(true, false, false, false); |
| scanner.setSource(contents.toCharArray()); |
| final int shift= range.getOffset(); |
| int start= shift; |
| while (true) { |
| |
| int token= scanner.getNextToken(); |
| start= shift + scanner.getCurrentTokenStartPosition(); |
| |
| switch (token) { |
| case ITerminalSymbols.TokenNameCOMMENT_JAVADOC: |
| case ITerminalSymbols.TokenNameCOMMENT_BLOCK: { |
| int end= shift + scanner.getCurrentTokenEndPosition() + 1; |
| regions.add(new Region(start, end - start)); |
| } |
| case ITerminalSymbols.TokenNameCOMMENT_LINE: |
| continue; |
| } |
| |
| break; |
| } |
| |
| regions.add(new Region(start, shift + range.getLength() - start)); |
| |
| if (regions.size() > 0) { |
| IRegion[] result= new IRegion[regions.size()]; |
| regions.toArray(result); |
| return result; |
| } |
| } |
| } catch (JavaModelException e) { |
| MylarPlugin.log(e, ""); |
| } catch (InvalidInputException e) { |
| MylarPlugin.log(e, ""); |
| } |
| |
| return null; |
| } |
| |
| private IRegion computeHeaderComment(IType type) throws JavaModelException { |
| if (fCachedDocument == null) |
| return null; |
| |
| // search at most up to the first type |
| ISourceRange range= type.getSourceRange(); |
| if (range == null) |
| return null; |
| int start= 0; |
| int end= range.getOffset(); |
| |
| if (fInput instanceof ISourceReference) { |
| String content; |
| try { |
| content= fCachedDocument.get(start, end - start); |
| } catch (BadLocationException e) { |
| return null; // ignore header comment in that case |
| } |
| |
| /* code adapted from CommentFormattingStrategy: |
| * scan the header content up to the first type. Once a comment is |
| * found, accumulate any additional comments up to the stop condition. |
| * The stop condition is reaching a package declaration, import container, |
| * or the end of the input. |
| */ |
| IScanner scanner= ToolFactory.createScanner(true, false, false, false); |
| scanner.setSource(content.toCharArray()); |
| |
| int headerStart= -1; |
| int headerEnd= -1; |
| try { |
| boolean foundComment= false; |
| int terminal= scanner.getNextToken(); |
| while (terminal != ITerminalSymbols.TokenNameEOF && !(terminal == ITerminalSymbols.TokenNameclass || terminal == ITerminalSymbols.TokenNameinterface || terminal == ITerminalSymbols.TokenNameenum || (foundComment && (terminal == ITerminalSymbols.TokenNameimport || terminal == ITerminalSymbols.TokenNamepackage)))) { |
| |
| if (terminal == ITerminalSymbols.TokenNameCOMMENT_JAVADOC || terminal == ITerminalSymbols.TokenNameCOMMENT_BLOCK || terminal == ITerminalSymbols.TokenNameCOMMENT_LINE) { |
| if (!foundComment) |
| headerStart= scanner.getCurrentTokenStartPosition(); |
| headerEnd= scanner.getCurrentTokenEndPosition(); |
| foundComment= true; |
| } |
| terminal= scanner.getNextToken(); |
| } |
| |
| |
| } catch (InvalidInputException ex) { |
| return null; |
| } |
| |
| if (headerEnd != -1) { |
| return new Region(headerStart, headerEnd - headerStart); |
| } |
| } |
| return null; |
| } |
| |
| private Position createProjectionPosition(IRegion region, IJavaElement element) { |
| |
| if (fCachedDocument == null) |
| return null; |
| |
| try { |
| |
| int start= fCachedDocument.getLineOfOffset(region.getOffset()); |
| int end= fCachedDocument.getLineOfOffset(region.getOffset() + region.getLength()); |
| if (start != end) { |
| int offset= fCachedDocument.getLineOffset(start); |
| int endOffset; |
| if (fCachedDocument.getNumberOfLines() > end + 1) |
| endOffset= fCachedDocument.getLineOffset(end + 1); |
| else if (end > start) |
| endOffset= fCachedDocument.getLineOffset(end) + fCachedDocument.getLineLength(end); |
| else |
| return null; |
| if (element instanceof IMember) |
| return new JavaElementPosition(offset, endOffset - offset, (IMember) element); |
| else |
| return new CommentPosition(offset, endOffset - offset); |
| } |
| |
| } catch (BadLocationException e) { |
| MylarPlugin.log(e, ""); |
| } |
| |
| return null; |
| } |
| |
| protected void processDelta(IJavaElementDelta delta) { |
| |
| if (!isInstalled()) |
| return; |
| |
| ProjectionAnnotationModel model= (ProjectionAnnotationModel) fEditor.getAdapter(ProjectionAnnotationModel.class); |
| if (model == null) |
| return; |
| |
| try { |
| |
| IDocumentProvider provider= fEditor.getDocumentProvider(); |
| fCachedDocument= provider.getDocument(fEditor.getEditorInput()); |
| fAllowCollapsing= false; |
| |
| fFirstType= null; |
| fHasHeaderComment= false; |
| |
| Map additions= new HashMap(); |
| List deletions= new ArrayList(); |
| List updates= new ArrayList(); |
| |
| Map updated= computeAdditions((IParent) fInput); |
| Map previous= createAnnotationMap(model); |
| |
| |
| Iterator e= updated.keySet().iterator(); |
| while (e.hasNext()) { |
| JavaProjectionAnnotation newAnnotation= (JavaProjectionAnnotation) e.next(); |
| IJavaElement element= newAnnotation.getElement(); |
| Position newPosition= (Position) updated.get(newAnnotation); |
| |
| List annotations= (List) previous.get(element); |
| if (annotations == null) { |
| |
| additions.put(newAnnotation, newPosition); |
| |
| } else { |
| Iterator x= annotations.iterator(); |
| boolean matched= false; |
| while (x.hasNext()) { |
| Tuple tuple= (Tuple) x.next(); |
| JavaProjectionAnnotation existingAnnotation= tuple.annotation; |
| Position existingPosition= tuple.position; |
| if (newAnnotation.isComment() == existingAnnotation.isComment()) { |
| if (existingPosition != null && (!newPosition.equals(existingPosition))) { |
| existingPosition.setOffset(newPosition.getOffset()); |
| existingPosition.setLength(newPosition.getLength()); |
| updates.add(existingAnnotation); |
| } |
| matched= true; |
| x.remove(); |
| break; |
| } |
| } |
| if (!matched) |
| additions.put(newAnnotation, newPosition); |
| |
| if (annotations.isEmpty()) |
| previous.remove(element); |
| } |
| } |
| |
| e= previous.values().iterator(); |
| while (e.hasNext()) { |
| List list= (List) e.next(); |
| int size= list.size(); |
| for (int i= 0; i < size; i++) |
| deletions.add(((Tuple) list.get(i)).annotation); |
| } |
| |
| match(model, deletions, additions, updates); |
| |
| Annotation[] removals= new Annotation[deletions.size()]; |
| deletions.toArray(removals); |
| Annotation[] changes= new Annotation[updates.size()]; |
| updates.toArray(changes); |
| model.modifyAnnotations(removals, additions, changes); |
| |
| } finally { |
| fCachedDocument= null; |
| fAllowCollapsing= true; |
| |
| fFirstType= null; |
| fHasHeaderComment= false; |
| } |
| } |
| |
| private void match(ProjectionAnnotationModel model, List deletions, Map additions, List changes) { |
| if (deletions.isEmpty() || (additions.isEmpty() && changes.isEmpty())) |
| return; |
| |
| List newDeletions= new ArrayList(); |
| List newChanges= new ArrayList(); |
| |
| Iterator deletionIterator= deletions.iterator(); |
| outer: while (deletionIterator.hasNext()) { |
| JavaProjectionAnnotation deleted= (JavaProjectionAnnotation) deletionIterator.next(); |
| Position deletedPosition= model.getPosition(deleted); |
| if (deletedPosition == null) |
| continue; |
| |
| Iterator changesIterator= changes.iterator(); |
| while (changesIterator.hasNext()) { |
| JavaProjectionAnnotation changed= (JavaProjectionAnnotation) changesIterator.next(); |
| if (deleted.isComment() == changed.isComment()) { |
| Position changedPosition= model.getPosition(changed); |
| if (changedPosition == null) |
| continue; |
| |
| if (deletedPosition.getOffset() == changedPosition.getOffset()) { |
| |
| deletedPosition.setLength(changedPosition.getLength()); |
| deleted.setElement(changed.getElement()); |
| |
| deletionIterator.remove(); |
| newChanges.add(deleted); |
| |
| changesIterator.remove(); |
| newDeletions.add(changed); |
| |
| continue outer; |
| } |
| } |
| } |
| |
| Iterator additionsIterator= additions.keySet().iterator(); |
| while (additionsIterator.hasNext()) { |
| JavaProjectionAnnotation added= (JavaProjectionAnnotation) additionsIterator.next(); |
| if (deleted.isComment() == added.isComment()) { |
| Position addedPosition= (Position) additions.get(added); |
| |
| if (deletedPosition.getOffset() == addedPosition.getOffset()) { |
| |
| deletedPosition.setLength(addedPosition.getLength()); |
| deleted.setElement(added.getElement()); |
| |
| deletionIterator.remove(); |
| newChanges.add(deleted); |
| |
| additionsIterator.remove(); |
| |
| break; |
| } |
| } |
| } |
| } |
| |
| deletions.addAll(newDeletions); |
| changes.addAll(newChanges); |
| } |
| |
| private Map createAnnotationMap(IAnnotationModel model) { |
| Map map= new HashMap(); |
| Iterator e= model.getAnnotationIterator(); |
| while (e.hasNext()) { |
| Object annotation= e.next(); |
| if (annotation instanceof JavaProjectionAnnotation) { |
| JavaProjectionAnnotation java= (JavaProjectionAnnotation) annotation; |
| Position position= model.getPosition(java); |
| Assert.isNotNull(position); |
| List list= (List) map.get(java.getElement()); |
| if (list == null) { |
| list= new ArrayList(2); |
| map.put(java.getElement(), list); |
| } |
| list.add(new Tuple(java, position)); |
| } |
| } |
| |
| Comparator comparator= new Comparator() { |
| public int compare(Object o1, Object o2) { |
| return ((Tuple) o1).position.getOffset() - ((Tuple) o2).position.getOffset(); |
| } |
| }; |
| for (Iterator it= map.values().iterator(); it.hasNext();) { |
| List list= (List) it.next(); |
| Collections.sort(list, comparator); |
| } |
| return map; |
| } |
| } |
