CtlOperators.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

using IfcDoc.Schema;
using IfcDoc.Schema.DOC;

namespace IfcDoc
{
    public partial class CtlOperators : UserControl
    {
        private DocProject m_project;
        private DocTemplateDefinition m_template;
        private DocModelRule m_modelrule; // relative rule for which to add constraints
        private object m_instance;
        private object[] m_population; // all instances for which rule is applicable, to check uniqueness

        public CtlOperators()
        {
            InitializeComponent();
        }

        public DocProject Project
        {
            get
            {
                return this.m_project;
            }
            set
            {
                this.m_project = value;
            }
        }

        public DocTemplateDefinition Template
        {
            get
            {
                return this.m_template;
            }
            set
            {
                this.m_template = value;

                this.LoadRules(null);
            }
        }

        public DocModelRule Rule
        {
            get
            {
                return this.m_modelrule;
            }
            set
            {
                this.m_modelrule = value;

                // update
                treeViewRules_AfterSelect(this, new TreeViewEventArgs(null));
            }
        }

        public object[] CurrentPopulation
        {
            get
            {
                return this.m_population;
            }
            set
            {
                this.m_population = value;
            }
        }

        public object CurrentInstance
        {
            get
            {
                return this.m_instance;
            }
            set
            {
                this.m_instance = value;

                foreach (TreeNode tn in this.treeViewRules.Nodes)
                {
                    ValidateNode(tn);
                }
            }
        }

        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 void LoadRules(DocOp selection)
        {
            this.treeViewRules.BeginUpdate();
            this.treeViewRules.Nodes.Clear();
            if (this.m_template != null)
            {
                this.LoadRules(this.Template.Rules, null);
                this.treeViewRules.ExpandAll();
                this.treeViewRules_AfterSelect(this.treeViewRules, new TreeViewEventArgs(null));

                foreach (TreeNode tn in this.treeViewRules.Nodes)
                {
                    SelectRule(tn, selection);
                }
            }
            this.treeViewRules.EndUpdate();

            // select nothing such that color is displayed for validation
            this.treeViewRules.SelectedNode = null;
        }

        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 LoadOpExpression(TreeNode tn, DocOp op)
        {
            if (op == null)
                return;

            if (tn.Tag == null)
            {
                tn.Tag = op;
            }
            tn.Text = op.ToString(this.Template);
            tn.ImageIndex = 3;
            tn.SelectedImageIndex = tn.ImageIndex;

            if (op is DocOpLogical)
            {
                DocOpLogical oplog = (DocOpLogical)op;
                tn.ImageIndex = 4;
                tn.SelectedImageIndex = tn.ImageIndex;

                TreeNode tnA = new TreeNode();
                LoadOpExpression(tnA, oplog.ExpressionA);
                tn.Nodes.Add(tnA);

                TreeNode tnB = new TreeNode();
                LoadOpExpression(tnB, oplog.ExpressionB);
                tn.Nodes.Add(tnB);
            }
        }

        private void SelectRule(TreeNode tn, DocOp selection)
        {
            if (tn.Tag == selection)
            {
                this.treeViewRules.SelectedNode = tn;
                return;
            }
            else if (tn.Tag is DocModelRuleConstraint)
            {
                DocModelRuleConstraint dmc = (DocModelRuleConstraint)tn.Tag;
                if (dmc.Expression == selection)
                {
                    this.treeViewRules.SelectedNode = tn;
                }
            }

            foreach (TreeNode ts in tn.Nodes)
            {
                SelectRule(ts, selection);
            }
        }

        private void treeViewRules_AfterSelect(object sender, TreeViewEventArgs e)
        {
            TreeNode tn = this.treeViewRules.SelectedNode;

            DocOp op = this.GetSelectedOp();

            if (this.Template == null)
            {
                foreach (ToolStripItem tsi in this.toolStripConceptRule.Items)
                {
                    tsi.Enabled = false;

                    if (tsi is ToolStripButton)
                    {
                        ((ToolStripButton)tsi).Checked = false;
                    }
                }
                return;
            }

            this.toolStripButtonRuleInsert.Enabled = (this.Rule is DocModelRuleEntity);
            this.toolStripButtonRuleRemove.Enabled = (tn != null);
            this.toolStripButtonRuleUpdate.Enabled = (op is DocOpStatement);
            this.toolStripButtonRuleRef.Enabled = (op is DocOpStatement && this.Rule != null);

            this.toolStripButtonRuleAnd.Enabled = (op is DocOpLogical);
            this.toolStripButtonRuleOr.Enabled = (op is DocOpLogical);
            this.toolStripButtonRuleXor.Enabled = (op is DocOpLogical);

            this.toolStripButtonRuleCeq.Enabled = (op is DocOpStatement);
            this.toolStripButtonRuleCne.Enabled = (op is DocOpStatement);
            this.toolStripButtonRuleCle.Enabled = (op is DocOpStatement);
            this.toolStripButtonRuleClt.Enabled = (op is DocOpStatement);
            this.toolStripButtonRuleCge.Enabled = (op is DocOpStatement);
            this.toolStripButtonRuleCgt.Enabled = (op is DocOpStatement);
            this.toolStripButtonRuleIncludes.Enabled = (op is DocOpStatement);

            this.toolStripButtonRuleAnd.Checked = (op != null && op.Operation == DocOpCode.And);
            this.toolStripButtonRuleOr.Checked = (op != null && op.Operation == DocOpCode.Or);
            this.toolStripButtonRuleXor.Checked = (op != null && op.Operation == DocOpCode.Xor);

            this.toolStripButtonRuleCeq.Checked = (op != null && op.Operation == DocOpCode.CompareEqual);
            this.toolStripButtonRuleCne.Checked = (op != null && op.Operation == DocOpCode.CompareNotEqual);
            this.toolStripButtonRuleCle.Checked = (op != null && op.Operation == DocOpCode.CompareLessThanOrEqual);
            this.toolStripButtonRuleClt.Checked = (op != null && op.Operation == DocOpCode.CompareLessThan);
            this.toolStripButtonRuleCge.Checked = (op != null && op.Operation == DocOpCode.CompareGreaterThanOrEqual);
            this.toolStripButtonRuleCgt.Checked = (op != null && op.Operation == DocOpCode.CompareGreaterThan);

            this.toolStripButtonRuleIncludes.Checked = (op != null && op.Operation == DocOpCode.IsIncluded);
        }

        private void treeViewRules_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            // launch literal editor
            toolStripButtonRuleUpdate_Click(null, EventArgs.Empty);
        }

        private void treeViewRules_MouseDown(object sender, MouseEventArgs e)
        {
            if (this.treeViewRules.HitTest(e.Location).Node == null)
            {
                this.treeViewRules.SelectedNode = null;
                treeViewRules_AfterSelect(this.treeViewRules, new TreeViewEventArgs(null));
            }
        }

        private void toolStripButtonRuleInsert_Click(object sender, EventArgs e)
        {
            this.DoInsert();
        }

        private void toolStripButtonRuleRemove_Click(object sender, EventArgs e)
        {
            TreeNode tn = this.treeViewRules.SelectedNode;
            if (tn == null)
                return;

            if (tn.Tag is DocModelRuleConstraint)
            {
                DocModelRuleConstraint docConstraint = (DocModelRuleConstraint)tn.Tag;
                docConstraint.Delete();
                this.RemoveRuleConstraint(this.Template.Rules, docConstraint);
                this.LoadRules(null);
            }
            else if (tn.Tag is DocOp)
            {
                // dissolve parent Logical operator, move other statement into parent

                DocOp op = (DocOp)tn.Tag;

                TreeNode tnParent = tn.Parent;
                DocOpLogical oplog = tnParent.Tag as DocOpLogical;
                if (tnParent.Tag is DocModelRuleConstraint)
                {
                    DocModelRuleConstraint dmr = (DocModelRuleConstraint)tnParent.Tag;
                    oplog = dmr.Expression as DocOpLogical;
                }

                TreeNode tnGrand = tnParent.Parent;

                DocOpExpression opOther = null;
                if (oplog.ExpressionA == op)
                {
                    opOther = oplog.ExpressionB;
                    oplog.ExpressionB = null; // prevent deletion
                }
                else if (oplog.ExpressionB == op)
                {
                    opOther = oplog.ExpressionA;
                    oplog.ExpressionA = null; // prevent deletion
                }

                if (tnParent.Tag is DocModelRuleConstraint)
                {
                    DocModelRuleConstraint dmr = (DocModelRuleConstraint)tnParent.Tag;
                    dmr.Expression = opOther;
                }
                else if (tnGrand != null)
                {
                    DocOpLogical opGrand = tnGrand.Tag as DocOpLogical;
                    if (tnGrand.Tag is DocModelRuleConstraint)
                    {
                        DocModelRuleConstraint dmr = (DocModelRuleConstraint)tnGrand.Tag;
                        opGrand = dmr.Expression as DocOpLogical;
                    }

                    if (opGrand.ExpressionA == oplog)
                    {
                        opGrand.ExpressionA = opOther;
                    }
                    else if (opGrand.ExpressionB == oplog)
                    {
                        opGrand.ExpressionB = opOther;
                    }
                }

                oplog.Delete();
                op.Delete();
                this.LoadRules(opOther);
            }
        }

        private void RemoveRuleConstraint(List<DocModelRule> list, DocModelRuleConstraint ruleCon)
        {
            if (list.Contains(ruleCon))
            {
                list.Remove(ruleCon);
            }

            foreach (DocModelRule sub in list)
            {
                if (sub.Rules != null)
                {
                    RemoveRuleConstraint(sub.Rules, ruleCon);
                }
            }
        }

        private DocOp GetSelectedOp()
        {
            TreeNode tn = this.treeViewRules.SelectedNode;
            if (tn == null)
                return null;

            DocOp docop = tn.Tag as DocOp;
            if (tn.Tag is DocModelRuleConstraint)
            {
                DocModelRuleConstraint dmr = (DocModelRuleConstraint)tn.Tag;
                docop = dmr.Expression;
            }

            return docop;
        }


        private void toolStripButtonRuleUpdate_Click(object sender, EventArgs e)
        {
            DocOpStatement docop = GetSelectedOp() as DocOpStatement;
            if (docop == null)
                return;

            // enumeration|boolean|logical: pick from list
            // string|integer|real: freeform editor

            using (FormConstraint form = new FormConstraint())
            {
                form.DataType = this.m_project.GetDefinition(docop.Reference.EntityRule.Name) as DocType;
                if (form.DataType == null)
                {
                    try
                    {
                        form.ExpressType = (DocExpressType)Enum.Parse(typeof(DocExpressType), docop.Reference.EntityRule.Name);
                    }
                    catch
                    {

                    }
                }

                form.Metric = docop.Metric;
                form.Operation = docop.Operation;

                if (docop.Value is DocOpLiteral)
                {
                    form.Literal = ((DocOpLiteral)docop.Value).Literal;
                }
                if (form.ShowDialog(this) == DialogResult.OK)
                {
                    docop.Operation = form.Operation;
                    docop.Metric = form.Metric;

                    if (!(docop.Value is DocOpLiteral))
                    {
                        docop.Value.Delete();
                        docop.Value = new DocOpLiteral();
                    }

                    ((DocOpLiteral)docop.Value).Literal = form.Literal;

                    this.treeViewRules.SelectedNode.Text = docop.ToString(this.Template);
                }
            }
        }

        private void toolStripButtonRuleRef_Click(object sender, EventArgs e)
        {
            DocOp op = this.GetSelectedOp();
            if (op is DocOpStatement)
            {
                DocOpStatement statement = (DocOpStatement)op;
                if (this.Rule is DocModelRuleAttribute)
                {
                    DocOpParameter param = new DocOpParameter();
                    param.Operation = DocOpCode.LoadArgument;
                    param.AttributeRule = (DocModelRuleAttribute)this.Rule;
                    statement.Value = param;
                }
                else if (this.Rule is DocModelRuleEntity)
                {
                    DocOpReference opref = new DocOpReference();
                    opref.Operation = DocOpCode.LoadField;
                    opref.EntityRule = (DocModelRuleEntity)this.Rule;
                    statement.Value = opref;
                }

                this.treeViewRules.SelectedNode.Text = op.ToString(this.Template);
            }
        }

        private void toolStripButtonRuleAnd_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.And);
        }

        private void toolStripButtonRuleOr_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.Or);
        }

        private void toolStripButtonRuleXor_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.Xor);
        }

        private void toolStripButtonRuleCeq_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.CompareEqual);
        }

        private void toolStripButtonRuleCne_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.CompareNotEqual);
        }

        private void toolStripButtonRuleCgt_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.CompareGreaterThan);
        }

        private void toolStripButtonRuleCge_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.CompareGreaterThanOrEqual);
        }

        private void toolStripButtonRuleClt_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.CompareLessThan);
        }

        private void toolStripButtonRuleCle_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.CompareLessThanOrEqual);
        }

        private void SetSelectedRuleOperator(DocOpCode opcode)
        {
            TreeNode tn = this.treeViewRules.SelectedNode;
            DocOp docop = this.GetSelectedOp();

            docop.Operation = opcode;
            tn.Text = docop.ToString(this.Template);

            this.treeViewRules_AfterSelect(this.treeViewRules, new TreeViewEventArgs(this.treeViewRules.SelectedNode));
        }

        private void toolStripButtonRuleIncludes_Click(object sender, EventArgs e)
        {
            SetSelectedRuleOperator(DocOpCode.IsIncluded);
        }

        private void ValidateNode(TreeNode tn)
        {
            if (this.m_instance != null)
            {
                DocOp docOp = null;
                if (tn.Tag is DocModelRuleConstraint)
                {
                    DocModelRuleConstraint con = (DocModelRuleConstraint)tn.Tag;
                    docOp = con.Expression;
                }
                else if (tn.Tag is DocOp)
                {
                    docOp = (DocOp)tn.Tag;
                }

                if (docOp != null)
                {
                    Hashtable hashtable = new Hashtable();
                    object oresult = docOp.Eval(this.m_instance, hashtable, this.m_template, null, null);

                    // if hashtable contains a value, that means that entire population must be tested to determine uniqueness
                    if (hashtable.Count > 0 && this.m_population != null)
                    {
                        // must evalulate all for uniqueness
                        foreach (object other in this.m_population)
                        {
                            if (other == this.m_instance) // first instance will pass; following duplicate instances will fail
                                break;
                            
                            // returning false means there's a duplicate (not unique).
                            object otherresult = docOp.Eval(other, hashtable, this.m_template, null, null);
                            if (otherresult is bool && !(bool)otherresult)
                            {
                                oresult = false;
                                break;
                            }
                        }
                    }

                    if (oresult == null)
                    {
                        tn.BackColor = Color.Yellow;
                    }
                    else if(oresult is bool && (bool)oresult)
                    {
                        tn.BackColor = Color.Lime;
                    }
                    else if (oresult is bool && !(bool)oresult)
                    {
                        tn.BackColor = Color.Red;
                    }
                }
            }
            else
            {
                tn.BackColor = Color.Empty;
            }

            // recurse
            foreach(TreeNode sub in tn.Nodes)
            {
                ValidateNode(sub);
            }
        }
    }
}