source: branches/HeuristicLab.TreeSimplifier/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views/3.4/InteractiveSymbolicExpressionTreeChart.cs @ 8388

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Problems.DataAnalysis.Symbolic.Views;

namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views {
  public partial class InteractiveSymbolicExpressionTreeChart : SymbolicExpressionTreeChart {
    private ISymbolicExpressionTreeNode _tempNode;
    private VisualSymbolicExpressionTreeNode _lastSelected; // previously selected node
    private VisualSymbolicExpressionTreeNode _currSelected; // currently selected node
    private enum EditOp { CopyNode, CopySubtree, CutNode, CutSubtree, DeleteNode, DeleteSubtree }
    private enum TreeState { Valid, Invalid }
    private int lastOp = -1;
    private TreeState treeState = TreeState.Valid; // tree edit operations must leave the tree in a valid state

    public InteractiveSymbolicExpressionTreeChart() {
      InitializeComponent();
      // add extra actions in the context menu strips
      this.contextMenuStrip.Opened += this.contextMenuStrip_Opened;
      this.contextMenuStrip.Items.AddRange(new ToolStripItem[] {
                                               insertNodeToolStripMenuItem,
                                               changeValueToolStripMenuItem, 
                                               copyToolStripMenuItem, 
                                               cutToolStripMenuItem, 
                                               deleteToolStripMenuItem, 
                                               pasteToolStripMenuItem });
      _lastSelected = null;
      _currSelected = null;
      _tempNode = null;
    }

    public bool TreeValid {
      get { return TreeState.Valid == treeState; }
    }

    // expose an additional event for signaling to the parent view when the tree structure was modified
    // the emitting of the signal is conditional on the tree being valid, otherwise only a Repaint is issued
    public event EventHandler SymbolicExpressionTreeChanged;
    private void OnSymbolicExpressionTreeChanged(object sender, EventArgs e) {
      if (IsValid(Tree)) {
        treeStatusValue.Text = "Valid";
        treeStatusValue.ForeColor = Color.Green;
        treeState = TreeState.Valid;
        var changed = SymbolicExpressionTreeChanged;
        if (changed != null) {
          changed(sender, e);
        }
      } else {
        treeStatusValue.Text = "Invalid";
        treeStatusValue.ForeColor = Color.Red;
        treeState = TreeState.Invalid;
        Repaint();
      }
    }

    private void contextMenuStrip_Opened(object sender, EventArgs e) {
      var menu = sender as ContextMenuStrip;
      if (menu == null) return;
      var point = menu.SourceControl.PointToClient(Cursor.Position);
      var visualNode = FindVisualSymbolicExpressionTreeNodeAt(point.X, point.Y);
      if (visualNode != null) {
        _lastSelected = _currSelected;
        if (_lastSelected != null) _lastSelected.LineColor = Color.Black;
        _currSelected = visualNode;
        _currSelected.LineColor = Color.LightGreen;
        var node = _currSelected.SymbolicExpressionTreeNode;
        var item = FindMenuItemByName("changeValueToolStripMenuItem");
        if (node is ConstantTreeNode || node is VariableTreeNode) {
          item.Enabled = true;
          item.Visible = true;
        } else {
          // do not show the change value menu item if the node is not a Constant or a Variable
          item.Enabled = false;
          item.Visible = false;
        }
        item = FindMenuItemByName("pasteToolStripMenuItem");
        item.Enabled = (_tempNode != null);
        // then, notify the parent so it can do its own stuff
        // we pass the actual SymbolicExpressionTreeNode (and not the visual node) to the event handler,
        // along with a new mouse event arg, to try to be consistend with naming semantics
        OnSymbolicExpressionTreeNodeClicked(_currSelected, new MouseEventArgs(MouseButtons.Right, 1, point.X, point.Y, 0));
      }
    }

    protected override void SymbolicExpressionTreeChart_MouseClick(object sender, MouseEventArgs e) {
      VisualSymbolicExpressionTreeNode visualTreeNode = FindVisualSymbolicExpressionTreeNodeAt(e.X, e.Y);
      if (visualTreeNode != null) {
        _lastSelected = _currSelected;
        if (_lastSelected != null) _lastSelected.LineColor = Color.Black;
        _currSelected = visualTreeNode;
        _currSelected.LineColor = Color.LightGreen;
      }
      Repaint();
      base.SymbolicExpressionTreeChart_MouseClick(sender, e);
    }

    private void insertNodeToolStripMenuItem_Click(object sender, EventArgs e) {
      if (_currSelected == null || _currSelected.SymbolicExpressionTreeNode is SymbolicExpressionTreeTerminalNode) return;
      var node = _currSelected.SymbolicExpressionTreeNode;

      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 += OnInsertNodeDialogValidated;
      dialog.ShowDialog(this);
    }

    private void changeValueToolStripMenuItem_Click(object sender, EventArgs e) {
      if (_currSelected == null) return;
      var node = _currSelected.SymbolicExpressionTreeNode;
      var dialog = new ValueChangeDialog();
      dialog.SetContent(node);
      dialog.DialogValidated += OnChangeValueDialogValidated;
      dialog.ShowDialog(this);
    }

    public event EventHandler SymbolicExpressionTreeNodeChanged;
    public event EventHandler SymbolicExpressionTreeNodeInserted;

    private void OnChangeValueDialogValidated(object sender, EventArgs e) {
      SymbolicExpressionTreeNodeChanged(sender, e);
    }

    private void OnInsertNodeDialogValidated(object sender, EventArgs e) {
      var dialog = (InsertNodeDialog)sender;
      var symbol = dialog.SelectedSymbol();
      var node = symbol.CreateTreeNode();
      var parent = _currSelected.SymbolicExpressionTreeNode;
      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);
          }
        }
        // we assume that there is no case in which the parents subtrees get transferred to node, but node doesn't get added as a subtree of parent
      }
      if (parent.Symbol.MaximumArity > parent.SubtreeCount) {
        parent.AddSubtree(node);
        Tree = Tree;
      }
      OnSymbolicExpressionTreeChanged(sender, e);
    }

    private void cutNodeToolStripMenuItem_Click(object sender, EventArgs e) {
      lastOp = (int)EditOp.CutNode;
      _tempNode = _currSelected.SymbolicExpressionTreeNode;
      var visualNode = visualTreeNodes[_tempNode];
      visualNode.LineColor = Color.LightGray;
      visualNode.TextColor = Color.LightGray;
      Repaint();
    }

    private void cutSubtreeToolStripMenuItem_Click(object sender, EventArgs e) {
      lastOp = (int)EditOp.CutSubtree;
      _tempNode = _currSelected.SymbolicExpressionTreeNode; // should never be null
      foreach (var node in _tempNode.IterateNodesPostfix()) {
        var visualNode = visualTreeNodes[node];
        visualNode.LineColor = Color.LightGray;
        visualNode.TextColor = Color.LightGray;
        if (node.SubtreeCount > 0) {
          foreach (var subtree in node.Subtrees) {
            var visualLine = visualLines[new Tuple<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>(node, subtree)];
            visualLine.LineColor = Color.LightGray;
          }
        }
      }
      Repaint();
    }

    private void copyNodeToolStripMenuItem_Click(object sender, EventArgs e) {
      lastOp = (int)EditOp.CopyNode;
      _tempNode = _currSelected.SymbolicExpressionTreeNode;
    }

    private void copySubtreeToolStripMenuItem_Click(object sender, EventArgs e) {
      lastOp = (int)EditOp.CopySubtree;
      _tempNode = _currSelected.SymbolicExpressionTreeNode;
    }

    private void deleteNodeToolStripMenuItem_Click(object sender, EventArgs e) {
      lastOp = (int)EditOp.DeleteNode;
      var node = _currSelected.SymbolicExpressionTreeNode;
      var parent = node.Parent;
      if (parent.Symbol.MaximumArity >= node.SubtreeCount + parent.SubtreeCount - 1) { // -1 because tempNode will be removed
        parent.RemoveSubtree(parent.IndexOfSubtree(node));
        for (int i = node.SubtreeCount - 1; i >= 0; --i) {
          var child = node.GetSubtree(i);
          node.RemoveSubtree(i);
          parent.AddSubtree(child);
        }
      } else {
        // if the node cannot be deleted without breaking the tree, do nothing
        // TODO: decide what to do
      }
      OnSymbolicExpressionTreeChanged(sender, e);
    }

    private void deleteSubtreeToolStripMenuItem_Click(object sender, EventArgs e) {
      lastOp = (int)EditOp.DeleteSubtree;
      var node = _currSelected.SymbolicExpressionTreeNode;
      var parent = node.Parent;
      parent.RemoveSubtree(parent.IndexOfSubtree(node));
      OnSymbolicExpressionTreeChanged(sender, e);
    }

    private void pasteToolStripMenuItem_Clicked(object sender, EventArgs e) {
      // 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
      // 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
      if (node.Symbol.MaximumArity > node.SubtreeCount) {
        switch (lastOp) {
          case ((int)EditOp.CutNode): // cut node
            var parent = _tempNode.Parent;
            // arity checks to see if parent can accept node's children (we assume the grammar is already ok with that)
            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) {
                var child = _tempNode.GetSubtree(i);
                _tempNode.RemoveSubtree(i);
                parent.AddSubtree(child);
              }
              lastOp = (int)EditOp.CopyNode;
            }
            break;
          case ((int)EditOp.CutSubtree): // cut subtree
            _tempNode.Parent.RemoveSubtree(_tempNode.Parent.IndexOfSubtree(_tempNode));
            lastOp = (int)EditOp.CopySubtree; // do this so the next paste will actually perform a copy
            break;
          case ((int)EditOp.CopyNode): // copy node
            _tempNode = _tempNode.Clone() as ISymbolicExpressionTreeNode; // should never be null
            if (_tempNode != null && _tempNode.SubtreeCount > 0) {
              for (int i = _tempNode.SubtreeCount - 1; i >= 0; --i)
                _tempNode.RemoveSubtree(i);
            }
            break;
          case ((int)EditOp.CopySubtree): // copy subtree
            _tempNode = _tempNode.Clone() as ISymbolicExpressionTreeNode;
            break;
        }
        node.AddSubtree(_tempNode);
        Tree = Tree; // hack in order to trigger the reinitialization of the dictionaries after new nodes appeared in the graph
        OnSymbolicExpressionTreeChanged(sender, e);
      } else {
        // throw exception or show a warning to the user about invalid arity
      }
    }

    private bool IsValid(ISymbolicExpressionTree tree) {
      if (tree.IterateNodesPostfix().Any(node => node.SubtreeCount < node.Symbol.MinimumArity || node.SubtreeCount > node.Symbol.MaximumArity)) {
        treeState = TreeState.Invalid;
        return false;
      }
      treeState = TreeState.Valid;
      return true;
    }

    private ToolStripItem FindMenuItemByName(string name) {
      ToolStripItem[] items = ContextMenuStrip.Items.Find(name, false);
      return items.Any() ? items[0] : null;
    }
  }
}