private TreeNode LoadTemplateGraph(TreeNode tnParent, DocModelRule docRule) { TreeNode tnRule = LoadTemplateRuleNode(tnParent, docRule, docRule.Name); UpdateTemplateGraph(tnRule); tnRule.Nodes.Clear(); foreach (DocModelRule docSub in docRule.Rules) { LoadTemplateGraph(tnRule, docSub); } if (docRule is DocModelRuleEntity) { DocModelRuleEntity dme = (DocModelRuleEntity)docRule; foreach (DocTemplateDefinition dtd in dme.References) { TreeNode tnTemplate = LoadTemplateRuleNode(tnRule, dtd, dtd.Name); if (dtd.Rules != null) { foreach (DocModelRule docTemplateRule in dtd.Rules) { LoadTemplateGraph(tnTemplate, docTemplateRule); } } } } return(tnRule); }
private void UpdateTemplateGraph(TreeNode tnRule) { DocModelRule docRule = (DocModelRule)tnRule.Tag; tnRule.Text = docRule.Name; if (this.m_parent != null) { DocModelRule[] objpath = this.m_parent.GetRulePath(tnRule.FullPath); if (objpath != null && objpath[objpath.Length - 1] != null) { tnRule.ForeColor = Color.Gray; } } string tooltip = docRule.Name; // decorative text doesn't allow treeview path to work -- use tooltip in UI now instead //tooltip += docRule.GetCardinalityExpression(); if (!String.IsNullOrEmpty(docRule.Identification)) { tooltip += " <" + docRule.Identification + ">"; tnRule.BackColor = Color.LightBlue; // mark parameter } else { tnRule.BackColor = Color.Empty; } tnRule.ToolTipText = tooltip; }
private void toolStripButtonTemplateUpdate_Click(object sender, EventArgs e) { if (this.treeViewTemplate.SelectedNode != null && this.treeViewTemplate.SelectedNode.Tag is DocModelRule) { DocModelRule docRule = (DocModelRule)this.treeViewTemplate.SelectedNode.Tag; if (docRule is DocModelRuleConstraint) { using (FormConstraint form = new FormConstraint()) { form.Expression = docRule.Description; DialogResult res = form.ShowDialog(this); if (res == DialogResult.OK) { docRule.Description = form.Expression; docRule.Name = form.Expression; // repeat for visibility } } } else { using (FormRule form = new FormRule(docRule)) { form.ShowDialog(this); } } // update text in treeview this.UpdateTemplateGraph(this.treeViewTemplate.SelectedNode); // propagate rule this.m_template.PropagateRule(this.treeViewTemplate.SelectedNode.FullPath); } }
private void MoveRule(int offset) { TreeNode tnSelect = this.treeViewTemplate.SelectedNode; TreeNode tnParent = tnSelect.Parent; DocModelRule ruleSelect = (DocModelRule)tnSelect.Tag; if (tnParent.Tag is DocModelRule) { DocModelRule ruleParent = (DocModelRule)tnParent.Tag; int index = ruleParent.Rules.IndexOf(ruleSelect); ruleParent.Rules.RemoveAt(index); index += offset; ruleParent.Rules.Insert(index, ruleSelect); tnSelect.Remove(); tnParent.Nodes.Insert(index, tnSelect); } else if (tnParent.Tag is DocTemplateDefinition) { DocTemplateDefinition ruleParent = (DocTemplateDefinition)tnParent.Tag; int index = ruleParent.Rules.IndexOf(ruleSelect); ruleParent.Rules.RemoveAt(index); index += offset; ruleParent.Rules.Insert(index, ruleSelect); tnSelect.Remove(); tnParent.Nodes.Insert(index, tnSelect); } this.treeViewTemplate.SelectedNode = tnSelect; }
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??? } } } List <DocTemplateItem> listItems = null; if (this.m_conceptleaf != null) { listItems = this.m_conceptleaf.Items; } else { listItems = this.m_conceptroot.ApplicableItems; } if (listItems.Count > e.RowIndex) { DocTemplateItem docItem = listItems[e.RowIndex]; docItem.RuleParameters = sb.ToString(); object val = this.dataGridViewConceptRules[this.dataGridViewConceptRules.Columns.Count - 1, e.RowIndex].Value; docItem.Documentation = val as string; object usage = this.dataGridViewConceptRules[0, e.RowIndex].Value; docItem.SetUsage(usage as string); } }
private void treeViewTemplate_AfterSelect(object sender, TreeViewEventArgs e) { this.m_attribute = null; this.m_selection = e.Node.Tag as DocModelRule; UpdateCommands(); if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } }
private void CtlConcept_MouseMove(object sender, MouseEventArgs e) { Point pt = e.Location; pt.X -= this.AutoScrollPosition.X; pt.Y -= this.AutoScrollPosition.Y; DocAttribute attr; this.m_highlight = Pick(pt, out this.m_iHighlight, out attr, out this.m_rcHighlight); this.Invalidate(); }
public FormRule(DocModelRule rule, DocProject project, DocTemplateDefinition template) : this() { this.m_rule = rule; this.m_project = project; this.m_template = template; this.Text = this.m_rule.Name; this.textBoxIdentifier.Text = this.m_rule.Identification; this.textBoxIdentifier.Enabled = !String.IsNullOrEmpty(this.m_rule.Identification); if (String.IsNullOrEmpty(this.m_rule.Identification)) { this.comboBoxUsage.SelectedIndex = 0; } else if (this.m_rule.Description != null && this.m_rule.Description.Equals("*")) { // convention indicating filter this.comboBoxUsage.SelectedIndex = 1; } else { // indicates parameter constraint this.comboBoxUsage.SelectedIndex = 2; } if (rule is DocModelRuleEntity) { this.textBoxPrefix.Enabled = true; this.textBoxPrefix.Text = ((DocModelRuleEntity)rule).Prefix; } if (this.m_rule.CardinalityMin == 0 && this.m_rule.CardinalityMax == 0) { this.comboBoxCardinality.SelectedIndex = 0; } else if (this.m_rule.CardinalityMin == -1 && this.m_rule.CardinalityMax == -1) { this.comboBoxCardinality.SelectedIndex = 1; } else if (this.m_rule.CardinalityMin == 0 && this.m_rule.CardinalityMax == 1) { this.comboBoxCardinality.SelectedIndex = 2; } else if (this.m_rule.CardinalityMin == 1 && this.m_rule.CardinalityMax == 1) { this.comboBoxCardinality.SelectedIndex = 3; } else if (this.m_rule.CardinalityMin == 1 && this.m_rule.CardinalityMax == -1) { this.comboBoxCardinality.SelectedIndex = 4; } }
private void CtlConcept_MouseDown(object sender, MouseEventArgs e) { Point pt = e.Location; pt.X -= this.AutoScrollPosition.X; pt.Y -= this.AutoScrollPosition.Y; this.m_selection = Pick(pt, out this.m_iSelection, out this.m_attribute, out this.m_rcSelection); this.Invalidate(); if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } }
private void toolStripButtonTemplateRemove_Click(object sender, EventArgs e) { if (this.treeViewTemplate.SelectedNode.Tag is DocTemplateDefinition) { DocTemplateDefinition dtd = (DocTemplateDefinition)this.treeViewTemplate.SelectedNode.Tag; if (treeViewTemplate.SelectedNode.Parent != null) { DocModelRuleEntity dme = (DocModelRuleEntity)this.treeViewTemplate.SelectedNode.Parent.Tag; dme.References.Remove(dtd); this.m_template.PropagateRule(this.treeViewTemplate.SelectedNode.Parent.FullPath); this.treeViewTemplate.SelectedNode.Remove(); } else { this.m_template.Type = null; this.treeViewTemplate.Nodes.Clear(); } UpdateCommands(); this.ContentChanged(this, EventArgs.Empty); return; } DocModelRule ruleTarget = this.treeViewTemplate.SelectedNode.Tag as DocModelRule; DocModelRule ruleParent = null; if (this.treeViewTemplate.SelectedNode.Parent != null) { ruleParent = this.treeViewTemplate.SelectedNode.Parent.Tag as DocModelRule; } if (ruleParent != null) { ruleParent.Rules.Remove(ruleTarget); } else { this.m_template.Rules.Remove(ruleTarget); } // copy to child templates (before clearing selection) this.m_template.PropagateRule(this.treeViewTemplate.SelectedNode.FullPath); ruleTarget.Delete(); this.treeViewTemplate.SelectedNode.Remove(); this.ContentChanged(this, EventArgs.Empty); }
public FormRule(DocModelRule rule, DocProject project, DocTemplateDefinition template) : this() { this.m_rule = rule; this.m_project = project; this.m_template = template; this.Text = this.m_rule.Name; this.textBoxIdentifier.Text = this.m_rule.Identification; this.textBoxIdentifier.Enabled = !String.IsNullOrEmpty(this.m_rule.Identification); if (String.IsNullOrEmpty(this.m_rule.Identification)) { this.comboBoxUsage.SelectedIndex = 0; } else if (this.m_rule.Description != null && this.m_rule.Description.Equals("*")) { // convention indicating filter this.comboBoxUsage.SelectedIndex = 1; } else { // indicates parameter constraint this.comboBoxUsage.SelectedIndex = 2; } if (this.m_rule.CardinalityMin == 0 && this.m_rule.CardinalityMax == 0) { this.comboBoxCardinality.SelectedIndex = 0; } else if (this.m_rule.CardinalityMin == -1 && this.m_rule.CardinalityMax == -1) { this.comboBoxCardinality.SelectedIndex = 1; } else if (this.m_rule.CardinalityMin == 0 && this.m_rule.CardinalityMax == 1) { this.comboBoxCardinality.SelectedIndex = 2; } else if (this.m_rule.CardinalityMin == 1 && this.m_rule.CardinalityMax == 1) { this.comboBoxCardinality.SelectedIndex = 3; } else if (this.m_rule.CardinalityMin == 1 && this.m_rule.CardinalityMax == -1) { this.comboBoxCardinality.SelectedIndex = 4; } this.UpdateBehavior(); }
public FormRule(DocModelRule rule) : this() { this.m_rule = rule; this.Text = this.m_rule.Name; this.textBoxIdentifier.Text = this.m_rule.Identification; this.textBoxIdentifier.Enabled = !String.IsNullOrEmpty(this.m_rule.Identification); if (String.IsNullOrEmpty(this.m_rule.Identification)) { this.comboBoxUsage.SelectedIndex = 0; } else if (this.m_rule.Description != null && this.m_rule.Description.Equals("*")) { // convention indicating filter this.comboBoxUsage.SelectedIndex = 1; } else { // indicates parameter constraint this.comboBoxUsage.SelectedIndex = 2; } if (this.m_rule.CardinalityMin == 0 && this.m_rule.CardinalityMax == 0) { this.comboBoxCardinality.SelectedIndex = 0; } else if (this.m_rule.CardinalityMin == -1 && this.m_rule.CardinalityMax == -1) { this.comboBoxCardinality.SelectedIndex = 1; } else if (this.m_rule.CardinalityMin == 0 && this.m_rule.CardinalityMax == 1) { this.comboBoxCardinality.SelectedIndex = 2; } else if (this.m_rule.CardinalityMin == 1 && this.m_rule.CardinalityMax == 1) { this.comboBoxCardinality.SelectedIndex = 3; } else if (this.m_rule.CardinalityMin == 1 && this.m_rule.CardinalityMax == -1) { this.comboBoxCardinality.SelectedIndex = 4; } this.UpdateBehavior(); }
private void dataGridViewConceptRules_CellEnter(object sender, DataGridViewCellEventArgs e) { if (this.m_columns == null) { return; } if (e.ColumnIndex >= 0 && e.ColumnIndex < this.m_columns.Length) { this.m_selectedcolumn = this.m_columns[e.ColumnIndex]; } else { this.m_selectedcolumn = null; } if (this.SelectedColumnChanged != null) { this.SelectedColumnChanged(this, EventArgs.Empty); } }
private static CardinalityType ExportCardinalityType(DocModelRule rule) { if (rule.CardinalityMin == 0 && rule.CardinalityMax == 0) { return CardinalityType._asSchema; } else if (rule.CardinalityMin == -1 && rule.CardinalityMax == -1) { return CardinalityType.Zero; } else if (rule.CardinalityMin == 0 && rule.CardinalityMax == 1) { return CardinalityType.ZeroToOne; } else if (rule.CardinalityMin == 1 && rule.CardinalityMax == 1) { return CardinalityType.One; } else if (rule.CardinalityMin == 1 && rule.CardinalityMax == -1) { return CardinalityType.OneToMany; } return CardinalityType._asSchema; }
private void CtlConcept_MouseDown(object sender, MouseEventArgs e) { Point pt = e.Location; pt.X -= this.AutoScrollPosition.X; pt.Y -= this.AutoScrollPosition.Y; this.m_selection = Pick(pt, out this.m_iSelection, out this.m_attribute, out this.m_rcSelection); this.Invalidate(); if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } }
private void CtlConcept_MouseMove(object sender, MouseEventArgs e) { Point pt = e.Location; pt.X -= this.AutoScrollPosition.X; pt.Y -= this.AutoScrollPosition.Y; DocAttribute attr; this.m_highlight = Pick(pt, out this.m_iHighlight, out attr, out this.m_rcHighlight); this.Invalidate(); }
public void DoInsert() { if (this.m_template == null) { return; } if (this.treeViewTemplate.Nodes.Count == 0) { DocEntity docEntityBase = null; if (this.m_parent is DocTemplateDefinition) { string classname = ((DocTemplateDefinition)this.m_parent).Type; docEntityBase = this.m_project.GetDefinition(classname) as DocEntity; } // get selected entity DocEntity docEntityThis = this.m_project.GetDefinition(this.m_template.Type) as DocEntity; using (FormSelectEntity form = new FormSelectEntity(docEntityBase, docEntityThis, this.m_project, SelectDefinitionOptions.Entity)) { DialogResult res = form.ShowDialog(this); if (res == DialogResult.OK && form.SelectedEntity != null) { this.m_template.Type = form.SelectedEntity.Name; this.LoadTemplateGraph(); this.ContentChanged(this, EventArgs.Empty); } } return; } if (this.m_attribute != null && !String.IsNullOrEmpty(this.m_attribute.DefinedType)) { DocTemplateDefinition docTemplate = this.m_template; DocAttribute docAttribute = this.m_attribute; string entityname = null; switch (this.m_attribute.DefinedType) { case "BOOLEAN": case "LOGICAL": case "BINARY": case "STRING": case "REAL": case "INTEGER": case "NUMBER": entityname = this.m_attribute.DefinedType; break; default: { // qualify schema DocObject docobj = null; if (!String.IsNullOrEmpty(this.m_template.Code)) { foreach (DocSection docSection in this.m_project.Sections) { foreach (DocSchema docSchema in docSection.Schemas) { if (docSchema.Name.Equals(this.m_template.Code, StringComparison.OrdinalIgnoreCase)) { docobj = docSchema.GetDefinition(docAttribute.DefinedType); break; } } } } if (docobj == null) { docobj = this.m_project.GetDefinition(docAttribute.DefinedType); } using (FormSelectEntity form = new FormSelectEntity((DocDefinition)docobj, null, this.m_project, SelectDefinitionOptions.Entity | SelectDefinitionOptions.Type)) { DialogResult res = form.ShowDialog(this); if (res == DialogResult.OK && form.SelectedEntity != null) { entityname = form.SelectedEntity.Name; } } break; } } if (entityname != null) { // get or add attribute rule TreeNode tn = this.treeViewTemplate.SelectedNode; DocModelRuleAttribute docRuleAtt = null; if (this.treeViewTemplate.SelectedNode.Tag is DocModelRuleAttribute) { docRuleAtt = (DocModelRuleAttribute)this.treeViewTemplate.SelectedNode.Tag; } else { docRuleAtt = new DocModelRuleAttribute(); docRuleAtt.Name = docAttribute.Name; if (this.treeViewTemplate.SelectedNode.Tag is DocModelRuleEntity) { DocModelRuleEntity docRuleEnt = (DocModelRuleEntity)this.treeViewTemplate.SelectedNode.Tag; docRuleEnt.Rules.Add(docRuleAtt); } else if (this.treeViewTemplate.SelectedNode.Tag is DocTemplateDefinition) { docTemplate.Rules.Add(docRuleAtt); } tn = this.LoadTemplateGraph(tn, docRuleAtt); } // get and add entity rule DocModelRuleEntity docRuleEntity = new DocModelRuleEntity(); docRuleEntity.Name = entityname; docRuleAtt.Rules.Add(docRuleEntity); this.treeViewTemplate.SelectedNode = this.LoadTemplateGraph(tn, docRuleEntity); // copy to child templates docTemplate.PropagateRule(this.treeViewTemplate.SelectedNode.FullPath); this.m_selection = docRuleEntity; this.ContentChanged(this, EventArgs.Empty); this.SelectionChanged(this, EventArgs.Empty); } } else { // pick attribute, including attribute that may be on subtype DocModelRule rule = null; if (this.treeViewTemplate.SelectedNode != null) { rule = this.treeViewTemplate.SelectedNode.Tag as DocModelRule; } //if (rule == null) // return; DocTemplateDefinition docTemplate = (DocTemplateDefinition)this.m_template; string typename = null; if (rule is DocModelRuleEntity) { DocModelRuleEntity docRuleEntity = (DocModelRuleEntity)rule; typename = docRuleEntity.Name; } else { // get applicable entity of target (or parent entity rule) typename = docTemplate.Type; } DocEntity docEntity = this.m_project.GetDefinition(typename) as DocEntity; if (docEntity == null) { // launch dialog for constraint using (FormConstraint form = new FormConstraint()) { DialogResult res = form.ShowDialog(this); if (res == DialogResult.OK) { DocModelRuleConstraint docRuleConstraint = new DocModelRuleConstraint(); rule.Rules.Add(docRuleConstraint); docRuleConstraint.Description = form.Expression; docRuleConstraint.Name = form.Expression; // for viewing this.treeViewTemplate.SelectedNode = this.LoadTemplateGraph(this.treeViewTemplate.SelectedNode, docRuleConstraint); // copy to child templates docTemplate.PropagateRule(this.treeViewTemplate.SelectedNode.FullPath); } } } else { // launch dialog to pick attribute of entity using (FormSelectAttribute form = new FormSelectAttribute(docEntity, this.m_project, null, true)) { DialogResult res = form.ShowDialog(this); if (res == DialogResult.OK && form.Selection != null) { // then add and update tree DocModelRuleAttribute docRuleAttr = new DocModelRuleAttribute(); docRuleAttr.Name = form.Selection; if (rule != null) { rule.Rules.Add(docRuleAttr); } else { docTemplate.Rules.Add(docRuleAttr); } this.treeViewTemplate.SelectedNode = this.LoadTemplateGraph(this.treeViewTemplate.SelectedNode, docRuleAttr); // copy to child templates docTemplate.PropagateRule(this.treeViewTemplate.SelectedNode.FullPath); } } } } }
public static CvtValuePath FromTemplateDefinition(DocTemplateDefinition dtd, DocProject docProject) { if (dtd.Rules.Count > 0 && dtd.Rules[0] is DocModelRuleAttribute) { DocModelRuleAttribute docRuleAtt = (DocModelRuleAttribute)dtd.Rules[0]; DocEntity docEnt = docProject.GetDefinition(dtd.Type) as DocEntity; if (docEnt != null) { CvtValuePath pathInner = null; if (docRuleAtt.Rules.Count > 0 && docRuleAtt.Rules[0] is DocModelRuleEntity) { pathInner = FromModelRule((DocModelRuleEntity)docRuleAtt.Rules[0], docProject); } DocAttribute docAtt = docEnt.ResolveAttribute(docRuleAtt.Name, docProject); string identifier = null; if (docRuleAtt.Name.Equals("IsDefinedBy")) { // hack for compat docRuleAtt.ToString(); // look for identifier if (docRuleAtt.Rules.Count > 0) { try { DocModelRule rule0 = docRuleAtt.Rules[0]; if (rule0.Rules.Count > 0) { DocModelRule rule1 = rule0.Rules[0]; if (rule1.Rules.Count > 0) { DocModelRule rule2 = rule1.Rules[0]; if (rule2.Rules.Count > 1) { DocModelRule rule3 = rule2.Rules[1]; if (rule3.Rules.Count > 0) { DocModelRule rule4 = rule3.Rules[0]; if (rule4.Rules.Count > 0) { DocModelRuleConstraint docRuleIndexCon = rule4.Rules[0] as DocModelRuleConstraint; if (docRuleIndexCon != null) { if (docRuleIndexCon.Expression is DocOpStatement) { DocOpStatement docOpStatement = (DocOpStatement)docRuleIndexCon.Expression; if (docOpStatement.Value != null) { identifier = docOpStatement.Value.ToString(); if (identifier.StartsWith("'") && identifier.EndsWith("'")) { identifier = identifier.Substring(1, identifier.Length - 2); } } } } } } } } } } catch { } } } CvtValuePath pathRoot = new CvtValuePath(docEnt, docAtt, identifier, pathInner); return(pathRoot); } } return(null); }
private string FormatRule(DocModelRule rule, string key) { string comp = null; if (rule.Identification == null || !rule.Identification.Equals(key)) { // recurse foreach (DocModelRule sub in rule.Rules) { comp = FormatRule(sub, key); if (comp != null) { break; } } if (comp == null) return null; } // generate rule if found if (rule is DocModelRuleAttribute) { return "." + rule.Name + comp; } else if (rule is DocModelRuleEntity) { return @"\" + rule.Name + comp; } return null; }
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); } } } } }
private void dataGridViewConceptRules_CellEnter(object sender, DataGridViewCellEventArgs e) { if (this.m_columns == null) return; if (e.ColumnIndex >= 0 && e.ColumnIndex < this.m_columns.Length) { this.m_selectedcolumn = this.m_columns[e.ColumnIndex]; } else { this.m_selectedcolumn = null; } if (this.SelectedColumnChanged != null) { this.SelectedColumnChanged(this, EventArgs.Empty); } }
private void LoadRules(List<DocModelRule> list, DocModelRule parentrule) { if (list == null) return; foreach (DocModelRule docRule in list) { if (docRule is DocModelRuleConstraint) { DocModelRuleConstraint rc = (DocModelRuleConstraint)docRule; TreeNode tn = new TreeNode(); tn.Tag = docRule; tn.Text = docRule.Description; tn.ImageIndex = 4; this.treeViewRules.Nodes.Add(tn); // backward compatibility before V6.1 -- generate rule from syntax if (rc.Expression == null && docRule.Description != null) { DocOpReference reference = new DocOpReference(); reference.EntityRule = parentrule as DocModelRuleEntity; DocOpLiteral literal = new DocOpLiteral(); DocOpStatement statement = new DocOpStatement(); statement.Reference = reference; statement.Value = literal; rc.Expression = statement; string value = docRule.Description; int index = value.IndexOfAny(new char[] { '=', '!', '>', '<' }); if (index > 0) { string metric = value.Substring(0, index); switch (metric) { case "Value": ///... break; case "Length": ///... break; } string oper = value.Substring(index, 1); string bench = value.Substring(index + 1); if (value.Length > index + 1 && value[index + 1] == '=') { oper = value.Substring(index, 2); bench = value.Substring(index + 2); } switch (oper) { case "=": statement.Operation = DocOpCode.CompareEqual; break; case "!=": statement.Operation = DocOpCode.CompareNotEqual; break; case "<=": statement.Operation = DocOpCode.CompareLessThanOrEqual; break; case "<": statement.Operation = DocOpCode.CompareLessThan; break; case ">=": statement.Operation = DocOpCode.CompareGreaterThanOrEqual; break; case ">": statement.Operation = DocOpCode.CompareGreaterThan; break; } literal.Literal = bench; } } LoadOpExpression(tn, rc.Expression); } LoadRules(docRule.Rules, docRule); } }
private void treeViewTemplate_AfterSelect(object sender, TreeViewEventArgs e) { this.m_attribute = null; this.m_selection = e.Node.Tag as DocModelRule; UpdateCommands(); if (this.SelectionChanged != null) { this.SelectionChanged(this, EventArgs.Empty); } }
private static void ExportMvdRule(AttributeRule mvdRule, DocModelRule docRule) { if (!String.IsNullOrEmpty(docRule.Identification)) { mvdRule.RuleID = docRule.Identification; } mvdRule.Description = docRule.Description; mvdRule.AttributeName = docRule.Name; //mvdRule.Cardinality = ExportCardinalityType(docRule); foreach (DocModelRule docRuleEntity in docRule.Rules) { if (docRuleEntity is DocModelRuleEntity) { if(mvdRule.EntityRules == null) { mvdRule.EntityRules = new List<EntityRule>(); } EntityRule mvdRuleEntity = new EntityRule(); mvdRule.EntityRules.Add(mvdRuleEntity); mvdRuleEntity.RuleID = docRuleEntity.Identification; mvdRuleEntity.Description = docRuleEntity.Description; mvdRuleEntity.EntityName = docRuleEntity.Name; //mvdRuleEntity.Cardinality = ExportCardinalityType(docRuleEntity); foreach (DocModelRule docRuleAttribute in docRuleEntity.Rules) { if (docRuleAttribute is DocModelRuleAttribute) { if(mvdRuleEntity.AttributeRules == null) { mvdRuleEntity.AttributeRules = new List<AttributeRule>(); } AttributeRule mvdRuleAttribute = new AttributeRule(); mvdRuleEntity.AttributeRules.Add(mvdRuleAttribute); ExportMvdRule(mvdRuleAttribute, docRuleAttribute); } else if (docRuleAttribute is DocModelRuleConstraint && !String.IsNullOrEmpty(docRuleAttribute.Description)) { if(mvdRuleEntity.Constraints == null) { mvdRuleEntity.Constraints = new List<Constraint>(); } Constraint mvdConstraint = new Constraint(); mvdRuleEntity.Constraints.Add(mvdConstraint); mvdConstraint.Expression = docRuleAttribute.Description; } } DocModelRuleEntity dme = (DocModelRuleEntity)docRuleEntity; if(dme.References.Count > 0) { mvdRuleEntity.References = new List<TemplateRef>(); foreach (DocTemplateDefinition dtd in dme.References) { TemplateRef tr = new TemplateRef(); tr.Ref = dtd.Uuid; mvdRuleEntity.References.Add(tr); } } } else if (docRuleEntity is DocModelRuleConstraint) { if(mvdRule.Constraints == null) { mvdRule.Constraints = new List<Constraint>(); } Constraint mvdConstraint = new Constraint(); mvdRule.Constraints.Add(mvdConstraint); mvdConstraint.Expression = docRuleEntity.Description; } } }
private void LoadRules(List <DocModelRule> list, DocModelRule parentrule) { if (list == null) { return; } foreach (DocModelRule docRule in list) { if (docRule is DocModelRuleConstraint) { DocModelRuleConstraint rc = (DocModelRuleConstraint)docRule; TreeNode tn = new TreeNode(); tn.Tag = docRule; tn.Text = docRule.Description; tn.ImageIndex = 4; this.treeViewRules.Nodes.Add(tn); // backward compatibility before V6.1 -- generate rule from syntax if (rc.Expression == null && docRule.Description != null) { DocOpReference reference = new DocOpReference(); reference.EntityRule = parentrule as DocModelRuleEntity; DocOpLiteral literal = new DocOpLiteral(); DocOpStatement statement = new DocOpStatement(); statement.Reference = reference; statement.Value = literal; rc.Expression = statement; string value = docRule.Description; int index = value.IndexOfAny(new char[] { '=', '!', '>', '<' }); if (index > 0) { string metric = value.Substring(0, index); switch (metric) { case "Value": ///... break; case "Length": ///... break; } string oper = value.Substring(index, 1); string bench = value.Substring(index + 1); if (value.Length > index + 1 && value[index + 1] == '=') { oper = value.Substring(index, 2); bench = value.Substring(index + 2); } switch (oper) { case "=": statement.Operation = DocOpCode.CompareEqual; break; case "!=": statement.Operation = DocOpCode.CompareNotEqual; break; case "<=": statement.Operation = DocOpCode.CompareLessThanOrEqual; break; case "<": statement.Operation = DocOpCode.CompareLessThan; break; case ">=": statement.Operation = DocOpCode.CompareGreaterThanOrEqual; break; case ">": statement.Operation = DocOpCode.CompareGreaterThan; break; } literal.Literal = bench; } } LoadOpExpression(tn, rc.Expression); } LoadRules(docRule.Rules, docRule); } }
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); } }
private void InitUsageFromTemplateRule(DocTemplateDefinition docTemp, DocTemplateDefinition docSource, DocModelRule docRule) { if (docRule is DocModelRuleEntity) { DocModelRuleEntity docRuleEntity = (DocModelRuleEntity)docRule; if (docRuleEntity.References.Contains(docSource)) { DocObject[] usagepath = new DocObject[] { docTemp }; ListViewItem lvi = new ListViewItem(); lvi.Tag = usagepath; lvi.Text = "[Template]"; lvi.SubItems.Add(docTemp.Name); this.listViewUsage.Items.Add(lvi); } } // recurse foreach(DocModelRule docInner in docRule.Rules) { InitUsageFromTemplateRule(docTemp, docSource, docInner); } }
private bool TraceRule(DocTemplateDefinition template, DocModelRule rule, StringBuilder sb, SEntity ent, List<SEntity> population) { bool pass = true; if (rule is DocModelRuleConstraint) { DocModelRuleConstraint ruleCon = (DocModelRuleConstraint)rule; object result = TraceOperation(template, ruleCon.Expression, sb, ent, population, 0); if(result is bool && !((bool)result)) pass = false; } foreach(DocModelRule sub in rule.Rules) { bool eachpass = TraceRule(template, sub, sb, ent, population); if (!eachpass) pass = false; } return pass; }
private static void WriteModelRule(FormatHTM format, DocModelRule docRule, string path) { format.Write("<tr><td>" + path + "</td><td>" + /*docRule.GetCardinalityExpression() + */"</td><td>" + docRule.Identification + "</td></tr>"); if (docRule.Rules != null) { foreach (DocModelRule docSub in docRule.Rules) { if (docSub is DocModelRuleAttribute) { WriteModelRule(format, docSub, path + "." + docSub.Name); } else if (docSub is DocModelRuleEntity) { WriteModelRule(format, docSub, path + "\\" + docSub.Name); } } } }
internal static void ImportMvdCardinality(DocModelRule docRule, CardinalityType cardinality) { switch (cardinality) { case CardinalityType._asSchema: docRule.CardinalityMin = 0; docRule.CardinalityMax = 0; // same as unitialized file break; case CardinalityType.Zero: docRule.CardinalityMin = -1; // means 0:0 docRule.CardinalityMax = -1; break; case CardinalityType.ZeroToOne: docRule.CardinalityMin = 0; docRule.CardinalityMax = 1; break; case CardinalityType.One: docRule.CardinalityMin = 1; docRule.CardinalityMax = 1; break; case CardinalityType.OneToMany: docRule.CardinalityMin = 1; docRule.CardinalityMax = -1; break; } }
private MethodInfo RegisterTemplate(DocTemplateDefinition dtd) { if (dtd == null || dtd.Rules == null) { return(null); } MethodInfo methodexist = null; if (this.m_templates.TryGetValue(dtd, out methodexist)) { return(methodexist); } Type[] paramtypes = null; DocModelRule[] parameters = dtd.GetParameterRules(); if (parameters != null && parameters.Length > 0) { paramtypes = new Type[parameters.Length]; for (int iParam = 0; iParam < parameters.Length; iParam++) { #if false DocModelRule param = parameters[iParam]; if (param is DocModelRuleAttribute) { DocDefinition paramtype = dtd.GetParameterType(param.Name, this.m_definitions); if (paramtype != null) { paramtypes[iParam] = RegisterType(paramtype.Name); } } else if (param is DocModelRuleEntity) { paramtypes[iParam] = RegisterType(param.Name); } #endif if (paramtypes[iParam] == null) { paramtypes[iParam] = typeof(string); // fallback } } } if (dtd.Type == null) { return(null); } TypeBuilder tb = (System.Reflection.Emit.TypeBuilder) this.RegisterType(dtd.Type); if (tb == null) { return(null); } string methodname; if (dtd.Name != null) { methodname = dtd.Name; } else { methodname = dtd.UniqueId; } methodname = methodname.Replace(' ', '_').Replace(':', '_').Replace('-', '_'); MethodBuilder method = tb.DefineMethod(methodname, MethodAttributes.Public, CallingConventions.HasThis, typeof(bool), paramtypes); ILGenerator generator = method.GetILGenerator(); foreach (DocModelRule docRule in dtd.Rules) { docRule.EmitInstructions(this, generator, dtd); } // if made it to the end, then successful, so return true generator.Emit(OpCodes.Ldc_I4_1); generator.Emit(OpCodes.Ret); return(method); }
public void DoInsert() { if (this.m_template == null) return; if (this.treeViewTemplate.Nodes.Count == 0) { DocEntity docEntityBase = null; if (this.m_parent is DocTemplateDefinition) { string classname = ((DocTemplateDefinition)this.m_parent).Type; docEntityBase = this.m_project.GetDefinition(classname) as DocEntity; } // get selected entity DocEntity docEntityThis = this.m_project.GetDefinition(this.m_template.Type) as DocEntity; using (FormSelectEntity form = new FormSelectEntity(docEntityBase, docEntityThis, this.m_project, SelectDefinitionOptions.Entity)) { DialogResult res = form.ShowDialog(this); if (res == DialogResult.OK && form.SelectedEntity != null) { this.m_template.Type = form.SelectedEntity.Name; this.LoadTemplateGraph(); this.ContentChanged(this, EventArgs.Empty); } } return; } if (this.m_attribute != null && !String.IsNullOrEmpty(this.m_attribute.DefinedType)) { DocTemplateDefinition docTemplate = this.m_template; DocAttribute docAttribute = this.m_attribute; string entityname = null; switch (this.m_attribute.DefinedType) { case "BOOLEAN": case "LOGICAL": case "BINARY": case "STRING": case "REAL": case "INTEGER": case "NUMBER": entityname = this.m_attribute.DefinedType; break; default: { // qualify schema DocObject docobj = null; if (!String.IsNullOrEmpty(this.m_template.Code)) { foreach(DocSection docSection in this.m_project.Sections) { foreach (DocSchema docSchema in docSection.Schemas) { if (docSchema.Name.Equals(this.m_template.Code, StringComparison.OrdinalIgnoreCase)) { docobj = docSchema.GetDefinition(docAttribute.DefinedType); break; } } } } if (docobj == null) { docobj = this.m_project.GetDefinition(docAttribute.DefinedType); } using (FormSelectEntity form = new FormSelectEntity((DocDefinition)docobj, null, this.m_project, SelectDefinitionOptions.Entity | SelectDefinitionOptions.Type)) { DialogResult res = form.ShowDialog(this); if (res == DialogResult.OK && form.SelectedEntity != null) { entityname = form.SelectedEntity.Name; } } break; } } if (entityname != null) { // get or add attribute rule TreeNode tn = this.treeViewTemplate.SelectedNode; DocModelRuleAttribute docRuleAtt = null; if (this.treeViewTemplate.SelectedNode.Tag is DocModelRuleAttribute) { docRuleAtt = (DocModelRuleAttribute)this.treeViewTemplate.SelectedNode.Tag; } else { docRuleAtt = new DocModelRuleAttribute(); docRuleAtt.Name = docAttribute.Name; if (this.treeViewTemplate.SelectedNode.Tag is DocModelRuleEntity) { DocModelRuleEntity docRuleEnt = (DocModelRuleEntity)this.treeViewTemplate.SelectedNode.Tag; docRuleEnt.Rules.Add(docRuleAtt); } else if (this.treeViewTemplate.SelectedNode.Tag is DocTemplateDefinition) { docTemplate.Rules.Add(docRuleAtt); } tn = this.LoadTemplateGraph(tn, docRuleAtt); } // get and add entity rule DocModelRuleEntity docRuleEntity = new DocModelRuleEntity(); docRuleEntity.Name = entityname; docRuleAtt.Rules.Add(docRuleEntity); this.treeViewTemplate.SelectedNode = this.LoadTemplateGraph(tn, docRuleEntity); // copy to child templates docTemplate.PropagateRule(this.treeViewTemplate.SelectedNode.FullPath); this.m_selection = docRuleEntity; this.ContentChanged(this, EventArgs.Empty); this.SelectionChanged(this, EventArgs.Empty); } } else { // pick attribute, including attribute that may be on subtype DocModelRule rule = null; if (this.treeViewTemplate.SelectedNode != null) { rule = this.treeViewTemplate.SelectedNode.Tag as DocModelRule; } //if (rule == null) // return; DocTemplateDefinition docTemplate = (DocTemplateDefinition)this.m_template; string typename = null; if (rule is DocModelRuleEntity) { DocModelRuleEntity docRuleEntity = (DocModelRuleEntity)rule; typename = docRuleEntity.Name; } else { // get applicable entity of target (or parent entity rule) typename = docTemplate.Type; } DocEntity docEntity = this.m_project.GetDefinition(typename) as DocEntity; if (docEntity == null) { #if false // constraints now edited at operations // launch dialog for constraint using (FormConstraint form = new FormConstraint()) { DialogResult res = form.ShowDialog(this); if (res == DialogResult.OK) { DocModelRuleConstraint docRuleConstraint = new DocModelRuleConstraint(); rule.Rules.Add(docRuleConstraint); docRuleConstraint.Description = form.Expression; docRuleConstraint.Name = form.Expression; // for viewing this.treeViewTemplate.SelectedNode = this.LoadTemplateGraph(this.treeViewTemplate.SelectedNode, docRuleConstraint); // copy to child templates docTemplate.PropagateRule(this.treeViewTemplate.SelectedNode.FullPath); } } #endif } else { // launch dialog to pick attribute of entity using (FormSelectAttribute form = new FormSelectAttribute(docEntity, this.m_project, null, true)) { DialogResult res = form.ShowDialog(this); if (res == DialogResult.OK && form.Selection != null) { // then add and update tree DocModelRuleAttribute docRuleAttr = new DocModelRuleAttribute(); docRuleAttr.Name = form.Selection; if (rule != null) { rule.Rules.Add(docRuleAttr); } else { docTemplate.Rules.Add(docRuleAttr); } this.treeViewTemplate.SelectedNode = this.LoadTemplateGraph(this.treeViewTemplate.SelectedNode, docRuleAttr); // copy to child templates docTemplate.PropagateRule(this.treeViewTemplate.SelectedNode.FullPath); } } } } }
public void DoInsert() { if (this.Template == null) { return; } DocModelRule docModelRule = this.Rule; if (docModelRule == null) { return; } if (!(this.Rule is DocModelRuleEntity)) { return; } TreeNode tnSelect = this.treeViewRules.SelectedNode; DocOpLiteral oplit = new DocOpLiteral(); oplit.Operation = DocOpCode.LoadString; oplit.Literal = null; DocOpStatement op = new DocOpStatement(); op.Operation = DocOpCode.CompareEqual; op.Value = oplit; DocOpReference opref = new DocOpReference(); opref.Operation = DocOpCode.NoOperation; // ldfld... opref.EntityRule = this.Rule as DocModelRuleEntity; op.Reference = opref; if (tnSelect != null) { DocOpExpression opSelect = tnSelect.Tag as DocOpExpression; if (tnSelect.Tag is DocModelRuleConstraint) { opSelect = ((DocModelRuleConstraint)tnSelect.Tag).Expression; } // convert existing node into new Logical operator DocOpLogical opLog = new DocOpLogical(); opLog.Operation = DocOpCode.And; opLog.ExpressionA = opSelect; opLog.ExpressionB = op; if (tnSelect.Tag is DocModelRuleConstraint) { DocModelRuleConstraint dmr = (DocModelRuleConstraint)tnSelect.Tag; dmr.Expression = opLog; } else if (tnSelect.Parent != null) { DocOpLogical opParent = tnSelect.Parent.Tag as DocOpLogical; if (tnSelect.Parent.Tag is DocModelRuleConstraint) { opParent = ((DocModelRuleConstraint)tnSelect.Parent.Tag).Expression as DocOpLogical; } if (tnSelect.Parent.Nodes[0] == tnSelect) { opParent.ExpressionA = opLog; } else if (tnSelect.Parent.Nodes[1] == tnSelect) { opParent.ExpressionB = opLog; } } else if (tnSelect.Parent != null && tnSelect.Parent.Nodes[1] == tnSelect) { DocOpLogical opParent = (DocOpLogical)tnSelect.Parent.Tag; opParent.ExpressionB = opLog; } this.LoadRules(op); } else { // create new constraint DocModelRuleConstraint docCon = new DocModelRuleConstraint(); docCon.Expression = op; docModelRule.Rules.Add(docCon); docCon.ParentRule = docModelRule; TreeNode tnCon = new TreeNode(); tnCon.Tag = docCon; tnCon.Text = op.ToString(this.Template); tnCon.ImageIndex = 3; tnCon.SelectedImageIndex = tnCon.ImageIndex; this.treeViewRules.Nodes.Add(tnCon); this.treeViewRules.SelectedNode = tnCon; } }
private TreeNode LoadTemplateGraph(TreeNode tnParent, DocModelRule docRule) { TreeNode tnRule = LoadTemplateRuleNode(tnParent, docRule, docRule.Name); UpdateTemplateGraph(tnRule); tnRule.Nodes.Clear(); foreach (DocModelRule docSub in docRule.Rules) { LoadTemplateGraph(tnRule, docSub); } if (docRule is DocModelRuleEntity) { DocModelRuleEntity dme = (DocModelRuleEntity)docRule; foreach (DocTemplateDefinition dtd in dme.References) { TreeNode tnTemplate = LoadTemplateRuleNode(tnRule, dtd, dtd.Name); if (dtd.Rules != null) { foreach (DocModelRule docTemplateRule in dtd.Rules) { LoadTemplateGraph(tnTemplate, docTemplateRule); } } } } return tnRule; }