| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2007 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 implementation |
| //------------------------------------------------------------------------------ |
| package org.eclipse.epf.authoring.ui.actions; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.emf.common.command.AbstractCommand; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.command.UnexecutableCommand; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.common.util.WrappedException; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain; |
| import org.eclipse.emf.edit.domain.IEditingDomainProvider; |
| import org.eclipse.emf.edit.ui.action.CommandActionHandler; |
| import org.eclipse.epf.authoring.ui.AuthoringUIPlugin; |
| import org.eclipse.epf.authoring.ui.AuthoringUIResources; |
| import org.eclipse.epf.authoring.ui.editors.EditorChooser; |
| import org.eclipse.epf.common.ui.util.MsgBox; |
| import org.eclipse.epf.common.utils.StrUtil; |
| import org.eclipse.epf.diagram.core.services.DiagramManager; |
| import org.eclipse.epf.library.LibraryService; |
| import org.eclipse.epf.library.LibraryServiceUtil; |
| import org.eclipse.epf.library.edit.ui.UserInteractionHelper; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.library.edit.validation.IValidator; |
| import org.eclipse.epf.library.edit.validation.IValidatorFactory; |
| import org.eclipse.epf.library.ui.actions.LibraryLockingOperationRunner; |
| import org.eclipse.epf.services.ILibraryPersister; |
| import org.eclipse.epf.services.ILibraryPersister.FailSafeMethodLibraryPersister; |
| import org.eclipse.epf.uma.ContentElement; |
| import org.eclipse.epf.uma.MethodConfiguration; |
| import org.eclipse.epf.uma.MethodElement; |
| import org.eclipse.epf.uma.MethodPlugin; |
| import org.eclipse.epf.uma.NamedElement; |
| import org.eclipse.epf.uma.Process; |
| import org.eclipse.epf.uma.ProcessComponent; |
| import org.eclipse.epf.uma.util.ContentDescriptionFactory; |
| import org.eclipse.epf.uma.util.MessageException; |
| import org.eclipse.jface.dialogs.IInputValidator; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.IWorkbenchPart; |
| |
| /** |
| * Renames method element. |
| * |
| * @author Phong Nguyen Le |
| * @since 1.2 |
| */ |
| public class RenameAction extends |
| CommandActionHandler implements IWorkbenchPartAction, IModifyingAction { |
| |
| private static final String LABEL = AuthoringUIResources.renameAction_text; |
| |
| private IStructuredSelection selection; |
| |
| private IWorkbenchPart activePart; |
| |
| /** |
| * Creates an instance |
| * @param text |
| */ |
| public RenameAction(String text) { |
| super(null, text); |
| } |
| |
| /** |
| * Creates an instance |
| * |
| */ |
| public RenameAction() { |
| this(LABEL); |
| } |
| |
| /** |
| * Returns <code>true</code> if the selected method elements can be |
| * renamed. |
| */ |
| private boolean canRename(IStructuredSelection selection) { |
| if (!(domain instanceof AdapterFactoryEditingDomain) || selection.size() > 1) |
| return false; |
| Object element = TngUtil.unwrap(selection.getFirstElement()); |
| if (element instanceof NamedElement |
| && !TngUtil.isPredefined((MethodElement) element)) { |
| return true; |
| } |
| return false; |
| } |
| |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.action.CommandActionHandler#updateSelection(org.eclipse.jface.viewers.IStructuredSelection) |
| */ |
| public boolean updateSelection(IStructuredSelection selection) { |
| boolean ret = false; |
| if(canRename(selection)) { |
| this.selection = selection; |
| ret = super.updateSelection(selection); |
| } |
| setEnabled(ret); |
| return ret; |
| } |
| |
| @Override |
| public Command createCommand(Collection<?> selection) { |
| if(selection.isEmpty()) { |
| return UnexecutableCommand.INSTANCE; |
| } |
| Object o = TngUtil.unwrap(selection.iterator().next()); |
| if(o instanceof NamedElement) { |
| return new RenameCommand((NamedElement) o, null); |
| } |
| return UnexecutableCommand.INSTANCE; |
| } |
| |
| /** |
| * @see org.eclipse.epf.authoring.ui.actions.IWorkbenchPartAction#setActiveWorkbenchPart(org.eclipse.ui.IWorkbenchPart) |
| */ |
| public void setActiveWorkbenchPart(IWorkbenchPart workbenchPart) { |
| if(workbenchPart instanceof IEditingDomainProvider) { |
| domain = ((IEditingDomainProvider)workbenchPart).getEditingDomain(); |
| } |
| activePart = workbenchPart; |
| } |
| |
| private void superRun() { |
| final NamedElement e = (NamedElement) TngUtil.unwrap(selection.getFirstElement()); |
| // Resource resource = e.eResource(); |
| // if(resource != null) { |
| // org.eclipse.core.resources.IFile file = WorkspaceSynchronizer.getFile(e.eResource()); |
| // if(file != null) { |
| // RepositoryProvider provider = RepositoryProvider.getProvider(file.getProject()); |
| // if(provider != null) { |
| // IFileHistoryProvider historyProvider = provider.getFileHistoryProvider(); |
| // FileModificationValidator modValidator = provider.getFileModificationValidator2(); |
| // String id = provider.getID(); |
| // Subscriber subscriber = provider.getSubscriber(); |
| // System.out.println(id); |
| // } |
| // } |
| // } |
| |
| Shell shell = activePart.getSite().getShell(); |
| |
| // check if container's resource can be modified |
| // |
| if (e.eContainer() != null |
| && e.eContainer().eResource() != e.eResource()) { |
| IStatus status = UserInteractionHelper.checkModify(e.eContainer(), shell); |
| if (!status.isOK()) { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources.renameDialog_title, |
| AuthoringUIResources.renameDialog_renameError, |
| status); |
| return; |
| } |
| } |
| |
| final IValidator validator = IValidatorFactory.INSTANCE |
| .createNameValidator(e, ((AdapterFactoryEditingDomain)domain).getAdapterFactory()); |
| IInputValidator inputValidator = new IInputValidator() { |
| public String isValid(String newText) { |
| if (validator != null) { |
| return UserInteractionHelper |
| .getSimpleErrorMessage(validator |
| .isValid(newText)); |
| } |
| return null; |
| } |
| }; |
| |
| boolean getInput = true; |
| InputDialog inputDlg = new InputDialog(Display.getCurrent() |
| .getActiveShell(), AuthoringUIResources.rename_text, |
| AuthoringUIResources.newname_text, e.getName(), |
| inputValidator); |
| while (getInput) { |
| getInput = false; |
| if (inputDlg.open() == Window.OK) { |
| String newName = inputDlg.getValue().trim(); |
| if(e instanceof ContentElement) { |
| newName = StrUtil.makeValidFileName(newName); |
| } |
| if (!newName.equals(e.getName())) { |
| if (e instanceof MethodConfiguration) { |
| String[] configNames = LibraryServiceUtil |
| .getMethodConfigurationNames(LibraryService |
| .getInstance() |
| .getCurrentMethodLibrary()); |
| for (int i = 0; i < configNames.length; i++) { |
| if (newName.equals(configNames[i])) { |
| AuthoringUIPlugin |
| .getDefault() |
| .getMsgDialog() |
| .displayError( |
| AuthoringUIResources.renameDialog_title, |
| AuthoringUIResources |
| .bind( |
| AuthoringUIResources.duplicateElementNameError_msg, |
| newName)); |
| getInput = true; |
| break; |
| } |
| } |
| } |
| if (getInput == true) { |
| inputDlg = new InputDialog(Display.getCurrent() |
| .getActiveShell(), |
| AuthoringUIResources.rename_text, |
| AuthoringUIResources.newname_text, e |
| .getName(), inputValidator); |
| continue; |
| } |
| |
| if (e instanceof MethodPlugin) { |
| String msg = AuthoringUIResources.bind(AuthoringUIResources.methodPluginDescriptionPage_confirmRename, (new Object[] { e.getName(), newName })); |
| String title = AuthoringUIResources.methodPluginDescriptionPage_confirmRename_title; |
| if (!MessageDialog.openConfirm(shell, title, msg)) { |
| return; |
| } |
| |
| EditorChooser.getInstance().closeMethodEditorsForPluginElements((MethodPlugin)e); |
| } |
| |
| RenameCommand renameCmd = (RenameCommand) command; |
| renameCmd.setNewName(newName); |
| renameCmd.setShell(shell); |
| super.run(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * @see org.eclipse.emf.edit.ui.action.CommandActionHandler#run() |
| */ |
| public void run() { |
| BusyIndicator.showWhile(activePart.getSite() |
| .getShell().getDisplay(), new Runnable() { |
| |
| public void run() { |
| LibraryLockingOperationRunner runner = new LibraryLockingOperationRunner(); |
| runner.run(new IRunnableWithProgress() { |
| |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException, |
| InterruptedException { |
| superRun(); |
| } |
| |
| }); |
| } |
| |
| }); |
| } |
| |
| public static void doRename(final NamedElement e, final String newName) { |
| new RenameCommand(e, newName).execute(); |
| } |
| |
| private static class RenameCommand extends AbstractCommand { |
| private NamedElement e; |
| private String newName; |
| private String oldName; |
| private Shell shell; |
| Collection<Resource> renamedResources; |
| |
| public RenameCommand(NamedElement e, String newName) { |
| this.e = e; |
| this.newName = newName; |
| } |
| |
| public void setNewName(String newName) { |
| this.newName = newName; |
| } |
| |
| public void setShell(Shell shell) { |
| this.shell = shell; |
| } |
| |
| private void rollback() { |
| // restore old name |
| // |
| setName(oldName); |
| |
| // restore old location |
| // |
| if(!renamedResources.isEmpty()) { |
| adjustLocation(renamedResources, new ArrayList<Resource>()); |
| } |
| } |
| |
| private void handlePersistenceException(Exception e1) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e1); |
| |
| String details = e1.getMessage() != null ? MessageFormat |
| .format(": {0}", new Object[] { e1.getMessage() }) : ""; //$NON-NLS-1$ //$NON-NLS-2$ |
| String msg = MessageFormat.format( |
| AuthoringUIResources.ElementsView_err_saving, |
| new Object[] { |
| e.eResource().getURI().toFileString(), |
| details }); |
| throw new MessageException(msg); |
| } |
| |
| private ILibraryPersister.FailSafeMethodLibraryPersister getPersister() { |
| return LibraryServiceUtil.getPersisterFor(e.eResource()) |
| .getFailSafePersister(); |
| } |
| |
| /** |
| * Adjusts location of all affected resources. |
| * |
| * @return resources whose location has been adjusted |
| */ |
| private IStatus adjustLocation(Collection<Resource> renamedResources) { |
| Collection<Resource> resourcesToRename = new ArrayList<Resource>(); |
| if (e instanceof ContentElement |
| && ContentDescriptionFactory |
| .hasPresentation((MethodElement) e)) { |
| resourcesToRename.add(((ContentElement) e).getPresentation() |
| .eResource()); |
| } |
| resourcesToRename.add(e.eResource()); |
| return adjustLocation(resourcesToRename, renamedResources); |
| } |
| |
| /** |
| * Adjusts location of the specified resources. |
| * |
| * @return resources whose location has been adjusted |
| */ |
| private IStatus adjustLocation(Collection<Resource> resourcesToRename, Collection<Resource> renamedResources) { |
| FailSafeMethodLibraryPersister persister = getPersister(); |
| try { |
| for (Resource resource : resourcesToRename) { |
| URI oldURI = resource.getURI(); |
| persister.adjustLocation(resource); |
| if(!resource.getURI().equals(oldURI)) { |
| renamedResources.add(resource); |
| } |
| } |
| return Status.OK_STATUS; |
| } catch (Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| try { |
| persister.rollback(); |
| } |
| catch(Exception ex) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| return new Status(IStatus.ERROR, AuthoringUIPlugin.getDefault().getId(), |
| e.getMessage(), e); |
| } |
| } |
| |
| private void setName(String newName) { |
| e.setName(newName); |
| |
| // Special handling for ProcessComponent to keep its |
| // name and the name of its process in sync. |
| if (e instanceof ProcessComponent) { |
| Process proc = ((ProcessComponent) e).getProcess(); |
| proc.setName(newName); |
| } |
| } |
| |
| public void execute() { |
| oldName = e.getName(); |
| setName(newName); |
| |
| renamedResources = new ArrayList<Resource>(); |
| |
| // rename file(s) |
| // |
| Runnable runnable = new Runnable() { |
| |
| public void run() { |
| IStatus status = adjustLocation(renamedResources); |
| if(!status.isOK()) { |
| rollback(); |
| Exception ex = (Exception) status.getException(); |
| throw ex instanceof RuntimeException ? (RuntimeException) ex : new WrappedException(ex); |
| } |
| |
| } |
| |
| }; |
| |
| boolean result = UserInteractionHelper.runWithProgress(runnable, |
| AuthoringUIResources.ElementsView_renaming_text); |
| if(!result) { |
| return; |
| } |
| |
| IStatus status = UserInteractionHelper.checkModify(e, |
| shell == null ? MsgBox.getDefaultShell() : shell); |
| if (!status.isOK()) { |
| AuthoringUIPlugin.getDefault().getMsgDialog().displayError( |
| AuthoringUIResources.renameDialog_title, |
| AuthoringUIResources.renameDialog_renameError, |
| status); |
| UserInteractionHelper.runWithProgress(new Runnable() { |
| |
| public void run() { |
| rollback(); |
| } |
| |
| }, ""); //$NON-NLS-1$ |
| return; |
| } |
| |
| // Save the modified file(s). |
| // |
| runnable = new Runnable() { |
| |
| public void run() { |
| // Save the modified file(s). |
| // |
| ILibraryPersister.FailSafeMethodLibraryPersister persister = getPersister(); |
| try { |
| try { |
| persister.save(e.eResource()); |
| persister.commit(); |
| } catch (Exception e1) { |
| try { |
| persister.rollback(); |
| } |
| catch(Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| handlePersistenceException(e1); |
| } |
| } |
| catch(RuntimeException e) { |
| rollback(); |
| throw e; |
| } |
| |
| // change diagram resource as well |
| if (e instanceof ProcessComponent) { |
| Process proc = ((ProcessComponent) e).getProcess(); |
| DiagramManager mgr = DiagramManager.getInstance(proc, this); |
| if(mgr != null) { |
| try { |
| mgr.updateResourceURI(); |
| } |
| catch(Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| finally { |
| try { |
| mgr.removeConsumer(this); |
| } |
| catch(Exception e) { |
| AuthoringUIPlugin.getDefault().getLogger().logError(e); |
| } |
| } |
| } |
| |
| } |
| } |
| |
| }; |
| UserInteractionHelper.runWithProgress(runnable, |
| AuthoringUIResources.ElementsView_renaming_text); |
| } |
| |
| public void redo() { |
| execute(); |
| } |
| |
| @Override |
| protected boolean prepare() { |
| return true; |
| } |
| |
| @Override |
| public void dispose() { |
| e = null; |
| super.dispose(); |
| } |
| } |
| } |
