| /******************************************************************************* |
| * Copyright (c) 2000, 2006 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.ui.actions; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| |
| import org.eclipse.core.runtime.CoreException; |
| |
| import org.eclipse.core.resources.IWorkspaceRunnable; |
| |
| import org.eclipse.swt.widgets.Shell; |
| |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.operation.IRunnableContext; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.window.Window; |
| |
| import org.eclipse.jface.text.IRewriteTarget; |
| import org.eclipse.jface.text.ITextSelection; |
| |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IWorkbenchSite; |
| import org.eclipse.ui.PlatformUI; |
| |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.core.dom.ASTParser; |
| import org.eclipse.jdt.core.dom.CompilationUnit; |
| import org.eclipse.jdt.core.dom.IMethodBinding; |
| import org.eclipse.jdt.core.dom.ITypeBinding; |
| |
| import org.eclipse.jdt.internal.corext.codemanipulation.AddUnimplementedMethodsOperation; |
| import org.eclipse.jdt.internal.corext.dom.ASTNodes; |
| import org.eclipse.jdt.internal.corext.util.JavaModelUtil; |
| |
| import org.eclipse.jdt.internal.ui.IJavaHelpContextIds; |
| import org.eclipse.jdt.internal.ui.JavaPlugin; |
| import org.eclipse.jdt.internal.ui.actions.ActionMessages; |
| import org.eclipse.jdt.internal.ui.actions.ActionUtil; |
| import org.eclipse.jdt.internal.ui.actions.SelectionConverter; |
| import org.eclipse.jdt.internal.ui.actions.WorkbenchRunnableAdapter; |
| import org.eclipse.jdt.internal.ui.dialogs.OverrideMethodDialog; |
| import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor; |
| import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility; |
| import org.eclipse.jdt.internal.ui.util.BusyIndicatorRunnableContext; |
| import org.eclipse.jdt.internal.ui.util.ElementValidator; |
| import org.eclipse.jdt.internal.ui.util.ExceptionHandler; |
| |
| /** |
| * Adds unimplemented methods of a type. The action opens a dialog from which the user can |
| * choose the methods to be added. |
| * <p> |
| * Will open the parent compilation unit in a Java editor. The result is unsaved, so the |
| * user can decide if the changes are acceptable. |
| * <p> |
| * The action is applicable to structured selections containing elements of type |
| * {@link org.eclipse.jdt.core.IType}. |
| * |
| * <p> |
| * This class may be instantiated; it is not intended to be subclassed. |
| * </p> |
| * |
| * @since 2.0 |
| */ |
| public class OverrideMethodsAction extends SelectionDispatchAction { |
| |
| /** The dialog title */ |
| private static final String DIALOG_TITLE= ActionMessages.OverrideMethodsAction_error_title; |
| |
| /** The compilation unit editor */ |
| private CompilationUnitEditor fEditor; |
| |
| /** |
| * Note: This constructor is for internal use only. Clients should not call this |
| * constructor. |
| * @param editor the compilation unit editor |
| */ |
| public OverrideMethodsAction(final CompilationUnitEditor editor) { |
| this(editor.getEditorSite()); |
| fEditor= editor; |
| setEnabled(checkEnabledEditor()); |
| } |
| |
| /** |
| * Creates a new override method action. |
| * <p> |
| * The action requires that the selection provided by the site's selection provider is |
| * of type {@link org.eclipse.jface.viewers.IStructuredSelection}. |
| * |
| * @param site the workbench site providing context information for this action |
| */ |
| public OverrideMethodsAction(final IWorkbenchSite site) { |
| super(site); |
| setText(ActionMessages.OverrideMethodsAction_label); |
| setDescription(ActionMessages.OverrideMethodsAction_description); |
| setToolTipText(ActionMessages.OverrideMethodsAction_tooltip); |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IJavaHelpContextIds.ADD_UNIMPLEMENTED_METHODS_ACTION); |
| } |
| |
| private boolean canEnable(IStructuredSelection selection) throws JavaModelException { |
| if ((selection.size() == 1) && (selection.getFirstElement() instanceof IType)) { |
| final IType type= (IType) selection.getFirstElement(); |
| return type.getCompilationUnit() != null && !type.isInterface(); |
| } |
| if ((selection.size() == 1) && (selection.getFirstElement() instanceof ICompilationUnit)) |
| return true; |
| return false; |
| } |
| |
| private boolean checkEnabledEditor() { |
| return fEditor != null && SelectionConverter.canOperateOn(fEditor); |
| } |
| |
| private String getDialogTitle() { |
| return DIALOG_TITLE; |
| } |
| |
| private IType getSelectedType(IStructuredSelection selection) throws JavaModelException { |
| final Object[] elements= selection.toArray(); |
| if (elements.length == 1 && (elements[0] instanceof IType)) { |
| final IType type= (IType) elements[0]; |
| if (type.getCompilationUnit() != null && !type.isInterface()) { |
| return type; |
| } |
| } else if (elements[0] instanceof ICompilationUnit) { |
| final IType type= ((ICompilationUnit) elements[0]).findPrimaryType(); |
| if (type != null && !type.isInterface()) |
| return type; |
| } |
| return null; |
| } |
| |
| /* |
| * @see org.eclipse.jdt.ui.actions.SelectionDispatchAction#run(org.eclipse.jface.viewers.IStructuredSelection) |
| */ |
| public void run(IStructuredSelection selection) { |
| try { |
| final IType type= getSelectedType(selection); |
| if (type == null) { |
| MessageDialog.openInformation(getShell(), getDialogTitle(), ActionMessages.OverrideMethodsAction_not_applicable); |
| notifyResult(false); |
| return; |
| } |
| if (!ElementValidator.check(type, getShell(), getDialogTitle(), false) || !ActionUtil.isProcessable(getShell(), type)) { |
| notifyResult(false); |
| return; |
| } |
| run(getShell(), type); |
| } catch (CoreException exception) { |
| ExceptionHandler.handle(exception, getShell(), getDialogTitle(), ActionMessages.OverrideMethodsAction_error_actionfailed); |
| } |
| } |
| |
| /* |
| * @see org.eclipse.jdt.ui.actions.SelectionDispatchAction#run(org.eclipse.jface.text.ITextSelection) |
| */ |
| public void run(ITextSelection selection) { |
| try { |
| final IType type= SelectionConverter.getTypeAtOffset(fEditor); |
| if (type != null) { |
| if (!ElementValidator.check(type, getShell(), getDialogTitle(), false) || !ActionUtil.isProcessable(getShell(), type)) { |
| notifyResult(false); |
| return; |
| } |
| if (type.isAnnotation()) { |
| MessageDialog.openInformation(getShell(), getDialogTitle(), ActionMessages.OverrideMethodsAction_annotation_not_applicable); |
| notifyResult(false); |
| return; |
| } |
| if (type.isInterface()) { |
| MessageDialog.openInformation(getShell(), getDialogTitle(), ActionMessages.OverrideMethodsAction_interface_not_applicable); |
| notifyResult(false); |
| return; |
| } |
| run(getShell(), type); |
| } else { |
| MessageDialog.openInformation(getShell(), getDialogTitle(), ActionMessages.OverrideMethodsAction_not_applicable); |
| } |
| } catch (JavaModelException e) { |
| ExceptionHandler.handle(e, getShell(), getDialogTitle(), null); |
| } catch (CoreException e) { |
| ExceptionHandler.handle(e, getShell(), getDialogTitle(), ActionMessages.OverrideMethodsAction_error_actionfailed); |
| } |
| } |
| |
| private void run(Shell shell, IType type) throws CoreException { |
| final OverrideMethodDialog dialog= new OverrideMethodDialog(shell, fEditor, type, false); |
| if (!dialog.hasMethodsToOverride()) { |
| MessageDialog.openInformation(shell, getDialogTitle(), ActionMessages.OverrideMethodsAction_error_nothing_found); |
| notifyResult(false); |
| return; |
| } |
| if (dialog.open() != Window.OK) { |
| notifyResult(false); |
| return; |
| } |
| |
| final Object[] selected= dialog.getResult(); |
| if (selected == null) { |
| notifyResult(false); |
| return; |
| } |
| |
| ArrayList methods= new ArrayList(); |
| for (int i= 0; i < selected.length; i++) { |
| Object elem= selected[i]; |
| if (elem instanceof IMethodBinding) { |
| methods.add(elem); |
| } |
| } |
| IMethodBinding[] methodToOverride= (IMethodBinding[]) methods.toArray(new IMethodBinding[methods.size()]); |
| |
| |
| final IEditorPart editor= EditorUtility.openInEditor(type.getCompilationUnit()); |
| final IRewriteTarget target= editor != null ? (IRewriteTarget) editor.getAdapter(IRewriteTarget.class) : null; |
| if (target != null) |
| target.beginCompoundChange(); |
| try { |
| CompilationUnit astRoot= dialog.getCompilationUnit(); |
| final ITypeBinding typeBinding= ASTNodes.getTypeBinding(astRoot, type); |
| int insertPos= dialog.getInsertOffset(); |
| |
| AddUnimplementedMethodsOperation operation= (AddUnimplementedMethodsOperation) createRunnable(astRoot, typeBinding, methodToOverride, insertPos, dialog.getGenerateComment()); |
| IRunnableContext context= JavaPlugin.getActiveWorkbenchWindow(); |
| if (context == null) |
| context= new BusyIndicatorRunnableContext(); |
| PlatformUI.getWorkbench().getProgressService().runInUI(context, new WorkbenchRunnableAdapter(operation, operation.getSchedulingRule()), operation.getSchedulingRule()); |
| final String[] created= operation.getCreatedMethods(); |
| if (created == null || created.length == 0) |
| MessageDialog.openInformation(shell, getDialogTitle(), ActionMessages.OverrideMethodsAction_error_nothing_found); |
| } catch (InvocationTargetException exception) { |
| ExceptionHandler.handle(exception, shell, getDialogTitle(), null); |
| } catch (InterruptedException exception) { |
| // Do nothing. Operation has been canceled by user. |
| } finally { |
| if (target != null) |
| target.endCompoundChange(); |
| } |
| notifyResult(true); |
| } |
| |
| /** |
| * Returns a runnable that creates the method stubs for overridden methods. |
| * |
| * @param astRoot the AST of the compilation unit to work on. The AST must have been created from a {@link ICompilationUnit}, that |
| * means {@link ASTParser#setSource(ICompilationUnit)} was used. |
| * @param type the binding of the type to add the new methods to. The type binding must correspond to a type declaration in the AST. |
| * @param methodToOverride the bindings of methods to override or <code>null</code> to implement all unimplemented, abstract methods from super types. |
| * @param insertPos a hint for a location in the source where to insert the new methods or <code>-1</code> to use the default behavior. |
| * @param createComments if set, comments will be added to the new methods. |
| * @return returns a runnable that creates the methods stubs. |
| * @throws IllegalArgumentException a {@link IllegalArgumentException} is thrown if the AST passed has not been created from a {@link ICompilationUnit}. |
| * |
| * @since 3.2 |
| */ |
| public static IWorkspaceRunnable createRunnable(CompilationUnit astRoot, ITypeBinding type, IMethodBinding[] methodToOverride, int insertPos, boolean createComments) { |
| AddUnimplementedMethodsOperation operation= new AddUnimplementedMethodsOperation(astRoot, type, methodToOverride, insertPos, true, true, false); |
| operation.setCreateComments(createComments); |
| return operation; |
| } |
| |
| /* |
| * @see org.eclipse.jdt.ui.actions.SelectionDispatchAction#selectionChanged(org.eclipse.jface.viewers.IStructuredSelection) |
| */ |
| public void selectionChanged(IStructuredSelection selection) { |
| try { |
| setEnabled(canEnable(selection)); |
| } catch (JavaModelException exception) { |
| if (JavaModelUtil.isExceptionToBeLogged(exception)) |
| JavaPlugin.log(exception); |
| setEnabled(false); |
| } |
| } |
| |
| /* |
| * @see org.eclipse.jdt.ui.actions.SelectionDispatchAction#run(org.eclipse.jface.text.ITextSelection) |
| */ |
| public void selectionChanged(ITextSelection selection) { |
| // Do nothing |
| } |
| } |