/**
* Creates and returns a command to remove the interface and associated inherited interfaces if
* they are not referenced by other ports.
*
* @param i the {@link Interface} to remove
* @param removePorts the {@link Uses} or {@link Provides} to ignore when considering which
* interfaces to remove
* @param removeInterfaces the {@link Set} of repIds already scheduled for removal
* @return a {@link Command} to remove the specified {@link Interface} and {@link
* InheritsInterface} if they can be removed
*/
public Command createRemoveInterfaceCommand(
final Collection<EObject> removePorts,
final Set<String> removeInterfaces,
final Interface i) {
if (!containsRepId(i.getRepid(), removePorts)) {
final CompoundCommand command = new CompoundCommand("Remove Interfaces");
for (final InheritsInterface inherited : i.getInheritsInterfaces()) {
if (!containsRepId(inherited.getRepid(), removePorts)) {
if (!removeInterfaces.contains(inherited.getRepid())) {
// If the inherited interface isn't referenced by another port and isn't already
// scheduled for
// removal, make a recursive call to remove it
if (inherited.getInterface() != null) {
command.append(
this.createRemoveInterfaceCommand(
removePorts, removeInterfaces, inherited.getInterface()));
}
}
}
}
// If the interface isn't already scheduled for removal, create a command to remove it
if (removeInterfaces.add(i.getRepid())) {
command.append(
RemoveCommand.create(
this.editingDomain,
PortsHandlerUtil.getInterfaces(this.softPkg),
ScdPackage.Literals.INTERFACES__INTERFACE,
i));
}
return command;
}
return null;
}
/**
* Adds a command to move a papyrus table and the matching table2 instance, to the compound
* command.
*/
protected static void addMoveTableCommand(
TransactionalEditingDomain editingDomain,
PapyrusTableInstance papyrusTable,
Resource target,
CompoundCommand commandToModify) {
// The command has to move both the table and its table2.
TableInstance2 papyrusTable2 = papyrusTable.getTable();
/*
* Has the target resource been loaded, and is it in read only mode ?
*/
if (editingDomain.isReadOnly(target)) {
return;
}
/*
* Moving both the table instance and the table2 instance.
*/
if (target != null) {
MoveOpenableCommand mvTabCmd =
new MoveOpenableCommand(
editingDomain, "moving table", papyrusTable, target); // $NON-NLS-1$
if (mvTabCmd != null && mvTabCmd.canExecute()) {
commandToModify.append(new GMFtoEMFCommandWrapper(mvTabCmd));
}
MoveOpenableCommand mvTab2Cmd =
new MoveOpenableCommand(
editingDomain, "moving table2", papyrusTable2, target); // $NON-NLS-1$
if (mvTab2Cmd != null && mvTab2Cmd.canExecute()) {
commandToModify.append(new GMFtoEMFCommandWrapper(mvTab2Cmd));
}
}
}
/** {@inheritDoc} */
public void uncontrol(
EditingDomain domain,
final EObject selection,
STATE_CONTROL state,
Resource source,
final Resource target,
CompoundCommand commandToModify) {
switch (state) {
case PRE_MODEL:
commandToModify.append(
new ChangeCommand(
domain,
new Runnable() {
public void run() {
unapplyDuplicateProfiles(selection, target);
}
}));
break;
case POST_MODEL:
commandToModify.append(
new ChangeCommand(
domain,
new Runnable() {
public void run() {
ProfileApplicationHelper.relocateStereotypeApplications(
(Package) selection, target);
}
}));
break;
default:
}
}
@Override
public Command createCommand(Collection<?> selection) {
EStructuralFeature ef = feature;
EObject owner = (EObject) viewer.getInput();
if (domain.getClipboard() == null) {
return UnexecutableCommand.INSTANCE;
}
Collection<Object> objs = getPasteObjs(EcoreUtil.copyAll(domain.getClipboard()), eclass);
if (objs.size() > 0) {
if (!MetadataViewerUtil.isShowCategory(viewer)) {
return AddCommand.create(getEditingDomain(), owner, ef, objs);
}
MetadataCategory cate = MetadataViewerUtil.getSelectedCategory(viewer, false);
if (cate instanceof UncategorizedItemsCategoryImpl) {
return AddCommand.create(getEditingDomain(), owner, ef, objs);
} else if (cate instanceof MetadataCategory) {
CompoundCommand command = new CompoundCommand();
command.append(
AddCommand.create(
getEditingDomain(), cate, MetadataPackage.Literals.METADATA_CATEGORY__ITEMS, objs));
command.append(AddCommand.create(getEditingDomain(), owner, ef, objs));
// 再添加到分组
return command;
}
}
return UnexecutableCommand.INSTANCE;
}
/**
* {@inheritDoc}
*
* @see
* org.eclipse.emf.eef.runtime.api.notify.IPropertiesEditionListener#firePropertiesChanged(org.eclipse.emf.eef.runtime.api.notify.IPropertiesEditionEvent)
*/
public void firePropertiesChanged(IPropertiesEditionEvent event) {
if (!isInitializing()) {
Diagnostic valueDiagnostic = validateValue(event);
if (PropertiesEditionEvent.COMMIT == event.getState()
&& IPropertiesEditionComponent.LIVE_MODE.equals(editing_mode)
&& valueDiagnostic.getSeverity() == Diagnostic.OK) {
CompoundCommand command = new CompoundCommand();
if (TarotViewsRepository.GamePlayers.players == event.getAffectedEditor()) {
if (PropertiesEditionEvent.SET == event.getKind()) {
Player oldValue = (Player) event.getOldValue();
Player newValue = (Player) event.getNewValue();
// TODO: Complete the game update command
for (EStructuralFeature feature : newValue.eClass().getEAllStructuralFeatures()) {
if (feature.isChangeable()
&& !(feature instanceof EReference && ((EReference) feature).isContainer())) {
command.append(
SetCommand.create(
liveEditingDomain, oldValue, feature, newValue.eGet(feature)));
}
}
} else if (PropertiesEditionEvent.ADD == event.getKind())
command.append(
AddCommand.create(
liveEditingDomain,
game,
TarotPackage.eINSTANCE.getGame_Players(),
event.getNewValue()));
else if (PropertiesEditionEvent.REMOVE == event.getKind())
command.append(DeleteCommand.create(liveEditingDomain, event.getNewValue()));
else if (PropertiesEditionEvent.MOVE == event.getKind())
command.append(
MoveCommand.create(
liveEditingDomain,
game,
TarotPackage.eINSTANCE.getPlayer(),
event.getNewValue(),
event.getNewIndex()));
}
if (!command.isEmpty() && !command.canExecute()) {
EEFRuntimePlugin.getDefault().logError("Cannot perform model change command.", null);
} else {
liveEditingDomain.getCommandStack().execute(command);
}
}
if (valueDiagnostic.getSeverity() != Diagnostic.OK
&& valueDiagnostic instanceof BasicDiagnostic)
super.firePropertiesChanged(new PropertiesValidationEditionEvent(event, valueDiagnostic));
else {
Diagnostic validate = validate();
super.firePropertiesChanged(new PropertiesValidationEditionEvent(event, validate));
}
super.firePropertiesChanged(event);
}
}
/** @generated */
protected Command createCommand() {
TransactionalEditingDomain editingDomain =
TransactionUtil.getEditingDomain(oldTarget.getDiagram().getElement());
CompoundCommand result = new CompoundCommand();
result.append(new ReconnectNotationalEdgeTargetCommand(edge, newTarget));
result.append(
SetCommand.create(
editingDomain,
edge.getElement(),
imagindata.imagindataPackage.eINSTANCE.getTransition_End(),
newTarget.getElement()));
return result;
}
/**
* In addition to the regular functionality (creating a SpecHierarchy child object), this method
* allows a SpecObject or a SpecType as an argument: Note that this is almost the same as {@link
* SpecificationItemProvider#createCreateChildCommand(EditingDomain, EObject, EStructuralFeature,
* Object, int, Collection)} .
*
* @param value instanceof {@link SpecType}: A new SpecObject with the given SpecType is created,
* and a SpecHierarchy is added that is associated with the newly created SpecObject.
* @param value instanceof {@link SpecObject}: The SpecObject is added to a new SpecHierarchy,
* which is then added.
*/
@Override
protected Command createCreateChildCommand(
EditingDomain domain,
EObject owner,
EStructuralFeature feature,
Object value,
int index,
Collection<?> collection) {
if (value instanceof SpecType) {
ReqIFContent content = ReqIF10Util.getReqIF(owner).getCoreContent();
SpecObject specObject = ReqIF10Factory.eINSTANCE.createSpecObject();
SpecHierarchy specHierarchy = ReqIF10Factory.eINSTANCE.createSpecHierarchy();
CompoundCommand cmd =
ProrUtil.createAddTypedElementCommand(
content,
REQ_IF_CONTENT__SPEC_OBJECTS,
specObject,
SPEC_OBJECT__TYPE,
(SpecType) value,
-1,
3,
domain,
adapterFactory);
cmd.append(AddCommand.create(domain, owner, SPEC_HIERARCHY__CHILDREN, specHierarchy, index));
cmd.append(SetCommand.create(domain, specHierarchy, SPEC_HIERARCHY__OBJECT, specObject));
return cmd;
}
if (value instanceof SpecObject) {
Object icon = ProrUtil.getItemProvider(adapterFactory, value).getImage(value);
CompoundCommand cmd = ProrUtil.createCompoundCommandWithAddIcon(icon, 0);
cmd.setLabel("Adding SpecObject");
cmd.setDescription("Adding SpecObject");
SpecHierarchy specHierarchy = ReqIF10Factory.eINSTANCE.createSpecHierarchy();
cmd.append(AddCommand.create(domain, owner, SPEC_HIERARCHY__CHILDREN, specHierarchy, index));
cmd.append(
AddCommand.create(
domain,
ReqIF10Util.getReqIF(owner).getCoreContent(),
REQ_IF_CONTENT__SPEC_OBJECTS,
value));
cmd.append(SetCommand.create(domain, specHierarchy, SPEC_HIERARCHY__OBJECT, value));
return cmd;
}
return super.createCreateChildCommand(domain, owner, feature, value, index, collection);
}
protected void updateLabel(FormElement fw, String name) {
if (headless) {
fw.setLabel(name);
} else {
cc.append(SetCommand.create(domain, fw, FormPackage.eINSTANCE.getFormElement_Label(), name));
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.papyrus.infra.gmfdiag.common.strategy.paste.IPasteStrategy#getSemanticCommand(org.eclipse.emf.edit.domain.EditingDomain,
* org.eclipse.emf.ecore.EObject, org.eclipse.papyrus.infra.core.clipboard.PapyrusClipboard)
*/
@Override
public org.eclipse.emf.common.command.Command getSemanticCommand(
EditingDomain domain, EObject targetOwner, PapyrusClipboard<Object> papyrusClipboard) {
CompoundCommand compoundCommand =
new CompoundCommand("Rename root paste elements"); // $NON-NLS-1$
List<EObject> filterDescendants = EcoreUtil.filterDescendants(papyrusClipboard.getTarget());
for (Iterator<EObject> iterator = filterDescendants.iterator(); iterator.hasNext(); ) {
EObject target = iterator.next();
if (target instanceof NamedElement) {
NamedElement namedElement = (NamedElement) target;
if (namedElement.getName() != null) {
String defaultCopyNameWithIncrement =
NamedElementUtil.getDefaultCopyNameWithIncrement(
namedElement, targetOwner.eContents());
RenameElementCommand renameElementCommand =
new RenameElementCommand(
(TransactionalEditingDomain) domain, namedElement, defaultCopyNameWithIncrement);
compoundCommand.append(renameElementCommand);
}
}
}
// An empty can't be executed
if (compoundCommand.getCommandList().isEmpty()) {
return null;
}
return compoundCommand;
}
public void updateModelChoiceField(
AbstractClass srcClazz, Association ass, ModelChoiceField mcf) {
ModelChoiceField modelChoiceFieldForAssociation =
ClassDiagramUtils.getModelChoiceFieldForAssociation(ass, srcClazz);
int parseInt = modelChoiceFieldForAssociation.getMax_bound();
// at least bounds must be compatible with constraints in the dt model
boolean b = (((ModelChoiceField) mcf).getMax_bound() > parseInt) && (parseInt != -1);
if (headless) {
if (b) {
mcf.setMax_bound(parseInt);
}
} else {
if (b) {
cc.append(
SetCommand.create(
domain, mcf, FormPackage.eINSTANCE.getModelChoiceField_Max_bound(), parseInt));
}
}
// maybe the name or Label have been changed must be based on target name/Label if exists
String id = modelChoiceFieldForAssociation.getId();
if (updateId && !id.equals(mcf.getId())) {
updateId(mcf, id);
}
String label = modelChoiceFieldForAssociation.getLabel();
if (updateLabel && !label.equals(mcf.getLabel())) {
updateLabel(mcf, label);
}
}
public void updateAttributeFields(
FormContainer formContainer, FormElement formElement, Attribute att) {
FormElement fieldForAttribute = null;
if (formContainer instanceof FormSearch) {
fieldForAttribute = SearchInitialization.getSearchFieldForAttribute(att);
} else if (formContainer instanceof FormClass || formContainer instanceof FormWorkflow) {
fieldForAttribute = ClassDiagramUtils.getFieldForAttribute(att);
}
if (!fieldForAttribute.getClass().isInstance(formElement)) {
// mismatch so we replace the Field
FormGroup eContainer = (FormGroup) formElement.eContainer();
boolean contains = eContainer.getChildren().contains(formElement);
if (headless) {
EList<FormElement> children = null;
if (contains) {
children = eContainer.getChildren();
} else {
children = eContainer.getDisabled();
}
// add the new Field
children.add(fieldForAttribute);
// remove
children.remove(formElement);
} else {
if (contains) {
cc.append(
AddCommand.create(
domain,
eContainer,
FormPackage.eINSTANCE.getFormGroup_Children(),
fieldForAttribute));
} else {
cc.append(
AddCommand.create(
domain,
eContainer,
FormPackage.eINSTANCE.getFormGroup_Disabled(),
fieldForAttribute));
}
Command rmCmd = RemoveCommand.create(domain, formElement);
cc.append(rmCmd);
}
}
}
/* (non-Javadoc)
* @see org.bonitasoft.studio.configuration.AbstractConnectorConfigurationSynchronizer#updateJarDependencies(org.bonitasoft.studio.model.configuration.FragmentContainer, org.bonitasoft.studio.connector.model.implementation.ConnectorImplementation, org.eclipse.emf.edit.domain.EditingDomain, org.eclipse.emf.common.command.CompoundCommand)
*/
@Override
protected void updateJarDependencies(
FragmentContainer connectorContainer,
ConnectorImplementation implementation,
EditingDomain editingDomain,
CompoundCommand cc,
boolean forceDriver) {
super.updateJarDependencies(connectorContainer, implementation, editingDomain, cc, forceDriver);
store =
(DatabaseConnectorPropertiesRepositoryStore)
RepositoryManager.getInstance()
.getRepositoryStore(DatabaseConnectorPropertiesRepositoryStore.class);
DatabaseConnectorPropertiesFileStore fileStore =
(DatabaseConnectorPropertiesFileStore)
store.getChild(
implementation.getDefinitionId()
+ "."
+ DatabaseConnectorPropertiesRepositoryStore.CONF_EXT);
if (fileStore != null) {
String defaultDriver = fileStore.getDefault();
List<String> jars = fileStore.getJarList();
boolean autoAddDriver = fileStore.getAutoAddDriver() || forceDriver;
Configuration conf = (Configuration) connectorContainer.eContainer().eContainer();
FragmentContainer otherDependencies = null;
for (FragmentContainer c : conf.getProcessDependencies()) {
if (FragmentTypes.OTHER.equals(c.getId())) {
otherDependencies = c;
}
}
for (String jar : jars) {
boolean exists = false;
for (Fragment dep : otherDependencies.getFragments()) {
if (dep.getValue().equals(jar)) {
exists = true;
break;
}
}
if (!exists) {
Fragment depFragment = ConfigurationFactory.eINSTANCE.createFragment();
if (jar.equals(defaultDriver) && autoAddDriver) {
depFragment.setExported(true);
} else {
depFragment.setExported(false);
}
depFragment.setKey(jar);
depFragment.setValue(jar);
depFragment.setType(FragmentTypes.JAR);
cc.append(
AddCommand.create(
editingDomain,
otherDependencies,
ConfigurationPackage.Literals.FRAGMENT_CONTAINER__FRAGMENTS,
depFragment));
}
}
}
}
protected void updateId(FormElement fw, String computeFormWorkflowId) {
if (headless) {
fw.setId(computeFormWorkflowId);
} else {
cc.append(
SetCommand.create(
domain, fw, FormPackage.eINSTANCE.getFormElement_Id(), computeFormWorkflowId));
}
}
@Override
public ICommand getReconcileCommand(Diagram diagram) {
try {
CompoundCommand cc =
new CompoundCommand("Update Internal Block Diagram From Undefined To 1.0.0");
Command updateCommandFromUndefinedTo_081 = getUpdateCommandFromUndefinedTo_081(diagram);
Command updateCommandFrom081To_091 = getUpdateCommandFrom081To_091(diagram);
cc.append(updateCommandFromUndefinedTo_081);
cc.append(updateCommandFrom081To_091);
return EMFtoGMFCommandWrapper.wrap(cc);
} catch (Exception e) {
Activator.log.error(e);
return UnexecutableCommand.INSTANCE;
}
}
/**
* {@inheritDoc}
*
* @see
* org.eclipse.emf.eef.runtime.api.component.IPropertiesEditionComponent#getPropertiesEditionCommand
* (org.eclipse.emf.edit.domain.EditingDomain)
*/
public CompoundCommand getPropertiesEditionCommand(EditingDomain editingDomain) {
CompoundCommand cc = new CompoundCommand();
if ((talk != null) && (basePart != null)) {
cc.append(
SetCommand.create(
editingDomain,
talk,
NonregPackage.eINSTANCE.getTalk_Presenter(),
basePart.getCombo()));
cc.append(
SetCommand.create(
editingDomain,
talk,
NonregPackage.eINSTANCE.getTalk_Presenter(),
basePart.getComboRO()));
}
if (!cc.isEmpty()) return cc;
cc.append(IdentityCommand.INSTANCE);
return cc;
}
/**
* {@inheritDoc}
*
* @see
* org.eclipse.emf.eef.runtime.api.component.IPropertiesEditionComponent#getPropertiesEditionCommand
* (org.eclipse.emf.edit.domain.EditingDomain)
*/
public CompoundCommand getPropertiesEditionCommand(EditingDomain editingDomain) {
CompoundCommand cc = new CompoundCommand();
if ((game != null) && (gamePlayersPart != null)) {
List playersToAddFromPlayers = gamePlayersPart.getPlayersToAdd();
for (Iterator iter = playersToAddFromPlayers.iterator(); iter.hasNext(); )
cc.append(
AddCommand.create(
editingDomain, game, TarotPackage.eINSTANCE.getGame_Players(), iter.next()));
Map playersToRefreshFromPlayers = gamePlayersPart.getPlayersToEdit();
for (Iterator iter = playersToRefreshFromPlayers.keySet().iterator(); iter.hasNext(); ) {
Player nextElement = (Player) iter.next();
Player players = (Player) playersToRefreshFromPlayers.get(nextElement);
for (EStructuralFeature feature : nextElement.eClass().getEAllStructuralFeatures()) {
if (feature.isChangeable()
&& !(feature instanceof EReference && ((EReference) feature).isContainer())) {
cc.append(
SetCommand.create(editingDomain, nextElement, feature, players.eGet(feature)));
}
}
}
List playersToRemoveFromPlayers = gamePlayersPart.getPlayersToRemove();
for (Iterator iter = playersToRemoveFromPlayers.iterator(); iter.hasNext(); )
cc.append(DeleteCommand.create(editingDomain, iter.next()));
List playersToMoveFromPlayers = gamePlayersPart.getPlayersToMove();
for (Iterator iter = playersToMoveFromPlayers.iterator(); iter.hasNext(); ) {
org.eclipse.emf.eef.runtime.impl.utils.EMFListEditUtil.MoveElement moveElement =
(org.eclipse.emf.eef.runtime.impl.utils.EMFListEditUtil.MoveElement) iter.next();
cc.append(
MoveCommand.create(
editingDomain,
game,
TarotPackage.eINSTANCE.getPlayer(),
moveElement.getElement(),
moveElement.getIndex()));
}
}
if (!cc.isEmpty()) return cc;
cc.append(IdentityCommand.INSTANCE);
return cc;
}
/**
* Creates and returns a command to remove the specified ports.
*
* @param ports the ports to remove from the {@link mil.jpeojtrs.sca.scd.SoftwareComponent}
* @param ignoreIds ignore the specified repIds when considering which interfaces to remove
* @return the {@link Command} to remove the port and all associated {@link Interface}
*/
public Command createRemovePortCommand(
final Collection<Object> ports, final Set<String> ignoreIds) {
final Set<String> repIds = new HashSet<String>();
final List<EObject> removePorts = new ArrayList<EObject>();
final CompoundCommand command = new CompoundCommand("Remove Ports");
for (final Object obj : ports) {
final EObject port = (EObject) AdapterFactoryEditingDomain.unwrap(obj);
if (port instanceof AbstractPort) {
for (AbstractPort p : getPorts().getAllPorts()) {
if (p.equals(port)) {
final AbstractPort sibling = p.getSibling();
if (sibling == null || !(p instanceof Uses)) {
repIds.add(p.getRepID());
command.append(
RemoveCommand.create(this.editingDomain, getPorts(), p.eContainingFeature(), p));
if (sibling != null) {
command.append(
RemoveCommand.create(
this.editingDomain, getPorts(), sibling.eContainingFeature(), sibling));
}
removePorts.add(p);
}
}
}
}
}
for (final String repId : repIds) {
if (this.interfaceMap.containsKey(repId) && !ignoreIds.contains(repId)) {
final Command interfaceCommand =
this.createRemoveInterfaceCommand(removePorts, ignoreIds, this.interfaceMap.get(repId));
if (interfaceCommand != null) {
command.append(interfaceCommand);
this.interfaceMap.remove(repId);
}
}
}
return command;
}
protected void createCommand(Object oldValue, Object newValue) {
boolean equals = oldValue == null ? false : oldValue.equals(newValue);
if (!equals) {
EditingDomain editingDomain = getEditingDomain();
CompoundCommand compoundCommand = new CompoundCommand(COMMAND_NAME);
// apply the property change to all selected elements
for (EObject nextObject : getEObjectList()) {
compoundCommand.append(
SetCommand.create(editingDomain, nextObject, getFeature(), newValue));
}
editingDomain.getCommandStack().execute(compoundCommand);
}
}
/** If a ReqIF has no labels yet, this method configures some smart defaults. */
public static void setDefaultLabelsIfNecessary(
AdapterFactory adapterFactory, EditingDomain editingDomain, ReqIF reqif) {
CompoundCommand cmd = new CompoundCommand();
ProrToolExtension extension = createProrToolExtension(reqif, editingDomain);
ProrGeneralConfiguration generalConfig = extension.getGeneralConfiguration();
if (generalConfig == null) {
generalConfig = ConfigurationFactory.eINSTANCE.createProrGeneralConfiguration();
cmd.append(
SetCommand.create(
editingDomain,
extension,
ConfigurationPackage.Literals.PROR_TOOL_EXTENSION__GENERAL_CONFIGURATION,
generalConfig));
}
LabelConfiguration labelConfig = generalConfig.getLabelConfiguration();
if (labelConfig == null) {
labelConfig = ConfigurationFactory.eINSTANCE.createLabelConfiguration();
cmd.append(
SetCommand.create(
editingDomain,
generalConfig,
ConfigurationPackage.Literals.PROR_GENERAL_CONFIGURATION__LABEL_CONFIGURATION,
labelConfig));
} else {
// If there is already a label configuration, we leave it alone.
return;
}
labelConfig.getDefaultLabel().add("ReqIF.ChapterNumber");
labelConfig.getDefaultLabel().add("ReqIF.ChapterName");
labelConfig.getDefaultLabel().add("ReqIF.Name");
labelConfig.getDefaultLabel().add("ReqIF.Text");
labelConfig.getDefaultLabel().add("ID");
labelConfig.getDefaultLabel().add("Name");
labelConfig.getDefaultLabel().add("Description");
editingDomain.getCommandStack().execute(cmd);
}
/**
* {@inheritDoc}
*
* @see
* org.eclipse.emf.eef.runtime.api.notify.IPropertiesEditionListener#firePropertiesChanged(org.eclipse.emf.eef.runtime.api.notify.IPropertiesEditionEvent)
*/
public void firePropertiesChanged(IPropertiesEditionEvent event) {
if (!isInitializing()) {
Diagnostic valueDiagnostic = validateValue(event);
if (PropertiesEditionEvent.COMMIT == event.getState()
&& IPropertiesEditionComponent.LIVE_MODE.equals(editing_mode)
&& valueDiagnostic.getSeverity() == Diagnostic.OK) {
CompoundCommand command = new CompoundCommand();
if (NonregViewsRepository.Combo.combo == event.getAffectedEditor())
command.append(
SetCommand.create(
liveEditingDomain,
talk,
NonregPackage.eINSTANCE.getTalk_Presenter(),
event.getNewValue()));
if (NonregViewsRepository.Combo.comboRO == event.getAffectedEditor())
command.append(
SetCommand.create(
liveEditingDomain,
talk,
NonregPackage.eINSTANCE.getTalk_Presenter(),
event.getNewValue()));
if (!command.isEmpty() && !command.canExecute()) {
EEFRuntimePlugin.getDefault().logError("Cannot perform model change command.", null);
} else {
liveEditingDomain.getCommandStack().execute(command);
}
}
if (valueDiagnostic.getSeverity() != Diagnostic.OK
&& valueDiagnostic instanceof BasicDiagnostic)
super.firePropertiesChanged(new PropertiesValidationEditionEvent(event, valueDiagnostic));
else {
Diagnostic validate = validate();
super.firePropertiesChanged(new PropertiesValidationEditionEvent(event, validate));
}
super.firePropertiesChanged(event);
}
}
@Override
public void saveChanges(IProgressMonitor monitor) throws CoreException {
super.saveChanges(monitor);
for (int i = 0; i < oldExpressions.size(); i++) {
if (!oldExpressions.get(i).getContent().equals(newExpressions.get(i).getContent())) {
cc.append(
SetCommand.create(
domain,
oldExpressions.get(i),
ExpressionPackage.Literals.EXPRESSION__CONTENT,
newExpressions.get(i).getContent()));
if (ExpressionConstants.CONDITION_TYPE.equals(oldExpressions.get(i).getType())) {
cc.append(
SetCommand.create(
domain,
oldExpressions.get(i),
ExpressionPackage.Literals.EXPRESSION__NAME,
newExpressions.get(i).getContent()));
}
}
}
status = true;
}
public void synchronize(FormCollection fc) throws Exception {
InternalModification.dontMoveToDisabled();
removeInvalide(fc);
EList<FormContainer> forms = fc.getForms();
for (FormContainer formContainer : forms) {
synchronizeFormContainer(formContainer);
}
// add Missing FormClass (new Class in dt model)
if (addNewFormClass) {
// get All Class
Collection<AbstractClass> missing = getAllClassesFromReferedModels(fc);
for (AbstractClass abstractClass : missing) {
if (!(abstractClass instanceof Clazz) ^ !((Clazz) abstractClass).isAbstract()) {
FormContainer formContainer = null;
if (!CommonServices.isNativeModel(abstractClass) || includeAlfrescoNativeClass) {
if (fc instanceof ClassFormCollection) {
formContainer = FormFactory.eINSTANCE.createFormClass();
setFormContainer(abstractClass, formContainer);
formContainer.setId(abstractClass.getName());
formContainer.setLabel(abstractClass.getLabel());
} else if (fc instanceof SearchFormCollection) {
formContainer = FormFactory.eINSTANCE.createFormSearch();
setFormContainer(abstractClass, formContainer);
SearchInitialization.initializeFormProperties((FormSearch) formContainer);
} else if (fc instanceof WorkflowFormCollection) {
formContainer = FormFactory.eINSTANCE.createFormWorkflow();
}
if (headless) {
fc.getForms().add(formContainer);
} else {
cc.append(
AddCommand.create(
domain, fc, FormPackage.eINSTANCE.getFormCollection_Forms(), formContainer));
}
if (formContainer instanceof ClassReference) {
synchronizeFormContainer(formContainer);
}
}
}
}
}
InternalModification.moveToDisabled();
}
/**
* Forces this list to commit all the pending commands. Only one composite command will be
* executed, and can be undone in a single operation.
*
* @see org.eclipse.papyrus.infra.widgets.editors.ICommitListener#commit(AbstractEditor)
*/
public void commit(AbstractEditor editor) {
if (commands.isEmpty()) {
return;
}
CompoundCommand compoundCommand =
new CompoundCommand() {
@Override
public void execute() {
super.execute();
refreshCacheList();
}
@Override
public void undo() {
super.undo();
refreshCacheList();
}
@Override
public void redo() {
super.redo();
refreshCacheList();
}
@Override
protected boolean prepare() {
if (commandList.isEmpty()) {
return false;
} else {
// We only test the first command, as the following ones might depend
// on the first command's execution. StrictCompoundCommands don't seem
// to be compatible with emf transaction (execute() is called by
// canExecute(), before the transaction is started)
return commandList.get(0).canExecute();
}
}
};
for (Command cmd : commands) {
compoundCommand.append(cmd);
}
editingDomain.getCommandStack().execute(compoundCommand);
commands.clear();
}
protected void addChild(FormGroup fw, FormElement f) {
if (headless) {
fw.getChildren().add(f);
} else {
Command create =
AddCommand.create(domain, fw, FormPackage.eINSTANCE.getFormGroup_Children(), f);
boolean canExecute = create.canExecute();
System.out.println(
"SynchronizeWorkflowFormWithClass.addChild() canExecute :"
+ fw.getId()
+ "->"
+ f
+ canExecute);
cc.append(create);
}
}
/**
* Create the expected model from the input model
*
* @throws InputModelInvalidException error during expected model initialization
* @throws IOException error during expected model serialization
*/
protected void initializeRemoveExpectedModelForLinkEndCreationDataValue()
throws InputModelInvalidException, IOException {
// Create the expected model content by applying the attempted command on a copy of the input
// model content
createExpectedModel();
EObject linkEndCreationData =
EEFTestsModelsUtils.getFirstInstanceOf(expectedModel, linkEndCreationDataMetaClass);
if (linkEndCreationData == null)
throw new InputModelInvalidException(linkEndCreationDataMetaClass.getName());
CompoundCommand cc = new CompoundCommand();
allInstancesOf = EEFTestsModelsUtils.getAllInstancesOf(expectedModel, inputPinMetaClass);
cc.append(
SetCommand.create(
editingDomain, linkEndCreationData, UMLPackage.eINSTANCE.getLinkEndData_Value(), null));
editingDomain.getCommandStack().execute(cc);
expectedModel.save(Collections.EMPTY_MAP);
}
/**
* Persists components. Stores EventBComponents as an extension in a machine.
*
* @param document
*/
private void doSaveComponents(IDocument document) {
ComponentDiagram diagram =
(ComponentDiagram) ((IDiagramDocument) document).getDiagram().getElement();
final TransactionalEditingDomain domain = ((IDiagramDocument) document).getEditingDomain();
CompoundCommand compoundCmd = new CompoundCommand();
for (final Component comp : diagram.getComponents()) {
if (comp instanceof EventBComponent && ((EventBComponent) comp).getMachine() != null) {
// adds command to extend Event-B machine with component config
// NOTE: replaces existing extension of the same id
compoundCmd.append(
new RecordingCommand(domain) {
@Override
protected void doExecute() {
EventBComponent compCopy = (EventBComponent) EcoreUtil.copy(comp);
try {
Resource resource =
domain.getResourceSet().getResource(compCopy.getMachine().getURI(), true);
if (resource != null && resource.isLoaded()) {
Machine machine = (Machine) resource.getContents().get(0);
// remove any existing extensions of the same id (EventB component)
Iterator<AbstractExtension> it = machine.getExtensions().iterator();
while (it.hasNext()) {
if (ComponentsPackage.EVENTB_COMPONENT_EXTENSION_ID.equals(
it.next().getExtensionId())) {
it.remove();
}
}
// compCopy.setReference(ComponentsPackage.EVENTB_COMPONENT_EXTENSION_ID
// + "." + EcoreUtil.generateUUID());
machine.getExtensions().add(compCopy);
resource.save(Collections.EMPTY_MAP);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}
domain.getCommandStack().execute(compoundCmd);
}
private void runRevealCommand(
final RootEditPart root, final DDiagramEditor editor, final DDiagramElement vpe) {
final Object adapter = editor.getAdapter(IDiagramCommandFactoryProvider.class);
final IDiagramCommandFactoryProvider cmdFactoryProvider =
(IDiagramCommandFactoryProvider) adapter;
final TransactionalEditingDomain transactionalEditingDomain =
TransactionUtil.getEditingDomain(editor.getEditingDomain().getResourceSet());
final IDiagramCommandFactory emfCommandFactory =
cmdFactoryProvider.getCommandFactory(transactionalEditingDomain);
final Command cmd = emfCommandFactory.buildRevealCommand(vpe);
final TransactionalEditingDomain domain = TransactionUtil.getEditingDomain(vpe);
CompoundCommand allInOne = new CompoundCommand(cmd.getLabel());
allInOne.append(cmd);
domain.getCommandStack().execute(allInOne);
}
/** Clear links */
@SuppressWarnings({"rawtypes", "unchecked"})
private static void clearLinks() {
Collection values =
getDiagramEditor().getDiagramGraphicalViewer().getEditPartRegistry().values();
Iterator iterator = values.iterator();
CompoundCommand ccModel = new CompoundCommand();
org.eclipse.gef.commands.CompoundCommand ccView =
new org.eclipse.gef.commands.CompoundCommand();
while (iterator.hasNext()) {
Object editPart = iterator.next();
if (editPart instanceof EsbLinkEditPart) {
EsbLinkEditPart linkEditPart = (EsbLinkEditPart) editPart;
/*
* We shouldn't remove EsbLinkEditParts if the target of the link is a AbstractEndpointInputConnectorEditPart.
* Because these kind of links will not be get regenerated again according to the current implementation.
*/
if (linkEditPart.getTarget() instanceof AbstractEndpointInputConnectorEditPart) {
continue;
}
Collection linkCollection = new ArrayList();
linkCollection.add(((ConnectorImpl) linkEditPart.getModel()).getElement());
org.eclipse.emf.edit.command.DeleteCommand modelDeleteCommand =
new org.eclipse.emf.edit.command.DeleteCommand(
getDiagramEditor().getEditingDomain(), linkCollection);
if (modelDeleteCommand.canExecute()) {
ccModel.append(modelDeleteCommand);
}
DeleteCommand viewDeleteCommand = new DeleteCommand(linkEditPart.getNotationView());
if (viewDeleteCommand.canExecute()) {
ccView.add(new ICommandProxy(viewDeleteCommand));
}
}
}
if (ccModel.canExecute()) {
getDiagramEditor().getEditingDomain().getCommandStack().execute(ccModel);
}
if (ccView.canExecute()) {
getDiagramEditor().getDiagramEditDomain().getDiagramCommandStack().execute(ccView);
}
}
void removeInvalide(EObject o) {
CompoundCommand removeCommands = new CompoundCommand();
List<EObject> validationErrors = EcoreHelper.getValidationErrors(o);
for (EObject eObject : validationErrors) {
if (eObject instanceof FormElement) {
System.out.println("SynchronizeWithClass.removeInvalide() remove :" + eObject);
if (headless) {
EList<?> children = null;
EObject eContainer = eObject.eContainer();
System.out.println("SynchronizeWithClass.removeInvalide() eContainer :" + eContainer);
if (eContainer != null) {
if (eContainer instanceof FormGroup) {
FormGroup fg = (FormGroup) eContainer;
if (fg.getChildren().contains(eObject)) {
children = fg.getChildren();
} else if (fg.getDisabled().contains(eObject)) {
children = fg.getDisabled();
}
} else if (eContainer instanceof FormCollection) {
children = ((FormCollection) eContainer).getForms();
}
boolean remove = children.remove(eObject);
System.out.println("SynchronizeWithClass.removeInvalide() removed? " + remove);
} else {
System.out.println("SynchronizeWithClass.removeInvalide() allready removed !");
}
} else {
Command delCmd = RemoveCommand.create(domain, eObject);
removeCommands.append(delCmd);
}
}
}
if (!headless) {
domain.getCommandStack().execute(removeCommands);
}
}
/**
* {@inheritDoc}
*
* @see org.eclipse.sirius.tools.internal.command.builders.CommandBuilder#buildCommand()
*/
@Override
public Command buildCommand() {
Command result = UnexecutableCommand.INSTANCE;
if (permissionAuthority.canEditInstance(reconnectionSource)
&& permissionAuthority.canEditInstance(reconnectionTarget)
&& permissionAuthority.canEditInstance(edge)
// Layouting mode on diagrams
// if the ddiagram is in LayoutingMode, we do not allow reconnection
&& !isInLayoutingModeDiagram(edge)) {
final EObject semanticSource =
SiriusUtil.getNearestDecorateSemanticElement(reconnectionSource).getTarget();
final EObject semanticTarget =
SiriusUtil.getNearestDecorateSemanticElement(reconnectionTarget).getTarget();
final Map<AbstractVariable, Object> variables = new HashMap<AbstractVariable, Object>();
variables.put(tool.getElement(), edge.getTarget());
variables.put(tool.getSource(), semanticSource);
variables.put(tool.getSourceView(), reconnectionSource);
variables.put(tool.getTarget(), semanticTarget);
variables.put(tool.getTargetView(), reconnectionTarget);
variables.put(tool.getEdgeView(), edge);
// we create an hidden variable that will be used to
// correct reconnection issues
ICommandTask createOtherEndVariableTask = getOtherEndVariableCreationTask(variables);
final DCommand cmd = createEnclosingCommand();
cmd.getTasks().add(createOtherEndVariableTask);
cmd.getTasks()
.add(
new InitInterpreterVariablesTask(
variables, InterpreterUtil.getInterpreter(reconnectionSource), uiCallback));
Option<DDiagram> parentDiagram = getDDiagram();
if (tool.getInitialOperation() != null
&& tool.getInitialOperation().getFirstModelOperations() != null) {
cmd.getTasks()
.add(
taskHelper.buildTaskFromModelOperation(
parentDiagram.get(),
edge.getTarget(),
tool.getInitialOperation().getFirstModelOperations()));
}
final SetObject setObject = ToolFactory.eINSTANCE.createSetObject();
final String featureName = getReconnectionKindFeatureName();
setObject.setFeatureName(featureName);
setObject.setObject(reconnectionTarget);
Option<DRepresentation> representation = new EObjectQuery(edge).getRepresentation();
final CommandContext edgeContext = new CommandContext(edge, representation.get());
cmd.getTasks()
.add(
new SetValueTask(
edgeContext,
this.modelAccessor,
setObject,
new EObjectQuery(edge).getSession().getInterpreter()));
final EdgeMapping newEdgeMapping = getEdgeMappingReconnector();
addRefreshTask(edge, cmd, tool);
final CompoundCommand cc = new CompoundCommand();
if (newEdgeMapping != null && !newEdgeMapping.equals(edge.getActualMapping())) {
cc.append(new SetEdgeActualMappingCommand(editingDomain, edge, newEdgeMapping));
}
if (reconnectionSource.equals(oldSource)
&& (newEdgeMapping != null && !newEdgeMapping.isUseDomainElement()
|| isEdgeActualMappingUsingDomainElement())) {
cc.append(
new ReconnectSourceNodeCommand(
editingDomain, edge, reconnectionTarget, semanticTarget));
}
cc.append(cmd);
result = cc;
}
return result;
}