source: branches/HeuristicLab.EvolutionTracking/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.cs @ 11349

Last change on this file since 11349 was 11349, checked in by bburlacu, 6 years ago

#1772: Merged trunk changes for HeuristicLab.Problems.DataAnalysis.Symbolic.Views.

File size: 10.4 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Drawing;
24using System.Linq;
25using System.Windows.Forms;
26using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
27using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
28
29namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
30  internal delegate void
31  ModifyTree(ISymbolicExpressionTree tree, ISymbolicExpressionTreeNode node, ISymbolicExpressionTreeNode oldChild, ISymbolicExpressionTreeNode newChild, bool removeSubtree = true);
32
33  internal sealed partial class InteractiveSymbolicExpressionTreeChart : SymbolicExpressionTreeChart {
34    private ISymbolicExpressionTreeNode tempNode; //node in clipboard (to be cut/copy/pasted etc)
35    private VisualTreeNode<ISymbolicExpressionTreeNode> currSelected; //currently selected node
36    private enum EditOp { NoOp, CopySubtree, CutSubtree }
37    private EditOp lastOp = EditOp.NoOp;
38
39    // delegate to notify the parent container (the view) about the tree edit operations that it needs to perform
40    public ModifyTree ModifyTree { get; set; }
41
42    public InteractiveSymbolicExpressionTreeChart() {
43      InitializeComponent();
44      currSelected = null;
45      tempNode = null;
46    }
47
48    private void contextMenuStrip_Opened(object sender, EventArgs e) {
49      var menuStrip = (ContextMenuStrip)sender;
50      var point = menuStrip.SourceControl.PointToClient(Cursor.Position);
51      var ea = new MouseEventArgs(MouseButtons.Left, 1, point.X, point.Y, 0);
52      var visualNode = FindVisualSymbolicExpressionTreeNodeAt(ea.X, ea.Y);
53      if (visualNode != null) {
54        OnSymbolicExpressionTreeNodeClicked(visualNode, ea);
55      } else {
56        currSelected = null;
57      }
58
59      if (currSelected == null) {
60        insertNodeToolStripMenuItem.Visible = false;
61        changeNodeToolStripMenuItem.Visible = false;
62        copyToolStripMenuItem.Visible = false;
63        cutToolStripMenuItem.Visible = false;
64        removeToolStripMenuItem.Visible = false;
65        pasteToolStripMenuItem.Visible = false;
66      } else {
67        var node = currSelected.Content;
68        insertNodeToolStripMenuItem.Visible = true;
69        changeNodeToolStripMenuItem.Visible = true;
70        changeNodeToolStripMenuItem.Enabled = (node is SymbolicExpressionTreeTerminalNode);
71        insertNodeToolStripMenuItem.Enabled = !changeNodeToolStripMenuItem.Enabled;
72        copyToolStripMenuItem.Visible = true;
73        cutToolStripMenuItem.Visible = true;
74        removeToolStripMenuItem.Visible = true;
75
76        pasteToolStripMenuItem.Visible = true;
77        pasteToolStripMenuItem.Enabled = tempNode != null && insertNodeToolStripMenuItem.Enabled
78                                                          && !(lastOp == EditOp.CutSubtree && tempNode.IterateNodesBreadth().Contains(node))
79                                                          && node.SubtreeCount < node.Symbol.MaximumArity;
80      }
81    }
82
83    protected override void OnSymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
84      currSelected = (VisualTreeNode<ISymbolicExpressionTreeNode>)sender; ;
85      base.OnSymbolicExpressionTreeNodeClicked(sender, e);
86    }
87
88    protected override void OnSymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
89      currSelected = null;
90      base.OnSymbolicExpressionTreeNodeDoubleClicked(sender, e);
91    }
92
93
94    private static readonly ISymbolicExpressionGrammar grammar = new TypeCoherentExpressionGrammar();
95    private void insertNodeToolStripMenuItem_Click(object sender, EventArgs e) {
96      if (currSelected == null || currSelected.Content is SymbolicExpressionTreeTerminalNode) return;
97      var parent = currSelected.Content;
98
99      using (var dialog = new InsertNodeDialog()) {
100        dialog.SetAllowedSymbols(grammar.Symbols.Where(s => !(s is ProgramRootSymbol || s is StartSymbol || s is Defun || s is GroupSymbol))); // allow everything
101        dialog.ShowDialog(this);
102        if (dialog.DialogResult != DialogResult.OK) return;
103
104        var symbol = dialog.SelectedSymbol();
105        var node = symbol.CreateTreeNode();
106        if (node is ConstantTreeNode) {
107          var constant = node as ConstantTreeNode;
108          constant.Value = double.Parse(dialog.constantValueTextBox.Text);
109        } else if (node is VariableTreeNode) {
110          var variable = node as VariableTreeNode;
111          variable.Weight = double.Parse(dialog.variableWeightTextBox.Text);
112          variable.VariableName = dialog.variableNamesCombo.Text;
113        } else if (node.Symbol.MinimumArity <= parent.SubtreeCount && node.Symbol.MaximumArity >= parent.SubtreeCount) {
114          for (int i = parent.SubtreeCount - 1; i >= 0; --i) {
115            var child = parent.GetSubtree(i);
116            parent.RemoveSubtree(i);
117            node.AddSubtree(child);
118          }
119        }
120        // the if condition will always be true for the final else clause above
121        if (parent.Symbol.MaximumArity > parent.SubtreeCount) {
122          ModifyTree(Tree, parent, null, node);
123        }
124      }
125      currSelected = null;
126    }
127    private void changeNodeToolStripMenuItem_Click(object sender, EventArgs e) {
128      if (currSelected == null) return;
129
130      var node = (ISymbolicExpressionTreeNode)currSelected.Content.Clone();
131      var originalNode = currSelected.Content;
132
133      ISymbolicExpressionTreeNode newNode = null;
134      var result = DialogResult.Cancel;
135      if (node is ConstantTreeNode) {
136        using (var dialog = new ConstantNodeEditDialog(node)) {
137          dialog.ShowDialog(this);
138          newNode = dialog.NewNode;
139          result = dialog.DialogResult;
140        }
141      } else if (node is VariableTreeNode) {
142        using (var dialog = new VariableNodeEditDialog(node)) {
143          dialog.ShowDialog(this);
144          newNode = dialog.NewNode;
145          result = dialog.DialogResult;
146        }
147      }
148      if (result != DialogResult.OK) return;
149      ModifyTree(Tree, originalNode.Parent, originalNode, newNode); // this will replace the original node with the new node
150      currSelected = null;
151    }
152    private void cutToolStripMenuItem_Click(object sender, EventArgs e) {
153      lastOp = EditOp.CutSubtree;
154      copySubtree();
155    }
156    private void copyToolStripMenuItem_Click(object sender, EventArgs e) {
157      lastOp = EditOp.CopySubtree;
158      copySubtree();
159    }
160    private void copySubtree() {
161      if (tempNode != null) {
162        foreach (var subtree in tempNode.IterateNodesPostfix()) {
163          var visualNode = GetVisualSymbolicExpressionTreeNode(subtree);
164          visualNode.LineColor = Color.Black;
165          visualNode.TextColor = Color.Black;
166          if (subtree.Parent != null) {
167            var visualLine = GetVisualSymbolicExpressionTreeNodeConnection(subtree.Parent, subtree);
168            visualLine.LineColor = Color.Black;
169          }
170        }
171      }
172      tempNode = currSelected.Content;
173      foreach (var node in tempNode.IterateNodesPostfix()) {
174        var visualNode = GetVisualSymbolicExpressionTreeNode(node);
175        visualNode.LineColor = Color.LightGray;
176        visualNode.TextColor = Color.LightGray;
177        foreach (var subtree in node.Subtrees) {
178          var visualLine = GetVisualSymbolicExpressionTreeNodeConnection(node, subtree);
179          visualLine.LineColor = Color.LightGray;
180        }
181      }
182      currSelected = null;
183      RepaintNodes(); // no need to redo the layout and repaint everything since this operation does not change the tree
184    }
185    private void removeNodeToolStripMenuItem_Click(object sender, EventArgs e) {
186      var node = currSelected.Content;
187      if (node == tempNode) tempNode = null;
188      ModifyTree(Tree, node.Parent, node, null, removeSubtree: false);
189      currSelected = null; // because the currently selected node was just deleted
190    }
191    private void removeSubtreeToolStripMenuItem_Click(object sender, EventArgs e) {
192      var node = currSelected.Content;
193      if (node.IterateNodesPostfix().Contains(tempNode)) tempNode = null;
194      ModifyTree(Tree, node.Parent, node, null, removeSubtree: true);
195      currSelected = null; // because the currently selected node was just deleted
196      contextMenuStrip.Close(); // avoid display of submenus since the action has already been performed
197    }
198    private void pasteToolStripMenuItem_Clicked(object sender, EventArgs e) {
199      if (!(lastOp == EditOp.CopySubtree || lastOp == EditOp.CutSubtree)) return;
200      // check if the copied/cut node (stored in the tempNode) can be inserted as a child of the current selected node
201      var node = currSelected.Content;
202      if (node is ConstantTreeNode || node is VariableTreeNode) return;
203      // check if the currently selected node can accept the copied node as a child
204      // no need to check the grammar, an arity check will do just fine here
205      if (node.Symbol.MaximumArity <= node.SubtreeCount) return;
206      switch (lastOp) {
207        case EditOp.CutSubtree: {
208            if (tempNode.IterateNodesBreadth().Contains(node))
209              throw new ArgumentException();// cannot cut/paste a node into itself
210            ModifyTree(Tree, tempNode.Parent, tempNode, null); //remove node from its original parent
211            ModifyTree(Tree, node, null, tempNode); //insert it as a child to the new parent
212            break;
213          }
214        case EditOp.CopySubtree: {
215            var clone = (SymbolicExpressionTreeNode)tempNode.Clone();
216            ModifyTree(Tree, node, null, clone);
217            break;
218          }
219      }
220      currSelected = null; // because the tree will have changed
221      tempNode = null; // clear the clipboard after one paste
222    }
223  }
224}
Note: See TracBrowser for help on using the repository browser.