source: branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views/3.4/SymbolicExpressionGrammarEditorView.cs @ 6403

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2011 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.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using HeuristicLab.Collections;
using HeuristicLab.Common;
using HeuristicLab.Core.Views;
using HeuristicLab.MainForm;
using HeuristicLab.PluginInfrastructure;

namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views {
  [View("Symbolic Expression Grammar Editor")]
  [Content(typeof(ISymbolicExpressionGrammar), false)]
  public partial class SymbolicExpressionGrammarEditorView : NamedItemView {
    private ObservableList<ISymbolicExpressionTreeNode> selectedSymbolicExpressionTreeNodes;

    public SymbolicExpressionGrammarEditorView() {
      InitializeComponent();
      selectedSymbolicExpressionTreeNodes = new ObservableList<ISymbolicExpressionTreeNode>();
    }

    public override bool ReadOnly {
      get {
        if ((Content != null) && Content.ReadOnly) return true;
        return base.ReadOnly;
      }
      set {
        if ((Content != null) && Content.ReadOnly) base.ReadOnly = true;
        else base.ReadOnly = value;
      }
    }

    public new ISymbolicExpressionGrammar Content {
      get { return (ISymbolicExpressionGrammar)base.Content; }
      set { base.Content = value; }
    }

    #region events
    protected override void RegisterContentEvents() {
      base.RegisterContentEvents();
      Content.ReadOnlyChanged += new System.EventHandler(Content_ReadOnlyChanged);
      Content.Changed += new System.EventHandler(Content_Changed);
    }
    protected override void DeregisterContentEvents() {
      Content.ReadOnlyChanged -= new System.EventHandler(Content_ReadOnlyChanged);
      Content.Changed -= new System.EventHandler(Content_Changed);
      base.DeregisterContentEvents();
    }

    private void Content_ReadOnlyChanged(object sender, EventArgs e) {
      ReadOnly = Content.ReadOnly;
    }

    private void Content_Changed(object sender, EventArgs e) {
      ISymbol symbol = null;
      if (symbolsTreeView.SelectedNode != null)
        symbol = (ISymbol)symbolsTreeView.SelectedNode.Tag;

      RebuildSymbolsTreeView();
      if (symbol != null && Content.ContainsSymbol(symbol)) {
        BuildAllowedChildSymbolsTree(symbol);
        symbolDetailsViewHost.Content = symbol;
        symbolsTreeView.SelectedNode = IterateSymbolTreeNodes().Where(n => n.Tag == symbol).ToList().FirstOrDefault();
      }
    }
    #endregion

    protected override void SetEnabledStateOfControls() {
      base.SetEnabledStateOfControls();
    }

    protected override void OnContentChanged() {
      base.OnContentChanged();
      if (Content != null) {
        RebuildSymbolsTreeView();
        allowedChildSymbolsControl.Tree = null;
        symbolDetailsViewHost.Content = null;
      } else {
        symbolsTreeView.Nodes.Clear();
        allowedChildSymbolsControl.Tree = null;
        symbolDetailsViewHost.Content = null;
      }
    }

    private void AddChildTreeNodes(TreeNodeCollection collection, IEnumerable<ISymbol> symbols) {
      foreach (ISymbol symbol in symbols) {
        var node = new TreeNode();
        node.Name = symbol.Name;
        node.Text = symbol.Name;
        node.Tag = symbol;
        node.Checked = symbol.Enabled;
        collection.Add(node);
        var groupSymbol = symbol as GroupSymbol;
        if (groupSymbol != null) AddChildTreeNodes(node.Nodes, groupSymbol.Symbols);
      }
    }

    private void symbolsTreeView_AfterSelect(object sender, TreeViewEventArgs e) {
      if (e.Action != TreeViewAction.Unknown) {
        var symbol = (ISymbol)e.Node.Tag;
        symbolDetailsViewHost.Content = symbol;
        selectedSymbolicExpressionTreeNodes.Clear();
        BuildAllowedChildSymbolsTree(symbol);
      }
      removeButton.Enabled = symbolsTreeView.SelectedNode != null && !(symbolsTreeView.SelectedNode.Tag is IReadOnlySymbol);
    }

    private void symbolsTreeView_AfterCheck(object sender, TreeViewEventArgs e) {
      if (e.Action != TreeViewAction.Unknown) {
        DeregisterContentEvents();
        var symbol = (ISymbol)e.Node.Tag;
        symbol.Enabled = e.Node.Checked;
        foreach (var node in IterateSymbolTreeNodes())
          node.Checked = ((ISymbol)node.Tag).Enabled;

        if (symbolsTreeView.SelectedNode != null) {
          symbol = (ISymbol)symbolsTreeView.SelectedNode.Tag;
          selectedSymbolicExpressionTreeNodes.Clear();
          BuildAllowedChildSymbolsTree(symbol);
        }
        RegisterContentEvents();
      }
    }

    private void RebuildSymbolsTreeView() {
      symbolsTreeView.Nodes.Clear();
      var symbols = Content.Symbols.ToList();
      var groupSymbols = symbols.OfType<GroupSymbol>().ToList();
      var topLevelSymbols = Content.Symbols.Where(s => !groupSymbols.Any(g => g.Symbols.Contains(s)));
      AddChildTreeNodes(symbolsTreeView.Nodes, topLevelSymbols);

      RebuildImageList();
      symbolsTreeView.ExpandAll();
    }

    private void BuildAllowedChildSymbolsTree(ISymbol symbol) {
      var tree = new SymbolicExpressionTree(new SymbolicExpressionTreeNode(symbol));

      allowedChildSymbolsControl.SuspendRepaint = true;
      if (Content.GetMaximumSubtreeCount(symbol) > 0) {
        for (int i = 0; i < Content.GetMaximumSubtreeCount(symbol); i++) {
          var node = new DummySymbol("Subtree " + i).CreateTreeNode();
          foreach (var childSymbol in Content.GetAllowedChildSymbols(symbol, i)) {
            node.AddSubtree(new SymbolicExpressionTreeNode(childSymbol));
          }
          tree.Root.AddSubtree(node);
        }
      }
      allowedChildSymbolsControl.Tree = tree;

      foreach (var subtreeNode in tree.Root.Subtrees) {
        foreach (var allowedChildNode in subtreeNode.Subtrees) {
          var visualLine = allowedChildSymbolsControl.GetVisualSymbolicExpressionTreeNodeConnection(subtreeNode, allowedChildNode);
          visualLine.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
        }
      }

      for (int i = Content.GetMinimumSubtreeCount(symbol); i < Content.GetMaximumSubtreeCount(symbol); i++) {
        var subtreeNode = tree.Root.GetSubtree(i);
        var visualTreeNode = allowedChildSymbolsControl.GetVisualSymbolicExpressionTreeNode(subtreeNode);
        visualTreeNode.TextColor = Color.Gray;
        visualTreeNode.LineColor = Color.LightGray;

        var visualLine = allowedChildSymbolsControl.GetVisualSymbolicExpressionTreeNodeConnection(tree.Root, subtreeNode);
        visualLine.LineColor = Color.LightGray;

        foreach (var allowedChildNode in subtreeNode.Subtrees) {
          visualTreeNode = allowedChildSymbolsControl.GetVisualSymbolicExpressionTreeNode(allowedChildNode);
          visualTreeNode.TextColor = Color.Gray;
          visualTreeNode.LineColor = Color.LightGray;

          visualLine = allowedChildSymbolsControl.GetVisualSymbolicExpressionTreeNodeConnection(subtreeNode, allowedChildNode);
          visualLine.LineColor = Color.LightGray;
        }
      }

      allowedChildSymbolsControl.SuspendRepaint = false;
      allowedChildSymbolsControl.Repaint();
      UpdateSelectedSymbolicExpressionTreeNodes();
    }

    private void symbolicExpressionTreeChart_SymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
      if ((Control.ModifierKeys & Keys.Control) == 0)
        selectedSymbolicExpressionTreeNodes.Clear();

      VisualSymbolicExpressionTreeNode clickedNode = (VisualSymbolicExpressionTreeNode)sender;
      var selectedNode = clickedNode.SymbolicExpressionTreeNode;
      if (selectedNode.SubtreeCount == 0) {
        if (!selectedSymbolicExpressionTreeNodes.Contains(selectedNode))
          selectedSymbolicExpressionTreeNodes.Add(selectedNode);
        else
          selectedSymbolicExpressionTreeNodes.Remove(selectedNode);
      }

      UpdateSelectedSymbolicExpressionTreeNodes();
    }

    private void symbolicExpressionTreeChart_KeyDown(object sender, KeyEventArgs e) {
      if (e.KeyCode == Keys.Delete) {
        DeregisterContentEvents();
        var root = allowedChildSymbolsControl.Tree.Root;
        foreach (var node in selectedSymbolicExpressionTreeNodes) {
          int argIndex = root.IndexOfSubtree(node.Parent);
          Content.RemoveAllowedChildSymbol(root.Symbol, node.Symbol, argIndex);
        }
        RegisterContentEvents();
        selectedSymbolicExpressionTreeNodes.Clear();
        BuildAllowedChildSymbolsTree(root.Symbol);
      }
    }

    private void symbolsTreeView_ItemDrag(object sender, ItemDragEventArgs e) {
      if (!Locked) {
        DataObject data = new DataObject();
        data.SetData(HeuristicLab.Common.Constants.DragDropDataFormat, ((TreeNode)e.Item).Tag);
        DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Link);
      }
    }

    private bool validDragOperation;
    private void symbolicExpressionTreeChart_DragEnter(object sender, DragEventArgs e) {
      validDragOperation = false;
      var data = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
      var symbol = data as ISymbol;
      var symbols = data as IEnumerable<ISymbol>;
      if (symbol != null && !(symbol is IReadOnlySymbol) && Content.ContainsSymbol(symbol)) validDragOperation = true;
      else if (symbols != null && symbols.All(s => !(symbol is IReadOnlySymbol) && Content.ContainsSymbol(s))) validDragOperation = true;
    }

    private void symbolicExpressionTreeChart_DragOver(object sender, DragEventArgs e) {
      e.Effect = DragDropEffects.None;
      if (validDragOperation) {
        Point coordinates = allowedChildSymbolsControl.PointToClient(new Point(e.X, e.Y));
        var visualNode = allowedChildSymbolsControl.FindVisualSymbolicExpressionTreeNodeAt(coordinates.X, coordinates.Y);
        if (visualNode != null) {
          var node = visualNode.SymbolicExpressionTreeNode;
          var root = allowedChildSymbolsControl.Tree.Root;
          if (root.Symbol is ProgramRootSymbol) return;
          if (node == root || node.Parent == root) e.Effect = DragDropEffects.Copy;
        }
      }
    }

    private void symbolicExpressionTreeChart_DragDrop(object sender, DragEventArgs e) {
      Point coordinates = allowedChildSymbolsControl.PointToClient(new Point(e.X, e.Y));
      var node = allowedChildSymbolsControl.FindVisualSymbolicExpressionTreeNodeAt(coordinates.X, coordinates.Y);
      var root = allowedChildSymbolsControl.Tree.Root;

      var data = e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
      var symbol = data as ISymbol;
      var symbols = data as IEnumerable<ISymbol>;

      DeregisterContentEvents();
      if (node.SymbolicExpressionTreeNode == root) {
        if (symbol != null)
          Content.AddAllowedChildSymbol(root.Symbol, symbol);
        else if (symbols != null)
          foreach (var s in symbols) Content.AddAllowedChildSymbol(root.Symbol, s);
      } else {
        int argumentIndex = root.IndexOfSubtree(node.SymbolicExpressionTreeNode);
        if (symbol != null)
          Content.AddAllowedChildSymbol(root.Symbol, symbol, argumentIndex);
        else if (symbols != null)
          foreach (var s in symbols) Content.AddAllowedChildSymbol(root.Symbol, s, argumentIndex);
      }
      RegisterContentEvents();
      BuildAllowedChildSymbolsTree(root.Symbol);
    }

    private void UpdateSelectedSymbolicExpressionTreeNodes() {
      foreach (var node in allowedChildSymbolsControl.Tree.IterateNodesPrefix()) {
        var visualNode = allowedChildSymbolsControl.GetVisualSymbolicExpressionTreeNode(node);
        if (!selectedSymbolicExpressionTreeNodes.Contains(node)) visualNode.FillColor = Color.White;
        else visualNode.FillColor = Color.LightSteelBlue;

      }
      allowedChildSymbolsControl.Repaint();
    }

    private RectangleF increaseMinimumSubtreeCountRectangle;
    private RectangleF decreaseMinimumSubtreeCountRectangle;
    private RectangleF increaseMaximumSubtreeCountRectangle;
    private RectangleF decreaseMaximumSubtreeCountRectangle;
    private void allowedChildSymbolsControl_Paint(object sender, PaintEventArgs e) {
      increaseMinimumSubtreeCountRectangle = RectangleF.Empty;
      decreaseMinimumSubtreeCountRectangle = RectangleF.Empty;
      increaseMaximumSubtreeCountRectangle = RectangleF.Empty;
      decreaseMaximumSubtreeCountRectangle = RectangleF.Empty;

      if (Content == null) return;
      if (allowedChildSymbolsControl.Tree == null) return;

      var rootNode = allowedChildSymbolsControl.Tree.Root;
      var visualRootNode = allowedChildSymbolsControl.GetVisualSymbolicExpressionTreeNode(rootNode);
      var graphics = e.Graphics;

      if (rootNode.Symbol is IReadOnlySymbol) return;
      if (rootNode.Symbol.MinimumArity == rootNode.Symbol.MaximumArity) return;

      using (Pen pen = new Pen(Color.Black)) {
        using (Font font = new Font("Times New Roman", 8)) {
          var stringFormat = new StringFormat();
          stringFormat.Alignment = StringAlignment.Center;
          stringFormat.LineAlignment = StringAlignment.Center;
          int spacing = 5;
          int size = (visualRootNode.Height - spacing * 3) / 2;

          increaseMinimumSubtreeCountRectangle = new RectangleF(visualRootNode.X - spacing - size, visualRootNode.Y + spacing, size, size);
          decreaseMinimumSubtreeCountRectangle = new RectangleF(visualRootNode.X - spacing - size, visualRootNode.Y + size + 2 * spacing, size, size);
          increaseMaximumSubtreeCountRectangle = new RectangleF(visualRootNode.X + visualRootNode.Width + spacing, visualRootNode.Y + spacing, size, size);
          decreaseMaximumSubtreeCountRectangle = new RectangleF(visualRootNode.X + visualRootNode.Width + spacing, visualRootNode.Y + size + 2 * spacing, size, size);

          pen.Color = Content.GetMaximumSubtreeCount(rootNode.Symbol) == Content.GetMinimumSubtreeCount(rootNode.Symbol) ? Color.LightGray : Color.Black;
          graphics.DrawString("+", font, pen.Brush, increaseMinimumSubtreeCountRectangle, stringFormat);
          graphics.DrawRectangle(pen, Rectangle.Round(increaseMinimumSubtreeCountRectangle));
          if (pen.Color == Color.LightGray) increaseMinimumSubtreeCountRectangle = RectangleF.Empty;

          pen.Color = Content.GetMinimumSubtreeCount(rootNode.Symbol) == rootNode.Symbol.MinimumArity ? Color.LightGray : Color.Black;
          graphics.DrawString("-", font, pen.Brush, decreaseMinimumSubtreeCountRectangle, stringFormat);
          graphics.DrawRectangle(pen, Rectangle.Round(decreaseMinimumSubtreeCountRectangle));
          if (pen.Color == Color.LightGray) decreaseMinimumSubtreeCountRectangle = RectangleF.Empty;

          pen.Color = Content.GetMaximumSubtreeCount(rootNode.Symbol) == rootNode.Symbol.MaximumArity ? Color.LightGray : Color.Black;
          graphics.DrawRectangle(pen, Rectangle.Round(increaseMaximumSubtreeCountRectangle));
          graphics.DrawString("+", font, pen.Brush, increaseMaximumSubtreeCountRectangle, stringFormat);
          if (pen.Color == Color.LightGray) increaseMaximumSubtreeCountRectangle = RectangleF.Empty;

          pen.Color = Content.GetMaximumSubtreeCount(rootNode.Symbol) == Content.GetMinimumSubtreeCount(rootNode.Symbol) ? Color.LightGray : Color.Black;
          graphics.DrawRectangle(pen, Rectangle.Round(decreaseMaximumSubtreeCountRectangle));
          graphics.DrawString("-", font, pen.Brush, decreaseMaximumSubtreeCountRectangle, stringFormat);
          if (pen.Color == Color.LightGray) decreaseMaximumSubtreeCountRectangle = RectangleF.Empty;
        }
      }
    }

    private TypeSelectorDialog typeSelectorDialog;
    private void addButton_Click(object sender, EventArgs e) {
      if (typeSelectorDialog == null) {
        typeSelectorDialog = new TypeSelectorDialog();
        typeSelectorDialog.Caption = "Select Symbol";
        typeSelectorDialog.TypeSelector.Caption = "Available Symbols";
        typeSelectorDialog.TypeSelector.Configure(typeof(ISymbol), false, false, (t) => { return !typeof(IReadOnlySymbol).IsAssignableFrom(t); });
      }
      if (typeSelectorDialog.ShowDialog(this) == DialogResult.OK) {
        try {
          ISymbol symbol = (ISymbol)typeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
          var originalSymbolName = symbol.Name;
          int i = 1;
          while (Content.ContainsSymbol(symbol)) {
            symbol.Name = originalSymbolName + i;
            i++;
          }

          var selectedNode = symbolsTreeView.SelectedNode;
          GroupSymbol groupSymbol = null;
          while (selectedNode != null) {
            groupSymbol = selectedNode.Tag as GroupSymbol;
            if (groupSymbol != null && Content.ContainsSymbol(groupSymbol)) break;
            selectedNode = selectedNode.Parent;
          }

          if (groupSymbol != null && Content.ContainsSymbol(groupSymbol)) groupSymbol.SymbolsCollection.Add(symbol);
          else Content.AddSymbol(symbol);
        }
        catch (Exception ex) {
          ErrorHandling.ShowErrorDialog(this, ex);
        }
      }
    }

    private void removeButton_Click(object sender, EventArgs e) {
      var symbol = symbolsTreeView.SelectedNode.Tag as ISymbol;
      if (symbol != null && !(symbol is IReadOnlySymbol))
        Content.RemoveSymbol(symbol);
      removeButton.Enabled = false;
      allowedChildSymbolsControl.Tree = null;
      symbolDetailsViewHost.Content = null;
    }

    private void showDetailsCheckBox_CheckedChanged(object sender, EventArgs e) {
      splitContainer1.Panel2Collapsed = !showDetailsCheckBox.Checked;
    }

    #region helpers
    private IEnumerable<TreeNode> IterateSymbolTreeNodes(TreeNode node = null) {
      TreeNodeCollection nodes;
      if (node == null)
        nodes = symbolsTreeView.Nodes;
      else {
        nodes = node.Nodes;
        yield return node;
      }

      foreach (var childNode in nodes.OfType<TreeNode>())
        foreach (var n in IterateSymbolTreeNodes(childNode))
          yield return n;
    }

    protected virtual void RebuildImageList() {
      symbolsTreeView.ImageList.Images.Clear();
      foreach (TreeNode treeNode in IterateSymbolTreeNodes()) {
        var symbol = (ISymbol)treeNode.Tag;
        symbolsTreeView.ImageList.Images.Add(symbol == null ? HeuristicLab.Common.Resources.VSImageLibrary.Nothing : symbol.ItemImage);
        treeNode.ImageIndex = symbolsTreeView.ImageList.Images.Count - 1;
      }
    }
    #endregion

    private void allowedChildSymbolsControl_MouseDown(object sender, MouseEventArgs e) {
      if (Content == null) return;
      if (allowedChildSymbolsControl.Tree == null) return;

      var pointF = new PointF(e.X, e.Y);
      var rootSymbol = allowedChildSymbolsControl.Tree.Root.Symbol;
      int minimumSubtreeCount = Content.GetMinimumSubtreeCount(rootSymbol);
      int maximumSubtreecount = Content.GetMaximumSubtreeCount(rootSymbol);

      bool changed = true;
      DeregisterContentEvents();
      if (increaseMinimumSubtreeCountRectangle.Contains(pointF))
        Content.SetSubtreeCount(rootSymbol, minimumSubtreeCount + 1, maximumSubtreecount);
      else if (decreaseMinimumSubtreeCountRectangle.Contains(pointF))
        Content.SetSubtreeCount(rootSymbol, minimumSubtreeCount - 1, maximumSubtreecount);
      else if (increaseMaximumSubtreeCountRectangle.Contains(pointF))
        Content.SetSubtreeCount(rootSymbol, minimumSubtreeCount, maximumSubtreecount + 1);
      else if (decreaseMaximumSubtreeCountRectangle.Contains(pointF))
        Content.SetSubtreeCount(rootSymbol, minimumSubtreeCount, maximumSubtreecount - 1);
      else
        changed = false;

      if (changed) BuildAllowedChildSymbolsTree(rootSymbol);
      RegisterContentEvents();
    }
  }

  [NonDiscoverableType]
  internal class DummySymbol : Symbol {
    private const int minimumArity = 1;
    private const int maximumArity = byte.MaxValue;

    public override int MinimumArity {
      get { return minimumArity; }
    }
    public override int MaximumArity {
      get { return maximumArity; }
    }

    public DummySymbol(DummySymbol original, Cloner cloner) : base(original, cloner) { }
    public DummySymbol(string name) : base(name, "DummySymbol for views") { }
    public override IDeepCloneable Clone(Cloner cloner) { return new DummySymbol(this, cloner); }
  }
}