/// <summary>
/// Copy port to target element
/// </summary>
/// <param name="srcPort"></param>
/// <param name="trgEl"></param>
private void CopyPort(Element srcPort, Element trgEl)
{
bool isUpdate = false;
Element trgPort = null;
if (srcPort.Type != "Port")
{
return;
}
// check if port already exits
foreach (Element p in trgEl.EmbeddedElements)
{
if (p.Name == srcPort.Name && p.Stereotype == srcPort.Stereotype)
{
isUpdate = true;
trgPort = p;
break;
}
}
if (isUpdate == false)
{
string name = srcPort.Name;
string stereotype = srcPort.Stereotype;
if (isUpdate == false)
{
trgPort = (Element)trgEl.EmbeddedElements.AddNew(name, "Port");
trgEl.EmbeddedElements.Refresh();
}
trgPort.Stereotype = stereotype;
trgPort.Update();
}
}
private bool SynchronizeUmlItemTags(UML.Classes.Interfaces.Interface interfaceItem, ref string TagName, ref string TagValue, ref string TagNotes)
{
if (HasSterotype(C_ExtStereotypes.funptr, interfaceItem.stereotypes))
{
FunptrInterface funptr = new FunptrInterface(interfaceItem);
string defaultTypeSynonymsTag = interfaceItem.name;
EA.Element eaElem = (interfaceItem as UTF_EA.ElementWrapper).WrappedElement;
bool changedElement = false;
// Synchronize tagged values
for (short i = 0; i < eaElem.TaggedValues.Count; ++i)
{
EA.TaggedValue currentTag = eaElem.TaggedValues.GetAt(i) as EA.TaggedValue;
bool changedTag = false;
switch (currentTag.Name)
{
case C_ExtTags.typeSynonyms:
if (currentTag.Value != defaultTypeSynonymsTag)
{
currentTag.Value = defaultTypeSynonymsTag;
changedTag = true;
}
break;
case C_ExtTags.static_:
if ((currentTag.Value == "false") &&
!((interfaceItem.owner is UML.Classes.Kernel.Class) ||
(interfaceItem.owner is UML.Classes.Interfaces.Interface)))
{
TagValue = "true";
changedTag = true;
}
break;
}
if (changedTag)
{
currentTag.Update();
eaElem.TaggedValues.Refresh();
changedElement = true;
}
}
// Synchronize element Alias
string alias = funptr.GetAliasFromTags(TagName, TagValue);
if (eaElem.Alias != alias)
{
eaElem.Alias = alias;
changedElement = true;
}
if (changedElement)
{
eaElem.Update();
}
return(changedElement);
}
return(false);
}
/// <summary>
/// Delete all tagged values for Element
/// </summary>
/// <param name="el"></param>
/// <returns></returns>
public static bool DeleteTaggedValuesForElement(EA.Element el)
{
for (int i = el.TaggedValues.Count - 1; i >= 0; i--)
{
el.TaggedValues.DeleteAt((short)i, false);
}
el.TaggedValues.Refresh();
el.Update();
return(true);
}
private void SynchronizePortData(EAAPI.Element originalPort, EAAPI.Element referencePort)
{
referencePort.Name = originalPort.Name;
referencePort.PropertyType = originalPort.PropertyType;
referencePort.Notes = originalPort.Notes;
referencePort.Stereotype = originalPort.Stereotype;
referencePort.Update();
SynchronizeTaggedValues(originalPort, referencePort);
}
public EA.Element FindOrCreateElement(Package rootPackage, string elementName, string stereoType)
{
EA.Element eaElement = GetElementByName(rootPackage.PackageID, elementName, stereoType);
if (null == eaElement)
{
eaElement = (EA.Element)rootPackage.Elements.AddNew(elementName, stereoType);
eaElement.Update();
}
return(eaElement);
}
/// <summary>
/// Copy TV to current element
/// </summary>
/// <param name="el"></param>
public void Copy(EA.Element el)
{
//var done = SyncTaggedValues(el);
foreach (EA.TaggedValue tv in _lTv)
{
var tvNew = TaggedValue.Add(el, tv.Name);
TaggedValue.SetTaggedValue(tvNew, tv.Value);
tvNew.Update();
}
el.Update();
el.TaggedValues.Refresh();
}
/// <summary>
/// Move EA requirements to Package with moved requirements
/// </summary>
public virtual void MoveDeletedRequirements()
{
var moveEaElements = from m in DictPackageRequirements
where !_dtRequirements.Rows.Cast <DataRow>().Any(x => GetAbsoluteNumerFromDoorsId(x["Id"].ToString()) == m.Key)
select m.Value;
foreach (var eaId in moveEaElements)
{
EA.Element el = _rep.GetElementByID(eaId);
el.PackageID = PkgDeletedObjects.PackageID;
el.ParentID = 0;
el.Update();
}
}
/// <summary>
/// Delete dependencies of element within the ReqIF Packages
/// </summary>
/// <param name="el"></param>
/// <param name="packageGuidList"></param>
private void DeleteDependencies(EA.Element el, List <ReqIfModuleAssign> packageGuidList)
{
for (int i = el.Connectors.Count - 1; i >= 0; i--)
{
var elConnector = (EA.Connector)el.Connectors.GetAt((short)i);
var elTarget = _rep.GetElementByID(elConnector.SupplierID);
string pkgTargetGuid = _rep.GetPackageByID(elTarget.PackageID).PackageGUID;
// Check if guid exists
if (packageGuidList.Exists(y => y.Guid == pkgTargetGuid))
{
el.Connectors.DeleteAt((short)i, true);
}
}
el.Refresh();
el.Update();
}
// subtype=100 init node
// subtype=101 final node
public static EA.DiagramObject CreateInitFinalNode(EA.Repository rep, EA.Diagram dia, EA.Element act,
int subType, string position)
{
EA.Element initNode = (EA.Element)act.Elements.AddNew("", "StateNode");
initNode.Subtype = subType;
initNode.Update();
if (dia != null)
{
HoUtil.AddSequenceNumber(rep, dia);
EA.DiagramObject initDiaNode = (EA.DiagramObject)dia.DiagramObjects.AddNew(position, "");
initDiaNode.ElementID = initNode.ElementID;
initDiaNode.Sequence = 1;
initDiaNode.Update();
HoUtil.SetSequenceNumber(rep, dia, initDiaNode, "1");
return(initDiaNode);
}
return(null);
}
private void AddOrUpdateElement(
EAAPI.Package parentPackage,
ref Dictionary <String, EAAPI.Element> elements,
String alias,
String type,
String value,
String backgroundColor)
{
// Try to update the existing element
if (true == elements.ContainsKey(alias))
{
if (null != value)
{
elements[alias].Notes = value;
}
else
{
elements[alias].Notes = "";
}
if (!String.IsNullOrEmpty(backgroundColor))
{
elements[alias].Properties.Item("BorderStyle").Value = "Solid";
}
elements[alias].Update();
}
else
{
// If the element is not in the list, then add it.
EAAPI.Element elementNew = (EAAPI.Element)parentPackage.Elements.AddNew("", type);
elementNew.Alias = alias;
if (null != value)
{
elementNew.Notes = value;
}
if (!String.IsNullOrEmpty(backgroundColor))
{
elementNew.Properties.Item("BorderStyle").Value = "Solid";
}
elementNew.Update();
elements.Add(alias, elementNew);
}
}
private EnAr.Element ConstructClassifier(Ecore.IEClassifier eClassifier)
{
if (eclassifier2Class.ContainsKey(eClassifier))
{
return(eclassifier2Class[eClassifier]);
}
EnAr.Element result;
if (eClassifier is Ecore.IEClass)
{
result = ConstructClass((Ecore.IEClass)eClassifier);
}
else if (eClassifier is Ecore.IEEnum)
{
result = ConstructEnumeration((Ecore.IEEnum)eClassifier);
}
else
{
result = ConstructPrimitiveType((Ecore.IEDataType)eClassifier);
}
EA.Element clazzEa = explorer.GetEaObject(result);
// Manage type parameters (eg. T in MyClass<T>)
foreach (Ecore.IETypeParameter eTypeParameter in eClassifier.ETypeParameters)
{
dynamic eaTemplateParameter = clazzEa.TemplateParameters.AddNew(eTypeParameter.Name, "");
eaTemplateParameter.Constraint = "";
List <string> guids = new List <string>();
foreach (Ecore.IEGenericType eGenericType in eTypeParameter.EBounds)
{
EnAr.Element constraintClass = ConstructClassifier(eGenericType.EClassifier);
guids.Add(constraintClass.ElementGUID);
}
eaTemplateParameter.Constraint = string.Join(",", guids);
eaTemplateParameter.Update();
}
clazzEa.TemplateParameters.Refresh();
clazzEa.Refresh();
clazzEa.Update();
return(result);
}
protected override void AddNewTypeToModel(string name)
{
if (UnsortedTypesPackage != null)
{
EAAPI.Element typeElement = UnsortedTypesPackage.Elements.AddNew(name, "Interface") as EAAPI.Element;
UnsortedTypesPackage.Elements.Refresh();
if (typeElement != null)
{
typeElement.Update();
TypeDataModel dataModel = new TypeDataModel()
{
Name = name,
ElementID = typeElement.ElementID
};
Type = dataModel;
}
}
}
/// <summary>
/// Set attributes and tags of supplier port when port is created or connected.
/// </summary>
/// <param name="connectorId">The created item flow connector.</param>
/// <param name="portStereotype">The stereotype of the port.</param>
/// <param name="connectorStereotype">The stereotype of the port connectiong flow connector.</param>
/// <param name="supplierName">The EA default name for the new created supplier port.</param>
public void SetPropertyTypeAndDirectionOnFlowPortCreation(int connectorId,
string portStereotype,
string connectorStereotype,
string supplierName)
{
EAShared.Connector connector = Rep.GetConnectorByID(connectorId);
EAShared.Element client = Rep.GetElementByID(connector.ClientID);
EAShared.Element supplier = Rep.GetElementByID(connector.SupplierID);
if ((supplier.Stereotype == portStereotype) &&
(connector.Stereotype == connectorStereotype))
{
CopyTaggedValuesFromClientToSupplierPort(client, supplier);
if (supplier.PropertyType == 0)
{
supplier.PropertyType = client.PropertyType;
if (supplier.Alias == "")
{
supplier.Alias = client.Alias;
}
if (supplier.Multiplicity == "")
{
supplier.Multiplicity = client.Multiplicity;
}
// Copy notes text from client to supplier
if (supplier.Notes == "")
{
supplier.Notes = client.Notes;
}
}
else if (supplier.PropertyType == client.PropertyType)
{
if (supplier.Alias == "")
{
supplier.Alias = client.Alias;
}
if (supplier.Multiplicity == "")
{
supplier.Multiplicity = client.Multiplicity;
}
// Copy notes text from client to supplier
if (supplier.Notes == "")
{
supplier.Notes = client.Notes;
}
}
if (supplier.Name.StartsWith(supplierName) || supplier.Name == "")
{
supplier.Name = client.Name;
}
supplier.Update();
supplier.Refresh();
} // if
}
private EA.Element createNewCorrespondenceLink(EA.Package tggOutermostePackage, out EA.Connector connectorToSource, out EA.Connector connectorToTarget)
{
EA.Element tggLink = tggOutermostePackage.Elements.AddNew(textBoxLinkName.Text, Main.EAClassType) as EA.Element;
tggLink.StereotypeEx = TGGModelingMain.TggCorrespondenceTypeStereotype;
tggLink.Update();
TGGCorrespondenceType correspondenceType = new TGGCorrespondenceType(sqlRepository.GetElementByID(tggLink.ElementID), sqlRepository);
correspondenceType.saveTreeToEATaggedValue(false);
connectorToSource = tggLink.Connectors.AddNew("", ECOREModelingMain.EReferenceConnectorType) as EA.Connector;
connectorToSource.SupplierID = clientClassifier.ElementID;
connectorToSource.Direction = Main.EASourceTargetDirection;
connectorToSource.SupplierEnd.Role = "source";
connectorToSource.SupplierEnd.Navigable = "Navigable";
connectorToSource.SupplierEnd.Cardinality = "1";
connectorToSource.SupplierEnd.IsNavigable = true;
connectorToSource.Update();
EReference refToSource = new EReference(sqlRepository.GetConnectorByID(connectorToSource.ConnectorID), sqlRepository);
refToSource.saveTreeToEATaggedValue(true);
tggLink.Connectors.Refresh();
connectorToTarget = tggLink.Connectors.AddNew("", ECOREModelingMain.EReferenceConnectorType) as EA.Connector;
connectorToTarget.SupplierID = supplierClassifier.ElementID;
connectorToTarget.Direction = Main.EASourceTargetDirection;
connectorToTarget.SupplierEnd.Role = "target";
connectorToTarget.SupplierEnd.Cardinality = "1";
connectorToTarget.SupplierEnd.Navigable = "Navigable";
connectorToTarget.SupplierEnd.IsNavigable = true;
connectorToTarget.Update();
EReference refToTarget = new EReference(sqlRepository.GetConnectorByID(connectorToTarget.ConnectorID), sqlRepository);
refToTarget.saveTreeToEATaggedValue(true);
selectedCorrespondenceLinkId = tggLink.ElementID;
EA.Diagram curDiagram = null;
EA.DiagramObject sourceDiagObj = null;
EA.DiagramObject targetDiagObj = null;
foreach (EA.Diagram diag in tggOutermostePackage.Diagrams)
{
foreach (EA.DiagramObject diagObj in diag.DiagramObjects)
{
if (diagObj.ElementID == clientClassifier.ElementID)
{
sourceDiagObj = diagObj;
}
else if (diagObj.ElementID == supplierClassifier.ElementID)
{
targetDiagObj = diagObj;
}
if (sourceDiagObj != null && targetDiagObj != null)
{
curDiagram = diag;
}
}
}
if (curDiagram != null)
{
sqlRepository.SaveDiagram(curDiagram.DiagramID);
int sourceLeft = (sourceDiagObj == null) ? 0 : sourceDiagObj.left;
int sourceRight = (sourceDiagObj == null) ? 0 : sourceDiagObj.right;
int sourceBottom = (sourceDiagObj == null) ? 0 : sourceDiagObj.bottom;
int sourceTop = (sourceDiagObj == null) ? 0 : sourceDiagObj.top;
int targetLeft = (targetDiagObj == null) ? 0 : targetDiagObj.left;
int targetRight = (targetDiagObj == null) ? 0 : targetDiagObj.right;
int targetBottom = (targetDiagObj == null) ? 0 : targetDiagObj.bottom;
int targetTop = (targetDiagObj == null) ? 0 : targetDiagObj.top;
EA.DiagramObject tggLinkDiagObj = curDiagram.DiagramObjects.AddNew("", "") as EA.DiagramObject;
tggLinkDiagObj.ElementID = tggLink.ElementID;
tggLinkDiagObj.Update();
tggLinkDiagObj.left = (sourceLeft + targetLeft) / 2;
tggLinkDiagObj.right = (sourceRight + targetRight) / 2;
tggLinkDiagObj.bottom = (sourceBottom + targetBottom) / 2;
tggLinkDiagObj.top = (sourceTop + targetTop) / 2;
tggLinkDiagObj.Update();
curDiagram.DiagramObjects.Refresh();
sqlRepository.ReloadDiagram(curDiagram.DiagramID);
tggOutermostePackage.Elements.Refresh();
}
return(tggLink);
}
public static bool CreateInteractionForOperation(EA.Repository rep, EA.Method m)
{
// get class
EA.Element elClass = rep.GetElementByID(m.ParentID);
Package pkgSrc = rep.GetPackageByID(elClass.PackageID);
// create a package with the name of the operation
Package pkgTrg = (Package)pkgSrc.Packages.AddNew(m.Name, "");
pkgTrg.Update();
pkgSrc.Packages.Refresh();
// create Class Sequence Diagram in target package
EA.Diagram pkgSeqDia = (EA.Diagram)pkgTrg.Diagrams.AddNew("Operation:" + m.Name + " Content", "Sequence");
pkgSeqDia.Update();
pkgTrg.Diagrams.Refresh();
// add frame in Sequence diagram
EA.DiagramObject frmObj = (EA.DiagramObject)pkgSeqDia.DiagramObjects.AddNew("l=100;r=400;t=25;b=50", "");
EA.Element frm = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "UMLDiagram");
frm.Update();
frmObj.ElementID = frm.ElementID;
//frmObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
frmObj.Update();
pkgTrg.Elements.Refresh();
pkgSeqDia.DiagramObjects.Refresh();
// create Interaction with the name of the operation
EA.Element seq = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "Interaction");
seq.Notes = "Generated from Operation:\r\n" + m.Visibility + " " + m.Name + ":" + m.ReturnType + ";\r\nDetails see Operation definition!!";
seq.Update();
pkgTrg.Elements.Refresh();
// create sequence diagram beneath Interaction
EA.Diagram seqDia = (EA.Diagram)seq.Diagrams.AddNew(m.Name, "Sequence");
seqDia.Update();
seq.Diagrams.Refresh();
// create instance from class beneath Interaction
EA.Element obj = (EA.Element)seq.Elements.AddNew("", "Object");
seq.Elements.Refresh();
obj.ClassfierID = elClass.ElementID;
obj.Update();
// add node object to Sequence Diagram
EA.DiagramObject node = (EA.DiagramObject)seqDia.DiagramObjects.AddNew("l=100;r=180;t=50;b=70", "");
node.ElementID = obj.ElementID;
node.Update();
// Add Heading to diagram
EA.DiagramObject noteObj = (EA.DiagramObject)seqDia.DiagramObjects.AddNew("l=40;r=700;t=10;b=25", "");
EA.Element note = (EA.Element)pkgTrg.Elements.AddNew("Text", "Text");
note.Notes = m.Visibility + " " + elClass.Name + "_" + m.Name + ":" + m.ReturnType;
note.Update();
noteObj.ElementID = note.ElementID;
noteObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
noteObj.Update();
pkgTrg.Elements.Refresh();
seqDia.DiagramObjects.Refresh();
// Link Operation to activity
HoUtil.SetBehaviorForOperation(rep, m, seq);
// Set show behavior
HoUtil.SetShowBehaviorInDiagram(rep, m);
HoUtil.SetFrameLinksToDiagram(rep, frm, seqDia); // link Overview frame to diagram
frm.Update();
//rep.ReloadDiagram(actDia.DiagramID);
return(true);
}
//-----------------------------------------------------------------------------------------
// Create StateMachine for Operation
//----------------------------------------------------------------------------------
public static bool CreateStateMachineForOperation(EA.Repository rep, EA.Method m)
{
// get class
EA.Element elClass = rep.GetElementByID(m.ParentID);
EA.Package pkgSrc = rep.GetPackageByID(elClass.PackageID);
// create a package with the name of the operation
EA.Package pkgTrg = (Package)pkgSrc.Packages.AddNew(m.Name, "");
pkgTrg.Update();
pkgSrc.Packages.Refresh();
// create Class StateMachine Diagram in target package
EA.Diagram pkgSeqDia = (EA.Diagram)pkgTrg.Diagrams.AddNew("Operation:" + m.Name + " Content", "Statechart");
pkgSeqDia.Update();
pkgTrg.Diagrams.Refresh();
// add frame in StateMachine diagram
EA.DiagramObject frmObj = (EA.DiagramObject)pkgSeqDia.DiagramObjects.AddNew("l=100;r=400;t=25;b=50", "");
EA.Element frm = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "UMLDiagram");
frm.Update();
frmObj.ElementID = frm.ElementID;
//frmObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
frmObj.Update();
pkgTrg.Elements.Refresh();
pkgSeqDia.DiagramObjects.Refresh();
// create StateMachine with the name of the operation
EA.Element stateMachine = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "StateMachine");
stateMachine.Notes = "Generated from Operation:\r\n" + m.Visibility + " " + m.Name + ":" + m.ReturnType + ";\r\nDetails see Operation definition!!";
stateMachine.Update();
pkgTrg.Elements.Refresh();
// create Statechart diagram beneath State Machine
EA.Diagram chartDia = (EA.Diagram)stateMachine.Diagrams.AddNew(m.Name, "Statechart");
chartDia.Update();
stateMachine.Diagrams.Refresh();
// put the state machine on the diagram
EA.DiagramObject chartObj = (EA.DiagramObject)chartDia.DiagramObjects.AddNew("l=50;r=600;t=100;b=800", "");
chartObj.ElementID = stateMachine.ElementID;
chartObj.Update();
chartDia.DiagramObjects.Refresh();
// add default nodes (init/final)
CreateDefaultElementsForStateDiagram(rep, chartDia, stateMachine);
// Add Heading to diagram
EA.DiagramObject noteObj = (EA.DiagramObject)chartDia.DiagramObjects.AddNew("l=40;r=700;t=10;b=25", "");
EA.Element note = (EA.Element)pkgTrg.Elements.AddNew("Text", "Text");
note.Notes = m.Visibility + " " + elClass.Name + "_" + m.Name + ":" + m.ReturnType;
note.Update();
noteObj.ElementID = note.ElementID;
noteObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
noteObj.Update();
pkgTrg.Elements.Refresh();
chartDia.DiagramObjects.Refresh();
// Link Operation to StateMachine
HoUtil.SetBehaviorForOperation(rep, m, stateMachine);
// Set show behavior
HoUtil.SetShowBehaviorInDiagram(rep, m);
HoUtil.SetFrameLinksToDiagram(rep, frm, chartDia); // link Overview frame to diagram
frm.Update();
//rep.ReloadDiagram(actDia.DiagramID);
return(true);
}
/// <summary>
/// Create Activity for operation
/// </summary>
/// <param name="rep"></param>
/// <param name="m"></param>
/// <param name="treePos"></param>
/// <param name="pkgSrc"></param>
/// <param name="elClass"></param>
private static void CreateActivityFromOperation(Repository rep, Method m, int treePos, EA.Package pkgSrc, EA.Element elClass)
{
// create a package with the name of the operation
EA.Package pkgTrg = (EA.Package)pkgSrc.Packages.AddNew(m.Name, "");
pkgTrg.TreePos = treePos;
pkgTrg.Update();
pkgSrc.Packages.Refresh();
EA.Element frm = null; // frame beneath package
if (ActivityIsSimple == false)
{
// create Class Activity Diagram in target package
EA.Diagram pkgActDia = (EA.Diagram)pkgTrg.Diagrams.AddNew("Operation:" + m.Name + " Content", "Activity");
pkgActDia.Update();
pkgTrg.Diagrams.Refresh();
// prevent information loss
Util.SetDiagramStyleFitToPage(pkgActDia); // after save diagram!
// add frame in Activity diagram
EA.DiagramObject frmObj = (EA.DiagramObject)pkgActDia.DiagramObjects.AddNew("l=100;r=400;t=25;b=50", "");
frm = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "UMLDiagram");
frm.Update();
frmObj.ElementID = frm.ElementID;
//frmObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
frmObj.Update();
pkgTrg.Elements.Refresh();
pkgActDia.DiagramObjects.Refresh();
}
// create activity with the name of the operation
EA.Element act = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "Activity");
if (ActivityIsSimple == false)
{
act.Notes = "Generated from Operation:\r\n" + m.Visibility + " " + m.Name + ":" + m.ReturnType +
";\r\nDetails see Operation definition!!";
}
act.StereotypeEx = m.StereotypeEx;
act.Update();
pkgTrg.Elements.Refresh();
// create activity diagram beneath Activity
EA.Diagram actDia = (EA.Diagram)act.Diagrams.AddNew(m.Name, "Activity");
// update diagram properties
actDia.ShowDetails = 0; // hide details
// scale page to din A4
if (actDia.StyleEx.Length > 0)
{
actDia.StyleEx = actDia.StyleEx.Replace("HideQuals=0", "HideQuals=1"); // hide qualifier
}
else
{
actDia.StyleEx = "HideQuals=1;";
}
// Hide Qualifier
if (actDia.ExtendedStyle.Length > 0)
{
actDia.ExtendedStyle = actDia.ExtendedStyle.Replace("ScalePI=0", "ScalePI=1");
}
else
{
actDia.ExtendedStyle = "ScalePI=1;";
}
actDia.Update();
act.Diagrams.Refresh();
// put the activity on the diagram
Util.AddSequenceNumber(rep, actDia);
EA.DiagramObject actObj = (EA.DiagramObject)actDia.DiagramObjects.AddNew("l=30;r=780;t=30;b=1120", "");
actObj.ElementID = act.ElementID;
actObj.Sequence = 1;
actObj.Update();
Util.SetSequenceNumber(rep, actDia, actObj, "1");
actDia.DiagramObjects.Refresh();
// add default nodes (init/final)
CreateDefaultElementsForActivity(rep, actDia, act);
if (ActivityIsSimple == false)
{
// Add Heading to diagram
Util.AddSequenceNumber(rep, actDia);
EA.DiagramObject noteObj = (EA.DiagramObject)actDia.DiagramObjects.AddNew("l=40;r=700;t=25;b=50", "");
EA.Element note = (EA.Element)pkgTrg.Elements.AddNew("Text", "Text");
note.Notes = m.Visibility + " " + elClass.Name + "_" + m.Name + ":" + m.ReturnType;
note.Update();
noteObj.ElementID = note.ElementID;
noteObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
noteObj.Sequence = 1;
noteObj.Update();
Util.SetSequenceNumber(rep, actDia, noteObj, "1");
}
pkgTrg.Elements.Refresh();
actDia.DiagramObjects.Refresh();
// Link Operation to activity
Util.SetBehaviorForOperation(rep, m, act);
// Set show behavior
Util.SetShowBehaviorInDiagram(rep, m);
// add parameters to activity
UpdateParameterFromOperation(rep, act, m);
int pos = 0;
foreach (EA.Element actPar in act.EmbeddedElements)
{
if (!actPar.Type.Equals("ActivityParameter"))
{
continue;
}
Util.VisualizePortForDiagramobject(rep, pos, actDia, actObj, actPar, null);
pos = pos + 1;
}
if (ActivityIsSimple == false)
{
// link Overview frame to diagram
Util.SetFrameLinksToDiagram(rep, frm, actDia);
frm.Update();
}
// select operation
rep.ShowInProjectView(m);
}
//-------------------------------------------------------------------------------------------------
// get Parameter from operation
// visualize them on diagram / activity
//-------------------------------------------------------------------------------------------------
// ReSharper disable once UnusedMethodReturnValue.Global
public static bool UpdateParameterFromOperation(Repository rep, EA.Element act, Method m)
{
if (m == null)
{
return(false);
}
if (act.Locked)
{
return(false);
}
if (!act.Type.Equals("Activity"))
{
return(false);
}
EA.Element parTrgt = null;
///////////////////////////////////////////////////////////////////////////////////
// return code
string parName = "Return";
int methodReturnTypId;
// is type defined?
if ((m.ClassifierID != "0") & (m.ClassifierID != ""))
{
methodReturnTypId = Convert.ToInt32(m.ClassifierID);
}
// type is only defined as text
else
{
methodReturnTypId = Convert.ToInt32(Util.GetTypeId(rep, m.ReturnType));
}
bool withActivityReturnParameter = false;
if (withActivityReturnParameter)
{
parTrgt.ClassifierID = methodReturnTypId;
// create an return Parameter for Activity (in fact an element with properties)
parTrgt = Util.GetParameterFromActivity(rep, null, act, true);
if (parTrgt == null)
{
parTrgt = (EA.Element)act.EmbeddedElements.AddNew(parName, "Parameter");
}
else
{
parTrgt.Name = parName;
}
parTrgt.Alias = "return:" + m.ReturnType;
parTrgt.ClassifierID = parTrgt.ClassifierID;
parTrgt.Update();
// update properties for return value
var par = new Param(rep, parTrgt);
par.SetParameterProperties("direction", "out");
par.Save();
par = null;
}
// returnType for activity
act.ClassfierID = methodReturnTypId;
act.Name = m.Name;
// use stereotype of operation as stereotype for activity
act.StereotypeEx = m.StereotypeEx;
act.Update();
act.EmbeddedElements.Refresh();
// over all parameters
string guids = "";
// It looks as if parSrc.Position isn't reliable
int pos = 0;
foreach (EA.Parameter parSrc in m.Parameters)
{
// create an Parameter for Activity (in fact an element with properties)
// - New if the parameter don't exists
// - Update if the parameter exists
// -- Update according to the parameter position
//string direction = " [" + parSrc.Kind + "]";
string direction = "";
string prefixTyp = "";
if (parSrc.IsConst)
{
prefixTyp = " const";
}
var postfixName = "";
if (parSrc.Kind.Contains("out"))
{
postfixName = "*";
}
//parName = parSrc.Position + ":" + parSrc.Name + postfixName + prefixTyp + direction;
parName = $"{pos}:{parSrc.Name}{postfixName}{prefixTyp}{direction}";
// check if parameter already exists (last parameter = false)
parTrgt = Util.GetParameterFromActivity(rep, parSrc, act);
// parameter doesn't exists
if (parTrgt == null)
{
parTrgt = (EA.Element)act.EmbeddedElements.AddNew(parName, "Parameter");
}
else
{
parTrgt.Name = parName;
}
guids = guids + parTrgt.ElementGUID;
// is type defined?
if ((parSrc.ClassifierID != "0") & (parSrc.ClassifierID != ""))
{
parTrgt.ClassifierID = Convert.ToInt32(parSrc.ClassifierID);
}
// type is only defined as text
else
{ // try to find classifier
parTrgt.ClassifierID = Convert.ToInt32(Util.GetTypeId(rep, parSrc.Type));
// use type in name (no classifier found)
if (parTrgt.ClassifierID == 0)
{
parTrgt.Name = parTrgt.Name + ":" + parSrc.Type;
}
}
parTrgt.Notes = parSrc.Notes;
//parTrgt.Alias = $"par_{parSrc.Position}:{parSrc.Type}";
parTrgt.Alias = $"par_{pos}:{parSrc.Type}";
// update properties for parameter
var par = new Param(rep, parTrgt);
par.SetParameterProperties("direction", parSrc.Kind);
if (parSrc.IsConst)
{
par.SetParameterProperties("constant", "true");
}
par.Save();
parTrgt.Update();
pos += 1;
}
act.EmbeddedElements.Refresh();
// delete all unused parameter
for (short i = (short)(act.EmbeddedElements.Count - 1); i >= 0; --i)
{
var embeddedEl = (EA.Element)act.EmbeddedElements.GetAt(i);
if (embeddedEl.Type.Equals("ActivityParameter"))
{
if (!(guids.Contains(embeddedEl.ElementGUID)))
{
act.EmbeddedElements.Delete(i);
}
}
}
act.EmbeddedElements.Refresh();
return(true);
}
public static void DiagramObjectMove(Repository rep)
{
// Package in browser selected
// only copy elements of type element
EA.ObjectType objType = rep.GetTreeSelectedItemType();
// if diagram: get the Element or Package
EA.Package pkg = null;
EA.Element elTarget = null;
if (objType == EA.ObjectType.otDiagram)
{
var dia = (EA.Diagram)rep.GetTreeSelectedObject();
if (dia.ParentID == 0)
{
pkg = rep.GetPackageByID(dia.PackageID);
}
else
{
elTarget = rep.GetElementByID(dia.ParentID);
}
}
if (objType == EA.ObjectType.otPackage || pkg != null)
{
// get selected DiagramObjects
EaDiagram eaDia = new EaDiagram(rep, getAllDiagramObject: false);
// Handle selected diagram and its selected items (connector/objects)
if (eaDia.Dia != null)
{
if (objType == EA.ObjectType.otPackage && pkg == null)
{
pkg = (EA.Package)rep.GetTreeSelectedObject();
}
// over all selected objects
var count = 0;
foreach (var dObj in eaDia.SelObjects)
{
EA.Element el = rep.GetElementByID(dObj.ElementID);
// don't change nested elements, you have to move the root element
if (el.Type != "Package" && el.ObjectType == EA.ObjectType.otElement && el.ParentID == 0)
{
el.PackageID = pkg.PackageID;
el.Update();
count = count + 1;
}
}
rep.RefreshModelView(pkg.PackageID);
if (count != eaDia.SelObjects.Count)
{
MessageBox.Show($@"Total items: {eaDia.SelObjects.Count}
Moved items: {count}
If item is a nested item only the root will be copied.
", @"not all items moved");
}
}
}
// Element in browser selected, or element to copy beneath exists
if (rep.GetTreeSelectedItemType() == EA.ObjectType.otElement || elTarget != null)
{
if (elTarget == null)
{
elTarget = (EA.Element)rep.GetTreeSelectedObject();
}
// get selected DiagramObjects
EaDiagram eaDia = new EaDiagram(rep, getAllDiagramObject: false);
// Handle selected diagram and its selected items (connector/objects)
if (eaDia.Dia != null)
{
// over all selected objects
foreach (var dObj in eaDia.SelObjects)
{
EA.Element el = rep.GetElementByID(dObj.ElementID);
// don't change nested elements, you have to move the root element
// don't copy to itself
if (el.Type != "Package" && el.ObjectType == EA.ObjectType.otElement && el.ParentID == 0 && el.ElementID != elTarget.ElementID)
{
el.ParentID = elTarget.ElementID;
el.Update();
}
}
}
}
}
public void SynchronizeReferenceWithOriginal()
{
List <EAAPI.Element> originals = new List <EAAPI.Element>();
EAAPI.Element original = null;
// search for originals
for (short connectorCount = 0; connectorCount < _referenceElement.Connectors.Count; connectorCount++)
{
EAAPI.Connector connector = (EAAPI.Connector)_referenceElement.Connectors.GetAt(connectorCount);
if (connector.ClientID == _referenceElement.ElementID && connector.SupplierID != _referenceElement.ElementID)
{
if (connector.Type == "Dependency" && connector.Stereotype == "referenceOf")
{
original = _repository.GetElementByID(connector.SupplierID);
if (original.Type == "Object" && original.ClassifierID == _referenceElement.ClassifierID)
{
originals.Add(original);
}
}
}
}
if (originals.Count == 1)
{
original = originals[0];
if (original.ClassifierID != _referenceElement.ClassfierID)
{
logger.Info("Synchronizing element type.");
_referenceElement.ClassifierID = _referenceElement.ClassifierID;
_referenceElement.Update();
}
DeleteWrongPortReferenceOfConnections(original.ElementID);
SynchronizePortsOfReferenceElement(original);
// synchronize descriptional notes
logger.Info("Synchronizing descriptional notes.");
_referenceElement.Notes = original.Notes;
_referenceElement.Update();
_referenceElement.Stereotype = original.Stereotype;
_referenceElement.Update();
SynchronizeTaggedValues(original, _referenceElement);
logger.Info("Port synchoronization finished.");
}
else if (originals.Count == 0)
{
// return if no original was found
logger.Info("No original element found.");
return;
}
else
{
logger.Error("Error: Reference is not unique.");
}
}
static void ChangeAuthorElement(Repository rep, Element el, string[] args)
{
el.Author = args[0];
el.Update();
}
/// <summary>
/// Write the EA dependencies according to ReqIF between the requirements
/// </summary>
public bool WriteRelations()
{
// Read all requirements
string stereotypePredicate = _settings.Stereotype == "" ? "" : $" AND stereotype = '{_settings.Stereotype}' ";
string sql = $@"select *
from t_object o
inner join t_package pkg on pkg.package_id = o.package_id
where pkg.ea_guid in ( {_settings.PackageGuidCommaList} ) AND
o.object_type = '{_settings.ObjectType}'
{stereotypePredicate}";
EA.Collection reqCol = _rep.GetElementSet(sql, 2);
foreach (EA.Element req in reqCol)
{
_requirements.Add(req);
}
// All EA requirements and their target
try
{
// check not existing references
var notExistingTargets = (from r in _reqIf.CoreContent[0].SpecRelations
join eaRS in _requirements on r.Source.Identifier ?? "" equals eaRS.Multiplicity ?? ""
where r.Target == null
select $"{eaRS.Multiplicity}:{eaRS.Name}").ToArray();
if (notExistingTargets.Length > 0)
{
MessageBox.Show($@"{String.Join("\r\n", notExistingTargets)}", @"Target Requirements for Link not available, skip links");
}
var relations = from r in _reqIf.CoreContent[0].SpecRelations
join eaRS in _requirements on r.Source?.Identifier ?? "" equals eaRS.Multiplicity ?? ""
join eaRT in _requirements on r.Target?.Identifier ?? "" equals eaRT.Multiplicity ?? ""
orderby r.Source?.Identifier ?? ""
select new
{
SourceReq = eaRS,
TargetReq = eaRT,
SObjectId = r.Source.Identifier ?? "",
TObjectId = r.Target.Identifier ?? "",
};
// Create the relations
EA.Element el = null;
foreach (var rel in relations)
{
if (el != rel.SourceReq)
{
el = rel.SourceReq;
if (el != null)
{
DeleteDependencies(el, _settings.PackageGuidList);
}
}
EA.Connector con = (EA.Connector)el.Connectors.AddNew("", "Dependency");
con.Stereotype = _settings.StereotypeDependency;
con.ClientID = rel.TargetReq.ElementID;
con.SupplierID = rel.SourceReq.ElementID;
con.Update();
el.Connectors.Refresh();
el.Update();
}
return(true);
}
catch (Exception e)
{
MessageBox.Show($@"Related link to requirement not available
File:
'{_settings.InputFile}'
{e}", @"Can't write ReqIF relations in EA, skip relations!");
return(false);
}
}
//------------------------------------------------------------------------------
// Create default Elements for Statemachine
//------------------------------------------------------------------------------
//
// init
// state 'State1'
// final
// transition from init to 'State1'
public static bool CreateDefaultElementsForStateDiagram(Repository rep, EA.Diagram dia, EA.Element stateChart)
{
// check if init and final node are available
bool init = false;
bool final = false;
foreach (EA.Element node in stateChart.Elements)
{
if (node.Type == "StateNode" & node.Subtype == 100)
{
init = true;
}
if (node.Type == "StateNode" & node.Subtype == 101)
{
final = true;
}
}
EA.Element initNode = null;
if (!init)
{
initNode = (EA.Element)stateChart.Elements.AddNew("", "StateNode");
initNode.Subtype = 3;
initNode.ParentID = stateChart.ElementID;
initNode.Update();
if (dia != null)
{
HoUtil.AddSequenceNumber(rep, dia);
EA.DiagramObject initDiaNode =
(EA.DiagramObject)dia.DiagramObjects.AddNew("l=295;r=315;t=125;b=135;", "");
initDiaNode.Sequence = 1;
initDiaNode.ElementID = initNode.ElementID;
initDiaNode.Update();
HoUtil.SetSequenceNumber(rep, dia, initDiaNode, "1");
}
}
EA.Element finalNode = null;
// create final node
if (!final)
{
finalNode = (EA.Element)stateChart.Elements.AddNew("", "StateNode");
finalNode.Subtype = 4;
finalNode.ParentID = stateChart.ElementID;
finalNode.Update();
if (dia != null)
{
HoUtil.AddSequenceNumber(rep, dia);
EA.DiagramObject finalDiaNode =
(EA.DiagramObject)dia.DiagramObjects.AddNew("l=285;r=305;t=745;b=765;", "");
finalDiaNode.Sequence = 1;
finalDiaNode.ElementID = finalNode.ElementID;
finalDiaNode.Update();
HoUtil.SetSequenceNumber(rep, dia, finalDiaNode, "1");
}
}
// create state node
EA.Element stateNode = (EA.Element)stateChart.Elements.AddNew("", "State");
stateNode.Subtype = 0; // state
stateNode.Name = "State1";
stateNode.ParentID = stateChart.ElementID;
stateNode.Update();
if (dia != null)
{
HoUtil.AddSequenceNumber(rep, dia);
string pos = "l=300;r=400;t=-400;b=-470";
EA.DiagramObject stateDiaNode = (EA.DiagramObject)dia.DiagramObjects.AddNew(pos, "");
stateDiaNode.Sequence = 1;
stateDiaNode.ElementID = stateNode.ElementID;
stateDiaNode.Update();
HoUtil.SetSequenceNumber(rep, dia, stateDiaNode, "1");
// draw a transition
EA.Connector con = (EA.Connector)finalNode.Connectors.AddNew("", "StateFlow");
con.SupplierID = stateNode.ElementID;
con.ClientID = initNode.ElementID;
con.Update();
finalNode.Connectors.Refresh();
stateChart.Elements.Refresh();
dia.DiagramObjects.Refresh();
dia.Update();
rep.ReloadDiagram(dia.DiagramID);
}
return(true);
}
