Index: core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ChangeSignatureRefactoring.java
===================================================================
RCS file: /home/eclipse/org.eclipse.jdt.ui/core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ChangeSignatureRefactoring.java,v
retrieving revision 1.116
diff -u -r1.116 ChangeSignatureRefactoring.java
--- core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ChangeSignatureRefactoring.java	10 Feb 2005 16:33:59 -0000	1.116
+++ core refactoring/org/eclipse/jdt/internal/corext/refactoring/structure/ChangeSignatureRefactoring.java	12 Mar 2005 10:07:05 -0000
@@ -1,10 +1,10 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2004 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
+ * Copyright (c) 2000, 2005 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/cpl-v10.html
- * 
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
@@ -69,17 +69,21 @@
 import org.eclipse.jdt.core.dom.Name;
 import org.eclipse.jdt.core.dom.PrimitiveType;
 import org.eclipse.jdt.core.dom.QualifiedName;
+import org.eclipse.jdt.core.dom.ReturnStatement;
 import org.eclipse.jdt.core.dom.SimpleName;
 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
+import org.eclipse.jdt.core.dom.Statement;
 import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
 import org.eclipse.jdt.core.dom.SuperMethodInvocation;
 import org.eclipse.jdt.core.dom.TagElement;
 import org.eclipse.jdt.core.dom.TextElement;
 import org.eclipse.jdt.core.dom.Type;
+import org.eclipse.jdt.core.dom.TypeDeclaration;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
 import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
 import org.eclipse.jdt.core.search.IJavaSearchConstants;
 import org.eclipse.jdt.core.search.IJavaSearchScope;
+import org.eclipse.jdt.core.search.SearchMatch;
 import org.eclipse.jdt.core.search.SearchPattern;
 
 import org.eclipse.jdt.internal.corext.Assert;
@@ -119,6 +123,7 @@
 import org.eclipse.jdt.internal.corext.util.WorkingCopyUtil;
 
 import org.eclipse.jdt.internal.ui.JavaPlugin;
+import org.eclipse.jdt.internal.ui.refactoring.RefactoringMessages;
 
 public class ChangeSignatureRefactoring extends Refactoring {
 	
@@ -133,6 +138,12 @@
 	private ReturnTypeInfo fReturnTypeInfo;
 	private String fMethodName;
 	private int fVisibility;
+	private boolean fLeaveStub;
+    private boolean fLeaveBodyStub;
+    private boolean fLeaveForwardingStub;
+    private boolean fTagAsDeprecated;
+	private boolean fUpdateReferences;
+
 	private static final String CONST_CLASS_DECL = "class A{";//$NON-NLS-1$
 	private static final String CONST_ASSIGN = " i=";		//$NON-NLS-1$
 	private static final String CONST_CLOSE = ";}";			//$NON-NLS-1$
@@ -150,6 +161,11 @@
 		fMethodName= getInitialMethodName();
 		fVisibility= getInitialMethodVisibility();
 		fOldVarargIndex= -1;
+		fLeaveStub= false;
+	    fLeaveBodyStub= false;
+	    fLeaveForwardingStub= !fLeaveBodyStub;
+	    fTagAsDeprecated= true;
+		fUpdateReferences= true;
 	}
 	
 	public static ChangeSignatureRefactoring create(IMethod method) throws JavaModelException{
@@ -257,7 +273,46 @@
 		            	visibility == Modifier.PRIVATE);  
 		fVisibility= visibility;            	
 	}
+    public void setLeaveStub(boolean leaveStub) {
+        fLeaveStub=leaveStub;
+    }
+    
+    public boolean shouldLeaveStub() {
+        return fLeaveStub;
+    }
+    
+    public void setLeaveBody(boolean leaveBody) {
+        fLeaveBodyStub=leaveBody;        
+    }
+
+    public boolean getLeaveBody() {
+        return fLeaveBodyStub;
+    }
+
+    public boolean getForwardingStub() {
+        return fLeaveForwardingStub;
+    }
+
+    public void setForwardingStub(boolean forwardingStub) {
+        fLeaveForwardingStub=forwardingStub;        
+    }
+
+    public void setTagAsDeprecated(boolean addTag) {
+        fTagAsDeprecated=addTag;
+    }
+    
+    public boolean shouldTagAsDeprecated() {
+		return fTagAsDeprecated;
+	}
 	
+	public boolean shouldUpdateReferences() {
+		return fUpdateReferences;
+	}
+
+	public void setUpdateReferences(boolean updateReferences) {
+		fUpdateReferences = updateReferences;
+	}
+
 	/*
 	 * @see JdtFlags
 	 */	
@@ -348,12 +403,31 @@
 	private boolean areParameterTypesSameAsInitial() {
 		for (Iterator iter= fParameterInfos.iterator(); iter.hasNext();) {
 			ParameterInfo info= (ParameterInfo) iter.next();
-			if (! info.isAdded() && ! info.isDeleted() && info.isTypeNameChanged())
+			if (info.isAdded() || info.isDeleted() || info.isTypeNameChanged())
 				return false;
 		}
 		return true;
 	}
 	
+	public boolean isSignatureEquivalentToInitial() {
+        if(!isMethodNameSameAsInitial()){
+            return false;
+        }
+        String[] originalTypes= getOriginalParameterTypenames();
+		int i= 0;
+		Iterator iter= fParameterInfos.iterator();
+		while(iter.hasNext()) {
+			ParameterInfo info= (ParameterInfo) iter.next();
+			if (info.isDeleted() ){
+				continue;
+			}
+			if (i >= originalTypes.length || ! info.getNewTypeName().equals(originalTypes[i++])){
+				return false;
+			}
+		}
+		return i == originalTypes.length;
+	}
+	
 	private boolean isReturnTypeSameAsInitial() throws JavaModelException {
 		return ! fReturnTypeInfo.isTypeNameChanged();
 	}
@@ -722,7 +796,7 @@
 			if (result.hasFatalError())
 				return result;
 
-			fRippleMethods= RippleMethodFinder2.getRelatedMethods(fMethod, new SubProgressMonitor(pm, 1), null);
+			fRippleMethods= getRippleMethods(pm);			
 			result.merge(checkVarargs());
 			if (result.hasFatalError())
 				return result;
@@ -768,6 +842,12 @@
 		}
 	}
 
+	private IMethod[] getRippleMethods(IProgressMonitor pm) throws CoreException {
+		if(!shouldUpdateReferences())
+			return new IMethod[] { fMethod };
+		return RippleMethodFinder2.getRelatedMethods(fMethod, new SubProgressMonitor(pm, 1), null);
+	}
+
 	private void clearManagers() {
 		fChangeManager= null;
 	}
@@ -1069,6 +1149,40 @@
 		return result;
 	}
 	
+    private ParameterInfo[] getOriginalParameters() {
+		ParameterInfo[] params= new ParameterInfo[getOriginalParameterCount()];
+		for (Iterator iter= fParameterInfos.iterator(); iter.hasNext();) {
+			ParameterInfo param= (ParameterInfo) iter.next();
+			if (param.isAdded()) {
+				continue;
+			}
+			params[param.getOldIndex()]= param;
+        }
+		return params;
+	}
+    
+    private int getOriginalParameterCount() {
+        int paramCount=0;
+        for (Iterator iter= fParameterInfos.iterator(); iter.hasNext();) {
+            ParameterInfo param= (ParameterInfo) iter.next();
+            if (param.isAdded()) {
+                continue;
+            }
+            ++paramCount;
+        }
+        return paramCount;
+    }        
+
+    private String[] getOriginalParameterTypenames() {
+            ParameterInfo[] params= getOriginalParameters();
+            String [] typenames=new String[params.length];
+            for (int i= 0; i < typenames.length; i++) {
+                    ParameterInfo param= params[i];
+                    typenames[param.getOldIndex()]= param.getOldTypeName();
+            }
+            return typenames;
+    }
+	
 	private Set getOriginalParameterNames() {
 		Set result= new HashSet();
 		for (Iterator iter= fParameterInfos.iterator(); iter.hasNext();) {
@@ -1121,6 +1235,7 @@
 		}else{
 			pm.worked(1);
 		}
+
 		for (int i= 0; i < fOccurrences.length; i++) {
 			if (pm.isCanceled())
 				throw new OperationCanceledException();
@@ -1133,11 +1248,18 @@
 				cuRewrite= fBaseCuRewrite;
 			else
 				cuRewrite= new CompilationUnitRewrite(cu);
-			ASTNode[] nodes= ASTNodeSearchUtil.findNodes(group.getSearchResults(), cuRewrite.getRoot());
-			for (int j= 0; j < nodes.length; j++) {
-				createOccurrenceUpdate(nodes[j], cuRewrite, result).updateNode();
-			}
-			if (isNoArgConstructor && namedSubclassMapping.containsKey(cu)){
+			
+			SearchMatch[] results = group.getSearchResults();
+			for (int j= 0; j < results.length; j++) {
+				SearchMatch searchMatch = results[j];
+				ASTNode node= ASTNodeSearchUtil.findNode(searchMatch, cuRewrite.getRoot());
+				if (node == null)
+					continue;
+				if(shouldUpdateReferences()||fMethod.equals(searchMatch.getElement())) {
+					createOccurrenceUpdate(node, cuRewrite, result).updateNode();
+				}
+			}			
+			if (isNoArgConstructor && shouldUpdateReferences() && namedSubclassMapping.containsKey(cu)){
 				//only non-anonymous subclasses may have noArgConstructors to modify - see bug 43444
 				Set subtypes= (Set)namedSubclassMapping.get(cu);
 				for (Iterator iter= subtypes.iterator(); iter.hasNext();) {
@@ -1628,7 +1750,6 @@
 			}
 			return true;
 		}
-
 	}
 
 	class DeclarationUpdate extends OccurrenceUpdate {
@@ -1638,10 +1759,193 @@
 			super(cuRewrite, cuRewrite.createGroupDescription(RefactoringCoreMessages.getString("ChangeSignatureRefactoring.change_signature")), result); //$NON-NLS-1$
 			fMethDecl= decl;
 		}
+		
+		protected void insertStubFunction() {
+			ASTNode targetClass= fMethDecl.getParent();			
+			ListRewrite listRewrite= getASTRewrite().getListRewrite(
+					targetClass, TypeDeclaration.BODY_DECLARATIONS_PROPERTY);
+            String oldName= getInitialMethodName();
+            String newName= fMethodName;
+			listRewrite.insertAt(createStubFunction(oldName,newName), -1, null);
+		}
+
+		private MethodDeclaration createStubFunction(String oldName,
+				String newName) {
+			final AST ast= getASTRewrite().getAST();
+			MethodDeclaration newMethod= ast.newMethodDeclaration();
+			newMethod.setName(ast.newSimpleName(oldName));
+            createModifiers(ast,newMethod);
+            createExceptions(ast,newMethod);
+			if (shouldTagAsDeprecated() == true) {
+				newMethod.setJavadoc(createDeprecatedTag(ast));
+			}
+			createParameters(ast, newMethod.parameters());
+			String oldTypeName= fReturnTypeInfo.getOldTypeName();
+			if (fMethDecl.isConstructor()) {
+				newMethod.setConstructor(true);
+			} else {
+				ITypeBinding oldTypeBindings=fReturnTypeInfo.getNewTypeBinding();//FIXME How to get OLD type binding?
+				newMethod.setReturnType2(createNewTypeNode(oldTypeName, oldTypeBindings));
+			}
+			createBody(newName, ast, newMethod, oldTypeName);
+			return newMethod;
+		}
+
+		private void createBody(String newName, final AST ast,
+				MethodDeclaration newMethod, String oldType) {
+			TypeDeclaration parent= (TypeDeclaration) fMethDecl.getParent();
+			if (parent.isInterface()) {
+				return;
+			}
+			Block body;
+			if (getLeaveBody() && ((fMethDecl.getModifiers()&Modifier.ABSTRACT)==0)) {
+				body= (Block) ASTNode.copySubtree(ast, fMethDecl.getBody());
+			} else {
+				body= ast.newBlock();
+				body.statements().add(createCallToNewName(ast, oldType, newName));
+			}
+			newMethod.setBody(body);
+
+		}
+
+		private void createExceptions(AST ast, MethodDeclaration newMethod) {
+            List list= fMethDecl.thrownExceptions();
+            for (Iterator iter= list.iterator(); iter.hasNext();) {
+				Name element= (Name) iter.next();
+                newMethod.thrownExceptions().add(ast.newSimpleName(element.getFullyQualifiedName()));
+            }
+		}
+
+		private void createModifiers(AST ast, MethodDeclaration newMethod) {
+			List list= fMethDecl.modifiers();
+			for (Iterator iter= list.iterator(); iter.hasNext();) {
+				Modifier element= (Modifier) iter.next();
+				if (element.getKeyword() == Modifier.ModifierKeyword.ABSTRACT_KEYWORD) {
+					continue;
+				}
+				newMethod.modifiers()
+						.add(ast.newModifier(element.getKeyword()));
+			}
+		}
+
+		private Javadoc createDeprecatedTag(final AST ast) {
+			Javadoc doc=ast.newJavadoc();
+            TagElement deprecated=ast.newTagElement();
+            deprecated.setTagName(TagElement.TAG_DEPRECATED);
+            TextElement useInstead= createUseInstead(ast);
+			deprecated.fragments().add(useInstead);
+            doc.tags().add(deprecated);
+			return doc;
+		}
+
+		private TextElement createUseInstead(final AST ast) {
+			TextElement useInstead= ast.newTextElement();
+			StringBuffer buff= new StringBuffer();
+			String newName= fMethodName;
+			buff.append(RefactoringMessages.getString("ChangeSignatureRefactoring.use_Instead") + " " + newName + "("); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+			boolean first= true;
+			List decParams = fMethDecl.parameters();
+			for (Iterator iter= fParameterInfos.iterator(); iter.hasNext();) {
+				ParameterInfo info= (ParameterInfo) iter.next();
+				if (info.isDeleted()) {
+					continue;
+				}
+				if (!first) {
+					buff.append(", "); //$NON-NLS-1$
+				}
+                first= false;
+				buff.append(info.getNewTypeName() + " ");//$NON-NLS-1$
+				/*
+				 * Not sure what's best here - to use the old names or the new
+				 * ones? The new ones seem more sensible, but if a method is
+				 * overriden, the overriding method may have its own names, so
+				 * use new names doesn't always make sense either.
+				 */
+				if(info.isAdded()) {
+					buff.append(info.getNewName()); 
+				}else {
+					SingleVariableDeclaration decParam= (SingleVariableDeclaration)decParams.get(info.getOldIndex());
+					buff.append(decParam.getName().getIdentifier());
+				}
+			}
+			buff.append(")"); //$NON-NLS-1$
+			useInstead.setText(buff.toString());
+			return useInstead;
+		}
+
+		private void createParameters(final AST ast, List argumentsList) {
+			List decParams = fMethDecl.parameters();
+            for (Iterator iter = decParams.iterator(); iter.hasNext();) {
+				SingleVariableDeclaration decParam = (SingleVariableDeclaration) iter.next();
+				SingleVariableDeclaration newParam = (SingleVariableDeclaration) ASTNode.copySubtree(ast,decParam);
+				argumentsList.add(newParam);
+			}
+		}
+
+		private Statement createCallToNewName(final AST ast, String oldType,
+				String newName) {
+			if (fMethDecl.isConstructor()) {
+				ConstructorInvocation ctr= ast.newConstructorInvocation();
+				addArgumentsToInvoke(ast, ctr.arguments());
+                return ctr;
+			}
+			Expression expression= createInvoke(ast, newName);
+			if (oldType.equals("void")) { //$NON-NLS-1$
+				return ast.newExpressionStatement(expression);
+			}
+			ReturnStatement statement= ast.newReturnStatement();
+			statement.setExpression(expression);
+			return statement;
+		}
+
+        private MethodInvocation createInvoke(final AST ast, String newName) {
+        	MethodInvocation expression= ast.newMethodInvocation();
+			expression.setName(ast.newSimpleName(newName));
+			addArgumentsToInvoke(ast, expression.arguments());
+			return expression;
+		}
+
+        private void addArgumentsToInvoke(final AST ast, List arguments) {
+			List decParams = fMethDecl.parameters();
+            for (int i= 0; i < fParameterInfos.size(); i++) {
+				ParameterInfo parameter= ((ParameterInfo) fParameterInfos
+						.get(i));
+				if (parameter.isDeleted()) {
+					continue;
+				}
+				if (parameter.isAdded()) {
+					String defaultValue= parameter.getDefaultValue();
+					arguments.add(parseExpression(ast, defaultValue));
+				} else {
+//					String[] paramName= new String[] { parameter.getOldName() };
+					SingleVariableDeclaration decParam = (SingleVariableDeclaration) decParams.get(parameter.getOldIndex());
+					String[] paramName= new String[] { decParam.getName().getIdentifier() };
+					arguments.add(ast.newName(paramName));
+				}
+			}
+		}
+
+        // This works. TODO Is there an easier way to do it?
+        // There ought to be an existing, standard way to turn text into an expression.
+        // Given that there is only one other call in the whole of the image to
+		// setKind, this probably isn't the best way to do this.  Not least because 
+        // that call is for a COMPILATION UNIT
+        private Expression parseExpression(AST ast,String code) {
+            ASTParser parser= ASTParser.newParser(ast.apiLevel());
+            parser.setKind(ASTParser.K_EXPRESSION);
+            parser.setSource(code.toCharArray());
+            ASTNode param= parser.createAST(null);
+            return (Expression) ASTNode.copySubtree(ast,param);
+		}
+
 
 		public void updateNode() throws JavaModelException {
 			changeParamguments();
-			
+
+			if (shouldLeaveStub() && !hasStubbableSuperImplementation()) {
+				insertStubFunction();
+			}
+
 			if (canChangeNameAndReturnType()) {
 				changeMethodName();
 				changeReturnType();
@@ -1656,10 +1960,20 @@
 			
 			checkIfDeletedParametersUsed();
 		}
-		
+
+		private boolean hasStubbableSuperImplementation() {
+			return false;
+			/*
+			 * TODO Return true if a super implementation exists. The super has
+			 * been stubbed/will be stubbed and so it would be nice not to stub
+			 * this method as well.
+			 */
+		}
+
 		/** @return {@inheritDoc} (element type: SingleVariableDeclaration) */
 		protected ListRewrite getParamgumentsRewrite() {
-			return getASTRewrite().getListRewrite(fMethDecl, MethodDeclaration.PARAMETERS_PROPERTY);
+			return getASTRewrite().getListRewrite(fMethDecl,
+					MethodDeclaration.PARAMETERS_PROPERTY);
 		}
 
 		protected void changeParamgumentName(ParameterInfo info) {
@@ -2005,6 +2319,7 @@
 		}
 
 		//TODO: already reported as compilation error -> don't report there?
+		//TODO: Warning should be different if local variable with same name exists
 		private void checkIfDeletedParametersUsed() {
 			for (Iterator iter= getDeletedInfos().iterator(); iter.hasNext();) {
 				ParameterInfo info= (ParameterInfo) iter.next();
@@ -2196,4 +2511,3 @@
 		}
 	}
 }
-
Index: ui refactoring/org/eclipse/jdt/internal/ui/refactoring/ChangeSignatureWizard.java
===================================================================
RCS file: /home/eclipse/org.eclipse.jdt.ui/ui refactoring/org/eclipse/jdt/internal/ui/refactoring/ChangeSignatureWizard.java,v
retrieving revision 1.25
diff -u -r1.25 ChangeSignatureWizard.java
--- ui refactoring/org/eclipse/jdt/internal/ui/refactoring/ChangeSignatureWizard.java	7 Feb 2005 17:15:22 -0000	1.25
+++ ui refactoring/org/eclipse/jdt/internal/ui/refactoring/ChangeSignatureWizard.java	12 Mar 2005 10:07:23 -0000
@@ -20,6 +20,7 @@
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Combo;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
@@ -71,6 +72,7 @@
 		public static final String PAGE_NAME= "ChangeSignatureInputPage"; //$NON-NLS-1$
 		private JavaSourceViewer fSignaturePreview;
 		private Document fSignaturePreviewDocument;
+		private StubButtonListener fStubButtonListener;
 		
 		public ChangeSignatureInputPage() {
 			super(PAGE_NAME);
@@ -92,6 +94,7 @@
 				createParameterExceptionsFolder(composite);
 				Label sep= new Label(composite, SWT.SEPARATOR | SWT.HORIZONTAL);
 				sep.setLayoutData((new GridData(GridData.FILL_HORIZONTAL)));
+				createStubOptions(composite); 
 				createSignaturePreview(composite);
 				
 				update(false);
@@ -277,7 +280,121 @@
 			cp.setInput(getChangeMethodSignatureRefactoring().getExceptionInfos());
 			return cp;
 		}
+
+        private void createStubOptions(Composite composite) {
+			Button stub= createCheckButton(composite, RefactoringMessages.getString("ChangeSignatureInputPage.leave_Stub")); //$NON-NLS-1$
+			Button forward= mkLeaveForwardingStubButton(composite);
+			Button original= mkLeaveBodyButton(composite);
+			Button deprecate= mkAddDeprecatedButton(composite);
+			Button updateReferences = mkUpdateReferencesButton(composite);
+			configureLeaveStubButton(stub, new Button[] { forward, original,
+					deprecate, updateReferences });
+		}
+
+		private Button mkUpdateReferencesButton(Composite composite) {
+			Button button = createCheckButton(composite, RefactoringMessages.getString("ChangeSignatureInputPage.update_References")); //$NON-NLS-1$
+			button.setSelection(getChangeMethodSignatureRefactoring().shouldUpdateReferences());
+			button.addSelectionListener(new SelectionAdapter() {
+				public void widgetSelected(SelectionEvent e) {
+					boolean isSelected = ((Button) e.widget).getSelection();
+					getChangeMethodSignatureRefactoring().setUpdateReferences(isSelected);
+				}
+			});
+			return button;
+		}		
+
+		private Button createRadioButton(Composite composite, String text) {
+            Button button= new Button(composite, SWT.RADIO);
+            button.setText(text);
+            return button;
+        }
+
+		class StubButtonListener extends SelectionAdapter {
+			private final Button fSelf;
+            private final Button[] fKids;
+			private boolean fIsDistinct;
+			private boolean fIsSelected;
+			public StubButtonListener(Button stub, Button [] kids) {
+                super();
+				fSelf= stub;
+                fKids= kids;
+			}
+            public void widgetSelected(SelectionEvent e) {
+                fIsSelected= ((Button) e.widget).getSelection();
+				propogateEnable();				
+            }
+			private void updateEnabled(){
+				fIsDistinct= ! getChangeMethodSignatureRefactoring().isSignatureEquivalentToInitial();
+				fSelf.setEnabled(fIsDistinct);
+				propogateEnable();
+			}
+			private void propogateEnable() {
+				getChangeMethodSignatureRefactoring().setLeaveStub(
+                        fIsSelected&&fIsDistinct);
+				for (int i= 0; i < fKids.length; i++) {
+					fKids[i].setEnabled(fIsDistinct&fIsSelected);
+                }
+			}
+        }
 		
+		private void configureLeaveStubButton(Button stub, Button[] kids) {	
+			fStubButtonListener= new StubButtonListener(stub, kids);
+			stub.addSelectionListener(fStubButtonListener);
+            boolean enabled=getChangeMethodSignatureRefactoring().shouldLeaveStub();
+			stub.setSelection(enabled);
+		}
+
+        private Button mkLeaveBodyButton(Composite composite) {
+            Button leaveBody= createRadioButton(composite,
+					RefactoringMessages.getString("ChangeSignatureInputPage.original_Body")); //$NON-NLS-1$ 
+            leaveBody.setSelection(getChangeMethodSignatureRefactoring()
+                    .getLeaveBody());
+            leaveBody.addSelectionListener(new SelectionAdapter() {
+                public void widgetSelected(SelectionEvent e) {
+                    boolean isSelected= ((Button) e.widget).getSelection();
+                    getChangeMethodSignatureRefactoring().setLeaveBody(
+                            isSelected);
+                }
+            });
+            return leaveBody;
+        }
+        
+        private Button mkLeaveForwardingStubButton(Composite composite) {
+            Button forward= createRadioButton(composite,
+					RefactoringMessages.getString("ChangeSignatureInputPage.forwarding_Stub"));  //$NON-NLS-1$
+            forward.setSelection(getChangeMethodSignatureRefactoring()
+                    .getForwardingStub());
+            forward.addSelectionListener(new SelectionAdapter() {
+                public void widgetSelected(SelectionEvent e) {
+                    boolean isSelected= ((Button) e.widget).getSelection();
+                    getChangeMethodSignatureRefactoring().setForwardingStub(
+                            isSelected);
+                }
+            });
+            return forward;
+        }
+
+        private Button mkAddDeprecatedButton(Composite composite) {
+            Button deprecate= createCheckButton(composite,
+					RefactoringMessages.getString("ChangeSignatureInputPage.add_Deprecated_Tag"));  //$NON-NLS-1$
+            deprecate.setSelection(getChangeMethodSignatureRefactoring()
+                    .shouldTagAsDeprecated());
+            deprecate.addSelectionListener(new SelectionAdapter() {
+                public void widgetSelected(SelectionEvent e) {
+                    boolean isSelected= ((Button) e.widget).getSelection();
+                    getChangeMethodSignatureRefactoring().setTagAsDeprecated(
+                            isSelected);
+                }
+            });
+            return deprecate;
+        }
+
+		private Button createCheckButton(Composite composite, String text) {
+            Button button= new Button(composite, SWT.CHECK);
+            button.setText(text);
+            return button;
+        }
+
 		private void createSignaturePreview(Composite composite) {
 			Label previewLabel= new Label(composite, SWT.NONE);
 			previewLabel.setText(RefactoringMessages.getString("ChangeSignatureInputPage.method_Signature_Preview")); //$NON-NLS-1$
@@ -316,6 +433,7 @@
 
 		private void update(boolean displayErrorMessage){
 			updateStatus(displayErrorMessage);
+			updateLeaveStubAvailability();
 			updateSignaturePreview();
 		}
 
@@ -341,6 +459,11 @@
 				setPageComplete(false);
 				JavaPlugin.log(e);
 			}
+		}
+
+		private void updateLeaveStubAvailability() {
+			fStubButtonListener.updateEnabled();
+			
 		}
 
 		private void updateSignaturePreview() {
Index: ui refactoring/org/eclipse/jdt/internal/ui/refactoring/refactoringui.properties
===================================================================
RCS file: /home/eclipse/org.eclipse.jdt.ui/ui refactoring/org/eclipse/jdt/internal/ui/refactoring/refactoringui.properties,v
retrieving revision 1.179
diff -u -r1.179 refactoringui.properties
--- ui refactoring/org/eclipse/jdt/internal/ui/refactoring/refactoringui.properties	20 Jan 2005 15:26:07 -0000	1.179
+++ ui refactoring/org/eclipse/jdt/internal/ui/refactoring/refactoringui.properties	12 Mar 2005 10:07:28 -0000
@@ -204,7 +204,16 @@
 ChangeSignatureInputPage.unchanged=Method signature is unchanged.
 ChangeSignatureInputPage.Internal_Error=Internal Error. See log for details.
 ChangeSignatureInputPage.Change_Signature=Change Signature
+ChangeSignatureInputPage.leave_Stub=&Leave:
+ChangeSignatureInputPage.update_References=&Update references
+ChangeSignatureInputPage.original_Body=Original &body
+ChangeSignatureInputPage.forwarding_Stub=Forwarding &stub
+ChangeSignatureInputPage.add_Deprecated_Tag=Add &deprecated tag
 ChangeSignatureRefactoring.modify_Parameters=Change Method Signature
+ChangeSignatureRefactoring.use_Instead=use instead
+
+
+
 
 RenameTempAction.exception=Unexpected Exception. See log for details
 ModifyParametersAction.unavailable=To activate this refactoring, please select the name of a non-binary method.