Index: /trunk/sources/HeuristicLab.Optimization.Views/3.3/ExperimentTreeView.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization.Views/3.3/ExperimentTreeView.Designer.cs	(revision 6523)
+++ /trunk/sources/HeuristicLab.Optimization.Views/3.3/ExperimentTreeView.Designer.cs	(revision 6524)
@@ -42,5 +42,5 @@
       this.moveDownButton = new System.Windows.Forms.Button();
       this.addButton = new System.Windows.Forms.Button();
-      this.optimizerTreeView = new HeuristicLab.Optimization.Views.ExperimentTreeView.CustomTreeView();
+      this.treeView = new HeuristicLab.Optimization.Views.ExperimentTreeView.CustomTreeView();
       this.imageList = new System.Windows.Forms.ImageList(this.components);
       this.detailsGroupBox = new System.Windows.Forms.GroupBox();
@@ -83,5 +83,5 @@
       this.splitContainer.Panel1.Controls.Add(this.moveDownButton);
       this.splitContainer.Panel1.Controls.Add(this.addButton);
-      this.splitContainer.Panel1.Controls.Add(this.optimizerTreeView);
+      this.splitContainer.Panel1.Controls.Add(this.treeView);
       // 
       // splitContainer.Panel2
@@ -155,25 +155,25 @@
       // optimizerTreeView
       // 
-      this.optimizerTreeView.AllowDrop = true;
-      this.optimizerTreeView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+      this.treeView.AllowDrop = true;
+      this.treeView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
             | System.Windows.Forms.AnchorStyles.Left)
             | System.Windows.Forms.AnchorStyles.Right)));
-      this.optimizerTreeView.HideSelection = false;
-      this.optimizerTreeView.ImageIndex = 0;
-      this.optimizerTreeView.ImageList = this.imageList;
-      this.optimizerTreeView.Location = new System.Drawing.Point(4, 34);
-      this.optimizerTreeView.Name = "optimizerTreeView";
-      this.optimizerTreeView.SelectedImageIndex = 0;
-      this.optimizerTreeView.Size = new System.Drawing.Size(191, 402);
-      this.optimizerTreeView.TabIndex = 10;
-      this.optimizerTreeView.ItemDrag += new System.Windows.Forms.ItemDragEventHandler(this.optimizerTreeView_ItemDrag);
-      this.optimizerTreeView.NodeMouseClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.optimizerTreeview_NodeMouseClick);
-      this.optimizerTreeView.NodeMouseDoubleClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.optimizerTreeView_NodeMouseDoubleClick);
-      this.optimizerTreeView.DragDrop += new System.Windows.Forms.DragEventHandler(this.optimizerTreeView_DragDrop);
-      this.optimizerTreeView.DragEnter += new System.Windows.Forms.DragEventHandler(this.optimizerTreeView_DragEnter);
-      this.optimizerTreeView.DragOver += new System.Windows.Forms.DragEventHandler(this.optimizerTreeView_DragOver);
-      this.optimizerTreeView.KeyDown += new System.Windows.Forms.KeyEventHandler(this.optimizerTreeView_KeyDown);
-      this.optimizerTreeView.MouseDown += new System.Windows.Forms.MouseEventHandler(this.optimizerTreeView_MouseDown);
-      this.optimizerTreeView.RightClick += new System.EventHandler(optimizerTreeView_RightClick);
+      this.treeView.HideSelection = false;
+      this.treeView.ImageIndex = 0;
+      this.treeView.ImageList = this.imageList;
+      this.treeView.Location = new System.Drawing.Point(4, 34);
+      this.treeView.Name = "optimizerTreeView";
+      this.treeView.SelectedImageIndex = 0;
+      this.treeView.Size = new System.Drawing.Size(191, 402);
+      this.treeView.TabIndex = 10;
+      this.treeView.ItemDrag += new System.Windows.Forms.ItemDragEventHandler(this.optimizerTreeView_ItemDrag);
+      this.treeView.NodeMouseClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.optimizerTreeview_NodeMouseClick);
+      this.treeView.NodeMouseDoubleClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.optimizerTreeView_NodeMouseDoubleClick);
+      this.treeView.DragDrop += new System.Windows.Forms.DragEventHandler(this.optimizerTreeView_DragDrop);
+      this.treeView.DragEnter += new System.Windows.Forms.DragEventHandler(this.optimizerTreeView_DragEnter);
+      this.treeView.DragOver += new System.Windows.Forms.DragEventHandler(this.optimizerTreeView_DragOver);
+      this.treeView.KeyDown += new System.Windows.Forms.KeyEventHandler(this.optimizerTreeView_KeyDown);
+      this.treeView.MouseDown += new System.Windows.Forms.MouseEventHandler(this.optimizerTreeView_MouseDown);
+      this.treeView.RightClick += new System.EventHandler(optimizerTreeView_RightClick);
       // 
       // imageList
@@ -255,5 +255,5 @@
     private System.Windows.Forms.GroupBox optimizersGroupBox;
     private System.Windows.Forms.SplitContainer splitContainer;
-    private HeuristicLab.Optimization.Views.ExperimentTreeView.CustomTreeView optimizerTreeView;
+    private HeuristicLab.Optimization.Views.ExperimentTreeView.CustomTreeView treeView;
     private System.Windows.Forms.GroupBox detailsGroupBox;
     private MainForm.WindowsForms.ViewHost detailsViewHost;
Index: /trunk/sources/HeuristicLab.Optimization.Views/3.3/ExperimentTreeView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization.Views/3.3/ExperimentTreeView.cs	(revision 6523)
+++ /trunk/sources/HeuristicLab.Optimization.Views/3.3/ExperimentTreeView.cs	(revision 6524)
@@ -28,4 +28,5 @@
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
+using HeuristicLab.Core;
 using HeuristicLab.Core.Views;
 using HeuristicLab.MainForm;
@@ -35,9 +36,9 @@
   public sealed partial class ExperimentTreeView : ItemView {
     private TypeSelectorDialog typeSelectorDialog;
-    private Dictionary<IOptimizer, List<TreeNode>> optimizerTreeViewMapping;
+    private Dictionary<INamedItem, List<TreeNode>> treeNodeTagMapping;
 
     public ExperimentTreeView() {
       InitializeComponent();
-      optimizerTreeViewMapping = new Dictionary<IOptimizer, List<TreeNode>>();
+      treeNodeTagMapping = new Dictionary<INamedItem, List<TreeNode>>();
     }
 
@@ -91,19 +92,22 @@
       Content.Optimizers.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsReplaced);
       Content.Optimizers.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_CollectionReset);
-      foreach (var optimizer in optimizerTreeViewMapping.Keys)
-        DeregisterOptimizerEvents(optimizer);
+      foreach (var optimizer in treeNodeTagMapping.Keys)
+        DeregisterNamedItemEvents(optimizer);
       base.DeregisterContentEvents();
     }
 
-    private void RegisterOptimizerEvents(IOptimizer optimizer) {
-      optimizer.ToStringChanged += new EventHandler(optimizer_ToStringChanged);
-      optimizer.ExecutionStateChanged += new EventHandler(optimizer_ExecutionStateChanged);
-
-      var batchRun = optimizer as BatchRun;
-      var experiment = optimizer as Experiment;
-      if (batchRun != null) {
+    private void RegisterNamedItemEvents(INamedItem namedItem) {
+      namedItem.ToStringChanged += new EventHandler(namedItem_ToStringChanged);
+      namedItem.ItemImageChanged += new EventHandler(namedItem_ItemImageChanged);
+
+      var algorithm = namedItem as IAlgorithm;
+      var batchRun = namedItem as BatchRun;
+      var experiment = namedItem as Experiment;
+
+      if (algorithm != null) {
+        algorithm.ProblemChanged += new EventHandler(algorithm_ProblemChanged);
+      } else if (batchRun != null) {
         batchRun.OptimizerChanged += new EventHandler(batchRun_OptimizerChanged);
-      }
-      if (experiment != null) {
+      } else if (experiment != null) {
         experiment.Optimizers.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsAdded);
         experiment.Optimizers.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsMoved);
@@ -114,14 +118,18 @@
     }
 
-    private void DeregisterOptimizerEvents(IOptimizer optimizer) {
-      optimizer.ToStringChanged -= new EventHandler(optimizer_ToStringChanged);
-      optimizer.ExecutionStateChanged -= new EventHandler(optimizer_ExecutionStateChanged);
-
-      var batchRun = optimizer as BatchRun;
-      var experiment = optimizer as Experiment;
-      if (batchRun != null) {
+
+
+    private void DeregisterNamedItemEvents(INamedItem namedItem) {
+      namedItem.ToStringChanged -= new EventHandler(namedItem_ToStringChanged);
+      namedItem.ItemImageChanged -= new EventHandler(namedItem_ItemImageChanged);
+
+      var algorithm = namedItem as IAlgorithm;
+      var batchRun = namedItem as BatchRun;
+      var experiment = namedItem as Experiment;
+      if (algorithm != null) {
+        algorithm.ProblemChanged -= new EventHandler(algorithm_ProblemChanged);
+      } else if (batchRun != null) {
         batchRun.OptimizerChanged -= new EventHandler(batchRun_OptimizerChanged);
-      }
-      if (experiment != null) {
+      } else if (experiment != null) {
         experiment.Optimizers.ItemsAdded -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsAdded);
         experiment.Optimizers.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<IOptimizer>>(Optimizers_ItemsMoved);
@@ -136,8 +144,8 @@
       base.OnContentChanged();
       if (Content == null) {
-        optimizerTreeView.Nodes.Clear();
+        treeView.Nodes.Clear();
       } else {
         UpdateOptimizerTreeView();
-        optimizerTreeView.ExpandAll();
+        treeView.ExpandAll();
       }
     }
@@ -149,32 +157,42 @@
         return;
       }
-      RebuildImageList();
       SetEnabledStateOfControls();
     }
 
-    private void optimizer_ExecutionStateChanged(object sender, EventArgs e) {
-      if (InvokeRequired) {
-        Invoke((Action<object, EventArgs>)optimizer_ExecutionStateChanged, sender, e);
-        return;
-      }
-      RebuildImageList();
-    }
-
-    private void batchRun_OptimizerChanged(object sender, EventArgs e) {
-      if (InvokeRequired) {
-        Invoke((Action<object, EventArgs>)batchRun_OptimizerChanged, sender, e);
-        return;
-      }
-      var batchRun = (BatchRun)sender;
-      foreach (TreeNode node in optimizerTreeViewMapping[batchRun]) {
-        foreach (TreeNode childNode in node.Nodes) {
+    private void algorithm_ProblemChanged(object sender, EventArgs e) {
+      if (InvokeRequired) {
+        Invoke((Action<object, EventArgs>)algorithm_ProblemChanged, sender, e);
+        return;
+      }
+
+      var algorithm = (IAlgorithm)sender;
+      foreach (TreeNode node in treeNodeTagMapping[algorithm]) {
+        foreach (TreeNode childNode in node.Nodes.OfType<TreeNode>().ToList()) {
           DisposeTreeNode(childNode);
           childNode.Remove();
         }
+        foreach (TreeNode childNode in CreateAlgorithmChildNodes(algorithm))
+          node.Nodes.Add(childNode);
+        node.Expand();
+      }
+
+      RebuildImageList();
+      UpdateDetailsViewHost();
+    }
+
+    private void batchRun_OptimizerChanged(object sender, EventArgs e) {
+      if (InvokeRequired) {
+        Invoke((Action<object, EventArgs>)batchRun_OptimizerChanged, sender, e);
+        return;
+      }
+      var batchRun = (BatchRun)sender;
+      foreach (TreeNode node in treeNodeTagMapping[batchRun]) {
+        foreach (TreeNode childNode in node.Nodes.OfType<TreeNode>().ToList()) {
+          DisposeTreeNode(childNode);
+          childNode.Remove();
+        }
 
         if (batchRun.Optimizer != null) {
-          TreeNode childNode = CreateTreeNode(batchRun.Optimizer);
-          UpdateChildTreeNodes(childNode.Nodes, batchRun.Optimizer);
-          node.Nodes.Add(childNode);
+          UpdateChildTreeNodes(node.Nodes, batchRun);
           node.Expand();
         }
@@ -192,8 +210,8 @@
       var optimizerList = (OptimizerList)sender;
       IEnumerable<TreeNodeCollection> parentNodes;
-      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { optimizerTreeView.Nodes };
+      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
       else {
-        Experiment experiment = optimizerTreeViewMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
-        parentNodes = optimizerTreeViewMapping[experiment].Select(node => node.Nodes);
+        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
+        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
       }
 
@@ -217,8 +235,8 @@
       var optimizerList = (OptimizerList)sender;
       IEnumerable<TreeNodeCollection> parentNodes;
-      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { optimizerTreeView.Nodes };
+      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
       else {
-        Experiment experiment = optimizerTreeViewMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
-        parentNodes = optimizerTreeViewMapping[experiment].Select(node => node.Nodes);
+        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
+        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
       }
 
@@ -249,8 +267,8 @@
       var optimizerList = (OptimizerList)sender;
       IEnumerable<TreeNodeCollection> parentNodes;
-      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { optimizerTreeView.Nodes };
+      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
       else {
-        Experiment experiment = optimizerTreeViewMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
-        parentNodes = optimizerTreeViewMapping[experiment].Select(node => node.Nodes);
+        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
+        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
       }
 
@@ -273,8 +291,8 @@
       var optimizerList = (OptimizerList)sender;
       IEnumerable<TreeNodeCollection> parentNodes;
-      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { optimizerTreeView.Nodes };
+      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
       else {
-        Experiment experiment = optimizerTreeViewMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
-        parentNodes = optimizerTreeViewMapping[experiment].Select(node => node.Nodes);
+        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
+        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
       }
 
@@ -302,8 +320,8 @@
       var optimizerList = (OptimizerList)sender;
       IEnumerable<TreeNodeCollection> parentNodes;
-      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { optimizerTreeView.Nodes };
+      if (optimizerList == Content.Optimizers) parentNodes = new List<TreeNodeCollection>() { treeView.Nodes };
       else {
-        Experiment experiment = optimizerTreeViewMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
-        parentNodes = optimizerTreeViewMapping[experiment].Select(node => node.Nodes);
+        Experiment experiment = treeNodeTagMapping.Keys.OfType<Experiment>().Where(exp => exp.Optimizers == optimizerList).First();
+        parentNodes = treeNodeTagMapping[experiment].Select(node => node.Nodes);
       }
 
@@ -324,52 +342,81 @@
     }
 
-    private void optimizer_ToStringChanged(object sender, EventArgs e) {
-      if (InvokeRequired) {
-        Invoke((Action<object, EventArgs>)optimizer_ToStringChanged, sender, e);
-        return;
-      }
-      var optimizer = (IOptimizer)sender;
-      foreach (TreeNode node in optimizerTreeViewMapping[optimizer])
-        node.Text = optimizer.ToString();
+    private void namedItem_ToStringChanged(object sender, EventArgs e) {
+      if (InvokeRequired) {
+        Invoke((Action<object, EventArgs>)namedItem_ToStringChanged, sender, e);
+        return;
+      }
+      var namedItem = (INamedItem)sender;
+      foreach (TreeNode node in treeNodeTagMapping[namedItem])
+        node.Text = namedItem.ToString();
+    }
+
+    private void namedItem_ItemImageChanged(object sender, EventArgs e) {
+      if (InvokeRequired) {
+        Invoke((Action<object, EventArgs>)namedItem_ItemImageChanged, sender, e);
+        return;
+      }
+      INamedItem namedItem = (INamedItem)sender;
+      foreach (TreeNode node in treeNodeTagMapping[namedItem]) {
+        treeView.ImageList.Images[node.ImageIndex] = namedItem.ItemImage;
+        node.ImageIndex = node.ImageIndex;
+      }
+      SetEnabledStateOfControls();
     }
     #endregion
+
+    protected override void PropagateStateChanges(Control control, Type type, System.Reflection.PropertyInfo propertyInfo) {
+      return;
+    }
 
     protected override void SetEnabledStateOfControls() {
       base.SetEnabledStateOfControls();
+      IOptimizer optimizer = null;
+      IAlgorithm algorithm = null;
       BatchRun batchRun = null;
-      BatchRun parentBatchRun = null;
       Experiment experiment = null;
-      if (optimizerTreeView.SelectedNode != null) {
-        batchRun = optimizerTreeView.SelectedNode.Tag as BatchRun;
-        experiment = optimizerTreeView.SelectedNode.Tag as Experiment;
-        if (optimizerTreeView.SelectedNode.Parent != null)
-          parentBatchRun = optimizerTreeView.SelectedNode.Parent.Tag as BatchRun;
-      }
-
-      optimizerTreeView.Enabled = Content != null;
-      detailsViewHost.Enabled = Content != null && optimizerTreeView.SelectedNode != null;
+
+      IOptimizer parentOptimizer = null;
+      Experiment parentExperiment = null;
+
+      if (treeView.SelectedNode != null) {
+        optimizer = treeView.SelectedNode.Tag as IOptimizer;
+        algorithm = optimizer as IAlgorithm;
+        batchRun = optimizer as BatchRun;
+        experiment = optimizer as Experiment;
+
+        if (treeView.SelectedNode.Parent != null) parentOptimizer = treeView.SelectedNode.Parent.Tag as IOptimizer;
+        else parentOptimizer = Content;
+
+        parentExperiment = parentOptimizer as Experiment;
+      }
+
+      treeView.Enabled = Content != null;
+      if (parentOptimizer != null) {
+        detailsViewHost.ReadOnly = parentOptimizer.ExecutionState == ExecutionState.Started;
+        detailsViewHost.Locked = parentOptimizer.ExecutionState == ExecutionState.Started;
+      }
 
       addButton.Enabled = Content != null && !Locked && !ReadOnly &&
-        (optimizerTreeView.SelectedNode == null || experiment != null || (batchRun != null && batchRun.Optimizer == null));
+        (treeView.SelectedNode == null || experiment != null || (batchRun != null && batchRun.Optimizer == null) || (algorithm != null && algorithm.Problem == null));
       moveUpButton.Enabled = Content != null && !Locked && !ReadOnly &&
-        optimizerTreeView.SelectedNode != null && optimizerTreeView.SelectedNode.PrevNode != null && parentBatchRun == null;
+        treeView.SelectedNode != null && treeView.SelectedNode.PrevNode != null && parentExperiment != null;
       moveDownButton.Enabled = Content != null && !Locked && !ReadOnly &&
-        optimizerTreeView.SelectedNode != null && optimizerTreeView.SelectedNode.NextNode != null && parentBatchRun == null;
-      removeButton.Enabled = Content != null && !Locked && !ReadOnly &&
-        optimizerTreeView.SelectedNode != null;
+        treeView.SelectedNode != null && treeView.SelectedNode.NextNode != null && parentExperiment != null;
+      removeButton.Enabled = Content != null && !Locked && !ReadOnly && optimizer != null;
     }
 
     private void UpdateOptimizerTreeView() {
-      optimizerTreeView.Nodes.Clear();
-      UpdateChildTreeNodes(optimizerTreeView.Nodes, Content);
-      RebuildImageList();
-    }
-
+      treeView.Nodes.Clear();
+      UpdateChildTreeNodes(treeView.Nodes, Content);
+      RebuildImageList();
+    }
 
     private void UpdateChildTreeNodes(TreeNodeCollection collection, IOptimizer optimizer) {
       var batchRun = optimizer as BatchRun;
       var experiment = optimizer as Experiment;
-      if (experiment != null) UpdateChildTreeNodes(collection, experiment.Optimizers);
-      else if (batchRun != null && batchRun.Optimizer != null) UpdateChildTreeNodes(collection, new List<IOptimizer>() { batchRun.Optimizer });
+
+      if (batchRun != null && batchRun.Optimizer != null) UpdateChildTreeNodes(collection, new List<IOptimizer>() { batchRun.Optimizer });
+      else if (experiment != null) UpdateChildTreeNodes(collection, experiment.Optimizers);
     }
     private void UpdateChildTreeNodes(TreeNodeCollection collection, IEnumerable<IOptimizer> optimizers) {
@@ -387,14 +434,15 @@
 
       TreeNode selectedNode = (TreeNode)e.Item;
-      var optimizer = (IOptimizer)selectedNode.Tag;
+      var item = (IItem)selectedNode.Tag;
       DataObject data = new DataObject();
-      data.SetData(HeuristicLab.Common.Constants.DragDropDataFormat, optimizer);
+      data.SetData(HeuristicLab.Common.Constants.DragDropDataFormat, item);
       validDragOperation = true;
 
-      if (ReadOnly) {
+      if (ReadOnly || !(item is IOptimizer)) {
         DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Link);
       } else {
         DragDropEffects result = DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Link | DragDropEffects.Move);
         if ((result & DragDropEffects.Move) == DragDropEffects.Move) {
+          var optimizer = (IOptimizer)item;
           if (selectedNode.Parent == null) Content.Optimizers.Remove(optimizer);
           else {
@@ -429,6 +477,6 @@
       e.Effect = DragDropEffects.None;
       if (validDragOperation) {
-        Point coordinates = optimizerTreeView.PointToClient(new Point(e.X, e.Y));
-        TreeNode node = optimizerTreeView.GetNodeAt(coordinates);
+        Point coordinates = treeView.PointToClient(new Point(e.X, e.Y));
+        TreeNode node = treeView.GetNodeAt(coordinates);
         Experiment experiment = null;
         BatchRun batchRun = null;
@@ -467,6 +515,6 @@
     }
     private void optimizerTreeView_DragDrop(object sender, DragEventArgs e) {
-      Point coordinates = optimizerTreeView.PointToClient(new Point(e.X, e.Y));
-      TreeNode node = optimizerTreeView.GetNodeAt(coordinates);
+      Point coordinates = treeView.PointToClient(new Point(e.X, e.Y));
+      TreeNode node = treeView.GetNodeAt(coordinates);
       Experiment experiment = null;
       BatchRun batchRun = null;
@@ -501,11 +549,11 @@
       if (e.X < e.Node.Bounds.Left || e.X > e.Node.Bounds.Right) return;
       e.Node.Toggle();
-      IOptimizer optimizer = (IOptimizer)e.Node.Tag;
+      IContent optimizer = (IContent)e.Node.Tag;
       MainFormManager.MainForm.ShowContent(optimizer);
     }
     private void optimizerTreeview_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) {
       if (e.X < e.Node.Bounds.Left || e.X > e.Node.Bounds.Right) return;
-      optimizerTreeView.SelectedNode = e.Node;
-      detailsViewHost.Content = (IOptimizer)e.Node.Tag;
+      treeView.SelectedNode = e.Node;
+      detailsViewHost.Content = (IContent)e.Node.Tag;
       SetEnabledStateOfControls();
     }
@@ -513,9 +561,9 @@
       // enables deselection of treeNodes
       if (e.Button != MouseButtons.Right) rightClickOccured = false;
-      if (optimizerTreeView.SelectedNode == null) return;
+      if (treeView.SelectedNode == null) return;
       Point coordinates = new Point(e.X, e.Y);
-      TreeNode node = optimizerTreeView.GetNodeAt(coordinates);
+      TreeNode node = treeView.GetNodeAt(coordinates);
       if (node == null || coordinates.X < node.Bounds.Left || coordinates.X > node.Bounds.Right) {
-        optimizerTreeView.SelectedNode = null;
+        treeView.SelectedNode = null;
         detailsViewHost.Content = null;
         SetEnabledStateOfControls();
@@ -526,8 +574,9 @@
     private void optimizerTreeView_KeyDown(object sender, KeyEventArgs e) {
       if (ReadOnly) return;
-      if (optimizerTreeView.SelectedNode == null) return;
       if (e.KeyCode != Keys.Delete) return;
-
-      var treeNode = optimizerTreeView.SelectedNode;
+      if (treeView.SelectedNode == null) return;
+      if (!(treeView.SelectedNode.Tag is IOptimizer)) return;
+
+      var treeNode = treeView.SelectedNode;
       var optimizer = (IOptimizer)treeNode.Tag;
 
@@ -539,5 +588,5 @@
         if (batchRun != null) batchRun.Optimizer = null;
         else if (experiment != null) experiment.Optimizers.Remove(optimizer);
-        else throw new NotSupportedException("Handling for specific type not implemented" + optimizerTreeView.SelectedNode.Tag.GetType());
+        else throw new NotSupportedException("Handling for specific type not implemented" + treeView.SelectedNode.Tag.GetType());
       }
       SetEnabledStateOfControls();
@@ -550,9 +599,9 @@
     private void optimizerTreeView_RightClick(object sender, EventArgs e) {
       rightClickOccured = true;
-      Point coordinates = optimizerTreeView.PointToClient(Cursor.Position);
-      toolStripMenuNode = optimizerTreeView.GetNodeAt(coordinates);
+      Point coordinates = treeView.PointToClient(Cursor.Position);
+      toolStripMenuNode = treeView.GetNodeAt(coordinates);
 
       if (toolStripMenuNode != null && coordinates.X >= toolStripMenuNode.Bounds.Left && coordinates.X <= toolStripMenuNode.Bounds.Right) {
-        optimizerTreeView.SelectedNode = toolStripMenuNode;
+        treeView.SelectedNode = toolStripMenuNode;
         detailsViewHost.Content = (IContent)toolStripMenuNode.Tag;
         SetEnabledStateOfControls();
@@ -575,21 +624,35 @@
 
     private void addButton_Click(object sender, System.EventArgs e) {
-      if (typeSelectorDialog == null) {
-        typeSelectorDialog = new TypeSelectorDialog();
+      if (typeSelectorDialog == null) typeSelectorDialog = new TypeSelectorDialog();
+
+      IAlgorithm algorithm = null;
+      if (treeView.SelectedNode != null && (treeView.SelectedNode.Tag is IAlgorithm))
+        algorithm = (IAlgorithm)treeView.SelectedNode.Tag;
+
+      if (algorithm == null) {
         typeSelectorDialog.Caption = "Select Optimizer";
         typeSelectorDialog.TypeSelector.Caption = "Available Optimizers";
         typeSelectorDialog.TypeSelector.Configure(typeof(IOptimizer), false, true);
+      } else {
+        typeSelectorDialog.Caption = "Select Problem";
+        typeSelectorDialog.TypeSelector.Caption = "Available Problems";
+        typeSelectorDialog.TypeSelector.Configure(algorithm.ProblemType, false, true);
       }
 
       if (typeSelectorDialog.ShowDialog(this) == DialogResult.OK) {
         try {
-          IOptimizer optimizer = (IOptimizer)typeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
-          if (optimizerTreeView.SelectedNode == null) Content.Optimizers.Add(optimizer);
-          else {
-            var batchRun = optimizerTreeView.SelectedNode.Tag as BatchRun;
-            var experiment = optimizerTreeView.SelectedNode.Tag as Experiment;
-            if (batchRun != null) batchRun.Optimizer = optimizer;
-            else if (experiment != null) experiment.Optimizers.Add(optimizer);
-            else throw new NotSupportedException("Handling for specific type not implemented" + optimizerTreeView.SelectedNode.Tag.GetType());
+          if (algorithm == null) {
+            IOptimizer optimizer = (IOptimizer)typeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
+            if (treeView.SelectedNode == null) Content.Optimizers.Add(optimizer);
+            else {
+              var batchRun = treeView.SelectedNode.Tag as BatchRun;
+              var experiment = treeView.SelectedNode.Tag as Experiment;
+              if (batchRun != null) batchRun.Optimizer = optimizer;
+              else if (experiment != null) experiment.Optimizers.Add(optimizer);
+              else throw new NotSupportedException("Handling for specific type not implemented" + treeView.SelectedNode.Tag.GetType());
+            }
+          } else {
+            IProblem problem = (IProblem)typeSelectorDialog.TypeSelector.CreateInstanceOfSelectedType();
+            algorithm.Problem = problem;
           }
         }
@@ -601,12 +664,12 @@
 
     private void moveUpButton_Click(object sender, EventArgs e) {
-      var optimizer = optimizerTreeView.SelectedNode.Tag as IOptimizer;
+      var optimizer = (IOptimizer)treeView.SelectedNode.Tag;
       Experiment experiment = null;
-      if (optimizerTreeView.SelectedNode.Parent == null) experiment = Content;
-      else experiment = (Experiment)optimizerTreeView.SelectedNode.Parent.Tag;
-
-      int index = optimizerTreeView.SelectedNode.Index;
+      if (treeView.SelectedNode.Parent == null) experiment = Content;
+      else experiment = (Experiment)treeView.SelectedNode.Parent.Tag;
+
+      int index = treeView.SelectedNode.Index;
       experiment.Optimizers.Reverse(index - 1, 2);
-      optimizerTreeView.SelectedNode = optimizerTreeViewMapping[optimizer].First();
+      treeView.SelectedNode = treeNodeTagMapping[optimizer].First();
       SetEnabledStateOfControls();
       UpdateDetailsViewHost();
@@ -614,12 +677,12 @@
     }
     private void moveDownButton_Click(object sender, EventArgs e) {
-      var optimizer = optimizerTreeView.SelectedNode.Tag as IOptimizer;
+      var optimizer = (IOptimizer)treeView.SelectedNode.Tag;
       Experiment experiment = null;
-      if (optimizerTreeView.SelectedNode.Parent == null) experiment = Content;
-      else experiment = (Experiment)optimizerTreeView.SelectedNode.Parent.Tag;
-
-      int index = optimizerTreeView.SelectedNode.Index;
+      if (treeView.SelectedNode.Parent == null) experiment = Content;
+      else experiment = (Experiment)treeView.SelectedNode.Parent.Tag;
+
+      int index = treeView.SelectedNode.Index;
       experiment.Optimizers.Reverse(index, 2);
-      optimizerTreeView.SelectedNode = optimizerTreeViewMapping[optimizer].First();
+      treeView.SelectedNode = treeNodeTagMapping[optimizer].First();
       SetEnabledStateOfControls();
       UpdateDetailsViewHost();
@@ -628,6 +691,6 @@
 
     private void removeButton_Click(object sender, EventArgs e) {
-      var treeNode = optimizerTreeView.SelectedNode;
-      var optimizer = (IOptimizer)treeNode.Tag;
+      var treeNode = treeView.SelectedNode;
+      var optimizer = treeNode.Tag as IOptimizer;
 
       if (treeNode.Parent == null)
@@ -638,5 +701,5 @@
         if (batchRun != null) batchRun.Optimizer = null;
         else if (experiment != null) experiment.Optimizers.Remove(optimizer);
-        else throw new NotSupportedException("Handling for specific type not implemented" + optimizerTreeView.SelectedNode.Tag.GetType());
+        else throw new NotSupportedException("Handling for specific type not implemented" + treeView.SelectedNode.Tag.GetType());
       }
       SetEnabledStateOfControls();
@@ -648,6 +711,6 @@
       if (showDetailsCheckBox.Checked) {
         splitContainer.Panel2Collapsed = false;
-        detailsGroupBox.Enabled = optimizerTreeView.SelectedNode != null;
-        detailsViewHost.Content = optimizerTreeView.SelectedNode != null ? (IOptimizer)optimizerTreeView.SelectedNode.Tag : null;
+        detailsGroupBox.Enabled = treeView.SelectedNode != null;
+        detailsViewHost.Content = treeView.SelectedNode != null ? (IContent)treeView.SelectedNode.Tag : null;
       } else {
         splitContainer.Panel2Collapsed = true;
@@ -659,6 +722,6 @@
     #region helpers
     private void UpdateDetailsViewHost() {
-      if (optimizerTreeView.SelectedNode != null)
-        detailsViewHost.Content = (IOptimizer)optimizerTreeView.SelectedNode.Tag;
+      if (treeView.SelectedNode != null)
+        detailsViewHost.Content = (IContent)treeView.SelectedNode.Tag;
       else
         detailsViewHost.Content = null;
@@ -668,23 +731,63 @@
       TreeNode node = new TreeNode(optimizer.ToString());
       node.Tag = optimizer;
+
+      var algorithm = optimizer as IAlgorithm;
+      if (algorithm != null) {
+        foreach (TreeNode childNode in CreateAlgorithmChildNodes(algorithm))
+          node.Nodes.Add(childNode);
+      }
+
       List<TreeNode> nodes;
-      if (!optimizerTreeViewMapping.TryGetValue(optimizer, out nodes)) {
+      if (!treeNodeTagMapping.TryGetValue(optimizer, out nodes)) {
         nodes = new List<TreeNode>();
-        optimizerTreeViewMapping.Add(optimizer, nodes);
-        RegisterOptimizerEvents(optimizer);
+        treeNodeTagMapping.Add(optimizer, nodes);
+        RegisterNamedItemEvents(optimizer);
       }
       nodes.Add(node);
+
+      foreach (TreeNode childNode in node.Nodes) {
+        NamedItem namedItem = childNode.Tag as NamedItem;
+        if (namedItem != null) {
+          if (!treeNodeTagMapping.TryGetValue(namedItem, out nodes)) {
+            nodes = new List<TreeNode>();
+            treeNodeTagMapping.Add(namedItem, nodes);
+            RegisterNamedItemEvents(namedItem);
+          }
+          nodes.Add(childNode);
+        }
+      }
       return node;
     }
 
+    private IEnumerable<TreeNode> CreateAlgorithmChildNodes(IAlgorithm algorithm) {
+      TreeNode problemNode;
+      if (algorithm.Problem != null) {
+        problemNode = new TreeNode(algorithm.Problem.Name);
+        problemNode.Tag = algorithm.Problem;
+      } else {
+        problemNode = new TreeNode("No Problem");
+        problemNode.Tag = null;
+      }
+      TreeNode parametersNode = new TreeNode("Parameters");
+      parametersNode.Tag = algorithm.Parameters;
+      TreeNode resultsNode = new TreeNode("Results");
+      resultsNode.Tag = algorithm.Results;
+
+      yield return problemNode;
+      yield return parametersNode;
+      yield return resultsNode;
+    }
+
     private void DisposeTreeNode(TreeNode node) {
-      var optimizer = (IOptimizer)node.Tag;
+      var namedItem = node.Tag as INamedItem;
+      if (namedItem == null) return;
+
       List<TreeNode> nodes;
-      if (!optimizerTreeViewMapping.TryGetValue(optimizer, out nodes))
+      if (!treeNodeTagMapping.TryGetValue(namedItem, out nodes))
         throw new ArgumentException();
       nodes.Remove(node);
       if (nodes.Count == 0) {
-        optimizerTreeViewMapping.Remove(optimizer);
-        DeregisterOptimizerEvents(optimizer);
+        treeNodeTagMapping.Remove(namedItem);
+        DeregisterNamedItemEvents(namedItem);
       }
     }
@@ -693,5 +796,5 @@
       TreeNodeCollection nodes;
       if (node == null)
-        nodes = optimizerTreeView.Nodes;
+        nodes = treeView.Nodes;
       else {
         nodes = node.Nodes;
@@ -710,9 +813,9 @@
       }
 
-      optimizerTreeView.ImageList.Images.Clear();
+      treeView.ImageList.Images.Clear();
       foreach (TreeNode treeNode in IterateTreeNodes()) {
-        var optimizer = (IOptimizer)treeNode.Tag;
-        optimizerTreeView.ImageList.Images.Add(optimizer == null ? HeuristicLab.Common.Resources.VSImageLibrary.Nothing : optimizer.ItemImage);
-        treeNode.ImageIndex = optimizerTreeView.ImageList.Images.Count - 1;
+        var item = (IItem)treeNode.Tag;
+        treeView.ImageList.Images.Add(item == null ? HeuristicLab.Common.Resources.VSImageLibrary.Nothing : item.ItemImage);
+        treeNode.ImageIndex = treeView.ImageList.Images.Count - 1;
         treeNode.SelectedImageIndex = treeNode.ImageIndex;
       }
Index: /trunk/sources/HeuristicLab.Optimization/3.3/ResultCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization/3.3/ResultCollection.cs	(revision 6523)
+++ /trunk/sources/HeuristicLab.Optimization/3.3/ResultCollection.cs	(revision 6524)
@@ -40,4 +40,8 @@
       return new ResultCollection(this, cloner);
     }
+
+    public override System.Drawing.Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Object; }
+    }
   }
 }
