private void ApplyExchangeRequirement(DocExchangeApplicabilityEnum applicability, DocExchangeRequirementEnum requirement)
{
if (m_loadreq)
return;
// commit changes
DocTemplateUsage docUsage = (DocTemplateUsage)this.m_target;
foreach (ListViewItem lvi in this.listViewExchange.SelectedItems)
{
DocExchangeDefinition docExchange = (DocExchangeDefinition)lvi.Tag;
// find existing
bool exists = false;
foreach (DocExchangeItem docItem in docUsage.Exchanges)
{
if (docItem.Exchange == docExchange && docItem.Applicability == applicability)
{
// found it
if (requirement == DocExchangeRequirementEnum.NotRelevant)
{
// delete item (reduce size)
docUsage.Exchanges.Remove(docItem);
docItem.Delete();
}
else
{
// update item
docItem.Requirement = requirement;
}
exists = true;
break; // perf, and collection may have been modified
}
}
if (!exists)
{
DocExchangeItem docItem = new DocExchangeItem();
docItem.Exchange = docExchange;
docItem.Applicability = applicability;
docItem.Requirement = requirement;
docUsage.Exchanges.Add(docItem);
}
// update list
if (applicability == DocExchangeApplicabilityEnum.Import)
{
lvi.SubItems[1].Text = requirement.ToString();
}
else if (applicability == DocExchangeApplicabilityEnum.Export)
{
lvi.SubItems[2].Text = requirement.ToString();
}
}
}
private void toolStripMenuItemEditPaste_Click(object sender, EventArgs e)
{
if (this.treeView.Focused)
{
DocObject docSelect = this.treeView.SelectedNode.Tag as DocObject;
if (docSelect is DocSection && this.m_clipboard is DocSchema && this.m_clipboardNode.Parent.Tag is DocSection)
{
DocSchema docSchema = (DocSchema)this.m_clipboard;
DocSection docSectionNew = (DocSection)docSelect;
DocSection docSectionOld = (DocSection)this.m_clipboardNode.Parent.Tag;
docSectionOld.Schemas.Remove(docSchema);
docSectionNew.Schemas.Add(docSchema);
this.m_clipboardNode.Remove();
TreeNode tnSchema = this.LoadNode(this.treeView.SelectedNode, docSchema, docSchema.Name, true);
this.treeView.SelectedNode = tnSchema;
LoadNodeSchema(tnSchema, docSchema);
}
else if (docSelect is DocSchema && this.m_clipboard is DocPropertySet)
{
DocSchema schemaNew = (DocSchema)docSelect;
DocPropertySet psetOld = (DocPropertySet)this.m_clipboard;
if (this.m_clipboardCut)
{
if (this.m_clipboardNode.Parent.Parent.Tag is DocSchema)
{
DocSchema schemaOld = (DocSchema)this.m_clipboardNode.Parent.Parent.Tag;
schemaOld.PropertySets.Remove(psetOld);
schemaNew.PropertySets.Add(psetOld);
this.m_clipboardNode.Remove();
this.m_clipboardNode = null;
this.m_clipboard = null;
this.m_clipboardCut = false;
this.treeView.SelectedNode = this.LoadNode(this.treeView.SelectedNode.Nodes[4], psetOld, psetOld.Name, false);
}
}
else
{
// TODO...
}
}
else if (docSelect is DocPropertySet && this.m_clipboard is DocProperty)
{
DocPropertySet psetNew = (DocPropertySet)docSelect;
DocProperty propOld = (DocProperty)this.m_clipboard;
if (this.m_clipboardCut)
{
if (this.m_clipboardNode.Parent.Tag is DocPropertySet)
{
DocPropertySet psetOld = (DocPropertySet)this.m_clipboardNode.Parent.Tag;
psetOld.Properties.Remove(propOld);
psetNew.Properties.Add(propOld);
this.m_clipboardNode.Remove();
this.m_clipboardNode = null;
this.m_clipboard = null;
this.m_clipboardCut = false;
this.treeView.SelectedNode = this.LoadNode(this.treeView.SelectedNode, propOld, propOld.Name, false);
}
}
else
{
DocProperty propNew = new DocProperty();
propNew.Name = propOld.Name;
propNew.Documentation = propOld.Documentation;
propNew.PropertyType = propOld.PropertyType;
propNew.PrimaryDataType = propOld.PrimaryDataType;
propNew.SecondaryDataType = propOld.SecondaryDataType;
foreach(DocLocalization localOld in propOld.Localization)
{
DocLocalization localNew = new DocLocalization();
localNew.Name = localOld.Name;
localNew.Documentation = localOld.Documentation;
localNew.Category = localOld.Category;
localNew.Locale = localOld.Locale;
localNew.URL = localOld.URL;
propNew.Localization.Add(localNew);
}
this.treeView.SelectedNode = this.LoadNode(this.treeView.SelectedNode, propNew, propNew.Name, false);
}
}
else if (docSelect is DocConceptRoot && this.m_clipboard is DocTemplateUsage)
{
DocConceptRoot docRoot = (DocConceptRoot)docSelect;
DocTemplateUsage docSource = (DocTemplateUsage)this.m_clipboard;
DocTemplateUsage docTarget = new DocTemplateUsage();
docRoot.Concepts.Add(docTarget);
CopyTemplateUsage(docSource, docTarget);
this.treeView.SelectedNode = LoadNode(this.treeView.SelectedNode, docTarget, docTarget.Name, false);
}
else if (docSelect is DocModelView && this.m_clipboard is DocExchangeDefinition)
{
DocModelView docView = (DocModelView)docSelect;
DocExchangeDefinition docSource = (DocExchangeDefinition)this.m_clipboard;
DocExchangeDefinition docTarget = new DocExchangeDefinition();
docView.Exchanges.Add(docTarget);
docTarget.Name = docSource.Name;
docTarget.Documentation = docSource.Documentation;
docTarget.Author = docSource.Author;
docTarget.Copyright = docSource.Copyright;
docTarget.Owner = docSource.Owner;
docTarget.Icon = docSource.Icon;
// copy entity requirements if in same view
if (docView.Exchanges.Contains(docSource))
{
foreach (DocConceptRoot docRoot in docView.ConceptRoots)
{
foreach (DocTemplateUsage docConcept in docRoot.Concepts)
{
List<DocExchangeItem> listNew = new List<DocExchangeItem>();
foreach (DocExchangeItem docSourceER in docConcept.Exchanges)
{
if (docSourceER.Exchange == docSource)
{
DocExchangeItem docTargetER = new DocExchangeItem();
docTargetER.Exchange = docTarget;
docTargetER.Applicability = docSourceER.Applicability;
docTargetER.Requirement = docSourceER.Requirement;
listNew.Add(docTargetER);
}
}
foreach (DocExchangeItem docTargetER in listNew)
{
docConcept.Exchanges.Add(docTargetER);
}
}
}
}
this.treeView.SelectedNode = LoadNode(this.treeView.SelectedNode, docTarget, docTarget.Name, false);
}
}
else
{
this.textBoxHTML.Paste();
}
}
private static void ImportMvdConcept(Concept mvdNode, DocTemplateUsage docUse, DocProject docProject, Dictionary<Guid, ExchangeRequirement> mapExchange)
{
// special case for attributes
DocTemplateDefinition docTemplateDef = docProject.GetTemplate(mvdNode.Template.Ref);
if (docTemplateDef != null)
{
ImportMvdObject(mvdNode, docUse);
docUse.Definition = docTemplateDef;
docUse.Override = mvdNode.Override;
// exchange requirements
foreach (ConceptRequirement mvdReq in mvdNode.Requirements)
{
ExchangeRequirement mvdExchange = null;
if (mapExchange.TryGetValue(mvdReq.ExchangeRequirement, out mvdExchange))
{
DocExchangeItem docReq = new DocExchangeItem();
docUse.Exchanges.Add(docReq);
foreach (DocModelView docModel in docProject.ModelViews)
{
foreach (DocExchangeDefinition docAnno in docModel.Exchanges)
{
if (docAnno.Uuid.Equals(mvdReq.ExchangeRequirement))
{
docReq.Exchange = docAnno;
break;
}
}
}
docReq.Applicability = (DocExchangeApplicabilityEnum)mvdReq.Applicability;
switch(mvdReq.Requirement)
{
case RequirementEnum.Mandatory:
docReq.Requirement = DocExchangeRequirementEnum.Mandatory;
break;
case RequirementEnum.Recommended:
docReq.Requirement = DocExchangeRequirementEnum.Optional;
break;
case RequirementEnum.NotRelevant:
docReq.Requirement = DocExchangeRequirementEnum.NotRelevant;
break;
case RequirementEnum.NotRecommended:
docReq.Requirement = DocExchangeRequirementEnum.NotRecommended;
break;
case RequirementEnum.Excluded:
docReq.Requirement = DocExchangeRequirementEnum.Excluded;
break;
}
}
}
// rules as template items
if (mvdNode.TemplateRules != null)
{
docUse.Operator = (DocTemplateOperator)Enum.Parse(typeof(DocTemplateOperator), mvdNode.TemplateRules.Operator.ToString());
foreach (TemplateRule rule in mvdNode.TemplateRules.TemplateRule)
{
DocTemplateItem docItem = ImportMvdItem(rule, docProject, mapExchange);
docUse.Items.Add(docItem);
}
if (mvdNode.TemplateRules.InnerRules != null)
{
mvdNode.ToString();
}
}
}
}
private static void ImportMvdConcept(Concept mvdNode, DocTemplateUsage docUse, DocProject docProject, Dictionary<Guid, ExchangeRequirement> mapExchange)
{
// special case for attributes
DocTemplateDefinition docTemplateDef = docProject.GetTemplate(mvdNode.Template.Ref);
if (docTemplateDef != null)
{
// lookup use definition
docUse.Uuid = mvdNode.Uuid;
docUse.Name = mvdNode.Name;
docUse.Definition = docTemplateDef;
docUse.Override = mvdNode.Override;
// content
if (mvdNode.Definitions != null)
{
foreach (Definition mvdDef in mvdNode.Definitions)
{
if (mvdDef.Body != null)
{
docUse.Documentation = mvdDef.Body.Content;
}
}
}
// exchange requirements
foreach (ConceptRequirement mvdReq in mvdNode.Requirements)
{
ExchangeRequirement mvdExchange = null;
if (mapExchange.TryGetValue(mvdReq.ExchangeRequirement, out mvdExchange))
{
DocExchangeItem docReq = new DocExchangeItem();
docUse.Exchanges.Add(docReq);
foreach (DocModelView docModel in docProject.ModelViews)
{
foreach (DocExchangeDefinition docAnno in docModel.Exchanges)
{
if (docAnno.Uuid.Equals(mvdReq.ExchangeRequirement))
{
docReq.Exchange = docAnno;
break;
}
}
}
docReq.Applicability = (DocExchangeApplicabilityEnum)mvdReq.Applicability;
docReq.Requirement = (DocExchangeRequirementEnum)mvdReq.Requirement;
}
}
// rules as template items
if (mvdNode.TemplateRules != null)
{
docUse.Operator = (DocTemplateOperator)Enum.Parse(typeof(DocTemplateOperator), mvdNode.TemplateRules.Operator.ToString());
foreach (TemplateRule rule in mvdNode.TemplateRules.TemplateRule)
{
DocTemplateItem docItem = ImportMvdItem(rule, docProject, mapExchange);
docUse.Items.Add(docItem);
}
if (mvdNode.TemplateRules.InnerRules != null)
{
mvdNode.ToString();
}
}
}
}
