private void buttonConvert_Click(object sender, EventArgs e)
        {
            if (treeView1.SelectedNode != null)
            {
                if (treeView1.SelectedNode.Tag is XmlComplexCondition)
                {
                    XmlSimpleCondition condition = new XmlSimpleCondition();
                    treeView1.SelectedNode.Tag = condition;
                    treeView1.SelectedNode.Nodes.Clear();
                    treeView1_AfterSelect(null, null);
                }
                else if (treeView1.SelectedNode.Tag is XmlSimpleCondition)
                {
                    XmlSimpleCondition oldCondition = treeView1.SelectedNode.Tag as XmlSimpleCondition;

                    XmlComplexCondition condition = new XmlComplexCondition();
                    treeView1.SelectedNode.Tag = condition;

                    TreeNode node1 = new TreeNode(treeView1.SelectedNode.Text);
                    node1.Tag = oldCondition;
                    treeView1.SelectedNode.Nodes.Add(node1);

                    TreeNode node2 = new TreeNode("unknown");
                    node2.Tag = new XmlSimpleCondition();
                    treeView1.SelectedNode.Nodes.Add(node2);

                    treeView1_AfterSelect(null, null);

                    treeView1.SelectedNode.Text = condition.BinaryOperator.ToString().Replace("Operator", "");
                    treeView1.SelectedNode.ExpandAll();
                }
            }
            label1.Text = BuildConditionString(treeView1.Nodes[0]);
        }
Example #2
0
        protected override void SerializeProperties(XmlCondition res)
        {
            base.SerializeProperties(res);

            XmlSimpleCondition instance = (XmlSimpleCondition)res;

            instance.Setting       = this.Setting.Serialize();
            instance.UnaryOperator = this.UnaryOperator;
        }
Example #3
0
        /// <summary>
        /// Build the expression string.
        /// </summary>
        /// <returns></returns>
        public string BuildExpressionString()
        {
            //TODO: replace usage of inheritors
            //with implementation and overriding of a virtual function
            string s = "";

            if (this is XmlComplexCondition)
            {
                XmlComplexCondition complex = this as XmlComplexCondition;
                s += "(";
                if (complex.Condition1 != null)
                {
                    s += complex.Condition1.BuildExpressionString();
                }
                else
                {
                    s += "unknown";
                }
                s += " " + complex.BinaryOperator.ToString().Replace("Operator", "").ToLower() + " ";
                if (complex.Condition2 != null)
                {
                    s += complex.Condition2.BuildExpressionString();
                }
                else
                {
                    s += "unknown";
                }

                s += ")";
            }
            else if (this is XmlSimpleCondition)
            {
                XmlSimpleCondition simple = this as XmlSimpleCondition;
                if (simple.UnaryOperator == UnaryOperator.NotOperator)
                {
                    s += "!";
                }
                if (simple.Setting != null)
                {
                    s += simple.Setting.GetPropertyName();
                }
                else
                {
                    s += "unknown";
                }
            }

            return(s);
        }
 private void buttonAddSimple_Click(object sender, EventArgs e)
 {
     if (treeView1.SelectedNode != null &&
         treeView1.SelectedNode.Tag is XmlComplexCondition &&
         treeView1.SelectedNode.Nodes.Count < 2)
     {
         XmlSimpleCondition condition = new XmlSimpleCondition();
         TreeNode           node      = new TreeNode("unknown");
         node.Tag = condition;
         treeView1.SelectedNode.Nodes.Add(node);
         treeView1.SelectedNode.Expand();
     }
     if (treeView1.SelectedNode != null && treeView1.SelectedNode.Nodes.Count > 1)
     {
         buttonAddSimple.Enabled  = false;
         buttonAddComplex.Enabled = false;
     }
     label1.Text = BuildConditionString(treeView1.Nodes[0]);
 }
 private void propertyGrid1_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
 {
     if (treeView1.SelectedNode.Tag is XmlComplexCondition)
     {
         treeView1.SelectedNode.Text = (treeView1.SelectedNode.Tag as XmlComplexCondition).BinaryOperator.ToString().Replace("Operator", "");
     }
     else
     {
         XmlSimpleCondition condition = treeView1.SelectedNode.Tag as XmlSimpleCondition;
         if (e.ChangedItem.Label == "Property")
         {
             condition.Setting.Value = null;
             propertyGrid1.Refresh();
         }
         else if (condition.Setting != null)
         {
             treeView1.SelectedNode.Text = (treeView1.SelectedNode.Tag as XmlSimpleCondition).Setting.Property;
         }
     }
     label1.Text = BuildConditionString(treeView1.Nodes[0]);
 }
        string BuildConditionString(TreeNode root)
        {
            string s = "";

            if (root.Tag is XmlComplexCondition)
            {
                XmlComplexCondition condition = root.Tag as XmlComplexCondition;
                s += "(";
                if (root.Nodes.Count > 0)
                {
                    s += BuildConditionString(root.Nodes[0]);
                }
                s += " " + condition.BinaryOperator.ToString().Replace("Operator", "").ToLower() + " ";
                if (root.Nodes.Count > 1)
                {
                    s += BuildConditionString(root.Nodes[1]);
                }
                s += ")";
            }
            else if (root.Tag is XmlSimpleCondition)
            {
                XmlSimpleCondition condition = root.Tag as XmlSimpleCondition;
                if (condition.UnaryOperator == UnaryOperator.NotOperator)
                {
                    s += "!";
                }
                if (condition.Setting != null)
                {
                    s += condition.Setting.GetPropertyName();
                }
                else
                {
                    s += "unknown";
                }
            }

            return(s);
        }