source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/PushProgramDebuggerView.cs @ 14727

using System.Windows.Forms;

using HeuristicLab.Core.Views;
using HeuristicLab.MainForm;

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

  using HeuristicLab.BenchmarkSuite.Problems;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;

  [View("Push Program Debugger")]
  [Content(typeof(PushSolution), true)]
  public partial class PushProgramDebuggerView : NamedItemView {
    private const string exampleSplitter = " => ";
    private PushGpInterpreter interpreter;

    public PushProgramDebuggerView() {
      InitializeComponent();

      Name = "Push Program Debugger";

      exampleComboBox.SelectedIndexChanged += SelectedExampleIndexChanged;
      runButton.Click += RunButtonClick;
      resetButton.Click += ResetButtonClick;
      stepButton.Click += StepButtonClick;
    }

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

      exampleComboBox.Enabled = !ReadOnly;
      execList.Enabled = !ReadOnly;
      codeList.Enabled = !ReadOnly;
      nameList.Enabled = !ReadOnly;
      integerList.Enabled = !ReadOnly;
      floatList.Enabled = !ReadOnly;
      booleanList.Enabled = !ReadOnly;
    }

    private void RunButtonClick(object sender, EventArgs e) {
      if (interpreter == null)
        return;

      interpreter.Resume();

      UpdateExecList();
      UpdateValueLists();
      CheckIfButtonsCanBeEnabled();
    }

    private void SyncExecList() {
      execList.Items.RemoveAt(0);

      if (!interpreter.ExecStack.SequenceEqual(execList.Items.Cast<Expression>().Reverse())) {
        UpdateExecList();
      }

      this.execGroupBox.Text = string.Format("Exec [{0}]", this.execList.Items.Count);
    }

    private void StepButtonClick(object sender, EventArgs e) {
      if (interpreter == null || stepWidthBox.Value <= 0)
        return;

      var count = Math.Min(stepWidthBox.Value, interpreter.ExecStack.Count);

      for (var i = 0; i < count; i++) {
        interpreter.Step();
      }

      stepWidthBox.Maximum = interpreter.ExecStack.Count;

      SyncExecList();
      UpdateValueLists();
      CheckIfButtonsCanBeEnabled();
    }

    private void CheckIfButtonsCanBeEnabled() {
      if (interpreter == null)
        return;

      runButton.Enabled = interpreter.CanStep;
      stepButton.Enabled = interpreter.CanStep;
      stepWidthBox.Enabled = interpreter.CanStep;
    }

    private void ResetButtonClick(object sender, System.EventArgs e) {
      Reset();
    }

    private void SelectedExampleIndexChanged(object sender, System.EventArgs e) {
      Reset();
    }

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

    private void Reset() {
      if (Content == null ||
        interpreter == null ||
        this.exampleComboBox.SelectedIndex < 0)
        return;

      interpreter.Clear();

      var example = Content.Data.Examples[this.exampleComboBox.SelectedIndex];

      interpreter.BooleanStack.Push(example.InputBoolean);
      interpreter.IntegerStack.Push(example.InputInt);
      interpreter.FloatStack.Push(example.InputFloat);

      interpreter.Run(Content.Program, true);
      stepWidthBox.Maximum = interpreter.ExecStack.Count;

      UpdateValueLists();
      UpdateExecList();
      CheckIfButtonsCanBeEnabled();
    }

    protected override void OnContentChanged() {
      if (Content == null) return;

      interpreter = Content.Pool.GetInstance(Content.Random);

      UpdateExamples(Content.Data);

      if (this.exampleComboBox.SelectedIndex < 0) {
        this.exampleComboBox.SelectedIndex = 0; // Triggers Reset via event
      } else {
        Reset();
      }
    }

    private void ClearLists() {
      codeList.Items.Clear();
      nameList.Items.Clear();
      booleanList.Items.Clear();
      integerList.Items.Clear();
      floatList.Items.Clear();
    }

    private void UpdateExecList() {
      execList.Items.Clear();

      foreach (var item in interpreter.ExecStack.Reverse())
        this.execList.Items.Add(item);

      this.execGroupBox.Text = string.Format("Exec [{0}]", this.execList.Items.Count);
    }

    private void UpdateValueLists() {
      ClearLists();

      if (Content == null || interpreter == null)
        return;

      if (interpreter.Configuration.IsCodeStackEnabled) {
        this.codeList.Enabled = true;

        foreach (var item in interpreter.CodeStack.Reverse())
          this.codeList.Items.Add(item);

        this.codeGroupBox.Text = string.Format("Code [{0}]", this.codeList.Items.Count);
      } else {
        this.codeList.Enabled = false;
        this.codeGroupBox.Text = "Code - Disabled";
      }

      if (interpreter.Configuration.IsIntegerStackEnabled) {
        this.integerList.Enabled = true;

        foreach (var item in interpreter.IntegerStack.Reverse())
          this.integerList.Items.Add(item);

        this.integerGroupBox.Text = string.Format("Integer [{0}]", this.integerList.Items.Count);
      } else {
        this.integerList.Enabled = false;
        this.integerGroupBox.Text = "Integer - Disabled";
      }

      if (interpreter.Configuration.IsFloatStackEnabled) {
        this.floatList.Enabled = true;

        foreach (var item in interpreter.FloatStack.Reverse())
          this.floatList.Items.Add(item);

        this.floatGroupBox.Text = string.Format("Float [{0}]", this.floatList.Items.Count);
      } else {
        this.floatList.Enabled = false;
        this.floatGroupBox.Text = "Float - Disabled";
      }

      if (interpreter.Configuration.IsBooleanStackEnabled) {
        this.booleanList.Enabled = true;

        foreach (var item in interpreter.BooleanStack.Reverse())
          this.booleanList.Items.Add(item);

        this.booleanGroupBox.Text = string.Format("Boolean [{0}]", this.booleanList.Items.Count);
      } else {
        this.booleanList.Enabled = false;
        this.booleanGroupBox.Text = "Boolean - Disabled";
      }

      if (interpreter.Configuration.IsNameStackEnabled) {
        this.nameList.Enabled = true;

        foreach (var item in interpreter.NameStack.Reverse())
          this.nameList.Items.Add(item);

        this.nameGroupBox.Text = string.Format("Name [{0}]", this.nameList.Items.Count);
      } else {
        this.nameList.Enabled = false;
        this.nameGroupBox.Text = "Name - Disabled";
      }
    }

    private void UpdateExamples(Data data) {
      const string seperator = ", ";
      var stringRepresentations = data.Examples.Select(e =>
        string.Join(seperator, e.InputArgs) +
        exampleSplitter +
        string.Join(seperator, e.OutputArgs));

      exampleComboBox.Items.Clear();
      foreach (var str in stringRepresentations) {
        exampleComboBox.Items.Add(str);
      }
    }
  }
}