* Copyright (c) 2006, 2008 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*******************************************************************************/

* Updates the projection model of a class file or compilation unit.

* <p>

* Clients may instantiate or subclass. Subclasses must make sure to always call the superclass'

* code when overriding methods that are marked with "subclasses may extend".

* </p>

* @since 3.0 (internal)

* @since 3.2 (API)

*/

        IJavaFoldingStructureProviderExtension {

  private static final String FUNCTION_RELATION_TOKEN = "/* => */";

  private static final String FUNCTION_RELATION_TOKEN_ONELINE = "// => ";

  /**

   * A context that contains the information needed to compute the folding structure of an

   * {@link ICompilationUnit} or an {@link IClassFile}. Computed folding regions are collected via

   * {@linkplain #addProjectionRange(JavaStyleClosuresFoldingProvider.JavaProjectionAnnotation, Position)

   * addProjectionRange}.

   */

  protected final class FoldingStructureComputationContext {

    private final ProjectionAnnotationModel fModel;

    private final IDocument fDocument;

    private final boolean fAllowCollapsing;

    private IType fFirstType;

    private boolean fHasHeaderComment;

    private LinkedHashMap<JavaProjectionAnnotation, Position> fMap = new LinkedHashMap<JavaProjectionAnnotation, Position>();

    private IScanner fScanner;

    boolean initial;

    private FoldingStructureComputationContext(IDocument document,

            ProjectionAnnotationModel model, boolean allowCollapsing, IScanner scanner) {

      Assert.isNotNull(document);

      Assert.isNotNull(model);

      fDocument = document;

      fModel = model;

      fAllowCollapsing = allowCollapsing;

      fScanner = scanner;

    }

    private void setFirstType(IType type) {

      if (hasFirstType())

        throw new IllegalStateException();

      fFirstType = type;

    }

    boolean hasFirstType() {

      return fFirstType != null;

    }

    private IType getFirstType() {

      return fFirstType;

    }

    private boolean hasHeaderComment() {

      return fHasHeaderComment;

    }

    private void setHasHeaderComment() {

      fHasHeaderComment = true;

    }

    /**

     * 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

     */

    private IDocument getDocument() {

      return fDocument;

    }

    private ProjectionAnnotationModel getModel() {

      return fModel;

    }

    private IScanner getScanner() {

      if (fScanner == null)

        fScanner = ToolFactory.createScanner(true, false, false, false);

      return fScanner;

    }

    /**

     * 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(JavaProjectionAnnotation annotation, Position position) {

      fMap.put(annotation, position);

    }

    /**

     * Returns <code>true</code> if header comments should be collapsed.

     * @return <code>true</code> if header comments should be collapsed

     */

    public boolean collapseHeaderComments() {

      return fAllowCollapsing && fCollapseHeaderComments;

    }

    /**

     * Returns <code>true</code> if import containers should be collapsed.

     * @return <code>true</code> if import containers should be collapsed

     */

    public boolean collapseImportContainer() {

      return fAllowCollapsing && fCollapseImportContainer;

    }

    /**

     * Returns <code>true</code> if inner types should be collapsed.

     * @return <code>true</code> if inner types should be collapsed

     */

    public boolean collapseInnerTypes() {

      return fAllowCollapsing && fCollapseInnerTypes;

    }

    /**

     * Returns <code>true</code> if javadoc comments should be collapsed.

     * @return <code>true</code> if javadoc comments should be collapsed

     */

    public boolean collapseJavadoc() {

      return fAllowCollapsing && fCollapseJavadoc;

    }

    /**

     * Returns <code>true</code> if methods should be collapsed.

     * @return <code>true</code> if methods should be collapsed

     */

    public boolean collapseMembers() {

      return fAllowCollapsing && fCollapseMembers;

    }

  }

  private Map<IType, Integer> annotationDecorationDrawingOffsets = new WeakHashMap<IType, Integer>();

  /**

   * A {@link ProjectionAnnotation} for java code.

   */

  protected final class JavaProjectionAnnotation extends ProjectionAnnotation implements

          AnnotationPainter.IDrawingStrategy {

    private IJavaElement fJavaElement;

    private boolean fIsComment;

    private final boolean isCollapsedByDefault;

    /**

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

     * @param element the java element this annotation refers to

     * @param isComment <code>true</code> for a foldable comment, <code>false</code> for a

     *            foldable code element

     */

    public JavaProjectionAnnotation(boolean isCollapsed,

            FoldingStructureComputationContext ctx, IJavaElement element, boolean isComment) {

      super(isCollapsed);

      this.isCollapsedByDefault = isCollapsed;

      setElement(element);

      fIsComment = isComment;

    }

    IJavaElement getElement() {

      return fJavaElement;

    }

    void setElement(IJavaElement element) {

      fJavaElement = element;

      closurable = findLambdaMethodIn(fJavaElement) != null;

    }

    boolean isComment() {

      return fIsComment;

    }

    void setIsComment(boolean isComment) {

      fIsComment = isComment;

    }

    /*

     * @see java.lang.Object#toString()

     */

    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" + isComment() + "\n"; //$NON-NLS-1$ //$NON-NLS-2$

    }

    public void draw(Annotation annotation, GC gc, StyledText textWidget, int offset,

            int length, Color color) {

      if (fIsComment || !closurable)

        throw new UnsupportedOperationException();

      // TEMP

      if (isCollapsed() || isCollapsedByDefault) {

        if (gc != null) {

          // Do not draw anything

        } else

          textWidget.redrawRange(offset, length, true);

      }

    }

    boolean closurable;

  }

  static IMethod findLambdaMethodIn(IJavaElement element) {

    try {

      if (element.getElementType() == IJavaElement.TYPE) {

        IType t = (IType) element;

        if (t.isAnonymous()) {

          IJavaElement[] c = t.getChildren();

          if (c.length == 1 && c[0].getElementType() == IJavaElement.METHOD) {

            IMethod m = (IMethod) c[0];

            String source = m.getSource();

// boolean hasToken2 = source.contains(FUNCTION_RELATION_TOKEN_ONELINE);

// if (hasToken1 ^ hasToken2)

            return m;

// if (annotations != null) {

// for (IAnnotation annotation : annotations) {

// if (annotation.getElementName().endsWith("FunctionFolded"))

// return m;

// }

// }

          }

        }

      }

    } catch (Exception e) {}

    return null;

  }

  private static final class Tuple {

    JavaProjectionAnnotation annotation;

    Position position;

    Tuple(JavaProjectionAnnotation annotation, Position position) {

      this.annotation = annotation;

      this.position = position;

    }

  }

  /**

   * Filter for annotations.

   */

  private static interface Filter {

    boolean match(JavaProjectionAnnotation annotation);

  }

  /**

   * Matches comments.

   */

  private static final class CommentFilter implements Filter {

    public boolean match(JavaProjectionAnnotation annotation) {

      if (annotation.isComment() && !annotation.isMarkedDeleted()) {

        return true;

      }

      return false;

    }

  }

  /**

   * Matches members.

   */

  private static final class MemberFilter implements Filter {

    public boolean match(JavaProjectionAnnotation annotation) {

      if (!annotation.isComment() && !annotation.isMarkedDeleted()) {

        IJavaElement element = annotation.getElement();

        if (element instanceof IMember) {

          if (element.getElementType() != IJavaElement.TYPE ||

                  ((IMember) element).getDeclaringType() != null) {

            return true;

          }

        }

      }

      return false;

    }

  }

  /**

   * Matches java elements contained in a certain set.

   */

  private static final class JavaElementSetFilter implements Filter {

    private final Set<? extends IJavaElement> set;

    private final boolean matchCollapsed;

    private JavaElementSetFilter(Set<? extends IJavaElement> set, boolean matchCollapsed) {

      this.set = set;

      this.matchCollapsed = matchCollapsed;

    }

    public boolean match(JavaProjectionAnnotation annotation) {

      boolean stateMatch = matchCollapsed == annotation.isCollapsed();

      if (stateMatch && !annotation.isComment() && !annotation.isMarkedDeleted()) {

        IJavaElement element = annotation.getElement();

        if (set.contains(element)) {

          return true;

        }

      }

      return false;

    }

  }

  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 &&

              (delta.getFlags() & (IJavaElementDelta.F_CONTENT | IJavaElementDelta.F_CHILDREN)) != 0) {

        CompilationUnit unitAST = e.getDelta().getCompilationUnitAST();

        if (shouldIgnoreDelta(unitAST, delta))

          return;

        fUpdatingCount++;

        try {

          update(createContext(false));

        } finally {

          fUpdatingCount--;

        }

      }

    }

    /**

     * Ignore the delta if there are errors on the caret line.

     * <p>

     * We don't ignore the delta if an import is added and the caret isn't inside the import

     * container.

     * </p>

     * @param ast the compilation unit AST

     * @param delta the Java element delta for the given AST element

     * @return <code>true</code> if the delta should be ignored

     * @since 3.3

     */

    private boolean shouldIgnoreDelta(CompilationUnit ast, IJavaElementDelta delta) {

      if (ast == null)

        return false; // can't compute

      IDocument document = getDocument();

      if (document == null)

        return false; // can't compute

      JavaEditor editor = fEditor;

      Point selectedRange = null;

      if (editor == null || (selectedRange = editor.getCachedSelectedRange()) == null)

        return false; // can't compute

      try {

        IJavaElementDelta[] affectedChildren = delta.getAffectedChildren();

        if (affectedChildren.length == 1 &&

                affectedChildren[0].getElement() instanceof IImportContainer) {

          IJavaElement elem = SelectionConverter.getElementAtOffset(ast.getTypeRoot(),

                  new TextSelection(selectedRange.x, selectedRange.y));

          if (!(elem instanceof IImportDeclaration))

            return false;

        }

      } catch (JavaModelException e) {

        return false; // can't compute

      }

      int caretLine = 0;

      try {

        caretLine = document.getLineOfOffset(selectedRange.x) + 1;

      } catch (BadLocationException x) {

        return false; // can't compute

      }

      if (caretLine > 0) {

        IProblem[] problems = ast.getProblems();

        for (int i = 0; i < problems.length; i++) {

          if (problems[i].isError() && caretLine == problems[i].getSourceLineNumber())

            return true;

        }

      }

      return false;

    }

    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.

   */

  private static final class JavaCommentPosition extends Position implements IProjectionPosition {

    JavaCommentPosition(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 {

// return new IRegion[] { new Region(offset, length) };

//     

      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 = null, postRegion = null;

      if (firstLine < captionLine) {

        int preOffset = document.getLineOffset(firstLine);

        IRegion preEndLineInfo = document.getLineInformation(captionLine);

        int preEnd = preEndLineInfo.getOffset();

        preRegion = new Region(preOffset, preEnd - preOffset);

      }

      if (captionLine < lastLine) {

        int postOffset = document.getLineOffset(captionLine + 1);

        postRegion = new Region(postOffset, offset + length - postOffset);

      }

      return combineRegions(preRegion, postRegion);

    }

    /**

     * Finds the offset of the first identifier part within <code>content</code>. Returns 0 if

     * none is found.

     * @param content the content to search

     * @param prefixEnd the end of the prefix

     * @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) {

      try {

        DocumentCharacterIterator sequence = new DocumentCharacterIterator(document,

                offset, offset + length);

        return findFirstContent(sequence, 0);

      } catch (BadLocationException e) {

        return offset;

      }

    }

  }

  protected static IRegion[] combineRegions(IRegion preRegion, IRegion postRegion) {

    if (preRegion != null && postRegion != null)

      return new IRegion[] { preRegion, postRegion };

    if (preRegion != null)

      return new IRegion[] { preRegion };

    if (postRegion != null)

      return new IRegion[] { postRegion };

    return null;

  }

  /**

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

   */

  private final class JavaElementPosition extends Position implements IProjectionPosition {

    private IMember fMember;

    private IMethod lambdaMethod;

// private String cachedSourceForCheck;

    public JavaElementPosition(int offset, int length, IMember member, IMethod lambdaMethod) {

      super(offset, length);

      Assert.isNotNull(member);

      fMember = member;

      this.lambdaMethod = lambdaMethod;

    }

    public void setMember(IMember member) {

      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 {

      if (!fMember.exists())

        return null;

      int nameStart = computeCaptionOffset(document) + offset;

      try {

        ISourceRange sourceRange = fMember.getSourceRange();

        IMethod foldedMethod = lambdaMethod;

        if (foldedMethod != null && !foldedMethod.exists()) {

          foldedMethod = findLambdaMethodIn(fMember);

          if (foldedMethod != null) {

            lambdaMethod = foldedMethod;

          }

        }

        if (foldedMethod != null && sourceRange != null)

          return computeFunctionRegions(document, sourceRange, null);

      } catch (IllegalStateException e) {

        System.out.println(e.getMessage());

      } catch (UnsupportedOperationException e) {

      } catch (Exception e) {

        e.printStackTrace();

        return null;

      } catch (AssertionError e) {

        e.printStackTrace();

      }

      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 = null, postRegion = null;

      if (firstLine < captionLine) {

        int preOffset = document.getLineOffset(firstLine);

        IRegion preEndLineInfo = document.getLineInformation(captionLine);

        int preEnd = preEndLineInfo.getOffset();

        preRegion = new Region(preOffset, preEnd - preOffset);

      }

      if (captionLine < lastLine) {

        int postOffset = document.getLineOffset(captionLine + 1);

        postRegion = new Region(postOffset, offset + length - postOffset);

      }

      return combineRegions(preRegion, postRegion);

    }

    private IRegion[] computeFunctionRegions(IDocument document, ISourceRange sourceRange,

            RegionDemarkator editables) throws BadLocationException {

//     

// try {

// sat = ((IType) foldedMethod.getParent()).getSource();

// sourceRange = ((IType) foldedMethod.getParent()).getSourceRange();

// } catch (JavaModelException e1) {}

//

      int anonymousTypeOffset = sourceRange.getOffset();

      int anonymousTypeLength = sourceRange.getLength();

      String anomymousTypeSource = document.get(anonymousTypeOffset, anonymousTypeLength);

      // String anomymousTypeSource = foldedMethod.getSource();

// if (cachedStructure != null && anomymousTypeSource.equals(cachedSourceForCheck))

// return cachedStructure;

// int functionMethodOffset = foldedMethod.getSourceRange().getOffset();

      if (editables != null) {

        editables.initialOffset = anonymousTypeOffset;

      }

      RegionDemarkator marker = new RegionDemarkator();

      marker.initialOffset = anonymousTypeOffset;

      marker.start(0);

      ScannerHelper scan = new ScannerHelper(anomymousTypeSource);

      scan.seekCorresponding(TokenNameLBRACE);

      int f = scan.offset;

      marker.end(f);

      marker.start(f);

      RegionHandle openingBraceRegion = marker.end(++f);

      marker.start(f);

      scan.seek(TokenNamepublic);

      f = scan.endOffset + 1;

      marker.end(f);

      marker.start(f);

      RegionHandle afterOpeningBraceWhitespace = marker.end(++f);

*/

      // Seek parenthese opening parameter list

      scan.seekCorresponding(TokenNameLPAREN);

      int parameterListOpenParenOffset = scan.offset;

      marker.end(parameterListOpenParenOffset);

      marker.start(parameterListOpenParenOffset);

      RegionHandle parameterListOpenParen = marker.end(parameterListOpenParenOffset + 1);

      marker.start(parameterListOpenParenOffset + 1);

//

// int methodNameIdentifierOffset = scan.identifierOffset;

//

// marker.end(methodNameIdentifierOffset - 1);

// // marker.start(methodNameIdentifierOffset - 1);

// // marker.end(methodNameIdentifierOffset);

//

// marker.start(methodNameIdentifierOffset);

      int paramsCount = 0;

      for (;;) {

        int t = scan.seekCorrespondingWithTypeParameterBrackets(TokenNameCOMMA,

                TokenNameRPAREN);

        if (scan.identifier != null) {

          paramsCount++;

          marker.end(scan.identifierOffset);

          if (editables != null) {

            editables.start(scan.identifierOffset);

            editables.end(scan.identifierOffset + scan.identifier.length);

          }

          if (t == TokenNameCOMMA) {

            scan.seekAnyExcept(TokenNameWHITESPACE);

            marker.start(scan.offset);

          }

        }

        if (t == TokenNameRPAREN || t < 0) {

          break;

        }

      }

      int rparenOffset = scan.offset;

      if (!marker.started)

        marker.start(rparenOffset);

      RegionHandle parameterListClosingParen = marker.end(rparenOffset + 1);

      marker.start(rparenOffset + 1);

      int lastPreMethodOffset = rparenOffset + 1;

// int arrowIndex = functionTokenIndex + 2;

// RegionHandle preArrowRegion = marker.end(arrowIndex);

// marker.start(arrowIndex);

//

// RegionHandle arrowRegion = marker.end(functionTokenIndex + 6);

// marker.start(functionTokenIndex + 6);

// annotationDecorationDrawingOffsets.put((IType) fMember, anonymousTypeOffset +

// functionTokenIndex + 3);

      scan.seekCorresponding(TokenNameLBRACE);

// scan.lineEnds.clear();

      int methodOpeningBraceOffset = scan.offset;

      // find where we go past all throws declaration if any

      if (scan.identifierOffset > lastPreMethodOffset) {

        lastPreMethodOffset = scan.identifierOffset + scan.identifier.length;

        while (anomymousTypeSource.charAt(lastPreMethodOffset) == ' ') {

          lastPreMethodOffset++;

        }

      }

      int indexOfArrowComment = anomymousTypeSource.indexOf(FUNCTION_RELATION_TOKEN);

      if (indexOfArrowComment >= lastPreMethodOffset &&

              indexOfArrowComment < methodOpeningBraceOffset)

        lastPreMethodOffset = indexOfArrowComment + FUNCTION_RELATION_TOKEN.length();

      int oneLineTokenIndex = anomymousTypeSource.indexOf(FUNCTION_RELATION_TOKEN_ONELINE);

      if (oneLineTokenIndex >= lastPreMethodOffset) {

        do {

          char c = anomymousTypeSource.charAt(oneLineTokenIndex);

          if (c == '\n' || c == '\r')

            break;

          oneLineTokenIndex++;

        } while (oneLineTokenIndex < methodOpeningBraceOffset);

        lastPreMethodOffset = oneLineTokenIndex;

      }

      // and hide it

      boolean hasPreBraceRegion = lastPreMethodOffset < methodOpeningBraceOffset;

      if (hasPreBraceRegion) {

        marker.end(lastPreMethodOffset);

        marker.start(lastPreMethodOffset);

// marker.start(methodOpeningBraceOffset);

      }

      RegionHandle preBraceRegion = marker.end(methodOpeningBraceOffset);

      marker.start(methodOpeningBraceOffset);

      RegionHandle methodOpeningBrace = marker.end(methodOpeningBraceOffset + 1);

      int methodCloseBraceOffset = -1;

      int returnOffset = -1;

      boolean singleStatement = true;

      int statementTerminator = -1;

      int firstNonWhitespace = -1;

      int lastBraceBlockEnd = -1;

      bodyScanLoop: for (;;) {

        int t = scan

                .seekCorresponding(TokenNameSEMICOLON, TokenNameRBRACE, TokenNamereturn);

        if (scan.wasFlowControlStatement)

          singleStatement = false;

        lastBraceBlockEnd = scan.lastBraceBlockEnd;

        if (firstNonWhitespace < 0)

          firstNonWhitespace = scan.firstNonWhitespace;

        swicher: switch (t) {

        case TokenNameSEMICOLON:

          if (statementTerminator > 0 && singleStatement)

            singleStatement = false;

          statementTerminator = scan.offset;

          continue bodyScanLoop;

        case TokenNamereturn:

          returnOffset = scan.offset;

          continue bodyScanLoop;

        case TokenNameRBRACE:

          methodCloseBraceOffset = scan.offset;

        }

        break;

      }

      if (lastBraceBlockEnd > statementTerminator) {

        statementTerminator = lastBraceBlockEnd;

        singleStatement = false;

      }

      boolean useClauseFolding = wheretherAnonymousTypeIsSingleParameterToHigherOrderMethod(

              document, anonymousTypeOffset, anonymousTypeLength);

      if (singleStatement && !(useClauseFolding && returnOffset < 0)) {

        if (paramsCount > 0) {

          parameterListOpenParen.reveal();// Show opening parameter paren

          parameterListClosingParen.reveal();// Show closing parameter paren

        }

        // Show up method openingBrace

        methodOpeningBrace.reveal();

        if (returnOffset > 0) {

          marker.start(methodOpeningBraceOffset + 1); // from after opening of method body

          marker.end(returnOffset + 7); // to end of return keyword

          marker.start(statementTerminator);// From before last semicolon

          marker.end(anonymousTypeLength - 1);// to end on anonymous type definition

        } else if (lastBraceBlockEnd < 0 && statementTerminator < 0) {

          marker.start(methodOpeningBraceOffset + 1); // from after opening of method body

          marker.end(anonymousTypeLength - 1);// to end on anonymous type definition

        } else {

          // openingBraceRegion.reveal();// Show up openingBrace

          marker.start(methodOpeningBraceOffset + 1); // from after opening of method body

          marker.end(firstNonWhitespace);// to begin of statement

          marker.start(statementTerminator + 1);// From before last semicolon

          marker.end(anonymousTypeLength - 1);// to end on anonymous type definition

          // marker.start(statementTerminator + 1);// From after last semicolon

          // marker.end(anonymousTypeLength - 1); // to before final closing brace

        }

      } else {

        if (paramsCount > 0) {

          parameterListOpenParen.reveal();// Show opening parameter paren

          parameterListClosingParen.reveal();// Show closing parameter paren

        }

        if (hasPreBraceRegion) {

          preBraceRegion.reveal();

        }

        // Show up method openingBrace

        methodOpeningBrace.reveal();

// marker.end(methodOpeningBraceOffset + 1);

// int methodRightBraceLine = document.getLineOfOffset(anonymousTypeOffset +

// methodCloseBraceOffset);

//

// int anonymousTypeBraceLine = document.getLineOfOffset(anonymousTypeOffset +

// anonymousTypeLength);

        if (statementTerminator < 0) {

          statementTerminator = methodCloseBraceOffset - 2;

        }

        marker.start(statementTerminator + 1); // hide lines from body end

        // to anonymous class end (exclusive)

        marker.end(methodCloseBraceOffset + 1);

        eatUpExtraTabsOnEachLine(anomymousTypeSource, marker, scan, lastPreMethodOffset,

                methodCloseBraceOffset);

        if (useClauseFolding)

          try {

// arrowRegion.length--;

            // arrowRegion.reveal();// ?

// if (editables != null)

// editables.clearAll();

// if (paramsCount == 0) {

// parameterListOpenParen.reveal();// Show opening parameter paren

// parameterListClosingParen.reveal();// Show closing parameter paren

// }

            // marker.printRegionHandles(document);

            Region prefix = new Region(anonymousTypeOffset - 1, 1);

            Region suffix = new Region(anonymousTypeOffset + anonymousTypeLength, 2);

            return marker.toProcessedArray(prefix, suffix);

          } catch (Exception e) {

            e.printStackTrace();

          }

      }

      // eat leading space before arror `=>` when no parameters

// if (paramsCount == 0) {

// preArrowRegion.length++;

// arrowRegion.offset++;

// arrowRegion.length--;

// }

//

// arrowRegion.reveal();

      IRegion[] resultingArray = marker.toProcessedArray();

      // System.out.println("__ " + Arrays.toString(resultingArray));

// Cache for later use

// this.cachedStructure = resultingArray;

// this.cachedSourceForCheck = anomymousTypeSource;

      return resultingArray;

    }

    private void eatUpExtraTabsOnEachLine(String anomymousTypeSource, RegionDemarkator marker,

            ScannerHelper scan, int startOffset, int endOffset) {

      for (int index : scan.lineEnds()) {

        if (index < startOffset || index > endOffset)

          continue;

        char startingNextLine = anomymousTypeSource.charAt(index + 1);

        if (startingNextLine == '\t') {

          marker.start(index + 1);

          marker.end(index + 2);

        } else {

          boolean hasTabInFormOf4Spaces = true;

          for (int i = index + 1; i < index + 5; i++) {

            if (anomymousTypeSource.charAt(i) != ' ') {

              hasTabInFormOf4Spaces = false;

              break;

            }

          }

          if (hasTabInFormOf4Spaces) {

            marker.start(index + 1);

            marker.end(index + 5);

          }

        }

      }

    }

    /*

     * @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 {

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

      }

      return nameStart - offset;

    }

    /**

     * Not a real comparator, just ugly hack. Not used now

     */

    @SuppressWarnings("unchecked")

    public int compare(Object o1, Object o2) {

      IDocument document = (IDocument) o1;

      Collection<IRegion> editableRegions = (Collection<IRegion>) o2;

      if (!fMember.exists())

        return 0;

      try {

        ISourceRange sourceRange = fMember.getSourceRange();

        IMethod foldedMethod = lambdaMethod;

        if (foldedMethod != null && !foldedMethod.exists()) {

          foldedMethod = findLambdaMethodIn(fMember);

          if (foldedMethod != null) {

            lambdaMethod = foldedMethod;

          }

        }

        if (foldedMethod != null && sourceRange != null) {

          // RegionDemarkator editableRegionDemarkator = new RegionDemarkator();

          computeFunctionRegions(document, sourceRange, null);

// for (IRegion region : editableRegionDemarkator.toProcessedArray()) {

// s += "[" + document.get(region.getOffset(), region.getLength()) + "]";

// editableRegions.add(region);

// }

//

// System.out.println(s);

        }

      } catch (UnsupportedOperationException e) {} catch (Exception e) {

        e.printStackTrace();

      } catch (AssertionError e) {

        e.printStackTrace();

      }

      return editableRegions.size();

    }

  }

  private static boolean wheretherAnonymousTypeIsSingleParameterToHigherOrderMethod(

          IDocument document, int declarationOffset, int declarationLength)

          throws BadLocationException {

    return document.get(declarationOffset - 1, 4).equals("(new") &&

            document.get(declarationOffset + declarationLength - 1, 3).equals("});");

  }

  /**

   * 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) {

      Assert.isLegal(viewer != null);

      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;

      }

    }

    /*

     * @see org.eclipse.jface.text.source.projection.IProjectionListener#projectionEnabled()

     */

    public void projectionEnabled() {

      handleProjectionEnabled();

    }

    /*

     * @see org.eclipse.jface.text.source.projection.IProjectionListener#projectionDisabled()

     */

    public void projectionDisabled() {

      handleProjectionDisabled();

    }

  }

  /* context and listeners */

  private JavaEditor fEditor;