source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs @ 14914

using System.Windows.Forms;
using HeuristicLab.Core.Views;
using HeuristicLab.MainForm;


namespace HeuristicLab.Problems.ProgramSynthesis.Push.Views {
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using Expressions;

  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;

  using Stack;

  [View("Push Expression Selection Editor")]
  [Content(typeof(IEnabledExpressionsConfiguration), true)]
  public partial class ExpressionSelectionView : NamedItemView {
    public ExpressionSelectionView() {
      InitializeComponent();

      InitEvents();
      Name = "Push Expression Selection Editor";
    }

    public new IEnabledExpressionsConfiguration Content
    {
      get { return (IEnabledExpressionsConfiguration)base.Content; }
      set
      {
        if (Content != null) Content.EnabledExpressionsChanged -= EnabledExpressionsChanged;
        base.Content = value;
      }
    }

    protected override void OnReadOnlyChanged() {
      base.OnReadOnlyChanged();

      expressionsTreeView.Enabled = !ReadOnly;
    }

    private void InitEvents() {
      expressionsTreeView.AfterCheck += ExpressionsTreeViewAfterCheck;
    }

    private void ExpressionsTreeViewAfterCheck(object sender, TreeViewEventArgs e) {
      if (e.Action == TreeViewAction.Unknown)
        return;

      Content.EnabledExpressionsChanged -= EnabledExpressionsChanged;
      var stackType = (StackTypes)e.Node.Tag;

      if (e.Node.Parent == null) {
        Content.SetStack(stackType, e.Node.Checked, true, false);
        SetStackNodeText(e.Node);
        foreach (var subNode in e.Node.Nodes.OfType<TreeNode>().Where(n => n.Checked != e.Node.Checked))
          subNode.Checked = e.Node.Checked;
      } else {
        Content.SetExpression(e.Node.Text, e.Node.Checked, true);
        SetStackNodeText(e.Node.Parent);

        if ((e.Node.Checked && !e.Node.Parent.Checked) ||
            (!e.Node.Checked && !e.Node.Parent.Nodes.OfType<TreeNode>().Any(n => n.Checked)))
          e.Node.Parent.Checked = e.Node.Checked;
      }

      Content.EnabledExpressionsChanged += EnabledExpressionsChanged;
    }

    protected override void OnContentChanged() {
      expressionsTreeView.Nodes.Clear();
      nameTextBox.Text = "Push Expression Selection";

      if (Content == null) {
        return;
      }

      Content.EnabledExpressionsChanged += EnabledExpressionsChanged;
      var treeNodes = GetTreeNodes(Content.EnabledExpressions).ToArray();
      expressionsTreeView.Nodes.AddRange(treeNodes);
    }

    private void EnabledExpressionsChanged(object sender, EnabledExpressionsChangedEventArgs e) {
      if (InvokeRequired) Invoke(new MethodInvoker(UpdateNodes));
      else UpdateNodes();
    }

    private void UpdateNodes() {
      expressionsTreeView.Nodes.Clear();

      var treeNodes = GetTreeNodes(Content.EnabledExpressions).ToArray();
      expressionsTreeView.Nodes.AddRange(treeNodes);
    }

    private IEnumerable<TreeNode> GetTreeNodes(IList<string> enabledExpressions) {
      foreach (var stackType in ExpressionTable.StackTypeToNamesTable.Keys) {
        var stackTreeNode = new TreeNode {
          Tag = stackType
        };

        var stackExpressions = ExpressionTable.StackTypeToNamesTable[stackType];
        var enabledStackExpressions = enabledExpressions.Intersect(stackExpressions).ToList();

        SetStackNodeText(stackTreeNode);
        stackTreeNode.Checked = enabledStackExpressions.Any();

        var expressionNodes = stackExpressions
          .OrderBy(name => name)
          .Select(name => new TreeNode {
            Text = name,
            Tag = stackType,
            Checked = enabledStackExpressions.Contains(name),
          }).ToArray();

        stackTreeNode.Nodes.AddRange(expressionNodes);

        yield return stackTreeNode;
      }
    }

    private void SetStackNodeText(TreeNode node) {
      var stackType = (StackTypes)node.Tag;
      var stackExpressions = ExpressionTable.StackTypeToNamesTable[stackType];
      var enabledStackExpressions = Content.EnabledExpressions.Intersect(stackExpressions).ToList();

      node.Text = string.Format(
                "{0} ({1}/{2})",
                Enum.GetName(typeof(StackTypes), stackType),
                enabledStackExpressions.Count,
                ExpressionTable.StackTypeToNamesTable[stackType].Count);
    }
  }
}