Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing.Views/3.3/DataGridContentView.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing.Views/3.3/DataGridContentView.cs	(revision 10589)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing.Views/3.3/DataGridContentView.cs	(revision 10590)
@@ -22,8 +22,9 @@
 using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 using System.Windows.Forms;
+using HeuristicLab.Data.Views;
 using HeuristicLab.MainForm;
+using System.Drawing;
 
 namespace HeuristicLab.DataPreprocessing.Views {
@@ -31,7 +32,4 @@
   [Content(typeof(IDataGridContent), true)]
   public partial class DataGridContentView : CopyOfStringConvertibleMatrixView {
-
-    private int lastClickedRow;
-    private int lastClickedColumn;
 
     private bool notOwnEvent = true;
@@ -123,8 +121,10 @@
           contextMenu.Show(MousePosition);
         } else {
+          if (!dataGridView.SelectedCells.Contains(dataGridView[e.ColumnIndex, e.RowIndex])) {
+            dataGridView.ClearSelection();
+            dataGridView[e.ColumnIndex, e.RowIndex].Selected = true;
+          }
           interpolationToolStripMenuItem.Enabled = !(e.RowIndex == 0 || e.RowIndex == Content.Rows);
           contextMenuCell.Show(MousePosition);
-          lastClickedColumn = e.ColumnIndex;
-          lastClickedRow = e.RowIndex;
         }
       }
@@ -175,22 +175,34 @@
     }
 
+    private Dictionary<int, List<int>> GetSelectedCells() {
+      var selectedCells = new Dictionary<int, List<int>>();
+      for (int i = 0; i < dataGridView.SelectedCells.Count; i++) {
+        var columnIndex=dataGridView.SelectedCells[i].ColumnIndex;
+        if(!selectedCells.ContainsKey(columnIndex)){
+          selectedCells.Add(columnIndex,new List<int>());
+        }
+        selectedCells[columnIndex].Add(dataGridView.SelectedCells[i].RowIndex);
+      }
+      return selectedCells;
+    }
+
     private void ReplaceWithAverage_Click(object sender, EventArgs e) {
-      Content.PreprocessingDataManipulation.ReplaceIndicesByAverageValue(lastClickedColumn, new List<int>() { lastClickedRow });
+      Content.PreprocessingDataManipulation.ReplaceIndicesByAverageValue(GetSelectedCells());
     }
 
     private void ReplaceWithMedian_Click(object sender, EventArgs e) {
-      Content.PreprocessingDataManipulation.ReplaceIndicesByMedianValue(lastClickedColumn, new List<int>() { lastClickedRow });
+      Content.PreprocessingDataManipulation.ReplaceIndicesByMedianValue(GetSelectedCells());
     }
 
     private void ReplaceWithRandom_Click(object sender, EventArgs e) {
-      Content.PreprocessingDataManipulation.ReplaceIndicesByRandomValue(lastClickedColumn, new List<int>() { lastClickedRow });
+      Content.PreprocessingDataManipulation.ReplaceIndicesByRandomValue(GetSelectedCells());
     }
 
     private void ReplaceWithMostCommon_Click(object sender, EventArgs e) {
-      Content.PreprocessingDataManipulation.ReplaceIndicesByMostCommonValue(lastClickedColumn, new List<int>() { lastClickedRow });
+      Content.PreprocessingDataManipulation.ReplaceIndicesByMostCommonValue(GetSelectedCells());
     }
 
     private void ReplaceWithInterpolation_Click(object sender, EventArgs e) {
-      Content.PreprocessingDataManipulation.ReplaceIndicesByLinearInterpolationOfNeighbours(lastClickedColumn, new List<int>() { lastClickedRow });
+      Content.PreprocessingDataManipulation.ReplaceIndicesByLinearInterpolationOfNeighbours(GetSelectedCells());
     }
   }
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/ManipulationLogic.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/ManipulationLogic.cs	(revision 10589)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Implementations/ManipulationLogic.cs	(revision 10590)
@@ -43,51 +43,67 @@
     }
 
-    public void ReplaceIndicesByAverageValue(int columnIndex, IEnumerable<int> rowIndices) {
-      double average = statisticInfo.GetAverage(columnIndex);
-      ReplaceIndicesByValue<double>(columnIndex, rowIndices, average);
-    }
-
-    public void ReplaceIndicesByMedianValue(int columnIndex, IEnumerable<int> rowIndices) {
-      double median = statisticInfo.GetMedian(columnIndex);
-      ReplaceIndicesByValue<double>(columnIndex, rowIndices, median);
-    }
-
-    public void ReplaceIndicesByRandomValue(int columnIndex, IEnumerable<int> rowIndices) {
+    public void ReplaceIndicesByAverageValue(Dictionary<int, List<int>> cells) {
+      preprocessingData.BeginTransaction();
+      foreach (var column in cells) {
+        double average = statisticInfo.GetAverage(column.Key);
+        ReplaceIndicesByValue<double>(column.Key, column.Value, average);
+      }
+      preprocessingData.EndTransaction();
+    }
+
+    public void ReplaceIndicesByMedianValue(Dictionary<int, List<int>> cells) {
+      preprocessingData.BeginTransaction();
+      foreach (var column in cells) {
+        double median = statisticInfo.GetMedian(column.Key);
+        ReplaceIndicesByValue<double>(column.Key, column.Value, median);
+      }
+      preprocessingData.EndTransaction();
+    }
+
+    public void ReplaceIndicesByRandomValue(Dictionary<int, List<int>> cells) {
+      preprocessingData.BeginTransaction();
       Random r = new Random();
 
-      double max = statisticInfo.GetMax<double>(columnIndex);
-      double min = statisticInfo.GetMin<double>(columnIndex);
-      double randMultiplier = (max - min);
-      foreach (int index in rowIndices) {
-        double rand = r.NextDouble() * randMultiplier + min;
-        preprocessingData.SetCell<double>(columnIndex, index, rand);
-      }
-    }
-
-    public void ReplaceIndicesByLinearInterpolationOfNeighbours(int columnIndex, IEnumerable<int> rowIndices) {
-      int countValues = preprocessingData.GetValues<double>(columnIndex).Count();
-      foreach (int index in rowIndices) {
-        // dont replace first or last values
-        if (index > 0 && index < countValues) {
-          int prevIndex = indexOfPrevPresentValue(columnIndex, index);
-          int nextIndex = indexOfNextPresentValue(columnIndex, index);
-
-          // no neighbours found
-          if (prevIndex < 0 && nextIndex >= countValues) {
-            continue;
+      foreach (var column in cells) {
+        double max = statisticInfo.GetMax<double>(column.Key);
+        double min = statisticInfo.GetMin<double>(column.Key);
+        double randMultiplier = (max - min);
+        foreach (int index in column.Value) {
+          double rand = r.NextDouble() * randMultiplier + min;
+          preprocessingData.SetCell<double>(column.Key, index, rand);
+        }
+      }
+      preprocessingData.EndTransaction();
+    }
+
+    public void ReplaceIndicesByLinearInterpolationOfNeighbours(Dictionary<int, List<int>> cells) {
+      preprocessingData.BeginTransaction();
+      foreach (var column in cells) {
+        int countValues = preprocessingData.GetValues<double>(column.Key).Count();
+        foreach (int index in column.Value) {
+          // dont replace first or last values
+          if (index > 0 && index < countValues) {
+            int prevIndex = indexOfPrevPresentValue(column.Key, index);
+            int nextIndex = indexOfNextPresentValue(column.Key, index);
+
+            // no neighbours found
+            if (prevIndex < 0 && nextIndex >= countValues) {
+              continue;
+            }
+            double prev = preprocessingData.GetCell<double>(column.Key, prevIndex);
+            double next = preprocessingData.GetCell<double>(column.Key, nextIndex);
+
+            int valuesToInterpolate = nextIndex - prevIndex;
+
+            double interpolationStep = (prev + next) / valuesToInterpolate;
+
+            for (int i = prevIndex; i < nextIndex; ++i) {
+              double interpolated = prev + (interpolationStep * (i - prevIndex));
+              preprocessingData.SetCell<double>(column.Key, i, interpolated);
+            }
           }
-          double prev = preprocessingData.GetCell<double>(columnIndex, prevIndex);
-          double next = preprocessingData.GetCell<double>(columnIndex, nextIndex);
-
-          int valuesToInterpolate = nextIndex - prevIndex;
-
-          double interpolationStep = (prev + next) / valuesToInterpolate;
-
-          for (int i = prevIndex; i < nextIndex; ++i) {
-            double interpolated = prev + (interpolationStep * (i - prevIndex));
-            preprocessingData.SetCell<double>(columnIndex, i, interpolated);
-          }
-        }
-      }
+        }
+      }
+      preprocessingData.EndTransaction();
     }
 
@@ -110,14 +126,18 @@
     }
 
-    public void ReplaceIndicesByMostCommonValue(int columnIndex, IEnumerable<int> rowIndices) {
-      if (preprocessingData.IsType<double>(columnIndex)) {
-        ReplaceIndicesByValue<double>(columnIndex, rowIndices, statisticInfo.GetMostCommonValue<double>(columnIndex));
-      } else if (preprocessingData.IsType<string>(columnIndex)) {
-        ReplaceIndicesByValue<string>(columnIndex, rowIndices, statisticInfo.GetMostCommonValue<string>(columnIndex));
-      } else if (preprocessingData.IsType<DateTime>(columnIndex)) {
-        ReplaceIndicesByValue<DateTime>(columnIndex, rowIndices, statisticInfo.GetMostCommonValue<DateTime>(columnIndex));
-      } else {
-        throw new ArgumentException("column with index: " + columnIndex + " contains a non supported type.");
-      }
+    public void ReplaceIndicesByMostCommonValue(Dictionary<int, List<int>> cells) {
+      preprocessingData.BeginTransaction();
+      foreach (var column in cells) {
+        if (preprocessingData.IsType<double>(column.Key)) {
+          ReplaceIndicesByValue<double>(column.Key, column.Value, statisticInfo.GetMostCommonValue<double>(column.Key));
+        } else if (preprocessingData.IsType<string>(column.Key)) {
+          ReplaceIndicesByValue<string>(column.Key, column.Value, statisticInfo.GetMostCommonValue<string>(column.Key));
+        } else if (preprocessingData.IsType<DateTime>(column.Key)) {
+          ReplaceIndicesByValue<DateTime>(column.Key, column.Value, statisticInfo.GetMostCommonValue<DateTime>(column.Key));
+        } else {
+          throw new ArgumentException("column with index: " + column.Key + " contains a non supported type.");
+        }
+      }
+      preprocessingData.EndTransaction();
     }
 
Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IManipulationLogic.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IManipulationLogic.cs	(revision 10589)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.3/Interfaces/IManipulationLogic.cs	(revision 10590)
@@ -27,9 +27,9 @@
     void ReOrderToIndices(IEnumerable<int> indices);
     void ReOrderToIndices(IList<Tuple<int, int>> indices);
-    void ReplaceIndicesByAverageValue(int columnIndex, IEnumerable<int> rowIndices);
-    void ReplaceIndicesByLinearInterpolationOfNeighbours(int columnIndex, IEnumerable<int> rowIndices);
-    void ReplaceIndicesByMedianValue(int columnIndex, IEnumerable<int> rowIndices);
-    void ReplaceIndicesByMostCommonValue(int columnIndex, IEnumerable<int> rowIndices);
-    void ReplaceIndicesByRandomValue(int columnIndex, IEnumerable<int> rowIndices);
+    void ReplaceIndicesByAverageValue(Dictionary<int, List<int>> cells);
+    void ReplaceIndicesByLinearInterpolationOfNeighbours(Dictionary<int, List<int>> cells);
+    void ReplaceIndicesByMedianValue(Dictionary<int, List<int>> cells);
+    void ReplaceIndicesByMostCommonValue(Dictionary<int, List<int>> cells);
+    void ReplaceIndicesByRandomValue(Dictionary<int, List<int>> cells);
     void ReplaceIndicesByValue<T>(int columnIndex, IEnumerable<int> rowIndices, T value);
     void ShuffleWithRanges(IEnumerable<HeuristicLab.Data.IntRange> ranges);
