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

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;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;
  using HeuristicLab.Random;

  [View("Push Program Debugger")]
  [Content(typeof(PushSolution), true)]
  public partial class PushProgramDebuggerView : NamedItemView {
    private const string Separator = ", ";
    private PushProgram program;

    private ListViewItem[] execListCache; //array to cache items for the virtual list
    private int firstExecListItemIndex; //stores the index of the first item in the cache

    private const string exampleSplitter = " => ";
    private PushInterpreter interpreter;

    public PushProgramDebuggerView() {
      InitializeComponent();

      Name = "Push Program Debugger";

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

      execList.RetrieveVirtualItem += ExecListRetrieveVirtualItem;
      execList.CacheVirtualItems += ExecListCacheVirtualItems;

      execList.View = View.Details;
      execList.HeaderStyle = ColumnHeaderStyle.Nonclickable;
      execList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.None);
      execList.Columns.Add(new ColumnHeader { Width = execList.Width - 40 });
      execList.VirtualMode = true;
      execList.VirtualListSize = 100;
    }

    private void ExecListCacheVirtualItems(object sender, CacheVirtualItemsEventArgs e) {
      //We've gotten a request to refresh the cache.
      //First check if it's really neccesary.
      if (execListCache != null &&
        e.StartIndex >= firstExecListItemIndex &&
        e.EndIndex <= firstExecListItemIndex + execListCache.Length) {
        //If the newly requested cache is a subset of the old cache,
        //no need to rebuild everything, so do nothing.
        return;
      }

      //Now we need to rebuild the cache.
      UpdateListCache(e.StartIndex, e.EndIndex);
    }

    private void ExecListRetrieveVirtualItem(object sender, RetrieveVirtualItemEventArgs e) {
      //check to see if the requested item is currently in the cache
      if (execListCache == null ||
        e.ItemIndex < firstExecListItemIndex ||
        e.ItemIndex >= firstExecListItemIndex + execListCache.Length) {
        UpdateListCache(e.ItemIndex, execList.VirtualListSize);
      }

      e.Item = e.ItemIndex >= firstExecListItemIndex && e.ItemIndex < firstExecListItemIndex + execListCache.Length
          ? execListCache[e.ItemIndex - firstExecListItemIndex]
          : e.Item = new ListViewItem();
    }

    private void UpdateListCache(int startIndex, int endIndex) {
      if (interpreter == null) {
        execListCache = new ListViewItem[0];
        return;
      }

      this.firstExecListItemIndex = startIndex;
      var length = Math.Min(endIndex - startIndex + 1, interpreter.ExecStack.Count); //indexes are inclusive
      this.execListCache = new ListViewItem[length];

      var expressions = this.interpreter.ExecStack.Peek(length);

      //Fill the cache with the appropriate ListViewItems.
      for (var i = 0; i < length; i++)
        this.execListCache[i] = new ListViewItem(expressions[length - 1 - i].ToString());

      execList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.None);
      execList.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
    }

    //protected override void OnEnabledChanged(EventArgs e) {
    //  SetReadonlyFields();
    //}

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

    //  SetReadonlyFields();
    //}

    //protected override void SetEnabledStateOfControls()
    //{
    //  SetReadonlyFields();
    //}

    private void SetReadonlyFields() {
      exampleComboBox.Enabled = !ReadOnly;
      execList.Enabled = !ReadOnly;
      codeList.Enabled = !ReadOnly;
      nameList.Enabled = !ReadOnly;
      integerList.Enabled = !ReadOnly;
      floatList.Enabled = !ReadOnly;
      booleanList.Enabled = !ReadOnly;
      stepButton.Enabled = !ReadOnly;
      runButton.Enabled = !ReadOnly;
      resetButton.Enabled = !ReadOnly;
      skipNoopsCheckBox.Enabled = !ReadOnly;
      stepWidthBox.Enabled = !ReadOnly;
    }

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

      interpreter.Resume();

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

    private void SyncExecList() {
      UpdateExecList();

      this.execGroupBox.Text = string.Format("Exec [{0}]", this.interpreter.ExecStack.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++) {
        if (skipNoopsCheckBox.Checked) {
          bool noop;

          do {
            noop = !interpreter.Step();
          }
          while (interpreter.CanStep && noop);
        } else 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.DataDescriptor.Examples[this.exampleComboBox.SelectedIndex];

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

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

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

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

      var random = Content.Random ?? new FastRandom();
      interpreter = new PushInterpreter(Content.Config, random);
      program = Content.IntegerVector.MapToPushProgram(Content.Config.EnabledExpressions);

      UpdateExamples(Content.DataDescriptor);

      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() {
      UpdateListCache(0, execList.VirtualListSize);
      execList.Update();

      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(IBenchmarkSuiteDataDescriptor data) {
      if (data == null) return;

      var stringRepresentations = data.Examples.Select(e =>
        string.Join(Separator, e.InputArgs) +
        exampleSplitter +
        string.Join(Separator, e.OutputArgs));

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