<context id="toggle_method_boundary_lines_action_context">

        <description>Allows you to toggle method boundary lines on and off.</description>

        <topic label="Java editor reference" href="reference/views/ref-java-editor.htm"/>

    </context>

          Method boundary Lines

          </td>

          <td valign="top">

            <p>

              If enabled, the Java editor will show the Method boundary lines to indicate the beginning and end of a method.

            </p>

          </td>

          <td valign="top">

            <p>

              Off

            </p>

          </td>

        </tr>

        <tr>

          <td valign="top">

              <dt>Method Boundary Lines</dt>

              <dd>The color of the method boundary lines</dd>

            <p><img src="../../images/org.eclipse.jdt.ui/etool16/toggle_method_boundary.gif" alt="Toggle Method Boundary Lines"></p>

          </td>

          <td valign="top">

            <p>

              Toggle Method Boundary Lines

            </p>

          </td>

          <td valign="top">

            <p>

              This button shows the Method boundary lines in the Java Editor.

            </p>

          </td>

        </tr>

        <tr>

        <td align="center" valign="top">

toggleMethodBoundaryLines.label= Toggle Method Boundary Lines

toggleMethodBoundaryLines.tooltip= Toggle Method Boundary Lines

toggleMethodBoundaryLines.description= Toggles method boundary lines in Java editors

         <action

               allowLabelUpdate="true"

               style="toggle"

               toolbarPath="org.eclipse.ui.edit.text.actionSet.presentation/Presentation"

               id="org.eclipse.jdt.ui.edit.text.java.toggleMethodBoundaryLines"

               definitionId="org.eclipse.jdt.ui.edit.text.java.toggleMethodBoundaryLines"

               disabledIcon="$nl$/icons/full/dtool16/toggle_method_boundary.gif"

               icon="$nl$/icons/full/etool16/toggle_method_boundary.gif"

               helpContextId="org.eclipse.jdt.ui.toggle_mark_occurrences_action_context"

               label="%toggleMethodBoundaryLines.label"

               retarget="true"

               tooltip="%toggleMethodBoundaryLines.tooltip">

         </action>

	        name="%toggleMethodBoundaryLines.label"

	        description="%toggleMethodBoundaryLines.description"

	        categoryId="org.eclipse.jdt.ui.category.source"

	        id="org.eclipse.jdt.ui.edit.text.java.toggleMethodBoundaryLines">

	  </command>

	  <command

	public static final String TOGGLE_METHOD_BOUNDARY_LINES_ACTION= PREFIX + "toggle_method_boundary_lines_action_context"; //$NON-NLS-1$

	 * Theme constant for the color used to render method boundary lines.

	 */

	public final String METHOD_BOUNDARY_LINES_COLOR= ID_PREFIX + PreferenceConstants.METHOD_BOUNDARY_LINES_COLOR;

	/**

				PreferenceConstants.METHOD_BOUNDARY_LINES_COLOR,

				findRGB(registry, IJavaThemeConstants.METHOD_BOUNDARY_LINES_COLOR, new RGB(192, 192, 192)), fireEvent);

		setDefault(

				store,

	private ToggleMethodBoundaryLinesAction fToggleMethodBoundaryLinesAction;

		fToggleMethodBoundaryLinesAction= new ToggleMethodBoundaryLinesAction();

		bars.setGlobalActionHandler(IJavaEditorActionDefinitionIds.TOGGLE_METHOD_BOUNDARY_LINES, fToggleMethodBoundaryLinesAction);

		fToggleMethodBoundaryLinesAction.setEditor(textEditor);

ToggleMethodBoundaryLinesAction.label=Toggle Method Boundary Lines

ToggleMethodBoundaryLinesAction.tooltip=Toggle Method Boundary Lines

import org.eclipse.swt.graphics.Color;

import org.eclipse.jface.preference.PreferenceConverter;

	 * The method boundary lines capability provider.

	 * 

	 * @since 3.7

	 */

	private MethodBoundaryLinesProvider fMethodBoundaryLinesProvider;

	/**

		if (fMethodBoundaryLinesProvider != null) {

			fMethodBoundaryLinesProvider.dispose();

			fMethodBoundaryLinesProvider= null;

		}

			if (PreferenceConstants.METHOD_BOUNDARY_LINES_COLOR.equals(property)) {

				if (fMethodBoundaryLinesProvider != null) {

					Color methodBoundaryColor= getSharedColors().getColor(PreferenceConverter.getColor(getPreferenceStore(), PreferenceConstants.METHOD_BOUNDARY_LINES_COLOR));

					fMethodBoundaryLinesProvider.setColor(methodBoundaryColor);

				}

			}

			if (PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES.equals(property)) {

				if (!JavaPlugin.getDefault().getPreferenceStore().getBoolean(PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES)) {

					if (fMethodBoundaryLinesProvider != null) {

						fMethodBoundaryLinesProvider.deactivate();

					}

				} else {

					if (fMethodBoundaryLinesProvider != null) {

						fMethodBoundaryLinesProvider.activate();

					}

				}

			}

		Color methodBoundaryColor= getSharedColors().getColor(PreferenceConverter.getColor(getPreferenceStore(), PreferenceConstants.METHOD_BOUNDARY_LINES_COLOR));

		fMethodBoundaryLinesProvider= new MethodBoundaryLinesProvider(this, (JavaSourceViewer)getViewer(), getAnnotationAccess(), methodBoundaryColor);

		if (JavaPlugin.getDefault().getPreferenceStore().getBoolean(PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES)) {

			fMethodBoundaryLinesProvider.activate();

		}

	 * Checks if the method boundary lines is enabled.

	 * 

	 * @return <code>true</code> if the method boundary lines preference is checked

	 * @since 3.7

	 */

	protected boolean isShowingMethodBoundaryLines() {

		IPreferenceStore store= getPreferenceStore();

		return store != null && store.getBoolean(PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES);

	}

	/**

package org.eclipse.jdt.internal.ui.javaeditor;

import java.util.Iterator;

import org.eclipse.swt.custom.StyledText;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.GC;

import org.eclipse.jface.text.BadLocationException;

import org.eclipse.jface.text.IDocument;

import org.eclipse.jface.text.IPainter;

import org.eclipse.jface.text.IRegion;

import org.eclipse.jface.text.Position;

import org.eclipse.jface.text.source.Annotation;

import org.eclipse.jface.text.source.AnnotationModel;

import org.eclipse.jface.text.source.AnnotationPainter;

import org.eclipse.jface.text.source.IAnnotationAccess;

import org.eclipse.jface.text.source.IAnnotationModel;

import org.eclipse.jface.text.source.IAnnotationModelExtension;

import org.eclipse.jface.text.source.ISourceViewer;

import org.eclipse.jface.text.source.ISourceViewerExtension2;

import org.eclipse.ui.texteditor.IDocumentProvider;

import org.eclipse.jdt.core.ElementChangedEvent;

import org.eclipse.jdt.core.IElementChangedListener;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jdt.core.IJavaElementDelta;

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.ITypeRoot;

import org.eclipse.jdt.core.JavaCore;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.internal.ui.JavaPlugin;

/**

 * Draws lines that visually demarcate the boundary for methods and types.

 * 

 * @since 3.7

 */

class MethodBoundaryLinesProvider {

	/**

	 * Updates the annotation model to reflect the incoming element changes.

	 */

	private class ElementChangedListener implements IElementChangedListener {

		/*

		 * @see org.eclipse.jdt.core.IElementChangedListener#elementChanged(org.eclipse.jdt.core.ElementChangedEvent)

		 */

		public void elementChanged(ElementChangedEvent event) {

			IJavaElementDelta delta= findElement(fInput, event.getDelta());

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

				//System.out.println("Element Changed: " + delta);

				if ((delta.getFlags() & IJavaElementDelta.F_CHILDREN) != 0)

					updateAnnotationModel(delta.getAffectedChildren());

				else

					updateAnnotationPositions();

			}

		}

		/**

		 * Find the element in the java element delta that matches the target element.

		 * 

		 * @param target the target java element to be searched for in the delta

		 * @param delta the java element delta that is to be searched for the target element

		 * @return the delta that contains the java element matching the target element

		 */

		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;

		}

	}

	/**

	 * The annotation model that holds the annotations for method boundary lines.

	 */

	private class MethodBoundaryAnnotationModel extends AnnotationModel {

		private MethodBoundaryAnnotationModel() {

		}

		/**

		 * Sets the position for the annotation associated with a given element to the new position.

		 * If position is null then the annotation, if found, is removed from the model.

		 * 

		 * @param element the element whose corresponding annotation position is to be modified

		 * @param newPosition The new position for the concerned annotation

		 */

		public void modifyAnnotationForElement(IJavaElement element, Position newPosition) {

			MethodBoundaryAnnotation methodBoundaryAnnotation= getAnnotationForElement(element);

			if (methodBoundaryAnnotation != null)

				modifyAnnotationPosition(methodBoundaryAnnotation, newPosition);

		}

		/**

		 * Searches and returns the annotation associated with given element.

		 * 

		 * @param element the element whose associated annotation we are looking for

		 * @return returns the associated annotation if found, else returns null

		 */

		public MethodBoundaryAnnotation getAnnotationForElement(IJavaElement element) {

			Iterator iterator= getAnnotationIterator();

			while (iterator.hasNext()) {

				MethodBoundaryAnnotation methodBoundaryAnnotation= (MethodBoundaryAnnotation)iterator.next();

				if (element.equals(methodBoundaryAnnotation.getElement())) {

					return methodBoundaryAnnotation;

				}

			}

			return null;

		}

	}

	/**

	 * The drawing strategy for method boundary lines draws the lines that visual separate methods

	 * and types.

	 */

	private static class MethodBoundaryDrawingStrategy implements AnnotationPainter.IDrawingStrategy {

		/*

		 * @see org.eclipse.jface.text.source.AnnotationPainter.IDrawingStrategy#draw(org.eclipse.swt.graphics.GC, org.eclipse.swt.custom.StyledText, int, int, org.eclipse.swt.graphics.Color)

		 */

		public void draw(Annotation annotation, GC gc, StyledText textWidget, int offset, int length, Color color) {

			if (annotation instanceof MethodBoundaryAnnotation) {

				MethodBoundaryAnnotation methodBoundaryAnnotation= (MethodBoundaryAnnotation)annotation;

				if (gc != null) {

					int lineIndex= textWidget.getLineAtOffset(offset);

					int lineY= textWidget.getLinePixel(lineIndex);

					IJavaElement element= methodBoundaryAnnotation.getElement();

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

						//System.out.println(methodBoundaryAnnotation.getElement().getElementName() + ":  Off-" + offset + "  Len-" + length + "  Width-" + 2);

						gc.setLineWidth(2);

						lineY++;

					} else if (element.getElementType() == IJavaElement.METHOD) {

						//System.out.println(methodBoundaryAnnotation.getElement().getElementName() + ":  Off-" + offset + "  Len-" + length + "  Width-" + 0);

						gc.setLineWidth(0);

					} else {

						//System.out.println(methodBoundaryAnnotation.getElement().getElementName() + ":  Off-" + offset + "  Len-" + length + "  Width- ?");

						if (methodBoundaryAnnotation.getPreviousElementType() == IJavaElement.TYPE) {

							gc.setLineWidth(2);

							lineY++;

						} else {

							gc.setLineWidth(0);

						}

					}

					Color defaultColor= gc.getForeground();

					gc.setForeground(color);

					gc.drawLine(2, lineY, textWidget.getClientArea().width, lineY);

					gc.setForeground(defaultColor);

				} else {

					//System.out.println("Clearing: " + methodBoundaryAnnotation.getElement().getElementName() + ":  " + offset + "  " + length);

					textWidget.redraw(2, textWidget.getLinePixel(textWidget.getLineAtOffset(offset)), textWidget.getClientArea().width, 2, true);

				}

			}

		}

	}

	/**

	 * Annotation for method boundary lines.

	 */

	private class MethodBoundaryAnnotation extends Annotation {

		/**

		 * The type for method boundary annotation.

		 */

		public static final String TYPE= "org.eclipse.separator"; //$NON-NLS-1$

		/**

		 * The java element associated with this annotation.

		 */

		private IJavaElement fElementToBeAnnotated;

		/**

		 * The type of the element thats is previous to the element associated with this annotation.

		 */

		private int fPreviousElementType;

		/**

		 * Creates a new method boundary annotation.

		 * 

		 * @param element the java element that this annotation is associated with

		 * @param previousElementType the previous element type

		 */

		public MethodBoundaryAnnotation(IJavaElement element, int previousElementType) {

			super(TYPE, false, null);

			fElementToBeAnnotated= element;

			fPreviousElementType= previousElementType;

		}

		/**

		 * Getter for the java element associated with this annotation.

		 * 

		 * @return returns the java element associated with this annotation

		 */

		public IJavaElement getElement() {

			return fElementToBeAnnotated;

		}

		/**

		 * Getter for previous element type.

		 * 

		 * @return returns the previous element type

		 */

		public int getPreviousElementType() {

			return fPreviousElementType;

		}

		/**

		 * Sets the previous element type.

		 * 

		 * @param previousElementType the previous element type

		 */

		public void setPreviousElementType(int previousElementType) {

			fPreviousElementType= previousElementType;

		}

	}

	/**

	 * Paints the method boundary lines.

	 */

	private class MethodBoundaryAnnotationsPainter extends AnnotationPainter {

		/**

		 * Constructs a new <code>MethodSeparatorPainter</code>.

		 * 

		 * @param sourceViewer the source viewer for the painter

		 * @param access the annotation access

		 */

		public MethodBoundaryAnnotationsPainter(ISourceViewer sourceViewer, IAnnotationAccess access) {

			super(sourceViewer, access);

		}

		/**

		 * Retrieves the annotation model from the given source viewer.

		 * 

		 * @param sourceViewer the source viewer

		 * @return the source viewer's annotation model or <code>null</code> if none can be found

		 */

		protected IAnnotationModel findAnnotationModel(ISourceViewer sourceViewer) {

			if (sourceViewer != null && sourceViewer instanceof ISourceViewerExtension2)

				return ((IAnnotationModelExtension)(((ISourceViewerExtension2)sourceViewer).getVisualAnnotationModel())).getAnnotationModel(METHOD_BOUNDARY);

			return null;

		}

	}

	/**

	 * Key of the method boundary annotation model inside the visual annotation model. Also

	 * internally used as key for the drawing strategy.

	 */

	public final static Object METHOD_BOUNDARY= new Object();

	/**

	 * The source viewer associated with the editor.

	 */

	private JavaSourceViewer fViewer;

	/**

	 * The method boundary painter that paints the boundary lines.

	 */

	private MethodBoundaryAnnotationsPainter fPainter;

	/**

	 * The annotation access.

	 */

	private IAnnotationAccess fAnnotationAccess;

	/**

	 * The drawing strategy that is used for drawing the method boundary lines.

	 */

	private static AnnotationPainter.IDrawingStrategy fDrawingStrategy;

	/**

	 * The method boundary annotation model that holds the annotations and is connected to the

	 * document.

	 */

	private MethodBoundaryAnnotationModel fMethodBoundaryAnnotationModel;

	/**

	 * The listener that listens for element changes from the java model.

	 */

	private IElementChangedListener fElementListener;

	/**

	 * The java input element associated with the java editor.

	 */

	private IJavaElement fInput;

	/**

	 * The java editor.

	 */

	private JavaEditor fEditor;

	/**

	 * The method boundary color.

	 */

	private Color fMethodBoundaryColor;

	/**

	 * Constructs the <code>MethodBoundaryLinesProvider</code>.

	 * 

	 * @param editor the java editor

	 * @param viewer the source viewer associated with the editor

	 * @param annotationAccess the annotation access

	 * @param methodBoundaryColor the color to be used for drawing the method boundary lines

	 */

	public MethodBoundaryLinesProvider(JavaEditor editor, JavaSourceViewer viewer, IAnnotationAccess annotationAccess, Color methodBoundaryColor) {

		fEditor= editor;

		fViewer= viewer;

		fAnnotationAccess= annotationAccess;

		fMethodBoundaryColor= methodBoundaryColor;

		fInput= EditorUtility.getEditorInputJavaElement(fEditor, false);

		fMethodBoundaryAnnotationModel= new MethodBoundaryAnnotationModel();

		try {

			initializeModel(((IParent)fInput).getChildren());

		} catch (JavaModelException e) {

			JavaPlugin.log(e);

		}

		((IAnnotationModelExtension)(fViewer.getVisualAnnotationModel())).addAnnotationModel(METHOD_BOUNDARY, fMethodBoundaryAnnotationModel);

		if (fElementListener == null) {

			//System.out.println("New Listener Registered: " + fEditor.getContentDescription());

			fElementListener= new ElementChangedListener();

			JavaCore.addElementChangedListener(fElementListener);

		}

	}

	/**

	 * Initializes the annotation model with annotations based on the array of java elements.

	 * 

	 * @param elements the java elements for which the annotation model is to be initialized

	 */

	private void initializeModel(IJavaElement[] elements) {

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

			int elementType= elements[i].getElementType();

			try {

				if (isElementOfTypeWeCanAnnotate(elements[i], true)) {

					if (isElementMethodOrType(elementType)) {

						fMethodBoundaryAnnotationModel.addAnnotation(new MethodBoundaryAnnotation(elements[i], 0), getAlignedFirstLineElementPosition(elements[i]));

					} else if (i != 0 && isElementMethodOrType(elements[i - 1].getElementType())) {

						fMethodBoundaryAnnotationModel.addAnnotation(new MethodBoundaryAnnotation(elements[i], elements[i - 1].getElementType()), getAlignedFirstLineElementPosition(elements[i]));

					}

				}

				if (elements[i] instanceof IParent) {

					IJavaElement[] children= ((IParent)elements[i]).getChildren();

					if (children.length > 0)

						initializeModel(children);

				}

			} catch (JavaModelException e) {

				JavaPlugin.log(e);

			}

		}

	}

	/**

	 * Get the aligned position of the first line of the java element.

	 * 

	 * @param element the java element whose first line position is to be determined

	 * @return returns the position of the first line of the java element

	 */

	private Position getAlignedFirstLineElementPosition(IJavaElement element) {

		IDocument document= getDocument();

		try {

			ISourceRange sourceRange= ((ISourceReference)element).getSourceRange();

			IRegion elementFirstLineRegion= document.getLineInformationOfOffset(sourceRange.getOffset());

			return new Position(elementFirstLineRegion.getOffset(), elementFirstLineRegion.getLength());

		} catch (JavaModelException e) {

			JavaPlugin.log(e);

		} catch (BadLocationException e) {

			JavaPlugin.log(e);

		}

		return null;

	}

	/**

	 * Returns <code>true</code> if the element type is one of the types that we can annotate and it

	 * should not be of primary type if <code>checkForPrimaryType</code> is true. Types we can

	 * annotate are {@link IJavaElement#TYPE}, METHOD, FIELD & INITIALIZER.

	 * 

	 * @param element the element whose type is to be checked

	 * @param checkForPrimaryType if <code>true</code> checks if the element is of primary type

	 * @return <code>true</code> if element type matches any in our list

	 */

	private boolean isElementOfTypeWeCanAnnotate(IJavaElement element, boolean checkForPrimaryType) {

		int elementType= element.getElementType();

		if (element instanceof ISourceReference && (elementType == IJavaElement.TYPE

				|| elementType == IJavaElement.METHOD || elementType == IJavaElement.FIELD

				|| elementType == IJavaElement.INITIALIZER)) {

			if (elementType == IJavaElement.TYPE && checkForPrimaryType)

				return !isPrimaryType((IType)element);

			return true;

		}

		return false;

	}

	/**

	 * Returns <code>true</code> if <code>type</code> is not a top-level type, <code>false</code> if

	 * it is.

	 * 

	 * @param type the type to test

	 * @return <code>true</code> if <code>type</code> is an inner type

	 */

	private boolean isInnerType(IType type) {

		return type.getDeclaringType() != null;

	}

	/**

	 * Returns <code>true</code> if <code>element</code> is the primary type, <code>false</code> if

	 * it is not. This is based on {@link ITypeRoot#findPrimaryType()}.

	 * 

	 * @param element the <code>element</code> to be evaluated if it is the primary type

	 * @return <code>true</code> if it is the primary type

	 */

	private boolean isPrimaryType(IType element) {

		IType primaryType= ((ITypeRoot)fInput).findPrimaryType();

		if (primaryType != null && primaryType.equals(element))

			return true;

		return false;

	}

	/**

	 * Update the annotations in the method boundary annotation model with the

	 * {@link IJavaElementDelta} changes. Based on ({@link IJavaElementDelta#getKind()}, annotation

	 * corresponding to the element in the delta is added, removed or changed.

	 * 

	 * @param delta the java element deltas that contain the changes done to the Java model

	 */

	private void updateAnnotationModel(IJavaElementDelta[] delta) {

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

			IJavaElement element= delta[i].getElement();

			if (isElementOfTypeWeCanAnnotate(element, false)) {

				int elementType= element.getElementType();

				int deltaKind= delta[i].getKind();

				if (deltaKind == IJavaElementDelta.REMOVED) {

					//System.out.println("Element 'Removed': " + element.getElementName());

					fMethodBoundaryAnnotationModel.modifyAnnotationForElement(element, null);

					updateAnnotationModelForDanglingElements(element.getParent());

				} else if (deltaKind == IJavaElementDelta.ADDED) {

					int previousElementType= getPreviousElementType(element);

					if (isElementMethodOrType(elementType) || previousElementType != 0) {

						addAnnotationForNewElementToModel(element, previousElementType);

						updateAnnotationModelForDanglingElements(element.getParent());

					}

				} else if (deltaKind == IJavaElementDelta.CHANGED) {

					//System.out.println("Element 'Changed': " + element.getElementName());

					fMethodBoundaryAnnotationModel.modifyAnnotationForElement(element, getAlignedFirstLineElementPosition(element));

				}

			}

			if (element instanceof IParent) {

				updateAnnotationModel(delta[i].getAffectedChildren());

			}

		}

	}

	private int getPreviousElementType(IJavaElement element) {

		try {

			IJavaElement parentElement= element.getParent();

			if (parentElement != null && parentElement.getElementType() == IJavaElement.TYPE && ((IType)parentElement).hasChildren()) {

				IJavaElement[] childrenElements= ((IType)parentElement).getChildren();

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

					if (childrenElements[i].equals(element)) {

						if (i == 0)

							return 0;

						int childElementType= childrenElements[i - 1].getElementType();

						if (childElementType == IJavaElement.METHOD)

							return IJavaElement.METHOD;

						else if (childElementType == IJavaElement.TYPE)

							return IJavaElement.TYPE;

						return 0;

					}

				}

			}

		} catch (JavaModelException e) {

			JavaPlugin.log(e);

		}

		return 0;

	}

	/**

	 * Return <code>true</code> if the given elementType is of type {@link IJavaElement#METHOD} or

	 * {@link IJavaElement#TYPE}.

	 * 

	 * @param elementType the element type to check against

	 * @return <code>true</code> if the given elementType is of type {@link IJavaElement#METHOD} or

	 *         {@link IJavaElement#TYPE}

	 */

	private boolean isElementMethodOrType(int elementType) {

		if (elementType == IJavaElement.METHOD || elementType == IJavaElement.TYPE)

			return true;

		return false;

	}

	/**

	 * For all the children of parentElement, it checks and updates if any does not have a required

	 * Method boundary.

	 * 

	 * @param parentElement the parent element whose children are checked for missing boundary lines

	 */

	private void updateAnnotationModelForDanglingElements(IJavaElement parentElement) {

		try {

			if (parentElement != null && parentElement.getElementType() == IJavaElement.TYPE && ((IType)parentElement).hasChildren()) {

				IJavaElement[] childrenElements= ((IType)parentElement).getChildren();

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

					if (!isElementMethodOrType(childrenElements[i].getElementType()) && isElementOfTypeWeCanAnnotate(childrenElements[i], true)) {

						if (i == 0) {

							fMethodBoundaryAnnotationModel.modifyAnnotationForElement(childrenElements[i], null);

						} else {

							int previousElementType= childrenElements[i - 1].getElementType();

							if (isElementMethodOrType(previousElementType)) {

								MethodBoundaryAnnotation methodBoundaryAnnotation= fMethodBoundaryAnnotationModel.getAnnotationForElement(childrenElements[i]);

								if (methodBoundaryAnnotation == null) {

									fMethodBoundaryAnnotationModel.addAnnotation(new MethodBoundaryAnnotation(childrenElements[i], previousElementType),

										getAlignedFirstLineElementPosition(childrenElements[i]));

								} else {

									methodBoundaryAnnotation.setPreviousElementType(previousElementType);

									Position position= fMethodBoundaryAnnotationModel.getPosition(methodBoundaryAnnotation);

									fMethodBoundaryAnnotationModel.modifyAnnotationPosition(methodBoundaryAnnotation, null);

									fMethodBoundaryAnnotationModel.addAnnotation(methodBoundaryAnnotation, position);

								}

							} else {

								fMethodBoundaryAnnotationModel.modifyAnnotationForElement(childrenElements[i], null);

							}

						}

					}

				}

			}

		} catch (JavaModelException e) {

			JavaPlugin.log(e);

		}

	}

	/**

	 * Returns <code>true</code> if the given element is immediately preceded by an element of type

	 * IJavaElement.METHOD or TYPE in the source code.

	 * 

	 * @param element the element

	 * @return <code>true</code> if the given element is preceded by an IMethod or IType element

	 */

	private boolean isElementAfterTypeOrMethod(IJavaElement element) {

		try {

			IJavaElement parentElement= element.getParent();

			if (parentElement != null && parentElement.getElementType() == IJavaElement.TYPE && ((IType)parentElement).hasChildren()) {

				IJavaElement[] childrenElements= ((IType)parentElement).getChildren();

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

					if (childrenElements[i].equals(element)) {

						if (i == 0)

							return false;

						int childElementType= childrenElements[i - 1].getElementType();

						if (childElementType == IJavaElement.METHOD || (childElementType == IJavaElement.TYPE && isInnerType((IType)childrenElements[i - 1]))) {

							return true;

						}

					}

				}

			}

		} catch (JavaModelException e) {

			JavaPlugin.log(e);

		}

		return false;

	}

	/**

	 * For a new element added to the Java, create and add an annotation to the method boundary

	 * annotation model.

	 * 

	 * @param element the new element for which annotation is to be added to the annotation model

	 * @param previousElementType the type of the previous element

	 */

	private void addAnnotationForNewElementToModel(IJavaElement element, int previousElementType) {

		//System.out.println("Element 'Added': " + element.getElementName());

		if (isElementOfTypeWeCanAnnotate(element, true))

			fMethodBoundaryAnnotationModel.addAnnotation(new MethodBoundaryAnnotation(element, previousElementType), getAlignedFirstLineElementPosition(element));

		if (element instanceof IParent) {

			try {

				IJavaElement[] children= ((IParent)element).getChildren();

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

					int elementType= children[i].getElementType();

					if (isElementMethodOrType(elementType) || isElementAfterTypeOrMethod(children[i])) {

						if (i != 0)

							previousElementType= children[i - 1].getElementType();

						else

							previousElementType= 0;

						addAnnotationForNewElementToModel(children[i], previousElementType);

					}

				}

			} catch (JavaModelException e) {

				JavaPlugin.log(e);

			}

		}

	}

	/**

	 * Update the Positions in the annotation model for all the elements whose current source range

	 * in the document is different from the Position stored with the corresponding annotation.

	 */

	private void updateAnnotationPositions() {

		Iterator iterator= fMethodBoundaryAnnotationModel.getAnnotationIterator();

		while (iterator.hasNext()) {

			MethodBoundaryAnnotation methodBoundaryAnnotation= (MethodBoundaryAnnotation)iterator.next();

			Position existingPosition= fMethodBoundaryAnnotationModel.getPosition(methodBoundaryAnnotation);

			IJavaElement element= methodBoundaryAnnotation.getElement();

			if (element != null && ((ISourceReference)element).exists()) {

				Position newPosition= getAlignedFirstLineElementPosition(element);

				if (newPosition.getOffset() != existingPosition.getOffset() || newPosition.getLength() != existingPosition.getLength()) {

					fMethodBoundaryAnnotationModel.modifyAnnotationPosition(methodBoundaryAnnotation, null);

					fMethodBoundaryAnnotationModel.modifyAnnotationPosition(methodBoundaryAnnotation, newPosition);

				}

			}

		}

	}

	/**

	 * Gets the document associated with the Java editor.

	 * 

	 * @return returns the document

	 */

	private IDocument getDocument() {

		JavaEditor editor= fEditor;

		if (editor == null)

			return null;

		IDocumentProvider provider= editor.getDocumentProvider();

		if (provider == null)

			return null;

		return provider.getDocument(editor.getEditorInput());

	}

	/**

	 * Returns the drawing strategy to be used by the method boundary annotation painter.

	 * 

	 * @return the drawing strategy to be used by the method boundary annotation painter

	 */

	private AnnotationPainter.IDrawingStrategy getDrawingStrategy() {

		if (fDrawingStrategy == null)

			fDrawingStrategy= new MethodBoundaryDrawingStrategy();

		return fDrawingStrategy;

	}

	/**

	 * Disposes the method boundary lines provider and associated painter.

	 */

	public void dispose() {

		if (fPainter != null) {

			fViewer.removePainter(fPainter);

			fPainter.deactivate(true);

			fPainter.dispose();

			fPainter= null;

		}

		IAnnotationModelExtension visualModel= ((IAnnotationModelExtension)(fViewer.getVisualAnnotationModel()));

		if (visualModel != null)

			visualModel.removeAnnotationModel(METHOD_BOUNDARY);

		fMethodBoundaryAnnotationModel= null;

		JavaCore.removeElementChangedListener(fElementListener);

		fViewer= null;

		fEditor= null;

		fMethodBoundaryColor= null;

	}

	/**

	 * Sets the color for the method boundary lines.

	 * 

	 * @param methodBoundaryColor the color to be used for drawing the method boundary lines

	 */

	public void setColor(Color methodBoundaryColor) {

		fMethodBoundaryColor= methodBoundaryColor;

		fPainter.setAnnotationTypeColor(MethodBoundaryAnnotation.TYPE, fMethodBoundaryColor);

		fPainter.paint(IPainter.CONFIGURATION);

	}

	/**

	 * Deactivates the boundary line drawing.

	 */

	public void deactivate() {

		if (fPainter != null) {

			fViewer.removePainter(fPainter);

			//fPainter.deactivate(true);

			fPainter.dispose();

			fPainter= null;

		}

	}

	/**

	 * Activates the boundary line drawing.

	 */

	public void activate() {

		if (fPainter == null) {

			fPainter= new MethodBoundaryAnnotationsPainter(fViewer, fAnnotationAccess);

			fPainter.addDrawingStrategy(METHOD_BOUNDARY, getDrawingStrategy());

			fPainter.addAnnotationType(MethodBoundaryAnnotation.TYPE, METHOD_BOUNDARY);

			fPainter.setAnnotationTypeColor(MethodBoundaryAnnotation.TYPE, fMethodBoundaryColor);

			fViewer.addPainter(fPainter);

		}

	}

}

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

 * Copyright (c) 2000, 2010 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

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

 * which accompanies this distribution, and is available at

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

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

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

package org.eclipse.jdt.internal.ui.javaeditor;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.util.IPropertyChangeListener;

import org.eclipse.jface.util.PropertyChangeEvent;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.texteditor.ITextEditor;

import org.eclipse.ui.texteditor.TextEditorAction;

import org.eclipse.jdt.ui.PreferenceConstants;

import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;

import org.eclipse.jdt.internal.ui.JavaPlugin;

import org.eclipse.jdt.internal.ui.JavaPluginImages;

/**

 * A toolbar action which toggles the

 * {@linkplain org.eclipse.jdt.ui.PreferenceConstants#SHOW_METHOD_BOUNDARY_LINES preference}.

 * 

 * @since 3.7

 */

public class ToggleMethodBoundaryLinesAction extends TextEditorAction implements IPropertyChangeListener {

	private IPreferenceStore fStore;

	/**

	 * Constructs and updates the action.

	 */

	public ToggleMethodBoundaryLinesAction() {

		super(JavaEditorMessages.getBundleForConstructedKeys(), "ToggleMethodBoundaryLinesAction.", null, IAction.AS_CHECK_BOX); //$NON-NLS-1$

		JavaPluginImages.setToolImageDescriptors(this, "toggle_method_boundary.gif"); //$NON-NLS-1$

		PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IJavaHelpContextIds.TOGGLE_METHOD_BOUNDARY_LINES_ACTION);

		update();

	}

	/*

	 * @see IAction#actionPerformed

	 */

	public void run() {

		fStore.setValue(PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES, isChecked());

	}

	/*

	 * @see TextEditorAction#update

	 */

	public void update() {

		ITextEditor editor= getTextEditor();

		boolean checked= false;

		if (editor instanceof JavaEditor)

			checked= ((JavaEditor)editor).isShowingMethodBoundaryLines();

		setChecked(checked);

		setEnabled(editor != null);

	}

	/*

	 * @see TextEditorAction#setEditor(ITextEditor)

	 */

	public void setEditor(ITextEditor editor) {

		super.setEditor(editor);

		if (editor != null) {

			if (fStore == null) {

				fStore= JavaPlugin.getDefault().getPreferenceStore();

				fStore.addPropertyChangeListener(this);

			}

		} else if (fStore != null) {

			fStore.removePropertyChangeListener(this);

			fStore= null;

		}

		update();

	}

	/*

	 * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)

	 */

	public void propertyChange(PropertyChangeEvent event) {

		if (event.getProperty().equals(PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES))

			setChecked(Boolean.valueOf(event.getNewValue().toString()).booleanValue());

	}

}

			{ PreferencesMessages.JavaEditorPreferencePage_methodBoundaryLinesColor, PreferenceConstants.METHOD_BOUNDARY_LINES_COLOR, null },

		overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES));

		overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, PreferenceConstants.METHOD_BOUNDARY_LINES_COLOR));

		label= PreferencesMessages.JavaEditorPreferencePage_ShowMethodBoundaryLines;

		addCheckBox(appearanceComposite, label, PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES, 0);

	public static String JavaEditorPreferencePage_ShowMethodBoundaryLines;

	public static String JavaEditorPreferencePage_methodBoundaryLinesColor;

JavaEditorPreferencePage_ShowMethodBoundaryLines=Separator line &between types and method

JavaEditorPreferencePage_methodBoundaryLinesColor= Separator line between types and method

	 * A named preference that controls whether method boundary lines are shown in the editor.

	 * <p>

	 * Value is of type <code>Boolean</code>.

	 * </p>

	 * 

	 * @since 3.7

	 */

	public static final String SHOW_METHOD_BOUNDARY_LINES= "showMethodBoundaryLines"; //$NON-NLS-1$

	/**

	 * A named preference that holds the color used for method boundary lines.

	 * <p>

	 * Value is of type <code>String</code>. A RGB color value encoded as a string using class

	 * <code>PreferenceConverter</code>

	 * </p>

	 * 

	 * @since 3.7

	 */

	public static final String METHOD_BOUNDARY_LINES_COLOR= "methodBoundaryLinesColor"; //$NON-NLS-1$

	/**

		store.setDefault(PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES, false);