| /******************************************************************************* |
| * Copyright (c) 2010, 2015 THALES GLOBAL SERVICES 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: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.sirius.tree.tools.internal.command; |
| |
| import java.text.MessageFormat; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.emf.common.command.AbstractCommand; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.command.CompoundCommand; |
| import org.eclipse.emf.common.command.UnexecutableCommand; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.transaction.RecordingCommand; |
| import org.eclipse.emf.transaction.TransactionalEditingDomain; |
| import org.eclipse.sirius.business.api.helper.task.ICommandTask; |
| import org.eclipse.sirius.business.api.helper.task.InitInterpreterVariablesTask; |
| import org.eclipse.sirius.business.api.helper.task.TaskHelper; |
| import org.eclipse.sirius.business.api.helper.task.UnexecutableTask; |
| import org.eclipse.sirius.business.api.helper.task.label.InitInterpreterFromParsedVariableTask2; |
| import org.eclipse.sirius.business.api.logger.RuntimeLoggerManager; |
| import org.eclipse.sirius.business.api.query.EObjectQuery; |
| import org.eclipse.sirius.business.internal.helper.task.DeleteDRepresentationElementsTask; |
| import org.eclipse.sirius.business.internal.helper.task.DeleteWithoutToolTask; |
| import org.eclipse.sirius.common.tools.api.interpreter.EvaluationException; |
| import org.eclipse.sirius.common.tools.api.interpreter.IInterpreter; |
| import org.eclipse.sirius.common.tools.api.interpreter.IInterpreterSiriusVariables; |
| import org.eclipse.sirius.common.tools.api.util.StringUtil; |
| import org.eclipse.sirius.ecore.extender.business.api.accessor.ModelAccessor; |
| import org.eclipse.sirius.ecore.extender.business.api.permission.IPermissionAuthority; |
| import org.eclipse.sirius.ext.base.Option; |
| import org.eclipse.sirius.tools.api.command.AbstractCommandFactory; |
| import org.eclipse.sirius.tools.api.command.DCommand; |
| import org.eclipse.sirius.tools.api.command.InvalidPermissionCommand; |
| import org.eclipse.sirius.tools.api.command.NoNullResourceCommand; |
| import org.eclipse.sirius.tools.api.command.SiriusCommand; |
| import org.eclipse.sirius.tools.api.command.view.JavaActionFromToolCommand; |
| import org.eclipse.sirius.tools.api.interpreter.InterpreterUtil; |
| import org.eclipse.sirius.tools.api.ui.IExternalJavaAction; |
| import org.eclipse.sirius.tools.internal.command.builders.ElementsToSelectTask; |
| import org.eclipse.sirius.tree.DTree; |
| import org.eclipse.sirius.tree.DTreeElement; |
| import org.eclipse.sirius.tree.DTreeItem; |
| import org.eclipse.sirius.tree.DTreeItemContainer; |
| import org.eclipse.sirius.tree.business.api.command.ITreeCommandFactory; |
| import org.eclipse.sirius.tree.business.internal.helper.RefreshTreeElementTask; |
| import org.eclipse.sirius.tree.business.internal.helper.TreeHelper; |
| import org.eclipse.sirius.tree.business.internal.refresh.CreateTreeTask; |
| import org.eclipse.sirius.tree.description.TreeDescription; |
| import org.eclipse.sirius.tree.description.TreeItemContainerDropTool; |
| import org.eclipse.sirius.tree.description.TreeItemCreationTool; |
| import org.eclipse.sirius.tree.description.TreeItemDeletionTool; |
| import org.eclipse.sirius.tree.description.TreeItemEditionTool; |
| import org.eclipse.sirius.tree.tools.internal.Messages; |
| import org.eclipse.sirius.viewpoint.DRepresentation; |
| import org.eclipse.sirius.viewpoint.DSemanticDecorator; |
| import org.eclipse.sirius.viewpoint.description.tool.AbstractToolDescription; |
| import org.eclipse.sirius.viewpoint.description.tool.AbstractVariable; |
| import org.eclipse.sirius.viewpoint.description.tool.ExternalJavaAction; |
| import org.eclipse.sirius.viewpoint.description.tool.OperationAction; |
| import org.eclipse.sirius.viewpoint.description.tool.RepresentationCreationDescription; |
| import org.eclipse.sirius.viewpoint.description.tool.ToolPackage; |
| |
| import com.google.common.collect.Sets; |
| |
| /** |
| * A command factory that creates commands that can be undone. |
| * |
| * @author nlepine |
| */ |
| public class TreeCommandFactory extends AbstractCommandFactory implements ITreeCommandFactory { |
| private TaskHelper commandTaskHelper; |
| |
| /** |
| * Create a new Factory. the autoRefresh is by default deactivated |
| * |
| * @param domain |
| * : current editing domain. |
| */ |
| public TreeCommandFactory(final TransactionalEditingDomain domain) { |
| super(domain); |
| } |
| |
| private IPermissionAuthority getPermissionAuthority() { |
| return modelAccessor.getPermissionAuthority(); |
| } |
| |
| /** |
| * Return the commandTaskHelper. |
| * |
| * @return the commandTaskHelper |
| */ |
| public TaskHelper getCommandTaskHelper() { |
| return commandTaskHelper; |
| } |
| |
| /** |
| * Set the model accessor. |
| * |
| * @param modelAccessor |
| * the modelAccessor to set |
| */ |
| @Override |
| public void setModelAccessor(final ModelAccessor modelAccessor) { |
| this.modelAccessor = modelAccessor; |
| commandTaskHelper = new TaskHelper(modelAccessor, uiCallBack); |
| } |
| |
| /** |
| * Returns a command that can delete the specified element. |
| * |
| * @param element |
| * the element to delete (a {@link DLine} or a |
| * {@link DTargetColumn}). |
| * @return a command that can delete the specified element. |
| */ |
| @Override |
| public Command buildDeleteTreeElement(final DTreeElement element) { |
| Command cmd = UnexecutableCommand.INSTANCE; |
| if (element instanceof DTreeItem) { |
| if (!getPermissionAuthority().canEditInstance(element)) { |
| cmd = new InvalidPermissionCommand(domain, element); |
| } else { |
| if (!getPermissionAuthority().canEditInstance(element.eContainer())) { |
| cmd = new InvalidPermissionCommand(domain, element.eContainer()); |
| } else { |
| final SiriusCommand result = new SiriusCommand(domain); |
| TreeItemDeletionTool deleteTool = getDeleteTool(element); |
| final DTree parentTree = TreeHelper.getTree(element); |
| if (deleteTool != null) { |
| addDeleteTreeElementFromTool(result, element, deleteTool); |
| addRefreshTask(parentTree, result, deleteTool); |
| Option<DRepresentation> dRepresentation = new EObjectQuery(element).getRepresentation(); |
| result.getTasks().add(new ElementsToSelectTask(deleteTool, InterpreterUtil.getInterpreter(element), element, dRepresentation.get())); |
| |
| cmd = new NoNullResourceCommand(result, element); |
| } else { |
| result.getTasks().add(new DeleteWithoutToolTask(element, modelAccessor, commandTaskHelper)); |
| addRefreshTask(parentTree, result, deleteTool); |
| cmd = new NoNullResourceCommand(result, element); |
| } |
| } |
| } |
| } |
| return cmd; |
| } |
| |
| private void addDeleteTreeElementFromTool(final SiriusCommand cmd, final DTreeElement element, final TreeItemDeletionTool deleteTool) { |
| final EObject semanticElement = ((DSemanticDecorator) element).getTarget(); |
| final EObject rootContainer = TreeHelper.getTree(element).getTarget(); |
| // check precondition |
| boolean delete = true; |
| if (deleteTool.getPrecondition() != null && !StringUtil.isEmpty(deleteTool.getPrecondition().trim())) { |
| delete = false; |
| final IInterpreter acceleoInterpreter = InterpreterUtil.getInterpreter(semanticElement); |
| acceleoInterpreter.setVariable(IInterpreterSiriusVariables.ROOT, rootContainer); |
| acceleoInterpreter.setVariable(IInterpreterSiriusVariables.ELEMENT, semanticElement); |
| try { |
| delete = acceleoInterpreter.evaluateBoolean(semanticElement, deleteTool.getPrecondition()); |
| } catch (final EvaluationException e) { |
| RuntimeLoggerManager.INSTANCE.error(deleteTool, ToolPackage.eINSTANCE.getAbstractToolDescription_Precondition(), e); |
| } |
| acceleoInterpreter.unSetVariable(IInterpreterSiriusVariables.ROOT); |
| acceleoInterpreter.unSetVariable(IInterpreterSiriusVariables.ELEMENT); |
| } |
| if (delete) { |
| cmd.getTasks().addAll(buildCommandFromModelOfTool(semanticElement, deleteTool, element.eContainer()).getTasks()); |
| cmd.getTasks().add(new DeleteDRepresentationElementsTask(modelAccessor, cmd, commandTaskHelper, element)); |
| } else { |
| cmd.getTasks().add(UnexecutableTask.INSTANCE); |
| } |
| } |
| |
| /** |
| * Build a command that covers all the model operations corresponding to a |
| * the semantic container and a |
| * {@link org.eclipse.sirius.viewpoint.description.tool.ToolDescription}. |
| * |
| * @param semanticCurrentElement |
| * the semantic current Element. |
| * @param tool |
| * the |
| * {@link org.eclipse.sirius.viewpoint.description.tool.ToolDescription} |
| * . |
| * @param containerView |
| * the container View |
| * @return a command able to execute the tool. |
| */ |
| protected SiriusCommand buildCommandFromModelOfTool(final EObject semanticCurrentElement, final AbstractToolDescription tool, final EObject containerView) { |
| SiriusCommand result = new SiriusCommand(domain); |
| if (!getPermissionAuthority().canEditInstance(containerView)) { |
| result = new InvalidPermissionCommand(domain, containerView); |
| } else { |
| final Map<AbstractVariable, Object> variables = new HashMap<AbstractVariable, Object>(); |
| if (tool instanceof TreeItemDeletionTool) { |
| final TreeItemDeletionTool deleteTool = (TreeItemDeletionTool) tool; |
| if (containerView instanceof DTreeElement) { |
| variables.put(TreeHelper.getVariable(deleteTool, IInterpreterSiriusVariables.ROOT), TreeHelper.getTree(containerView).getTarget()); |
| } else if (containerView instanceof DTree) { |
| variables.put(TreeHelper.getVariable(deleteTool, IInterpreterSiriusVariables.ROOT), ((DTree) containerView).getTarget()); |
| } |
| variables.put(TreeHelper.getVariable(deleteTool, IInterpreterSiriusVariables.ELEMENT), semanticCurrentElement); |
| // Initialization of the variables |
| result.getTasks().add(new InitInterpreterVariablesTask(variables, InterpreterUtil.getInterpreter(semanticCurrentElement), uiCallBack)); |
| // Creation of the tasks to execute the tool |
| result.getTasks().add(commandTaskHelper.buildTaskFromModelOperation(TreeHelper.getTree(containerView), semanticCurrentElement, deleteTool.getFirstModelOperation())); |
| } else if (tool instanceof TreeItemCreationTool) { |
| final TreeItemCreationTool creationTool = (TreeItemCreationTool) tool; |
| if (containerView instanceof DTreeElement) { |
| variables.put(TreeHelper.getVariable(creationTool, IInterpreterSiriusVariables.ROOT), TreeHelper.getTree(containerView).getTarget()); |
| if (containerView instanceof DTreeItem) { |
| variables.put(TreeHelper.getVariable(creationTool, IInterpreterSiriusVariables.CONTAINER), ((DTreeItem) containerView).getTarget()); |
| } |
| } else if (containerView instanceof DTree) { |
| variables.put(TreeHelper.getVariable(creationTool, IInterpreterSiriusVariables.ROOT), ((DTree) containerView).getTarget()); |
| variables.put(TreeHelper.getVariable(creationTool, IInterpreterSiriusVariables.CONTAINER), ((DTree) containerView).getTarget()); |
| } |
| variables.put(TreeHelper.getVariable(creationTool, IInterpreterSiriusVariables.ELEMENT), semanticCurrentElement); |
| // Initialization of the variables |
| result.getTasks().add(new InitInterpreterVariablesTask(variables, InterpreterUtil.getInterpreter(semanticCurrentElement), uiCallBack)); |
| // Creation of the tasks to execute the tool |
| result.getTasks().add(commandTaskHelper.buildTaskFromModelOperation(TreeHelper.getTree(containerView), semanticCurrentElement, creationTool.getFirstModelOperation())); |
| } |
| } |
| return result; |
| } |
| |
| private TreeItemDeletionTool getDeleteTool(final DTreeElement element) { |
| TreeItemDeletionTool result = null; |
| if (element instanceof DTreeItem) { |
| result = ((DTreeItem) element).getActualMapping().getDelete(); |
| } |
| return result; |
| } |
| |
| /** |
| * Create a command that creates a line. |
| * |
| * @param lineContainer |
| * container element in which the command should put the created |
| * line. |
| * @param semanticCurrentElement |
| * the semantic current element |
| * @param tool |
| * {@link CreateTool} used to build the command. |
| * @return a command able to create the line and putting it in the |
| * container, corresponding to the {@link CreateTool}. |
| */ |
| @Override |
| public Command buildCreateLineCommandFromTool(final DTreeItemContainer lineContainer, final EObject semanticCurrentElement, final TreeItemCreationTool tool) { |
| Command result = UnexecutableCommand.INSTANCE; |
| if (!getPermissionAuthority().canEditInstance(lineContainer)) { |
| result = new InvalidPermissionCommand(domain, lineContainer); |
| } else { |
| if (commandTaskHelper.checkPrecondition(semanticCurrentElement, tool)) { |
| SiriusCommand createLineCommand = buildCommandFromModelOfTool(semanticCurrentElement, tool, lineContainer); |
| addRefreshTask(lineContainer, createLineCommand, tool); |
| Option<DRepresentation> dRepresentation = new EObjectQuery(lineContainer).getRepresentation(); |
| createLineCommand.getTasks().add(new ElementsToSelectTask(tool, InterpreterUtil.getInterpreter(lineContainer), semanticCurrentElement, dRepresentation.get())); |
| |
| result = createLineCommand; |
| } |
| } |
| return result; |
| |
| } |
| |
| /** |
| * Create a command that is able to create a table. |
| * |
| * @param description |
| * the tool that describes how to create the table. |
| * @param semanticElement |
| * the element from which the table will be created. |
| * @param monitor |
| * a {@link IProgressMonitor} to show progression of |
| * {@link DTree} creation |
| * @return a command that is able to create a table. |
| */ |
| public DCommand buildCreateTreeFromDescription(final TreeDescription description, final EObject semanticElement, IProgressMonitor monitor) { |
| final DCommand command = new SiriusCommand(domain) { |
| /** |
| * Creation of a table must not be undoable ! <BR> |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.emf.transaction.RecordingCommand#canUndo() |
| */ |
| @Override |
| public boolean canUndo() { |
| return false; |
| } |
| }; |
| command.getTasks().add(new CreateTreeTask(description, semanticElement, monitor)); |
| return command; |
| } |
| |
| @Override |
| public AbstractCommand buildDoExecuteDetailsOperation(final DSemanticDecorator target, final RepresentationCreationDescription desc, final String newRepresentationName) { |
| final SiriusCommand cmd = new SiriusCommand(domain); |
| final Map<AbstractVariable, Object> variables = new HashMap<AbstractVariable, Object>(); |
| variables.put(desc.getContainerViewVariable(), target); |
| final Map<AbstractVariable, String> stringVariables = new HashMap<AbstractVariable, String>(); |
| stringVariables.put(desc.getRepresentationNameVariable(), newRepresentationName); |
| final ICommandTask initInterpreterVariables = new InitInterpreterVariablesTask(variables, stringVariables, InterpreterUtil.getInterpreter(target), uiCallBack); |
| cmd.getTasks().add(initInterpreterVariables); |
| cmd.getTasks().add(commandTaskHelper.buildTaskFromModelOperation(TreeHelper.getTree(target), target.getTarget(), desc.getInitialOperation().getFirstModelOperations())); |
| return cmd; |
| } |
| |
| @Override |
| public Command buildDirectEditLabelFromTool(final DTreeItem editedTreeItem, TreeItemEditionTool directEditTool, String newValue) { |
| SiriusCommand result = new SiriusCommand(domain, MessageFormat.format(Messages.TreeCommandFactory_directEdit, editedTreeItem.getName())); |
| if (!getPermissionAuthority().canEditInstance(editedTreeItem)) { |
| result = new InvalidPermissionCommand(domain, editedTreeItem); |
| } else { |
| if (editedTreeItem.getUpdater() != null) { |
| if (editedTreeItem.getUpdater().getDirectEdit() != null) { |
| |
| // Step 1 : variables initialization |
| EObject interpreterContext = editedTreeItem.getTarget(); |
| |
| final Map<AbstractVariable, Object> variables = new HashMap<AbstractVariable, Object>(); |
| variables.put(directEditTool.getRoot(), TreeHelper.getTree(editedTreeItem).getTarget()); |
| variables.put(directEditTool.getElement(), editedTreeItem.getTarget()); |
| |
| result.getTasks().add(new InitInterpreterVariablesTask(variables, InterpreterUtil.getInterpreter(interpreterContext), uiCallBack)); |
| |
| if (directEditTool.getMask() != null) { |
| /* |
| * First we need to init the mask variables. |
| */ |
| final String messageFormat = directEditTool.getMask().getMask(); |
| result.getTasks().add(new InitInterpreterFromParsedVariableTask2(InterpreterUtil.getInterpreter(interpreterContext), messageFormat, newValue)); |
| } |
| |
| // Step 2 : build the task from the model operations |
| // specified in this tool |
| result.getTasks().add(commandTaskHelper.buildTaskFromModelOperation(TreeHelper.getTree(editedTreeItem), interpreterContext, directEditTool.getFirstModelOperation())); |
| |
| // Add a RefreshTreeElementTask to have DTreeItem refreshed |
| // on direct edit even in REFRESH_AUTO mode at false |
| ICommandTask refreshTreeElementTask = new RefreshTreeElementTask(editedTreeItem); |
| result.getTasks().add(refreshTreeElementTask); |
| } |
| } |
| } |
| return result; |
| } |
| |
| @Override |
| public Command buildDropItemFromTool(EObject dropped, DTreeItemContainer dropTarget, Collection<DTreeItem> precedingSiblings, TreeItemContainerDropTool dropTool) { |
| final SiriusCommand result = new SiriusCommand(domain, MessageFormat.format(Messages.TreeCommandFactory_dropItem, dropped)); |
| |
| EObject dropSem = dropped; |
| DSemanticDecorator dropDec = null; |
| DSemanticDecorator oldContainer = null; |
| if (dropped instanceof DSemanticDecorator) { |
| dropDec = (DSemanticDecorator) dropped; |
| dropSem = dropDec.getTarget(); |
| oldContainer = getOldContainer(dropDec); |
| } |
| |
| // Step 1 : variables initialization |
| EObject interpreterContext = dropTarget.getTarget(); |
| |
| final Map<AbstractVariable, Object> variables = new HashMap<AbstractVariable, Object>(); |
| if (dropDec != null) { |
| variables.put(dropTool.getOldContainer(), oldContainer); |
| } |
| variables.put(dropTool.getNewContainer(), dropTarget.getTarget()); |
| variables.put(dropTool.getElement(), dropSem); |
| variables.put(dropTool.getNewViewContainer(), dropTarget); |
| variables.put(dropTool.getPrecedingSiblings(), precedingSiblings); |
| |
| result.getTasks().add(new InitInterpreterVariablesTask(variables, InterpreterUtil.getInterpreter(interpreterContext), uiCallBack)); |
| |
| // Step 2 : build the task from the model operations |
| // specified in this tool |
| DTree droppedTree = TreeHelper.getTree(dropTarget); |
| if (dropTool.getFirstModelOperation() != null) { |
| result.getTasks().add(commandTaskHelper.buildTaskFromModelOperation(droppedTree, interpreterContext, dropTool.getFirstModelOperation())); |
| } |
| // Step 3 : adding task to refresh |
| if (droppedTree != null) { |
| addRefreshTask(droppedTree, result, dropTool); |
| } |
| if (dropDec != null) { |
| addRefreshTask(dropDec, result, dropTool); |
| } |
| Option<DRepresentation> dRepresentation = new EObjectQuery(dropTarget).getRepresentation(); |
| result.getTasks().add(new ElementsToSelectTask(dropTool, InterpreterUtil.getInterpreter(dropTarget), dropTarget.getTarget(), dRepresentation.get())); |
| |
| return result; |
| } |
| |
| private DSemanticDecorator getOldContainer(DSemanticDecorator dropDec) { |
| EObject semanticOldContainer = null; |
| DSemanticDecorator oldContainer = null; |
| |
| EObject currentOldContainer = dropDec.eContainer(); |
| while (currentOldContainer != null && semanticOldContainer == null) { |
| if (currentOldContainer instanceof DSemanticDecorator) { |
| oldContainer = (DSemanticDecorator) currentOldContainer; |
| semanticOldContainer = oldContainer.getTarget(); |
| } |
| currentOldContainer = currentOldContainer.eContainer(); |
| } |
| return oldContainer; |
| } |
| |
| @Override |
| public Command buildOperationActionFromTool(OperationAction operationAction, final DTreeItem selectedItem) { |
| final SiriusCommand result = new SiriusCommand(domain, MessageFormat.format(Messages.TreeCommandFactory_operationAction, operationAction.getName(), selectedItem.getName())); |
| // Step 1 : variables initialization |
| final Map<AbstractVariable, Object> variables = new HashMap<AbstractVariable, Object>(); |
| EObject interpreterContext = selectedItem.getTarget(); |
| variables.put(operationAction.getView(), selectedItem); |
| result.getTasks().add(new InitInterpreterVariablesTask(variables, InterpreterUtil.getInterpreter(interpreterContext), uiCallBack)); |
| |
| // Step 2 : adding task from model operations |
| DTree targetTree = TreeHelper.getTree(selectedItem); |
| result.getTasks().add(commandTaskHelper.buildTaskFromModelOperation(targetTree, interpreterContext, operationAction.getInitialOperation().getFirstModelOperations())); |
| |
| // Step 3 : adding task to refresh |
| addRefreshTask(targetTree, result, null); |
| Option<DRepresentation> dRepresentation = new EObjectQuery(selectedItem).getRepresentation(); |
| result.getTasks().add(new ElementsToSelectTask(operationAction, InterpreterUtil.getInterpreter(selectedItem.getTarget()), selectedItem.getTarget(), dRepresentation.get())); |
| |
| return result.chain(new RecordingCommand(domain) { |
| |
| @Override |
| protected void doExecute() { |
| selectedItem.setExpanded(true); |
| } |
| }); |
| } |
| |
| @Override |
| public Command buildJavaActionFromTool(ExternalJavaAction javaActionItem, DTreeItem selectedItem, IExternalJavaAction javaAction) { |
| final CompoundCommand compoundCommand = new CompoundCommand(); |
| // Step 1 : creating the command from the java action tool |
| Set<DSemanticDecorator> views = Sets.newLinkedHashSet(); |
| views.add(selectedItem); |
| final JavaActionFromToolCommand javaActionFromToolCommand = new JavaActionFromToolCommand(this.domain, javaAction, javaActionItem, views); |
| compoundCommand.append(javaActionFromToolCommand); |
| |
| // Step 2 : creating a command for refreshing the representation |
| final SiriusCommand dCommand = new SiriusCommand(this.domain, selectedItem.getName()); |
| addRefreshTask(selectedItem, dCommand, javaActionItem); |
| Option<DRepresentation> dRepresentation = new EObjectQuery(selectedItem).getRepresentation(); |
| dCommand.getTasks().add(new ElementsToSelectTask(javaActionItem, InterpreterUtil.getInterpreter(selectedItem.getTarget()), selectedItem.getTarget(), dRepresentation.get())); |
| |
| compoundCommand.append(dCommand); |
| |
| return compoundCommand; |
| } |
| } |
