private void CreateAndAssignProperty(FormSelectProperty form, DocTemplateUsage propertyConcept, DocTemplateItem property, string psetName)
{
propertyConcept.Items.Add(property);
foreach (DocTemplateItem pset in this.Concept.Items)
{
if (pset.Name == psetName)
{
pset.Concepts.Add(propertyConcept);
//if (pset.Concepts.Count == 0)
//{
// pset.Concepts.Add(propertyConcept);
//}
//else
//{
// bool propertyAdded = false;
// foreach (DocTemplateUsage propConcept in pset.Concepts)
// {
// if (propConcept.Definition.Equals(propertyConcept.Definition))
// {
// propConcept.Items.Add(property);
// propertyAdded = true;
// }
// //if (form.SelectedProperty.PropertyType == prop.)
// }
// if (!propertyAdded)
// {
// pset.Concepts.Add(propertyConcept);
// }
//}
//this.Concept.Items.Add(propertySetProperty);
}
}
}
private void toolStripButtonMoveUp_Click(object sender, EventArgs e)
{
this.m_editcon = true;
int index = this.dataGridViewConceptRules.SelectedRows[0].Index;
DocTemplateUsage docUsage = (DocTemplateUsage)this.m_conceptleaf;
DocTemplateItem dti = docUsage.Items[index];
docUsage.Items.Insert(index - 1, dti);
docUsage.Items.RemoveAt(index + 1);
LoadUsage();
this.m_editcon = false;
}
private void comboBoxTemplate_SelectedIndexChanged(object sender, EventArgs e)
{
DocModelRuleEntity sel = this.comboBoxTemplate.SelectedItem as DocModelRuleEntity;
if (sel == null)
{
return;
}
if (sel.References.Count > 0)
{
DocTemplateDefinition docTemplateInner = sel.References[0];
DocTemplateUsage docConceptInner = ((DocTemplateItem)this.ConceptItem).RegisterParameterConcept(this.ConceptAttr.Identification, docTemplateInner);
this.ConceptLeaf = docConceptInner;
}
}
private void dataGridViewConceptRules_CellValidated(object sender, DataGridViewCellEventArgs e)
{
if (this.m_editcon)
{
return;
}
// format parameters
StringBuilder sb = new StringBuilder();
for (int i = 0; i < this.dataGridViewConceptRules.Columns.Count - 1; i++)
{
object val = this.dataGridViewConceptRules[i, e.RowIndex].Value;
if (val != null)
{
DataGridViewColumn col = this.dataGridViewConceptRules.Columns[i];
if (col.Tag is DocModelRule)
{
DocModelRule rule = (DocModelRule)col.Tag;
sb.Append(rule.Identification);
sb.Append("=");
sb.Append(val as string);
sb.Append(";");
}
else
{
this.ToString(); // description???
}
}
}
DocTemplateUsage docUsage = (DocTemplateUsage)this.m_conceptleaf;
if (docUsage.Items.Count > e.RowIndex)
{
DocTemplateItem docItem = docUsage.Items[e.RowIndex];
docItem.RuleParameters = sb.ToString();
object val = this.dataGridViewConceptRules[this.dataGridViewConceptRules.Columns.Count - 1, e.RowIndex].Value;
docItem.Documentation = val as string;
}
}
private void toolStripButtonTemplateRemove_Click(object sender, EventArgs e)
{
this.m_editcon = true;
int index = this.dataGridViewConceptRules.SelectedRows[0].Index;
DocTemplateUsage docUsage = (DocTemplateUsage)this.m_conceptleaf;
docUsage.Items.RemoveAt(index);
this.m_editcon = false;
LoadUsage();
/*
* this.m_editcon = true;
* if (this.dataGridViewConceptRules.Rows.Count > index)
* {
* this.dataGridViewConceptRules.Rows[index].Selected = true;
* }
* this.m_editcon = false;
*/
}
public void SetCell(int row, int col, CellValue val)
{
DocTemplateDefinition docTemplate = this.m_listTemplate[col];
DocConceptRoot docRoot = this.m_view.ConceptRoots[row];
DocTemplateUsage docConcept = null;
foreach (DocTemplateUsage docUsage in docRoot.Concepts)
{
if (docUsage.Definition == docTemplate)
{
docConcept = docUsage;
break;
}
}
if (docConcept == null)
{
docConcept = new DocTemplateUsage();
docRoot.Concepts.Add(docConcept);
docConcept.Definition = docTemplate;
}
DocExchangeRequirementEnum req = DocExchangeRequirementEnum.NotRelevant;
switch (val)
{
case CellValue.Mandatory:
req = DocExchangeRequirementEnum.Mandatory;
break;
case CellValue.Recommended:
req = DocExchangeRequirementEnum.Optional;
break;
}
docConcept.RegisterExchange(this.m_exchange, req);
}
public void SetCell(int row, int col, CellValue val)
{
DocTemplateDefinition docTemplate = this.m_listTemplate[row];
DocExchangeDefinition docExchange = this.m_view.Exchanges[col];
DocTemplateUsage docUsage = null;
foreach (DocTemplateUsage eachUsage in this.m_root.Concepts)
{
if (eachUsage.Definition == docTemplate)
{
docUsage = eachUsage;
break;
}
}
if (docUsage == null)
{
docUsage = new DocTemplateUsage();
this.m_root.Concepts.Add(docUsage);
docUsage.Definition = docTemplate;
}
DocExchangeRequirementEnum req = DocExchangeRequirementEnum.NotRelevant;
switch (val)
{
case CellValue.Required:
req = DocExchangeRequirementEnum.Mandatory;
break;
case CellValue.Optional:
req = DocExchangeRequirementEnum.Optional;
break;
}
docUsage.RegisterExchange(docExchange, req);
}
private void UpdateInheritance()
{
// hacky, but not worth making a general-purpose update notification
DocTemplateUsage docConcept = (DocTemplateUsage)this.m_conceptleaf;
TreeNode tn = (TreeNode)docConcept.Tag;
if (docConcept.Suppress)
{
tn.ImageIndex = 46;
tn.SelectedImageIndex = 46;
}
else if (docConcept.Override)
{
tn.ImageIndex = 45;
tn.SelectedImageIndex = 45;
}
else
{
tn.ImageIndex = 44;
tn.SelectedImageIndex = 44;
}
this.LoadInheritance();
}
private void UpdateConceptInheritance(ListViewItem lvi, DocTemplateUsage docConcept)
{
if(docConcept == null)
{
lvi.ImageIndex = 3;
}
else if (docConcept.Suppress)
{
lvi.ImageIndex = 2;
}
else if (docConcept.Override)
{
lvi.ImageIndex = 1;
}
else
{
lvi.ImageIndex = 0;
}
}
private static string FormatRequirements(DocTemplateUsage eachusage, DocModelView docModel, bool showexchanges)
{
if (eachusage.Exchanges == null || eachusage.Exchanges.Count == 0 && (eachusage.Items.Count == 0 || eachusage.Definition.Type == ""))
return null; // don't show if no rules or exchanges
if (!Properties.Settings.Default.Requirement)
return String.Empty;
StringBuilder sb = new StringBuilder();
if (showexchanges && docModel.Exchanges.Count > 0)
{
sb.AppendLine("<table class=\"exchange\">");
sb.AppendLine("<tr>");
sb.AppendLine("<th>Exchange</th>");
foreach (DocExchangeDefinition docExchange in docModel.Exchanges)
{
sb.Append("<th><a href=\"../../views/");
sb.Append(MakeLinkName(docModel));
sb.Append("/");
sb.Append(MakeLinkName(docExchange));
sb.Append(".htm\"><img width=\"16\" src=\"../../../img/mvd-");
sb.Append(MakeLinkName(docExchange));
sb.Append(".png\" title=\"");
sb.Append(docExchange.Name);
sb.Append("\"/></a></th>");
sb.AppendLine();
}
sb.AppendLine("</tr>");
sb.AppendLine("<tr>");
sb.AppendLine("<td>Import</td>");
foreach (DocExchangeDefinition docExchange in docModel.Exchanges)
{
sb.Append("<td>");
foreach (DocExchangeItem dti in eachusage.Exchanges)
{
if (dti.Exchange == docExchange && dti.Applicability == DocExchangeApplicabilityEnum.Import)
{
AppendRequirement(sb, dti.Requirement, 3);
}
}
sb.Append("</td>");
sb.AppendLine();
}
sb.AppendLine("</tr>");
sb.AppendLine("<tr>");
sb.AppendLine("<td>Export</td>");
foreach (DocExchangeDefinition docExchange in docModel.Exchanges)
{
sb.Append("<td>");
foreach (DocExchangeItem dti in eachusage.Exchanges)
{
if (dti.Exchange == docExchange && dti.Applicability == DocExchangeApplicabilityEnum.Export)
{
AppendRequirement(sb, dti.Requirement, 3);
}
}
sb.Append("</td>");
sb.AppendLine();
}
sb.AppendLine("</tr>");
sb.AppendLine("</table>");
}
return sb.ToString();
}
/// <summary>
/// Formats a template given an entity and optional template
/// </summary>
/// <param name="entity">The entity to format.</param>
/// <param name="usage">Use definition to format, or null for all use definitions for entity.</param>
/// <param name="iFigure">The last figure number used.</param>
/// /// <param name="iFigure">The last table number used.</param>
/// <returns></returns>
private static string FormatConcept(
DocProject docProject,
DocEntity entity,
DocConceptRoot root,
DocTemplateUsage usage,
Dictionary<string, DocObject> mapEntity,
Dictionary<string, string> mapSchema,
List<ContentRef> listFigures,
List<ContentRef> listTables)
{
if (usage.Definition == null)
return String.Empty;
StringBuilder sb = new StringBuilder();
string anchorid = MakeLinkName(usage.Definition);
// anchor
sb.Append("<a id=\"");
sb.Append(anchorid);
sb.Append("\" />");
sb.AppendLine();
// Caption
sb.Append("<p class=\"use-head\">");
sb.Append(usage.Definition.Name);
sb.Append("</p>");
sb.AppendLine();
// filter by particular model view
DocModelView docModelView = null;
if (root != null)
{
foreach (DocModelView docView in docProject.ModelViews)
{
if (docView.ConceptRoots.Contains(root))
{
docModelView = docView;
break;
}
}
}
// new (2.0): capture inherited properties too
DocTemplateItem[] listItems = FindTemplateItems(docProject, entity, usage.Definition, docModelView);
// add stock sentence
// typical values: "Material Constituents", "Documents", "Aggregation", "Nesting", "Representations"
// Usage of the <i>Material Constituents</i> concept is shown in Table XXXX.
// Usage of the <i>Nesting</i> concept is shown in Table XXXX.
// Usage of the <i>Aggregation</i> concept is shown in Table XXXX:
// get link of usage
string deflink = MakeLinkName(usage.Definition) + ".htm";
if (listItems.Length > 0)
{
listTables.Add(new ContentRef(entity.Name + " " + usage.Definition.Name, entity));
sb.Append("<p>The <a href=\"../../templates/");
sb.Append(deflink);
sb.Append("\">");
sb.Append(usage.Definition.Name);
sb.Append("</a> concept applies to this entity as shown in Table ");
sb.Append(listTables.Count);
sb.Append(".");
sb.AppendLine("<table>");
sb.AppendLine("<tr><td>");
string table = FormatConceptTable(docProject, docModelView, entity, root, usage, mapEntity, mapSchema);
sb.Append(table);
sb.AppendLine("</td></tr>");
sb.Append("<tr><td><p class=\"table\">Table ");
sb.Append(listTables.Count);
sb.Append(" — ");
sb.Append(entity.Name);
sb.Append(" ");
sb.Append(usage.Definition.Name);
sb.AppendLine("</td></tr></table>");
sb.AppendLine();
}
else
{
sb.Append("<p>The <a href=\"../../templates/");
sb.Append(deflink);
sb.Append("\">");
sb.Append(usage.Definition.Name);
sb.Append("</a> concept applies to this entity.</p>");
}
// add figure if it exists
string fig = FormatFigure(docProject, entity, usage.Definition, entity.Text, listFigures);
if (fig != null)
{
sb.Append(fig);
}
if (usage.Documentation != null)
{
sb.AppendLine(usage.Documentation); // special case if definition provides description, such as for classification
}
string req = FormatRequirements(usage, docModelView, true);
if (req != null)
{
sb.AppendLine(req);
}
sb.AppendLine("<br/><br/>");
return sb.ToString();
}
public static void UploadTemplateUsage(DocProject docProject, string baseurl, string sessionid, string parentid, DocTemplateUsage docConc)
{
// MVD Concept entry is a relationship in BSDD; contexts are exchanges
foreach (DocTemplateItem docItem in docConc.Items)
{
if (docItem.Concepts.Count == 0)
{
string code = docItem.GetParameterValue("Reference");
if (String.IsNullOrEmpty(code))
{
code = docItem.Name;
}
code = HttpUtility.UrlEncode(code);
string name = docItem.GetParameterValue("Name");
if (code != null && name != null)
{
// if no sub-concepts, then its a property
IfdBase ifdItem = CreateConcept(baseurl, sessionid, docItem, code, name, null, IfdConceptTypeEnum.PROPERTY);
CreateRelationship(baseurl, sessionid, parentid, ifdItem.guid, IfdRelationshipTypeEnum.ASSIGNS_PROPERTIES);
string paramval = docItem.GetParameterValue("Value");
if (!String.IsNullOrEmpty(paramval))
{
DocDefinition docDef = docProject.GetDefinition(paramval);
if (docDef != null)
{
// get the measure type
IfdBase ifdType = SearchConcept(baseurl, sessionid, docDef.Name, IfdConceptTypeEnum.MEASURE);
if (ifdType == null)
{
// create concept
ifdType = CreateConcept(baseurl, sessionid, docDef, docDef.Name, docDef.Name, null, IfdConceptTypeEnum.MEASURE);
}
CreateRelationship(baseurl, sessionid, ifdItem.guid, ifdType.guid, IfdRelationshipTypeEnum.ASSIGNS_MEASURES);
}
}
}
}
else
{
// otherwise its a nest
if (docItem.Name != null)
{
IfdBase ifdItem = CreateConcept(baseurl, sessionid, docItem, docItem.Name, docItem.Name, null, IfdConceptTypeEnum.NEST);
CreateRelationship(baseurl, sessionid, parentid, ifdItem.guid, IfdRelationshipTypeEnum.ASSIGNS_COLLECTIONS);
// recurse -- e.g. properties within property sets
foreach (DocTemplateUsage docInner in docItem.Concepts)
{
UploadTemplateUsage(docProject, baseurl, sessionid, ifdItem.guid, docInner);
}
}
}
}
}
private static void ExportMvdConcept(Concept mvdConceptLeaf, DocTemplateUsage docTemplateUsage)
{
if (docTemplateUsage.Definition == null)
return;
ExportMvdObject(mvdConceptLeaf, docTemplateUsage);
mvdConceptLeaf.Template = new TemplateRef();
mvdConceptLeaf.Template.Ref = docTemplateUsage.Definition.Uuid;
mvdConceptLeaf.Override = docTemplateUsage.Override;
// requirements
foreach (DocExchangeItem docExchangeRef in docTemplateUsage.Exchanges)
{
if (docExchangeRef.Exchange != null)
{
ConceptRequirement mvdRequirement = new ConceptRequirement();
mvdConceptLeaf.Requirements.Add(mvdRequirement);
switch (docExchangeRef.Applicability)
{
case DocExchangeApplicabilityEnum.Export:
mvdRequirement.Applicability = ApplicabilityEnum.Export;
break;
case DocExchangeApplicabilityEnum.Import:
mvdRequirement.Applicability = ApplicabilityEnum.Import;
break;
}
switch (docExchangeRef.Requirement)
{
case DocExchangeRequirementEnum.Excluded:
mvdRequirement.Requirement = RequirementEnum.Excluded;
break;
case DocExchangeRequirementEnum.Mandatory:
mvdRequirement.Requirement = RequirementEnum.Mandatory;
break;
case DocExchangeRequirementEnum.NotRelevant:
mvdRequirement.Requirement = RequirementEnum.NotRelevant;
break;
case DocExchangeRequirementEnum.Optional:
mvdRequirement.Requirement = RequirementEnum.Optional;
break;
default:
mvdRequirement.Requirement = RequirementEnum.Optional;
break;
}
mvdRequirement.ExchangeRequirement = docExchangeRef.Exchange.Uuid;
}
}
// rules
mvdConceptLeaf.TemplateRules = new TemplateRules();
mvdConceptLeaf.TemplateRules.Operator = (TemplateOperator)Enum.Parse(typeof(TemplateOperator), docTemplateUsage.Operator.ToString());
foreach (DocTemplateItem docRule in docTemplateUsage.Items)
{
TemplateRule mvdTemplateRule = ExportMvdItem(docRule);
mvdConceptLeaf.TemplateRules.TemplateRule.Add(mvdTemplateRule);
// using proposed mvdXML schema
if (docRule.Concepts.Count > 0)
{
mvdConceptLeaf.SubConcepts = new List<Concept>();
mvdTemplateRule.References = new List<Concept>();
foreach (DocTemplateUsage docInner in docRule.Concepts)
{
Concept mvdInner = new Concept();
mvdTemplateRule.References.Add(mvdInner);
ExportMvdConcept(mvdInner, docInner);
}
}
}
}
private void LoadNodeConcept(TreeNode tnOuter, DocTemplateUsage docConcept)
{
TreeNode tn = LoadNode(tnOuter, docConcept, docConcept.Definition != null ? docConcept.Definition.Name : docConcept.Name, false);
foreach (DocTemplateUsage docInner in docConcept.Concepts)
{
LoadNodeConcept(tn, docInner);
}
}
internal static void ExportMvdConcept(Concept mvdConceptLeaf, DocTemplateUsage docTemplateUsage, bool documentation)
{
if (docTemplateUsage.Definition == null)
return;
ExportMvdObject(mvdConceptLeaf, docTemplateUsage, documentation);
mvdConceptLeaf.Template = new TemplateRef();
mvdConceptLeaf.Template.Ref = docTemplateUsage.Definition.Uuid;
mvdConceptLeaf.Override = docTemplateUsage.Override;
// requirements
foreach (DocExchangeItem docExchangeRef in docTemplateUsage.Exchanges)
{
if (docExchangeRef.Exchange != null)
{
ConceptRequirement mvdRequirement = new ConceptRequirement();
if(mvdConceptLeaf.Requirements == null)
{
mvdConceptLeaf.Requirements = new List<ConceptRequirement>();
}
mvdConceptLeaf.Requirements.Add(mvdRequirement);
switch (docExchangeRef.Applicability)
{
case DocExchangeApplicabilityEnum.Export:
mvdRequirement.Applicability = ApplicabilityEnum.Export;
break;
case DocExchangeApplicabilityEnum.Import:
mvdRequirement.Applicability = ApplicabilityEnum.Import;
break;
}
switch (docExchangeRef.Requirement)
{
case DocExchangeRequirementEnum.Excluded:
mvdRequirement.Requirement = RequirementEnum.Excluded;
break;
case DocExchangeRequirementEnum.Mandatory:
mvdRequirement.Requirement = RequirementEnum.Mandatory;
break;
case DocExchangeRequirementEnum.NotRelevant:
mvdRequirement.Requirement = RequirementEnum.NotRelevant;
break;
case DocExchangeRequirementEnum.Optional:
mvdRequirement.Requirement = RequirementEnum.Recommended;
break;
default:
mvdRequirement.Requirement = RequirementEnum.NotRelevant;
break;
}
mvdRequirement.ExchangeRequirement = docExchangeRef.Exchange.Uuid;
}
}
// rules
if (docTemplateUsage.Items.Count > 0)
{
mvdConceptLeaf.TemplateRules = new TemplateRules();
mvdConceptLeaf.TemplateRules.Operator = (TemplateOperator)Enum.Parse(typeof(TemplateOperator), docTemplateUsage.Operator.ToString());
foreach (DocTemplateItem docRule in docTemplateUsage.Items)
{
TemplateRule mvdTemplateRule = ExportMvdItem(docRule);
mvdConceptLeaf.TemplateRules.TemplateRule.Add(mvdTemplateRule);
// using proposed mvdXML schema
if (false) // was removed from mvdXML final schema, so no longer possible to capture inner templates such as valid property names and values /// docRule.Concepts.Count > 0)
{
mvdConceptLeaf.SubConcepts = new List<Concept>();
mvdTemplateRule.References = new List<Concept>();
foreach (DocTemplateUsage docInner in docRule.Concepts)
{
Concept mvdInner = new Concept();
mvdTemplateRule.References.Add(mvdInner);
ExportMvdConcept(mvdInner, docInner, documentation);
}
}
}
}
}
private void BuildConceptForPropertySets(DocConceptRoot docRoot, DocTemplateDefinition docTemplatePset, DocPropertySet[] psets)
{
DocTemplateUsage docConcept = null;
// get any existing concept for psets
foreach (DocTemplateUsage docExistConcept in docRoot.Concepts)
{
if (docExistConcept.Definition == docTemplatePset)
{
docConcept = docExistConcept;
break;
}
}
if (psets.Length > 0)
{
if (docConcept == null)
{
docConcept = new DocTemplateUsage();
docConcept.Definition = docTemplatePset;
docRoot.Concepts.Add(docConcept);
LoadNode(this.treeView.SelectedNode, docConcept, docConcept.ToString(), false);
}
// remove old listings
for (int iExist = docConcept.Items.Count - 1; iExist >= 0; iExist--)
{
docConcept.Items[iExist].Delete();
docConcept.Items.RemoveAt(iExist);
}
foreach (DocPropertySet docPset in psets)
{
//if (docPset.PropertySetType == "PSET_OCCURRENCEDRIVEN" ||
// docPset.PropertySetType == "PSET_TYPEDRIVENOVERRIDE")
{
// add new, in order
DocTemplateItem docItemPset = new DocTemplateItem();
docItemPset.RuleParameters = "Name=" + docPset.Name + ";";
docConcept.Items.Add(docItemPset);
//... predefined type
//... properties...
int order = 0;
foreach (DocProperty docProp in docPset.Properties)
{
DocTemplateDefinition docInnerTemplate = null;
string suffix = String.Empty;
switch (docProp.PropertyType)
{
case DocPropertyTemplateTypeEnum.P_SINGLEVALUE:
docInnerTemplate = this.m_project.GetTemplate(new Guid("6655f6d0-29a8-47b8-8f3d-c9fce9c9a620"));
break;
case DocPropertyTemplateTypeEnum.P_BOUNDEDVALUE:
docInnerTemplate = this.m_project.GetTemplate(new Guid("3d67a2d2-761d-44d9-a09e-b7fbb1fa5632"));
break;
case DocPropertyTemplateTypeEnum.P_ENUMERATEDVALUE:
docInnerTemplate = this.m_project.GetTemplate(new Guid("c148a099-c351-43a8-9266-5f3de0b45a95"));
suffix = "Reference=" + docProp.SecondaryDataType.Substring(0, docProp.SecondaryDataType.IndexOf(':'));
break;
case DocPropertyTemplateTypeEnum.P_LISTVALUE:
docInnerTemplate = this.m_project.GetTemplate(new Guid("8e10b688-9179-4e3a-8db2-6abcaafe952d"));
break;
case DocPropertyTemplateTypeEnum.P_TABLEVALUE:
docInnerTemplate = this.m_project.GetTemplate(new Guid("35c947b0-6abc-4b13-8ec7-696ef2041721"));
suffix = "Reference=" + docProp.SecondaryDataType;
break;
case DocPropertyTemplateTypeEnum.P_REFERENCEVALUE:
docInnerTemplate = this.m_project.GetTemplate(new Guid("e20bc116-889b-46cc-b193-31b3e2376a8e"));
suffix = "Reference=" + docProp.SecondaryDataType;
break;
}
if (docInnerTemplate != null)
{
order++;
DocTemplateUsage docInnerConcept = docItemPset.RegisterParameterConcept("Properties", docInnerTemplate);
DocTemplateItem docInnerItem = new DocTemplateItem();
docInnerItem.RuleParameters = "Order=" + order + ";Name=" + docProp.Name + ";Value=" + docProp.PrimaryDataType + ";" + suffix;
docInnerConcept.Items.Add(docInnerItem);
}
}
}
}
}
}
private void toolStripMenuItemFileImport_Click(object sender, EventArgs e)
{
StringBuilder sbErrors = new StringBuilder();
DialogResult res = this.openFileDialogImport.ShowDialog(this);
if (res == DialogResult.OK)
{
List<DocSchema> importedschemas = new List<DocSchema>();
bool updateDescriptions = false;
if(this.openFileDialogImport.FileName.EndsWith(".vex"))
{
DialogResult resUpdate = MessageBox.Show(this, "Do you want to update the documentation? Click Yes to update documentation and definitions, or No to update just definitions.", "Import VEX", MessageBoxButtons.YesNoCancel);
if (resUpdate == System.Windows.Forms.DialogResult.Cancel)
return;
if (resUpdate == System.Windows.Forms.DialogResult.Yes)
updateDescriptions = true;
}
foreach (string filename in this.openFileDialogImport.FileNames)
{
string ext = System.IO.Path.GetExtension(filename).ToLower();
switch (ext)
{
case ".vex":
using (FormatSPF format = new FormatSPF(filename, SchemaVEX.Types, null))
{
format.Load();
// get the root schemata
SCHEMATA vexschema = null;
foreach (SEntity entity in format.Instances.Values)
{
if (entity is SCHEMATA)
{
vexschema = (SCHEMATA)entity;
break;
}
}
if (vexschema != null)
{
DocSchema schema = Program.ImportVex(vexschema, this.m_project, updateDescriptions);
importedschemas.Add(schema); // add schemas from multiple files first, process later
}
}
break;
case ".xml":
if (filename.Contains("Pset_"))
{
using (FormatXML format = new FormatXML(filename, typeof(PropertySetDef), "http://buildingSMART-tech.org/xml/psd/PSD_IFC4.xsd"))
{
format.Load();
PropertySetDef psd = (PropertySetDef)format.Instance;
string schema = null;
if (psd.Versions != null && psd.Versions.Count > 0)
{
schema = psd.Versions[0].schema;
}
if (String.IsNullOrEmpty(schema))
{
// guess the schema according to applicable type value
if (psd.ApplicableTypeValue != null)
{
string[] parts = psd.ApplicableTypeValue.Split(new char[] { '/', '[' });
TreeNode tnEntity = null;
if (this.m_mapTree.TryGetValue(parts[0].ToLowerInvariant(), out tnEntity))
{
DocSchema docschema = (DocSchema)tnEntity.Parent.Parent.Tag;
schema = docschema.Name;
}
}
}
if(schema == null)
{
schema = "IfcProductExtension";//fallback
}
// find the schema
TreeNode tn = null;
if (schema != null && this.m_mapTree.TryGetValue(schema.ToLowerInvariant(), out tn))
{
DocSchema docschema = (DocSchema)tn.Tag;
// find existing pset if applicable
DocPropertySet pset = docschema.RegisterPset(psd.Name);
// use hashed guid
if (pset.Uuid == Guid.Empty)
{
System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();
byte[] hash = md5.ComputeHash(Encoding.Default.GetBytes(pset.Name));
pset.Uuid = new Guid(hash);
}
pset.Name = psd.Name;
if (psd.Definition != null)
{
pset.Documentation = psd.Definition.Trim();
}
if (psd.ApplicableTypeValue != null)
{
pset.ApplicableType = psd.ApplicableTypeValue.Replace("Type", "").Replace("[PerformanceHistory]", ""); // organize at occurrences; use pset type to determine type applicability
}
// for now, rely on naming convention (better to capture in pset schema eventually)
if (psd.Name.Contains("PHistory")) // special naming convention
{
pset.PropertySetType = "PSET_PERFORMANCEDRIVEN";
}
else if (psd.Name.Contains("Occurrence"))
{
pset.PropertySetType = "PSET_OCCURRENCEDRIVEN";
}
else
{
pset.PropertySetType = "PSET_TYPEDRIVENOVERRIDE";
}
// import localized definitions
if (psd.PsetDefinitionAliases != null)
{
foreach (PsetDefinitionAlias pl in psd.PsetDefinitionAliases)
{
pset.RegisterLocalization(pl.lang, null, pl.Value);
}
}
foreach (PropertyDef subdef in psd.PropertyDefs)
{
DocProperty docprop = pset.RegisterProperty(subdef.Name);
Program.ImportPsdPropertyTemplate(subdef, docprop);
}
// add to Use Definition at applicable entity
#if false
if (pset.ApplicableType != null)
{
string[] apptypes = pset.ApplicableType.Split('/');
if (this.m_mapTree.TryGetValue(apptypes[0].ToLowerInvariant(), out tn))
{
DocEntity entity = (DocEntity)tn.Tag;
if (this.m_project.ModelViews.Count == 0)
{
// must have at least one model view for populating property set links
this.m_project.ModelViews.Add(new DocModelView());
}
foreach (DocModelView docView in this.m_project.ModelViews)
{
DocConceptRoot docRoot = null;
foreach (DocConceptRoot eachRoot in docView.ConceptRoots)
{
if (eachRoot.ApplicableEntity == entity)
{
docRoot = eachRoot;
break;
}
}
if (docRoot == null)
{
docRoot = new DocConceptRoot();
docRoot.ApplicableEntity = entity;
docView.ConceptRoots.Add(docRoot);
}
// find the pset template
DocTemplateUsage templateuse = null;
foreach (DocTemplateUsage eachtemplateuse in docRoot.Concepts)
{
if (eachtemplateuse.Definition != null && eachtemplateuse.Definition.Name.StartsWith("Property"))
{
templateuse = eachtemplateuse;
break;
}
}
DocTemplateDefinition docdefpset = this.m_project.GetTemplate(new Guid("f74255a6-0c0e-4f31-84ad-24981db62461"));
if (docdefpset != null)
{
// if no template, add it
if (templateuse == null)
{
// get the pset template
templateuse = new DocTemplateUsage();
docRoot.Concepts.Add(templateuse);
templateuse.Definition = docdefpset;
}
DocTemplateItem templateitem = new DocTemplateItem();
templateuse.Items.Add(templateitem);
templateitem.RuleInstanceID = "IfcPropertySet";
if (apptypes.Length == 2)
{
templateitem.RuleParameters += "PredefinedType=" + apptypes[1] + ";";
}
templateitem.RuleParameters += "Name=" + pset.Name + ";";
templateitem.RuleParameters += "TemplateType=" + pset.PropertySetType + ";";
// don't include documentation -- too wordy templateitem.Documentation = pset.Documentation;
}
}
}
else
{
sbErrors.Append(System.IO.Path.GetFileNameWithoutExtension(filename) + ": unrecognized ApplicableTypeValue; ");
}
}
#endif
}
else
{
sbErrors.Append(System.IO.Path.GetFileNameWithoutExtension(filename) + ": unrecognized schema; ");
}
}
}
else if (filename.Contains("Qto_"))
{
using (FormatXML format = new FormatXML(filename, typeof(QtoSetDef)))
{
format.Load();
QtoSetDef qto = (QtoSetDef)format.Instance;
string schema = qto.Versions[0].schema;
TreeNode tn = null;
if (schema != null && this.m_mapTree.TryGetValue(schema.ToLowerInvariant(), out tn))
{
DocSchema docschema = (DocSchema)tn.Tag;
// find existing pset if applicable
DocQuantitySet qset = docschema.RegisterQset(qto.Name);
// use hashed guid
if (qset.Uuid == Guid.Empty)
{
System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();
byte[] hash = md5.ComputeHash(Encoding.Default.GetBytes(qset.Name));
qset.Uuid = new Guid(hash);
}
// everything is currently named "Base Quantities"; get name from file instead; e.g. "Qto_Beam"
qset.Name = System.IO.Path.GetFileNameWithoutExtension(filename);
qset.Documentation = qto.Definition;
qset.ApplicableType = qto.ApplicableClasses[0].Value;
// fix: remove "Type"
if (qset.ApplicableType.EndsWith("Type"))
{
qset.ApplicableType = qset.ApplicableType.Substring(0, qset.ApplicableType.Length - 4);
}
// import localized definitions
if (qto.QtoDefinitionAliases != null)
{
foreach (QtoDefinitionAlias pl in qto.QtoDefinitionAliases)
{
qset.RegisterLocalization(pl.lang, null, pl.Value);
}
}
foreach (QtoDef qtodef in qto.QtoDefs)
{
DocQuantity q = qset.RegisterQuantity(qtodef.Name);
q.Documentation = qtodef.Definition;
switch (qtodef.QtoType)
{
case "IfcQuantityCount":
q.QuantityType = DocQuantityTemplateTypeEnum.Q_COUNT;
break;
case "IfcQuantityLength":
q.QuantityType = DocQuantityTemplateTypeEnum.Q_LENGTH;
break;
case "IfcQuantityArea":
q.QuantityType = DocQuantityTemplateTypeEnum.Q_AREA;
break;
case "IfcQuantityVolume":
q.QuantityType = DocQuantityTemplateTypeEnum.Q_VOLUME;
break;
case "IfcQuantityWeight":
q.QuantityType = DocQuantityTemplateTypeEnum.Q_WEIGHT;
break;
case "IfcQuantityTime":
q.QuantityType = DocQuantityTemplateTypeEnum.Q_TIME;
break;
}
foreach (NameAlias namealias in qtodef.NameAliases)
{
string desc = null;
foreach (DefinitionAlias docalias in qtodef.DefinitionAliases)
{
if (docalias.lang.Equals(namealias.lang))
{
desc = docalias.Value;
break;
}
}
q.RegisterLocalization(namealias.lang, namealias.Value, desc);
}
}
// map to use definition
if (this.m_mapTree.TryGetValue(qset.ApplicableType.ToLowerInvariant(), out tn))
{
DocEntity entity = (DocEntity)tn.Tag;
if (this.m_project.ModelViews.Count == 0)
{
// must have at least one model view for populating property set links
this.m_project.ModelViews.Add(new DocModelView());
}
foreach (DocModelView docView in this.m_project.ModelViews)
{
DocConceptRoot docRoot = null;
foreach (DocConceptRoot eachRoot in docView.ConceptRoots)
{
if (eachRoot.ApplicableEntity == entity)
{
docRoot = eachRoot;
break;
}
}
if (docRoot == null)
{
docRoot = new DocConceptRoot();
docRoot.ApplicableEntity = entity;
docView.ConceptRoots.Add(docRoot);
}
// find the qset template
DocTemplateUsage templateuse = null;
foreach (DocTemplateUsage eachtemplateuse in docRoot.Concepts)
{
if (eachtemplateuse.Definition.Name.StartsWith("Quantity"))
{
templateuse = eachtemplateuse;
break;
}
}
// if no template, add it
if (templateuse == null)
{
// get the pset template
templateuse = new DocTemplateUsage();
docRoot.Concepts.Add(templateuse);
templateuse.Definition = this.m_project.GetTemplate(new Guid("6652398e-6579-4460-8cb4-26295acfacc7"));
}
if (templateuse != null)
{
DocTemplateItem templateitem = new DocTemplateItem();
templateuse.Items.Add(templateitem);
templateitem.RuleInstanceID = "IfcElementQuantity";
templateitem.RuleParameters = "Name=" + qset.Name + ";TemplateType=QTO_OCCURRENCEDRIVEN;";
}
}
}
}
else
{
sbErrors.Append(System.IO.Path.GetFileNameWithoutExtension(filename) + ": unrecognized schema; ");
}
}
}
else if (filename.Contains("ifcXML"))
{
using (FormatXML format = new FormatXML(filename, typeof(configuration), null, SchemaCNF.Prefixes))
{
try
{
this.m_loading = true; // prevent constructors from registering instances (xml serializer instantiates)
format.Load();
DocModelView docView = null;
using(FormSelectView form = new FormSelectView(this.m_project, null))
{
if(form.ShowDialog(this) == System.Windows.Forms.DialogResult.OK && form.Selection != null && form.Selection.Length == 1)
{
docView = form.Selection[0];
}
}
configuration cnf = (configuration)format.Instance;
Program.ImportCnf(cnf, this.m_project, docView);
}
catch (Exception xx)
{
MessageBox.Show(this, xx.Message, "Import CNFXML");
}
finally
{
this.m_loading = false;
}
}
}
break;
case ".mvdxml":
this.ImportMVD(filename);
break;
case ".txt":
using (FormatCSV format = new FormatCSV(filename))
{
try
{
format.Instance = this.m_project;
format.Load();
}
catch (System.Exception xx)
{
MessageBox.Show(this, xx.Message, "Import CSV");
}
}
break;
case ".ifd":
using (FormatIFD format = new FormatIFD(filename))
{
try
{
format.Instance = this.m_project;
format.Load();
}
catch (System.Exception xx)
{
MessageBox.Show(this, xx.Message, "Import IFD");
}
}
break;
case ".xsd":
using (FormatXML format = new FormatXML(filename, typeof(IfcDoc.Schema.XSD.schema), IfcDoc.Schema.XSD.SchemaXsd.DefaultNamespace))
{
try
{
format.Load();
DocSchema docSchema = Program.ImportXsd((IfcDoc.Schema.XSD.schema)format.Instance, this.m_project);
if(docSchema.Name == null)
{
docSchema.Name = System.IO.Path.GetFileNameWithoutExtension(filename);
}
}
catch(System.Exception xx)
{
MessageBox.Show(this, xx.Message, "Import XSD");
}
}
break;
}
}
// load tree before generating use definitions
this.LoadTree();
// load tree again to pick up definitions
if (importedschemas.Count > 0)
{
LoadTree();
}
}
if (sbErrors.Length > 0)
{
MessageBox.Show(this, "Import succeeded, however one or more definitions have missing or incorrect information:\r\n" + sbErrors.ToString(), "Import Errors");
}
}
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();
}
}
/// <summary>
/// Recursively copies concepts
/// </summary>
/// <param name="docSource"></param>
/// <param name="docTarget"></param>
private static void CopyTemplateUsage(DocTemplateUsage docSource, DocTemplateUsage docTarget)
{
docTarget.Name = docSource.Name;
docTarget.Documentation = docSource.Documentation;
docTarget.Author = docSource.Author;
docTarget.Copyright = docSource.Copyright;
docTarget.Owner = docSource.Owner;
docTarget.Definition = docSource.Definition;
foreach (DocTemplateItem docSourceItem in docSource.Items)
{
DocTemplateItem docTargetItem = new DocTemplateItem();
docTarget.Items.Add(docTargetItem);
docTargetItem.Name = docSourceItem.Name;
docTargetItem.Documentation = docSourceItem.Documentation;
docTargetItem.RuleInstanceID = docSourceItem.RuleInstanceID;
docTargetItem.RuleParameters = docSourceItem.RuleParameters;
docTargetItem.Optional = docSourceItem.Optional;
foreach (DocTemplateUsage docSourceInner in docSourceItem.Concepts)
{
DocTemplateUsage docTargetInner = new DocTemplateUsage();
docTargetItem.Concepts.Add(docTargetInner);
CopyTemplateUsage(docSourceInner, docTargetInner);
}
}
}
private void LoadNodeConcept(TreeNode tnOuter, DocTemplateUsage docConcept)
{
TreeNode tn = LoadNode(tnOuter, docConcept, docConcept.ToString(), false);
foreach (DocTemplateUsage docInner in docConcept.Concepts)
{
LoadNodeConcept(tn, docInner);
}
}
private void CompileConcept(DocTemplateUsage concept, DocModelView view, TypeBuilder tb)
{
bool includeconcept = true;
if (this.m_exchange != null)
{
includeconcept = false;
foreach (DocExchangeItem ei in concept.Exchanges)
{
if (ei.Exchange == this.m_exchange && ei.Applicability == DocExchangeApplicabilityEnum.Export &&
(ei.Requirement == DocExchangeRequirementEnum.Mandatory || ei.Requirement == DocExchangeRequirementEnum.Optional))
{
includeconcept = true;
}
}
}
// bool ConceptTemplateA([Parameter1, ...]);
// {
// // for loading reference value:
// .ldfld [AttributeRule]
// .ldelem [Index] // for collection, get element by index
// .castclass [EntityRule] for entity, cast to expected type;
// // for object graphs, repeat the above instructions to load value
//
// for loading constant:
// .ldstr 'value'
//
// for comparison functions:
// .cge
//
// for logical aggregations, repeat each item, pushing 2 elements on stack, then run comparison
// .or
//
// return the boolean value on the stack
// .ret;
// }
// bool[] ConceptA()
// {
// bool[] result = new bool[2];
//
// if parameters are specified, call for each template rule; otherwise call just once
// result[0] = ConceptTemplateA([Parameter1, ...]); // TemplateRule#1
// result[1] = ConceptTemplateA([Parameter1, ...]); // TemplateRule#2
//
// return result;
// }
// compile a method for the template definition, where parameters are passed to the template
if (includeconcept && concept.Definition != null)
{
MethodInfo methodTemplate = this.RegisterTemplate(concept.Definition);
// verify that definition is compatible with entity (user error)
if (methodTemplate != null && methodTemplate.DeclaringType.IsAssignableFrom(tb))
{
string methodname = DocumentationISO.MakeLinkName(view) + "_" + DocumentationISO.MakeLinkName(concept.Definition);
MethodBuilder method = tb.DefineMethod(methodname, MethodAttributes.Public, CallingConventions.HasThis, typeof(bool[]), null);
ILGenerator generator = method.GetILGenerator();
DocModelRule[] parameters = concept.Definition.GetParameterRules();
if (parameters != null && parameters.Length > 0)
{
// allocate array of booleans, store as local variable
generator.DeclareLocal(typeof(bool[]));
generator.Emit(OpCodes.Ldc_I4, concept.Items.Count);
generator.Emit(OpCodes.Newarr, typeof(bool));
generator.Emit(OpCodes.Stloc_0);
// call for each item with specific parameters
for (int row = 0; row < concept.Items.Count; row++)
{
DocTemplateItem docItem = concept.Items[row];
generator.Emit(OpCodes.Ldloc_0); // push the array object onto the stack, for storage later
generator.Emit(OpCodes.Ldc_I4, row); // push the array index onto the stack for storage later
generator.Emit(OpCodes.Ldarg_0); // push the *this* pointer for the IFC object instance
// push parameters onto stack
for (int col = 0; col < parameters.Length; col++)
{
DocModelRule docParam = parameters[col];
string paramvalue = docItem.GetParameterValue(docParam.Identification);
if (paramvalue != null)
{
DocDefinition docParamType = concept.Definition.GetParameterType(docParam.Identification, this.m_definitions);
if (docParamType is DocDefined)
{
DocDefined docDefined = (DocDefined)docParamType;
switch (docDefined.DefinedType)
{
case "INTEGER":
{
Int64 ival = 0;
Int64.TryParse(paramvalue, out ival);
generator.Emit(OpCodes.Ldc_I8, ival);
generator.Emit(OpCodes.Box);
}
break;
case "REAL":
{
Double dval = 0.0;
Double.TryParse(paramvalue, out dval);
generator.Emit(OpCodes.Ldc_R8, dval);
generator.Emit(OpCodes.Box);
}
break;
case "STRING":
generator.Emit(OpCodes.Ldstr, paramvalue);
break;
default:
generator.Emit(OpCodes.Ldstr, paramvalue);
break;
}
}
else
{
// assume string
generator.Emit(OpCodes.Ldstr, paramvalue);
}
}
else
{
generator.Emit(OpCodes.Ldnull);
}
}
generator.Emit(OpCodes.Call, methodTemplate); // call the validation function for the concept template
generator.Emit(OpCodes.Stelem_I1); // store the result (bool) into an array slot
}
// return the array of boolean results
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ret);
}
else
{
// allocate array of booleans, store as local variable
generator.DeclareLocal(typeof(bool[]));
generator.Emit(OpCodes.Ldc_I4, 1);
generator.Emit(OpCodes.Newarr, typeof(bool));
generator.Emit(OpCodes.Stloc_0);
generator.Emit(OpCodes.Ldloc_0); // push the array object onto the stack, for storage later
generator.Emit(OpCodes.Ldc_I4, 0); // push the array index onto the stack for storage later
// call once
generator.Emit(OpCodes.Ldarg_0); // push the *this* pointer for the IFC object instance
generator.Emit(OpCodes.Call, methodTemplate); // call the validation function for the concept template
generator.Emit(OpCodes.Stelem_I1); // store the result (bool) into an array slot
// return the array of boolean results
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ret);
}
}
else
{
System.Diagnostics.Debug.WriteLine("Incompatible template: " + tb.Name + " - " + concept.Definition.Name);
}
}
// recurse
foreach (DocTemplateUsage docChild in concept.Concepts)
{
CompileConcept(docChild, view, tb);
}
}
public void SetCell(int row, int col, CellValue val)
{
DocTemplateDefinition docTemplate = this.m_listTemplate[col];
DocConceptRoot docRoot = this.m_view.ConceptRoots[row];
DocTemplateUsage docConcept = null;
foreach (DocTemplateUsage docUsage in docRoot.Concepts)
{
if (docUsage.Definition == docTemplate)
{
docConcept = docUsage;
break;
}
}
if (docConcept == null)
{
docConcept = new DocTemplateUsage();
docRoot.Concepts.Add(docConcept);
docConcept.Definition = docTemplate;
}
DocExchangeRequirementEnum req = DocExchangeRequirementEnum.NotRelevant;
switch (val)
{
case CellValue.Required:
req = DocExchangeRequirementEnum.Mandatory;
break;
case CellValue.Optional:
req = DocExchangeRequirementEnum.Optional;
break;
}
docConcept.RegisterExchange(this.m_exchange, req);
}
private void toolStripMenuItemInsertUseDefinition_Click(object sender, EventArgs e)
{
DocConceptRoot docConceptRoot = this.treeView.SelectedNode.Tag as DocConceptRoot;
if (docConceptRoot == null)
return;
DocEntity docEntity = (DocEntity)this.treeView.SelectedNode.Parent.Tag as DocEntity;
if (docEntity == null)
return;
// browse for template
using (FormSelectTemplate form = new FormSelectTemplate(null, this.m_project, docEntity))
{
DialogResult res = form.ShowDialog(this);
if (res == DialogResult.OK && form.SelectedTemplate != null)
{
// create
DocTemplateUsage docUsage = new DocTemplateUsage();
docConceptRoot.Concepts.Add(docUsage);
docUsage.Definition = form.SelectedTemplate;
docUsage.Name = docUsage.Definition.Name;
this.treeView.SelectedNode = LoadNode(this.treeView.SelectedNode, docUsage, docUsage.Name, false);
}
}
}
private void LoadUsage()
{
m_editcon = true;
this.dataGridViewConceptRules.Rows.Clear();
this.dataGridViewConceptRules.Columns.Clear();
if (this.m_conceptroot == null || this.m_conceptleaf == null)// || !this.m_conceptroot.Concepts.Contains(this.m_conceptleaf))
{
return;
}
LoadInheritance();
DocTemplateUsage docUsage = (DocTemplateUsage)this.m_conceptleaf;
if (docUsage.Definition != null)
{
this.m_columns = docUsage.Definition.GetParameterRules();
foreach (DocModelRule rule in this.m_columns)
{
DataGridViewColumn column = new DataGridViewColumn();
column.Tag = rule;
column.HeaderText = rule.Identification;
column.ValueType = typeof(string);//?
column.CellTemplate = new DataGridViewTextBoxCell();
column.Width = 200;
if (rule.IsCondition())
{
column.HeaderText += "?";
}
// override cell template for special cases
DocConceptRoot docConceptRoot = (DocConceptRoot)this.m_conceptroot;
DocEntity docEntity = this.m_project.GetDefinition(docUsage.Definition.Type) as DocEntity;// docConceptRoot.ApplicableEntity;
foreach (DocModelRuleAttribute docRule in docUsage.Definition.Rules)
{
DocAttribute docAttribute = docEntity.ResolveParameterAttribute(docRule, rule.Identification, m_map);
if (docAttribute != null)
{
DocObject docDef = null;
if (this.m_map.TryGetValue(docAttribute.DefinedType, out docDef) && docDef is DocDefinition)
{
if (docDef is DocEnumeration)
{
DocEnumeration docEnum = (DocEnumeration)docDef;
DataGridViewComboBoxCell cell = new DataGridViewComboBoxCell();
cell.MaxDropDownItems = 32;
cell.DropDownWidth = 200;
// add blank item
cell.Items.Add(String.Empty);
foreach (DocConstant docConst in docEnum.Constants)
{
cell.Items.Add(docConst.Name);
}
column.CellTemplate = cell;
}
else if (docDef is DocEntity || docDef is DocSelect)
{
// button to launch dialog for picking entity
DataGridViewButtonCell cell = new DataGridViewButtonCell();
cell.Tag = docDef;
column.CellTemplate = cell;
}
}
else if (docAttribute.DefinedType != null && (docAttribute.DefinedType.Equals("LOGICAL") || docAttribute.DefinedType.Equals("BOOLEAN")))
{
DataGridViewComboBoxCell cell = new DataGridViewComboBoxCell();
cell.MaxDropDownItems = 4;
cell.DropDownWidth = 200;
// add blank item
cell.Items.Add(String.Empty);
cell.Items.Add(Boolean.FalseString);
cell.Items.Add(Boolean.TrueString);
column.CellTemplate = cell;
}
}
}
this.dataGridViewConceptRules.Columns.Add(column);
}
}
// add description column
DataGridViewColumn coldesc = new DataGridViewColumn();
coldesc.HeaderText = "Description";
coldesc.ValueType = typeof(string);//?
coldesc.CellTemplate = new DataGridViewTextBoxCell();
coldesc.Width = 400;
this.dataGridViewConceptRules.Columns.Add(coldesc);
foreach (DocTemplateItem item in docUsage.Items)
{
string[] values = new string[this.dataGridViewConceptRules.Columns.Count];
if (this.m_columns != null)
{
for (int i = 0; i < this.m_columns.Length; i++)
{
string parmname = this.m_columns[i].Identification;
string val = item.GetParameterValue(parmname);
if (val != null)
{
values[i] = val;
}
}
}
values[values.Length - 1] = item.Documentation;
int row = this.dataGridViewConceptRules.Rows.Add(values);
this.dataGridViewConceptRules.Rows[row].Tag = item;
if (item.Optional)
{
this.dataGridViewConceptRules.Rows[row].DefaultCellStyle.ForeColor = Color.Gray;
}
}
if (this.dataGridViewConceptRules.SelectedCells.Count > 0)
{
this.dataGridViewConceptRules.SelectedCells[0].Selected = false;
}
m_editcon = false;
}
/// <summary>
/// Recursively validates a concept and all referenced concepts
/// </summary>
/// <param name="docUsage">The concept to validate</param>
/// <param name="docView">The model view containing the concept</param>
/// <param name="reqInherit">For a referenced concept, indicates requirements defined by the referencing (outer) concept.</param>
/// <param name="typeEntity">The compiled type corresponding to entity.</param>
/// <param name="list">List of entities to test for concept.</param>
/// <param name="sb">String builder to append for reporting results.</param>
/// <param name="typemap">Map of identifiers to compiled types</param>
/// <param name="grandtotalpass">The total tests passing (less than or equal to total tests executed).</param>
/// <param name="grandtotallist">The total tests executed.</param>
private void ValidateConcept(DocTemplateUsage docUsage, DocModelView docView, DocExchangeRequirementEnum reqInherit, Type typeEntity, List<SEntity> list, StringBuilder sb, Dictionary<string, Type> typemap, ref int grandtotalpass, ref int grandtotalskip, ref int grandtotallist)
{
if (docUsage.Definition == null || docUsage.Definition.IsDisabled || docUsage.Suppress)
return;
DocExchangeRequirementEnum req = DocExchangeRequirementEnum.NotRelevant;
bool includeconcept = true;
if (this.m_filterexchange != null)
{
includeconcept = false;
foreach (DocExchangeItem ei in docUsage.Exchanges)
{
if (ei.Exchange == this.m_filterexchange && ei.Applicability == DocExchangeApplicabilityEnum.Export &&
(ei.Requirement == DocExchangeRequirementEnum.Mandatory || ei.Requirement == DocExchangeRequirementEnum.Optional))
{
includeconcept = true;
req = ei.Requirement;
}
}
}
else
{
// check net requirement if mandatory for any exchange
foreach (DocExchangeItem docExchangeItem in docUsage.Exchanges)
{
switch (docExchangeItem.Requirement)
{
case DocExchangeRequirementEnum.Mandatory:
req = DocExchangeRequirementEnum.Mandatory;
break;
case DocExchangeRequirementEnum.Optional:
if (req == DocExchangeRequirementEnum.NotRelevant)
{
req = DocExchangeRequirementEnum.Optional;
}
break;
case DocExchangeRequirementEnum.Excluded:
if (req == DocExchangeRequirementEnum.NotRelevant)
{
req = DocExchangeRequirementEnum.Excluded;
}
break;
}
}
}
if (req == DocExchangeRequirementEnum.NotRelevant)
{
req = reqInherit;
if (reqInherit != DocExchangeRequirementEnum.NotRelevant)
{
includeconcept = true;
}
}
if (!includeconcept)
return;
if (list.Count == 0)
{
sb.Append("<details><summary>");
sb.Append(docUsage.Definition.Name);
sb.AppendLine("</summary></details>");
return;
}
StringBuilder sbDetail = new StringBuilder();
if (docUsage.Definition != null && docUsage.Definition.Rules != null)
{
// new-style validation -- compiled code (fast)
string methodname = DocumentationISO.MakeLinkName(docView) + "_" + DocumentationISO.MakeLinkName(docUsage.Definition);
System.Reflection.MethodInfo method = typeEntity.GetMethod(methodname);
int fail = 0;
int pass = 0; // pass graph check
int passRule = 0; // pass rule check
int failRule = 0; // fail rule check
List<DocModelRule> trace = new List<DocModelRule>();
DocModelRule[] parameterrules = docUsage.Definition.GetParameterRules();
Dictionary<DocModelRuleAttribute, bool> conditions = new Dictionary<DocModelRuleAttribute, bool>();
if (docUsage.Definition.Name.Contains("-086"))
{
this.ToString();
}
foreach (SEntity ent in list)
{
if(docUsage.Definition.Name.Contains("-077") && ent.GetType().Name.Equals("IfcWindow"))
{
this.ToString();
}
object[] args = new object[0];
if (parameterrules != null && parameterrules.Length > 0)
{
args = new object[parameterrules.Length];
foreach (DocTemplateItem docItem in docUsage.Items)
{
//if (!docItem.Optional)
{
trace.Clear();
conditions.Clear();
if (docItem == docUsage.Items[0])
{
sbDetail.Append("<tr valign=\"top\"><td rowspan=\"" + docUsage.Items.Count + "\">#");
sbDetail.Append(ent.OID);
sbDetail.Append("</td>");
}
else
{
sbDetail.Append("<tr valign=\"top\">");
}
for (int iParam = 0; iParam < parameterrules.Length; iParam++)
{
DocModelRule prule = parameterrules[iParam];
sbDetail.Append("<td>");
DocTemplateUsage docUsageInner = docItem.GetParameterConcept(prule.Identification, null);//verify...
if (docUsageInner != null)
{
// report inner rules...
foreach (DocTemplateItem docItemInner in docUsageInner.Items)
{
sbDetail.Append(docItemInner.RuleParameters);
if (docItemInner.Optional)
{
sbDetail.Append("*");
}
sbDetail.Append("<br/>");
}
}
else
{
string pval = docItem.GetParameterValue(prule.Identification);
sbDetail.Append(pval);
}
sbDetail.Append("</td>");
}
sbDetail.Append("<td>");
bool? result = true;
foreach (DocModelRule rule in docUsage.Definition.Rules)
{
trace.Clear();
bool? itemresult = rule.Validate(ent, docItem, typemap, trace, ent, docUsage, conditions);
if (itemresult != null && !itemresult.Value && result != null)
{
result = false;
// check if conditions were all met; if not, then not a failure
foreach(DocModelRule checkparam in parameterrules)
{
if(checkparam.IsCondition())
{
bool paramspec = false;
if (!conditions.TryGetValue((DocModelRuleAttribute)checkparam, out paramspec) || paramspec == false)
{
result = null;
break;
}
}
}
break;
}
else if (itemresult == null)
{
result = null; //verify: was commented out -- put back in to indicate that entire rule is inapplicable.
}
}
if (result != null && !result.Value)
{
foreach (DocModelRule mm in trace)
{
if (mm is DocModelRuleEntity)
{
sbDetail.Append("\\");
}
else if (mm is DocModelRuleAttribute)
{
sbDetail.Append(".");
}
sbDetail.Append(mm.Name);
}
docItem.ValidationStructure[ent] = false;
#if false // don't mark overall usage as failure, since operator may only require one to be true
if (!docItem.Optional)
{
docUsage.ValidationStructure[ent] = false;
docUsage.Validation = false;
docUsage.Definition.Validation = false;
fail++;
}
#endif
}
else if (result != null && result.Value)
{
// check for any nested failures
foreach (DocTemplateUsage docInnerConcept in docItem.Concepts)
{
foreach (DocTemplateItem docInnerItem in docInnerConcept.Items)
{
bool innerresult = false;
if(docInnerItem.ValidationStructure.TryGetValue(ent, out innerresult))
{
if(!innerresult)
{
sbDetail.Append("~");
sbDetail.Append(docInnerItem.RuleParameters);
sbDetail.Append("<br/>");
result = false;
fail++;
break;
}
}
}
}
if (result != null && result.Value)
{
sbDetail.Append("+");
pass++;
docItem.ValidationStructure[ent] = true;
if (!docUsage.ValidationStructure.ContainsKey(ent)) // if no failures so far, then concept passes for now
{
docUsage.ValidationStructure[ent] = true;
}
}
}
else if (result == null)
{
sbDetail.Append("*"); // NOT APPLICABLE
// new V9.5: don't mark non-applicable as passing
/*
docItem.ValidationStructure[ent] = true;
if (!docUsage.ValidationStructure.ContainsKey(ent))
{
docUsage.ValidationStructure[ent] = true;
}*/
}
sbDetail.Append("</td><td>");
if (result == null)
{
// don't evaluate constraint if it doesn't apply
}
else if (method != null)
{
try
{
bool[] ruleresult = (bool[])method.Invoke(ent, null);//, args);
if (ruleresult != null)
{
bool allpass = true;
foreach (bool compresult in ruleresult)
{
if (!compresult)
{
allpass = false;
break;
}
}
if (allpass)
{
sbDetail.Append("+");
passRule++;
docUsage.ValidationConstraints[ent] = true;
if (docUsage.Validation == null)
{
docUsage.Validation = true;
}
}
else
{
// run detailed report
foreach (DocModelRule rule in docUsage.Definition.Rules)
{
TraceRule(docUsage.Definition, rule, sbDetail, ent, list);
}
failRule++;
docUsage.ValidationConstraints[ent] = false;
docUsage.Validation = false;
}
}
else
{
sbDetail.Append("FAIL");
failRule++;
}
}
catch (System.Reflection.TargetInvocationException et)
{
sbDetail.Append(et.InnerException.GetType().Name);
failRule++;
}
catch (Exception ex)
{
sbDetail.Append(ex.GetType().Name);
failRule++;
}
}
else
{
sbDetail.Append("FAIL - Incompatible Template");
}
sbDetail.AppendLine("</td></tr>");
}
}
// capture items that didn't match
}
else
{
// check for if there are no parameters
sbDetail.Append("<tr valign=\"top\"><td>#");
sbDetail.Append(ent.OID);
sbDetail.Append("</td><td>");
DocModelRule ruleFail = null;
bool? result = true;
foreach (DocModelRule rule in docUsage.Definition.Rules)
{
trace.Clear();
bool? itemresult = rule.Validate(ent, null, typemap, trace, ent, docUsage, conditions);
if (itemresult != null && !itemresult.Value)
{
result = false;
}
else if (itemresult == null)
{
result = null;
}
if (itemresult != null && !itemresult.Value)
{
if (ruleFail != null)
{
sbDetail.Append("<br/>");
}
ruleFail = rule;
foreach (DocModelRule mm in trace)
{
if (mm is DocModelRuleEntity)
{
sbDetail.Append("\\");
}
else if (mm is DocModelRuleAttribute)
{
sbDetail.Append(".");
}
sbDetail.Append(mm.Name);
}
}
}
if (result == null)
{
// no applicable rules, so passing
pass++;
}
else if (result != null && result.Value)
{
// all rules passed
docUsage.ValidationStructure[ent] = true;
if (docUsage.Validation == null)
{
docUsage.Validation = true;
}
pass++;
}
else if (ruleFail != null)
{
docUsage.ValidationStructure[ent] = false;
docUsage.Validation = false;
fail++;
}
if (result == null)
{
sbDetail.Append("*");
}
else if (ruleFail == null)
{
sbDetail.Append("+");
}
sbDetail.Append("</td><td>");
if (method != null)
{
try
{
bool[] ruleresult = (bool[])method.Invoke(ent, args);
if (ruleresult != null)
{
bool allpass = true;
foreach (bool compresult in ruleresult)
{
if (!compresult)
{
allpass = false;
break;
}
}
if (allpass)
{
sbDetail.Append("+");
docUsage.ValidationConstraints[ent] = true;
passRule++;
}
else
{
// run second-stage validation and trace
bool debugpass = true;
StringBuilder sbCheck = new StringBuilder();
foreach (DocModelRule rule in docUsage.Definition.Rules)
{
bool eachpass = TraceRule(docUsage.Definition, rule, sbCheck, ent, list);
if (!eachpass)
{
debugpass = false;
}
}
if (!debugpass)
{
sbDetail.Append(sbCheck.ToString());
docUsage.ValidationConstraints[ent] = false;
docUsage.Validation = false;
failRule++;
}
else
{
sbDetail.Append("+");
docUsage.ValidationConstraints[ent] = true;
if (docUsage.Validation == null)
{
docUsage.Validation = true;
}
passRule++;
}
}
}
else
{
sbDetail.Append("FAIL");
failRule++;
}
}
catch (System.Reflection.TargetInvocationException et)
{
sbDetail.Append(et.InnerException.GetType().Name);
failRule++;
}
catch (Exception ex)
{
sbDetail.Append(ex.GetType().Name);
failRule++;
}
}
else
{
sbDetail.Append("FAIL - Incompatible Template");
}
sbDetail.AppendLine("</td></tr>");
}
}
grandtotallist++;
// nested concepts -- only one must pass
StringBuilder sbNested = new StringBuilder();
if (docUsage.Concepts.Count > 0)
{
sbNested.AppendLine("<p>Validation of concept groups (only one must pass):</p>");
int subtotalpass = 0;
int subtotalskip = 0;
int subtotallist = 0;
foreach (DocTemplateUsage docSub in docUsage.Concepts)
{
ValidateConcept(docSub, docView, reqInherit, typeEntity, list, sbNested, typemap, ref subtotalpass, ref subtotalskip, ref subtotallist);
}
if (subtotalpass > 0)
{
//grandtotalpass++;
sbNested.AppendLine("<p>RESULT: PASS (" + subtotalpass + "/" + subtotallist + ")</p>");
}
else
{
fail++;
sbNested.AppendLine("<p>RESULT: FAIL (" + subtotalpass + "/" + subtotallist + ")</p>");
}
}
sb.AppendLine("<details><summary>" + docUsage.Definition.Name);
sb.Append(" (Operator: " + docUsage.Operator.ToString() + ")");
if(req == DocExchangeRequirementEnum.Optional)
{
sb.Append(" [OPTIONAL]");
}
if (fail > 0 || failRule > 0)
{
docUsage.Validation = false;
docUsage.Definition.Validation = false;
if(req == DocExchangeRequirementEnum.Optional)
{
grandtotalskip++;
}
sb.AppendLine(" - [FAIL]");
}
else
{
docUsage.Validation = true;
if (docUsage.Definition.Validation == null)
{
docUsage.Definition.Validation = true;
}
grandtotalpass++;
}
sb.AppendLine("</summary>");
sb.AppendLine("<table border=\"1\" >");
sb.Append("<tr><th>Instance</th>");
foreach (DocModelRule docRule in parameterrules)
{
sb.Append("<th>");
sb.Append(docRule.Identification);
if (docRule.IsCondition())
{
sb.Append("?");
}
sb.Append("</th>");
}
sb.Append("<th>Structure</th>");
sb.Append("<th>Constraints</th>");
sb.AppendLine("</tr>");
sb.AppendLine(sbDetail.ToString());
sb.AppendLine("</table>");
sb.AppendLine(sbNested.ToString());
sb.AppendLine("</details>");
}
}
private void dataGridViewConceptRules_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex < 0 || e.ColumnIndex < 0)
{
return;
}
// for button types, launch dialog
DataGridViewCell cell = this.dataGridViewConceptRules.Rows[e.RowIndex].Cells[e.ColumnIndex];
DocDefinition docEntity = cell.Tag as DocDefinition;
if (docEntity == null)
{
return;
}
DocDefinition docSelect = null;
if (cell.Value != null && this.m_map.ContainsKey(cell.Value.ToString()))
{
docSelect = this.m_map[cell.Value.ToString()] as DocDefinition;
}
if (docEntity.Name != null && docEntity.Name.Equals("IfcReference"))
{
DocDefinition docDef = this.m_conceptroot.ApplicableEntity as DocDefinition;
// special case for building reference paths
using (FormReference form = new FormReference(this.m_project, docDef, this.m_map, cell.Value as string))
{
DialogResult res = form.ShowDialog(this);
if (res == System.Windows.Forms.DialogResult.OK)
{
if (form.ValuePath != null && form.ValuePath.StartsWith("\\"))
{
cell.Value = form.ValuePath.Substring(1);
}
else if (form.ValuePath == "")
{
cell.Value = String.Empty;// "\\";
}
dataGridViewConceptRules_CellValidated(this, e);
this.dataGridViewConceptRules.NotifyCurrentCellDirty(true);
}
}
}
else
{
// new: if a referenced concept template applies, then edit that; otherwise, edit type
// get the model view
DocTemplateDefinition docTemplateInner = null;
DocModelRule docRule = this.m_columns[e.ColumnIndex];
if (docRule is DocModelRuleAttribute)
{
DocModelRuleAttribute dma = (DocModelRuleAttribute)docRule;
if (dma.Rules.Count > 0 && dma.Rules[0] is DocModelRuleEntity)
{
DocModelRuleEntity dme = (DocModelRuleEntity)dma.Rules[0];
if (dme.References.Count == 1)
{
docTemplateInner = dme.References[0];
if (dma.Rules.Count > 1)
{
// prompt user to select which template...
}
}
}
}
if (docTemplateInner != null)
{
DocTemplateItem docConceptItem = (DocTemplateItem)this.dataGridViewConceptRules.Rows[e.RowIndex].Tag;
if (docConceptItem != null)
{
DocTemplateUsage docConceptInner = docConceptItem.RegisterParameterConcept(docRule.Identification, docTemplateInner);
using (FormParameters form = new FormParameters())
{
form.Project = this.m_project;
form.ConceptRoot = this.m_conceptroot;
form.ConceptItem = docConceptItem;
form.ConceptLeaf = docConceptInner;
form.CurrentInstance = this.m_instance;
form.ShowDialog(this);
}
}
}
else
{
// set type of item
using (FormSelectEntity form = new FormSelectEntity(docEntity, docSelect, this.m_project, SelectDefinitionOptions.Entity | SelectDefinitionOptions.Type))
{
DialogResult res = form.ShowDialog(this);
if (res == DialogResult.OK && form.SelectedEntity != null)
{
cell.Value = form.SelectedEntity.Name;
this.dataGridViewConceptRules.NotifyCurrentCellDirty(true);
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="docProject"></param>
/// <param name="docModelView"></param>
/// <param name="entity"></param>
/// <param name="root"></param>
/// <param name="usage">Optional usage or NULL to format table from concept root applicability</param>
/// <param name="mapEntity"></param>
/// <param name="mapSchema"></param>
/// <returns></returns>
private static string FormatConceptTable(
DocProject docProject,
DocModelView docModelView,
DocEntity entity,
DocConceptRoot root,
DocTemplateUsage usage,
Dictionary<string, DocObject> mapEntity,
Dictionary<string, string> mapSchema)
{
StringBuilder sb = new StringBuilder();
DocTemplateDefinition docTemplate = null;
DocTemplateItem[] listItems = null;
if (usage != null)
{
docTemplate = usage.Definition;
listItems = FindTemplateItems(docProject, entity, usage.Definition, docModelView);
if (usage.Override)
{
listItems = usage.Items.ToArray();
}
if (listItems.Length == 0)
{
// scenario for referenced inner templates
listItems = usage.Items.ToArray();
}
}
else
{
docTemplate = root.ApplicableTemplate;
listItems = root.ApplicableItems.ToArray();
}
// new way with table
DocModelRule[] parameters = docTemplate.GetParameterRules();
if (parameters != null && parameters.Length > 0 && listItems.Length > 0)
{
// check if descriptions are provided
bool showdescriptions = false;
foreach (DocTemplateItem item in listItems)
{
if (item.Documentation != null)
{
showdescriptions = true;
break;
}
}
sb.AppendLine("<table class=\"gridtable\">");
// header
sb.Append("<tr>");
foreach (DocModelRule parameter in parameters)
{
sb.Append("<th><b>");
// hack until fixed in data
if (parameter.Identification.Equals("Name") && docTemplate.Name.Equals("External Data Constraints"))
{
sb.Append("Column");
}
else
{
sb.Append(parameter.Identification);
}
sb.Append("</b></th>");
}
if (showdescriptions)
{
sb.Append("<th><b>Description</b></th>");
}
sb.AppendLine("</tr>");
// items
foreach (DocTemplateItem item in listItems)
{
sb.Append("<tr>");
foreach (DocModelRule parameter in parameters)
{
string value = item.GetParameterValue(parameter.Identification);
string schema = null;
if(parameter.Name.Equals("Columns"))
{
parameter.ToString();
}
sb.Append("<td>");
//if (value != null)
{
DocDefinition docDef = docTemplate.GetParameterType(parameter.Identification, mapEntity);
if (docDef is DocEnumeration)
{
if(value != null)
{
schema = mapSchema[docDef.Name];
sb.Append("<a href=\"../../");
sb.Append(schema.ToLower());
sb.Append("/lexical/");
sb.Append(docDef.Name.ToLower());
sb.Append(".htm\">");
sb.Append(value);
sb.Append("</a>");
}
}
else if (docDef is DocEntity)
{
DocTemplateDefinition docTemplateInner = null;
if (parameter is DocModelRuleAttribute)
{
DocModelRuleAttribute dma = (DocModelRuleAttribute)parameter;
foreach(DocModelRule docInnerRule in dma.Rules)
{
if (docInnerRule is DocModelRuleEntity)
{
DocModelRuleEntity dme = (DocModelRuleEntity)docInnerRule;
if (dme.References.Count == 1)
{
docTemplateInner = dme.References[0];
DocTemplateUsage docConceptInner = item.GetParameterConcept(parameter.Identification, docTemplateInner);
if (docConceptInner != null)
{
string inner = FormatConceptTable(docProject, docModelView, (DocEntity)docDef, root, docConceptInner, mapEntity, mapSchema);
sb.Append("<a href=\"../../templates/" + MakeLinkName(docTemplateInner) + ".htm\">" + docTemplateInner.Name + "</a><br/>");
sb.Append(inner);
}
}
}
}
}
if (docTemplateInner == null && value != null && mapSchema.TryGetValue(value, out schema))
{
if(value.StartsWith("Pset_"))
{
value.ToString();
}
sb.Append("<a href=\"../../");
sb.Append(schema.ToLower());
sb.Append("/lexical/");
sb.Append(value.ToLower());
sb.Append(".htm\">");
sb.Append(value);
sb.Append("</a>");
}
else if(docDef.Name.Equals("IfcReference"))
{
// ...hyperlinks
if(value != null)
{
string reftext = FormatReference(docProject, value);
sb.Append(reftext);
}
//sb.Append(value);
}
else if(value != null)
{
sb.Append(value);
}
}
else if (docDef != null && value != null)
{
value = FormatField(docProject, value, value, docDef.Name, value);
sb.Append(value);
}
else if (value != null)
{
sb.Append(value);
}
else
{
sb.Append(" ");
}
}
sb.Append("</td>");
}
if (showdescriptions)
{
sb.Append("<td>");
if (item.Documentation != null)
{
sb.Append(item.Documentation);
}
else
{
sb.Append(" ");
}
sb.Append("</td>");
}
sb.AppendLine("</tr>");
}
sb.AppendLine("</table>");
}
return sb.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();
}
}
}
}
private void toolStripButtonProperty_Click(object sender, EventArgs e)
{
DocEntity docBaseEntity = this.m_project.GetDefinition(this.m_template.Type) as DocEntity;
if (this.m_conceptroot != null && this.m_conceptroot.ApplicableEntity != null)
{
docBaseEntity = this.m_conceptroot.ApplicableEntity;
}
using (FormSelectProperty form = new FormSelectProperty(docBaseEntity, this.m_project, false))
{
if (form.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
{
string value = form.GenerateValuePath();
Dictionary <string, DocObject> mapEntity = new Dictionary <string, DocObject>();
foreach (DocSection docSection in this.m_project.Sections)
{
foreach (DocSchema docSchema in docSection.Schemas)
{
foreach (DocEntity docEntity in docSchema.Entities)
{
mapEntity.Add(docEntity.Name, docEntity);
}
foreach (DocType docType in docSchema.Types)
{
mapEntity.Add(docType.Name, docType);
}
}
}
if (docBaseEntity.BaseDefinition == "IfcElement" || docBaseEntity.BaseDefinition == "IfcElementComponent" || docBaseEntity.BaseDefinition == "IfcBuildingElement" ||
docBaseEntity.BaseDefinition == "IfcReinforcingElement" || docBaseEntity.BaseDefinition == "IfcFlowSegment" || docBaseEntity.BaseDefinition == "IfcFeatureElement" ||
docBaseEntity.BaseDefinition == "IfcContext" || docBaseEntity.BaseDefinition == "IfcSpatialStructureElement" || docBaseEntity.BaseDefinition == "IfcFacility" ||
docBaseEntity.BaseDefinition == "IfcFacilityPart")
{
this.ChangeTemplate(this.m_project.GetTemplate(DocTemplateDefinition.guidTemplatePsetObject));
string[] psetParamNames = this.Concept.Definition.GetParameterNames();
DocTemplateItem pset = new DocTemplateItem();
pset.Name = form.SelectedPropertySet.Name;
if (form.SelectedPropertySet.Name == "Pset_ElementCommon")
{
pset.Name = form.SelectedPropertySet.Name.Replace("Element", docBaseEntity.Name);
}
pset.RuleParameters = "PsetName=" + pset.Name;
if (this.Concept.Items.Count == 0)
{
this.Concept.Items.Add(pset);
}
else
{
bool addItem = true;
foreach (DocTemplateItem existingPsetDefinition in this.Concept.Items)
{
if (existingPsetDefinition.Name == pset.Name)
{
addItem = false;
}
}
if (addItem)
{
this.Concept.Items.Add(pset);
}
}
DocTemplateUsage propertyConcept = new DocTemplateUsage();
DocPropertyTemplateTypeEnum propertyType = form.SelectedProperty.PropertyType;
propertyConcept.Operator = DocTemplateOperator.And;
DocTemplateItem property = new DocTemplateItem();
string psetName = pset.Name;
propertyConcept.Name = String.Join(" ", Regex.Split(form.SelectedProperty.Name, @"(?<!^)(?=[A-Z])"));
switch (propertyType)
{
case DocPropertyTemplateTypeEnum.P_SINGLEVALUE:
//propertyConcept.Name = "Single Value";
//propertyRule.RuleParameters = parameterNames[0] + "[Value]=" + "'" + form.SelectedProperty.Name + "'" + parameterNames[1] + "[Type]=" + "'" + form.SelectedProperty.PrimaryDataType + "'";
propertyConcept.Definition = this.m_project.GetTemplate(DocTemplateDefinition.guidTemplatePropertySingle);
//parameterNames = property.Definition.GetParameterNames();
property.RuleParameters = propertyConcept.Definition.GetParameterNames()[0] + "=" + form.SelectedProperty.Name + ";" + propertyConcept.Definition.GetParameterNames()[1] + "=" + form.SelectedProperty.PrimaryDataType + ";";
CreateAndAssignProperty(form, propertyConcept, property, psetName);
break;
case DocPropertyTemplateTypeEnum.P_ENUMERATEDVALUE:
//propertyConcept.Name = "Enumerated Value";
propertyConcept.Definition = this.m_project.GetTemplate(DocTemplateDefinition.guidTemplatePropertyEnumerated);
//parameterNames = property.Definition.GetParameterNames();
property.RuleParameters = propertyConcept.Definition.GetParameterNames()[0] + "=" + form.SelectedProperty.Name + ";" + propertyConcept.Definition.GetParameterNames()[1] + "=" + form.SelectedProperty.PrimaryDataType + ";";
CreateAndAssignProperty(form, propertyConcept, property, psetName);
break;
case DocPropertyTemplateTypeEnum.P_LISTVALUE:
propertyConcept.Definition = this.m_project.GetTemplate(DocTemplateDefinition.guidTemplatePropertyList);
property.RuleParameters = propertyConcept.Definition.GetParameterNames()[0] + "=" + form.SelectedProperty.Name + ";" + propertyConcept.Definition.GetParameterNames()[1] + "=" + form.SelectedProperty.PrimaryDataType + ";";
CreateAndAssignProperty(form, propertyConcept, property, psetName);
break;
case DocPropertyTemplateTypeEnum.P_BOUNDEDVALUE:
propertyConcept.Definition = this.m_project.GetTemplate(DocTemplateDefinition.guidTemplatePropertyBounded);
property.RuleParameters = propertyConcept.Definition.GetParameterNames()[0] + "=" + form.SelectedProperty.Name + ";" + propertyConcept.Definition.GetParameterNames()[1] + "=" + form.SelectedProperty.PrimaryDataType + ";";
CreateAndAssignProperty(form, propertyConcept, property, psetName);
break;
case DocPropertyTemplateTypeEnum.P_REFERENCEVALUE:
propertyConcept.Definition = this.m_project.GetTemplate(DocTemplateDefinition.guidTemplatePropertyReference);
property.RuleParameters = propertyConcept.Definition.GetParameterNames()[0] + "=" + form.SelectedProperty.Name + ";" + propertyConcept.Definition.GetParameterNames()[1] + "=" + form.SelectedProperty.PrimaryDataType + ";";
CreateAndAssignProperty(form, propertyConcept, property, psetName);
break;
case DocPropertyTemplateTypeEnum.P_TABLEVALUE:
propertyConcept.Definition = this.m_project.GetTemplate(DocTemplateDefinition.guidTemplatePropertyTable);
property.RuleParameters = propertyConcept.Definition.GetParameterNames()[0] + "=" + form.SelectedProperty.Name + ";" + propertyConcept.Definition.GetParameterNames()[1] + "=" + form.SelectedProperty.PrimaryDataType + ";";
CreateAndAssignProperty(form, propertyConcept, property, psetName);
break;
}
//foreach(DocModelRule rule in property.Definition.Rules)
//{
// if (!string.IsNullOrEmpty(rule.Identification))
// {
// }
//}
}
else
{
CvtValuePath valuepath = CvtValuePath.Parse(value, mapEntity);
this.ChangeTemplate(valuepath.ToTemplateDefinition());
}
}
}
}
private static string FormatConceptTable(
DocProject docProject,
DocModelView docModelView,
DocEntity entity,
DocConceptRoot root,
DocTemplateUsage usage,
Dictionary<string, DocObject> mapEntity,
Dictionary<string, string> mapSchema)
{
StringBuilder sb = new StringBuilder();
DocTemplateItem[] listItems = FindTemplateItems(docProject, entity, usage.Definition, docModelView);
if(listItems.Length == 0)
{
// scenario for referenced inner templates
listItems = usage.Items.ToArray();
}
// new way with table
DocModelRule[] parameters = usage.Definition.GetParameterRules();
if (parameters != null && parameters.Length > 0 && listItems.Length > 0)
{
// check if descriptions are provided
bool showdescriptions = false;
foreach (DocTemplateItem item in listItems)
{
if (item.Documentation != null)
{
showdescriptions = true;
break;
}
}
sb.AppendLine("<table class=\"gridtable\">");
// header
sb.Append("<tr>");
foreach (DocModelRule parameter in parameters)
{
sb.Append("<th><b>");
sb.Append(parameter.Identification);
sb.Append("</b></th>");
}
if (showdescriptions)
{
sb.Append("<th><b>Description</b></th>");
}
sb.AppendLine("</tr>");
// items
foreach (DocTemplateItem item in listItems)
{
sb.Append("<tr>");
foreach (DocModelRule parameter in parameters)
{
string value = item.GetParameterValue(parameter.Identification);
string schema = null;
if(parameter.Name.Equals("Columns"))
{
parameter.ToString();
}
sb.Append("<td>");
//if (value != null)
{
DocDefinition docDef = usage.Definition.GetParameterType(parameter.Identification, mapEntity);
if (docDef is DocEnumeration)
{
if(value != null)
{
schema = mapSchema[docDef.Name];
sb.Append("<a href=\"../../");
sb.Append(schema.ToLower());
sb.Append("/lexical/");
sb.Append(docDef.Name.ToLower());
sb.Append(".htm\">");
sb.Append(value);
sb.Append("</a>");
}
}
else if (docDef is DocEntity)
{
DocTemplateDefinition docTemplateInner = null;
if (parameter is DocModelRuleAttribute)
{
DocModelRuleAttribute dma = (DocModelRuleAttribute)parameter;
foreach(DocModelRule docInnerRule in dma.Rules)
{
if (docInnerRule is DocModelRuleEntity)
{
DocModelRuleEntity dme = (DocModelRuleEntity)docInnerRule;
if (dme.References.Count == 1)
{
docTemplateInner = dme.References[0];
DocTemplateUsage docConceptInner = item.GetParameterConcept(parameter.Identification, docTemplateInner);
if (docConceptInner != null)
{
string inner = FormatConceptTable(docProject, docModelView, (DocEntity)docDef, root, docConceptInner, mapEntity, mapSchema);
sb.Append("<a href=\"../../templates/" + MakeLinkName(docTemplateInner) + ".htm\">" + docTemplateInner.Name + "</a><br/>");
sb.Append(inner);
}
}
}
}
}
if (docTemplateInner == null && value != null && mapSchema.TryGetValue(value, out schema))
{
if(value.StartsWith("Pset_"))
{
value.ToString();
}
sb.Append("<a href=\"../../");
sb.Append(schema.ToLower());
sb.Append("/lexical/");
sb.Append(value.ToLower());
sb.Append(".htm\">");
sb.Append(value);
sb.Append("</a>");
}
else if(docDef.Name.Equals("IfcReference"))
{
// ...hyperlinks
if(value != null)
{
string[] parts = value.Split('\\');
foreach(string part in parts)
{
string[] tokens = part.Split('.');
if (tokens.Length > 0)
{
sb.Append("\\");
DocDefinition docToken = docProject.GetDefinition(tokens[0]);
if (docToken != null)
{
DocSchema docSchema = docProject.GetSchemaOfDefinition(docToken);
string relative = @"../../";
string hyperlink = relative + docSchema.Name.ToLower() + @"/lexical/" + docToken.Name.ToLower() + ".htm";
string format = "<a href=\"" + hyperlink + "\">" + tokens[0] + "</a>";
sb.Append(format);
}
if (tokens.Length > 1)
{
sb.Append(".");
sb.Append(tokens[1]);
}
sb.Append("<br>");
}
}
}
//sb.Append(value);
}
else if(value != null)
{
sb.Append(value);
}
}
else if (docDef != null && value != null)
{
value = FormatField(docProject, value, value, docDef.Name, value);
sb.Append(value);
}
else if (value != null)
{
sb.Append(value);
}
else
{
sb.Append(" ");
}
}
/*
else
{
sb.Append(" ");
}*/
sb.Append("</td>");
}
if (showdescriptions)
{
sb.Append("<td>");
if (item.Documentation != null)
{
sb.Append(item.Documentation);
}
else
{
sb.Append(" ");
}
sb.Append("</td>");
}
sb.AppendLine("</tr>");
}
sb.AppendLine("</table>");
}
return sb.ToString();
}
private void BuildConceptForPropertySets(DocConceptRoot docRoot, DocTemplateDefinition docTemplatePset, DocPropertySet[] psets)
{
DocTemplateUsage docConcept = null;
// get any existing concept for psets
foreach (DocTemplateUsage docExistConcept in docRoot.Concepts)
{
if (docExistConcept.Definition == docTemplatePset)
{
docConcept = docExistConcept;
break;
}
}
if (psets.Length > 0)
{
if (docConcept == null)
{
docConcept = new DocTemplateUsage();
docConcept.Definition = docTemplatePset;
docRoot.Concepts.Add(docConcept);
LoadNode(this.treeView.SelectedNode, docConcept, docConcept.Name, false);
}
// remove old listings
for (int iExist = docConcept.Items.Count - 1; iExist >= 0; iExist--)
{
docConcept.Items[iExist].Delete();
docConcept.Items.RemoveAt(iExist);
}
foreach (DocPropertySet docPset in psets)
{
//if (docPset.PropertySetType == "PSET_OCCURRENCEDRIVEN" ||
// docPset.PropertySetType == "PSET_TYPEDRIVENOVERRIDE")
{
// add new, in order
DocTemplateItem docItemPset = new DocTemplateItem();
docItemPset.RuleParameters = "Name=" + docPset.Name + ";";
docConcept.Items.Add(docItemPset);
//... predefined type
//... properties...
foreach (DocProperty docProp in docPset.Properties)
{
DocTemplateDefinition docInnerTemplate = null;
switch (docProp.PropertyType)
{
case DocPropertyTemplateTypeEnum.P_SINGLEVALUE:
docInnerTemplate = this.m_project.GetTemplate(new Guid("6655f6d0-29a8-47b8-8f3d-c9fce9c9a620"));
break;
case DocPropertyTemplateTypeEnum.P_BOUNDEDVALUE:
docInnerTemplate = this.m_project.GetTemplate(new Guid("3d67a2d2-761d-44d9-a09e-b7fbb1fa5632"));
break;
case DocPropertyTemplateTypeEnum.P_ENUMERATEDVALUE:
docInnerTemplate = this.m_project.GetTemplate(new Guid("c148a099-c351-43a8-9266-5f3de0b45a95"));
break;
}
if (docInnerTemplate != null)
{
DocTemplateUsage docInnerConcept = docItemPset.RegisterParameterConcept("Properties", docInnerTemplate);
DocTemplateItem docInnerItem = new DocTemplateItem();
docInnerItem.RuleParameters = "Name=" + docProp.Name + ";Value=" + docProp.PrimaryDataType + ";";
docInnerConcept.Items.Add(docInnerItem);
}
}
}
}
}
}
private static void FormatEntityUsage(DocProject docProject, DocEntity entity, DocConceptRoot docRoot, DocTemplateUsage eachusage, Dictionary<string, DocObject> mapEntity, Dictionary<string, string> mapSchema, List<ContentRef> listFigures, List<ContentRef> listTables, Dictionary<DocObject, bool> included, StringBuilder sb)
{
if (eachusage.Definition != null)
{
if (included == null || included.ContainsKey(eachusage.Definition))
{
if (eachusage.Documentation != null)
{
eachusage.Documentation = UpdateNumbering(eachusage.Documentation, listFigures, listTables, entity);
}
string eachtext = FormatConcept(docProject, entity, docRoot, eachusage, mapEntity, mapSchema, listFigures, listTables);
sb.Append(eachtext);
sb.AppendLine();
if (eachusage.Concepts.Count > 0)
{
sb.AppendLine("<details>");
sb.AppendLine("<summary>Concept alternates</summary>");
foreach (DocTemplateUsage innerusage in eachusage.Concepts)
{
FormatEntityUsage(docProject, entity, docRoot, innerusage, mapEntity, mapSchema, listFigures, listTables, included, sb);
}
sb.AppendLine("</details>");
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="docEntity">If entity specified, shows property sets and properties applicable to entity; if null, shows all property sets.</param>
/// <param name="docProject">Required project.</param>
/// <param name="multiselect">True to select multiple properties; False to select single property; Null to show properties that can be merged.</param>
public FormSelectProperty(DocEntity docEntity, DocProject docProject, bool?multiselect, DocTemplateUsage psetConcept = null) : this()
{
this.m_entity = docEntity;
this.m_project = docProject;
this.m_psetConcept = psetConcept;
if (multiselect != null)
{
if (multiselect == true)
{
this.treeViewProperty.CheckBoxes = true;
this.Text = "Include Property Sets";
this.comboBoxPort.Enabled = false;
}
else if (multiselect == false)
{
// find applicable ports
this.comboBoxPort.Items.Add("(object)");
this.comboBoxPort.SelectedIndex = 0;
if (docEntity != null)
{
foreach (DocModelView docView in docProject.ModelViews)
{
foreach (DocConceptRoot docRoot in docView.ConceptRoots)
{
if (docRoot.ApplicableEntity == docEntity)
{
foreach (DocTemplateUsage docConcept in docRoot.Concepts)
{
if (docConcept.Definition != null && docConcept.Definition.Uuid == DocTemplateDefinition.guidPortNesting)
{
foreach (DocTemplateItem docItem in docConcept.Items)
{
string name = docItem.GetParameterValue("Name");
if (name != null && !this.comboBoxPort.Items.Contains(name))
{
this.comboBoxPort.Items.Add(name);
}
}
}
}
}
}
}
}
}
this.LoadPropertySets();
}
else if (multiselect == null)
{
this.Text = "Merge Duplicate Properties";
this.treeViewProperty.CheckBoxes = true;
this.comboBoxPort.Enabled = false;
// build list of shared properties
//Dictionary<string, DocProperty> duplicateProperties = new Dictionary<string, DocProperty>();
this.m_sharedproperties = new Dictionary <string, DocProperty>();
foreach (DocSection docSection in this.m_project.Sections)
{
foreach (DocSchema docSchema in docSection.Schemas)
{
foreach (DocPropertySet docPset in docSchema.PropertySets)
{
// first, capture all unique properties... THEN, only shared properties
if (!docPset.IsVisible())
{
foreach (DocProperty docProp in docPset.Properties)
{
if (!this.m_sharedproperties.ContainsKey(docProp.Name))
{
this.m_sharedproperties.Add(docProp.Name, docProp);
}
/*
* else if(!duplicateProperties.ContainsKey(docProp.Name))
* {
* duplicateProperties.Add(docProp.Name, docProp);
* }*/
}
}
}
}
}
//this.m_sharedproperties = duplicateProperties;
// find all duplicate properties
foreach (DocSection docSection in this.m_project.Sections)
{
foreach (DocSchema docSchema in docSection.Schemas)
{
foreach (DocPropertySet docPset in docSchema.PropertySets)
{
if (docPset.IsVisible())
{
TreeNode tnPset = null;
foreach (DocProperty docProp in docPset.Properties)
{
DocProperty docExist = null;
if (this.m_sharedproperties.TryGetValue(docProp.Name, out docExist) && docExist != docProp)
{
if (tnPset == null)
{
tnPset = new TreeNode();
tnPset.Tag = docPset;
tnPset.Text = docPset.Name;
tnPset.ImageIndex = 0;
tnPset.SelectedImageIndex = 0;
tnPset.Checked = true;
this.treeViewProperty.Nodes.Add(tnPset);
}
TreeNode tnProp = new TreeNode();
tnProp.Tag = docProp;
tnProp.Text = docProp.Name;
tnProp.ImageIndex = 1;
tnProp.SelectedImageIndex = 1;
tnProp.Checked = true;
tnPset.Nodes.Add(tnProp);
tnPset.Expand();
}
}
}
}
}
}
}
}
public static DocProject LoadFile(string filePath)
{
List <object> instances = new List <object>();
string ext = System.IO.Path.GetExtension(filePath).ToLower();
string schema = "";
DocProject project = null;
switch (ext)
{
case ".ifcdoc":
using (FileStream streamDoc = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
Dictionary <long, object> dictionaryInstances = null;
StepSerializer formatDoc = new StepSerializer(typeof(DocProject), SchemaDOC.Types);
project = (DocProject)formatDoc.ReadObject(streamDoc, out dictionaryInstances);
instances.AddRange(dictionaryInstances.Values);
schema = formatDoc.Schema;
}
break;
case ".ifcdocxml":
using (FileStream streamDoc = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
Dictionary <string, object> dictionaryInstances = null;
XmlSerializer formatDoc = new XmlSerializer(typeof(DocProject));
project = (DocProject)formatDoc.ReadObject(streamDoc, out dictionaryInstances);
instances.AddRange(dictionaryInstances.Values);
}
break;
default:
MessageBox.Show("Unsupported file type " + ext, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
#if MDB
case ".mdb":
using (FormatMDB format = new FormatMDB(this.m_file, SchemaDOC.Types, this.m_instances))
{
format.Load();
}
break;
#endif
}
if (project == null)
{
return(null);
}
double schemaVersion = 0;
if (!string.IsNullOrEmpty(schema))
{
string[] fields = schema.Split("_".ToCharArray());
int i = 0;
if (fields.Length > 1)
{
if (int.TryParse(fields[1], out i))
{
schemaVersion = i;
}
if (fields.Length > 2 && int.TryParse(fields[2], out i))
{
schemaVersion += i / 10.0;
}
}
}
List <SEntity> listDelete = new List <SEntity>();
List <DocTemplateDefinition> listTemplate = new List <DocTemplateDefinition>();
foreach (object o in instances)
{
if (o is DocSchema)
{
DocSchema docSchema = (DocSchema)o;
// renumber page references
foreach (DocPageTarget docTarget in docSchema.PageTargets)
{
if (docTarget.Definition != null) // fix it up -- NULL bug from older .ifcdoc files
{
int page = docSchema.GetDefinitionPageNumber(docTarget);
int item = docSchema.GetPageTargetItemNumber(docTarget);
docTarget.Name = page + "," + item + " " + docTarget.Definition.Name;
foreach (DocPageSource docSource in docTarget.Sources)
{
docSource.Name = docTarget.Name;
}
}
}
}
else if (o is DocExchangeDefinition)
{
// files before V4.9 had Description field; no longer needed so use regular Documentation field again.
DocExchangeDefinition docexchange = (DocExchangeDefinition)o;
if (docexchange._Description != null)
{
docexchange.Documentation = docexchange._Description;
docexchange._Description = null;
}
}
else if (o is DocTemplateDefinition)
{
// files before V5.0 had Description field; no longer needed so use regular Documentation field again.
DocTemplateDefinition doctemplate = (DocTemplateDefinition)o;
if (doctemplate._Description != null)
{
doctemplate.Documentation = doctemplate._Description;
doctemplate._Description = null;
}
listTemplate.Add((DocTemplateDefinition)o);
}
else if (o is DocConceptRoot)
{
// V12.0: ensure template is defined
DocConceptRoot docConcRoot = (DocConceptRoot)o;
if (docConcRoot.ApplicableTemplate == null && docConcRoot.ApplicableEntity != null)
{
docConcRoot.ApplicableTemplate = new DocTemplateDefinition();
docConcRoot.ApplicableTemplate.Type = docConcRoot.ApplicableEntity.Name;
}
}
else if (o is DocTemplateUsage)
{
// V12.0: ensure template is defined
DocTemplateUsage docUsage = (DocTemplateUsage)o;
if (docUsage.Definition == null)
{
docUsage.Definition = new DocTemplateDefinition();
}
}
else if (o is DocLocalization)
{
DocLocalization localization = o as DocLocalization;
if (!string.IsNullOrEmpty(localization.Name))
{
localization.Name = localization.Name.Trim();
}
}
// ensure all objects have valid guid
DocObject docObject = o as DocObject;
if (docObject != null)
{
if (docObject.Uuid == Guid.Empty)
{
docObject.Uuid = Guid.NewGuid();
}
if (!string.IsNullOrEmpty(docObject.Documentation))
{
docObject.Documentation = docObject.Documentation.Trim();
}
if (schemaVersion < 12.1)
{
DocChangeSet docChangeSet = docObject as DocChangeSet;
if (docChangeSet != null)
{
docChangeSet.ChangesEntities.RemoveAll(x => !isUnchanged(x));
}
else
{
if (schemaVersion < 12)
{
DocEntity entity = docObject as DocEntity;
if (entity != null)
{
entity.ClearDefaultMember();
}
}
}
}
}
}
if (project == null)
{
return(null);
}
if (schemaVersion > 0 && schemaVersion < 12.1)
{
Dictionary <string, DocPropertyEnumeration> encounteredPropertyEnumerations = new Dictionary <string, DocPropertyEnumeration>();
foreach (DocSchema docSchema in project.Sections.SelectMany(x => x.Schemas))
{
extractListingsV12_1(project, docSchema, encounteredPropertyEnumerations);
}
}
foreach (DocModelView docModelView in project.ModelViews)
{
// sort alphabetically (V11.3+)
docModelView.SortConceptRoots();
}
// upgrade to Publications (V9.6)
if (project.Annotations.Count == 4)
{
project.Publications.Clear();
DocAnnotation docCover = project.Annotations[0];
DocAnnotation docContents = project.Annotations[1];
DocAnnotation docForeword = project.Annotations[2];
DocAnnotation docIntro = project.Annotations[3];
DocPublication docPub = new DocPublication();
docPub.Name = "Default";
docPub.Documentation = docCover.Documentation;
docPub.Owner = docCover.Owner;
docPub.Author = docCover.Author;
docPub.Code = docCover.Code;
docPub.Copyright = docCover.Copyright;
docPub.Status = docCover.Status;
docPub.Version = docCover.Version;
docPub.Annotations.Add(docForeword);
docPub.Annotations.Add(docIntro);
project.Publications.Add(docPub);
docCover.Delete();
docContents.Delete();
project.Annotations.Clear();
}
project.SortProject();
return(project);
}
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 void SetConceptInheritance(bool isOverride, bool isSuppress)
{
DocConceptRoot docRoot = (DocConceptRoot)this.m_target;
foreach(ListViewItem lvi in this.listViewConceptRoot.SelectedItems)
{
DocTemplateDefinition dtd = (DocTemplateDefinition)lvi.Tag;
DocTemplateUsage docConcept = null;
foreach (DocTemplateUsage docConceptEach in docRoot.Concepts)
{
if(docConceptEach.Definition == dtd)
{
docConcept = docConceptEach;
break;
}
}
if (docConcept == null)
{
docConcept = new DocTemplateUsage();
docConcept.Definition = dtd;
docRoot.Concepts.Add(docConcept);
//... update main tree view...
}
docConcept.Override = isOverride;
docConcept.Suppress = isSuppress;
UpdateConceptInheritance(lvi, docConcept);
}
}
private static DocTemplateItem ImportMvdItem(TemplateRule rule, DocProject docProject, Dictionary<Guid, ExchangeRequirement> mapExchange)
{
DocTemplateItem docItem = new DocTemplateItem();
docItem.Documentation = rule.Description;
docItem.RuleInstanceID = rule.RuleID;
docItem.ParseParameterExpressions(rule.Parameters); // convert from mvdXML
if (rule.References != null)
{
foreach (Concept con in rule.References)
{
DocTemplateUsage docInner = new DocTemplateUsage();
docItem.Concepts.Add(docInner);
ImportMvdConcept(con, docInner, docProject, mapExchange);
}
}
return docItem;
}
private void CompileConcept(DocTemplateUsage concept, DocModelView view, TypeBuilder tb)
{
bool includeconcept = true;
if (this.m_exchange != null)
{
includeconcept = false;
foreach (DocExchangeItem ei in concept.Exchanges)
{
if (ei.Exchange == this.m_exchange && ei.Applicability == DocExchangeApplicabilityEnum.Export &&
(ei.Requirement == DocExchangeRequirementEnum.Mandatory || ei.Requirement == DocExchangeRequirementEnum.Optional))
{
includeconcept = true;
}
}
}
// bool ConceptTemplateA([Parameter1, ...]);
// {
// // for loading reference value:
// .ldfld [AttributeRule]
// .ldelem [Index] // for collection, get element by index
// .castclass [EntityRule] for entity, cast to expected type;
// // for object graphs, repeat the above instructions to load value
//
// for loading constant:
// .ldstr 'value'
//
// for comparison functions:
// .cge
//
// for logical aggregations, repeat each item, pushing 2 elements on stack, then run comparison
// .or
//
// return the boolean value on the stack
// .ret;
// }
// bool[] ConceptA()
// {
// bool[] result = new bool[2];
//
// if parameters are specified, call for each template rule; otherwise call just once
// result[0] = ConceptTemplateA([Parameter1, ...]); // TemplateRule#1
// result[1] = ConceptTemplateA([Parameter1, ...]); // TemplateRule#2
//
// return result;
// }
// compile a method for the template definition, where parameters are passed to the template
#if true
if (includeconcept && concept.Definition != null)
{
MethodInfo methodTemplate = this.RegisterTemplate(concept.Definition);
// verify that definition is compatible with entity (user error)
if (methodTemplate != null && methodTemplate.DeclaringType.IsAssignableFrom(tb))
{
string methodname = DocumentationISO.MakeLinkName(view) + "_" + DocumentationISO.MakeLinkName(concept.Definition);
MethodBuilder method = tb.DefineMethod(methodname, MethodAttributes.Public, CallingConventions.HasThis, typeof(bool[]), null);
ILGenerator generator = method.GetILGenerator();
DocModelRule[] parameters = concept.Definition.GetParameterRules();
if (parameters != null && parameters.Length > 0)
{
// allocate array of booleans, store as local variable
generator.DeclareLocal(typeof(bool[]));
generator.Emit(OpCodes.Ldc_I4, concept.Items.Count);
generator.Emit(OpCodes.Newarr, typeof(bool));
generator.Emit(OpCodes.Stloc_0);
// call for each item with specific parameters
for (int row = 0; row < concept.Items.Count; row++)
{
DocTemplateItem docItem = concept.Items[row];
generator.Emit(OpCodes.Ldloc_0); // push the array object onto the stack, for storage later
generator.Emit(OpCodes.Ldc_I4, row); // push the array index onto the stack for storage later
generator.Emit(OpCodes.Ldarg_0); // push the *this* pointer for the IFC object instance
// push parameters onto stack
for (int col = 0; col < parameters.Length; col++)
{
DocModelRule docParam = parameters[col];
string paramvalue = docItem.GetParameterValue(docParam.Identification);
if (paramvalue != null)
{
DocDefinition docParamType = concept.Definition.GetParameterType(docParam.Identification, this.m_definitions);
if (docParamType is DocDefined)
{
DocDefined docDefined = (DocDefined)docParamType;
switch (docDefined.DefinedType)
{
case "INTEGER":
{
Int64 ival = 0;
Int64.TryParse(paramvalue, out ival);
generator.Emit(OpCodes.Ldc_I8, ival);
generator.Emit(OpCodes.Box);
}
break;
case "REAL":
{
Double dval = 0.0;
Double.TryParse(paramvalue, out dval);
generator.Emit(OpCodes.Ldc_R8, dval);
generator.Emit(OpCodes.Box);
}
break;
case "STRING":
generator.Emit(OpCodes.Ldstr, paramvalue);
break;
default:
generator.Emit(OpCodes.Ldstr, paramvalue);
break;
}
}
else
{
// assume string
generator.Emit(OpCodes.Ldstr, paramvalue);
}
}
else
{
generator.Emit(OpCodes.Ldnull);
}
}
generator.Emit(OpCodes.Call, methodTemplate); // call the validation function for the concept template
generator.Emit(OpCodes.Stelem_I1); // store the result (bool) into an array slot
}
// return the array of boolean results
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ret);
}
else
{
// allocate array of booleans, store as local variable
generator.DeclareLocal(typeof(bool[]));
generator.Emit(OpCodes.Ldc_I4, 1);
generator.Emit(OpCodes.Newarr, typeof(bool));
generator.Emit(OpCodes.Stloc_0);
generator.Emit(OpCodes.Ldloc_0); // push the array object onto the stack, for storage later
generator.Emit(OpCodes.Ldc_I4, 0); // push the array index onto the stack for storage later
// call once
generator.Emit(OpCodes.Ldarg_0); // push the *this* pointer for the IFC object instance
generator.Emit(OpCodes.Call, methodTemplate); // call the validation function for the concept template
generator.Emit(OpCodes.Stelem_I1); // store the result (bool) into an array slot
// return the array of boolean results
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ret);
}
}
else
{
System.Diagnostics.Debug.WriteLine("Incompatible template: " + tb.Name + " - " + concept.Definition.Name);
}
}
#endif
// recurse
foreach (DocTemplateUsage docChild in concept.Concepts)
{
CompileConcept(docChild, view, tb);
}
}
/// <summary>
///
/// </summary>
/// <param name="docProject"></param>
/// <param name="docModelView"></param>
/// <param name="entity"></param>
/// <param name="root"></param>
/// <param name="usage">Optional usage or NULL to format table from concept root applicability</param>
/// <param name="mapEntity"></param>
/// <param name="mapSchema"></param>
/// <returns></returns>
private static string FormatConceptTable(
DocProject docProject,
DocModelView docModelView,
DocEntity entity,
DocConceptRoot root,
DocTemplateUsage usage,
Dictionary<string, DocObject> mapEntity,
Dictionary<string, string> mapSchema)
{
StringBuilder sb = new StringBuilder();
DocTemplateDefinition docTemplate = null;
DocTemplateItem[] listItems = null;
if (usage != null)
{
docTemplate = usage.Definition;
listItems = FindTemplateItems(docProject, entity, usage.Definition, docModelView);
if (usage.Override)
{
listItems = usage.Items.ToArray();
}
if (listItems.Length == 0)
{
// scenario for referenced inner templates
listItems = usage.Items.ToArray();
}
}
else
{
docTemplate = root.ApplicableTemplate;
listItems = root.ApplicableItems.ToArray();
}
// new way with table
DocModelRule[] parameters = docTemplate.GetParameterRules();
if (parameters != null && parameters.Length > 0 && listItems.Length > 0)
{
// check if descriptions are provided
bool showdescriptions = false;
foreach (DocTemplateItem item in listItems)
{
if (item.Documentation != null)
{
showdescriptions = true;
break;
}
}
sb.AppendLine("<table class=\"gridtable\">");
// header
sb.Append("<tr>");
foreach (DocModelRule parameter in parameters)
{
sb.Append("<th><b>");
// hack until fixed in data
if (parameter.Identification.Equals("Name") && docTemplate.Name.Equals("External Data Constraints"))
{
sb.Append("Column");
}
else
{
sb.Append(parameter.Identification);
}
sb.Append("</b></th>");
}
if (showdescriptions)
{
sb.Append("<th><b>Description</b></th>");
}
sb.AppendLine("</tr>");
// items
foreach (DocTemplateItem item in listItems)
{
sb.Append("<tr>");
foreach (DocModelRule parameter in parameters)
{
string value = item.GetParameterValue(parameter.Identification);
string schema = null;
sb.Append("<td>");
//if (value != null)
{
DocDefinition docDef = docTemplate.GetParameterType(parameter.Identification, mapEntity);
if (docDef is DocEnumeration)
{
if(value != null)
{
schema = mapSchema[docDef.Name];
sb.Append("<a href=\"../../");
sb.Append(schema.ToLower());
sb.Append("/lexical/");
sb.Append(docDef.Name.ToLower());
sb.Append(".htm\">");
sb.Append(value);
sb.Append("</a>");
}
}
else if (docDef is DocEntity && docDef.Name.Equals("IfcReference"))
{
// ...hyperlinks
if (value != null)
{
string reftext = FormatReference(docProject, value);
sb.Append(reftext);
}
//sb.Append(value);
}
else if (docDef is DocEntity)
{
DocTemplateDefinition docTemplateInner = null;
if (parameter is DocModelRuleAttribute)
{
List<string> cols = new List<string>();
List<DocTemplateItem> rows = new List<DocTemplateItem>();
List<DocTemplateUsage> usages = new List<DocTemplateUsage>();
DocModelRuleAttribute dma = (DocModelRuleAttribute)parameter;
foreach(DocModelRule docInnerRule in dma.Rules)
{
if (docInnerRule is DocModelRuleEntity)
{
DocModelRuleEntity dme = (DocModelRuleEntity)docInnerRule;
if (dme.References.Count == 1)
{
docTemplateInner = dme.References[0];
// new: combine nested tables -- properties are shown together
DocTemplateUsage docConceptInner = item.GetParameterConcept(parameter.Identification, docTemplateInner);
if (docConceptInner != null)
{
DocModelRule[] innerparameters = docTemplateInner.GetParameterRules();
foreach (DocModelRule innerparam in innerparameters)
{
if (!cols.Contains(innerparam.Identification))
{
cols.Add(innerparam.Identification);
}
}
foreach(DocTemplateItem docItemInner in docConceptInner.Items)
{
string orderstr = docItemInner.GetParameterValue("Order");
int ordernum;
if(!String.IsNullOrEmpty(orderstr) && Int32.TryParse(orderstr, out ordernum))
{
while (rows.Count < ordernum)
{
rows.Add(null);
usages.Add(null);
}
rows[ordernum - 1] = docItemInner;
usages[ordernum - 1] = docConceptInner;
}
}
}
//break;
/*
DocTemplateUsage docConceptInner = item.GetParameterConcept(parameter.Identification, docTemplateInner);
if (docConceptInner != null)
{
string inner = FormatConceptTable(docProject, docModelView, (DocEntity)docDef, root, docConceptInner, mapEntity, mapSchema);
sb.Append("<a href=\"../../templates/" + MakeLinkName(docTemplateInner) + ".htm\">" + docTemplateInner.Name + "</a><br/>");
sb.Append(inner);
}
*/
}
}
}
if(rows.Count > 0)
{
sb.Append("<table class=\"gridtable\"><tr>");
sb.Append("<th>Template</th>");
foreach(string colname in cols)
{
sb.Append("<th>");
sb.Append(colname);
sb.Append("</th>");
}
sb.AppendLine("</tr>");
for (int iSubRow = 0; iSubRow < rows.Count; iSubRow++ )
{
DocTemplateItem docItem = rows[iSubRow];
DocTemplateUsage docUsage = usages[iSubRow];
//todo: show template with link... define icon at template...
if (docItem != null)
{
sb.Append("<tr>");
sb.Append("<td><a href=\"../../templates/");
sb.Append(MakeLinkName(docUsage.Definition));
sb.Append(".htm\">");
sb.Append(docUsage.Definition.Name);
sb.Append("</a></td>");
foreach (string colname in cols)
{
string pval = docItem.GetParameterValue(colname);
pval = FormatField(docProject, pval, pval, pval, pval);
sb.Append("<td>");
sb.Append(pval);
sb.Append("</td>");
}
sb.AppendLine("</tr>");
}
}
sb.Append("</table>");
}
}
if (docTemplateInner == null && value != null && mapSchema.TryGetValue(value, out schema))
{
sb.Append("<a href=\"../../");
sb.Append(schema.ToLower());
sb.Append("/lexical/");
sb.Append(value.ToLower());
sb.Append(".htm\">");
sb.Append(value);
sb.Append("</a>");
}
else if(value != null)
{
sb.Append(value);
}
}
else if (docDef != null && value != null)
{
value = FormatField(docProject, value, value, docDef.Name, value);
sb.Append(value);
}
else if (value != null)
{
sb.Append(value);
}
else
{
sb.Append(" ");
}
}
sb.Append("</td>");
}
if (showdescriptions)
{
sb.Append("<td>");
if (item.Documentation != null)
{
sb.Append(item.Documentation);
}
else
{
sb.Append(" ");
}
sb.Append("</td>");
}
sb.AppendLine("</tr>");
}
sb.AppendLine("</table>");
}
return sb.ToString();
}
internal static void ImportMvd(mvdXML mvd, DocProject docProject, string filepath)
{
if (mvd.Templates != null)
{
Dictionary<EntityRule, DocModelRuleEntity> fixups = new Dictionary<EntityRule, DocModelRuleEntity>();
foreach (ConceptTemplate mvdTemplate in mvd.Templates)
{
DocTemplateDefinition docDef = docProject.GetTemplate(mvdTemplate.Uuid);
if (docDef == null)
{
docDef = new DocTemplateDefinition();
docProject.Templates.Add(docDef);
}
ImportMvdTemplate(mvdTemplate, docDef, fixups);
}
foreach(EntityRule er in fixups.Keys)
{
DocModelRuleEntity docEntityRule = fixups[er];
if(er.References != null)
{
foreach(TemplateRef tr in er.References)
{
DocTemplateDefinition dtd = docProject.GetTemplate(tr.Ref);
if(dtd != null)
{
docEntityRule.References.Add(dtd);
}
}
}
}
}
if (mvd.Views != null)
{
foreach (ModelView mvdView in mvd.Views)
{
DocModelView docView = docProject.GetView(mvdView.Uuid);
if (docView == null)
{
docView = new DocModelView();
docProject.ModelViews.Add(docView);
}
ImportMvdObject(mvdView, docView);
docView.BaseView = mvdView.BaseView;
docView.Exchanges.Clear();
Dictionary<Guid, ExchangeRequirement> mapExchange = new Dictionary<Guid, ExchangeRequirement>();
foreach (ExchangeRequirement mvdExchange in mvdView.ExchangeRequirements)
{
mapExchange.Add(mvdExchange.Uuid, mvdExchange);
DocExchangeDefinition docExchange = new DocExchangeDefinition();
ImportMvdObject(mvdExchange, docExchange);
docView.Exchanges.Add(docExchange);
docExchange.Applicability = (DocExchangeApplicabilityEnum)mvdExchange.Applicability;
// attempt to find icons if exists -- remove extention
try
{
string iconpath = filepath.Substring(0, filepath.Length - 7) + @"\mvd-" + docExchange.Name.ToLower().Replace(' ', '-') + ".png";
if (System.IO.File.Exists(iconpath))
{
docExchange.Icon = System.IO.File.ReadAllBytes(iconpath);
}
}
catch
{
}
}
foreach (ConceptRoot mvdRoot in mvdView.Roots)
{
// find the entity
DocEntity docEntity = LookupEntity(docProject, mvdRoot.ApplicableRootEntity);
if (docEntity != null)
{
DocConceptRoot docConceptRoot = docView.GetConceptRoot(mvdRoot.Uuid);
if (docConceptRoot == null)
{
docConceptRoot = new DocConceptRoot();
if (docView.ConceptRoots == null)
{
docView.ConceptRoots = new List<DocConceptRoot>();
}
docView.ConceptRoots.Add(docConceptRoot);
}
ImportMvdObject(mvdRoot, docConceptRoot);
docConceptRoot.ApplicableEntity = docEntity;
if (mvdRoot.Applicability != null)
{
docConceptRoot.ApplicableTemplate = docProject.GetTemplate(mvdRoot.Applicability.Template.Ref);
if(mvdRoot.Applicability.TemplateRules != null)
{
docConceptRoot.ApplicableOperator = (DocTemplateOperator)Enum.Parse(typeof(TemplateOperator), mvdRoot.Applicability.TemplateRules.Operator.ToString());
foreach (TemplateRule r in mvdRoot.Applicability.TemplateRules.TemplateRule)
{
DocTemplateItem docItem = ImportMvdItem(r, docProject, mapExchange);
docConceptRoot.ApplicableItems.Add(docItem);
}
}
}
docConceptRoot.Concepts.Clear();
foreach (Concept mvdNode in mvdRoot.Concepts)
{
DocTemplateUsage docUse = new DocTemplateUsage();
docConceptRoot.Concepts.Add(docUse);
ImportMvdConcept(mvdNode, docUse, docProject, mapExchange);
}
}
else
{
//TODO: log error
}
}
}
}
}
public string FormatDataConcept(DocProject docProject, DocPublication docPublication, DocExchangeDefinition docExchange, Dictionary <string, DocObject> map, Dictionary <string, Type> typemap, Dictionary <long, SEntity> instances, SEntity root, bool markup, DocModelView docView, DocConceptRoot docRoot, DocTemplateUsage docConcept)
{
StringBuilder sb = new StringBuilder();
string table = docConcept.Items[0].GetParameterValue("Table");
string query = docConcept.Items[0].GetParameterValue("Reference");
sb.AppendLine("<h4>" + docConcept.Name + "</h4>");
sb.AppendLine("<table class=\"gridtable\">");
List <string> colstyles = new List <string>();
List <string> colformat = new List <string>();
List <CvtValuePath> colmaps = new List <CvtValuePath>();
// generate header row
sb.AppendLine("<tr>");
foreach (DocTemplateItem docItem in docConcept.Items)
{
string name = docItem.GetParameterValue("Name");
string disp = "#" + docItem.GetColor().ToArgb().ToString("X8"); //docItem.GetParameterValue("Color");docItem.GetParameterValue("Color");
string expr = docItem.GetParameterValue("Reference");
string form = docItem.GetParameterValue("Format");
string style = "";
if (!String.IsNullOrEmpty(disp))
{
style = " style=\"background-color:" + disp + ";\"";
}
colstyles.Add(style);
string format = "";
if (!String.IsNullOrEmpty(form))
{
format = form;
}
colformat.Add(format);
string desc = "";
CvtValuePath valpath = CvtValuePath.Parse(expr, map);
colmaps.Add(valpath);
if (valpath != null)
{
desc = /*valpath.GetDescription(map) + " " + */ valpath.ToString().Replace("\\", " ");
}
sb.Append("<th><a href=\"../../schema/views/" + DocumentationISO.MakeLinkName(docView) + "/" + DocumentationISO.MakeLinkName(docExchange) + ".htm#" + DocumentationISO.MakeLinkName(docConcept) + "\" title=\"" + desc + "\">");
sb.Append(name);
sb.Append("</a></th>");
}
;
sb.AppendLine("</tr>");
// generate data rows
List <DocModelRule> trace = new List <DocModelRule>();
foreach (SEntity e in instances.Values)
{
string eachname = e.GetType().Name;
if (docRoot.ApplicableEntity.IsInstanceOfType(e))
{
bool includerow = true;
// if root has more complex rules, check them
if (docRoot.ApplicableTemplate != null && docRoot.ApplicableItems.Count > 0)
{
includerow = false;
// must check1
foreach (DocTemplateItem docItem in docRoot.ApplicableItems)
{
foreach (DocModelRule rule in docRoot.ApplicableTemplate.Rules)
{
try
{
trace.Clear();
bool?result = rule.Validate(e, docItem, typemap, trace, e, null, null);
if (result == true && docRoot.ApplicableOperator == DocTemplateOperator.Or)
{
includerow = true;
break;
}
}
catch
{
docRoot.ToString();
}
}
// don't yet support AND or other operators
if (includerow)
{
break;
}
}
}
if (includerow)
{
StringBuilder sbRow = new StringBuilder();
sbRow.Append("<tr>");
int iCol = 0;
foreach (DocTemplateItem docItem in docConcept.Items)
{
sbRow.Append("<td" + colstyles[iCol]);
CvtValuePath valpath = colmaps[iCol];
string format = colformat[iCol];
iCol++;
if (valpath != null)
{
string nn = docItem.GetParameterValue("Name");
object value = valpath.GetValue(e, null);
if (value == e)
{
value = e.GetType().Name;
}
else if (value is SEntity)
{
// use name
FieldInfo fieldValue = value.GetType().GetField("Name");
if (fieldValue != null)
{
value = fieldValue.GetValue(value);
}
}
else if (value is System.Collections.IList)
{
System.Collections.IList list = (System.Collections.IList)value;
StringBuilder sbList = new StringBuilder();
foreach (object elem in list)
{
FieldInfo fieldName = elem.GetType().GetField("Name");
if (fieldName != null)
{
object elemname = fieldName.GetValue(elem);
if (elemname != null)
{
FieldInfo fieldValue = elemname.GetType().GetField("Value");
if (fieldValue != null)
{
object elemval = fieldValue.GetValue(elemname);
sbList.Append(elemval.ToString());
}
}
}
sbList.Append("; <br/>");
}
value = sbList.ToString();
}
else if (value is Type)
{
value = ((Type)value).Name;
}
if (!String.IsNullOrEmpty(format))
{
if (format.Equals("Required") && value == null)
{
includerow = false;
}
}
if (value != null)
{
FieldInfo fieldValue = value.GetType().GetField("Value");
if (fieldValue != null)
{
value = fieldValue.GetValue(value);
}
if (format != null && format.Equals("True") && (value == null || !value.ToString().Equals("True")))
{
includerow = false;
}
if (value is Double)
{
sbRow.Append(" align=\"right\">");
sbRow.Append(((Double)value).ToString("N3"));
}
else if (value is List <Int64> )
{
sbRow.Append(">");
// latitude or longitude
List <Int64> intlist = (List <Int64>)value;
if (intlist.Count >= 3)
{
sbRow.Append(intlist[0] + "° " + intlist[1] + "' " + intlist[2] + "\"");
}
}
else if (value != null)
{
sbRow.Append(">");
sbRow.Append(value.ToString()); // todo: html-encode
}
}
else
{
sbRow.Append(">");
sbRow.Append(" ");
}
}
else
{
sbRow.Append(">");
}
sbRow.Append("</td>");
}
sbRow.AppendLine("</tr>");
if (includerow)
{
sb.Append(sbRow.ToString());
}
}
}
}
sb.AppendLine("</table>");
sb.AppendLine("<br/>");
return(sb.ToString());
}
