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()); }