Changeset 12847 for branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem.Views/3.3/ExpertSystemOptimizerView.cs

Timestamp:

08/12/15 10:29:01 (9 years ago)

Author:

abeham

Message:

#2457: Added view

File:

• branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem.Views/3.3/ExpertSystemOptimizerView.cs (copied) (copied from branches/PerformanceComparison/HeuristicLab.Optimization.Views/3.3/IRRestarterView.cs) (12 diffs)

branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem.Views/3.3/ExpertSystemOptimizerView.cs

@@ -30 +30 @@
 using HeuristicLab.Core.Views;
 using HeuristicLab.MainForm;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Views;
 using HeuristicLab.PluginInfrastructure;
 
-namespace HeuristicLab.Optimization.Views {
-  [View("Independent Random Restarter View")]
-  [Content(typeof(IndepdentRandomRestarter), IsDefaultView = true)]
-  public partial class IndependentRandomRestarterView : IOptimizerView {
-    protected TypeSelectorDialog algorithmTypeSelectorDialog;
+namespace HeuristicLab.OptimizationExpertSystem.Views {
+  [View("Expert-system Optimizer View")]
+  [Content(typeof(ExpertSystemOptimizer), IsDefaultView = true)]
+  public partial class ExpertSystemOptimizerView : IOptimizerView {
+    protected TypeSelectorDialog problemTypeSelectorDialog;
     protected virtual bool SuppressEvents { get; set; }
 
-    public new IndepdentRandomRestarter Content {
-      get { return (IndepdentRandomRestarter)base.Content; }
+    public new ExpertSystemOptimizer Content {
+      get { return (ExpertSystemOptimizer)base.Content; }
       set { base.Content = value; }
     }
 
-    public IndependentRandomRestarterView() {
+    public ExpertSystemOptimizerView() {
       InitializeComponent();
-      terminationComboBox.Items.AddRange(Enum.GetValues(typeof(TerminationCriterium)).Cast<object>().ToArray());
     }
 
     protected override void Dispose(bool disposing) {
       if (disposing) {
-        if (algorithmTypeSelectorDialog != null) algorithmTypeSelectorDialog.Dispose();
+        if (problemTypeSelectorDialog != null) problemTypeSelectorDialog.Dispose();
         if (components != null) components.Dispose();
       }
@@ -59 +60 @@
     protected override void DeregisterContentEvents() {
       Content.PropertyChanged -= Content_PropertyChanged;
+      Content.SuggestedInstances.CollectionReset -= SuggestedInstancesOnChanged;
+      Content.SuggestedInstances.ItemsAdded -= SuggestedInstancesOnChanged;
+      Content.SuggestedInstances.ItemsMoved -= SuggestedInstancesOnChanged;
+      Content.SuggestedInstances.ItemsRemoved -= SuggestedInstancesOnChanged;
+      Content.SuggestedInstances.ItemsReplaced -= SuggestedInstancesOnChanged;
       base.DeregisterContentEvents();
     }
@@ -64 +70 @@
       base.RegisterContentEvents();
       Content.PropertyChanged += Content_PropertyChanged;
+      Content.SuggestedInstances.CollectionReset += SuggestedInstancesOnChanged;
+      Content.SuggestedInstances.ItemsAdded += SuggestedInstancesOnChanged;
+      Content.SuggestedInstances.ItemsMoved += SuggestedInstancesOnChanged;
+      Content.SuggestedInstances.ItemsRemoved += SuggestedInstancesOnChanged;
+      Content.SuggestedInstances.ItemsReplaced += SuggestedInstancesOnChanged;
     }
 
@@ -71 +82 @@
       try {
         if (Content == null) {
-          maxExecutionTimeTextBox.Text = String.Empty;
           maxEvaluationsTextBox.Text = String.Empty;
-          moveCostPerSolutionTextBox.Text = String.Empty;
-          targetValueTextBox.Text = String.Empty;
-          maximizationCheckBox.CheckState = CheckState.Indeterminate;
-          terminationComboBox.SelectedIndex = -1;
-          storeBestSolutionCheckBox.CheckState = CheckState.Indeterminate;
-
+
+          problemViewHost.Content = null;
           algorithmViewHost.Content = null;
-          currentRunView.Content = null;
           runsView.Content = null;
+          okbRunCollectionView.Content = null;
         } else {
-          maxExecutionTimeTextBox.Text = TimeSpanHelper.FormatNatural(Content.MaximumExecutionTime);
           maxEvaluationsTextBox.Text = Content.MaximumEvaluations.ToString();
-          moveCostPerSolutionTextBox.Text = Content.MoveCostPerSolution.ToString(CultureInfo.CurrentCulture.NumberFormat);
-          targetValueTextBox.Text = Content.TargetValue.ToString(CultureInfo.CurrentCulture.NumberFormat);
-          maximizationCheckBox.Checked = Content.Maximization;
-          terminationComboBox.SelectedItem = Content.TerminationCriterium;
-          storeBestSolutionCheckBox.Checked = Content.StoreSolutionInRun;
-
-          algorithmViewHost.Content = Content.Algorithm;
-          currentRunView.Content = Content.CurrentRun;
+          problemViewHost.Content = Content.Problem;
           runsView.Content = Content.Runs;
-        }
+          okbRunCollectionView.Content = Content.KnowledgeBase;
+        }
+        UpdateSuggestedInstancesCombobox();
       } finally { SuppressEvents = false; }
     }
@@ -100 +100 @@
     protected override void SetEnabledStateOfControls() {
       base.SetEnabledStateOfControls();
-      maxExecutionTimeTextBox.Enabled = Content != null && !ReadOnly && !Locked;
       maxEvaluationsTextBox.Enabled = Content != null && !ReadOnly && !Locked;
-      moveCostPerSolutionTextBox.Enabled = Content != null && !ReadOnly && !Locked;
-      targetValueTextBox.Enabled = Content != null && !ReadOnly && !Locked;
-      maximizationCheckBox.Enabled = Content != null && !ReadOnly && !Locked;
-      terminationComboBox.Enabled = Content != null && !ReadOnly && !Locked;
-      storeBestSolutionCheckBox.Enabled = Content != null && !ReadOnly && !Locked;
-      newAlgorithmButton.Enabled = Content != null && !ReadOnly;
-      openAlgorithmButton.Enabled = Content != null && !ReadOnly;
-      algorithmViewHost.Enabled = Content != null;
-      currentRunView.Enabled = Content != null;
+      newProblemButton.Enabled = Content != null && !ReadOnly && !Locked;
+      openProblemButton.Enabled = Content != null && !ReadOnly && !Locked;
+      problemViewHost.Enabled = Content != null && !ReadOnly && !Locked;
+      suggestedInstancesComboBox.Enabled = Content != null && !ReadOnly && !Locked;
+      algorithmViewHost.Enabled = Content != null && !ReadOnly && !Locked;
       runsView.Enabled = Content != null;
+      okbRunCollectionView.Enabled = Content != null;
     }
 
@@ -117 +113 @@
       if ((Content != null) && (Content.ExecutionState == ExecutionState.Started)) {
         //The content must be stopped if no other view showing the content is available
-        var optimizers = MainFormManager.MainForm.Views.OfType<IContentView>().Where(v => v != this).Select(v => v.Content).OfType<IAlgorithm>();
-        if (!optimizers.Contains(Content.Algorithm)) {
+        var optimizers = MainFormManager.MainForm.Views.OfType<IContentView>().Where(v => v != this).Select(v => v.Content).OfType<IOptimizer>();
+        if (!optimizers.Contains(Content)) {
           var nestedOptimizers = optimizers.SelectMany(opt => opt.NestedOptimizers);
           if (!nestedOptimizers.Contains(Content)) Content.Stop();
@@ -124 +120 @@
       }
       base.OnClosed(e);
+    }
+
+    private void UpdateSuggestedInstancesCombobox() {
+      SuspendRepaint();
+      try {
+        var prevSelection = (IAlgorithm)suggestedInstancesComboBox.SelectedItem;
+        var prevNewIndex = -1;
+        suggestedInstancesComboBox.Items.Clear();
+        if (Content == null) return;
+
+        for (var i = 0; i < Content.SuggestedInstances.Count; i++) {
+          suggestedInstancesComboBox.Items.Add(Content.SuggestedInstances[i]);
+          if (prevSelection == null || Content.SuggestedInstances[i].Name == prevSelection.Name)
+            prevNewIndex = prevSelection == null ? 0 : i;
+        }
+        if (prevNewIndex >= 0) {
+          suggestedInstancesComboBox.SelectedIndex = prevNewIndex;
+        }
+      } finally { ResumeRepaint(true); }
     }
 
@@ -136 +151 @@
       try {
         switch (e.PropertyName) {
-          case "TerminationCriterium": terminationComboBox.SelectedItem = Content.TerminationCriterium; break;
-          case "MaximumExecutionTime": maxExecutionTimeTextBox.Text = TimeSpanHelper.FormatNatural(Content.MaximumExecutionTime); break;
           case "MaximumEvaluations": maxEvaluationsTextBox.Text = Content.MaximumEvaluations.ToString(); break;
-          case "TargetValue": targetValueTextBox.Text = Content.TargetValue.ToString(CultureInfo.CurrentCulture.NumberFormat); break;
-          case "Maximization": maximizationCheckBox.Checked = Content.Maximization; break;
-          case "MoveCostPerSolution": moveCostPerSolutionTextBox.Text = Content.MoveCostPerSolution.ToString(CultureInfo.CurrentCulture.NumberFormat); break;
-          case "StoreSolutionInRun": storeBestSolutionCheckBox.Checked = Content.StoreSolutionInRun; break;
-          case "Algorithm": algorithmViewHost.Content = Content.Algorithm; break;
-          case "CurrentRun": currentRunView.Content = Content.CurrentRun; break;
           case "Runs": runsView.Content = Content.Runs; break;
+          case "KnowledgeBase": okbRunCollectionView.Content = Content.KnowledgeBase; break;
+          case "Problem": problemViewHost.Content = Content.Problem; break;
         }
       } finally { SuppressEvents = false; }
     }
+
+    private void SuggestedInstancesOnChanged(object sender, EventArgs e) {
+      SuppressEvents = true;
+      try {
+        UpdateSuggestedInstancesCombobox();
+      } finally { SuppressEvents = false; }
+    }
     #endregion
 
     #region Control events
-    private void maxExecutionTimeTextBox_Validating(object sender, CancelEventArgs e) {
-      if (SuppressEvents) return;
-      if (InvokeRequired) {
-        Invoke((Action<object, CancelEventArgs>)maxExecutionTimeTextBox_Validating, sender, e);
-        return;
-      }
-      TimeSpan ts;
-      if (!TimeSpanHelper.TryGetFromNaturalFormat(maxExecutionTimeTextBox.Text, out ts)) {
-        e.Cancel = !maxExecutionTimeTextBox.ReadOnly && maxExecutionTimeTextBox.Enabled;
-        errorProvider.SetError(maxExecutionTimeTextBox, "Please enter a valid time span, e.g. 20 seconds ; 45s ; 4min ; 1h ; 3 hours ; 2 days ; 4d");
-      } else {
-        Content.MaximumExecutionTime = ts;
-        e.Cancel = false;
-        errorProvider.SetError(maxExecutionTimeTextBox, null);
-      }
-    }
-
     private void maxEvaluationsTextBox_Validating(object sender, CancelEventArgs e) {
       if (SuppressEvents) return;
@@ -186 +185 @@
     }
 
-    private void moveCostPerSolutionTextBox_Validating(object sender, CancelEventArgs e) {
-      if (SuppressEvents) return;
-      if (InvokeRequired) {
-        Invoke((Action<object, CancelEventArgs>)moveCostPerSolutionTextBox_Validating, sender, e);
-        return;
-      }
-      double value;
-      if (!double.TryParse(moveCostPerSolutionTextBox.Text, out value)) {
-        e.Cancel = !moveCostPerSolutionTextBox.ReadOnly && moveCostPerSolutionTextBox.Enabled;
-        errorProvider.SetError(moveCostPerSolutionTextBox, "Please enter a valid integer number.");
-      } else {
-        Content.MoveCostPerSolution = value;
-        e.Cancel = false;
-        errorProvider.SetError(moveCostPerSolutionTextBox, null);
-      }
-    }
-
-    private void targetValueTextBox_Validating(object sender, CancelEventArgs e) {
-      if (SuppressEvents) return;
-      if (InvokeRequired) {
-        Invoke((Action<object, CancelEventArgs>)targetValueTextBox_Validating, sender, e);
-        return;
-      }
-      double value;
-      if (!double.TryParse(targetValueTextBox.Text, out value)) {
-        e.Cancel = !targetValueTextBox.ReadOnly && targetValueTextBox.Enabled;
-        errorProvider.SetError(targetValueTextBox, "Please enter a valid integer number.");
-      } else {
-        Content.TargetValue = value;
-        e.Cancel = false;
-        errorProvider.SetError(targetValueTextBox, null);
-      }
-    }
-
-    private void maximizationCheckBox_CheckedChanged(object sender, EventArgs e) {
-      if (SuppressEvents) return;
-      if (InvokeRequired) {
-        Invoke((Action<object, EventArgs>)maximizationCheckBox_CheckedChanged, sender, e);
-        return;
-      }
-      Content.Maximization = maximizationCheckBox.Checked;
-    }
-
-    private void terminationComboBox_SelectedIndexChanged(object sender, EventArgs e) {
-      if (SuppressEvents) return;
-      if (InvokeRequired) {
-        Invoke((Action<object, EventArgs>)terminationComboBox_SelectedIndexChanged, sender, e);
-        return;
-      }
-      Content.TerminationCriterium = (TerminationCriterium)terminationComboBox.SelectedItem;
-    }
-
-    private void storeBestSolutionCheckBox_CheckedChanged(object sender, EventArgs e) {
-      if (SuppressEvents) return;
-      if (InvokeRequired) {
-        Invoke((Action<object, EventArgs>)storeBestSolutionCheckBox_CheckedChanged, sender, e);
-        return;
-      }
-      Content.StoreSolutionInRun = storeBestSolutionCheckBox.Checked;
-    }
-
-    private void newAlgorithmButton_Click(object sender, EventArgs e) {
-      if (algorithmTypeSelectorDialog == null) {
-        algorithmTypeSelectorDialog = new TypeSelectorDialog { Caption = "Select Algorithm" };
-        algorithmTypeSelectorDialog.TypeSelector.Caption = "Available Algorithms";
-        algorithmTypeSelectorDialog.TypeSelector.Configure(typeof(IAlgorithm)
+    private void newProblemButton_Click(object sender, EventArgs e) {
+      if (problemTypeSelectorDialog == null) {
+        problemTypeSelectorDialog = new TypeSelectorDialog { Caption = "Select Problem" };
+        problemTypeSelectorDialog.TypeSelector.Caption = "Available Problems";
+        problemTypeSelectorDialog.TypeSelector.Configure(typeof(IProblem)
           , showNotInstantiableTypes: false, showGenericTypes: false);
       }
-      if (algorithmTypeSelectorDialog.ShowDialog(this) == DialogResult.OK) {
+      if (problemTypeSelectorDialog.ShowDialog(this) == DialogResult.OK) {
         try {
-          Content.Algorithm = (IAlgorithm)algorithmTypeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
+          Content.Problem = (IProblem)problemTypeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
         } catch (Exception ex) {
           ErrorHandling.ShowErrorDialog(this, ex);
@@ -263 +201 @@
     }
 
-    private void openAlgorithmButton_Click(object sender, EventArgs e) {
-      openFileDialog.Title = "Open Algorithm";
+    private void openProblemButton_Click(object sender, EventArgs e) {
+      openFileDialog.Title = "Open Problem";
       if (openFileDialog.ShowDialog(this) == DialogResult.OK) {
-        newAlgorithmButton.Enabled = openAlgorithmButton.Enabled = false;
-        algorithmViewHost.Enabled = false;
+        newProblemButton.Enabled = openProblemButton.Enabled = false;
+        problemViewHost.Enabled = false;
 
         ContentManager.LoadAsync(openFileDialog.FileName, delegate(IStorableContent content, Exception error) {
           try {
             if (error != null) throw error;
-            var algorithm = content as IAlgorithm;
-            if (algorithm == null)
-              MessageBox.Show(this, "The selected file does not contain an algorithm.", "Invalid File", MessageBoxButtons.OK, MessageBoxIcon.Error);
-            else
-              Content.Algorithm = algorithm;
+            var problem = content as IProblem;
+            if (problem == null) {
+              var algorithm = content as IAlgorithm;
+              if (algorithm == null || algorithm.Problem == null)
+                MessageBox.Show(this, "The selected file is not a problem, nor an algorithm with a problem.", "Invalid File", MessageBoxButtons.OK, MessageBoxIcon.Error);
+              else Content.Problem = algorithm.Problem;
+            } else
+              Content.Problem = problem;
           } catch (Exception ex) {
             ErrorHandling.ShowErrorDialog(this, ex);
           } finally {
             Invoke(new Action(delegate() {
-              algorithmViewHost.Enabled = true;
-              newAlgorithmButton.Enabled = openAlgorithmButton.Enabled = true;
+              problemViewHost.Enabled = true;
+              newProblemButton.Enabled = openProblemButton.Enabled = true;
             }));
           }
@@ -289 +230 @@
     }
 
-    private void algorithmTabPage_DragEnterOver(object sender, DragEventArgs e) {
+    private void problemTabPage_DragEnterOver(object sender, DragEventArgs e) {
       e.Effect = DragDropEffects.None;
-      var alg = e.Data.GetData(Constants.DragDropDataFormat) as IAlgorithm;
-      if (!ReadOnly && alg != null) {
-        if (!typeof(ISingleObjectiveHeuristicOptimizationProblem).IsAssignableFrom(alg.ProblemType))
-          return;
+      var prob = e.Data.GetData(Constants.DragDropDataFormat) as IProblem;
+      if (!ReadOnly && prob != null) {
         if ((e.KeyState & 32) == 32) e.Effect = DragDropEffects.Link;  // ALT key
         else if ((e.KeyState & 4) == 4) e.Effect = DragDropEffects.Move;  // SHIFT key
@@ -303 +242 @@
     }
 
-    private void algorithmTabPage_DragDrop(object sender, DragEventArgs e) {
+    private void problemTabPage_DragDrop(object sender, DragEventArgs e) {
       if (e.Effect != DragDropEffects.None) {
-        var algorithm = e.Data.GetData(Constants.DragDropDataFormat) as IAlgorithm;
-        if (e.Effect.HasFlag(DragDropEffects.Copy)) algorithm = (IAlgorithm)algorithm.Clone();
-        Content.Algorithm = algorithm;
-      }
+        var prob = e.Data.GetData(Constants.DragDropDataFormat) as IProblem;
+        if (e.Effect.HasFlag(DragDropEffects.Copy)) prob = (IProblem)prob.Clone();
+        Content.Problem = prob;
+      }
+    }
+
+    private void suggestedInstancesComboBox_SelectedIndexChanged(object sender, EventArgs e) {
+      if (SuppressEvents) return;
+      if (InvokeRequired) { Invoke((Action<object, EventArgs>)suggestedInstancesComboBox_SelectedIndexChanged, sender, e); return; }
+      if (suggestedInstancesComboBox.SelectedIndex >= 0)
+        algorithmViewHost.Content = (IAlgorithm)suggestedInstancesComboBox.SelectedItem;
+      else algorithmViewHost.Content = null;
     }
     #endregion