Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs	(revision 14039)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs	(revision 14040)
@@ -29,4 +29,12 @@
 using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using HeuristicLab.PluginInfrastructure;
+using System.Linq;
+using HeuristicLab.Problems.BinPacking.Analyzers;
+using System;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -35,6 +43,6 @@
   public abstract class BinPackingProblem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IPackingPlanEvaluationAlgorithm, IPackingSolutionCreator> 
     where D : class, IPackingDimensions 
-    where B : PackingShape<D>, IPackingBin, new()
-    where I : PackingShape<D>, IPackingItem, new () {
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape, new()
+    where I : PackingShape<D>, IPackingItem, IRegularPackingShape, new () {
 
 
@@ -54,4 +62,10 @@
     public ValueParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
       get { return (ValueParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    }
+    public IValueParameter<B> PackingBinMeasuresParameter {
+      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
     }
     #endregion
@@ -70,4 +84,12 @@
       set { PackingPlanEvaluatorParameter.Value = value; }
     }
+    public B PackingBinMeasures {
+      get { return PackingBinMeasuresParameter.Value; }
+      set { PackingBinMeasuresParameter.Value = value; }
+    }
+    public PackingSolutionDecoder<D, B, I> PackingSolutionDecoder {
+      get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; }
+      set { PackingSolutionDecoderParameter.Value = value; }
+    }
     #endregion
 
@@ -77,5 +99,9 @@
     protected BinPackingProblem(BinPackingProblem<D,B,I> original, Cloner cloner)
       : base(original, cloner) {
-    }                 
+      InitializeEventHandlers();
+    }
+
+    protected BinPackingProblem(IPackingPlanEvaluationAlgorithm e) : this(e, new MultiComponentVectorRandomCreator()) { }
+
     protected BinPackingProblem(IPackingPlanEvaluationAlgorithm e, IPackingSolutionCreator c) : base (e, c){
       Parameters.Add(new OptionalValueParameter<PackingPlan<D, B, I>>("BestKnownSolution", "The best known solution of this bin-packing instance."));
@@ -84,10 +110,148 @@
       Parameters.Add(new FixedValueParameter<IntValue>("PackingItems", "The number of packing-items used in this bin packing instance.", new IntValue()));
       Parameters.Add(new FixedValueParameter<IntValue>("LowerBound", "The lower possible number of bins needed to solve this problem (taken from Dell'Amico, Martello and Vigo; 2002)", new IntValue()));
-    }
-
-    protected abstract void InitializeDecoder(); 
-    protected abstract void InitializeProblemInstance();
-    protected abstract void InitializeOperators();
-    protected abstract void InitializeEventHandlers();
+      Parameters.Add(new ValueParameter<B>("PackingBinMeasures", "Packing-bin data defining the measures of the used bins.", new B()));
+      Parameters.Add(new ValueParameter<IPackingPlanEvaluator>("PackingPlanEvaluator", "The evaluator is used to determine the quality of a solution.", CreateDefaultEvaluator()));
+      Parameters.Add(new ConstrainedValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
+      this.Maximization.Value = true;
+      InitializeProblemInstance();
+      InitializeOperators();
+      InitializeEventHandlers();
+    }
+
+    protected abstract void InitializeDecoder();
+    protected virtual void InitializeProblemInstance() {
+      InitializeProblemData();
+      ApplyHorizontalOrientation();
+      SortItems();
+      RemoveTooBigItems();
+      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+    protected virtual void InitializeOperators() {
+      Operators.Clear();
+      Operators.Add(new BestBinPackingSolutionAnalyzer<D, B, I>());
+
+      ApplyEncoding();
+      ParameterizeOperators();
+    }
+    protected virtual void InitializeEventHandlers() {
+      PackingPlanEvaluatorParameter.ValueChanged += PackingPlanEvaluatorParameter_ValueChanged;
+      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
+      SolutionCreatorParameter.ValueChanged += SolutionCreatorParameter_ValueChanged;
+      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
+      PackingSolutionDecoderParameter.ValueChanged += PackingSolutionDecoderParameter_ValueChanged;
+      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
+    }
+
+
+    protected abstract void RemoveTooBigItems();
+    protected abstract void InitializeProblemData();
+    protected abstract IPackingPlanEvaluator CreateDefaultEvaluator();
+    protected void ApplyHorizontalOrientation() {
+      PackingBinMeasures.ApplyHorizontalOrientation();
+      foreach (IRegularPackingShape shape in PackingItemMeasures) {
+        shape.ApplyHorizontalOrientation();
+      }
+    }
+    protected void SortItems() {
+      PackingItemMeasures.Sort((x, y) => y.CompareTo(x));
+    }
+    protected int CalculateLowerBound() {
+      //This is the obvious continuous lower bound calculation; Martello and Vigo proposed a better way but it has not been implemented yet;
+      int items = PackingItemMeasures.Select(x => x.Volume).Sum();
+      int bin = PackingBinMeasures.Volume;
+      return (items + bin - 1) / (bin);
+    }
+
+    private void ApplyEncoding() {
+      if (SolutionCreator.GetType() == typeof(PackingSequenceRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPackingSequenceOperator>());
+        InitializeDecoder();
+      } else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IGroupingVectorOperator>());
+        InitializeDecoder();
+      } else if (SolutionCreator.GetType() == typeof(MultiComponentVectorRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
+        InitializeDecoder();
+      }
+    }
+    private void ParameterizeOperators() {
+      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
+        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+      }
+
+      Evaluator.PackingSolutionDecoderParameter.ActualName = PackingSolutionDecoderParameter.Name;
+      Evaluator.PackingSolutionDecoderParameter.Hidden = true;
+      Evaluator.PackingPlanEvaluatorParameter.ActualName = PackingPlanEvaluatorParameter.Name;
+      Evaluator.PackingPlanEvaluatorParameter.Hidden = true;
+      Evaluator.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+      Evaluator.QualityParameter.Hidden = true;
+
+      if (PackingSolutionDecoder != null)
+        PackingSolutionDecoder.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+
+      if (PackingSolutionDecoder != null) {
+        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
+        PackingPlanEvaluator.PackingPlanParameter.Hidden = true;
+      } else {
+        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingPlanEvaluator.PackingPlanParameter.Name;
+        PackingPlanEvaluator.PackingPlanParameter.Hidden = false;
+      }
+
+      foreach (var op in Operators.OfType<IPackingSolutionManipulator>()) {
+        op.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.EncodedSolutionParameter.Hidden = true;
+      }
+
+      foreach (var op in Operators.OfType<IPackingSolutionCrossover>()) {
+        op.ChildParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.ChildParameter.Hidden = true;
+        op.ParentsParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.ParentsParameter.Hidden = true;
+      }
+
+      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
+        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+        if (PackingSolutionDecoder != null) {
+          op.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
+          op.PackingPlanParameter.Hidden = true;
+        } else {
+          op.PackingPlanParameter.ActualName = op.PackingPlanParameter.Name;
+          op.PackingPlanParameter.Hidden = false;
+        }
+      }
+
+    }
+
+    #region Events
+    protected override void OnSolutionCreatorChanged() {
+      InitializeOperators();
+    }
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      ParameterizeOperators();
+    }
+    private void PackingPlanEvaluatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void PackingPlanEvaluator_QualityParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void SolutionCreator_EncodedSolutionParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    private void PackingSolutionDecoderParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    #endregion
   }
 }
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 14039)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 14040)
@@ -290,5 +290,4 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="RegularIdenticalBinPackingProblem.cs" />
   </ItemGroup>
   <ItemGroup>
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/RegularIdenticalBinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/RegularIdenticalBinPackingProblem.cs	(revision 14039)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/RegularIdenticalBinPackingProblem.cs	(revision 14040)
@@ -47,21 +47,9 @@
 
     #region Parameter Properties
-    public IValueParameter<B> PackingBinMeasuresParameter {
-      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
-    }
-    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
-      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
-    }
+
     #endregion
 
     #region Properties
-    public B PackingBinMeasures {
-      get { return PackingBinMeasuresParameter.Value; }
-      set { PackingBinMeasuresParameter.Value = value; }
-    }
-    public PackingSolutionDecoder<D, B, I> PackingSolutionDecoder {
-      get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; }
-      set { PackingSolutionDecoderParameter.Value = value; }
-    }
+
     #endregion
 
