Attachment #5259 for bug #8518

Lines 29-34 Link Here

(-)plugin.properties (+4 lines)
29	upperCase.label= To Upper Case	29	upperCase.label= To Upper Case
30	lowerCase.description= Changes the selection to lower case	30	lowerCase.description= Changes the selection to lower case
31	lowerCase.label= To Lower Case	31	lowerCase.label= To Lower Case
		32	invertCase.description= Inverts the case of the selection
		33	invertCase.label= Invert Case
		34	capitalizeCase.description= Capitalizes the selection
		35	capitalizeCase.label= Capitalize
32		36
33	markerAnnotationSpecification.label= Marker Annotation Specification	37	markerAnnotationSpecification.label= Marker Annotation Specification
34		38




            configuration="org.eclipse.ui.defaultAcceleratorConfiguration">
      </keyBinding>
   </extension>
   <extension
         point="org.eclipse.ui.commands">
      <command
            name="%invertCase.label"
            description="%invertCase.description"
            category="org.eclipse.ui.category.textEditor"
            id="org.eclipse.ui.edit.text.invertCase">
      </command>
      <keyBinding
            string="Ctrl+Shift+I"
            scope="org.eclipse.ui.textEditorScope"
            command="org.eclipse.ui.edit.text.invertCase"
            configuration="org.eclipse.ui.defaultAcceleratorConfiguration">
      </keyBinding>
   </extension>   
   <extension
         point="org.eclipse.ui.commands">
      <command
            name="%capitalizeCase.label"
            description="%capitalizeCase.description"
            category="org.eclipse.ui.category.textEditor"
            id="org.eclipse.ui.edit.text.capitalizeCase">
      </command>
      <keyBinding
            string="Ctrl+Shift+C"
            scope="org.eclipse.ui.textEditorScope"
            command="org.eclipse.ui.edit.text.capitalizeCase"
            configuration="org.eclipse.ui.defaultAcceleratorConfiguration">
      </keyBinding>
   </extension>  
      
<!-- action sets -->
   <extension
         point="org.eclipse.ui.actionSets">




		action.setActionDefinitionId(ITextEditorActionDefinitionIds.MOVE_LINES_DOWN);
		setAction(ITextEditorActionConstants.MOVE_LINE_DOWN, action);
		
		action = new UpperLowerCaseAction(EditorMessages.getResourceBundle(), "Editor.UpperCase.", this, true); //$NON-NLS-1$
		action.setHelpContextId(IAbstractTextEditorHelpContextIds.UPPER_CASE_ACTION);
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.UPPER_CASE);
		setAction(ITextEditorActionConstants.UPPER_CASE, action);
		
		action = new UpperLowerCaseAction(EditorMessages.getResourceBundle(), "Editor.LowerCase.", this, false); //$NON-NLS-1$
		action.setHelpContextId(IAbstractTextEditorHelpContextIds.LOWER_CASE_ACTION);
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.LOWER_CASE);
		setAction(ITextEditorActionConstants.LOWER_CASE, action);
		
		action = new InvertCaseAction(EditorMessages.getResourceBundle(), "Editor.InvertCase.", this); //$NON-NLS-1$
		action.setHelpContextId(IAbstractTextEditorHelpContextIds.INVERT_CASE_ACTION);
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.INVERT_CASE);
		setAction(ITextEditorActionConstants.INVERT_CASE, action);
		
		action = new CapitalizeCaseAction(EditorMessages.getResourceBundle(), "Editor.CapitalizeCase.", this); //$NON-NLS-1$
		action.setHelpContextId(IAbstractTextEditorHelpContextIds.INVERT_CASE_ACTION);
		action.setActionDefinitionId(ITextEditorActionDefinitionIds.CAPITALIZE_CASE);
		setAction(ITextEditorActionConstants.INVERT_CASE, action);		
		
		action = new SmartEnterAction(EditorMessages.getResourceBundle(), "Editor.SmartEnter.", this, false); //$NON-NLS-1$
		action.setHelpContextId(IAbstractTextEditorHelpContextIds.SMART_ENTER_ACTION);




 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Sebastian Davids <sdavids@gmx.de> - bug 8515
 *******************************************************************************/
package org.eclipse.ui.texteditor;


import org.eclipse.swt.graphics.Point;

/**
 * Action that converts the current selection to a different case.
 * @since 3.0
 */
public abstract class CaseAction extends ResourceAction implements IUpdate {

	/** The editor we are working on. */
	private AbstractTextEditor fEditor;

	/** <code>true</code> if this action converts to upper case, <code>false</code> otherwise. */
	private boolean fToUpper;

	/**
	 * Creates and initializes the action for the given text editor.
	 * The action configures its visual representation from the given resource

	 * @param prefix a prefix to be prepended to the various resource keys
	 *   (described in <code>ResourceAction</code> constructor), or  <code>null</code> if none
	 * @param editor the text editor
	 * @param toUpper <code>true</code> if this is an uppercase action, <code>false</code> otherwise.
	 * 
	 * @see ResourceAction#ResourceAction
	 */
	public CaseAction(ResourceBundle bundle, String prefix, AbstractTextEditor editor) {
		super(bundle, prefix);
		fEditor= editor;
		fToUpper= toUpper;
		update();
	}


		Point sel= viewer.getSelectedRange();
		if (sel == null)
			return;
		int selY = sel.y;
		try {
			// if the selection is emtpy, we select the word / string using the viewer's 
			// doubleclick strategy
			if (selY == 0)  {
				SourceViewerConfiguration svc= fEditor.getSourceViewerConfiguration(); // never null when viewer instantiated
				String partition= document.getContentType(sel.x);
				ITextDoubleClickStrategy dcs= svc.getDoubleClickStrategy(viewer, partition);

					dcs.doubleClicked(viewer);
					sel= viewer.getSelectedRange();
				} 
				if (selY == 0)
					return;	// if the selection is still empty, we're done
			}

			String target= document.get(sel.x, selY);
			//bug 8515
			String replacement= replace(target);
			if (!target.equals(replacement)) {
				document.replace(sel.x, target.length(), replacement);
				//the replacement might be larger than the original
				int adjustment = replacement.length() - target.length();
				if (adjustment > 0)
					selY += adjustment;
			}
		} catch (BadLocationException x) {
			// ignore and return

		}

		// reinstall selection and move it into view
		viewer.setSelectedRange(sel.x, selY);
		// don't use the viewer's reveal feature in order to avoid jumping around		
		st.showSelection();
	}

		}
		setEnabled(enabled);
	}
	
	protected abstract String replace(String original);
}

Lines 286-291 Link Here

(-)src/org/eclipse/ui/texteditor/EditorMessages.properties (+9 lines)
286	Editor.LowerCase.image=	286	Editor.LowerCase.image=
287	Editor.LowerCase.description=Changes the selection to lower case	287	Editor.LowerCase.description=Changes the selection to lower case
288		288
		289	Editor.InvertCase.label=Invert Case
		290	Editor.InvertCase.tooltip=Inverts the case of the selection
		291	Editor.InvertCase.image=
		292	Editor.InvertCase.description=Inverts the case of the selection
		293
		294	Editor.CapitalizeCase.label=Capitalize Case
		295	Editor.CapitalizeCase.tooltip=Capitalizes the selection
		296	Editor.CapitalizeCase.image=
		297	Editor.CapitalizeCase.description=Capitalizes the selection
289		298
290	## Status line ##	299	## Status line ##
291		300





	/**
	 * Help context id for the action.
	 * Value: <code>"org.eclipse.ui.invert_case_action_context"</code>
	 * @since 3.0
	 */
	public static final String INVERT_CASE_ACTION= PREFIX + "invert_case" + ACTION_POSTFIX; //$NON-NLS-1$
	
	/**
	 * Help context id for the action.
	 * Value: <code>"org.eclipse.ui.capitalize_case_action_context"</code>
	 * @since 3.0
	 */
	public static final String CAPITALIZE_CASE_ACTION= PREFIX + "capitalize_case" + ACTION_POSTFIX; //$NON-NLS-1$	
	
	/**
	 * Help context id for the action.
	 * Value: <code>"org.eclipse.ui.smart_enter_action_context"</code>
	 * @since 3.0
	 */




	 * @since 3.0
	 */
	static final String LOWER_CASE= "LowerCase"; //$NON-NLS-1$

	/** 
	 * Name of the action to invert a selection's case 
	 * Value: <code>"LowerCase"</code>
	 * @since 3.0
	 */
	static final String INVERT_CASE= "InvertCase"; //$NON-NLS-1$
		
	/** 
	 * Name of the action to turn a selection to capitalized case 
	 * Value: <code>"LowerCase"</code>
	 * @since 3.0
	 */
	static final String CAPITALIZE_CASE= "CapitalizeCase"; //$NON-NLS-1$
	
	/** 
	 * Name of the action to find next. 




	 * @since 3.0
	 */
	public static final String UPPER_CASE= "org.eclipse.ui.edit.text.upperCase"; //$NON-NLS-1$

	/**
	 * Action definition id of the upper case action.
	 * Value: <code>"org.eclipse.ui.edit.text.lowerCase"</code>
	 * @since 3.0
	 */
	public static final String LOWER_CASE= "org.eclipse.ui.edit.text.lowerCase"; //$NON-NLS-1$
		
	/**
	 * Action definition id of the lower case action.
	 * Value: <code>"org.eclipse.ui.edit.text.lowerCase"</code>
	 * @since 3.0
	 */
	public static final String INVERT_CASE= "org.eclipse.ui.edit.text.invertCase"; //$NON-NLS-1$
	
	/**
	 * Action definition id of the lower case action.
	 * Value: <code>"org.eclipse.ui.edit.text.lowerCase"</code>
	 * @since 3.0
	 */
	public static final String CAPITALIZE_CASE= "org.eclipse.ui.edit.text.capitalizeCase"; //$NON-NLS-1$
	

	// navigation
	
	/**




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     Sebastian Davids <sdavids@gmx.de> - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.internal.texteditor;

import java.util.StringTokenizer;

/**
 * Helper class to provide String manipulation functions not available in standard JDK.
 */
public class Strings {

	private Strings() {}

	/** 
	 * Inverts the case of each letter of the given <code>String</code>.
	 * <p>
	 * This methods handles the special cases where a lower case letter will be
	 * represented as two upper case letters, e.g. German &szlig; -> SS.
	 * <p>
	 * <strong>Attention:</strong>
	 * <ul>
	 * 	<li>The length of the inverted string may be greater than the original
	 * 	one's.</li>
	 * 	<li>The inversion might not be reversible, e.g. German <em>Ma&szlig;e</em>
	 * 	will be inverted to <em>mASSE</em>; but inverting <em>mASSE</em> will
	 * 	produce <em>Masse</em>.</li>
	 * </ul>
	 * 
	 * @param s the <code>String</code> to be inverted.
	 * @return the inverted <code>String</code>
	 */
	public static String invertCase(String s) {
		if (s == null)
			return null;

		final int len= s.length();

		if (len == 0)
			return s;

		int i;
		char c;

		//skip to the first lower case letter
		for (i= 0; i < len; ++i) {
			c= s.charAt(i);

			if (Character.isLetter(c) && Character.isLowerCase(c))
				break;
		}

		if (i == len)
			return s.toLowerCase();

		StringBuffer result= new StringBuffer(len);

		//append characters before first lower case letter
		result.append(s.substring(0, i).toLowerCase());

		String cS;

		for (; i < len; ++i) {
			c= s.charAt(i);

			if (Character.isLetter(c)) {
				if (Character.isLowerCase(c)) {
					cS= ("" + c).toUpperCase(); //$NON-NLS-1$

					result.append(cS);
				} else
					result.append(Character.toLowerCase(c));
			} else
				result.append(c);
		}

		return result.toString();
	}

	/** 
	 * Capitalizes the given <code>String</code>.
	 * <p>
	 * Rules:
	 * <p>
	 * <ul>
	 *   <li>if the first character is a letter it will be upper case</li>
	 *   <li>each letter directly after a whitespace will be in upper case</li>
	 * </ul>
	 * 
	 * @param s the <code>String</code> to be capitalized.
	 * @return the capitalized <code>String</code>
	 */
	public static String capitalize(String s) {
		if (s == null)
			return null;

		final int len= s.length();

		if (len == 0)
			return s;

		if (len == 1)
			return s.toUpperCase();

		StringTokenizer st= new StringTokenizer(s, " \t\n\r\f", true); //$NON-NLS-1$

		StringBuffer result= new StringBuffer(s.length());

		while (st.hasMoreTokens())
			upperCaseFirstLetter(result, st.nextToken());

		return result.toString();
	}

	/**
	 * Converts the first character of <code>token</code> to upper case if it is
	 * a letter and append the converted <code>String</code> to <code>buf</code>;
	 * if the first character is not a letter, <code>token</code> will be
	 * appended to <code>buf</code> without any processing.
	 * 
	 * @param buf the <code>StringBuffer</code> the processed <code>token</code> will be appended to.
	 * @param token the token.
	 */
	private static void upperCaseFirstLetter(StringBuffer buf, String token) {
		//assert token.length() != 0;
		char firstChar= token.charAt(0);

		if (!Character.isLetter(firstChar)) {
			buf.append(token);
			return;
		}

		buf.append(("" + firstChar).toUpperCase()); //$NON-NLS-1$

		int len= token.length();

		if (len > 1)
			buf.append(token.substring(1, len));
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.internal.texteditor;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.jdt.internal.corext.util.Strings;

public class StringsTest extends TestCase {

		public void testInvertCase() {
			assertEquals("null", null, Strings.invertCase(null)); //$NON-NLS-1$
	
			assertEquals("empty", //$NON-NLS-1$ 
			"", //$NON-NLS-1$
			Strings.invertCase("")); //$NON-NLS-1$
	
			assertEquals("&ABC1", //$NON-NLS-1$
			"&abc1", //$NON-NLS-1$ 
			Strings.invertCase("&ABC1")); //$NON-NLS-1$
	
			assertEquals("A", //$NON-NLS-1$
			"a", //$NON-NLS-1$ 
			Strings.invertCase("A")); //$NON-NLS-1$
	
			assertEquals("AAA", //$NON-NLS-1$
			"aaa", //$NON-NLS-1$ 
			Strings.invertCase("AAA")); //$NON-NLS-1$
	
			assertEquals("b", //$NON-NLS-1$
			"B", //$NON-NLS-1$ 
			Strings.invertCase("b")); //$NON-NLS-1$
	
			assertEquals("aB", //$NON-NLS-1$
			"Ab", //$NON-NLS-1$ 
			Strings.invertCase("aB")); //$NON-NLS-1$
	
			assertEquals("Ab", //$NON-NLS-1$
			"aB", //$NON-NLS-1$ 
			Strings.invertCase("Ab")); //$NON-NLS-1$
	
			assertEquals("aBa", //$NON-NLS-1$
			"AbA", //$NON-NLS-1$ 
			Strings.invertCase("aBa")); //$NON-NLS-1$
	
			assertEquals("AbA", //$NON-NLS-1$
			"aBa", //$NON-NLS-1$ 
			Strings.invertCase("AbA")); //$NON-NLS-1$
	
			assertEquals("Maße", //$NON-NLS-1$
			"mASSE", //$NON-NLS-1$
			Strings.invertCase("Maße")); //$NON-NLS-1$
	
			assertEquals("mASSE", //$NON-NLS-1$
			"Masse", //$NON-NLS-1$
			Strings.invertCase("mASSE")); //$NON-NLS-1$
	
			assertEquals("&ßö\t\";AÜ4", //$NON-NLS-1$ 
			"&SSÖ\t\";aü4", //$NON-NLS-1$ 
			Strings.invertCase("&ßö\t\";AÜ4")); //$NON-NLS-1$
		}
 	
	
		public void testCapitalize() {
			assertEquals("null", null, Strings.capitalize(null)); //$NON-NLS-1$
	
			assertEquals("empty", //$NON-NLS-1$ 
			"", //$NON-NLS-1$
			Strings.capitalize("")); //$NON-NLS-1$
	
			assertEquals("a", //$NON-NLS-1$
			"A", //$NON-NLS-1$ 
			Strings.capitalize("a")); //$NON-NLS-1$
	
			assertEquals("A", //$NON-NLS-1$
			"A", //$NON-NLS-1$ 
			Strings.capitalize("A")); //$NON-NLS-1$
	
			assertEquals("ß", //$NON-NLS-1$
			"SS", //$NON-NLS-1$ 
			Strings.capitalize("ß")); //$NON-NLS-1$
 
			assertEquals("ab", //$NON-NLS-1$
			"Ab", //$NON-NLS-1$ 
			Strings.capitalize("Ab")); //$NON-NLS-1$
	
			assertEquals("1a", //$NON-NLS-1$
			"1a", //$NON-NLS-1$ 
			Strings.capitalize("1a")); //$NON-NLS-1$
	
			assertEquals(" a", //$NON-NLS-1$
			" A", //$NON-NLS-1$ 
			Strings.capitalize(" a")); //$NON-NLS-1$	
	
			assertEquals("a ", //$NON-NLS-1$
			"A ", //$NON-NLS-1$ 
			Strings.capitalize("a ")); //$NON-NLS-1$
	
			assertEquals(" A", //$NON-NLS-1$
			" A", //$NON-NLS-1$ 
			Strings.capitalize(" A")); //$NON-NLS-1$				
	
			assertEquals("A ", //$NON-NLS-1$
			"A ", //$NON-NLS-1$ 
			Strings.capitalize("A ")); //$NON-NLS-1$				
	
			assertEquals(" ß", //$NON-NLS-1$
			" SS", //$NON-NLS-1$ 
			Strings.capitalize(" ß")); //$NON-NLS-1$
	
			assertEquals("ß ", //$NON-NLS-1$
			"SS ", //$NON-NLS-1$ 
			Strings.capitalize("ß ")); //$NON-NLS-1$
	
			assertEquals(" ab", //$NON-NLS-1$
			" Ab", //$NON-NLS-1$ 
			Strings.capitalize(" ab")); //$NON-NLS-1$	
	
			assertEquals(" 1a", //$NON-NLS-1$
			" 1a", //$NON-NLS-1$ 
			Strings.capitalize(" 1a")); //$NON-NLS-1$	
	
			assertEquals("\\ta", //$NON-NLS-1$
			"\tA", //$NON-NLS-1$ 
			Strings.capitalize("\ta")); //$NON-NLS-1$	
	
			assertEquals("a\\t", //$NON-NLS-1$
			"A\t", //$NON-NLS-1$ 
			Strings.capitalize("a\t")); //$NON-NLS-1$	
	
			assertEquals("\\tA", //$NON-NLS-1$
			"\tA", //$NON-NLS-1$ 
			Strings.capitalize("\tA")); //$NON-NLS-1$				
	
			assertEquals("A\\t", //$NON-NLS-1$
			"A\t", //$NON-NLS-1$ 
			Strings.capitalize("A\t")); //$NON-NLS-1$		
	
			assertEquals("\\t1ab", //$NON-NLS-1$
		"\t1ab", //$NON-NLS-1$ 
			Strings.capitalize("\t1ab")); //$NON-NLS-1$	
	
			assertEquals("\\t1a", //$NON-NLS-1$
		"\t1a", //$NON-NLS-1$ 
			Strings.capitalize("\t1a")); //$NON-NLS-1$	
	
			assertEquals("a\\tb cd", //$NON-NLS-1$
			"A\tBa SSd", //$NON-NLS-1$ 
			Strings.capitalize("a\tba ßd")); //$NON-NLS-1$	
		}
	
	public static Test suite() {
		return new TestSuite(StringsTest.class);
	}
}





/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     Sebastian Davids <sdavids@gmx.de> - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.texteditor;

import java.util.ResourceBundle;

import org.eclipse.ui.internal.texteditor.Strings;

/**
 * Action that capitalizes the current selection.
 * @since 3.0
 */
public class CapitalizeCaseAction extends CaseAction {

	/**
	 * Creates and initializes the action for the given text editor.
	 * The action configures its visual representation from the given resource
	 * bundle. 
	 * 
	 * @param bundle the resource bundle
	 * @param prefix a prefix to be prepended to the various resource keys
	 *   (described in <code>ResourceAction</code> constructor), or  <code>null</code> if none
	 * @param editor the text editor
	 * @param toUpper <code>true</code> if this is an uppercase action, <code>false</code> otherwise.
	 * 
	 * @see ResourceAction#ResourceAction
	 */
	public CapitalizeCaseAction(ResourceBundle bundle, String prefix, AbstractTextEditor editor) {
		super(bundle, prefix, editor);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.CaseAction#replace(java.lang.String)
	 */	
	protected String replace(String original) {
		return Strings.capitalize(original);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     Sebastian Davids <sdavids@gmx.de> - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.texteditor;

import java.util.ResourceBundle;

import org.eclipse.ui.internal.texteditor.Strings;

/**
 * Action that inverts the case of the current selection.
 * @since 3.0
 */
public class InvertCaseAction extends CaseAction {

	/**
	 * Creates and initializes the action for the given text editor.
	 * The action configures its visual representation from the given resource bundle. 
	 * 
	 * @param bundle the resource bundle
	 * @param prefix a prefix to be prepended to the various resource keys
	 *   (described in <code>ResourceAction</code> constructor), or  <code>null</code> if none
	 * @param editor the text editor
	 * 
	 * @see ResourceAction#ResourceAction
	 */
	public InvertCaseAction(ResourceBundle bundle, String prefix, AbstractTextEditor editor) {
		super(bundle, prefix, editor);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.CaseAction#replace(java.lang.String)
	 */
	protected String replace(String original) {
		return Strings.invertCase(original);
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     Sebastian Davids <sdavids@gmx.de> - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.texteditor;

import java.util.ResourceBundle;

/**
 * Action that converts the current selection to upper or lower case.
 * @since 3.0
 */
public class UpperLowerCaseAction extends CaseAction {

	/** <code>true</code> if this action converts to upper case, <code>false</code> otherwise. */
	private boolean fToUpper;

	/**
	 * Creates and initializes the action for the given text editor.
	 * The action configures its visual representation from the given resource bundle. 
	 * 
	 * @param bundle the resource bundle
	 * @param prefix a prefix to be prepended to the various resource keys
	 *   (described in <code>ResourceAction</code> constructor), or  <code>null</code> if none
	 * @param editor the text editor
	 * @param toUpper <code>true</code> if this is an uppercase action, <code>false</code> otherwise.
	 * 
	 * @see ResourceAction#ResourceAction
	 */
	public UpperLowerCaseAction(ResourceBundle bundle, String prefix, AbstractTextEditor editor, boolean toUpper) {
		super(bundle, prefix, editor);
		fToUpper= toUpper;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.texteditor.CaseAction#replace(java.lang.String)
	 */	
	protected String replace(String original) {
		return (fToUpper ? original.toUpperCase() : original.toLowerCase());
	}
}

Return to bug 8518

Lines 129-135 Link Here

(-)plugin.xml (-1 / +31 lines)
129	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">	129	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">
130	</keyBinding>	130	</keyBinding>
131	</extension>	131	</extension>
132		132	<extension
		133	point="org.eclipse.ui.commands">
		134	<command
		135	name="%invertCase.label"
		136	description="%invertCase.description"
		137	category="org.eclipse.ui.category.textEditor"
		138	id="org.eclipse.ui.edit.text.invertCase">
		139	</command>
		140	<keyBinding
		141	string="Ctrl+Shift+I"
		142	scope="org.eclipse.ui.textEditorScope"
		143	command="org.eclipse.ui.edit.text.invertCase"
		144	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">
		145	</keyBinding>
		146	</extension>
		147	<extension
		148	point="org.eclipse.ui.commands">
		149	<command
		150	name="%capitalizeCase.label"
		151	description="%capitalizeCase.description"
		152	category="org.eclipse.ui.category.textEditor"
		153	id="org.eclipse.ui.edit.text.capitalizeCase">
		154	</command>
		155	<keyBinding
		156	string="Ctrl+Shift+C"
		157	scope="org.eclipse.ui.textEditorScope"
		158	command="org.eclipse.ui.edit.text.capitalizeCase"
		159	configuration="org.eclipse.ui.defaultAcceleratorConfiguration">
		160	</keyBinding>
		161	</extension>
		162
133	<!-- action sets -->	163	<!-- action sets -->
134	<extension	164	<extension
135	point="org.eclipse.ui.actionSets">	165	point="org.eclipse.ui.actionSets">

Lines 3730-3744 Link Here

(-)src/org/eclipse/ui/texteditor/AbstractTextEditor.java (-2 / +12 lines)
3730	action.setActionDefinitionId(ITextEditorActionDefinitionIds.MOVE_LINES_DOWN);	3730	action.setActionDefinitionId(ITextEditorActionDefinitionIds.MOVE_LINES_DOWN);
3731	setAction(ITextEditorActionConstants.MOVE_LINE_DOWN, action);	3731	setAction(ITextEditorActionConstants.MOVE_LINE_DOWN, action);
3732		3732
3733	action = new CaseAction(EditorMessages.getResourceBundle(), "Editor.UpperCase.", this, true); //$NON-NLS-1$	3733	action = new UpperLowerCaseAction(EditorMessages.getResourceBundle(), "Editor.UpperCase.", this, true); //$NON-NLS-1$
3734	action.setHelpContextId(IAbstractTextEditorHelpContextIds.UPPER_CASE_ACTION);	3734	action.setHelpContextId(IAbstractTextEditorHelpContextIds.UPPER_CASE_ACTION);
3735	action.setActionDefinitionId(ITextEditorActionDefinitionIds.UPPER_CASE);	3735	action.setActionDefinitionId(ITextEditorActionDefinitionIds.UPPER_CASE);
3736	setAction(ITextEditorActionConstants.UPPER_CASE, action);	3736	setAction(ITextEditorActionConstants.UPPER_CASE, action);
3737		3737
3738	action = new CaseAction(EditorMessages.getResourceBundle(), "Editor.LowerCase.", this, false); //$NON-NLS-1$	3738	action = new UpperLowerCaseAction(EditorMessages.getResourceBundle(), "Editor.LowerCase.", this, false); //$NON-NLS-1$
3739	action.setHelpContextId(IAbstractTextEditorHelpContextIds.LOWER_CASE_ACTION);	3739	action.setHelpContextId(IAbstractTextEditorHelpContextIds.LOWER_CASE_ACTION);
3740	action.setActionDefinitionId(ITextEditorActionDefinitionIds.LOWER_CASE);	3740	action.setActionDefinitionId(ITextEditorActionDefinitionIds.LOWER_CASE);
3741	setAction(ITextEditorActionConstants.LOWER_CASE, action);	3741	setAction(ITextEditorActionConstants.LOWER_CASE, action);
		3742
		3743	action = new InvertCaseAction(EditorMessages.getResourceBundle(), "Editor.InvertCase.", this); //$NON-NLS-1$
		3744	action.setHelpContextId(IAbstractTextEditorHelpContextIds.INVERT_CASE_ACTION);
		3745	action.setActionDefinitionId(ITextEditorActionDefinitionIds.INVERT_CASE);
		3746	setAction(ITextEditorActionConstants.INVERT_CASE, action);
		3747
		3748	action = new CapitalizeCaseAction(EditorMessages.getResourceBundle(), "Editor.CapitalizeCase.", this); //$NON-NLS-1$
		3749	action.setHelpContextId(IAbstractTextEditorHelpContextIds.INVERT_CASE_ACTION);
		3750	action.setActionDefinitionId(ITextEditorActionDefinitionIds.CAPITALIZE_CASE);
		3751	setAction(ITextEditorActionConstants.INVERT_CASE, action);
3742		3752
3743	action = new SmartEnterAction(EditorMessages.getResourceBundle(), "Editor.SmartEnter.", this, false); //$NON-NLS-1$	3753	action = new SmartEnterAction(EditorMessages.getResourceBundle(), "Editor.SmartEnter.", this, false); //$NON-NLS-1$
3744	action.setHelpContextId(IAbstractTextEditorHelpContextIds.SMART_ENTER_ACTION);	3754	action.setHelpContextId(IAbstractTextEditorHelpContextIds.SMART_ENTER_ACTION);

Lines 196-201 Link Here

(-)src/org/eclipse/ui/texteditor/ITextEditorActionConstants.java (+14 lines)
196	* @since 3.0	196	* @since 3.0
197	*/	197	*/
198	static final String LOWER_CASE= "LowerCase"; //$NON-NLS-1$	198	static final String LOWER_CASE= "LowerCase"; //$NON-NLS-1$
		199
		200	/**
		201	* Name of the action to invert a selection's case
		202	* Value: <code>"LowerCase"</code>
		203	* @since 3.0
		204	*/
		205	static final String INVERT_CASE= "InvertCase"; //$NON-NLS-1$
		206
		207	/**
		208	* Name of the action to turn a selection to capitalized case
		209	* Value: <code>"LowerCase"</code>
		210	* @since 3.0
		211	*/
		212	static final String CAPITALIZE_CASE= "CapitalizeCase"; //$NON-NLS-1$
199		213
200	/**	214	/**
201	* Name of the action to find next.	215	* Name of the action to find next.

Lines 111-125 Link Here

(-)src/org/eclipse/ui/texteditor/ITextEditorActionDefinitionIds.java (-2 / +15 lines)
111	* @since 3.0	111	* @since 3.0
112	*/	112	*/
113	public static final String UPPER_CASE= "org.eclipse.ui.edit.text.upperCase"; //$NON-NLS-1$	113	public static final String UPPER_CASE= "org.eclipse.ui.edit.text.upperCase"; //$NON-NLS-1$
		114
		115	/**
		116	* Action definition id of the upper case action.
		117	* Value: <code>"org.eclipse.ui.edit.text.lowerCase"</code>
		118	* @since 3.0
		119	*/
		120	public static final String LOWER_CASE= "org.eclipse.ui.edit.text.lowerCase"; //$NON-NLS-1$
		121
		122	/**
		123	* Action definition id of the lower case action.
		124	* Value: <code>"org.eclipse.ui.edit.text.lowerCase"</code>
		125	* @since 3.0
		126	*/
		127	public static final String INVERT_CASE= "org.eclipse.ui.edit.text.invertCase"; //$NON-NLS-1$
114		128
115	/**	129	/**
116	* Action definition id of the lower case action.	130	* Action definition id of the lower case action.
117	* Value: <code>"org.eclipse.ui.edit.text.lowerCase"</code>	131	* Value: <code>"org.eclipse.ui.edit.text.lowerCase"</code>
118	* @since 3.0	132	* @since 3.0
119	*/	133	*/
120	public static final String LOWER_CASE= "org.eclipse.ui.edit.text.lowerCase"; //$NON-NLS-1$	134	public static final String CAPITALIZE_CASE= "org.eclipse.ui.edit.text.capitalizeCase"; //$NON-NLS-1$
121		135
122
123	// navigation	136	// navigation
124		137
125	/**	138	/**

Lines 7-12 Link Here

(-)src/org/eclipse/ui/texteditor/CaseAction.java (-15 / +17 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Sebastian Davids <sdavids@gmx.de> - bug 8515
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.ui.texteditor;	12	package org.eclipse.ui.texteditor;
12		13
Lines 21-37 Link Here
21	import org.eclipse.swt.graphics.Point;	22	import org.eclipse.swt.graphics.Point;
22		23
23	/**	24	/**
24	* Action that converts the current selection to lower case.	25	* Action that converts the current selection to a different case.
25	* @since 3.0	26	* @since 3.0
26	*/	27	*/
27	public class CaseAction extends ResourceAction implements IUpdate {	28	public abstract class CaseAction extends ResourceAction implements IUpdate {
28		29
29	/** The editor we are working on. */	30	/** The editor we are working on. */
30	private AbstractTextEditor fEditor;	31	private AbstractTextEditor fEditor;
31		32
32	/** <code>true</code> if this action converts to upper case, <code>false</code> otherwise. */
33	private boolean fToUpper;
34
35	/**	33	/**
36	* Creates and initializes the action for the given text editor.	34	* Creates and initializes the action for the given text editor.
37	* The action configures its visual representation from the given resource	35	* The action configures its visual representation from the given resource
Lines 41-54 Link Here
41	* @param prefix a prefix to be prepended to the various resource keys	39	* @param prefix a prefix to be prepended to the various resource keys
42	* (described in <code>ResourceAction</code> constructor), or <code>null</code> if none	40	* (described in <code>ResourceAction</code> constructor), or <code>null</code> if none
43	* @param editor the text editor	41	* @param editor the text editor
44	* @param toUpper <code>true</code> if this is an uppercase action, <code>false</code> otherwise.
45	*
46	* @see ResourceAction#ResourceAction	42	* @see ResourceAction#ResourceAction
47	*/	43	*/
48	public CaseAction(ResourceBundle bundle, String prefix, AbstractTextEditor editor, boolean toUpper) {	44	public CaseAction(ResourceBundle bundle, String prefix, AbstractTextEditor editor) {
49	super(bundle, prefix);	45	super(bundle, prefix);
50	fEditor= editor;	46	fEditor= editor;
51	fToUpper= toUpper;
52	update();	47	update();
53	}	48	}
54		49
Lines 77-87 Link Here
77	Point sel= viewer.getSelectedRange();	72	Point sel= viewer.getSelectedRange();
78	if (sel == null)	73	if (sel == null)
79	return;	74	return;
80		75	int selY = sel.y;
81	try {	76	try {
82	// if the selection is emtpy, we select the word / string using the viewer's	77	// if the selection is emtpy, we select the word / string using the viewer's
83	// doubleclick strategy	78	// doubleclick strategy
84	if (sel.y == 0) {	79	if (selY == 0) {
85	SourceViewerConfiguration svc= fEditor.getSourceViewerConfiguration(); // never null when viewer instantiated	80	SourceViewerConfiguration svc= fEditor.getSourceViewerConfiguration(); // never null when viewer instantiated
86	String partition= document.getContentType(sel.x);	81	String partition= document.getContentType(sel.x);
87	ITextDoubleClickStrategy dcs= svc.getDoubleClickStrategy(viewer, partition);	82	ITextDoubleClickStrategy dcs= svc.getDoubleClickStrategy(viewer, partition);
Lines 89-102 Link Here
89	dcs.doubleClicked(viewer);	84	dcs.doubleClicked(viewer);
90	sel= viewer.getSelectedRange();	85	sel= viewer.getSelectedRange();
91	}	86	}
92	if (sel.y == 0)	87	if (selY == 0)
93	return; // if the selection is still empty, we're done	88	return; // if the selection is still empty, we're done
94	}	89	}
95		90
96	String target= document.get(sel.x, sel.y);	91	String target= document.get(sel.x, selY);
97	String replacement= (fToUpper ? target.toUpperCase() : target.toLowerCase());	92	//bug 8515
		93	String replacement= replace(target);
98	if (!target.equals(replacement)) {	94	if (!target.equals(replacement)) {
99	document.replace(sel.x, target.length(), replacement);	95	document.replace(sel.x, target.length(), replacement);
		96	//the replacement might be larger than the original
		97	int adjustment = replacement.length() - target.length();
		98	if (adjustment > 0)
		99	selY += adjustment;
100	}	100	}
101	} catch (BadLocationException x) {	101	} catch (BadLocationException x) {
102	// ignore and return	102	// ignore and return
Lines 104-110 Link Here
104	}	104	}
105		105
106	// reinstall selection and move it into view	106	// reinstall selection and move it into view
107	viewer.setSelectedRange(sel.x, sel.y);	107	viewer.setSelectedRange(sel.x, selY);
108	// don't use the viewer's reveal feature in order to avoid jumping around	108	// don't use the viewer's reveal feature in order to avoid jumping around
109	st.showSelection();	109	st.showSelection();
110	}	110	}
Lines 123-126 Link Here
123	}	123	}
124	setEnabled(enabled);	124	setEnabled(enabled);
125	}	125	}
		126
		127	protected abstract String replace(String original);
126	}	128	}

Lines 282-287 Link Here

(-)src/org/eclipse/ui/texteditor/IAbstractTextEditorHelpContextIds.java (+14 lines)
282		282
283	/**	283	/**
284	* Help context id for the action.	284	* Help context id for the action.
		285	* Value: <code>"org.eclipse.ui.invert_case_action_context"</code>
		286	* @since 3.0
		287	*/
		288	public static final String INVERT_CASE_ACTION= PREFIX + "invert_case" + ACTION_POSTFIX; //$NON-NLS-1$
		289
		290	/**
		291	* Help context id for the action.
		292	* Value: <code>"org.eclipse.ui.capitalize_case_action_context"</code>
		293	* @since 3.0
		294	*/
		295	public static final String CAPITALIZE_CASE_ACTION= PREFIX + "capitalize_case" + ACTION_POSTFIX; //$NON-NLS-1$
		296
		297	/**
		298	* Help context id for the action.
285	* Value: <code>"org.eclipse.ui.smart_enter_action_context"</code>	299	* Value: <code>"org.eclipse.ui.smart_enter_action_context"</code>
286	* @since 3.0	300	* @since 3.0
287	*/	301	*/

Added Link Here

(-)src/org/eclipse/ui/internal/texteditor/Strings.java (+147 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Sebastian Davids <sdavids@gmx.de> - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.internal.texteditor;
12
13	import java.util.StringTokenizer;
14
15	/**
16	* Helper class to provide String manipulation functions not available in standard JDK.
17	*/
18	public class Strings {
19
20	private Strings() {}
21
22	/**
23	* Inverts the case of each letter of the given <code>String</code>.
24	* <p>
25	* This methods handles the special cases where a lower case letter will be
26	* represented as two upper case letters, e.g. German ß -> SS.
27	* <p>
28	* <strong>Attention:</strong>
29	* <ul>
30	* <li>The length of the inverted string may be greater than the original
31	* one's.</li>
32	* <li>The inversion might not be reversible, e.g. German <em>Maße</em>
33	* will be inverted to <em>mASSE</em>; but inverting <em>mASSE</em> will
34	* produce <em>Masse</em>.</li>
35	* </ul>
36	*
37	* @param s the <code>String</code> to be inverted.
38	* @return the inverted <code>String</code>
39	*/
40	public static String invertCase(String s) {
41	if (s == null)
42	return null;
43
44	final int len= s.length();
45
46	if (len == 0)
47	return s;
48
49	int i;
50	char c;
51
52	//skip to the first lower case letter
53	for (i= 0; i < len; ++i) {
54	c= s.charAt(i);
55
56	if (Character.isLetter(c) && Character.isLowerCase(c))
57	break;
58	}
59
60	if (i == len)
61	return s.toLowerCase();
62
63	StringBuffer result= new StringBuffer(len);
64
65	//append characters before first lower case letter
66	result.append(s.substring(0, i).toLowerCase());
67
68	String cS;
69
70	for (; i < len; ++i) {
71	c= s.charAt(i);
72
73	if (Character.isLetter(c)) {
74	if (Character.isLowerCase(c)) {
75	cS= ("" + c).toUpperCase(); //$NON-NLS-1$
76
77	result.append(cS);
78	} else
79	result.append(Character.toLowerCase(c));
80	} else
81	result.append(c);
82	}
83
84	return result.toString();
85	}
86
87	/**
88	* Capitalizes the given <code>String</code>.
89	* <p>
90	* Rules:
91	* <p>
92	* <ul>
93	* <li>if the first character is a letter it will be upper case</li>
94	* <li>each letter directly after a whitespace will be in upper case</li>
95	* </ul>
96	*
97	* @param s the <code>String</code> to be capitalized.
98	* @return the capitalized <code>String</code>
99	*/
100	public static String capitalize(String s) {
101	if (s == null)
102	return null;
103
104	final int len= s.length();
105
106	if (len == 0)
107	return s;
108
109	if (len == 1)
110	return s.toUpperCase();
111
112	StringTokenizer st= new StringTokenizer(s, " \t\n\r\f", true); //$NON-NLS-1$
113
114	StringBuffer result= new StringBuffer(s.length());
115
116	while (st.hasMoreTokens())
117	upperCaseFirstLetter(result, st.nextToken());
118
119	return result.toString();
120	}
121
122	/**
123	* Converts the first character of <code>token</code> to upper case if it is
124	* a letter and append the converted <code>String</code> to <code>buf</code>;
125	* if the first character is not a letter, <code>token</code> will be
126	* appended to <code>buf</code> without any processing.
127	*
128	* @param buf the <code>StringBuffer</code> the processed <code>token</code> will be appended to.
129	* @param token the token.
130	*/
131	private static void upperCaseFirstLetter(StringBuffer buf, String token) {
132	//assert token.length() != 0;
133	char firstChar= token.charAt(0);
134
135	if (!Character.isLetter(firstChar)) {
136	buf.append(token);
137	return;
138	}
139
140	buf.append(("" + firstChar).toUpperCase()); //$NON-NLS-1$
141
142	int len= token.length();
143
144	if (len > 1)
145	buf.append(token.substring(1, len));
146	}
147	}

Added Link Here

(-)src/org/eclipse/ui/texteditor/CapitalizeCaseAction.java (+46 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Sebastian Davids <sdavids@gmx.de> - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.texteditor;
12
13	import java.util.ResourceBundle;
14
15	import org.eclipse.ui.internal.texteditor.Strings;
16
17	/**
18	* Action that capitalizes the current selection.
19	* @since 3.0
20	*/
21	public class CapitalizeCaseAction extends CaseAction {
22
23	/**
24	* Creates and initializes the action for the given text editor.
25	* The action configures its visual representation from the given resource
26	* bundle.
27	*
28	* @param bundle the resource bundle
29	* @param prefix a prefix to be prepended to the various resource keys
30	* (described in <code>ResourceAction</code> constructor), or <code>null</code> if none
31	* @param editor the text editor
32	* @param toUpper <code>true</code> if this is an uppercase action, <code>false</code> otherwise.
33	*
34	* @see ResourceAction#ResourceAction
35	*/
36	public CapitalizeCaseAction(ResourceBundle bundle, String prefix, AbstractTextEditor editor) {
37	super(bundle, prefix, editor);
38	}
39
40	/* (non-Javadoc)
41	* @see org.eclipse.ui.texteditor.CaseAction#replace(java.lang.String)
42	*/
43	protected String replace(String original) {
44	return Strings.capitalize(original);
45	}
46	}

Added Link Here

(-)src/org/eclipse/ui/texteditor/InvertCaseAction.java (+44 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Sebastian Davids <sdavids@gmx.de> - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.texteditor;
12
13	import java.util.ResourceBundle;
14
15	import org.eclipse.ui.internal.texteditor.Strings;
16
17	/**
18	* Action that inverts the case of the current selection.
19	* @since 3.0
20	*/
21	public class InvertCaseAction extends CaseAction {
22
23	/**
24	* Creates and initializes the action for the given text editor.
25	* The action configures its visual representation from the given resource bundle.
26	*
27	* @param bundle the resource bundle
28	* @param prefix a prefix to be prepended to the various resource keys
29	* (described in <code>ResourceAction</code> constructor), or <code>null</code> if none
30	* @param editor the text editor
31	*
32	* @see ResourceAction#ResourceAction
33	*/
34	public InvertCaseAction(ResourceBundle bundle, String prefix, AbstractTextEditor editor) {
35	super(bundle, prefix, editor);
36	}
37
38	/* (non-Javadoc)
39	* @see org.eclipse.ui.texteditor.CaseAction#replace(java.lang.String)
40	*/
41	protected String replace(String original) {
42	return Strings.invertCase(original);
43	}
44	}

Added Link Here

(-)src/org/eclipse/ui/texteditor/UpperLowerCaseAction.java (+47 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html
7	*
8	* Contributors:
9	* Sebastian Davids <sdavids@gmx.de> - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.ui.texteditor;
12
13	import java.util.ResourceBundle;
14
15	/**
16	* Action that converts the current selection to upper or lower case.
17	* @since 3.0
18	*/
19	public class UpperLowerCaseAction extends CaseAction {
20
21	/** <code>true</code> if this action converts to upper case, <code>false</code> otherwise. */
22	private boolean fToUpper;
23
24	/**
25	* Creates and initializes the action for the given text editor.
26	* The action configures its visual representation from the given resource bundle.
27	*
28	* @param bundle the resource bundle
29	* @param prefix a prefix to be prepended to the various resource keys
30	* (described in <code>ResourceAction</code> constructor), or <code>null</code> if none
31	* @param editor the text editor
32	* @param toUpper <code>true</code> if this is an uppercase action, <code>false</code> otherwise.
33	*
34	* @see ResourceAction#ResourceAction
35	*/
36	public UpperLowerCaseAction(ResourceBundle bundle, String prefix, AbstractTextEditor editor, boolean toUpper) {
37	super(bundle, prefix, editor);
38	fToUpper= toUpper;
39	}
40
41	/* (non-Javadoc)
42	* @see org.eclipse.ui.texteditor.CaseAction#replace(java.lang.String)
43	*/
44	protected String replace(String original) {
45	return (fToUpper ? original.toUpperCase() : original.toLowerCase());
46	}
47	}