Index: stable/HeuristicLab.DataPreprocessing/3.4/Implementations/DataGridContent.cs
===================================================================
--- stable/HeuristicLab.DataPreprocessing/3.4/Implementations/DataGridContent.cs	(revision 12702)
+++ stable/HeuristicLab.DataPreprocessing/3.4/Implementations/DataGridContent.cs	(revision 12718)
@@ -114,7 +114,11 @@
     }
 
-    public void DeleteRow(IEnumerable<int> rows) {
+    public void DeleteRows(IEnumerable<int> rows) {
       PreProcessingData.DeleteRowsWithIndices(rows);
       createRowNames();
+    }
+
+    public void DeleteColumn(int column) {
+      PreProcessingData.DeleteColumn(column);
     }
 
Index: stable/HeuristicLab.DataPreprocessing/3.4/Implementations/HistogramContent.cs
===================================================================
--- stable/HeuristicLab.DataPreprocessing/3.4/Implementations/HistogramContent.cs	(revision 12702)
+++ stable/HeuristicLab.DataPreprocessing/3.4/Implementations/HistogramContent.cs	(revision 12718)
@@ -42,4 +42,5 @@
       set { this.classifierVariableIndex = value; }
     }
+    public bool IsDetailedChartViewEnabled { get; set; }
 
 
Index: stable/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingChartContent.cs
===================================================================
--- stable/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingChartContent.cs	(revision 12702)
+++ stable/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingChartContent.cs	(revision 12718)
@@ -23,4 +23,5 @@
 using System.Collections.Generic;
 using System.Drawing;
+using System.Linq;
 using HeuristicLab.Analysis;
 using HeuristicLab.Common;
@@ -126,8 +127,9 @@
 
 
-    public ICheckedItemList<StringValue> CreateVariableItemList() {
+    public ICheckedItemList<StringValue> CreateVariableItemList(IEnumerable<string> checkedItems = null) {
       ICheckedItemList<StringValue> itemList = new CheckedItemList<StringValue>();
       foreach (string name in PreprocessingData.GetDoubleVariableNames()) {
-        itemList.Add(new StringValue(name), true);
+        var n = new StringValue(name);
+        itemList.Add(n, (checkedItems == null) ? true : checkedItems.Contains(name));
       }
       return new ReadOnlyCheckedItemList<StringValue>(itemList);
Index: stable/HeuristicLab.DataPreprocessing/3.4/Implementations/SearchLogic.cs
===================================================================
--- stable/HeuristicLab.DataPreprocessing/3.4/Implementations/SearchLogic.cs	(revision 12702)
+++ stable/HeuristicLab.DataPreprocessing/3.4/Implementations/SearchLogic.cs	(revision 12718)
@@ -23,9 +23,9 @@
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace HeuristicLab.DataPreprocessing {
   public class SearchLogic : ISearchLogic {
     private readonly ITransactionalPreprocessingData preprocessingData;
+    private readonly IFilterLogic filterLogic;
 
     private Dictionary<int, IList<int>> MissingValueIndicies { get; set; }
@@ -44,15 +44,24 @@
     }
 
-    public SearchLogic(ITransactionalPreprocessingData thePreprocessingData) {
+    public SearchLogic(ITransactionalPreprocessingData thePreprocessingData, IFilterLogic theFilterLogic) {
       preprocessingData = thePreprocessingData;
+      filterLogic = theFilterLogic;
 
       MissingValueIndicies = new Dictionary<int, IList<int>>();
       ValuesWithoutNaN = new Dictionary<int, IList>();
 
-      preprocessingData.Changed += preprocessingData_Changed;
+      preprocessingData.Changed += PreprocessingData_Changed;
+      filterLogic.FilterChanged += FilterLogic_FilterChanged;
     }
 
-    void preprocessingData_Changed(object sender, DataPreprocessingChangedEventArgs e)
-    {
+    void FilterLogic_FilterChanged(object sender, EventArgs e) {
+      //recalculate
+      for (int i = 0; i < Columns; i++) {
+        MissingValueIndicies.Remove(i);
+        ValuesWithoutNaN.Remove(i);
+      }
+    }
+
+    void PreprocessingData_Changed(object sender, DataPreprocessingChangedEventArgs e) {
       switch (e.Type) {
         case DataPreprocessingChangedEventType.DeleteColumn:
@@ -73,5 +82,5 @@
           ValuesWithoutNaN = new Dictionary<int, IList>();
           break;
-      } 
+      }
     }
 
@@ -97,22 +106,22 @@
 
     public IList<int> GetMissingValueIndices(int columnIndex) {
-      if (!MissingValueIndicies.ContainsKey(columnIndex)){        
-          if (preprocessingData.VariableHasType<double>(columnIndex)) {
-            MissingValueIndicies[columnIndex] = GetMissingValueIndices<double>(columnIndex);
-          } else if (preprocessingData.VariableHasType<string>(columnIndex)) {
-            MissingValueIndicies[columnIndex] = GetMissingValueIndices<string>(columnIndex);
-          } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
-            MissingValueIndicies[columnIndex] = GetMissingValueIndices<DateTime>(columnIndex);
-          } else {
-            throw new ArgumentException("column " + columnIndex + " contains a non supported type.");
-          }
-      } 
+      if (!MissingValueIndicies.ContainsKey(columnIndex)) {
+        if (preprocessingData.VariableHasType<double>(columnIndex)) {
+          MissingValueIndicies[columnIndex] = GetMissingValueIndices<double>(columnIndex);
+        } else if (preprocessingData.VariableHasType<string>(columnIndex)) {
+          MissingValueIndicies[columnIndex] = GetMissingValueIndices<string>(columnIndex);
+        } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
+          MissingValueIndicies[columnIndex] = GetMissingValueIndices<DateTime>(columnIndex);
+        } else {
+          throw new ArgumentException("column " + columnIndex + " contains a non supported type.");
+        }
+      }
+      return MissingValueIndicies[columnIndex];
+    }
 
-      return MissingValueIndicies[columnIndex];
-   }
     private IList<int> GetMissingValueIndices<T>(int columnIndex) {
       List<int> missingIndices = new List<int>();
-     
-      for(int row = 0; row < preprocessingData.Rows; ++row) {
+
+      for (int row = 0; row < preprocessingData.Rows; ++row) {
         if (IsMissingValue(columnIndex, row)) {
           missingIndices.Add(row);
@@ -123,9 +132,8 @@
     }
 
-    public IEnumerable<T> GetValuesWithoutNaN<T>(int columnIndex, bool considerSelection)
-    {
-      if (considerSelection) {     
-        var selectedRows =  preprocessingData.Selection[columnIndex];
-        
+    public IEnumerable<T> GetValuesWithoutNaN<T>(int columnIndex, bool considerSelection) {
+      if (considerSelection) {
+        var selectedRows = preprocessingData.Selection[columnIndex];
+
         List<T> values = new List<T>();
         foreach (var rowIdx in selectedRows) {
Index: stable/HeuristicLab.DataPreprocessing/3.4/Implementations/StatisticsLogic.cs
===================================================================
--- stable/HeuristicLab.DataPreprocessing/3.4/Implementations/StatisticsLogic.cs	(revision 12702)
+++ stable/HeuristicLab.DataPreprocessing/3.4/Implementations/StatisticsLogic.cs	(revision 12718)
@@ -38,9 +38,9 @@
 
     public int GetColumnCount() {
-      return preprocessingData.Columns;
+      return searchLogic.Columns;
     }
 
     public int GetRowCount() {
-      return preprocessingData.Rows;
+      return searchLogic.Rows;
     }
 
@@ -48,5 +48,5 @@
       int count = 0;
 
-      for (int i = 0; i < preprocessingData.Columns; ++i) {
+      for (int i = 0; i < searchLogic.Columns; ++i) {
         if (preprocessingData.VariableHasType<double>(i)) {
           ++count;
@@ -57,10 +57,10 @@
 
     public int GetNominalColumnCount() {
-      return preprocessingData.Columns - GetNumericColumnCount();
+      return searchLogic.Columns - GetNumericColumnCount();
     }
 
     public int GetMissingValueCount() {
       int count = 0;
-      for (int i = 0; i < preprocessingData.Columns; ++i) {
+      for (int i = 0; i < searchLogic.Columns; ++i) {
         count += GetMissingValueCount(i);
       }
@@ -73,9 +73,23 @@
 
     public T GetMin<T>(int columnIndex, bool considerSelection) where T : IComparable<T> {
-      return preprocessingData.GetValues<T>(columnIndex, considerSelection).Min();
+      var min = default(T);
+      if (preprocessingData.VariableHasType<T>(columnIndex)) {
+        var values = GetValuesWithoutNaN<T>(columnIndex, considerSelection);
+        if (values.Any()) {
+          min = values.Min();
+        }
+      }
+      return min;
     }
 
     public T GetMax<T>(int columnIndex, bool considerSelection) where T : IComparable<T> {
-      return preprocessingData.GetValues<T>(columnIndex, considerSelection).Max();
+      var max = default(T);
+      if (preprocessingData.VariableHasType<T>(columnIndex)) {
+        var values = GetValuesWithoutNaN<T>(columnIndex, considerSelection);
+        if (values.Any()) {
+          max = values.Max();
+        }
+      }
+      return max;
     }
 
@@ -83,5 +97,8 @@
       double median = double.NaN;
       if (preprocessingData.VariableHasType<double>(columnIndex)) {
-        median = GetValuesWithoutNaN<double>(columnIndex, considerSelection).Median();
+        var values = GetValuesWithoutNaN<double>(columnIndex, considerSelection);
+        if (values.Any()) {
+          median = values.Median();
+        }
       }
       return median;
@@ -91,5 +108,8 @@
       double avg = double.NaN;
       if (preprocessingData.VariableHasType<double>(columnIndex)) {
-        avg = GetValuesWithoutNaN<double>(columnIndex, considerSelection).Average();
+        var values = GetValuesWithoutNaN<double>(columnIndex, considerSelection);
+        if (values.Any()) {
+          avg = values.Average();
+        }
       }
       return avg;
@@ -113,10 +133,8 @@
 
     public T GetMostCommonValue<T>(int columnIndex, bool considerSelection) {
-      var t = preprocessingData.GetValues<T>(columnIndex, considerSelection);
-      var t2 = t.GroupBy(x => x);
-      var t3 = t2.Select(g => g.Key);
-
-      return preprocessingData.GetValues<T>(columnIndex, considerSelection)
-                              .GroupBy(x => x)
+      var values = GetValuesWithoutNaN<T>(columnIndex, considerSelection);
+      if (!values.Any())
+        return default(T);
+      return values.GroupBy(x => x)
                               .OrderByDescending(g => g.Count())
                               .Select(g => g.Key)
