+ 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. +
+
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();
+ try {
+ if (isElementOfTypeWeCanAnnotate(elements[i])) {
+ if (isMethodOrType(elementType)) {
+ fMethodBoundaryAnnotationModel.addAnnotation(new MethodBoundaryAnnotation(elements[i]), getAlignedFirstLineElementPosition(elements[i]));
+ } else if (i != 0 && isMethodOrType(elements[i - 1].getElementType())) {
+ fMethodBoundaryAnnotationModel.addAnnotation(new MethodBoundaryAnnotation(elements[i]), 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 true if the element type is one of the types that we can annotate and it
+ * should not be of primary type. Types we can annotate are TYPE, METHOD, FIELD & INITIALIZER.
+ *
+ * @param element the element whose type is to be checked
+ * @return true if element type matches any in our list
+ */
+ private boolean isElementOfTypeWeCanAnnotate(IJavaElement element) {
+ int elementType= element.getElementType();
+ if (element instanceof ISourceReference && ((elementType == IJavaElement.TYPE && !isPrimaryType((IType)element))
+ || elementType == IJavaElement.METHOD || elementType == IJavaElement.FIELD
+ || elementType == IJavaElement.INITIALIZER)) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * 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) {
+ 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)) {
+ 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) {
+ if (!isMethodOrType(elementType) && isElementAfterTypeOrMethod(element)) {
+ //modifyAnnotationForNextElement(element, false);
+ addAnnotationForNewElementToModel(element);
+ updateAnnotationModelForDanglingElements(element.getParent());
+ } else if (isMethodOrType(elementType)) {
+ //modifyAnnotationForNextElement(element, true);
+ addAnnotationForNewElementToModel(element);
+ 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());
+ }
+ }
+ }
+
+ /**
+ * Return true if the given elementType is of type {@link IJavaElement#METHOD} or
+ * {@link IJavaElement#TYPE}.
+ *
+ * @param elementType the element type to check against
+ * @return true if the given elementType is of type {@link IJavaElement#METHOD} or
+ * {@link IJavaElement#TYPE}
+ */
+ private boolean isMethodOrType(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++) {
+ int childElementType= childrenElements[i].getElementType();
+ if (!isMethodOrType(childElementType)) {
+ if (i == 0) {
+ fMethodBoundaryAnnotationModel.modifyAnnotationForElement(childrenElements[i], null);
+ } else {
+ childElementType= childrenElements[i - 1].getElementType();
+ if (isMethodOrType(childElementType) && isElementOfTypeWeCanAnnotate(childrenElements[i])
+ && fMethodBoundaryAnnotationModel.getAnnotationForElement(childrenElements[i]) == null) {
+ fMethodBoundaryAnnotationModel.addAnnotation(new MethodBoundaryAnnotation(childrenElements[i]), getAlignedFirstLineElementPosition(childrenElements[i]));
+ } else if (!isMethodOrType(childElementType)) {
+ fMethodBoundaryAnnotationModel.modifyAnnotationForElement(childrenElements[i], null);
+ }
+ }
+ }
+ }
+ }
+ } catch (JavaModelException e) {
+ JavaPlugin.log(e);
+ }
+ }
+
+ /**
+ * Returns true 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 true 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
+ */
+ private void addAnnotationForNewElementToModel(IJavaElement 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 23 Nov 2010 23:24:03 -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 23 Nov 2010 23:24:04 -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 23 Nov 2010 23:24:06 -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 23 Nov 2010 23:24:09 -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 23 Nov 2010 23:24:12 -0000
@@ -175,8 +175,8 @@
