Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyAlgorithm.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyAlgorithm.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyAlgorithm.cs	(revision 5344)
@@ -0,0 +1,90 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("Empty Algorithm", "A dummy algorithm which serves as a placeholder and cannot be executed.")]
+  [StorableClass]
+  public sealed class EmptyAlgorithm : HeuristicLab.Optimization.Algorithm {
+    private string exceptionMessage;
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    private ResultCollection results;
+    public override Optimization.ResultCollection Results {
+      get { return results; }
+    }
+
+    #region Persistence Properties
+    [Storable(Name = "ExceptionMessage")]
+    private string ExceptionMessage {
+      get { return exceptionMessage; }
+      set { exceptionMessage = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private EmptyAlgorithm(bool deserializing)
+      : base(deserializing) {
+      this.results = new ResultCollection();
+    }
+    private EmptyAlgorithm(EmptyAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+      this.exceptionMessage = original.exceptionMessage;
+      this.results = new ResultCollection();
+    }
+    public EmptyAlgorithm()
+      : base() {
+      results = new ResultCollection();
+    }
+    public EmptyAlgorithm(string exceptionMessage)
+      : this() {
+      this.exceptionMessage = exceptionMessage;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptyAlgorithm(this, cloner);
+    }
+
+    public override void Prepare() {
+      throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot prepare an EmptyAlgorithm." : exceptionMessage);
+    }
+    public override void Start() {
+      throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot start an EmptyAlgorithm." : exceptionMessage);
+    }
+    public override void Pause() {
+      throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot pause an EmptyAlgorithm." : exceptionMessage);
+    }
+    public override void Stop() {
+      throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot stop an EmptyAlgorithm." : exceptionMessage);
+    }
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyEvaluator.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyEvaluator.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyEvaluator.cs	(revision 5344)
@@ -0,0 +1,70 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("EmptyEvaluator", "A dummy evaluator which throws an exception when executed.")]
+  [StorableClass]
+  public sealed class EmptyEvaluator : Operator, IEvaluator {
+    private string exceptionMessage;
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    #region Persistence Properties
+    [Storable(Name = "ExceptionMessage")]
+    private string ExceptionMessage {
+      get { return exceptionMessage; }
+      set { exceptionMessage = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private EmptyEvaluator(bool deserializing) : base(deserializing) { }
+    private EmptyEvaluator(EmptyEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+      exceptionMessage = original.exceptionMessage;
+    }
+    public EmptyEvaluator() : base() { }
+    public EmptyEvaluator(string exceptionMessage)
+      : this() {
+      this.exceptionMessage = exceptionMessage;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptyEvaluator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot execute an EmptyEvaluator. Please choose an appropriate solution evaluator." : exceptionMessage);
+    }
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyMultiObjectiveEvaluator.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyMultiObjectiveEvaluator.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyMultiObjectiveEvaluator.cs	(revision 5344)
@@ -0,0 +1,79 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("EmptyMultiObjectiveEvaluator", "A dummy multi-objective evaluator which throws an exception when executed.")]
+  [StorableClass]
+  public sealed class EmptyMultiObjectiveEvaluator : Operator, IMultiObjectiveEvaluator {
+    private string exceptionMessage;
+
+    public ILookupParameter<DoubleArray> QualitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Qualities"]; }
+    }
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    #region Persistence Properties
+    [Storable(Name = "ExceptionMessage")]
+    private string ExceptionMessage {
+      get { return exceptionMessage; }
+      set { exceptionMessage = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private EmptyMultiObjectiveEvaluator(bool deserializing) : base(deserializing) { }
+    private EmptyMultiObjectiveEvaluator(EmptyMultiObjectiveEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+      exceptionMessage = original.exceptionMessage;
+    }
+    public EmptyMultiObjectiveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleArray>("Qualities", "The evaluated quality values of a solution."));
+    }
+    public EmptyMultiObjectiveEvaluator(string exceptionMessage)
+      : this() {
+      this.exceptionMessage = exceptionMessage;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptyMultiObjectiveEvaluator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot execute an EmptyMultiObjectiveEvaluator. Please choose an appropriate solution evaluator." : exceptionMessage);
+    }
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyMultiObjectiveProblem.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyMultiObjectiveProblem.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyMultiObjectiveProblem.cs	(revision 5344)
@@ -0,0 +1,56 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("Empty Multi-Objective Problem", "A dummy multi-objective problem which serves as a placeholder and cannot be solved.")]
+  [StorableClass]
+  public sealed class EmptyMultiObjectiveProblem : MultiObjectiveProblem<EmptyMultiObjectiveEvaluator, EmptySolutionCreator> {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    [StorableConstructor]
+    private EmptyMultiObjectiveProblem(bool deserializing) : base(deserializing) { }
+    private EmptyMultiObjectiveProblem(EmptyMultiObjectiveProblem original, Cloner cloner) : base(original, cloner) { }
+    public EmptyMultiObjectiveProblem()
+      : base() {
+      SolutionCreator = new EmptySolutionCreator();
+      Evaluator = new EmptyMultiObjectiveEvaluator();
+    }
+    public EmptyMultiObjectiveProblem(string exceptionMessage)
+      : base() {
+      SolutionCreator = new EmptySolutionCreator(exceptionMessage);
+      Evaluator = new EmptyMultiObjectiveEvaluator(exceptionMessage);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptyMultiObjectiveProblem(this, cloner);
+    }
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyProblem.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyProblem.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptyProblem.cs	(revision 5344)
@@ -0,0 +1,56 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("Empty Problem", "A dummy problem which serves as a placeholder and cannot be solved.")]
+  [StorableClass]
+  public sealed class EmptyProblem : Problem<EmptyEvaluator, EmptySolutionCreator> {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    [StorableConstructor]
+    private EmptyProblem(bool deserializing) : base(deserializing) { }
+    private EmptyProblem(EmptyProblem original, Cloner cloner) : base(original, cloner) { }
+    public EmptyProblem()
+      : base() {
+      SolutionCreator = new EmptySolutionCreator();
+      Evaluator = new EmptyEvaluator();
+    }
+    public EmptyProblem(string exceptionMessage)
+      : base() {
+      SolutionCreator = new EmptySolutionCreator(exceptionMessage);
+      Evaluator = new EmptyEvaluator(exceptionMessage);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptyProblem(this, cloner);
+    }
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptySingleObjectiveEvaluator.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptySingleObjectiveEvaluator.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptySingleObjectiveEvaluator.cs	(revision 5344)
@@ -0,0 +1,79 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("EmptySingleObjectiveEvaluator", "A dummy single-objective evaluator which throws an exception when executed.")]
+  [StorableClass]
+  public sealed class EmptySingleObjectiveEvaluator : Operator, ISingleObjectiveEvaluator {
+    private string exceptionMessage;
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    #region Persistence Properties
+    [Storable(Name = "ExceptionMessage")]
+    private string ExceptionMessage {
+      get { return exceptionMessage; }
+      set { exceptionMessage = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private EmptySingleObjectiveEvaluator(bool deserializing) : base(deserializing) { }
+    private EmptySingleObjectiveEvaluator(EmptySingleObjectiveEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+      exceptionMessage = original.exceptionMessage;
+    }
+    public EmptySingleObjectiveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of a solution."));
+    }
+    public EmptySingleObjectiveEvaluator(string exceptionMessage)
+      : this() {
+      this.exceptionMessage = exceptionMessage;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptySingleObjectiveEvaluator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot execute an EmptySingleObjectiveEvaluator. Please choose an appropriate solution evaluator." : exceptionMessage);
+    }
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptySingleObjectiveProblem.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptySingleObjectiveProblem.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptySingleObjectiveProblem.cs	(revision 5344)
@@ -0,0 +1,56 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("Empty Single-Objective Problem", "A dummy single-objective problem which serves as a placeholder and cannot be solved.")]
+  [StorableClass]
+  public sealed class EmptySingleObjectiveProblem : SingleObjectiveProblem<EmptySingleObjectiveEvaluator, EmptySolutionCreator> {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    [StorableConstructor]
+    private EmptySingleObjectiveProblem(bool deserializing) : base(deserializing) { }
+    private EmptySingleObjectiveProblem(EmptySingleObjectiveProblem original, Cloner cloner) : base(original, cloner) { }
+    public EmptySingleObjectiveProblem()
+      : base() {
+      SolutionCreator = new EmptySolutionCreator();
+      Evaluator = new EmptySingleObjectiveEvaluator();
+    }
+    public EmptySingleObjectiveProblem(string exceptionMessage)
+      : base() {
+      SolutionCreator = new EmptySolutionCreator(exceptionMessage);
+      Evaluator = new EmptySingleObjectiveEvaluator(exceptionMessage);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptySingleObjectiveProblem(this, cloner);
+    }
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptySolutionCreator.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptySolutionCreator.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/EmptySolutionCreator.cs	(revision 5344)
@@ -0,0 +1,70 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("EmptySolutionCreator", "A dummy solution creator which throws an exception when executed.")]
+  [StorableClass]
+  public sealed class EmptySolutionCreator : Operator, ISolutionCreator {
+    private string exceptionMessage;
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    #region Persistence Properties
+    [Storable(Name = "ExceptionMessage")]
+    private string ExceptionMessage {
+      get { return exceptionMessage; }
+      set { exceptionMessage = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private EmptySolutionCreator(bool deserializing) : base(deserializing) { }
+    private EmptySolutionCreator(EmptySolutionCreator original, Cloner cloner)
+      : base(original, cloner) {
+      exceptionMessage = original.exceptionMessage;
+    }
+    public EmptySolutionCreator() : base() { }
+    public EmptySolutionCreator(string exceptionMessage)
+      : this() {
+      this.exceptionMessage = exceptionMessage;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptySolutionCreator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      throw new InvalidOperationException(string.IsNullOrEmpty(exceptionMessage) ? "Cannot execute an EmptySolutionCreator. Please choose an appropriate solution creator." : exceptionMessage);
+    }
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/HeuristicLab.Clients.OKB-3.3.csproj
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/HeuristicLab.Clients.OKB-3.3.csproj	(revision 5343)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/HeuristicLab.Clients.OKB-3.3.csproj	(revision 5344)
@@ -66,4 +66,7 @@
       <HintPath>..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.MainForm.WindowsForms-3.3.dll</HintPath>
     </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Optimization-3.3">
       <HintPath>..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.Optimization-3.3.dll</HintPath>
@@ -74,4 +77,7 @@
     <Reference Include="HeuristicLab.Optimizer-3.3">
       <HintPath>..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.Optimizer-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\..\..\Program Files\HeuristicLab 3.3\HeuristicLab.Parameters-3.3.dll</HintPath>
     </Reference>
     <Reference Include="HeuristicLab.Persistence-3.3">
@@ -94,4 +100,14 @@
   <ItemGroup>
     <Compile Include="AdministratorMenuItem.cs" />
+    <Compile Include="EmptyAlgorithm.cs" />
+    <Compile Include="OKBAlgorithm.cs" />
+    <Compile Include="MultiObjectiveOKBProblem.cs" />
+    <Compile Include="EmptyMultiObjectiveProblem.cs" />
+    <Compile Include="EmptyEvaluator.cs" />
+    <Compile Include="EmptyProblem.cs" />
+    <Compile Include="EmptyMultiObjectiveEvaluator.cs" />
+    <Compile Include="EmptySolutionCreator.cs" />
+    <Compile Include="EmptySingleObjectiveEvaluator.cs" />
+    <Compile Include="EmptySingleObjectiveProblem.cs" />
     <Compile Include="SingleObjectiveOKBProblem.cs" />
     <Compile Include="OKBProblem.cs" />
@@ -184,4 +200,10 @@
       <DependentUpon>AlgorithmParameterView.cs</DependentUpon>
     </Compile>
+    <Compile Include="Views\OKBAlgorithmView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Views\OKBAlgorithmView.Designer.cs">
+      <DependentUpon>OKBAlgorithmView.cs</DependentUpon>
+    </Compile>
     <Compile Include="Views\OKBProblemView.cs">
       <SubType>UserControl</SubType>
@@ -390,9 +412,4 @@
     <None Include="HeuristicLab.snk" />
     <None Include="HeuristicLabClientsOKBPlugin.cs.frame" />
-  </ItemGroup>
-  <ItemGroup>
-    <EmbeddedResource Include="Views\OKBProblemView.resx">
-      <DependentUpon>OKBProblemView.cs</DependentUpon>
-    </EmbeddedResource>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/HeuristicLabClientsOKBPlugin.cs.frame
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/HeuristicLabClientsOKBPlugin.cs.frame	(revision 5343)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/HeuristicLabClientsOKBPlugin.cs.frame	(revision 5344)
@@ -37,7 +37,9 @@
   [PluginDependency("HeuristicLab.MainForm", "3.3")]
   [PluginDependency("HeuristicLab.MainForm.WindowsForms", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
   [PluginDependency("HeuristicLab.Optimization.Views", "3.3")]
   [PluginDependency("HeuristicLab.Optimizer", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
   public class HeuristicLabClientsOKBPlugin : PluginBase {
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/MultiObjectiveOKBProblem.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/MultiObjectiveOKBProblem.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/MultiObjectiveOKBProblem.cs	(revision 5344)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("Multi-Objective OKB Problem", "Represents a multi-objective problem which is stored in the OKB.")]
+  [Creatable("Optimization Knowledge Base (OKB)")]
+  [StorableClass]
+  public sealed class MultiObjectiveOKBProblem : OKBProblem, IMultiObjectiveProblem {
+    public override Type ProblemType {
+      get { return typeof(IMultiObjectiveProblem); }
+    }
+    public new IMultiObjectiveProblem Problem {
+      get { return base.Problem as IMultiObjectiveProblem; }
+    }
+    public IParameter MaximizationParameter {
+      get { return Problem.MaximizationParameter; }
+    }
+    public new IMultiObjectiveEvaluator Evaluator {
+      get { return Problem.Evaluator; }
+    }
+
+    [StorableConstructor]
+    private MultiObjectiveOKBProblem(bool deserializing) : base(deserializing) { }
+    private MultiObjectiveOKBProblem(MultiObjectiveOKBProblem original, Cloner cloner) : base(original, cloner) { }
+    public MultiObjectiveOKBProblem() : base(new EmptyMultiObjectiveProblem("No problem selected. Please choose a multi-objective problem instance from the OKB.")) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveOKBProblem(this, cloner);
+    }
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/OKBAlgorithm.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/OKBAlgorithm.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/OKBAlgorithm.cs	(revision 5344)
@@ -0,0 +1,332 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence.Default.Xml;
+
+namespace HeuristicLab.Clients.OKB {
+  [Item("OKB Algorithm", "An algorithm which is stored in the OKB.")]
+  [Creatable("Optimization Knowledge Base (OKB)")]
+  [StorableClass]
+  public sealed class OKBAlgorithm : Item, IAlgorithm {
+    private long algorithmId;
+    public long AlgorithmId {
+      get { return algorithmId; }
+    }
+    private IAlgorithm algorithm;
+    public IAlgorithm Algorithm {
+      get { return algorithm; }
+      private set {
+        if (value == null) throw new ArgumentNullException("Algorithm", "Algorithm cannot be null.");
+        if (value != algorithm) {
+          CancelEventArgs<string> e = new CancelEventArgs<string>(value.Name);
+          OnNameChanging(e);
+          if (!e.Cancel) {
+            DeregisterAlgorithmEvents();
+            algorithm = value;
+            RegisterAlgorithmEvents();
+
+            OnToStringChanged();
+            OnItemImageChanged();
+            OnNameChanged();
+            OnDescriptionChanged();
+            OnAlgorithmChanged();
+          }
+        }
+      }
+    }
+
+    public override Image ItemImage {
+      get { return Algorithm.ItemImage; }
+    }
+
+    public string Name {
+      get { return Algorithm.Name; }
+      set { throw new NotSupportedException("Name cannot be changed."); }
+    }
+    public string Description {
+      get { return Algorithm.Description; }
+      set { throw new NotSupportedException("Description cannot be changed."); }
+    }
+    public bool CanChangeName {
+      get { return false; }
+    }
+    public bool CanChangeDescription {
+      get { return false; }
+    }
+
+    public IKeyedItemCollection<string, IParameter> Parameters {
+      get { return Algorithm.Parameters; }
+    }
+
+    public ExecutionState ExecutionState {
+      get { return Algorithm.ExecutionState; }
+    }
+    public TimeSpan ExecutionTime {
+      get { return Algorithm.ExecutionTime; }
+    }
+
+    public Type ProblemType {
+      get { return Algorithm.ProblemType; }
+    }
+    public IProblem Problem {
+      get { return Algorithm.Problem; }
+      set { Algorithm.Problem = value; }
+    }
+
+    public ResultCollection Results {
+      get { return Algorithm.Results; }
+    }
+
+    public RunCollection Runs {
+      get { return Algorithm.Runs; }
+    }
+    public bool StoreAlgorithmInEachRun {
+      get { return Algorithm.StoreAlgorithmInEachRun; }
+      set { Algorithm.StoreAlgorithmInEachRun = value; }
+    }
+
+    #region Persistence Properties
+    [Storable(Name = "AlgorithmId")]
+    private long StorableAlgorithmId {
+      get { return algorithmId; }
+      set { algorithmId = value; }
+    }
+    [Storable(Name = "Algorithm")]
+    private IAlgorithm StorableAlgorithm {
+      get { return algorithm; }
+      set {
+        algorithm = value;
+        RegisterAlgorithmEvents();
+      }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private OKBAlgorithm(bool deserializing) : base(deserializing) { }
+    private OKBAlgorithm(OKBAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+      algorithmId = original.algorithmId;
+      algorithm = cloner.Clone(original.algorithm);
+      RegisterAlgorithmEvents();
+    }
+    public OKBAlgorithm()
+      : base() {
+      algorithmId = -1;
+      algorithm = new EmptyAlgorithm("No algorithm selected. Please choose an algorithm from the OKB.");
+      RegisterAlgorithmEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new OKBAlgorithm(this, cloner);
+    }
+
+    public void Load(long algorithmId) {
+      if (this.algorithmId != algorithmId) {
+        IAlgorithm algorithm;
+        AlgorithmData algorithmData = OKBClient.Instance.GetAlgorithmData(algorithmId);
+        using (MemoryStream stream = new MemoryStream(algorithmData.Data)) {
+          algorithm = XmlParser.Deserialize<IAlgorithm>(stream);
+        }
+        this.algorithmId = algorithmId;
+        Algorithm = algorithm;
+      }
+    }
+
+    public void CollectParameterValues(IDictionary<string, IItem> values) {
+      Algorithm.CollectParameterValues(values);
+    }
+    public void CollectResultValues(IDictionary<string, IItem> values) {
+      Algorithm.CollectResultValues(values);
+    }
+
+    public void Prepare() {
+      Algorithm.Prepare();
+    }
+    public void Prepare(bool clearRuns) {
+      Algorithm.Prepare(clearRuns);
+    }
+    public void Start() {
+      Algorithm.Start();
+    }
+    public void Pause() {
+      Algorithm.Pause();
+    }
+    public void Stop() {
+      Algorithm.Stop();
+    }
+
+    #region Events
+    public event EventHandler AlgorithmChanged;
+    private void OnAlgorithmChanged() {
+      EventHandler handler = AlgorithmChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler<CancelEventArgs<string>> NameChanging;
+    private void OnNameChanging(CancelEventArgs<string> e) {
+      var handler = NameChanging;
+      if (handler != null) handler(this, e);
+    }
+    public event EventHandler NameChanged;
+    private void OnNameChanged() {
+      var handler = NameChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler DescriptionChanged;
+    private void OnDescriptionChanged() {
+      var handler = DescriptionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ExecutionStateChanged;
+    private void OnExecutionStateChanged() {
+      var handler = ExecutionStateChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ExecutionTimeChanged;
+    private void OnExecutionTimeChanged() {
+      var handler = ExecutionTimeChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ProblemChanged;
+    private void OnProblemChanged() {
+      var handler = ProblemChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler StoreAlgorithmInEachRunChanged;
+    private void OnStoreAlgorithmInEachRunChanged() {
+      var handler = StoreAlgorithmInEachRunChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Prepared;
+    private void OnPrepared() {
+      var handler = Prepared;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Started;
+    private void OnStarted() {
+      var handler = Started;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Paused;
+    private void OnPaused() {
+      var handler = Paused;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Stopped;
+    private void OnStopped() {
+      var handler = Stopped;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;
+    private void OnExceptionOccurred(Exception exception) {
+      var handler = ExceptionOccurred;
+      if (handler != null) handler(this, new EventArgs<Exception>(exception));
+    }
+
+    private void RegisterAlgorithmEvents() {
+      if (Algorithm != null) {
+        Algorithm.ToStringChanged += new EventHandler(Algorithm_ToStringChanged);
+        Algorithm.ItemImageChanged += new EventHandler(Algorithm_ItemImageChanged);
+        Algorithm.NameChanging += new EventHandler<CancelEventArgs<string>>(Algorithm_NameChanging);
+        Algorithm.NameChanged += new EventHandler(Algorithm_NameChanged);
+        Algorithm.DescriptionChanged += new EventHandler(Algorithm_DescriptionChanged);
+        Algorithm.ExecutionStateChanged += new EventHandler(Algorithm_ExecutionStateChanged);
+        Algorithm.ExecutionTimeChanged += new EventHandler(Algorithm_ExecutionTimeChanged);
+        Algorithm.ProblemChanged += new EventHandler(Algorithm_ProblemChanged);
+        Algorithm.StoreAlgorithmInEachRunChanged += new EventHandler(Algorithm_StoreAlgorithmInEachRunChanged);
+        Algorithm.Prepared += new EventHandler(Algorithm_Prepared);
+        Algorithm.Started += new EventHandler(Algorithm_Started);
+        Algorithm.Paused += new EventHandler(Algorithm_Paused);
+        Algorithm.Stopped += new EventHandler(Algorithm_Stopped);
+        Algorithm.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(Algorithm_ExceptionOccurred);
+      }
+    }
+    private void DeregisterAlgorithmEvents() {
+      if (Algorithm != null) {
+        Algorithm.ToStringChanged -= new EventHandler(Algorithm_ToStringChanged);
+        Algorithm.ItemImageChanged -= new EventHandler(Algorithm_ItemImageChanged);
+        Algorithm.NameChanging -= new EventHandler<CancelEventArgs<string>>(Algorithm_NameChanging);
+        Algorithm.NameChanged -= new EventHandler(Algorithm_NameChanged);
+        Algorithm.DescriptionChanged -= new EventHandler(Algorithm_DescriptionChanged);
+        Algorithm.ExecutionStateChanged -= new EventHandler(Algorithm_ExecutionStateChanged);
+        Algorithm.ExecutionTimeChanged -= new EventHandler(Algorithm_ExecutionTimeChanged);
+        Algorithm.ProblemChanged -= new EventHandler(Algorithm_ProblemChanged);
+        Algorithm.StoreAlgorithmInEachRunChanged -= new EventHandler(Algorithm_StoreAlgorithmInEachRunChanged);
+        Algorithm.Prepared -= new EventHandler(Algorithm_Prepared);
+        Algorithm.Started -= new EventHandler(Algorithm_Started);
+        Algorithm.Paused -= new EventHandler(Algorithm_Paused);
+        Algorithm.Stopped -= new EventHandler(Algorithm_Stopped);
+        Algorithm.ExceptionOccurred -= new EventHandler<EventArgs<Exception>>(Algorithm_ExceptionOccurred);
+      }
+    }
+
+    private void Algorithm_ToStringChanged(object sender, EventArgs e) {
+      OnToStringChanged();
+    }
+    private void Algorithm_ItemImageChanged(object sender, EventArgs e) {
+      OnItemImageChanged();
+    }
+    private void Algorithm_NameChanging(object sender, CancelEventArgs<string> e) {
+      OnNameChanging(e);
+    }
+    private void Algorithm_NameChanged(object sender, EventArgs e) {
+      OnNameChanged();
+    }
+    private void Algorithm_DescriptionChanged(object sender, EventArgs e) {
+      OnDescriptionChanged();
+    }
+    private void Algorithm_ExecutionStateChanged(object sender, EventArgs e) {
+      OnExecutionStateChanged();
+    }
+    private void Algorithm_ExecutionTimeChanged(object sender, EventArgs e) {
+      OnExecutionTimeChanged();
+    }
+    private void Algorithm_ProblemChanged(object sender, EventArgs e) {
+      OnProblemChanged();
+    }
+    private void Algorithm_StoreAlgorithmInEachRunChanged(object sender, EventArgs e) {
+      OnStoreAlgorithmInEachRunChanged();
+    }
+    private void Algorithm_Prepared(object sender, EventArgs e) {
+      OnPrepared();
+    }
+    private void Algorithm_Started(object sender, EventArgs e) {
+      OnStarted();
+    }
+    private void Algorithm_Paused(object sender, EventArgs e) {
+      OnPaused();
+    }
+    private void Algorithm_Stopped(object sender, EventArgs e) {
+      OnStopped();
+    }
+    private void Algorithm_ExceptionOccurred(object sender, EventArgs<Exception> e) {
+      OnExceptionOccurred(e.Value);
+    }
+    #endregion
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/OKBProblem.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/OKBProblem.cs	(revision 5343)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/OKBProblem.cs	(revision 5344)
@@ -24,5 +24,4 @@
 using System.Drawing;
 using System.IO;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -32,32 +31,7 @@
 
 namespace HeuristicLab.Clients.OKB {
-  [Item("OKB Problem", "Represents a problem which is stored in the OKB.")]
+  [Item("OKB Problem", "A base class for problems which are stored in the OKB.")]
   [StorableClass]
-  public class OKBProblem : Item, IProblem, IStorableContent {
-    public string Filename { get; set; }
-
-    public override Image ItemImage {
-      get { return Problem == null ? HeuristicLab.Common.Resources.VSImageLibrary.Type : Problem.ItemImage; }
-    }
-
-    public string Name {
-      get { return Problem == null ? ItemName : Problem.Name; }
-      set { throw new NotSupportedException("Name cannot be changed."); }
-    }
-    public string Description {
-      get { return Problem == null ? ItemDescription : Problem.Description; }
-      set { throw new NotSupportedException("Description cannot be changed."); }
-    }
-    public bool CanChangeName {
-      get { return false; }
-    }
-    public bool CanChangeDescription {
-      get { return false; }
-    }
-
-    public IKeyedItemCollection<string, IParameter> Parameters {
-      get { return Problem == null ? null : Problem.Parameters; }
-    }
-
+  public abstract class OKBProblem : Item, IProblem {
     public virtual Type ProblemType {
       get { return typeof(IProblem); }
@@ -71,5 +45,5 @@
       get { return problem; }
       private set {
-        if (value == null) throw new ArgumentNullException("Problem");
+        if (value == null) throw new ArgumentNullException("Problem", "Problem cannot be null.");
         if (value != problem) {
           CancelEventArgs<string> e = new CancelEventArgs<string>(value.Name);
@@ -94,18 +68,41 @@
     }
 
+    public override Image ItemImage {
+      get { return Problem.ItemImage; }
+    }
+
+    public string Name {
+      get { return Problem.Name; }
+      set { throw new NotSupportedException("Name cannot be changed."); }
+    }
+    public string Description {
+      get { return Problem.Description; }
+      set { throw new NotSupportedException("Description cannot be changed."); }
+    }
+    public bool CanChangeName {
+      get { return false; }
+    }
+    public bool CanChangeDescription {
+      get { return false; }
+    }
+
+    public IKeyedItemCollection<string, IParameter> Parameters {
+      get { return Problem.Parameters; }
+    }
+
     public IParameter SolutionCreatorParameter {
-      get { return Problem == null ? null : Problem.SolutionCreatorParameter; }
+      get { return Problem.SolutionCreatorParameter; }
     }
     public ISolutionCreator SolutionCreator {
-      get { return Problem == null ? null : Problem.SolutionCreator; }
+      get { return Problem.SolutionCreator; }
     }
     public IParameter EvaluatorParameter {
-      get { return Problem == null ? null : Problem.EvaluatorParameter; }
+      get { return Problem.EvaluatorParameter; }
     }
     public IEvaluator Evaluator {
-      get { return Problem == null ? null : Problem.Evaluator; }
+      get { return Problem.Evaluator; }
     }
     public IEnumerable<IOperator> Operators {
-      get { return Problem == null ? Enumerable.Empty<IOperator>() : Problem.Operators; }
+      get { return Problem.Operators; }
     }
 
@@ -118,6 +115,9 @@
     [Storable(Name = "Problem")]
     private IProblem StorableProblem {
-      get { return Problem; }
-      set { Problem = value; }
+      get { return problem; }
+      set {
+        problem = value;
+        RegisterProblemEvents();
+      }
     }
     #endregion
@@ -129,12 +129,12 @@
       problemId = original.problemId;
       problem = cloner.Clone(original.problem);
-    }
-    protected OKBProblem()
+      RegisterProblemEvents();
+    }
+    protected OKBProblem(IProblem initialProblem)
       : base() {
+      if (initialProblem == null) throw new ArgumentNullException("initialProblem", "Initial problem cannot be null.");
       problemId = -1;
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new OKBProblem(this, cloner);
+      problem = initialProblem;
+      RegisterProblemEvents();
     }
 
@@ -154,8 +154,13 @@
 
     public void CollectParameterValues(IDictionary<string, IItem> values) {
-      if (Problem != null) Problem.CollectParameterValues(values);
+      Problem.CollectParameterValues(values);
     }
 
     #region Events
+    public event EventHandler ProblemChanged;
+    protected virtual void OnProblemChanged() {
+      EventHandler handler = ProblemChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
     public event EventHandler<CancelEventArgs<string>> NameChanging;
     protected virtual void OnNameChanging(CancelEventArgs<string> e) {
@@ -171,9 +176,4 @@
     protected virtual void OnDescriptionChanged() {
       var handler = DescriptionChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler ProblemChanged;
-    protected virtual void OnProblemChanged() {
-      EventHandler handler = ProblemChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/SingleObjectiveOKBProblem.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/SingleObjectiveOKBProblem.cs	(revision 5343)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/SingleObjectiveOKBProblem.cs	(revision 5344)
@@ -38,11 +38,11 @@
     }
     public IParameter BestKnownQualityParameter {
-      get { return Problem == null ? null : Problem.BestKnownQualityParameter; }
+      get { return Problem.BestKnownQualityParameter; }
+    }
+    public IParameter MaximizationParameter {
+      get { return Problem.MaximizationParameter; }
     }
     public new ISingleObjectiveEvaluator Evaluator {
-      get { return Problem == null ? null : Problem.Evaluator; }
-    }
-    public IParameter MaximizationParameter {
-      get { return Problem == null ? null : Problem.MaximizationParameter; }
+      get { return Problem.Evaluator; }
     }
 
@@ -50,5 +50,5 @@
     private SingleObjectiveOKBProblem(bool deserializing) : base(deserializing) { }
     private SingleObjectiveOKBProblem(SingleObjectiveOKBProblem original, Cloner cloner) : base(original, cloner) { }
-    public SingleObjectiveOKBProblem() : base() { }
+    public SingleObjectiveOKBProblem() : base(new EmptySingleObjectiveProblem("No problem selected. Please choose a single-objective problem instance from the OKB.")) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBAlgorithmView.Designer.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBAlgorithmView.Designer.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBAlgorithmView.Designer.cs	(revision 5344)
@@ -0,0 +1,130 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace HeuristicLab.Clients.OKB {
+  partial class OKBAlgorithmView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing) {
+        if (components != null) components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.components = new System.ComponentModel.Container();
+      this.algorithmLabel = new System.Windows.Forms.Label();
+      this.algorithmComboBox = new System.Windows.Forms.ComboBox();
+      this.refreshButton = new System.Windows.Forms.Button();
+      this.toolTip = new System.Windows.Forms.ToolTip(this.components);
+      this.viewHost = new HeuristicLab.MainForm.WindowsForms.ViewHost();
+      this.SuspendLayout();
+      // 
+      // algorithmLabel
+      // 
+      this.algorithmLabel.AutoSize = true;
+      this.algorithmLabel.Location = new System.Drawing.Point(3, 5);
+      this.algorithmLabel.Name = "algorithmLabel";
+      this.algorithmLabel.Size = new System.Drawing.Size(53, 13);
+      this.algorithmLabel.TabIndex = 0;
+      this.algorithmLabel.Text = "&Algorithm:";
+      // 
+      // algorithmComboBox
+      // 
+      this.algorithmComboBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.algorithmComboBox.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
+      this.algorithmComboBox.FormattingEnabled = true;
+      this.algorithmComboBox.Location = new System.Drawing.Point(62, 1);
+      this.algorithmComboBox.Name = "algorithmComboBox";
+      this.algorithmComboBox.Size = new System.Drawing.Size(546, 21);
+      this.algorithmComboBox.TabIndex = 1;
+      this.algorithmComboBox.SelectedValueChanged += new System.EventHandler(this.algorithmComboBox_SelectedValueChanged);
+      // 
+      // refreshButton
+      // 
+      this.refreshButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+      this.refreshButton.Location = new System.Drawing.Point(614, 0);
+      this.refreshButton.Name = "refreshButton";
+      this.refreshButton.Size = new System.Drawing.Size(24, 24);
+      this.refreshButton.TabIndex = 2;
+      this.toolTip.SetToolTip(this.refreshButton, "Refresh Algorithms");
+      this.refreshButton.UseVisualStyleBackColor = true;
+      this.refreshButton.Click += new System.EventHandler(this.refreshButton_Click);
+      // 
+      // viewHost
+      // 
+      this.viewHost.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.viewHost.Caption = "View";
+      this.viewHost.Content = null;
+      this.viewHost.Enabled = false;
+      this.viewHost.Location = new System.Drawing.Point(0, 30);
+      this.viewHost.Name = "viewHost";
+      this.viewHost.ReadOnly = false;
+      this.viewHost.Size = new System.Drawing.Size(638, 422);
+      this.viewHost.TabIndex = 3;
+      this.viewHost.ViewsLabelVisible = true;
+      this.viewHost.ViewType = null;
+      // 
+      // OKBAlgorithmView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.viewHost);
+      this.Controls.Add(this.algorithmComboBox);
+      this.Controls.Add(this.algorithmLabel);
+      this.Controls.Add(this.refreshButton);
+      this.Name = "OKBAlgorithmView";
+      this.Size = new System.Drawing.Size(638, 452);
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.Label algorithmLabel;
+    private System.Windows.Forms.ComboBox algorithmComboBox;
+    private System.Windows.Forms.Button refreshButton;
+    private System.Windows.Forms.ToolTip toolTip;
+    private MainForm.WindowsForms.ViewHost viewHost;
+
+
+
+
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBAlgorithmView.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBAlgorithmView.cs	(revision 5344)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBAlgorithmView.cs	(revision 5344)
@@ -0,0 +1,132 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using System.Windows.Forms;
+using HeuristicLab.Core.Views;
+using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
+
+namespace HeuristicLab.Clients.OKB {
+  [View("OKBAlgorithm View")]
+  [Content(typeof(OKBAlgorithm), true)]
+  public sealed partial class OKBAlgorithmView : ItemView {
+    public new OKBAlgorithm Content {
+      get { return (OKBAlgorithm)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public OKBAlgorithmView() {
+      InitializeComponent();
+    }
+
+    protected override void OnInitialized(System.EventArgs e) {
+      base.OnInitialized(e);
+      OKBClient.Instance.Refreshing += new EventHandler(OKBClient_Refreshing);
+      OKBClient.Instance.Refreshed += new EventHandler(OKBClient_Refreshed);
+      PopulateComboBox();
+    }
+
+    protected override void DeregisterContentEvents() {
+      Content.AlgorithmChanged -= new EventHandler(Content_AlgorithmChanged);
+      base.DeregisterContentEvents();
+    }
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.AlgorithmChanged += new EventHandler(Content_AlgorithmChanged);
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+        algorithmComboBox.SelectedIndex = -1;
+        viewHost.Content = null;
+      } else {
+        algorithmComboBox.SelectedItem = OKBClient.Instance.Algorithms.FirstOrDefault(x => x.Id == Content.AlgorithmId);
+        viewHost.Content = Content.Algorithm;
+      }
+    }
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      algorithmComboBox.Enabled = (Content != null) && !ReadOnly && !Locked && (algorithmComboBox.Items.Count > 0);
+      refreshButton.Enabled = (Content != null) && !ReadOnly && !Locked;
+    }
+
+    private void PopulateComboBox() {
+      algorithmComboBox.DataSource = null;
+      Platform platform = OKBClient.Instance.Platforms.FirstOrDefault(x => x.Name == "HeuristicLab 3.3");
+      if (platform != null) {
+        algorithmComboBox.DataSource = OKBClient.Instance.Algorithms.Where(x => x.PlatformId == platform.Id).ToList();
+        algorithmComboBox.DisplayMember = "Name";
+      }
+    }
+
+    protected override void OnClosed(FormClosedEventArgs e) {
+      OKBClient.Instance.Refreshing -= new EventHandler(OKBClient_Refreshing);
+      OKBClient.Instance.Refreshed -= new EventHandler(OKBClient_Refreshed);
+      base.OnClosed(e);
+    }
+
+    private void OKBClient_Refreshing(object sender, EventArgs e) {
+      if (InvokeRequired) {
+        Invoke(new EventHandler(OKBClient_Refreshing), sender, e);
+      } else {
+        Cursor = Cursors.AppStarting;
+        algorithmComboBox.Enabled = refreshButton.Enabled = viewHost.Enabled = false;
+      }
+    }
+    private void OKBClient_Refreshed(object sender, EventArgs e) {
+      if (InvokeRequired) {
+        Invoke(new EventHandler(OKBClient_Refreshed), sender, e);
+      } else {
+        PopulateComboBox();
+        SetEnabledStateOfControls();
+        Cursor = Cursors.Default;
+      }
+    }
+
+    #region Content Events
+    private void Content_AlgorithmChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_AlgorithmChanged), sender, e);
+      else {
+        algorithmComboBox.SelectedItem = OKBClient.Instance.Algorithms.FirstOrDefault(x => x.Id == Content.AlgorithmId);
+        viewHost.Content = Content.Algorithm;
+      }
+    }
+    #endregion
+
+    #region Control Events
+    private void refreshButton_Click(object sender, System.EventArgs e) {
+      OKBClient.Instance.Refresh();
+    }
+    private void algorithmComboBox_SelectedValueChanged(object sender, System.EventArgs e) {
+      Algorithm algorithm = algorithmComboBox.SelectedValue as Algorithm;
+      if ((algorithm != null) && (Content != null)) {
+        Content.Load(algorithm.Id);
+        if (Content.AlgorithmId != algorithm.Id)  // reset selected item if load was not successful
+          algorithmComboBox.SelectedItem = OKBClient.Instance.Algorithms.FirstOrDefault(x => x.Id == Content.AlgorithmId);
+      }
+    }
+    #endregion
+  }
+}
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBProblemView.Designer.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBProblemView.Designer.cs	(revision 5343)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBProblemView.Designer.cs	(revision 5344)
@@ -59,5 +59,5 @@
       this.problemLabel.Name = "problemLabel";
       this.problemLabel.Size = new System.Drawing.Size(48, 13);
-      this.problemLabel.TabIndex = 7;
+      this.problemLabel.TabIndex = 0;
       this.problemLabel.Text = "&Problem:";
       // 
@@ -71,5 +71,5 @@
       this.problemComboBox.Name = "problemComboBox";
       this.problemComboBox.Size = new System.Drawing.Size(551, 21);
-      this.problemComboBox.TabIndex = 8;
+      this.problemComboBox.TabIndex = 1;
       this.problemComboBox.SelectedValueChanged += new System.EventHandler(this.problemComboBox_SelectedValueChanged);
       // 
@@ -80,5 +80,5 @@
       this.refreshButton.Name = "refreshButton";
       this.refreshButton.Size = new System.Drawing.Size(24, 24);
-      this.refreshButton.TabIndex = 4;
+      this.refreshButton.TabIndex = 2;
       this.toolTip.SetToolTip(this.refreshButton, "Refresh Problems");
       this.refreshButton.UseVisualStyleBackColor = true;
@@ -97,5 +97,5 @@
       this.viewHost.ReadOnly = false;
       this.viewHost.Size = new System.Drawing.Size(638, 422);
-      this.viewHost.TabIndex = 9;
+      this.viewHost.TabIndex = 3;
       this.viewHost.ViewsLabelVisible = true;
       this.viewHost.ViewType = null;
Index: /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBProblemView.cs
===================================================================
--- /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBProblemView.cs	(revision 5343)
+++ /branches/OKB (trunk integration)/HeuristicLab.Clients.OKB/3.3/Views/OKBProblemView.cs	(revision 5344)
@@ -122,5 +122,9 @@
     private void problemComboBox_SelectedValueChanged(object sender, System.EventArgs e) {
       Problem problem = problemComboBox.SelectedValue as Problem;
-      if ((problem != null) && (Content != null)) Content.Load(problem.Id);
+      if ((problem != null) && (Content != null)) {
+        Content.Load(problem.Id);
+        if (Content.ProblemId != problem.Id)  // reset selected item if load was not successful
+          problemComboBox.SelectedItem = OKBClient.Instance.Problems.FirstOrDefault(x => x.Id == Content.ProblemId);
+      }
     }
     #endregion
