Java tutorial
/******************************************************************************* * Copyright (c) 2007, 2008 Edgar Espina. * 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 * *******************************************************************************/ package org.deved.antlride.common.ui.text.folding; 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.core.resources.IProject; import org.eclipse.core.runtime.ILog; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.Status; import org.eclipse.dltk.ast.ASTNode; import org.eclipse.dltk.ast.ASTVisitor; import org.eclipse.dltk.ast.declarations.MethodDeclaration; import org.eclipse.dltk.ast.declarations.ModuleDeclaration; import org.eclipse.dltk.ast.declarations.TypeDeclaration; import org.eclipse.dltk.ast.parser.ISourceParser; import org.eclipse.dltk.compiler.env.ModuleSource; import org.eclipse.dltk.core.DLTKCore; import org.eclipse.dltk.core.DLTKLanguageManager; import org.eclipse.dltk.core.ElementChangedEvent; import org.eclipse.dltk.core.IElementChangedListener; import org.eclipse.dltk.core.IMember; import org.eclipse.dltk.core.IModelElement; import org.eclipse.dltk.core.IModelElementDelta; import org.eclipse.dltk.core.IModelElementVisitor; import org.eclipse.dltk.core.ISourceModule; import org.eclipse.dltk.core.ISourceRange; import org.eclipse.dltk.core.ISourceReference; import org.eclipse.dltk.core.ModelException; import org.eclipse.dltk.core.SourceParserUtil; import org.eclipse.dltk.corext.SourceRange; import org.eclipse.dltk.internal.core.SourceMethod; import org.eclipse.dltk.internal.ui.editor.ScriptEditor; import org.eclipse.dltk.internal.ui.text.DocumentCharacterIterator; import org.eclipse.dltk.ui.DLTKUIPlugin; import org.eclipse.dltk.ui.PreferenceConstants; import org.eclipse.dltk.ui.text.folding.AbstractASTFoldingStructureProvider; import org.eclipse.dltk.ui.text.folding.DefaultElementCommentResolver; import org.eclipse.dltk.ui.text.folding.IElementCommentResolver; import org.eclipse.dltk.ui.text.folding.IFoldingStructureProvider; import org.eclipse.dltk.ui.text.folding.IFoldingStructureProviderExtension; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.text.BadLocationException; import org.eclipse.jface.text.Document; import org.eclipse.jface.text.IDocument; import org.eclipse.jface.text.IDocumentPartitioner; import org.eclipse.jface.text.IRegion; import org.eclipse.jface.text.ITypedRegion; import org.eclipse.jface.text.Position; import org.eclipse.jface.text.Region; import org.eclipse.jface.text.TextUtilities; import org.eclipse.jface.text.rules.FastPartitioner; import org.eclipse.jface.text.rules.IPartitionTokenScanner; import org.eclipse.jface.text.source.Annotation; 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.ui.texteditor.IDocumentProvider; import org.eclipse.ui.texteditor.ITextEditor; /** * Updates the projection model of a source module using AST info. * * Just a copy of {@link AbstractASTFoldingStructureProvider} TODO: delete this * class when DLTK supports multiples languages */ @SuppressWarnings("restriction") public abstract class AntlrAbstractFoldingStructureProvider implements IFoldingStructureProvider, IFoldingStructureProviderExtension { /** * A context that contains the information needed to compute the folding * structure of an {@link ISourceModule}. Computed folding regions are * collected via * {@link #addProjectionRange(AbstractASTFoldingStructureProvider.ScriptProjectionAnnotation, Position) * addProjectionRange}. */ public static final class FoldingStructureComputationContext { private final ProjectionAnnotationModel fModel; private final IDocument fDocument; private final boolean fAllowCollapsing; protected LinkedHashMap<Annotation, Position> fMap = new LinkedHashMap<Annotation, Position>(); public FoldingStructureComputationContext(IDocument document, ProjectionAnnotationModel model, boolean allowCollapsing) { fDocument = document; fModel = model; fAllowCollapsing = allowCollapsing; } public Map<Annotation, Position> getMap() { return fMap; } /** * Returns <code>true</code> if newly created folding regions may be * collapsed, <code>false</code> if not. This is usually * <code>false</code> when updating the folding structure while typing; * it may be <code>true</code> when computing or restoring the initial * folding structure. * * @return <code>true</code> if newly created folding regions may be * collapsed, <code>false</code> if not */ public boolean allowCollapsing() { return fAllowCollapsing; } /** * Returns the document which contains the code being folded. * * @return the document which contains the code being folded */ IDocument getDocument() { return fDocument; } ProjectionAnnotationModel getModel() { return fModel; } /** * Adds a projection (folding) region to this context. The created * annotation / position pair will be added to the * {@link ProjectionAnnotationModel} of the {@link ProjectionViewer} of * the editor. * * @param annotation * the annotation to add * @param position * the corresponding position */ public void addProjectionRange(ScriptProjectionAnnotation annotation, Position position) { fMap.put(annotation, position); } } protected static final class SourceRangeStamp { private int hash, length; public SourceRangeStamp(int hash, int lenght) { this.hash = hash; this.length = lenght; } /** * @return the hash */ public int getHash() { return hash; } /** * @param hash * the hash to set */ public void setHash(int hash) { this.hash = hash; } /** * @return the length */ public int getLength() { return length; } /** * @param length * the length to set */ public void setLength(int length) { this.length = length; } /* * (non-Javadoc) * * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals(Object obj) { if (obj instanceof SourceRangeStamp) { SourceRangeStamp s = (SourceRangeStamp) obj; return (s.hash == hash); // && s.length == length); } return super.equals(obj); } /* * (non-Javadoc) * * @see java.lang.Object#hashCode() */ @Override public int hashCode() { return hash; } } /** * A {@link ProjectionAnnotation} for code. */ protected static final class ScriptProjectionAnnotation extends ProjectionAnnotation { private boolean fIsComment; private SourceRangeStamp stamp; private IModelElement element; /** * Creates a new projection annotation. * * @param isCollapsed * <code>true</code> to set the initial state to collapsed, * <code>false</code> to set it to expanded * @param codeStamp * the stamp of source code this annotation refers to * @param isComment * <code>true</code> for a foldable comment, * <code>false</code> for a foldable code element */ public ScriptProjectionAnnotation(boolean isCollapsed, boolean isComment, SourceRangeStamp codeStamp, IModelElement element) { super(isCollapsed); fIsComment = isComment; stamp = codeStamp; this.element = element; } public IModelElement getElement() { return element; } boolean isComment() { return fIsComment; } /** * @return the stamp */ SourceRangeStamp getStamp() { return stamp; } /** * @param stamp * the stamp to set */ void setStamp(SourceRangeStamp stamp) { this.stamp = stamp; } void setIsComment(boolean isComment) { fIsComment = isComment; } /* * @see java.lang.Object#toString() */ @Override public String toString() { return "ScriptProjectionAnnotation:\n" + //$NON-NLS-1$ "\tcollapsed: \t" + isCollapsed() + "\n" + //$NON-NLS-1$ //$NON-NLS-2$ "\tcomment: \t" + isComment() + "\n"; //$NON-NLS-1$ //$NON-NLS-2$ } } private static final class Tuple { ScriptProjectionAnnotation annotation; Position position; Tuple(ScriptProjectionAnnotation annotation, Position position) { this.annotation = annotation; this.position = position; } } /** * Filter for annotations. */ private static interface Filter { boolean match(ScriptProjectionAnnotation annotation); } /** * Matches comments. */ private static final class CommentFilter implements Filter { public boolean match(ScriptProjectionAnnotation annotation) { if (annotation.isComment() && !annotation.isMarkedDeleted()) { return true; } return false; } } /** * Matches members. */ private static final class MemberFilter implements Filter { public boolean match(ScriptProjectionAnnotation annotation) { if (!annotation.isMarkedDeleted() && annotation.getElement() instanceof IMember) { return true; } return false; } } /** * 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. */ private static final class CommentPosition extends Position implements IProjectionPosition { CommentPosition(int offset, int length) { super(offset, length); } /* * @seeorg.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; } /* * @seeorg.eclipse.jface.text.source.projection.IProjectionPosition# * computeCaptionOffset(org.eclipse.jface.text.IDocument) */ public int computeCaptionOffset(IDocument document) { 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 script * element, one folding away any lines after the caption. */ private static final class ScriptElementPosition extends Position implements IProjectionPosition { public ScriptElementPosition(int offset, int length) { super(offset, length); } /* * @seeorg.eclipse.jface.text.source.projection.IProjectionPosition# * computeFoldingRegions(org.eclipse.jface.text.IDocument) */ public IRegion[] computeProjectionRegions(IDocument document) throws BadLocationException { int nameStart = offset; 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; } /* * @seeorg.eclipse.jface.text.source.projection.IProjectionPosition# * computeCaptionOffset(org.eclipse.jface.text.IDocument) */ public int computeCaptionOffset(IDocument document) { return 0; } } /** * Internal projection listener. */ private final class ProjectionListener implements IProjectionListener { private ProjectionViewer fViewer; /** * Registers the listener with the viewer. * * @param viewer * the viewer to register a listener with */ public ProjectionListener(ProjectionViewer viewer) { fViewer = viewer; fViewer.addProjectionListener(this); } /** * Disposes of this listener and removes the projection listener from * the viewer. */ public void dispose() { if (fViewer != null) { fViewer.removeProjectionListener(this); fViewer = null; } } /* * @seeorg.eclipse.jface.text.source.projection.IProjectionListener# * projectionEnabled() */ public void projectionEnabled() { handleProjectionEnabled(); } /* * @seeorg.eclipse.jface.text.source.projection.IProjectionListener# * projectionDisabled() */ public void projectionDisabled() { handleProjectionDisabled(); } } private class ElementChangedListener implements IElementChangedListener { /* * @see * org.eclipse.dltk.core.IElementChangedListener#elementChanged(org. * eclipse.dltk.core.ElementChangedEvent) */ public void elementChanged(ElementChangedEvent e) { IModelElementDelta delta = findElement(fInput, e.getDelta()); if (delta != null && (delta.getFlags() & (IModelElementDelta.F_CONTENT | IModelElementDelta.F_CHILDREN)) != 0) update(createContext(false)); } private IModelElementDelta findElement(IModelElement target, IModelElementDelta delta) { if (delta == null || target == null) return null; IModelElement element = delta.getElement(); if (element.getElementType() > IModelElement.SOURCE_MODULE) return null; if (target.equals(element)) return delta; IModelElementDelta[] children = delta.getAffectedChildren(); for (int i = 0; i < children.length; i++) { IModelElementDelta d = findElement(target, children[i]); if (d != null) return d; } return null; } } /* context and listeners */ private ITextEditor fEditor; private ProjectionListener fProjectionListener; private IModelElement fInput; private IElementChangedListener fElementListener; /* filters */ /** Member filter, matches nested members (but not top-level types). */ private final Filter fMemberFilter = new MemberFilter(); /** Comment filter, matches comments. */ private final Filter fCommentFilter = new CommentFilter(); private IPreferenceStore fStore; private int fBlockLinesMin; protected boolean fDocsFolding; protected boolean fCommentsFolding; protected boolean fFoldNewLines; protected boolean fInitCollapseComments; protected boolean fInitCollapseHeaderComments; protected boolean fInitCollapseClasses; protected boolean fInitCollapseMethods; private boolean fInitCollapseDocs; /** * Creates a new folding provider. It must be * {@link #install(ITextEditor, ProjectionViewer, IPreferenceStore) * installed} on an editor/viewer pair before it can be used, and * {@link #uninstall() uninstalled} when not used any longer. * <p> * The projection state may be reset by calling {@link #initialize()}. * </p> */ public AntlrAbstractFoldingStructureProvider() { // empty constructor } /** * {@inheritDoc} * <p> * Subclasses may extend. * </p> * * @param editor * {@inheritDoc} * @param viewer * {@inheritDoc} */ public void install(ITextEditor editor, ProjectionViewer viewer, IPreferenceStore store) { internalUninstall(); fStore = store; if (editor instanceof ScriptEditor) { fEditor = editor; fProjectionListener = new ProjectionListener(viewer); } } /** * {@inheritDoc} * <p> * Subclasses may extend. * </p> */ public void uninstall() { internalUninstall(); } /** * Internal implementation of {@link #uninstall()}. */ private void internalUninstall() { if (isInstalled()) { handleProjectionDisabled(); fProjectionListener.dispose(); fProjectionListener = null; fEditor = null; } } /** * Returns <code>true</code> if the provider is installed, * <code>false</code> otherwise. * * @return <code>true</code> if the provider is installed, * <code>false</code> otherwise */ protected final boolean isInstalled() { return fEditor != null; } /** * Called whenever projection is enabled, for example when the viewer issues * a {@link IProjectionListener#projectionEnabled() projectionEnabled} * message. When the provider is already enabled when this method is called, * it is first {@link #handleProjectionDisabled() disabled}. * <p> * Subclasses may extend. * </p> */ protected void handleProjectionEnabled() { handleProjectionDisabled(); if (fEditor instanceof ScriptEditor) { initialize(); fElementListener = new ElementChangedListener(); DLTKCore.addElementChangedListener(fElementListener); } } /** * Called whenever projection is disabled, for example when the provider is * {@link #uninstall() uninstalled}, when the viewer issues a * {@link IProjectionListener#projectionDisabled() projectionDisabled} * message and before {@link #handleProjectionEnabled() enabling} the * provider. Implementations must be prepared to handle multiple calls to * this method even if the provider is already disabled. * <p> * Subclasses may extend. * </p> */ protected void handleProjectionDisabled() { if (fElementListener != null) { DLTKCore.removeElementChangedListener(fElementListener); fElementListener = null; } } public final void initialize() { initialize(false); } public final void initialize(boolean isReinit) { update(createInitialContext(isReinit)); } protected FoldingStructureComputationContext createInitialContext(boolean isReinit) { initializePreferences(fStore); fInput = getInputElement(); if (fInput == null) return null; // don't auto collapse if reinitializing return createContext((isReinit) ? false : true); } protected FoldingStructureComputationContext createInitialContext() { return createInitialContext(true); } protected FoldingStructureComputationContext createContext(boolean allowCollapse) { if (!isInstalled()) return null; ProjectionAnnotationModel model = getModel(); if (model == null) return null; IDocument doc = getDocument(); if (doc == null) return null; return new FoldingStructureComputationContext(doc, model, allowCollapse); } private IModelElement getInputElement() { if (fEditor == null) return null; // TODO: multiple languages support return ((ScriptEditor) fEditor).getInputModelElement(); } private void update(FoldingStructureComputationContext ctx) { if (ctx == null) return; Map<Annotation, Position> additions = new HashMap<Annotation, Position>(); List<Annotation> deletions = new ArrayList<Annotation>(); List<Annotation> updates = new ArrayList<Annotation>(); if (!computeFoldingStructure(ctx)) { return; } Map<Annotation, Position> updated = ctx.fMap; Map<SourceRangeStamp, List<Tuple>> previous = computeCurrentStructure(ctx); for (Iterator<Annotation> e = updated.keySet().iterator(); e.hasNext();) { ScriptProjectionAnnotation newAnnotation = (ScriptProjectionAnnotation) e.next(); SourceRangeStamp stamp = newAnnotation.getStamp(); Position newPosition = updated.get(newAnnotation); List<Tuple> annotations = previous.get(stamp); if (annotations == null) { additions.put(newAnnotation, newPosition); } else { Iterator<Tuple> x = annotations.iterator(); boolean matched = false; while (x.hasNext()) { Tuple tuple = x.next(); ScriptProjectionAnnotation existingAnnotation = tuple.annotation; Position existingPosition = tuple.position; if (newAnnotation.isComment() == existingAnnotation.isComment()) { if (existingPosition != null && (!newPosition.equals(existingPosition) || ctx.allowCollapsing() && existingAnnotation.isCollapsed() != newAnnotation.isCollapsed())) { existingPosition.setOffset(newPosition.getOffset()); existingPosition.setLength(newPosition.getLength()); if (ctx.allowCollapsing() && existingAnnotation.isCollapsed() != newAnnotation.isCollapsed()) if (newAnnotation.isCollapsed()) existingAnnotation.markCollapsed(); else existingAnnotation.markExpanded(); updates.add(existingAnnotation); } matched = true; x.remove(); break; } } if (!matched) additions.put(newAnnotation, newPosition); if (annotations.isEmpty()) previous.remove(stamp); } } for (List<Tuple> list : previous.values()) { int size = list.size(); for (int i = 0; i < size; i++) deletions.add(list.get(i).annotation); } Annotation[] removals = new Annotation[deletions.size()]; deletions.toArray(removals); Annotation[] changes = new Annotation[updates.size()]; updates.toArray(changes); ctx.getModel().modifyAnnotations(removals, additions, changes); } private boolean computeFoldingStructure(FoldingStructureComputationContext ctx) { try { String contents = ((ISourceReference) fInput).getSource(); return computeFoldingStructure(contents, ctx); } catch (ModelException e) { return false; } } protected boolean computeFoldingStructure(String contents, FoldingStructureComputationContext ctx) { CodeBlock[] blockRegions = getCodeBlocks(contents); if (blockRegions == null) { return false; } if (fCommentsFolding) { IRegion[] commentRegions = computeCommentsRanges(contents); addDocAnnotations(contents, ctx, commentRegions, false); } String docPartition = getDocPartition(); if (fDocsFolding && docPartition != null) { IRegion[] commentRegions = computeCommentsRanges(contents, docPartition); addDocAnnotations(contents, ctx, commentRegions, true); } // 2. Compute blocks regions final Document d = new Document(contents); final MethodCollector methodCollector = new MethodCollector(); if (fInput != null) { try { fInput.accept(methodCollector); } catch (ModelException e) { // empty } } for (int i = 0; i < blockRegions.length; i++) { CodeBlock codeBlock = blockRegions[i]; if (!mayCollapse(codeBlock.statement, ctx)) continue; boolean collapseCode = initiallyCollapse(codeBlock.statement, ctx); IRegion reg = codeBlock.region; // code boolean multiline = false; try { multiline = isMultilineRegion(d, reg); } catch (BadLocationException e) { // nothing to do } IRegion normalized = alignRegion(reg, ctx); if (normalized != null && multiline) { Position position = createMemberPosition(normalized); if (position != null) { try { int len = normalized.getOffset() + normalized.getLength(); if (contents.length() == len + 1) { len = len - 1; } if (contents.length() >= len) { int hash = contents.substring(normalized.getOffset(), len).hashCode(); IModelElement element = null; if (codeBlock.statement instanceof MethodDeclaration) { MethodDeclaration meth = (MethodDeclaration) codeBlock.statement; hash = meth.getName().hashCode(); element = methodCollector.get(meth.getNameStart(), meth.getNameEnd() - meth.getNameStart()); } SourceRangeStamp codeStamp = new SourceRangeStamp(hash, normalized.getLength()); ScriptProjectionAnnotation annotation = new ScriptProjectionAnnotation(collapseCode, false, codeStamp, element); ctx.addProjectionRange(annotation, position); } } catch (StringIndexOutOfBoundsException e) { if (DLTKCore.DEBUG) { e.printStackTrace(); } } } } } return true; } private void addDocAnnotations(String contents, FoldingStructureComputationContext ctx, IRegion[] commentRegions, boolean isDoc) { if (commentRegions.length == 0) { return; } final IElementCommentResolver commentResolver = fInput != null ? createElementCommentResolver(fInput, contents) : null; for (int i = 0; i < commentRegions.length; i++) { IRegion normalized = alignRegion(commentRegions[i], ctx); if (normalized == null) { continue; } Position position = createCommentPosition(normalized); if (position == null) { continue; } int hash = contents.substring(normalized.getOffset(), normalized.getOffset() + normalized.getLength()) .hashCode(); final IModelElement element; if (commentResolver != null) { element = commentResolver.getElementByCommentPosition(position.offset, 0); } else { element = null; } boolean initCollapse = (isDoc) ? initiallyCollapseDocs(normalized, ctx) : initiallyCollapseComments(normalized, ctx); ctx.addProjectionRange(new ScriptProjectionAnnotation(initCollapse, true, new SourceRangeStamp(hash, normalized.getLength()), element), position); } } /** * @param modelElement * @param contents * @return */ public IElementCommentResolver createElementCommentResolver(IModelElement modelElement, String contents) { return new DefaultElementCommentResolver((ISourceModule) modelElement, contents); } protected static class CodeBlock { public ASTNode statement; public IRegion region; /** * Represents foldable statement. * * @param s * AST statement * @param r * <b>Absolute</b> statement position in source file */ public CodeBlock(ASTNode s, IRegion r) { this.statement = s; this.region = r; } } protected int getMinimalFoldableLinesCount() { return fBlockLinesMin; } protected void initializePreferences(IPreferenceStore store) { fBlockLinesMin = store.getInt(PreferenceConstants.EDITOR_FOLDING_LINES_LIMIT); fDocsFolding = store.getBoolean(PreferenceConstants.EDITOR_DOCS_FOLDING_ENABLED); fCommentsFolding = store.getBoolean(PreferenceConstants.EDITOR_COMMENTS_FOLDING_ENABLED); fFoldNewLines = store.getBoolean(PreferenceConstants.EDITOR_COMMENT_FOLDING_JOIN_NEWLINES); fInitCollapseComments = store.getBoolean(PreferenceConstants.EDITOR_FOLDING_INIT_COMMENTS); fInitCollapseHeaderComments = store.getBoolean(PreferenceConstants.EDITOR_FOLDING_INIT_HEADER_COMMENTS); fInitCollapseDocs = store.getBoolean(PreferenceConstants.EDITOR_FOLDING_INIT_DOCS); fInitCollapseClasses = store.getBoolean(getInitiallyFoldClassesKey()); fInitCollapseMethods = store.getBoolean(getInitiallyFoldMethodsKey()); } /** * Returns the preference key used to indicate if classes should be * 'initially' folded. * * <p> * Sub-classes may override this method to provide an alternative preference * key if they are not using the one in {@link PreferenceConstants}. * </p> */ protected String getInitiallyFoldClassesKey() { return PreferenceConstants.EDITOR_FOLDING_INIT_CLASSES; } /** * Returns the preference key used to indicate if methods should be * 'initially' folded. * * <p> * Sub-classes may override this method to provide an alternative preference * key if they are not using the one in {@link PreferenceConstants}. * </p> */ protected String getInitiallyFoldMethodsKey() { return PreferenceConstants.EDITOR_FOLDING_INIT_METHODS; } protected boolean isEmptyRegion(IDocument d, ITypedRegion r) throws BadLocationException { return isEmptyRegion(d, r.getOffset(), r.getLength()); } /** * Tests if the specified region contains only space or tab characters. * * @param document * @param region * @return * @throws BadLocationException * @since 2.0 */ protected boolean isBlankRegion(IDocument document, ITypedRegion region) throws BadLocationException { String value = document.get(region.getOffset(), region.getLength()); for (int i = 0; i < value.length(); ++i) { char ch = value.charAt(i); if (ch != ' ' && ch != '\t') { return false; } } return true; } protected boolean isEmptyRegion(IDocument d, int offset, int length) throws BadLocationException { return d.get(offset, length).trim().length() == 0; } protected boolean isMultilineRegion(IDocument d, IRegion region) throws BadLocationException { int line1 = d.getLineOfOffset(region.getOffset()); int line2 = d.getLineOfOffset(region.getOffset() + region.getLength()); final int foldMinLines = getMinimalFoldableLinesCount(); if (foldMinLines > 0) { return line2 - line1 + 1 >= foldMinLines; } else { return line1 != line2; } } /** * Creates a comment folding position from an * {@link #alignRegion(IRegion, AbstractASTFoldingStructureProvider.FoldingStructureComputationContext) * aligned} region. * * @param aligned * an aligned region * @return a folding position corresponding to <code>aligned</code> */ protected final Position createCommentPosition(IRegion aligned) { return new CommentPosition(aligned.getOffset(), aligned.getLength()); } /** * Creates a folding position that remembers its member from an * {@link #alignRegion(IRegion, AbstractASTFoldingStructureProvider.FoldingStructureComputationContext) * aligned} region. * * @param aligned * an aligned region * * @return a folding position corresponding to <code>aligned</code> */ protected final Position createMemberPosition(IRegion aligned) { return new ScriptElementPosition(aligned.getOffset(), aligned.getLength()); } /** * Aligns <code>region</code> to start and end at a line offset. The * region's start is decreased to the next line offset, and the end offset * increased to the next line start or the end of the document. * <code>null</code> is returned if <code>region</code> is <code>null</code> * itself or does not comprise at least one line delimiter, as a single line * cannot be folded. * * @param region * the region to align, may be <code>null</code> * @param ctx * the folding context * @return a region equal or greater than <code>region</code> that is * aligned with line offsets, <code>null</code> if the region is too * small to be foldable (e.g. covers only one line) */ protected IRegion alignRegion(IRegion region, FoldingStructureComputationContext ctx) { if (region == null) return null; IDocument document = ctx.getDocument(); try { int start = document.getLineOfOffset(region.getOffset()); int end = document.getLineOfOffset(region.getOffset() + region.getLength()); if (start >= end) return null; int offset = document.getLineOffset(start); int endOffset; if (document.getNumberOfLines() > end + 1) { endOffset = document.getLineOffset(end + 1); } else { endOffset = document.getLineOffset(end) + document.getLineLength(end); } return new Region(offset, endOffset - offset); } catch (BadLocationException x) { // concurrent modification return null; } } private ProjectionAnnotationModel getModel() { return (ProjectionAnnotationModel) fEditor.getAdapter(ProjectionAnnotationModel.class); } private IDocument getDocument() { IDocumentProvider provider = fEditor.getDocumentProvider(); return provider.getDocument(fEditor.getEditorInput()); } private Map<SourceRangeStamp, List<Tuple>> computeCurrentStructure(FoldingStructureComputationContext ctx) { Map<SourceRangeStamp, List<Tuple>> map = new HashMap<SourceRangeStamp, List<Tuple>>(); ProjectionAnnotationModel model = ctx.getModel(); Iterator<?> e = model.getAnnotationIterator(); while (e.hasNext()) { Object annotation = e.next(); if (annotation instanceof ScriptProjectionAnnotation) { ScriptProjectionAnnotation ann = (ScriptProjectionAnnotation) annotation; Position position = model.getPosition(ann); List<Tuple> list = map.get(ann.getStamp()); if (list == null) { list = new ArrayList<Tuple>(2); map.put(ann.getStamp(), list); } list.add(new Tuple(ann, position)); } } Comparator<Tuple> comparator = new Comparator<Tuple>() { public int compare(Tuple o1, Tuple o2) { return o1.position.getOffset() - o2.position.getOffset(); } }; for (Iterator<List<Tuple>> it = map.values().iterator(); it.hasNext();) { List<Tuple> list = it.next(); Collections.sort(list, comparator); } return map; } /* * @see IScriptFoldingStructureProviderExtension#collapseMembers() */ public final void collapseMembers() { modifyFiltered(fMemberFilter, false); } /* * @see IScriptFoldingStructureProviderExtension#collapseComments() */ public final void collapseComments() { modifyFiltered(fCommentFilter, false); } /** * Collapses or expands all annotations matched by the passed filter. * * @param filter * the filter to use to select which annotations to collapse * @param expand * <code>true</code> to expand the matched annotations, * <code>false</code> to collapse them */ private void modifyFiltered(Filter filter, boolean expand) { if (!isInstalled()) return; ProjectionAnnotationModel model = getModel(); if (model == null) return; List<Annotation> modified = new ArrayList<Annotation>(); Iterator<?> iter = model.getAnnotationIterator(); while (iter.hasNext()) { Object annotation = iter.next(); if (annotation instanceof ScriptProjectionAnnotation) { ScriptProjectionAnnotation annot = (ScriptProjectionAnnotation) annotation; if (expand == annot.isCollapsed() && filter.match(annot)) { if (expand) annot.markExpanded(); else annot.markCollapsed(); modified.add(annot); } } } model.modifyAnnotations(null, null, modified.toArray(new Annotation[modified.size()])); } protected abstract String getPartition(); protected abstract String getCommentPartition(); protected String getDocPartition() { return null; } protected abstract IPartitionTokenScanner getPartitionScanner(); protected abstract String getNatureId(); protected abstract String[] getPartitionTypes(); protected abstract ILog getLog(); protected FoldingASTVisitor getFoldingVisitor(int offset) { return new FoldingASTVisitor(offset); } protected static class FoldingASTVisitor extends ASTVisitor { private final List<CodeBlock> result = new ArrayList<CodeBlock>(); private final int offset; protected FoldingASTVisitor(int offset) { this.offset = offset; } @Override public boolean visit(MethodDeclaration s) throws Exception { add(s); return super.visit(s); } @Override public boolean visit(TypeDeclaration s) throws Exception { add(s); return super.visit(s); } public CodeBlock[] getResults() { return result.toArray(new CodeBlock[result.size()]); } protected final void add(ASTNode s) { int start = offset + s.sourceStart(); int end = s.sourceEnd() - s.sourceStart(); result.add(new CodeBlock(s, new Region(start, end))); } protected void add(CodeBlock block) { result.add(block); } } // TODO: multiple languages support protected ISourceParser getSourceParser() { final IProject project = fInput != null ? fInput.getScriptProject().getProject() : null; return DLTKLanguageManager.getSourceParser(project, getNatureId()); } /** * Should locate all statements and return * * @param code */ protected CodeBlock[] getCodeBlocks(String code) { return getCodeBlocks(code, 0); } protected CodeBlock[] getCodeBlocks(String code, int offset) { ModuleDeclaration decl = parse(code, offset); if (decl == null) { return null; } return buildCodeBlocks(decl, offset); } protected final IModelElement getModuleElement() { return fInput; } protected final ModuleDeclaration parse(String code, int offset) { if (offset == 0 && fInput instanceof ISourceModule) { final ISourceModule module = (ISourceModule) fInput; try { // TODO: DLTK multiples languages if (code.equals(module.getSource()) && module.getElementName().endsWith(".g")) { // use the cache luke! ;) return SourceParserUtil.getModuleDeclaration(module); } } catch (ModelException e) { getLog().log(new Status(IStatus.WARNING, DLTKUIPlugin.PLUGIN_ID, e.getMessage(), e)); } } ISourceModule sm = (ISourceModule) getInputElement(); IPath path = sm.getPath(); return (ModuleDeclaration) getSourceParser().parse(new ModuleSource(path.toString(), code), null); } protected CodeBlock[] buildCodeBlocks(ModuleDeclaration decl, int offset) { FoldingASTVisitor visitor = getFoldingVisitor(offset); try { decl.traverse(visitor); } catch (Exception e) { if (DLTKCore.DEBUG) { e.printStackTrace(); } } return visitor.getResults(); } /** * Returns is it possible to collapse statement, or it should never be * folded * * @param s * @param ctx */ protected boolean mayCollapse(ASTNode s, FoldingStructureComputationContext ctx) { if (s instanceof TypeDeclaration) { return true; } if (s instanceof MethodDeclaration) { return true; } return false; } protected boolean initiallyCollapse(ASTNode s, FoldingStructureComputationContext ctx) { if (ctx.allowCollapsing()) { return initiallyCollapse(s); } return false; } protected boolean initiallyCollapse(ASTNode s) { // classes, modules, etc if (s instanceof TypeDeclaration && fInitCollapseClasses) { return true; } // methods, subroutines, etc if (s instanceof MethodDeclaration && fInitCollapseMethods) { return true; } return false; } protected boolean initiallyCollapseComments(IRegion commentRegion, FoldingStructureComputationContext ctx) { if (ctx.allowCollapsing()) { return isHeaderRegion(commentRegion, ctx) ? fInitCollapseHeaderComments : fInitCollapseComments; } return false; } protected boolean initiallyCollapseDocs(IRegion commentRegion, FoldingStructureComputationContext ctx) { if (ctx.allowCollapsing()) { return fInitCollapseDocs; } return false; } /** * Checks if the specified region is located at the beginning of the * document * * @param region * @param ctx */ protected boolean isHeaderRegion(IRegion region, FoldingStructureComputationContext ctx) { final int offset = region.getOffset(); if (offset == 0) { return true; } else if (offset < 100) { try { return isEmptyRegion(ctx.getDocument(), 0, offset); } catch (BadLocationException e) { // } } return false; } /** * Installs a partitioner with <code>document</code>. * * @param document * the document */ private void installDocumentStuff(Document document) { IDocumentPartitioner partitioner = getDocumentPartitioner(); partitioner.connect(document); document.setDocumentPartitioner(getPartition(), partitioner); } protected IDocumentPartitioner getDocumentPartitioner() { return new FastPartitioner(getPartitionScanner(), getPartitionTypes()); } /** * Removes partitioner with <code>document</code>. * * @param document * the document */ private void removeDocumentStuff(Document document) { document.setDocumentPartitioner(getPartition(), null); } public void expandElements(final IModelElement[] array) { modifyFiltered(new Filter() { public boolean match(ScriptProjectionAnnotation annotation) { IModelElement element = annotation.getElement(); if (element == null) return false; for (int a = 0; a < array.length; a++) { IModelElement e = array[a]; if (e.equals(element)) { return true; } } return false; } }, true); } public void collapseElements(IModelElement[] modelElements) { // empty implementation } private ITypedRegion getRegion(IDocument d, int offset) throws BadLocationException { return TextUtilities.getPartition(d, getPartition(), offset, true); } protected IRegion[] computeCommentsRanges(String contents) { // for backwards compatibility incase anyone has overridden this.. return computeCommentsRanges(contents, getCommentPartition()); } protected IRegion[] computeCommentsRanges(String contents, String partition) { try { if (contents == null) return new IRegion[0]; Document d = new Document(contents); installDocumentStuff(d); List<ITypedRegion> docRegionList = new ArrayList<ITypedRegion>(); int offset = 0; for (;;) { try { ITypedRegion region = getRegion(d, offset); docRegionList.add(region); offset = region.getLength() + region.getOffset() + 1; } catch (BadLocationException e1) { break; } } ITypedRegion start = null; ITypedRegion lastRegion = null; List<IRegion> regions = new ArrayList<IRegion>(); for (ITypedRegion region : docRegionList) { if (region.getType().equals(partition) && startsAtLineBegin(d, region)) { if (start == null) start = region; } else if (start != null && (isBlankRegion(d, region) || isEmptyRegion(d, region) && collapseEmptyLines())) { // blanks or empty lines // TODO introduce line limit for collapseEmptyLines() ? } else { if (start != null) { int offset0 = start.getOffset(); int length0 = lastRegion.getOffset() + lastRegion.getLength() - offset0 - 1; length0 = contents.substring(offset0, offset0 + length0).trim().length(); IRegion fullRegion = new Region(offset0, length0); if (isMultilineRegion(d, fullRegion)) { regions.add(fullRegion); } } start = null; } lastRegion = region; } if (start != null) { int offset0 = start.getOffset(); int length0 = lastRegion.getOffset() - offset0 + lastRegion.getLength() - 1; IRegion fullRegion = new Region(offset0, length0); if (isMultilineRegion(d, fullRegion)) { regions.add(fullRegion); } } prepareRegions(d, regions); removeDocumentStuff(d); return regions.toArray(new IRegion[regions.size()]); } catch (BadLocationException e) { e.printStackTrace(); } return new IRegion[0]; } /** * @param d * @param regions * @since 2.0 */ protected void prepareRegions(Document d, List<IRegion> regions) { // override in descendants } private boolean startsAtLineBegin(Document d, ITypedRegion region) throws BadLocationException { int lineStart = d.getLineOffset(d.getLineOfOffset(region.getOffset())); if (lineStart != region.getOffset()) { if (!isEmptyRegion(d, lineStart, region.getOffset() - lineStart)) { return false; } } return true; } protected boolean collapseEmptyLines() { return fFoldNewLines; } /** * @deprecated */ protected final void getElementCommentResolver() { // will be deleted } public static class MethodCollector implements IModelElementVisitor { private final Map<SourceRange, IModelElement> methodByNameRange = new HashMap<SourceRange, IModelElement>(); public boolean visit(IModelElement element) { if (element instanceof SourceMethod) { try { final ISourceRange nameRange = ((SourceMethod) element).getNameRange(); methodByNameRange.put(new SourceRange(nameRange), element); } catch (ModelException e) { // empty } } return true; } /** * @param offset * @param length */ public IModelElement get(int offset, int length) { return methodByNameRange.get(new SourceRange(offset, length)); } } }