+ If enabled, the Java editor will show the Method boundary lines to indicate the beginning and end of a method. +
++ Off +
++ Toggle Method Boundary Lines +
++ This button shows the Method boundary lines in the Java Editor. +
+true
if the delta should be ignored
+ */
+ private boolean shouldIgnoreDelta(CompilationUnit ast, IJavaElementDelta delta) {
+ IDocument document= getDocument();
+
+ if (ast == null || fEditor == null || fEditor.getCachedSelectedRange() == null)
+ return false;
+
+ int caretLine= 0;
+ try {
+ caretLine= document.getLineOfOffset(fEditor.getCachedSelectedRange().x) + 1;
+ } catch (BadLocationException x) {
+ return false;
+ }
+
+ 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;
+ }
+
+ /**
+ * 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() {
+ }
+
+ /**
+ * Searches for the annotation associated with an given element and modifies its position.
+ *
+ * @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) {
+ Iterator iterator= getAnnotationIterator();
+ while (iterator.hasNext()) {
+ MethodBoundaryAnnotation methodBoundaryAnnotation= (MethodBoundaryAnnotation)iterator.next();
+ if (element.equals(methodBoundaryAnnotation.getElement())) {
+ modifyAnnotationPosition(methodBoundaryAnnotation, newPosition);
+ return;
+ }
+ }
+ }
+ }
+
+ /**
+ * 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 {
+ //System.out.println(methodBoundaryAnnotation.getElement().getElementName() + ": Off-" + offset + " Len-" + length + " Width-" + 0);
+ 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;
+
+ /**
+ * Creates a new method boundary annotation.
+ *
+ * @param element the java element that this annotation is associated with
+ */
+ public MethodBoundaryAnnotation(IJavaElement element) {
+ super(TYPE, false, null);
+ fElementToBeAnnotated= element;
+ }
+
+ /**
+ * Getter for the java element associated with this annotation.
+ *
+ * @return returns the java element associated with this annotation
+ */
+ public IJavaElement getElement() {
+ return fElementToBeAnnotated;
+ }
+ }
+
+ /**
+ * Paints the method boundary lines.
+ */
+ private class MethodBoundaryAnnotationsPainter extends AnnotationPainter {
+
+ /**
+ * Constructs a new MethodSeparatorPainter
.
+ *
+ * @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 null
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;
+ /**
+ * Constructs the MethodBoundaryLinesProvider
.
+ *
+ * @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;
+ if (fPainter == null) {
+ fPainter= new MethodBoundaryAnnotationsPainter(fViewer, fAnnotationAccess);
+ fPainter.addDrawingStrategy(METHOD_BOUNDARY, getDrawingStrategy());
+ fPainter.addAnnotationType(MethodBoundaryAnnotation.TYPE, METHOD_BOUNDARY);
+ fPainter.setAnnotationTypeColor(MethodBoundaryAnnotation.TYPE, methodBoundaryColor);
+ fViewer.addPainter(fPainter);
+ }
+
+ 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();
+ if (elements[i] instanceof ISourceReference && (elementType == IJavaElement.TYPE || elementType == IJavaElement.METHOD)) {
+ try {
+ if (elementType == IJavaElement.METHOD || isInnerType((IType)elements[i]) || !isPrimaryType((IType)elements[i])) {
+ fMethodBoundaryAnnotationModel.addAnnotation(new MethodBoundaryAnnotation(elements[i]), getAlignedFirstLineElementPosition(elements[i]));
+ }
+ IJavaElement[] children= ((IParent)elements[i]).getChildren();
+ if (elements[i] instanceof IParent && 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 true
if type
is not a top-level type, false
if
+ * it is.
+ *
+ * @param type the type to test
+ * @return true
if type
is an inner type
+ */
+ private boolean isInnerType(IType type) {
+ return type.getDeclaringType() != null;
+ }
+
+ /**
+ * Returns true
if element
is the primary type, false
if
+ * it is not. This is based on {@link ITypeRoot#findPrimaryType()}.
+ *
+ * @param element the element
to be evaluated if it is the primary type
+ * @return true
if it is the primary type
+ */
+ private boolean isPrimaryType(IType element) {
+ if (((ITypeRoot)fInput).findPrimaryType().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();
+ int elementType= element.getElementType();
+ if (element instanceof ISourceReference && ((elementType == IJavaElement.TYPE && !isPrimaryType((IType)element)) || elementType == IJavaElement.METHOD)) {
+ int deltaKind= delta[i].getKind();
+ if (deltaKind == IJavaElementDelta.REMOVED) {
+ //System.out.println("Element 'Removed': " + element.getElementName());
+ fMethodBoundaryAnnotationModel.modifyAnnotationForElement(element, null);
+ } else {
+ if (deltaKind == IJavaElementDelta.ADDED) {
+ addAnnotationForNewElementToModel(element);
+ } 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());
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * 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
+ */
+ private void addAnnotationForNewElementToModel(IJavaElement element) {
+ if (element instanceof IMethod || !isPrimaryType((IType)element)) {
+ //System.out.println("Element 'Added': " + element.getElementName());
+ fMethodBoundaryAnnotationModel.addAnnotation(new MethodBoundaryAnnotation(element), 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 (elementType == IJavaElement.METHOD || elementType == IJavaElement.TYPE) {
+ addAnnotationForNewElementToModel(children[i]);
+ }
+ }
+ } 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, 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;
+ }
+ fMethodBoundaryAnnotationModel= null;
+ JavaCore.removeElementChangedListener(fElementListener);
+ fViewer= null;
+ fEditor= 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) {
+ fPainter.setAnnotationTypeColor(MethodBoundaryAnnotation.TYPE, methodBoundaryColor);
+ fPainter.paint(IPainter.CONFIGURATION);
+ }
+}
\ No newline at end of file
Index: ui/org/eclipse/jdt/internal/ui/javaeditor/ToggleMethodBoundaryLinesAction.java
===================================================================
RCS file: ui/org/eclipse/jdt/internal/ui/javaeditor/ToggleMethodBoundaryLinesAction.java
diff -N ui/org/eclipse/jdt/internal/ui/javaeditor/ToggleMethodBoundaryLinesAction.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ ui/org/eclipse/jdt/internal/ui/javaeditor/ToggleMethodBoundaryLinesAction.java 1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * 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());
+ }
+}
Index: ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorAppearanceConfigurationBlock.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorAppearanceConfigurationBlock.java,v
retrieving revision 1.29
diff -u -r1.29 JavaEditorAppearanceConfigurationBlock.java
--- ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorAppearanceConfigurationBlock.java 7 Oct 2010 09:57:54 -0000 1.29
+++ ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorAppearanceConfigurationBlock.java 21 Nov 2010 19:36:21 -0000
@@ -59,6 +59,7 @@
{PreferencesMessages.JavaEditorPreferencePage_backgroundForCompletionReplacement, PreferenceConstants.CODEASSIST_REPLACEMENT_BACKGROUND, null },
{PreferencesMessages.JavaEditorPreferencePage_foregroundForCompletionReplacement, PreferenceConstants.CODEASSIST_REPLACEMENT_FOREGROUND, null },
{PreferencesMessages.JavaEditorPreferencePage_sourceHoverBackgroundColor, PreferenceConstants.EDITOR_SOURCE_HOVER_BACKGROUND_COLOR, PreferenceConstants.EDITOR_SOURCE_HOVER_BACKGROUND_COLOR_SYSTEM_DEFAULT},
+ { PreferencesMessages.JavaEditorPreferencePage_methodBoundaryLinesColor, PreferenceConstants.METHOD_BOUNDARY_LINES_COLOR, null },
};
@@ -84,6 +85,8 @@
overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_SUB_WORD_NAVIGATION));
overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_EVALUTE_TEMPORARY_PROBLEMS));
overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.EDITOR_SHOW_SEGMENTS));
+ overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES));
+ overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, PreferenceConstants.METHOD_BOUNDARY_LINES_COLOR));
overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, PreferenceConstants.CODEASSIST_PARAMETERS_BACKGROUND));
overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, PreferenceConstants.CODEASSIST_PARAMETERS_FOREGROUND));
overlayKeys.add(new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, PreferenceConstants.CODEASSIST_REPLACEMENT_BACKGROUND));
@@ -234,6 +237,9 @@
label= PreferencesMessages.JavaEditorPreferencePage_showJavaElementOnly;
addCheckBox(appearanceComposite, label, PreferenceConstants.EDITOR_SHOW_SEGMENTS, 0);
+ label= PreferencesMessages.JavaEditorPreferencePage_ShowMethodBoundaryLines;
+ addCheckBox(appearanceComposite, label, PreferenceConstants.SHOW_METHOD_BOUNDARY_LINES, 0);
+
Label l= new Label(appearanceComposite, SWT.LEFT );
gd= new GridData(GridData.HORIZONTAL_ALIGN_FILL);
gd.horizontalSpan= 2;
Index: ui/org/eclipse/jdt/internal/ui/preferences/PreferencesMessages.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/PreferencesMessages.java,v
retrieving revision 1.137
diff -u -r1.137 PreferencesMessages.java
--- ui/org/eclipse/jdt/internal/ui/preferences/PreferencesMessages.java 5 Nov 2010 05:49:58 -0000 1.137
+++ ui/org/eclipse/jdt/internal/ui/preferences/PreferencesMessages.java 21 Nov 2010 19:36:22 -0000
@@ -151,6 +151,8 @@
public static String JavaEditorPreferencePage_enable;
public static String JavaEditorPreferencePage_preview;
public static String JavaEditorPreferencePage_highlightMatchingBrackets;
+
+ public static String JavaEditorPreferencePage_ShowMethodBoundaryLines;
public static String JavaEditorPreferencePage_insertSingleProposalsAutomatically;
public static String JavaEditorPreferencePage_showOnlyProposalsVisibleInTheInvocationContext;
public static String JavaEditorPreferencePage_presentProposalsInAlphabeticalOrder;
@@ -178,6 +180,8 @@
public static String JavaEditorPreferencePage_empty_input;
public static String JavaEditorPreferencePage_invalid_input;
public static String JavaEditorPreferencePage_matchingBracketsHighlightColor2;
+
+ public static String JavaEditorPreferencePage_methodBoundaryLinesColor;
public static String JavaEditorPreferencePage_appearanceOptions;
public static String JavaEditorPreferencePage_typing_tabTitle;
public static String JavaEditorPreferencePage_closeStrings;
Index: ui/org/eclipse/jdt/internal/ui/preferences/PreferencesMessages.properties
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/PreferencesMessages.properties,v
retrieving revision 1.521
diff -u -r1.521 PreferencesMessages.properties
--- ui/org/eclipse/jdt/internal/ui/preferences/PreferencesMessages.properties 5 Nov 2010 05:49:58 -0000 1.521
+++ ui/org/eclipse/jdt/internal/ui/preferences/PreferencesMessages.properties 21 Nov 2010 19:36:24 -0000
@@ -131,6 +131,7 @@
JavaEditorPreferencePage_enable=Enab&le
JavaEditorPreferencePage_preview=Previe&w:
JavaEditorPreferencePage_highlightMatchingBrackets=Highlight &matching brackets
+JavaEditorPreferencePage_ShowMethodBoundaryLines=Separator line &between types and method
JavaEditorPreferencePage_insertSingleProposalsAutomatically=Insert single &proposals automatically
JavaEditorPreferencePage_showOnlyProposalsVisibleInTheInvocationContext=Hide proposals not visible in the in&vocation context
JavaEditorPreferencePage_presentProposalsInAlphabeticalOrder=&Sort proposals
@@ -160,6 +161,7 @@
JavaEditorPreferencePage_empty_input=Empty input
JavaEditorPreferencePage_invalid_input=''{0}'' is not a valid input.
JavaEditorPreferencePage_matchingBracketsHighlightColor2=Matching brackets highlight
+JavaEditorPreferencePage_methodBoundaryLinesColor= Separator line between types and method
JavaEditorPreferencePage_appearanceOptions=Appearance co&lor options:
JavaEditorPreferencePage_typing_tabTitle=T&yping
Index: ui/org/eclipse/jdt/ui/PreferenceConstants.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/PreferenceConstants.java,v
retrieving revision 1.257
diff -u -r1.257 PreferenceConstants.java
--- ui/org/eclipse/jdt/ui/PreferenceConstants.java 5 Nov 2010 05:49:58 -0000 1.257
+++ ui/org/eclipse/jdt/ui/PreferenceConstants.java 21 Nov 2010 19:36:27 -0000
@@ -2275,11 +2275,32 @@
public static final String EDITOR_BROWSER_LIKE_LINKS_KEY_MODIFIER_MASK= "browserLikeLinksKeyModifierMask"; //$NON-NLS-1$
/**
+ * A named preference that controls whether method boundary lines are shown in the editor.
+ *
+ * Value is of type Boolean
.
+ *
+ * Value is of type String
. A RGB color value encoded as a string using class
+ * PreferenceConverter
+ *
* Value is of type Boolean
.
*
"org.eclipse.jdt.ui.edit.text.java.toggleBreadcrumb"
).
+ * Action definition id of toggle method boundary lines action (value:
+ * "org.eclipse.jdt.ui.edit.text.java.toggleMethodBoundaryLines"
).
+ *
+ * @since 3.7
+ */
+ public static final String TOGGLE_METHOD_BOUNDARY_LINES= "org.eclipse.jdt.ui.edit.text.java.toggleMethodBoundaryLines"; //$NON-NLS-1$
+
+ /**
+ * Action definition id of toggle breadcrumb action (value:
+ * "org.eclipse.jdt.ui.edit.text.java.toggleBreadcrumb"
).
+ *
* @since 3.4
*/
public static final String TOGGLE_BREADCRUMB= "org.eclipse.jdt.ui.edit.text.java.toggleBreadcrumb"; //$NON-NLS-1$
#P org.eclipse.platform.doc.user
Index: reference/ref-68.htm
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.platform.doc.user/reference/ref-68.htm,v
retrieving revision 1.31
diff -u -r1.31 ref-68.htm
--- reference/ref-68.htm 29 May 2009 10:25:13 -0000 1.31
+++ reference/ref-68.htm 21 Nov 2010 19:36:30 -0000
@@ -175,8 +175,8 @@