Changeset 8980 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.cs

Timestamp:

11/30/12 23:15:47 (11 years ago)

Author:

bburlacu

Message:

#1763: Refactored the tree simplifier. Improved tree/node edit operations.

File:

• trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.cs (modified) (13 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
@@ -29 +30 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
   public sealed partial class InteractiveSymbolicExpressionTreeChart : SymbolicExpressionTreeChart {
-    private ISymbolicExpressionTreeNode tempNode;
-    private VisualSymbolicExpressionTreeNode lastSelected; // previously selected node
+    private ISymbolicExpressionTreeNode tempNode; // node in clipboard (to be cut/copy/pasted etc)
     private VisualSymbolicExpressionTreeNode currSelected; // currently selected node
     private enum EditOp { NoOp, CopyNode, CopySubtree, CutNode, CutSubtree, DeleteNode, DeleteSubtree }
@@ -37 +37 @@
     private TreeState treeState = TreeState.Valid; // tree edit operations must leave the tree in a valid state
 
+    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> originalNodes; // map a new node to the original node it replaced
+
     public InteractiveSymbolicExpressionTreeChart() {
       InitializeComponent();
-      // add extra actions in the context menu strips
-
-
-      lastSelected = null;
       currSelected = null;
       tempNode = null;
+
+      originalNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
     }
 
@@ -65 +65 @@
         Repaint();
       }
+      foreach (var node in originalNodes.Keys) {
+        var visualNode = GetVisualSymbolicExpressionTreeNode(node);
+        if (visualNode == null) continue;
+        visualNode.LineColor = Color.DodgerBlue;
+        RepaintNode(visualNode);
+      }
     }
 
     private void contextMenuStrip_Opened(object sender, EventArgs e) {
-      var menu = sender as ContextMenuStrip;
-      if (menu == null) return;
+      var menuStrip = (ContextMenuStrip)sender;
+      var point = menuStrip.SourceControl.PointToClient(Cursor.Position);
+      var ea = new MouseEventArgs(MouseButtons.Left, 1, point.X, point.Y, 0);
+      InteractiveSymbolicExpressionTreeChart_MouseClick(null, ea);
+
       if (currSelected == null) {
         insertNodeToolStripMenuItem.Visible = false;
-        changeValueToolStripMenuItem.Visible = false;
+        editNodeToolStripMenuItem.Visible = false;
         copyToolStripMenuItem.Visible = false;
         cutToolStripMenuItem.Visible = false;
@@ -79 +88 @@
       } else {
         var node = currSelected.SymbolicExpressionTreeNode;
-        changeValueToolStripMenuItem.Visible = (node is SymbolicExpressionTreeTerminalNode);
-        insertNodeToolStripMenuItem.Visible = !changeValueToolStripMenuItem.Visible;
+        editNodeToolStripMenuItem.Visible = (node is SymbolicExpressionTreeTerminalNode);
+        insertNodeToolStripMenuItem.Visible = !editNodeToolStripMenuItem.Visible;
         copyToolStripMenuItem.Visible = true;
         cutToolStripMenuItem.Visible = true;
@@ -89 +98 @@
 
     protected override void OnSymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
-      var visualTreeNode = FindVisualSymbolicExpressionTreeNodeAt(e.X, e.Y);
-      if (visualTreeNode == null || visualTreeNode == currSelected) return;
-      lastSelected = currSelected;
-      if (lastSelected != null)
-        lastSelected.LineColor = Color.Black;
+      var visualTreeNode = (VisualSymbolicExpressionTreeNode)sender;
+      var lastSelected = currSelected;
+      if (lastSelected != null) {
+        lastSelected.LineColor = originalNodes.ContainsKey(lastSelected.SymbolicExpressionTreeNode) ? Color.DodgerBlue : Color.Black;
+        RepaintNode(lastSelected);
+      }
+
       currSelected = visualTreeNode;
-      currSelected.LineColor = Color.LightGreen;
-      Repaint();
-      base.OnSymbolicExpressionTreeNodeClicked(sender, e);
+      if (currSelected != null) {
+        currSelected.LineColor = Color.LightGreen;
+        RepaintNode(currSelected);
+      }
+    }
+
+    protected override void OnSymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
+      var visualTreeNode = (VisualSymbolicExpressionTreeNode)sender;
+      if (originalNodes.ContainsKey(visualTreeNode.SymbolicExpressionTreeNode)) {
+        var originalNode = originalNodes[visualTreeNode.SymbolicExpressionTreeNode];
+
+        var parent = visualTreeNode.SymbolicExpressionTreeNode.Parent;
+        var i = parent.IndexOfSubtree(visualTreeNode.SymbolicExpressionTreeNode);
+        parent.RemoveSubtree(i);
+        parent.InsertSubtree(i, originalNode);
+
+        originalNodes.Remove(visualTreeNode.SymbolicExpressionTreeNode);
+        visualTreeNode.SymbolicExpressionTreeNode = originalNode;
+        OnSymbolicExpressionTreeChanged(sender, EventArgs.Empty);
+      } else {
+        currSelected = null; // because the tree node will be folded/unfolded 
+        base.OnSymbolicExpressionTreeNodeDoubleClicked(sender, e);
+        // at this point the tree got redrawn, so we mark the edited nodes
+        foreach (var node in originalNodes.Keys) {
+          var visualNode = GetVisualSymbolicExpressionTreeNode(node);
+          if (visualNode == null) continue;
+          visualNode.LineColor = Color.DodgerBlue;
+          RepaintNode(visualNode);
+        }
+      }
     }
 
     private void insertNodeToolStripMenuItem_Click(object sender, EventArgs e) {
       if (currSelected == null || currSelected.SymbolicExpressionTreeNode is SymbolicExpressionTreeTerminalNode) return;
-      var node = currSelected.SymbolicExpressionTreeNode;
+      var parent = currSelected.SymbolicExpressionTreeNode;
 
       using (var dialog = new InsertNodeDialog()) {
-        dialog.SetAllowedSymbols(node.Grammar.AllowedSymbols.Where(s => s.Enabled && s.InitialFrequency > 0.0 && !(s is ProgramRootSymbol || s is StartSymbol || s is Defun)));
-        dialog.DialogValidated += InsertNodeDialog_Validated;
+        dialog.SetAllowedSymbols(parent.Grammar.AllowedSymbols.Where(s => s.Enabled && s.InitialFrequency > 0.0 && !(s is ProgramRootSymbol || s is StartSymbol || s is Defun)));
         dialog.ShowDialog(this);
-      }
-    }
-
-    private void changeValueToolStripMenuItem_Click(object sender, EventArgs e) {
+
+        if (dialog.DialogResult == DialogResult.OK) {
+          var symbol = dialog.SelectedSymbol();
+          var node = symbol.CreateTreeNode();
+          if (node is ConstantTreeNode) {
+            var constant = node as ConstantTreeNode;
+            constant.Value = double.Parse(dialog.constantValueTextBox.Text);
+          } else if (node is VariableTreeNode) {
+            var variable = node as VariableTreeNode;
+            variable.Weight = double.Parse(dialog.variableWeightTextBox.Text);
+            variable.VariableName = dialog.variableNamesCombo.Text;
+          } else {
+            if (node.Symbol.MinimumArity <= parent.SubtreeCount && node.Symbol.MaximumArity >= parent.SubtreeCount) {
+              for (int i = parent.SubtreeCount - 1; i >= 0; --i) {
+                var child = parent.GetSubtree(i);
+                parent.RemoveSubtree(i);
+                node.AddSubtree(child);
+              }
+            }
+          }
+          if (parent.Symbol.MaximumArity > parent.SubtreeCount) {
+            parent.AddSubtree(node);
+            Tree = Tree;
+          }
+          OnSymbolicExpressionTreeChanged(sender, e);
+        }
+      }
+    }
+
+    private void editNodeToolStripMenuItem_Click(object sender, EventArgs e) {
       if (currSelected == null) return;
-      var node = currSelected.SymbolicExpressionTreeNode;
-      using (var dialog = new ValueChangeDialog()) {
-        dialog.SetContent(node);
-        dialog.DialogValidated += ChangeValueDialog_Validated;
-        dialog.ShowDialog(this);
-      }
-    }
-
-    public event EventHandler SymbolicExpressionTreeNodeChanged;
-    private void OnSymbolicExpressionTreeNodeChanged(object sender, EventArgs e) {
-      var changed = SymbolicExpressionTreeNodeChanged;
-      if (changed != null)
-        SymbolicExpressionTreeNodeChanged(sender, e);
-    }
-
-    private void ChangeValueDialog_Validated(object sender, EventArgs e) {
-      OnSymbolicExpressionTreeNodeChanged(sender, e);
-    }
-
-    private void InsertNodeDialog_Validated(object sender, EventArgs e) {
-      var dialog = (InsertNodeDialog)sender;
-      var symbol = dialog.SelectedSymbol();
-      var node = symbol.CreateTreeNode();
-      var parent = currSelected.SymbolicExpressionTreeNode;
+
+      ISymbolicExpressionTreeNode node;
+      if (originalNodes.ContainsKey(currSelected.SymbolicExpressionTreeNode)) {
+        node = currSelected.SymbolicExpressionTreeNode;
+      } else {
+        node = (ISymbolicExpressionTreeNode)currSelected.SymbolicExpressionTreeNode.Clone();
+      }
+      var originalNode = currSelected.SymbolicExpressionTreeNode;
+      ISymbolicExpressionTreeNode newNode = null;
+      var result = DialogResult.Cancel;
       if (node is ConstantTreeNode) {
-        var constant = node as ConstantTreeNode;
-        constant.Value = double.Parse(dialog.constantValueTextBox.Text);
+        using (var dialog = new ConstantNodeEditDialog(node)) {
+          dialog.ShowDialog(this);
+          newNode = dialog.NewNode;
+          result = dialog.DialogResult;
+        }
       } else if (node is VariableTreeNode) {
-        var variable = node as VariableTreeNode;
-        variable.Weight = double.Parse(dialog.variableWeightTextBox.Text);
-        variable.VariableName = dialog.variableNamesCombo.Text;
-      } else {
-        if (node.Symbol.MinimumArity <= parent.SubtreeCount && node.Symbol.MaximumArity >= parent.SubtreeCount) {
-          for (int i = parent.SubtreeCount - 1; i >= 0; --i) {
-            var child = parent.GetSubtree(i);
-            parent.RemoveSubtree(i);
-            node.AddSubtree(child);
-          }
-        }
-      }
-      if (parent.Symbol.MaximumArity > parent.SubtreeCount) {
-        parent.AddSubtree(node);
-        Tree = Tree;
-      }
-      OnSymbolicExpressionTreeChanged(sender, e);
+        using (var dialog = new VariableNodeEditDialog(node)) {
+          dialog.ShowDialog(this);
+          newNode = dialog.NewNode;
+          result = dialog.DialogResult;
+        }
+      }
+      if (result != DialogResult.OK) return;
+      if (originalNode != newNode) {
+        var parent = originalNode.Parent;
+        int i = parent.IndexOfSubtree(originalNode);
+        parent.RemoveSubtree(i);
+        parent.InsertSubtree(i, newNode);
+        originalNodes[newNode] = originalNode;
+        currSelected.SymbolicExpressionTreeNode = newNode;
+      }
+      OnSymbolicExpressionTreeChanged(sender, EventArgs.Empty);
     }
 
@@ -171 +222 @@
     private void cutSubtreeToolStripMenuItem_Click(object sender, EventArgs e) {
       lastOp = EditOp.CutSubtree;
-      tempNode = currSelected.SymbolicExpressionTreeNode; // should never be null
+      tempNode = currSelected.SymbolicExpressionTreeNode;
       foreach (var node in tempNode.IterateNodesPostfix()) {
         var visualNode = GetVisualSymbolicExpressionTreeNode(node);
@@ -244 +295 @@
       // check if the copied/cut node (stored in the tempNode) can be inserted as a child of the current selected node
       var node = currSelected.SymbolicExpressionTreeNode;
-      if (node is ConstantTreeNode || node is VariableTreeNode) return; // nothing to do
+      if (node is ConstantTreeNode || node is VariableTreeNode) return;
       // check if the currently selected node can accept the copied node as a child 
       // no need to check the grammar, an arity check will do just fine here
@@ -254 +305 @@
               // arity checks to see if parent can accept node's children (we assume the grammar is already ok with that)
               // (otherise, the 'cut' part of the operation will just not do anything)
-              if (parent.Symbol.MaximumArity >= tempNode.SubtreeCount + parent.SubtreeCount - 1) {
-                // -1 because tempNode will be removed
+              if (parent.Symbol.MaximumArity >= tempNode.SubtreeCount + parent.SubtreeCount - 1) { // -1 because tempNode will be removed
                 parent.RemoveSubtree(parent.IndexOfSubtree(tempNode));
                 for (int i = tempNode.SubtreeCount - 1; i >= 0; --i) {
@@ -263 +313 @@
                 }
                 lastOp = EditOp.CopyNode;
-                currSelected = null;
               }
               break;
@@ -272 +321 @@
               parent.RemoveSubtree(parent.IndexOfSubtree(tempNode));
               lastOp = EditOp.CopySubtree; // do this so the next paste will actually perform a copy   
-              currSelected = null;
               break;
             }
           case (EditOp.CopyNode): {
               // copy node
-              var clone = (SymbolicExpressionTreeNode)tempNode.Clone(); // should never be null
+              var clone = (SymbolicExpressionTreeNode)tempNode.Clone();
               clone.Parent = tempNode.Parent;
               tempNode = clone;
@@ -292 +340 @@
         }
         node.AddSubtree(tempNode);
-        Tree = Tree; // hack in order to trigger the reinitialization of the dictionaries after new nodes appeared in the graph
+        Tree = Tree; // hack in order to trigger the reinitialization of the dictionaries after new nodes appeared in the tree
         OnSymbolicExpressionTreeChanged(sender, e);
+        currSelected = null; // because the tree changed and was completely redrawn
       }
     }
@@ -305 +354 @@
       return true;
     }
+
+    private void InteractiveSymbolicExpressionTreeChart_MouseClick(object sender, MouseEventArgs e) {
+      var visualTreeNode = FindVisualSymbolicExpressionTreeNodeAt(e.X, e.Y);
+      if (currSelected != null) {
+        currSelected.LineColor = originalNodes.ContainsKey(currSelected.SymbolicExpressionTreeNode) ? Color.DodgerBlue : Color.Black;
+      }
+      currSelected = visualTreeNode;
+      if (currSelected != null) {
+        currSelected.LineColor = Color.LightGreen;
+        RepaintNode(currSelected);
+      }
+    }
   }
 }