| /******************************************************************************* |
| * Copyright (c) 2007, 2021 THALES GLOBAL SERVICES and others. |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.sirius.table.tools.internal.command; |
| |
| import java.text.MessageFormat; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| 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.UnexecutableCommand; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.transaction.TransactionalEditingDomain; |
| import org.eclipse.sirius.business.api.helper.task.AbstractCommandTask; |
| 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.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.accessor.exception.FeatureNotFoundException; |
| import org.eclipse.sirius.ecore.extender.business.api.accessor.exception.MetaClassNotFoundException; |
| import org.eclipse.sirius.ecore.extender.business.api.permission.IPermissionAuthority; |
| import org.eclipse.sirius.ecore.extender.business.api.permission.exception.LockedInstanceException; |
| import org.eclipse.sirius.ext.base.Option; |
| import org.eclipse.sirius.table.business.api.helper.TableHelper; |
| import org.eclipse.sirius.table.business.internal.helper.task.CreateTableTask; |
| import org.eclipse.sirius.table.metamodel.table.DCell; |
| import org.eclipse.sirius.table.metamodel.table.DLine; |
| import org.eclipse.sirius.table.metamodel.table.DTable; |
| import org.eclipse.sirius.table.metamodel.table.DTableElement; |
| import org.eclipse.sirius.table.metamodel.table.DTargetColumn; |
| import org.eclipse.sirius.table.metamodel.table.LineContainer; |
| import org.eclipse.sirius.table.metamodel.table.description.CellEditorTool; |
| import org.eclipse.sirius.table.metamodel.table.description.CellUpdater; |
| import org.eclipse.sirius.table.metamodel.table.description.ColumnMapping; |
| import org.eclipse.sirius.table.metamodel.table.description.CreateCellTool; |
| import org.eclipse.sirius.table.metamodel.table.description.CreateTool; |
| import org.eclipse.sirius.table.metamodel.table.description.DeleteTool; |
| import org.eclipse.sirius.table.metamodel.table.description.ElementColumnMapping; |
| import org.eclipse.sirius.table.metamodel.table.description.LabelEditTool; |
| import org.eclipse.sirius.table.metamodel.table.description.TableDescription; |
| import org.eclipse.sirius.table.metamodel.table.description.TableTool; |
| import org.eclipse.sirius.table.metamodel.table.description.TableVariable; |
| import org.eclipse.sirius.table.tools.api.command.ITableCommandFactory; |
| import org.eclipse.sirius.table.tools.api.interpreter.IInterpreterSiriusTableVariables; |
| import org.eclipse.sirius.table.tools.internal.Messages; |
| 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.interpreter.IInterpreterMessages; |
| import org.eclipse.sirius.tools.api.interpreter.InterpreterUtil; |
| import org.eclipse.sirius.tools.internal.command.builders.ElementsToSelectTask; |
| import org.eclipse.sirius.viewpoint.DRepresentation; |
| import org.eclipse.sirius.viewpoint.DSemanticDecorator; |
| import org.eclipse.sirius.viewpoint.SiriusPlugin; |
| import org.eclipse.sirius.viewpoint.description.AbstractVariable; |
| import org.eclipse.sirius.viewpoint.description.tool.AbstractToolDescription; |
| import org.eclipse.sirius.viewpoint.description.tool.RepresentationCreationDescription; |
| import org.eclipse.sirius.viewpoint.description.tool.ToolPackage; |
| |
| /** |
| * A command factory that creates commands that can be undone. |
| * |
| * @author lredor |
| */ |
| public class TableCommandFactory extends AbstractCommandFactory implements ITableCommandFactory { |
| private TaskHelper commandTaskHelper; |
| |
| /** |
| * Create a new Factory. the autoRefresh is by default deactivated |
| * |
| * @param domain |
| * : current editing domain. |
| */ |
| public TableCommandFactory(final TransactionalEditingDomain domain) { |
| super(domain); |
| } |
| |
| /** |
| * Create a new Factory. the autoRefresh is by default deactivated |
| * |
| * @param domain |
| * : current editing domain. |
| * @param modelAccessor |
| * the model Accessor |
| */ |
| public TableCommandFactory(final TransactionalEditingDomain domain, final ModelAccessor modelAccessor) { |
| super(domain); |
| } |
| |
| private IPermissionAuthority getPermissionAuthority() { |
| return modelAccessor.getPermissionAuthority(); |
| } |
| |
| /** |
| * 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 buildDeleteTableElement(final DTableElement element) { |
| Command cmd = UnexecutableCommand.INSTANCE; |
| |
| if (element instanceof DLine || element instanceof DTargetColumn) { |
| // We check that, in case of tool, the tool allows the deletion |
| DeleteTool deleteTool = getDeleteTool(element); |
| if (deleteTool == null || isDeleteAllowedByTool(element, deleteTool)) { |
| 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); |
| final DTable parentTable = TableHelper.getTable(element); |
| if (deleteTool != null) { |
| addDeleteTableElementFromTool(result, element, deleteTool); |
| addRefreshTask(parentTable, result, deleteTool); |
| cmd = new NoNullResourceCommand(result, element); |
| } else { |
| result.getTasks().add(new DeleteWithoutToolTask(element, modelAccessor, commandTaskHelper)); |
| addRefreshTask(parentTable, result, deleteTool); |
| cmd = new NoNullResourceCommand(result, element); |
| } |
| } |
| } |
| } |
| } |
| return cmd; |
| } |
| |
| /** |
| * 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 LineContainer lineContainer, final EObject semanticCurrentElement, final CreateTool 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.getTarget()), lineContainer.getTarget(), dRepresentation.get())); |
| result = createLineCommand; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Create a command that creates a column. |
| * |
| * @param containerView |
| * 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 buildCreateColumnCommandFromTool(final DTable containerView, final EObject semanticCurrentElement, final CreateTool tool) { |
| Command result = UnexecutableCommand.INSTANCE; |
| if (!getPermissionAuthority().canEditInstance(containerView)) { |
| result = new InvalidPermissionCommand(domain, containerView); |
| } else { |
| if (commandTaskHelper.checkPrecondition(semanticCurrentElement, tool)) { |
| SiriusCommand createColumnCommand = buildCommandFromModelOfTool(semanticCurrentElement, tool, containerView); |
| // Add the task that creates the element DTargetColumn |
| // result.getTasks().add(new CreateDLineTask(tool, result, |
| // modelAccessor, lineContainer)); |
| addRefreshTask(containerView, createColumnCommand, tool); |
| Option<DRepresentation> dRepresentation = new EObjectQuery(containerView).getRepresentation(); |
| createColumnCommand.getTasks().add(new ElementsToSelectTask(tool, InterpreterUtil.getInterpreter(containerView.getTarget()), containerView.getTarget(), dRepresentation.get())); |
| result = createColumnCommand; |
| } |
| } |
| return result; |
| } |
| |
| private DeleteTool getDeleteTool(final DTableElement element) { |
| DeleteTool result = null; |
| if (element instanceof DLine) { |
| result = ((DLine) element).getOriginMapping().getDelete(); |
| } else if (element instanceof DTargetColumn) { |
| final ColumnMapping columnMapping = ((DTargetColumn) element).getOriginMapping(); |
| if (columnMapping instanceof ElementColumnMapping) { |
| result = ((ElementColumnMapping) columnMapping).getDelete(); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Check the delete availability from tool, based on its condition expression. |
| * |
| * @param element |
| * the DTableElement |
| * @param deleteTool |
| * the tool |
| * @return if the deletion is available from tool |
| */ |
| private boolean isDeleteAllowedByTool(final DTableElement element, final DeleteTool deleteTool) { |
| final EObject semanticElement = ((DSemanticDecorator) element).getTarget(); |
| final EObject rootContainer = TableHelper.getTable(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); |
| } |
| return delete; |
| } |
| |
| private void addDeleteTableElementFromTool(final SiriusCommand cmd, final DTableElement element, final DeleteTool deleteTool) { |
| final EObject semanticElement = ((DSemanticDecorator) element).getTarget(); |
| cmd.getTasks().addAll(buildCommandFromModelOfTool(semanticElement, deleteTool, element.eContainer()).getTasks()); |
| cmd.getTasks().add(new DeleteDRepresentationElementsTask(modelAccessor, cmd, commandTaskHelper, element) { |
| @Override |
| protected void addDialectSpecificAdditionalDeleteSubTasks(DSemanticDecorator semDec, List<ICommandTask> subTasks) { |
| super.addDialectSpecificAdditionalDeleteSubTasks(semDec, subTasks); |
| if (semDec instanceof DCell) { |
| final DCell cell = (DCell) semDec; |
| subTasks.add(new AbstractCommandTask() { |
| |
| @Override |
| public String getLabel() { |
| return ""; //$NON-NLS-1$ |
| } |
| |
| @Override |
| public void execute() throws MetaClassNotFoundException, FeatureNotFoundException { |
| cell.setColumn(null); |
| } |
| }); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * 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 DeleteTool) { |
| final DeleteTool deleteTool = (DeleteTool) tool; |
| if (containerView instanceof DTableElement) { |
| variables.put(TableHelper.getVariable(deleteTool, IInterpreterSiriusVariables.ROOT), TableHelper.getTable(containerView).getTarget()); |
| } else if (containerView instanceof DTable) { |
| variables.put(TableHelper.getVariable(deleteTool, IInterpreterSiriusVariables.ROOT), ((DTable) containerView).getTarget()); |
| } |
| variables.put(TableHelper.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(TableHelper.getTable(containerView), semanticCurrentElement, deleteTool.getFirstModelOperation())); |
| } else if (tool instanceof CreateTool) { |
| final CreateTool creationTool = (CreateTool) tool; |
| if (containerView instanceof DTableElement) { |
| variables.put(TableHelper.getVariable(creationTool, IInterpreterSiriusVariables.ROOT), TableHelper.getTable(containerView).getTarget()); |
| if (containerView instanceof DLine) { |
| variables.put(TableHelper.getVariable(creationTool, IInterpreterSiriusVariables.CONTAINER), ((DLine) containerView).getTarget()); |
| } |
| } else if (containerView instanceof DTable) { |
| TableVariable rootVariable = TableHelper.getVariable(creationTool, IInterpreterSiriusVariables.ROOT); |
| if (rootVariable != null) { |
| variables.put(rootVariable, ((DTable) containerView).getTarget()); |
| } |
| TableVariable containerVariable = TableHelper.getVariable(creationTool, IInterpreterSiriusVariables.CONTAINER); |
| if (containerVariable != null) { |
| variables.put(containerVariable, ((DTable) containerView).getTarget()); |
| } |
| } |
| TableVariable elementVariable = TableHelper.getVariable(creationTool, IInterpreterSiriusVariables.ELEMENT); |
| if (elementVariable != null) { |
| variables.put(elementVariable, 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(TableHelper.getTable(containerView), semanticCurrentElement, creationTool.getFirstModelOperation())); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Build a command that covers all the model operations corresponding to a the {@link DCell currentCell} and the |
| * corresponding {@link org.eclipse.sirius.table.metamodel.table.description.LabelEditTool directEdit tool}, |
| * {@link org.eclipse.sirius.table.metamodel.table.description.CellEditorTool cellEditor tool} or |
| * {@link org.eclipse.sirius.table.metamodel.table.description.CreateCellTool createCell tool}. |
| * |
| * @param currentCell |
| * the current edited cell. |
| * @param tool |
| * The table tool (create or edit) |
| * @param newValue |
| * the new value for this cell |
| * @return a command able to execute the direct Edit Tool. |
| */ |
| private SiriusCommand buildCommandFromCell(final DCell currentCell, final TableTool tool, final Object newValue) { |
| SiriusCommand result = new SiriusCommand(domain, Messages.TableCommandFactory_setCellContent); |
| if (!getPermissionAuthority().canEditInstance(currentCell)) { |
| result = new InvalidPermissionCommand(domain, currentCell); |
| } else { |
| EObject interpreterContext = currentCell.getTarget(); |
| if (interpreterContext == null) { |
| interpreterContext = currentCell.getLine().getTarget(); |
| } |
| |
| final Map<AbstractVariable, Object> variables = new HashMap<AbstractVariable, Object>(); |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusVariables.ROOT), TableHelper.getTable(currentCell).getTarget()); |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusTableVariables.LINE_SEMANTIC), currentCell.getLine().getTarget()); |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusTableVariables.LINE), currentCell.getLine()); |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusTableVariables.TABLE), TableHelper.getTable(currentCell)); |
| if (currentCell.getColumn() instanceof DTargetColumn) { |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusTableVariables.COLUMN_SEMANTIC), ((DTargetColumn) currentCell.getColumn()).getTarget()); |
| } |
| if (tool instanceof LabelEditTool) { |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusVariables.ELEMENT), currentCell.getTarget()); |
| } else if (tool instanceof CellEditorTool) { |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusVariables.ELEMENT), currentCell.getTarget()); |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusTableVariables.CELL_EDITOR_RESULT), newValue); |
| } |
| // Initialization of the variables |
| result.getTasks().add(new InitInterpreterVariablesTask(variables, InterpreterUtil.getInterpreter(interpreterContext), uiCallBack)); |
| if (tool instanceof LabelEditTool) { |
| final LabelEditTool labelEditTool = (LabelEditTool) tool; |
| if (labelEditTool.getMask() != null) { |
| /* |
| * First we need to init the mask variables. |
| */ |
| final String messageFormat = labelEditTool.getMask().getMask(); |
| result.getTasks().add(new InitInterpreterFromParsedVariableTask2(InterpreterUtil.getInterpreter(interpreterContext), messageFormat, newValue)); |
| } |
| } else if (tool instanceof CreateCellTool) { |
| final CreateCellTool createCellTool = (CreateCellTool) tool; |
| if (createCellTool.getMask() != null) { |
| /* |
| * First we need to init the mask variables. |
| */ |
| final String messageFormat = createCellTool.getMask().getMask(); |
| result.getTasks().add(new InitInterpreterFromParsedVariableTask2(InterpreterUtil.getInterpreter(interpreterContext), messageFormat, newValue)); |
| } |
| } |
| // Creation of the tasks to execute the tool |
| result.getTasks().add(commandTaskHelper.buildTaskFromModelOperation(TableHelper.getTable(currentCell), interpreterContext, tool.getFirstModelOperation())); |
| } |
| return result; |
| } |
| |
| /** |
| * Build a command that covers all the model operations corresponding to a |
| * {@link org.eclipse.sirius.table.metamodel.table.description.CreateCellTool createCell tool} for the current |
| * {@link DLine line} and {@link org.eclipse.sirius.table.metamodel.table.DColumn column}. |
| * |
| * @param currentLine |
| * the line corresponding to the intersection that need a creation of a new cell. |
| * @param currentColumn |
| * the column corresponding to the intersection that need a creation of a new cell. |
| * @param tool |
| * The create tool |
| * @param newValue |
| * the new value for this cell |
| * @return a command able to execute the create Tool. |
| */ |
| private SiriusCommand buildCommandFromIntersection(final DLine currentLine, final DTargetColumn currentColumn, final CreateCellTool tool, final Object newValue) { |
| SiriusCommand result = new SiriusCommand(domain, Messages.TableCommandFactory_setCellContent); |
| if (!getPermissionAuthority().canEditInstance(currentLine)) { |
| result = new InvalidPermissionCommand(domain, currentLine); |
| } else { |
| if (!getPermissionAuthority().canEditInstance(currentColumn)) { |
| result = new InvalidPermissionCommand(domain, currentColumn); |
| } else { |
| EObject interpreterContext = currentLine.getTarget(); |
| |
| final Map<AbstractVariable, Object> variables = new HashMap<AbstractVariable, Object>(); |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusVariables.ROOT), TableHelper.getTable(currentLine).getTarget()); |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusTableVariables.LINE_SEMANTIC), currentLine.getTarget()); |
| variables.put(TableHelper.getVariable(tool, IInterpreterSiriusTableVariables.COLUMN_SEMANTIC), currentColumn.getTarget()); |
| |
| // Initialization of the variables |
| result.getTasks().add(new InitInterpreterVariablesTask(variables, InterpreterUtil.getInterpreter(interpreterContext), uiCallBack)); |
| if (tool.getMask() != null) { |
| /* |
| * First we need to init the mask variables. |
| */ |
| final String messageFormat = tool.getMask().getMask(); |
| result.getTasks().add(new InitInterpreterFromParsedVariableTask2(InterpreterUtil.getInterpreter(interpreterContext), messageFormat, newValue)); |
| } |
| // Creation of the tasks to execute the tool |
| result.getTasks().add(commandTaskHelper.buildTaskFromModelOperation(TableHelper.getTable(currentLine), interpreterContext, tool.getFirstModelOperation())); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Return the commandTaskHelper. |
| * |
| * @return the commandTaskHelper |
| */ |
| public TaskHelper getCommandTaskHelper() { |
| return commandTaskHelper; |
| } |
| |
| /** |
| * @return the modelAccessor |
| */ |
| private ModelAccessor getModelAccessor() { |
| return modelAccessor; |
| } |
| |
| /** |
| * 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); |
| } |
| |
| /** |
| * Create a command that set the content of a crossTable cell. |
| * |
| * @param editedCell |
| * The cell to set |
| * @param newValue |
| * the new value for this cell |
| * @return a command able to set the content of a cell, corresponding to the |
| * {@link org.eclipse.sirius.table.metamodel.table.description.LabelEditTool LabelEditTool}, |
| * {@link org.eclipse.sirius.table.metamodel.table.description.CellEditorTool CellEditorTool} or |
| * {@link org.eclipse.sirius.table.metamodel.table.description.CreateCellTool CreateCellTool}. |
| */ |
| @Override |
| public Command buildSetCellValueFromTool(final DCell editedCell, final Object newValue) { |
| Command result = UnexecutableCommand.INSTANCE; |
| if (!getPermissionAuthority().canEditInstance(editedCell)) { |
| result = new InvalidPermissionCommand(domain, editedCell); |
| } else { |
| CellUpdater updater = editedCell.getUpdater(); |
| if (updater != null) { |
| if (updater.getDirectEdit() != null || updater.getCellEditor() != null) { |
| // If both directEdit and cellEditor is defined, the cell editor has priority (explained in |
| // documentation). |
| if (updater.getCellEditor() != null) { |
| result = buildCommandFromCell(editedCell, updater.getCellEditor(), newValue); |
| } else { |
| result = buildCommandFromCell(editedCell, updater.getDirectEdit(), newValue); |
| } |
| addRefreshTask(TableHelper.getTable(editedCell), (SiriusCommand) result, null); |
| } |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.table.tools.api.command.ITableCommandFactory#buildCreateCellFromTool(org.eclipse.sirius.table.metamodel.table.DLine, |
| * org.eclipse.sirius.table.metamodel.table.DTargetColumn, java.lang.Object) |
| */ |
| @Override |
| public Command buildCreateCellFromTool(DLine line, DTargetColumn column, Object newValue) { |
| Command result = UnexecutableCommand.INSTANCE; |
| if (!getPermissionAuthority().canEditInstance(line)) { |
| result = new InvalidPermissionCommand(domain, line); |
| } else { |
| if (!getPermissionAuthority().canEditInstance(column)) { |
| result = new InvalidPermissionCommand(domain, column); |
| } else { |
| final Option<CreateCellTool> optionalCreateCellTool = TableHelper.getCreateCellTool(line, column); |
| if (optionalCreateCellTool.some()) { |
| result = buildCommandFromIntersection(line, column, optionalCreateCellTool.get(), newValue); |
| addRefreshTask(TableHelper.getTable(line), (SiriusCommand) result, optionalCreateCellTool.get()); |
| Option<DRepresentation> dRepresentation = new EObjectQuery(line).getRepresentation(); |
| ((SiriusCommand) result).getTasks() |
| .add(new ElementsToSelectTask(optionalCreateCellTool.get(), InterpreterUtil.getInterpreter(line.getTarget()), line.getTarget(), dRepresentation.get())); |
| } |
| } |
| } |
| 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 DTable} creation |
| * @return a command that is able to create a table. |
| */ |
| public DCommand buildCreateTableFromDescription(final TableDescription 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 CreateTableTask(description, semanticElement, monitor)); |
| |
| return command; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.table.tools.api.command.ITableCommandFactory#buildSetValue(org.eclipse.emf.ecore.EObject, |
| * java.lang.String, java.lang.Object) |
| */ |
| @Override |
| public Command buildSetValue(final EObject instance, final String name, final Object value) { |
| if (getPermissionAuthority().canEditInstance(instance)) { |
| final SiriusCommand result = new SiriusCommand(domain); |
| result.getTasks().add(new AbstractCommandTask() { |
| |
| private final Object newValue = value; |
| |
| @Override |
| public String getLabel() { |
| return MessageFormat.format(Messages.TableCommandFactory_setValue, name); |
| } |
| |
| @Override |
| public void execute() { |
| try { |
| if (!getModelAccessor().eGet(instance, name).equals(newValue)) { |
| getModelAccessor().eSet(instance, name, newValue); |
| } |
| } catch (final LockedInstanceException e) { |
| SiriusPlugin.getDefault().error(IInterpreterMessages.EVALUATION_ERROR_ON_MODEL_MODIFICATION, e); |
| } catch (final FeatureNotFoundException e) { |
| SiriusPlugin.getDefault().error(IInterpreterMessages.EVALUATION_ERROR_ON_MODEL_MODIFICATION, e); |
| } |
| } |
| }); |
| return result; |
| } else { |
| return new InvalidPermissionCommand(domain, instance); |
| } |
| |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.table.tools.api.command.ITableCommandFactory#buildAddValue(org.eclipse.emf.ecore.EObject, |
| * java.lang.String, java.lang.Object) |
| */ |
| @Override |
| public Command buildAddValue(final EObject instance, final String name, final Object value) { |
| if (getPermissionAuthority().canEditInstance(instance)) { |
| final SiriusCommand result = new SiriusCommand(domain); |
| result.getTasks().add(new AbstractCommandTask() { |
| |
| @Override |
| public String getLabel() { |
| return MessageFormat.format(Messages.TableCommandFactory_addValue, name); |
| } |
| |
| @Override |
| public void execute() { |
| try { |
| getModelAccessor().eAdd(instance, name, value); |
| } catch (final LockedInstanceException e) { |
| SiriusPlugin.getDefault().error(IInterpreterMessages.EVALUATION_ERROR_ON_MODEL_MODIFICATION, e); |
| } catch (final FeatureNotFoundException e) { |
| SiriusPlugin.getDefault().error(IInterpreterMessages.EVALUATION_ERROR_ON_MODEL_MODIFICATION, e); |
| } |
| } |
| }); |
| return result; |
| } else { |
| return new InvalidPermissionCommand(domain, instance); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.table.tools.api.command.ITableCommandFactory#buildClearValue(org.eclipse.emf.ecore.EObject, |
| * java.lang.String, java.lang.Object) |
| */ |
| @Override |
| public Command buildClearValue(final EObject instance, final String name) { |
| if (getPermissionAuthority().canEditInstance(instance)) { |
| |
| final SiriusCommand result = new SiriusCommand(domain); |
| result.getTasks().add(new AbstractCommandTask() { |
| |
| @Override |
| public String getLabel() { |
| return MessageFormat.format(Messages.TableCommandFactory_clearValue, name); |
| } |
| |
| @Override |
| public void execute() { |
| try { |
| getModelAccessor().eClear(instance, name); |
| } catch (final LockedInstanceException e) { |
| SiriusPlugin.getDefault().error(IInterpreterMessages.EVALUATION_ERROR_ON_MODEL_MODIFICATION, e); |
| } |
| } |
| }); |
| return result; |
| } else { |
| return new InvalidPermissionCommand(domain, instance); |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.table.tools.api.command.ITableCommandFactory#buildDoExecuteDetailsOperation(org.eclipse.sirius.viewpoint.DSemanticDecorator, |
| * org.eclipse.sirius.viewpoint.description.tool.RepresentationCreationDescription, java.lang.String) |
| */ |
| @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(TableHelper.getTable(target), target.getTarget(), desc.getInitialOperation().getFirstModelOperations())); |
| return cmd; |
| } |
| } |
