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

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
      {
        base.Content = value;
      }
    }

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

      this.expressionsTreeView.Enabled = !ReadOnly;
    }

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

    private void ExpressionsTreeViewAfterCheck(object sender, TreeViewEventArgs e) {
      var isStackNode = e.Node.Tag is StackType;

      if (isStackNode) {
        if (e.Node.Checked) {
          Content.EnableStack((StackType)e.Node.Tag);
          foreach (var subNode in e.Node.Nodes.Cast<TreeNode>())
            subNode.Checked = true;
        } else {
          Content.DisableStack((StackType)e.Node.Tag);
          foreach (var subNode in e.Node.Nodes.Cast<TreeNode>())
            subNode.Checked = false;
        }
      } else {
        if (e.Node.Checked) {
          Content.EnableExpression(e.Node.Name);
        } else {
          Content.DisableExpression(e.Node.Name);
        }
      }
    }

    protected override void OnContentChanged() {
      expressionsTreeView.Nodes.Clear();

      if (Content == null) {
        return;
      }

      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,
          Text = Enum.GetName(typeof(StackType), stackType),
        };

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

        stackTreeNode.Checked = enabledStackExpressions.Any();

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

        stackTreeNode.Nodes.AddRange(expressionNodes);

        yield return stackTreeNode;
      }
    }
  }
}