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

#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);
        symbolViewHost.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();
        symbolicExpressionTreeChart.Tree = null;
        symbolViewHost.Content = null;
      } else {
        symbolsTreeView.Nodes.Clear();
        symbolicExpressionTreeChart.Tree = null;
        symbolViewHost.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;
        symbolViewHost.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));

      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);
        }
      }
      symbolicExpressionTreeChart.Tree = tree;
      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.SubtreesCount == 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 = symbolicExpressionTreeChart.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 && Content.ContainsSymbol(symbol)) validDragOperation = true;
      else if (symbols != null && symbols.All(s => Content.ContainsSymbol(s))) validDragOperation = true;
    }


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

    private void symbolicExpressionTreeChart_DragDrop(object sender, DragEventArgs e) {
      Point coordinates = symbolicExpressionTreeChart.PointToClient(new Point(e.X, e.Y));
      var node = symbolicExpressionTreeChart.FindVisualSymbolicExpressionTreeNodeAt(coordinates.X, coordinates.Y);
      var root = symbolicExpressionTreeChart.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 symbolicExpressionTreeChart.Tree.IterateNodesPrefix()) {
        var visualNode = symbolicExpressionTreeChart.GetVisualSymbolicExpressionTreeNode(node);
        if (!selectedSymbolicExpressionTreeNodes.Contains(node)) {
          visualNode.FillColor = Color.White;
          visualNode.LineColor = Color.Black;
        } else {
          visualNode.FillColor = Color.WhiteSmoke;
          visualNode.LineColor = Color.DarkOrange;
        }
      }
      symbolicExpressionTreeChart.Repaint();
    }

    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++;
          }
          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;
    }

    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
  }

  [NonDiscoverableType]
  internal class DummySymbol : Symbol {
    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); }
  }
}