private void recurseEaPackage(EA.Package eaPackage, Dictionary <string, EA.Element> eaElementDict)
{
foreach (EA.Package eaSubPackage in eaPackage.Packages)
{
EA.TaggedValue tvSID = (EA.TaggedValue)eaSubPackage.Element.TaggedValues.GetByName(TV_MAX_ID);
if (tvSID != null)
{
eaElementDict[tvSID.Value.ToUpper()] = eaSubPackage.Element;
}
else
{
eaElementDict[eaSubPackage.PackageID.ToString()] = eaSubPackage.Element;
}
recurseEaPackage(eaSubPackage, eaElementDict);
}
foreach (EA.Element eaElement in eaPackage.Elements)
{
EA.TaggedValue tvEID = (EA.TaggedValue)eaElement.TaggedValues.GetByName(TV_MAX_ID);
if (tvEID != null)
{
eaElementDict[tvEID.Value.ToUpper()] = eaElement;
}
else
{
eaElementDict[eaElement.ElementID.ToString()] = eaElement;
}
recurseEaElements(eaElement, eaElementDict);
}
}
/// <summary>
/// Set Tagged Value with 'Name' to a value. If tagged value doesn't exists a new one is created.
/// </summary>
/// <param name="el"></param>
/// <param name="name"></param>
/// <param name="value"></param>
/// <returns></returns>
public static EA.TaggedValue SetTaggedValue(EA.Element el, string name, string value)
{
EA.TaggedValue tg = AddTaggedValue(el, name);
tg.Value = value;
tg.Update();
return(tg);
}
public void LoadFromRepository(EA.Repository repository)
{
element = EAHelper.GetCurrentElement(repository);
if (element != null)
{
field = element.TaggedValuesEx.GetByName("Markdown");
if(field == null)
{
field = element.TaggedValuesEx.AddNew("Markdown", "TaggedValue");
field.Value = "<memo>";
field.Update();
}
style = element.TaggedValuesEx.GetByName("MarkdownStyle");
if(style == null)
{
style = element.TaggedValuesEx.AddNew("MarkdownStyle", "TaggedValue");
style.Value = ((MarkdownStyle)this.toolstripStyleBox.SelectedItem).CSSLink;
style.Update();
}
skin = element.TaggedValuesEx.GetByName("PrettifySkin");
if (skin == null)
{
skin = element.TaggedValuesEx.AddNew("PrettifySkin", "TaggedValue");
skin.Value = this.toolStripSkinBox.SelectedItem.ToString();
skin.Update();
}
}
this.markdownTextBox.Text = field.Notes;
//UpdateWebBrowser();
}
/// <summary>
/// Sets a normal EA.Package as an UMM view package. This means, that a stereotype is
/// applied and also the taggedvalues, which every "UMM view package" inherits
/// from "BusinessLibrary" from UMM base. Additionally a package diagram is created if
/// the package is stereotyped as BDV, BRV or BTV
/// </summary>
/// <param name="package">the EA.Package which should be modified to an UMM "view package"</param>
/// <param name="stereotype">the stereotype, which should be applied</param>
/// <returns>a reference to the modified package</returns>
private EA.Package populateUMMView(EA.Package package, UMM stereotype)
{
// set the stereotype
package.Element.Stereotype = stereotype.ToString();
// add the tagged values
foreach (string tv_string in Enum.GetNames(typeof(BusinessLibraryTV)))
{
EA.TaggedValue tv = (EA.TaggedValue)package.Element.TaggedValues.AddNew(tv_string, "");
tv.Update();
}
/* if the stereotype is BRV or BCV the package is own of the core views.
* then for a more convinient modeling, a package diagram is added */
if (stereotype.Equals(UMM.bRequirementsV) || stereotype.Equals(UMM.bChoreographyV))
{
EA.Diagram diagram = (EA.Diagram)package.Diagrams.AddNew(package.Name, EA_Element.Package.ToString());
diagram.ShowDetails = 0;
diagram.Update();
}
//For the BIV we add a class diagram
else if (stereotype.Equals(UMM.bInformationV))
{
EA.Diagram diagram = (EA.Diagram)package.Diagrams.AddNew(package.Name, EA_Element.Class.ToString());
diagram.ShowDetails = 0;
diagram.Update();
}
package.Update();
return(package);
}
/// informed that the deletion of the Method will delete the SDM Diagram as well.
/// </summary>
/// <param name="Repository"></param>
/// <param name="Info"></param>
/// <returns></returns>
public Boolean EA_OnPreDeleteMethod(EA.Repository Repository, EA.Method method)
{
EA.Method meth = method;
EA.Element methParent = Repository.GetElementByID(meth.ParentID);
EA.TaggedValue aTag = null;
SQLRepository sqlRep = new SQLRepository(Repository, false);
foreach (EA.Element actEle in methParent.Elements)
{
aTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(actEle, SDMModelingMain.SDMContainerAssociatedMethodTaggedValueName);
if (aTag != null)
{
if (aTag.Value.ToString() == meth.MethodGUID.ToString())
{
Boolean delete = false;
DeleteMethod deleteMethod = new DeleteMethod(delete);
deleteMethod.StartPosition = FormStartPosition.CenterScreen;
deleteMethod.ShowDialog();
delete = deleteMethod.setVal();
if (delete)
{
EAUtil.deleteElement(actEle, sqlRep);
return(true);
}
return(false);
}
}
}
return(true);
}
public void TestUpdateClassFromInstance_NewDataItem()
{
DiagramCache diagramCache = new DiagramCache();
EAMetaModel meta = new EAMetaModel().setupSchemaPackage();
EAFactory rootClass = new EAFactory();
rootClass.setupClient("SomeClass", RoundTripAddInClass.EA_TYPE_CLASS, RoundTripAddInClass.EA_STEREOTYPE_REQUEST, 0, null);
EA.Element el = rootClass.clientElement;
EAFactory attrFactory = rootClass.addSupplier("SomeAttribute", RoundTripAddInClass.EA_TYPE_CLASS, 0, RoundTripAddInClass.EA_STEREOTYPE_DATAITEM, null, "someAttribute", RoundTripAddInClass.CARDINALITY_0_TO_ONE, null);
EA.Element attr = attrFactory.clientElement;
EA.Package pkg = SchemaManager.generateSample(EARepository.Repository, diagramCache);
object os = pkg.Elements.GetAt(0);
EA.Element sample = (EA.Element)os;
string nrs = ObjectManager.addRunState(sample.RunState, "SomeAttribute", "foobar", 0);
sample.RunState = nrs;
SchemaManager.updateClassFromSample(EARepository.Repository, sample);
EA.TaggedValue def = SchemaManager.getAttributeDefault(attr);
Assert.AreEqual("foobar", def.Value);
}
private void button1_Click(object sender, EventArgs e)
{
Enabled = false;
Close();
string maxFile = textBox1.Text;
string schFile = textBox2.Text;
string svrlFile = textBox3.Text;
// Update Package SchematronFile
EA.TaggedValue tvSchematronFile = GetSchematronTaggedValue(repository);
tvSchematronFile.Value = schFile;
tvSchematronFile.Update();
// Create MAX file
MAX_EA.MAXExporter3 exporter = new MAX_EA.MAXExporter3();
EA.ObjectType type = repository.GetTreeSelectedItemType();
if (type == EA.ObjectType.otPackage)
{
EA.Package package = repository.GetTreeSelectedPackage();
exporter.exportPackage(repository, package, maxFile);
}
else if (type == EA.ObjectType.otDiagram)
{
EA.Diagram diagram = (EA.Diagram)repository.GetTreeSelectedObject();
exporter.exportDiagram(repository, diagram, maxFile);
}
// Execute Transform
issues = new MAXValidator().validate(repository, maxFile, schFile, svrlFile);
}
private void criteriaListBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (criteriaListView.SelectedItems.Count > 0)
{
ListViewItem selected = criteriaListView.SelectedItems[0];
EA.Element ciElement = ((R2ModelElementHolder)selected.Tag).compilerInstructionEAElement;
EA.TaggedValue tvChangeNote = null;
if (ciElement != null)
{
tvChangeNote = (EA.TaggedValue)ciElement.TaggedValues.GetByName(R2Const.TV_CHANGENOTE);
}
ignoreEvent = true;
if (tvChangeNote != null)
{
textBox1.Text = tvChangeNote.Notes;
}
else
{
textBox1.Text = "";
}
ignoreEvent = false;
groupBox3.Show();
}
else
{
groupBox3.Hide();
}
}
private EA.Element CreateChildElement(CsvReader csv, EA.Package parent, String polarionID, Dictionary <String, EA.Element> map)
{
if (map.ContainsKey(polarionID))
{
EA.Element req = map[polarionID];
req.Name = csv["Title"];
req.Notes = csv["Description"] + "\r\n\r\n\r\nMotivation\r\n" + csv["Motivation"] + "\r\n\r\n\r\nNotes\r\n" + csv["Note"];
// No need to touch polarion ID
req.PackageID = parent.PackageID;
req.ParentID = 0; // Directly owned by this Package
// TODO: Need to fiddle with parents Elements list?
req.Update();
map.Remove(polarionID);
return(req);
}
else
{
EA.Element newReq = (EA.Element)parent.Elements.AddNew(csv["Title"], "Requirement");
newReq.Notes = csv["Description"] + "\r\n\r\n\r\nMotivation\r\n" + csv["Motivation"] + "\r\n\r\n\r\nNotes\r\n" + csv["Note"];
EA.TaggedValue polID = (EA.TaggedValue)newReq.TaggedValues.AddNew("PolarionID", "String");
polID.Value = polarionID;
polID.Update();
newReq.Update();
return(newReq);
}
}
/// <summary>
/// Create Tagged Value with 'Name'. It return the TaggedValue
/// </summary>
/// <param name="el"></param>
/// <param name="name"></param>
/// <returns></returns>
public static EA.TaggedValue CreateTaggedValue(EA.Element el, string name)
{
EA.TaggedValue tg = Add(el, name);
tg.Update();
return(tg);
}
private List <XElement> visitElement(EA.Element element)
{
List <XElement> xRows = new List <XElement>();
EA.TaggedValue tv = (EA.TaggedValue)element.TaggedValues.GetByName(R2Const.TV_OPTIONALITY);
if (tv != null)
{
if (!"SHALL".Equals(tv.Value))
{
string valName = string.Format("{0} {1}", element.Name, element.Notes);
string valType = element.Stereotype;
string valOptionality = tv.Value;
string valDependent = ((EA.TaggedValue)element.TaggedValues.GetByName(R2Const.TV_DEPENDENT)).Value;
string valConditional = ((EA.TaggedValue)element.TaggedValues.GetByName(R2Const.TV_CONDITIONAL)).Value;
xRows.Add(new XElement("Row",
new XElement("Field", new XAttribute("name", "CLASSGUID"), new XAttribute("value", element.ElementGUID)),
new XElement("Field", new XAttribute("name", "CLASSTYPE"), new XAttribute("value", element.Type)),
new XElement("Field", new XAttribute("name", "Name"), new XAttribute("value", valName)),
new XElement("Field", new XAttribute("name", "Type"), new XAttribute("value", valType)),
new XElement("Field", new XAttribute("name", "Optionality"), new XAttribute("value", valOptionality)),
new XElement("Field", new XAttribute("name", "Dependent"), new XAttribute("value", valDependent)),
new XElement("Field", new XAttribute("name", "Conditional"), new XAttribute("value", valConditional))
));
}
}
else
{
xRows.Add(new XElement("Row",
new XElement("Field", new XAttribute("name", "CLASSGUID"), new XAttribute("value", element.ElementGUID)),
new XElement("Field", new XAttribute("name", "CLASSTYPE"), new XAttribute("value", element.Type)),
new XElement("Field", new XAttribute("name", "Name"), new XAttribute("value", element.Name)),
new XElement("Field", new XAttribute("name", "Type"), new XAttribute("value", element.Stereotype))
));
// First the children that have no children
// then children that do have children
foreach (EA.Element childElement in element.Elements)
{
if (childElement.Elements.Count == 0)
{
visitElement(childElement).ForEach(xRow => xRows.Add(xRow));
}
}
foreach (EA.Element childElement in element.Elements)
{
if (childElement.Elements.Count > 0)
{
visitElement(childElement).ForEach(xRow => xRows.Add(xRow));
}
}
// If there are no childs, clear it
// This makes empty Header/Functions disappear from the results
if (xRows.Count == 1)
{
xRows.Clear();
}
}
return(xRows);
}
public void RefreshWebBrowser()
{
element = EAHelper.GetCurrentElement(currentRepo);
if (element != null)
{
field = element.TaggedValuesEx.GetByName("Markdown");
if (field == null)
{
field = element.TaggedValuesEx.AddNew("Markdown", "TaggedValue");
field.Value = "<memo>";
field.Update();
}
style = element.TaggedValuesEx.GetByName("MarkdownStyle");
if (style == null)
{
style = element.TaggedValuesEx.AddNew("MarkdownStyle", "TaggedValue");
style.Value = "";
style.Update();
}
skin = element.TaggedValuesEx.GetByName("PrettifySkin");
if (skin == null)
{
skin = element.TaggedValuesEx.AddNew("PrettifySkin", "TaggedValue");
skin.Value = "sunburst";
skin.Update();
}
}
StringBuilder sb = new StringBuilder();
sb.Append(String.Format("<link rel=\"stylesheet\" href=\"{0}\">", style.Value));
string s = skin.Value;
if (s != "default")
{
s = "?skin=" + s;
}
else
{
s = "";
}
string file = Path.GetTempPath() + "documentation.html";
using (FileStream fs = File.Open(file, FileMode.Create))
{
StreamWriter writer = new StreamWriter(fs);
writer.Write(Properties.Resources.HTMLHeader, sb.ToString(), s, md.Transform(field.Notes));
writer.Flush();
}
this.webBrowser1.Navigate(file);
}
/// <summary>
/// AddInformationClass
/// </summary>
/// <param name="strPackageName"></param>
/// <param name="strInfoClassName"></param>
/// <param name="strInfoClassDescription"></param>
private int AddInformationClass(EA.Package eaPackage, string strInfoClassName, string strInfoClassDescription, string strRequirements)
{
string strLogInfo = "Information Class: " + strInfoClassName;
int iErrorCount = 0;
EA.Element element1 = null;
EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);
if (eaPackage == null)
{
EAImporter.LogError(EAImporter.LogErrorLevel.A, "cannot add infomation class- package does not exist " + strInfoClassName);
iErrorCount++;
return(iErrorCount);
}
if (m_InfoClasses[strInfoClassName] != null)
{
EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
return(iErrorCount);
}
try
{
element1 = eaPackage.Elements.GetByName(strInfoClassName);
}
catch (Exception ex)
{
EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, ex.Message);
// EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, m_Repository.Stereotypes.GetLastError() + " : " + ex.Message);
}
if (element1 == null)
{
element1 = eaPackage.Elements.AddNew(strInfoClassName, "Class");
element1.Notes = strInfoClassDescription;
element1.Update();
EA.TaggedValue eaTgVal = element1.TaggedValues.AddNew("requirements", "TaggedValue");
eaTgVal.Value = strRequirements;
eaTgVal.Update();
eaPackage.Elements.Refresh();
EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);
m_InfoClasses[strInfoClassName] = element1;
}
else
{
m_InfoClasses[strInfoClassName] = element1;
EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
}
return(iErrorCount);
}
private static void transformConstraintToCSPElement(SQLElement eaElement2, SQLWrapperClasses.SQLRepository sqlRep, EA.Repository repository)
{
EA.Element eaElement = EAUtil.sqlEAObjectToOriginalObject(sqlRep, eaElement2) as EA.Element;
String result = repository.SQLQuery("select Diagram_ID from t_diagramobjects where Object_ID = " + eaElement.ElementID);
string diagramId = EAUtil.getXMLNodeContentFromSQLQueryString(result, "Diagram_ID")[0];
if (diagramId != "")
{
EA.Diagram diagram = repository.GetDiagramByID(int.Parse(diagramId));
EA.DiagramObject oldDiagObject = EAUtil.findDiagramObject(sqlRep, eaElement, diagram);
EA.Element ruleElement = repository.GetElementByID(diagram.ParentID);
if (ruleElement.Stereotype == TGGModelingMain.TggRuleStereotype)
{
List <EA.Connector> outgoingCons = new List <EA.Connector>();
foreach (EA.Connector con in eaElement.Connectors)
{
if (con.Stereotype == "ConstraintLink" && con.ClientID == eaElement.ElementID)
{
outgoingCons.Add(con);
}
}
EA.Element newCsp = ruleElement.Elements.AddNew("", Main.EAClassType) as EA.Element;
newCsp.Notes = eaElement.Notes;
newCsp.Stereotype = TGGModelingMain.CSPConstraintStereotype;
newCsp.Update();
EA.TaggedValue oldTag = EAUtil.findTaggedValue(eaElement, Main.MoflonExportTreeTaggedValueName);
if (oldTag != null)
{
EAUtil.setTaggedValueNotes(sqlRep, newCsp, oldTag.Name, oldTag.Notes);
}
EA.DiagramObject newDiagObject = diagram.DiagramObjects.AddNew("", Main.EAClassType) as EA.DiagramObject;
newDiagObject.ElementID = newCsp.ElementID;
newDiagObject.left = oldDiagObject.left;
newDiagObject.right = oldDiagObject.right;
newDiagObject.bottom = oldDiagObject.bottom;
newDiagObject.top = oldDiagObject.top;
newDiagObject.Update();
foreach (EA.Connector con in outgoingCons)
{
con.ClientID = newCsp.ElementID;
con.Update();
}
EAUtil.deleteDiagramObject(repository, diagram, eaElement);
EAUtil.deleteElement(eaElement, sqlRep);
}
}
}
private bool Update(EA.TaggedValue tgdVl)
{
bool result = tgdVl.Update();
if (result == false)
{
throw new Exception("Update Didn't work out properlly!!!");
}
return(result);
}
public static void SetTaggedValue(EA.Element element, string name, string value, string notes = null)
{
DeleteTaggedValue(element, name);
EA.TaggedValue tv = (EA.TaggedValue)element.TaggedValues.AddNew(name, "TaggedValue");
tv.Value = value;
if (notes != null)
{
tv.Notes = notes;
}
tv.Update();
}
/// <summary>
/// Удаляет TaggedValue из элемента
/// </summary>
/// <param name="element"></param>
/// <param name="tagName"></param>
public static void TaggedValueRemove(EA.Element element, string tagName)
{
for (short i = 0; i < element.TaggedValues.Count; i++)
{
EA.TaggedValue tag = element.TaggedValues.GetAt(i);
if (tag.Name == tagName)
{
element.TaggedValues.DeleteAt(i, true);
}
}
}
public static string GetTaggedValueNotes(EA.Element element, string name, string defaultValue = "")
{
EA.TaggedValue tv = (EA.TaggedValue)element.TaggedValues.GetByName(name);
if (tv != null)
{
return(tv.Notes);
}
else
{
return(defaultValue);
}
}
public static string GetTaggedValue(EA.Element element, string name, string defaultValue = "")
{
EA.TaggedValue tv = element.TaggedValues.Cast <EA.TaggedValue>().FirstOrDefault(t => name.Equals(t.Name) && !string.IsNullOrEmpty(t.Value));
if (tv != null)
{
return(tv.Value);
}
else
{
return(defaultValue);
}
}
private EA.TaggedValue GetSchematronTaggedValue(EA.Repository Repository)
{
EA.Package selectedPackage = Repository.GetTreeSelectedPackage();
EA.TaggedValue tvSchematronFile = (EA.TaggedValue)selectedPackage.Element.TaggedValues.GetByName(TV_MAX_SchematronFile);
if (tvSchematronFile == null)
{
tvSchematronFile = (EA.TaggedValue)selectedPackage.Element.TaggedValues.AddNew(TV_MAX_SchematronFile, "");
tvSchematronFile.Value = defaultSchematronFile;
tvSchematronFile.Update();
}
return(tvSchematronFile);
}
private EA.Element createEAClass(EA.Package package, EAClass eAClass)
{
EA.Element element = package.Elements.AddNew(eAClass.Name, "Class");
element.Stereotype = eAClass.StereoType;
if (EnumUtil.checkInEnumValues(eAClass.StereoType, typeof(PlatformDataTypeEnum)))
{
element.Stereotype = DATA_TYPE;
EA.TaggedValue taggedValue = element.TaggedValues.AddNew("IDLType", eAClass.StereoType);
taggedValue.Update();
}
return(element);
}
public static EA.TaggedValue setTaggedValueNotes(SQLRepository repository, EA.Package package, String name, String notes)
{
if (package.Element != null)
{
package.Element.TaggedValues.Refresh();
EA.TaggedValue aTag = setTaggedValue(repository, package, name, "<memo>");
aTag.Notes = notes;
aTag.Update();
return(aTag);
}
return(null);
}
/*
* Delete all tagged values with <name>.
*/
public static void DeleteTaggedValue(EA.Element element, string name)
{
for (short index = 0; index < element.TaggedValues.Count; index++)
{
EA.TaggedValue tv = (EA.TaggedValue)element.TaggedValues.GetAt(index);
if (name.Equals(tv.Name))
{
element.TaggedValues.Delete(index);
}
}
element.TaggedValues.Refresh();
}
private void addTaggedValue(EA.Element element, string name, string value)
{
if (!string.IsNullOrEmpty(value))
{
EA.TaggedValue tv = (EA.TaggedValue)element.TaggedValues.AddNew(name, "TaggedValue");
if (value.Length > 255)
{
value = "{truncated}" + value.Substring(0, 244);
}
tv.Value = value;
tv.Update();
}
}
public static EA.TaggedValue setTaggedValueNotes(SQLRepository repository, EA.Element element, String name, String notes)
{
element.TaggedValues.Refresh();
EA.Element actElement = element;
if (actElement is SQLElement)
{
actElement = repository.GetOriginalRepository().GetElementByID(element.ElementID);
}
EA.TaggedValue aTag = setTaggedValue(repository, actElement, name, "<memo>");
aTag.Notes = notes;
aTag.Update();
return(aTag);
}
public bool exportPackage(EA.Repository Repository, EA.Package package, string fileName)
{
this.Repository = Repository;
progress_max = 1;
progress.setup(progress_max);
progress.Show();
Repository.EnableCache = true;
// Add/update export metadata to the model
ModelType model = new ModelType();
model.exportDate = DateTime.Now.ToString();
// Now export selected package
objects = new List <ObjectType>();
relationships = new List <RelationshipType>();
visitSelectedPackage(package.PackageID);
model.objects = objects.ToArray();
model.relationships = relationships.ToArray();
progress.Close();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.NewLineChars = "\n";
XmlSerializer serializer = new XmlSerializer(typeof(ModelType));
using (XmlWriter writer = XmlWriter.Create(fileName, settings))
{
serializer.Serialize(writer, model);
}
// Add/update export metadata to the package
EA.TaggedValue tvExportDate = (EA.TaggedValue)package.Element.TaggedValues.GetByName("MAX::ExportDate");
if (tvExportDate == null)
{
tvExportDate = (EA.TaggedValue)package.Element.TaggedValues.AddNew("MAX::ExportDate", "");
}
tvExportDate.Value = DateTime.Now.ToString();
tvExportDate.Update();
EA.TaggedValue tvExportFile = (EA.TaggedValue)package.Element.TaggedValues.GetByName("MAX::ExportFile");
if (tvExportFile == null)
{
tvExportFile = (EA.TaggedValue)package.Element.TaggedValues.AddNew("MAX::ExportFile", "");
}
tvExportFile.Value = fileName;
tvExportFile.Update();
return(issues);
}
private EA.TaggedValue GetXsltTaggedValue(EA.Repository Repository)
{
// N.B. Model doesnot support tagged values!
EA.Package modelPackage = (EA.Package)Repository.Models.GetAt(0);
EA.Package viewPackage = (EA.Package)modelPackage.Packages.GetAt(0);
EA.TaggedValue tvXsltFile = (EA.TaggedValue)viewPackage.Element.TaggedValues.GetByName(TV_MAX_XSLTFile);
if (tvXsltFile == null)
{
tvXsltFile = (EA.TaggedValue)viewPackage.Element.TaggedValues.AddNew(TV_MAX_XSLTFile, "");
tvXsltFile.Value = defaultXsltFile;
tvXsltFile.Update();
}
return(tvXsltFile);
}
/// <summary>
/// Make a memo field out of the current TaggedValue
/// </summary>
/// <param name="el"></param>
/// <param name="name"></param>
/// <returns></returns>
public static EA.TaggedValue MakeMemo(EA.Element el, string name)
{
EA.TaggedValue tg = Add(el, name);
string value = tg.Value;
if (value.ToLower() == MemoString)
{
return(tg);
}
tg.Value = MemoString;
tg.Notes = value;
tg.Update();
return(tg);
}
/// <summary>
/// c) An enumeration type shall either have a tagged value agencyName or agencyIdentifier.
/// </summary>
/// <param name="context"></param>
/// <param name="package"></param>
/// <param name="enums"></param>
private void checkC554c(IValidationContext context, EA.Package p, Dictionary <Int32, EA.Element> enums)
{
foreach (KeyValuePair <Int32, EA.Element> e in enums)
{
//Check for agencyName or agencyIdentifier tagged value
EA.TaggedValue agencyName = Utility.getTaggedValue(e.Value, UPCC_TV.agencyName.ToString());
EA.TaggedValue agencyIdentifier = Utility.getTaggedValue(e.Value, UPCC_TV.agencyIdentifier.ToString());
if ((agencyName == null || agencyName.Value == "") && (agencyIdentifier == null || agencyIdentifier.Value == ""))
{
context.AddValidationMessage(new ValidationMessage("Missing agencyIdentifier/agencyName found in ENUM.", "An enumeration type shall either have a tagged value agencyName or agencyIdentifier. ENUM " + e.Value.Name + " found in ENUMLibrary " + p.Name + " does neither have an agencyName tagged value nor an agencyIdentifier tagged value.", "ENUMLibrary", ValidationMessage.errorLevelTypes.ERROR, p.PackageID));
}
}
}
public static void TaggedValueSet(EA.Element element, string tagName, string tagValue)
{
EA.TaggedValue tag = element.TaggedValues.GetByName(tagName);
if (tag == null)
{
tag = element.TaggedValues.AddNew(tagName, tagValue);
}
else
{
tag.Value = tagValue;
}
tag.Update();
//element.Update(); // is it needed?
}
private void recurseEaElements(EA.Element eaElement, Dictionary <string, EA.Element> eaElementDict)
{
foreach (EA.Element eaChildElement in eaElement.Elements)
{
EA.TaggedValue tvID = (EA.TaggedValue)eaChildElement.TaggedValues.GetByName(TV_MAX_ID);
if (tvID != null)
{
eaElementDict[tvID.Value.ToUpper()] = eaChildElement;
}
else
{
eaElementDict[eaChildElement.ElementID.ToString()] = eaChildElement;
}
recurseEaElements(eaChildElement, eaElementDict);
}
}
/// <summary>
/// Searches for a TaggedValue with the given name on the given Element
/// </summary>
/// <param name="element"></param>
/// <param name="name"></param>
/// <returns>the found TaggedValue or null</returns>
public static EA.TaggedValue findTaggedValue(EA.Element element, String name)
{
EA.TaggedValue aTag = null;
if (element != null)
{
element.TaggedValues.Refresh();
foreach (EA.TaggedValue aTaggi in element.TaggedValues)
{
if (aTaggi.Name == name)
{
aTag = aTaggi;
}
}
}
return(aTag);
}
public FindAndReplaceItemTagPackage(EA.TaggedValue tag)
: base(tag.Name, tag.Value)
{
_tag = tag;
}
public FindAndReplaceItemTagElement(EA.TaggedValue tag) :base(tag.Name, tag.Value)
{
_tag = tag;
}
public void UpdateWebBrowser()
{
StringBuilder sb = new StringBuilder();
sb.Append(String.Format("<link rel=\"stylesheet\" href=\"{0}\">", ((MarkdownStyle)this.toolstripStyleBox.SelectedItem).CSSLink));
sb.Append(String.Format("<link rel=\"stylesheet\" href=\"{0}\">", "https://cdnjs.cloudflare.com/ajax/libs/highlight.js/8.7/styles/default.min.css"));
//sb.Append("<script src=\"https://cdnjs.cloudflare.com/ajax/libs/highlight.js/8.7/highlight.min.js\"></script>");
string skin = this.toolStripSkinBox.SelectedItem != null ? this.toolStripSkinBox.SelectedItem.ToString() : "default";
if (skin != "default")
{
skin = "?skin=" + skin;
}
else
{
skin = "";
}
string file = Path.GetTempPath() + "documentation.html";
using (FileStream fs = File.Open(file, FileMode.Create))
{
StreamWriter writer = new StreamWriter(fs);
writer.Write(Properties.Resources.HTMLHeader, sb.ToString(),skin, md.Transform(this.markdownTextBox.Text));
writer.Flush();
}
this.webBrowser.Navigate(file);
//this.webBrowser.DocumentText =
// String.Format(Properties.Resources.HTMLHeader, sb.ToString(), md.Transform(this.markdownTextBox.Text));
}
