public static IList <EvolutionChange> Detect(Version v1, Version v2, PSMClassUnion classUnion)
{
List <EvolutionChange> result = new List <EvolutionChange>();
PSMClassUnion classUnionOldVersion =
(PSMClassUnion)classUnion.GetInVersion(v1);
foreach (PSMAssociationChild associationChild in classUnionOldVersion.Components)
{
/* must not exist in new version, testing whether it disappeard from components of the new
* version is not enough. It could have been moved, but not deleted.
*/
if (associationChild.GetInVersion(v2) == null)
{
ClassUnionComponentRemovedChange change =
new ClassUnionComponentRemovedChange(classUnion)
{
RemovedComponent = associationChild,
OldVersion = v1,
NewVersion = v2
};
result.Add(change);
}
}
return(result);
}
private void TranslateClassUnion(PSMClassUnion classUnion, DataGeneratorContext context)
{
PSMAssociationChild selectedPath = classUnion.Components.ChooseOneRandomly();
TranslateComments(classUnion, context);
TranslateAssociationChild(selectedPath, context);
}
private void ConvertPSMAssociation(PSMAssociation psmAssociation, PSMAssociationViewHelper psmAssociationViewHelper)
{
EvoX.Model.PSM.PSMAssociation evoxPSMAssociation;
if (!TranslatedAlready(psmAssociation, out evoxPSMAssociation))
{
PSMAssociationMember parent = (PSMAssociationMember)ElementRef(psmAssociation.Parent);
PSMAssociationMember child = (PSMAssociationMember)ElementRef(psmAssociation.Child);
evoxPSMAssociation = new EvoX.Model.PSM.PSMAssociation(evoxProject, parent, child, psmSchema);
associationOrder[evoxPSMAssociation] = psmAssociation.ComponentIndex();
translatedElements[psmAssociation] = evoxPSMAssociation;
}
PSMClass childPSMClass = psmAssociation.Child as PSMClass;
if (childPSMClass != null && childPSMClass.HasElementLabel)
{
evoxPSMAssociation.Name = childPSMClass.ElementName;
}
else
{
evoxPSMAssociation.Name = null;
}
PSMClassUnion psmClassUnion = psmAssociation.Child as PSMClassUnion;
if (psmClassUnion != null)
{
evoxPSMAssociation.Name = null;
}
evoxPSMAssociation.Lower = ConvertToUint(psmAssociation.Lower);
evoxPSMAssociation.Upper = ConvertToUnlimitedInt(psmAssociation.Upper);
}
/// <summary>
/// Checks if the subtree starting in the given class union contains
/// the given item.
/// </summary>
/// <param name="root">References the class union that is the root of searched subtree</param>
/// <param name="item">References the item being searched</param>
/// <returns>True if the item is present, false otherwise</returns>
private static bool ClassUnionContains(PSMClassUnion root, object item)
{
if (root == item)
{
return(true);
}
foreach (PSMAssociationChild child in root.Components)
{
if (child == item)
{
return(true);
}
if (child is PSMClass)
{
if (SubtreeContains(child as PSMClass, item))
{
return(true);
}
}
else
if (ClassUnionContains(child as PSMClassUnion, item))
{
return(true);
}
}
return(false);
}
public static IList <EvolutionChange> Detect(Version v1, Version v2, PSMClassUnion classUnion)
{
List <EvolutionChange> result = new List <EvolutionChange>();
{
foreach (PSMAssociationChild associationChild in classUnion.Components)
{
/* must not exist in old version, testing whether it is not among components of the old
* version is not enough. It could have been moved, but not created as new.
*/
if (associationChild.GetInVersion(v1) == null)
{
ClassUnionComponentAddedChange change =
new ClassUnionComponentAddedChange(classUnion)
{
AddedComponent = associationChild,
OldVersion = v1,
NewVersion = v2
};
result.Add(change);
}
}
}
return(result);
}
public void MoveToClassUnion(PSMClassUnion classUnion)
{
MoveClassToClassUnionMacroCommand c = (MoveClassToClassUnionMacroCommand)MoveClassToClassUnionMacroCommandFactory.Factory().Create(DiagramController);
c.InitializeCommand(new[] { PSMAssociation }, classUnion);
if (c.Commands.Count > 0)
{
c.Execute();
}
}
/// <summary>
/// Sets this command for use.
/// </summary>
/// <param name="sourceUnion">Reference to the source class union</param>
/// <param name="targetUnion">Reference to the target class union holder</param>
public void Set(PSMClassUnion sourceUnion, Helpers.ElementHolder <PSMClassUnion> targetUnion)
{
if (SourceUnion == null)
{
SourceUnion = new Helpers.ElementHolder <PSMClassUnion>();
}
SourceUnion.Element = sourceUnion;
TargetUnion = targetUnion;
}
private void ConvertPSMClassUnion(PSMClassUnion psmClassUnion, PSMElementViewHelper psmElementViewHelper)
{
PSMContentModel contentModel;
if (!TranslatedAlready(psmClassUnion, out contentModel))
{
contentModel = new PSMContentModel(evoxProject, psmSchema, false);
translatedElements[psmClassUnion] = contentModel;
}
contentModel.Type = PSMContentModelType.Choice;
}
private void TranslateClassUnion(PSMClassUnion classUnion, ChangesDetectorContext context)
{
context.ScopeStack.Push(EChangeScope.ClassUnion);
context.CurrentPSMElement = classUnion;
ChangesLookupManager.DetectLocalChanges(context);
foreach (PSMAssociationChild psmAssociationChild in classUnion.Components)
{
TranslateAssociationChild(psmAssociationChild, context);
}
EChangeScope pcu = context.ScopeStack.Pop();
Debug.Assert(pcu == EChangeScope.ClassUnion);
}
private void AddClassUnionDependencies(Element root, PSMClassUnion union)
{
foreach (PSMAssociationChild psmAssociationChild in union.Components)
{
AddDependency(root, psmAssociationChild);
elementsToDo.Enqueue(new KeyValuePair <Element, Element>(root, psmAssociationChild));
}
if (union.ParentUnion != null)
{
AddDependency(root, union.ParentUnion);
AddClassUnionDependencies(root, union.ParentUnion);
}
if (union.ParentAssociation != null)
{
AddDependency(root, union.ParentAssociation);
}
}
public static IList <EvolutionChange> Detect(Version v1, Version v2, PSMClassUnion classUnion)
{
List <EvolutionChange> result = new List <EvolutionChange>();
PSMClassUnion oldVersion = (PSMClassUnion)classUnion.GetInVersion(v1);
PSMClassUnion newVersion = (PSMClassUnion)classUnion.GetInVersion(v2);
if (newVersion != null && oldVersion != null &&
oldVersion.ParentAssociation != newVersion.ParentAssociation.GetInVersion(v1))
{
result.Add(new ClassUnionMovedChange(classUnion)
{
OldVersion = v1, NewVersion = v2
});
}
return(result);
}
internal override void CommandOperation()
{
if (CreatedUnion == null)
{
CreatedUnion = new Helpers.ElementHolder <PSMClassUnion>();
}
PSMClassUnion union = Parent.CreateClassUnion();
if (Parent is PSMClassUnion)
{
}
CreatedUnion.Element = union;
Diagram.AddModelElement(union, ViewHelper = new PSMElementViewHelper(Diagram));
AssociatedElements.Add(union);
}
public void Set(PSMClassUnion classUnion, IEnumerable <PSMAssociation> associations)
{
AddedAssociations.AddRange(associations);
ClassUnion = classUnion;
ElementHolder <PSMAssociation> leadingAssociationHolder = new ElementHolder <PSMAssociation>(ClassUnion.ParentAssociation);
ElementHolder <PSMClassUnion> unionHolder = new ElementHolder <PSMClassUnion>(ClassUnion);
CopyNestingJoinsCommand c3 = CopyNestingJoinsCommandFactory.Factory().Create(Controller.ModelController) as CopyNestingJoinsCommand;
c3.Set(leadingAssociationHolder, AddedAssociations);
this.Commands.Add(c3);
/*GetClassUnionContentCommand c4 = GetClassUnionContentCommandFactory.Factory().Create(Controller.ModelController) as GetClassUnionContentCommand;
* c4.Set(joinedAssociations, CreatedUnion);
* Commands.Add(c4);*/
DeleteFromPSMDiagramCommand delCommand = DeleteFromPSMDiagramCommandFactory.Factory().Create(Controller) as DeleteFromPSMDiagramCommand;
delCommand.DeletedElements = new List <Element>(AddedAssociations.Cast <Element>());
delCommand.CheckOrdering = false;
Commands.Add(delCommand);
PutClassesToUnionCommand c4 = PutClassesToUnionCommandFactory.Factory().Create(Controller.ModelController) as PutClassesToUnionCommand;
c4.Set(AddedAssociations, unionHolder);
Commands.Add(c4);
foreach (PSMAssociation assoc in AddedAssociations)
{
PSMClassUnion union = assoc.Child as PSMClassUnion;
if (union != null)
{
MoveClassUnionContentCommand moveCommand = MoveClassUnionContentCommandFactory.Factory().Create(Controller) as MoveClassUnionContentCommand;
moveCommand.Set(union, unionHolder);
Commands.Add(moveCommand);
DeleteFromPSMDiagramCommand delUnion = DeleteFromPSMDiagramCommandFactory.Factory().Create(Controller) as DeleteFromPSMDiagramCommand;
delUnion.DeletedElements = new List <Element>();
delUnion.DeletedElements.Add(union);
Commands.Add(delUnion);
}
}
}
public string GetUnionTemplate(PSMClassUnion classUnion, bool forceCallable)
{
Dictionary <PSMElement, string> templateCollection = forceCallable ? forceCallableUnionTemplates : unionTemplates;
if (templateCollection.ContainsKey(classUnion))
{
return(templateCollection[classUnion]);
}
else
{
string name = suggestNameFromXPath(classUnion) + UNION_SUFFIX;
if (forceCallable)
{
name += FORCE_CALLABLE_SUFFIX;
}
templateCollection[classUnion] = name;
return(name);
}
}
public static IEnumerable <Element> GetChildrenOfElement(Element element)
{
PSMSuperordinateComponent superordinateComponent = element as PSMSuperordinateComponent;
if (superordinateComponent != null && superordinateComponent.Components.Count > 0)
{
return(superordinateComponent.Components);
}
PSMClassUnion union = element as PSMClassUnion;
if (union != null && union.Components.Count > 0)
{
return(union.Components);
}
PSMAssociation association = element as PSMAssociation;
if (association != null)
{
return(new Element[] { association.Child });
}
PSMClass psmClass = element as PSMClass;
if (psmClass != null)
{
if (psmClass.Specifications.Count > 0)
{
return(psmClass.Specifications);
}
}
Generalization generalization = element as Generalization;
if (generalization != null)
{
return(new Element[] { generalization.Specific });
}
return(new Element[0]);
}
public static Element GetFirstChildOfElement(Element element)
{
PSMSuperordinateComponent superordinateComponent = element as PSMSuperordinateComponent;
if (superordinateComponent != null && superordinateComponent.Components.Count > 0)
{
return(superordinateComponent.Components[0]);
}
PSMClassUnion union = element as PSMClassUnion;
if (union != null && union.Components.Count > 0)
{
return(union.Components[0]);
}
PSMAssociation association = element as PSMAssociation;
if (association != null)
{
return(association.Child);
}
PSMClass psmClass = element as PSMClass;
if (psmClass != null)
{
if (psmClass.Specifications.Count > 0)
{
return(psmClass.Specifications.First());
}
}
Generalization generalization = element as Generalization;
if (generalization != null)
{
return(generalization.Specific);
}
return(null);
}
public IEnumerable <PSMElement> GetChildNodes()
{
{
PSMSuperordinateComponent cs = CurrentNode as PSMSuperordinateComponent;
if (cs != null)
{
//return cs.Components.Select(c => (c is PSMAssociation) ? (PSMElement)((PSMAssociation)c).Child : (PSMElement)c);
return(cs.Components.Cast <PSMElement>());
}
}
{
PSMClassUnion cu = CurrentNode as PSMClassUnion;
if (cu != null)
{
return(cu.Components.Cast <PSMElement>());
}
}
{
PSMAssociation a = CurrentNode as PSMAssociation;
if (a != null)
{
return(new PSMElement[] { a.Child });
}
}
{
PSMAttributeContainer ac = CurrentNode as PSMAttributeContainer;
if (ac != null)
{
return(ac.PSMAttributes.Cast <PSMElement>());
}
}
return(new PSMElement[0]);
}
public PSM_ClassUnionController(PSMClassUnion classUnion, DiagramController diagramController) :
base(classUnion, diagramController)
{
}
public PSMElement GetParent()
{
PSMElement parent = null;
{
PSMClass cl = CurrentNode as PSMClass;
if (cl != null)
{
if (cl.ParentAssociation != null)
{
parent = cl.ParentAssociation.Parent;
return(parent);
}
if (cl.ParentUnion != null)
{
parent = cl.ParentUnion;
return(parent);
}
if (Diagram.Roots.Contains(cl))
{
return(null);
}
if (cl.Generalizations.Count > 0)
{
PSMTreeIterator tmp = new PSMTreeIterator((PSMClass)cl.Generalizations[0].General);
return(tmp.GetParent());
}
}
}
{
PSMSubordinateComponent cs = CurrentNode as PSMSubordinateComponent;
if (cs != null)
{
parent = cs.Parent;
return(parent);
}
}
{
PSMClassUnion cu = CurrentNode as PSMClassUnion;
if (cu != null)
{
parent = cu.ParentAssociation.Parent;
return(parent);
}
}
{
PSMAttribute ca = CurrentNode as PSMAttribute;
if (ca != null)
{
if (ca.AttributeContainer != null)
{
return(ca.AttributeContainer);
}
else
{
return(ca.Class);
}
}
}
return(parent);
}
/// <summary>
/// Adds attributes under a node into <param name="attributeList"/> (when called for a superordinate component, attributes
/// from all subordinate PSM classes without element labels are included in the result too)
/// </summary>
/// <param name="node">node where to search for attributes</param>
/// <param name="firstCall">false value indicates recursive call</param>
/// <param name="attributeList">list in which attributes are added</param>
private static void GetAttributesUnderNode(PSMElement node, bool firstCall, ref List <NodeAttributeWrapper> attributeList)
{
if (!firstCall && node is PSMClass &&
!((PSMClass)node).HasElementLabel &&
((PSMClass)node).IsStructuralRepresentative)
{
PSMClass representedClass = ((PSMClass)node).RepresentedPSMClass;
attributeList.Add(new StructuralRepresentativeAttributes((PSMClass)node, representedClass));
}
{
PSMClass psmClass = node as PSMClass;
if (psmClass != null)
{
if (firstCall || (!psmClass.HasElementLabel))
{
foreach (PSMAttribute psmAttribute in psmClass.PSMAttributes)
{
attributeList.Add(new SimpleNodeAttribute(psmAttribute));
}
}
else
{
return;
}
}
}
if (node is PSMClass || (node is PSMContentContainer && firstCall))
{
foreach (PSMSubordinateComponent component in ((PSMSuperordinateComponent)node).Components)
{
GetAttributesUnderNode(component, false, ref attributeList);
}
}
if (node is PSMClassUnion)
{
//throw new NotImplementedException("Can't handle unions yet");
}
if (node is PSMContentChoice)
{
PSMContentChoice contentChoice = (PSMContentChoice)node;
PSMTreeIterator it = new PSMTreeIterator(contentChoice);
List <ChoiceAttributeOption> options = new List <ChoiceAttributeOption>();
foreach (PSMElement childNode in it.GetChildNodes())
{
List <NodeAttributeWrapper> choices = new List <NodeAttributeWrapper>();
GetAttributesUnderNode(childNode, false, ref choices);
if (choices.Count > 0)
{
ChoiceAttributeOption option = new ChoiceAttributeOption();
option.Items = choices;
options.Add(option);
}
}
if (options.Count > 0)
{
ChoiceAttributes choiceAttributes = new ChoiceAttributes(contentChoice, options);
attributeList.Add(choiceAttributes);
}
}
else if (node is PSMClassUnion)
{
PSMClassUnion classUnion = (PSMClassUnion)node;
PSMTreeIterator it = new PSMTreeIterator(classUnion);
List <ChoiceAttributeOption> options = new List <ChoiceAttributeOption>();
foreach (PSMElement childNode in it.GetChildNodes())
{
List <NodeAttributeWrapper> choices = new List <NodeAttributeWrapper>();
GetAttributesUnderNode(childNode, false, ref choices);
if (choices.Count > 0)
{
ChoiceAttributeOption option = new ChoiceAttributeOption();
option.Items = choices;
options.Add(option);
}
}
if (options.Count > 0)
{
UnionAttributes choiceAttributes = new UnionAttributes(classUnion, options);
attributeList.Add(choiceAttributes);
}
}
if (node is PSMAssociation)
{
GetAttributesUnderNode(((PSMAssociation)node).Child, false, ref attributeList);
}
return;
}
public static void CheckDiagram(PSMDiagram diagram, out List <string> errors, out List <string> warnings)
{
errors = new List <string>();
warnings = new List <string>();
#region diagram has roots
if (diagram.Roots.Count == 0)
{
errors.Add(string.Format("Diagram has no roots. "));
}
#endregion
#region diagram has global element
if (diagram.Roots.Where(r => (r is PSMClass) && ((PSMClass)r).HasElementLabel).Count() == 0)
{
bool found = false;
foreach (PSMSuperordinateComponent superordinate in diagram.Roots)
{
if (superordinate is PSMContentContainer)
{
found = true;
break;
}
else
{
PSMClass c = superordinate as PSMClass;
if (c != null)
{
if (GetSpecificiationsRecursive(c).Any(s => s.HasElementLabel))
{
found = true;
}
}
}
}
if (!found)
{
warnings.Add(string.Format("Diagram has no root with an element label, no global element is declared. "));
}
}
#endregion
#region not zero or only one component in choice
foreach (Element element in diagram.DiagramElements.Keys)
{
{
PSMContentChoice cc = element as PSMContentChoice;
if (cc != null && cc.Components.Count == 1)
{
warnings.Add(string.Format("Only one component in {0}. ", cc));
}
if (cc != null && cc.Components.Count == 0)
{
warnings.Add(string.Format("Zero components in {0}. ", cc));
}
}
{
PSMClassUnion cu = element as PSMClassUnion;
if (cu != null && cu.Components.Count == 1)
{
warnings.Add(string.Format("Only one component in {0}. ", cu));
}
if (cu != null && cu.Components.Count == 0)
{
warnings.Add(string.Format("Zero components in {0}. ", cu));
}
}
}
#endregion
}
public bool ForceCallableUnionTemplateExists(PSMClassUnion classUnion)
{
return(forceCallableUnionTemplates.ContainsKey(classUnion));
}
/// <summary>
/// Draws all children of given root element and counts width of its subtree.
/// </summary>
/// <param name="diagram">Diagram to be layouted</param>
/// <param name="root">Root element of layouted subtree</param>
/// <param name="top">Location of the upper border of the root's children</param>
/// <param name="left">Location of the left border of the entire subtree</param>
/// <returns>Width of the subtree (root not included)</returns>
private static double DrawSubtree(XCaseCanvas diagram, NamedElement root, double top, double left)
{
double right = left;
if (root is PSMSuperordinateComponent)
{
PSMSuperordinateComponent aClass = root as PSMSuperordinateComponent;
NamedElement child = null;
if (aClass.Components.Count > 0)
{
foreach (PSMSubordinateComponent component in aClass.Components)
{
if (component is PSMAssociation)
{
child = (component as PSMAssociation).Child;
}
else
{
if (component is PSMAttributeContainer)
{
child = component as PSMAttributeContainer;
}
else
{
if (component is PSMContentChoice || component is PSMContentContainer)
{
child = component as PSMSuperordinateComponent;
}
}
}
if (child != null)
{
right += DrawTree(diagram, child, top, right) + horizontalSpace;
}
child = null;
}
}
if (aClass is PSMClass && (aClass as PSMClass).Specifications.Count > 0)
{
foreach (Generalization specification in (aClass as PSMClass).Specifications)
{
right += DrawTree(diagram, specification.Specific, top, right) + horizontalSpace;
}
}
if (right != left)
{
right -= horizontalSpace;
}
}
else
{
if (root is PSMClassUnion)
{
PSMClassUnion classUnion = root as PSMClassUnion;
if (classUnion.Components.Count > 0)
{
foreach (PSMAssociationChild component in classUnion.Components)
{
right += DrawTree(diagram, component, top, right) + horizontalSpace;
}
right = right - horizontalSpace;
}
}
}
return(right - left);
}
public void InitializeCommand(IEnumerable <PSMAssociation> associations, PSMClassUnion container)
{
if (associations.Count() == 0)
{
return;
}
if (container == null)
{
PSMSuperordinateComponent parentClass;
if (!PSMTree.AreComponentsOfCommonParent(associations))
{
return;
}
parentClass = associations.First().Parent;
List <PSMClassUnion> candidates = new List <PSMClassUnion>();
FindCURecursive(parentClass, candidates);
bool createNew = false;
SelectItemsDialog d = new SelectItemsDialog();
d.Title = "Select class union";
d.ShortMessage = "Select class union";
d.LongMessage = String.Empty;
d.UseRadioButtons = true;
ArrayList _c = new ArrayList(candidates.ToList());
const string _newAC = "<< new class union >>";
_c.Add(_newAC);
d.SetItems(_c);
if (d.ShowDialog() == true)
{
if (d.selectedObjects.FirstOrDefault().Equals(_newAC))
{
createNew = true;
}
else
{
ClassUnion = d.selectedObjects.FirstOrDefault() as PSMClassUnion;
}
}
if (createNew)
{
JoinAssociationsToClassUnionMacroCommand createCUcommand =
(JoinAssociationsToClassUnionMacroCommand)
JoinAssociationsToClassUnionMacroCommandFactory.Factory().Create(Controller);
createCUcommand.Set(parentClass, associations);
Commands.Add(createCUcommand);
return;
}
}
else
{
ClassUnion = container;
}
if (ClassUnion != null)
{
MoveClassToExistingClassUnionMacroCommand moveCommand =
(MoveClassToExistingClassUnionMacroCommand)
MoveClassToExistingClassUnionMacroCommandFactory.Factory().Create(Controller);
moveCommand.Set(ClassUnion, associations);
Commands.Add(moveCommand);
}
}
/// <summary>
/// Sets this command for use.
/// </summary>
/// <param name="parent">Reference to the PSM component that is the root of joined associations</param>
/// <param name="joinedAssociations">List of associations to be joined to one class union</param>
public void Set(PSMSuperordinateComponent parent, IEnumerable <PSMAssociation> joinedAssociations)
{
JoinedAssociations = new List <PSMAssociation>(joinedAssociations);
PSMSubordinateComponent first = parent.Components.First(assoc => JoinedAssociations.Contains(assoc as PSMAssociation));
int?index = parent.Components.IndexOf(first);
if (ParentHolder == null)
{
ParentHolder = new Helpers.ElementHolder <PSMSuperordinateComponent>();
}
ParentHolder.Element = parent;
if (CreatedUnion == null)
{
CreatedUnion = new Helpers.ElementHolder <PSMClassUnion>();
}
if (CreatedAssocChild == null)
{
CreatedAssocChild = new Helpers.ElementHolder <PSMAssociationChild>();
}
if (CreatedAssociationHolder == null)
{
CreatedAssociationHolder = new Helpers.ElementHolder <PSMAssociation>();
}
NewPSMClassUnionCommand c1 = NewPSMClassUnionCommandFactory.Factory().Create(Controller) as NewPSMClassUnionCommand;
c1.CreatedUnion = CreatedUnion;
c1.Parent = parent;
Commands.Add(c1);
Helpers.HolderConvertorCommand <PSMClassUnion, PSMAssociationChild> cc =
new Commands.Helpers.HolderConvertorCommand <PSMClassUnion, PSMAssociationChild>(CreatedUnion,
CreatedAssocChild);
Commands.Add(cc);
NewPSMAssociationCommand newAssocCommand = NewPSMAssociationCommandFactory.Factory().Create(Controller.ModelController) as NewPSMAssociationCommand;
newAssocCommand.Set(ParentHolder, CreatedAssocChild, CreatedAssociationHolder, index);
Commands.Add(newAssocCommand);
CopyNestingJoinsCommand copyNJcommand = CopyNestingJoinsCommandFactory.Factory().Create(Controller.ModelController) as CopyNestingJoinsCommand;
copyNJcommand.Set(CreatedAssociationHolder, JoinedAssociations);
Commands.Add(copyNJcommand);
/*GetClassUnionContentCommand c4 = GetClassUnionContentCommandFactory.Factory().Create(Controller.ModelController) as GetClassUnionContentCommand;
* c4.Set(joinedAssociations, CreatedUnion);
* Commands.Add(c4);*/
PutClassesToUnionCommand putCommand = PutClassesToUnionCommandFactory.Factory().Create(Controller.ModelController) as PutClassesToUnionCommand;
putCommand.Set(joinedAssociations, CreatedUnion);
Commands.Add(putCommand);
DeleteFromPSMDiagramCommand delCommand = DeleteFromPSMDiagramCommandFactory.Factory().Create(Controller) as DeleteFromPSMDiagramCommand;
delCommand.DeletedElements = new List <Element>(JoinedAssociations.Cast <Element>());
delCommand.CheckOrdering = false;
Commands.Add(delCommand);
foreach (PSMAssociation assoc in joinedAssociations)
{
PSMClassUnion union = assoc.Child as PSMClassUnion;
if (union != null)
{
MoveClassUnionContentCommand moveCommand = MoveClassUnionContentCommandFactory.Factory().Create(Controller) as MoveClassUnionContentCommand;
moveCommand.Set(union, CreatedUnion);
Commands.Add(moveCommand);
DeleteFromPSMDiagramCommand delUnion = DeleteFromPSMDiagramCommandFactory.Factory().Create(Controller) as DeleteFromPSMDiagramCommand;
delUnion.DeletedElements = new List <Element>();
delUnion.DeletedElements.Add(union);
Commands.Add(delUnion);
}
}
ElementToDiagramCommand <PSMAssociation, PSMAssociationViewHelper> includeAssociation = (ElementToDiagramCommand <PSMAssociation, PSMAssociationViewHelper>) ElementToDiagramCommandFactory <PSMAssociation, PSMAssociationViewHelper> .Factory().Create(Controller);
includeAssociation.IncludedElement = CreatedAssociationHolder;
Commands.Add(includeAssociation);
}
protected ClassUnionChange(PSMClassUnion classUnion)
{
Element = classUnion;
}
public ClassUnionMovedChange(PSMClassUnion classUnion)
: base(classUnion)
{
}
public ClassUnionComponentAddedChange(PSMClassUnion classUnion)
: base(classUnion)
{
}
