Index: Core/Components/src/Core.Components.Charting.Forms/IChartControl.cs
===================================================================
diff -u -rf04895089d34bddb618db8c7001c574428be10c6 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.Charting.Forms/IChartControl.cs	(.../IChartControl.cs)	(revision f04895089d34bddb618db8c7001c574428be10c6)
+++ Core/Components/src/Core.Components.Charting.Forms/IChartControl.cs	(.../IChartControl.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -41,7 +41,7 @@
         /// <summary>
         /// Gets or sets the data to show in the <see cref="IChartControl"/>.
         /// </summary>
-        ChartDataCollection Data { get; }
+        ChartDataCollection Data { get; set; }
 
         /// <summary>
         /// Gets or sets the title of the chart.
@@ -72,10 +72,5 @@
         /// Zooms to a level so that everything is in view.
         /// </summary>
         void ZoomToAll();
-
-        /// <summary>
-        /// Sets the data of the chart to <c>null</c>.
-        /// </summary>
-        void ResetChartData();
     }
 }
\ No newline at end of file
Index: Core/Components/src/Core.Components.Charting/Core.Components.Charting.csproj
===================================================================
diff -u -r1795be9025cb0e054dca86a5275203966c0a9b2a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.Charting/Core.Components.Charting.csproj	(.../Core.Components.Charting.csproj)	(revision 1795be9025cb0e054dca86a5275203966c0a9b2a)
+++ Core/Components/src/Core.Components.Charting/Core.Components.Charting.csproj	(.../Core.Components.Charting.csproj)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -44,6 +44,7 @@
     <Compile Include="Data\ChartLineData.cs" />
     <Compile Include="Data\ChartMultipleAreaData.cs" />
     <Compile Include="Data\ChartPointData.cs" />
+    <Compile Include="Data\ItemBasedChartData.cs" />
     <Compile Include="Data\PointBasedChartData.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Styles\ChartAreaStyle.cs" />
Index: Core/Components/src/Core.Components.Charting/Data/ChartMultipleAreaData.cs
===================================================================
diff -u -r38ee40c1f98ff4b1921d4de64fd032c8fbcadf92 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.Charting/Data/ChartMultipleAreaData.cs	(.../ChartMultipleAreaData.cs)	(revision 38ee40c1f98ff4b1921d4de64fd032c8fbcadf92)
+++ Core/Components/src/Core.Components.Charting/Data/ChartMultipleAreaData.cs	(.../ChartMultipleAreaData.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -30,7 +30,7 @@
     /// <summary>
     /// This class represents data in 2D space which forms multiple closed areas.
     /// </summary>
-    public class ChartMultipleAreaData : ChartData
+    public class ChartMultipleAreaData : ItemBasedChartData
     {
         private IEnumerable<Point2D[]> areas;
 
Index: Core/Components/src/Core.Components.Charting/Data/ItemBasedChartData.cs
===================================================================
diff -u
--- Core/Components/src/Core.Components.Charting/Data/ItemBasedChartData.cs	(revision 0)
+++ Core/Components/src/Core.Components.Charting/Data/ItemBasedChartData.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,39 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+
+namespace Core.Components.Charting.Data
+{
+    /// <summary>
+    /// Base class for <see cref="ChartData"/> that contains items like points or areas.
+    /// </summary>
+    public abstract class ItemBasedChartData : ChartData
+    {
+        /// <summary>
+        /// Creates a new instance of <see cref="ItemBasedChartData"/>.
+        /// </summary>
+        /// <param name="name">The name of the <see cref="ItemBasedChartData"/>.</param>
+        /// <exception cref="ArgumentException">Thrown when <paramref name="name"/> is 
+        /// <c>null</c> or only whitespace.</exception>
+        protected ItemBasedChartData(string name) : base(name) {}
+    }
+}
\ No newline at end of file
Index: Core/Components/src/Core.Components.Charting/Data/PointBasedChartData.cs
===================================================================
diff -u -r38ee40c1f98ff4b1921d4de64fd032c8fbcadf92 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.Charting/Data/PointBasedChartData.cs	(.../PointBasedChartData.cs)	(revision 38ee40c1f98ff4b1921d4de64fd032c8fbcadf92)
+++ Core/Components/src/Core.Components.Charting/Data/PointBasedChartData.cs	(.../PointBasedChartData.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -25,9 +25,9 @@
 namespace Core.Components.Charting.Data
 {
     /// <summary>
-    /// Base class for <see cref="ChartData"/> which is based on an array of points in 2D space.
+    /// Base class for <see cref="ItemBasedChartData"/> that is based on an array of points in 2D space.
     /// </summary>
-    public abstract class PointBasedChartData : ChartData
+    public abstract class PointBasedChartData : ItemBasedChartData
     {
         private Point2D[] points;
 
Index: Core/Components/src/Core.Components.DotSpatial.Forms/MapControl.cs
===================================================================
diff -u -r2cafb330e0b90d1103bc9329eafbcba24836787f -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.DotSpatial.Forms/MapControl.cs	(.../MapControl.cs)	(revision 2cafb330e0b90d1103bc9329eafbcba24836787f)
+++ Core/Components/src/Core.Components.DotSpatial.Forms/MapControl.cs	(.../MapControl.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -227,7 +227,7 @@
 
             drawnMapDataLookup = drawnMapDataList.ToDictionary(dmd => dmd.FeatureBasedMapData, dmd => dmd);
 
-            MoveMapDataOnCollectionChange(mapDataThatShouldBeDrawn, drawnMapDataLookup);
+            ReorderMapDataOnCollectionChange(mapDataThatShouldBeDrawn, drawnMapDataLookup);
         }
 
         private void DrawMissingMapDataOnCollectionChange(IEnumerable<FeatureBasedMapData> mapDataThatShouldBeDrawn,
@@ -248,8 +248,8 @@
             }
         }
 
-        private void MoveMapDataOnCollectionChange(IList<FeatureBasedMapData> mapDataThatShouldBeDrawn,
-                                                   IDictionary<FeatureBasedMapData, DrawnMapData> drawnMapDataLookup)
+        private void ReorderMapDataOnCollectionChange(IList<FeatureBasedMapData> mapDataThatShouldBeDrawn,
+                                                      IDictionary<FeatureBasedMapData, DrawnMapData> drawnMapDataLookup)
         {
             for (var i = 0; i < mapDataThatShouldBeDrawn.Count; i++)
             {
@@ -287,21 +287,21 @@
 
         private static IEnumerable<FeatureBasedMapData> GetFeatureBasedMapDataRecursively(MapDataCollection mapDataCollection)
         {
-            var featureBaseMapDataList = new List<FeatureBasedMapData>();
+            var featureBasedMapDataList = new List<FeatureBasedMapData>();
 
             foreach (MapData mapData in mapDataCollection.Collection)
             {
                 var nestedMapDataCollection = mapData as MapDataCollection;
                 if (nestedMapDataCollection != null)
                 {
-                    featureBaseMapDataList.AddRange(GetFeatureBasedMapDataRecursively(nestedMapDataCollection));
+                    featureBasedMapDataList.AddRange(GetFeatureBasedMapDataRecursively(nestedMapDataCollection));
                     continue;
                 }
 
-                featureBaseMapDataList.Add((FeatureBasedMapData) mapData);
+                featureBasedMapDataList.Add((FeatureBasedMapData) mapData);
             }
 
-            return featureBaseMapDataList;
+            return featureBasedMapDataList;
         }
 
         private void MapFunctionActivateFunction(object sender, EventArgs e)
Index: Core/Components/src/Core.Components.DotSpatial/Converter/FeatureBasedMapDataConverter.cs
===================================================================
diff -u -r7ab976b1a6799058565681fd87400d48fc72f140 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.DotSpatial/Converter/FeatureBasedMapDataConverter.cs	(.../FeatureBasedMapDataConverter.cs)	(revision 7ab976b1a6799058565681fd87400d48fc72f140)
+++ Core/Components/src/Core.Components.DotSpatial/Converter/FeatureBasedMapDataConverter.cs	(.../FeatureBasedMapDataConverter.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -121,7 +121,7 @@
         {
             if (data == null)
             {
-                throw new ArgumentNullException("data", @"Null data cannot be converted into a feature layer data.");
+                throw new ArgumentNullException("data", @"Null data cannot be converted into feature layer data.");
             }
 
             if (layer == null)
Index: Core/Components/src/Core.Components.OxyPlot.Forms/ChartControl.cs
===================================================================
diff -u -r640df7c0609a81e19cc3661323ee461d801049b0 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.OxyPlot.Forms/ChartControl.cs	(.../ChartControl.cs)	(revision 640df7c0609a81e19cc3661323ee461d801049b0)
+++ Core/Components/src/Core.Components.OxyPlot.Forms/ChartControl.cs	(.../ChartControl.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -19,26 +19,29 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
-using System.ComponentModel;
+using System.Collections.Generic;
 using System.Drawing;
+using System.Linq;
 using System.Windows.Forms;
 using Core.Common.Base;
 using Core.Components.Charting.Data;
 using Core.Components.Charting.Forms;
-using Core.Components.OxyPlot.Converter;
-using OxyPlot.WindowsForms;
+using Core.Components.OxyPlot.DataSeries;
+using OxyPlot.Series;
 
 namespace Core.Components.OxyPlot.Forms
 {
     /// <summary>
     /// This class describes a plot view with configured representation of axes.
     /// </summary>
-    public sealed class ChartControl : Control, IObserver, IChartControl
+    public sealed class ChartControl : Control, IChartControl
     {
-        private readonly ChartSeriesFactory seriesFactory = new ChartSeriesFactory();
+        private readonly RecursiveObserver<ChartDataCollection, ChartDataCollection> chartDataCollectionObserver;
+        private readonly IList<DrawnChartData> drawnChartDataList = new List<DrawnChartData>();
 
-        private LinearPlotView view;
-        private DynamicPlotController controller;
+        private LinearPlotView plotView;
+        private DynamicPlotController plotController;
+        private ChartDataCollection data;
 
         /// <summary>
         /// Creates a new instance of <see cref="ChartControl"/>.
@@ -48,125 +51,264 @@
             InitializePlotView();
             MinimumSize = new Size(100, 100);
 
-            Data = new ChartDataCollection("Root");
-            Data.Attach(this);
-
-            DrawSeries();
+            chartDataCollectionObserver = new RecursiveObserver<ChartDataCollection, ChartDataCollection>(HandleChartDataCollectionChange, cdc => cdc.Collection);
         }
 
-        /// <summary>
-        /// Initialize the <see cref="PlotView"/> for the <see cref="ChartControl"/>.
-        /// </summary>
-        private void InitializePlotView()
+        public ChartDataCollection Data
         {
-            view = new LinearPlotView
+            get
             {
-                BackColor = Color.White
-            };
+                return data;
+            }
+            set
+            {
+                if (data != null)
+                {
+                    ClearChartData();
+                }
 
-            controller = new DynamicPlotController();
-            view.Controller = controller;
-            Controls.Add(view);
-        }
+                data = value;
 
-        /// <summary>
-        /// Draws series based on the currently set <see cref="Data"/>.
-        /// </summary>
-        private void DrawSeries()
-        {
-            view.Model.Series.Clear();
-            if (Data != null)
-            {
-                foreach (var series in seriesFactory.Create(Data))
+                chartDataCollectionObserver.Observable = data;
+
+                if (data != null)
                 {
-                    view.Model.Series.Add(series);
+                    DrawInitialChartData();
                 }
             }
-            view.InvalidatePlot(true);
         }
 
-        #region IChart
-
-        public bool IsPanningEnabled
+        public string ChartTitle
         {
             get
             {
-                return controller.IsPanningEnabled;
+                return plotView.ModelTitle;
             }
-        }
-
-        public bool IsRectangleZoomingEnabled
-        {
-            get
+            set
             {
-                return controller.IsRectangleZoomingEnabled;
+                plotView.ModelTitle = value;
             }
         }
 
-        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
-        public ChartDataCollection Data { get; private set; }
-
-        public string ChartTitle
+        public string BottomAxisTitle
         {
             get
             {
-                return view.ModelTitle;
+                return plotView.BottomAxisTitle;
             }
             set
             {
-                view.ModelTitle = value;
+                plotView.BottomAxisTitle = value;
             }
         }
 
-        public string BottomAxisTitle
+        public string LeftAxisTitle
         {
             get
             {
-                return view.BottomAxisTitle;
+                return plotView.LeftAxisTitle;
             }
             set
             {
-                view.BottomAxisTitle = value;
+                plotView.LeftAxisTitle = value;
             }
         }
 
-        public string LeftAxisTitle
+        public bool IsPanningEnabled
         {
             get
             {
-                return view.LeftAxisTitle;
+                return plotController.IsPanningEnabled;
             }
-            set
+        }
+
+        public bool IsRectangleZoomingEnabled
+        {
+            get
             {
-                view.LeftAxisTitle = value;
+                return plotController.IsRectangleZoomingEnabled;
             }
         }
 
         public void TogglePanning()
         {
-            controller.TogglePanning();
+            plotController.TogglePanning();
         }
 
         public void ToggleRectangleZooming()
         {
-            controller.ToggleRectangleZooming();
+            plotController.ToggleRectangleZooming();
         }
 
         public void ZoomToAll()
         {
-            view.ZoomToAll();
+            plotView.ZoomToAll();
         }
 
-        public void UpdateObserver()
+        protected override void Dispose(bool disposing)
         {
-            DrawSeries();
+            plotView.Dispose();
+            chartDataCollectionObserver.Dispose();
+
+            base.Dispose(disposing);
         }
 
-        public void ResetChartData()
+        private void InitializePlotView()
         {
-            Data = null;
+            plotView = new LinearPlotView
+            {
+                BackColor = Color.White,
+                Model =
+                {
+                    IsLegendVisible = false
+                }
+            };
+
+            plotController = new DynamicPlotController();
+            plotView.Controller = plotController;
+
+            Controls.Add(plotView);
         }
 
-        #endregion
+        private static IEnumerable<ItemBasedChartData> GetItemBasedChartDataRecursively(ChartDataCollection chartDataCollection)
+        {
+            var itemBasedChartDataList = new List<ItemBasedChartData>();
+
+            foreach (ChartData chartData in chartDataCollection.Collection)
+            {
+                var nestedChartDataCollection = chartData as ChartDataCollection;
+                if (nestedChartDataCollection != null)
+                {
+                    itemBasedChartDataList.AddRange(GetItemBasedChartDataRecursively(nestedChartDataCollection));
+                    continue;
+                }
+
+                itemBasedChartDataList.Add((ItemBasedChartData) chartData);
+            }
+
+            return itemBasedChartDataList;
+        }
+
+        private void HandleChartDataCollectionChange()
+        {
+            var chartDataThatShouldBeDrawn = GetItemBasedChartDataRecursively(Data).ToList();
+            var drawnChartDataLookup = drawnChartDataList.ToDictionary(dcd => dcd.ItemBasedChartData, dcd => dcd);
+
+            DrawMissingChartDataOnCollectionChange(chartDataThatShouldBeDrawn, drawnChartDataLookup);
+            RemoveRedundantChartDataOnCollectionChange(chartDataThatShouldBeDrawn, drawnChartDataLookup);
+
+            drawnChartDataLookup = drawnChartDataList.ToDictionary(dcd => dcd.ItemBasedChartData, dcd => dcd);
+
+            ReorderChartDataOnCollectionChange(chartDataThatShouldBeDrawn, drawnChartDataLookup);
+
+            plotView.InvalidatePlot(true);
+        }
+
+        private void DrawMissingChartDataOnCollectionChange(IEnumerable<ItemBasedChartData> chartDataThatShouldBeDrawn,
+                                                            IDictionary<ItemBasedChartData, DrawnChartData> drawnChartDataLookup)
+        {
+            foreach (var chartDataToDraw in chartDataThatShouldBeDrawn)
+            {
+                if (!drawnChartDataLookup.ContainsKey(chartDataToDraw))
+                {
+                    DrawChartData(chartDataToDraw);
+                }
+            }
+        }
+
+        private void RemoveRedundantChartDataOnCollectionChange(IEnumerable<ItemBasedChartData> chartDataThatShouldBeDrawn,
+                                                                IDictionary<ItemBasedChartData, DrawnChartData> drawnChartDataLookup)
+        {
+            foreach (var itemBasedChartData in drawnChartDataLookup.Keys.Except(chartDataThatShouldBeDrawn))
+            {
+                RemoveChartData(drawnChartDataLookup[itemBasedChartData]);
+            }
+        }
+
+        private void ReorderChartDataOnCollectionChange(IEnumerable<ItemBasedChartData> chartDataThatShouldBeDrawn,
+                                                        IDictionary<ItemBasedChartData, DrawnChartData> drawnChartDataLookup)
+        {
+            plotView.Model.Series.Clear();
+
+            foreach (ItemBasedChartData itemBasedChartData in chartDataThatShouldBeDrawn)
+            {
+                plotView.Model.Series.Add((Series) drawnChartDataLookup[itemBasedChartData].ItemBasedChartDataSeries);
+            }
+        }
+
+        private void RemoveChartData(DrawnChartData drawnChartDataToRemove)
+        {
+            drawnChartDataToRemove.Observer.Dispose();
+            drawnChartDataList.Remove(drawnChartDataToRemove);
+
+            plotView.Model.Series.Remove((Series) drawnChartDataToRemove.ItemBasedChartDataSeries);
+        }
+
+        private void DrawInitialChartData()
+        {
+            foreach (var itemBasedChartData in GetItemBasedChartDataRecursively(Data))
+            {
+                DrawChartData(itemBasedChartData);
+            }
+
+            plotView.InvalidatePlot(true);
+        }
+
+        private void DrawChartData(ItemBasedChartData itemBasedChartData)
+        {
+            var itemBasedChartDataSeries = ItemBasedChartDataSeriesFactory.Create(itemBasedChartData);
+
+            var drawnChartData = new DrawnChartData
+            {
+                ItemBasedChartData = itemBasedChartData,
+                ItemBasedChartDataSeries = itemBasedChartDataSeries
+            };
+
+            drawnChartData.Observer = new Observer(() =>
+            {
+                drawnChartData.ItemBasedChartDataSeries.Update();
+                plotView.InvalidatePlot(true);
+            })
+            {
+                Observable = itemBasedChartData
+            };
+
+            drawnChartDataList.Add(drawnChartData);
+
+            plotView.Model.Series.Add((Series) itemBasedChartDataSeries);
+        }
+
+        private void ClearChartData()
+        {
+            foreach (DrawnChartData drawnChartData in drawnChartDataList)
+            {
+                drawnChartData.Observer.Dispose();
+            }
+
+            drawnChartDataList.Clear();
+
+            plotView.Model.Series.Clear();
+        }
+
+        /// <summary>
+        /// Lookup class for administration related to drawn chart data series.
+        /// </summary>
+        private class DrawnChartData
+        {
+            /// <summary>
+            /// The item based chart data which the drawn <see cref="ItemBasedChartDataSeries"/> is based upon.
+            /// </summary>
+            public ItemBasedChartData ItemBasedChartData { get; set; }
+
+            /// <summary>
+            /// The drawn chart data series.
+            /// </summary>
+            public IItemBasedChartDataSeries ItemBasedChartDataSeries { get; set; }
+
+            /// <summary>
+            /// The observer attached to <see cref="ItemBasedChartData"/> and responsible for updating <see cref="ItemBasedChartDataSeries"/>.
+            /// </summary>
+            public Observer Observer { get; set; }
+        }
     }
 }
\ No newline at end of file
Index: Core/Components/src/Core.Components.OxyPlot/Converter/ChartAreaDataConverter.cs
===================================================================
diff -u -red96d38a758365e4c0f117def83a2926c589c18a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.OxyPlot/Converter/ChartAreaDataConverter.cs	(.../ChartAreaDataConverter.cs)	(revision ed96d38a758365e4c0f117def83a2926c589c18a)
+++ Core/Components/src/Core.Components.OxyPlot/Converter/ChartAreaDataConverter.cs	(.../ChartAreaDataConverter.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -19,49 +19,38 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
-using System.Collections.Generic;
+using System.Linq;
 using Core.Components.Charting.Data;
-using Core.Components.Charting.Styles;
+using OxyPlot;
 using OxyPlot.Series;
 
 namespace Core.Components.OxyPlot.Converter
 {
     /// <summary>
-    /// This class converts <see cref="ChartAreaData"/> into <see cref="AreaSeries"/>.
+    /// The converter that converts <see cref="ChartAreaData"/> data into <see cref="AreaSeries"/> data.
     /// </summary>
-    public class ChartAreaDataConverter : ChartDataConverter<ChartAreaData>
+    public class ChartAreaDataConverter : ItemBasedChartDataConverter<ChartAreaData, AreaSeries>
     {
-        protected override IList<Series> Convert(ChartAreaData data)
+        protected override void SetSeriesItems(ChartAreaData data, AreaSeries series)
         {
-            var series = new AreaSeries
-            {
-                IsVisible = data.IsVisible,
-                Tag = data
-            };
-            foreach (var p in data.Points)
-            {
-                series.Points.Add(Point2DToDataPoint(p));
-            }
+            series.Points.Clear();
+            series.Points2.Clear();
+
+            series.Points.AddRange(data.Points.Select(p => new DataPoint(p.X, p.Y)));
+
             if (series.Points.Count > 0)
             {
                 series.Points2.Add(series.Points[0]);
             }
-
-            CreateStyle(series, data.Style);
-
-            return new List<Series>
-            {
-                series
-            };
         }
 
-        private static void CreateStyle(AreaSeries series, ChartAreaStyle style)
+        protected override void SetSeriesStyle(ChartAreaData data, AreaSeries series)
         {
-            if (style != null)
+            if (data.Style != null)
             {
-                series.Fill = ChartDataHelper.Convert(style.FillColor);
-                series.Color = ChartDataHelper.Convert(style.StrokeColor);
-                series.StrokeThickness = style.Width;
+                series.Fill = ChartDataHelper.Convert(data.Style.FillColor);
+                series.Color = ChartDataHelper.Convert(data.Style.StrokeColor);
+                series.StrokeThickness = data.Style.Width;
             }
         }
     }
Fisheye: Tag 4dbfc20ef0200e34db43efeb8899d72e4046cc5b refers to a dead (removed) revision in file `Core/Components/src/Core.Components.OxyPlot/Converter/ChartDataCollectionConverter.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 4dbfc20ef0200e34db43efeb8899d72e4046cc5b refers to a dead (removed) revision in file `Core/Components/src/Core.Components.OxyPlot/Converter/ChartDataConverter.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Core/Components/src/Core.Components.OxyPlot/Converter/ChartLineDataConverter.cs
===================================================================
diff -u -red96d38a758365e4c0f117def83a2926c589c18a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.OxyPlot/Converter/ChartLineDataConverter.cs	(.../ChartLineDataConverter.cs)	(revision ed96d38a758365e4c0f117def83a2926c589c18a)
+++ Core/Components/src/Core.Components.OxyPlot/Converter/ChartLineDataConverter.cs	(.../ChartLineDataConverter.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -19,44 +19,30 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
-using System.Collections.Generic;
 using System.Linq;
 using Core.Components.Charting.Data;
-using Core.Components.Charting.Styles;
+using OxyPlot;
 using OxyPlot.Series;
 
 namespace Core.Components.OxyPlot.Converter
 {
     /// <summary>
-    /// This class converts <see cref="ChartLineData"/> into <see cref="LineSeries"/>.
+    /// The converter that converts <see cref="ChartLineData"/> data into <see cref="LineSeries"/> data.
     /// </summary>
-    public class ChartLineDataConverter : ChartDataConverter<ChartLineData>
+    public class ChartLineDataConverter : ItemBasedChartDataConverter<ChartLineData, LineSeries>
     {
-        protected override IList<Series> Convert(ChartLineData data)
+        protected override void SetSeriesItems(ChartLineData data, LineSeries series)
         {
-            var series = new LineSeries
-            {
-                ItemsSource = data.Points.ToArray(),
-                Mapping = Point2DToDataPoint,
-                IsVisible = data.IsVisible,
-                Tag = data
-            };
-
-            CreateStyle(series, data.Style);
-
-            return new List<Series>
-            {
-                series
-            };
+            series.ItemsSource = data.Points.Select(p => new DataPoint(p.X, p.Y));
         }
 
-        private static void CreateStyle(LineSeries series, ChartLineStyle style)
+        protected override void SetSeriesStyle(ChartLineData data, LineSeries series)
         {
-            if (style != null)
+            if (data.Style != null)
             {
-                series.Color = ChartDataHelper.Convert(style.Color);
-                series.StrokeThickness = style.Width;
-                series.LineStyle = ChartDataHelper.Convert(style.Style);
+                series.Color = ChartDataHelper.Convert(data.Style.Color);
+                series.StrokeThickness = data.Style.Width;
+                series.LineStyle = ChartDataHelper.Convert(data.Style.Style);
             }
         }
     }
Index: Core/Components/src/Core.Components.OxyPlot/Converter/ChartMultipleAreaDataConverter.cs
===================================================================
diff -u -red96d38a758365e4c0f117def83a2926c589c18a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.OxyPlot/Converter/ChartMultipleAreaDataConverter.cs	(.../ChartMultipleAreaDataConverter.cs)	(revision ed96d38a758365e4c0f117def83a2926c589c18a)
+++ Core/Components/src/Core.Components.OxyPlot/Converter/ChartMultipleAreaDataConverter.cs	(.../ChartMultipleAreaDataConverter.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -19,48 +19,35 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
-using System.Collections.Generic;
 using System.Linq;
 using Core.Components.Charting.Data;
-using Core.Components.Charting.Styles;
 using Core.Components.OxyPlot.CustomSeries;
-using OxyPlot.Series;
+using OxyPlot;
 
 namespace Core.Components.OxyPlot.Converter
 {
     /// <summary>
-    /// This class converts <see cref="ChartMultipleAreaData"/> into <see cref="MultipleAreaSeries"/>.
+    /// The converter that converts <see cref="ChartMultipleAreaData"/> data into <see cref="MultipleAreaSeries"/> data.
     /// </summary>
-    public class ChartMultipleAreaDataConverter : ChartDataConverter<ChartMultipleAreaData>
+    public class ChartMultipleAreaDataConverter : ItemBasedChartDataConverter<ChartMultipleAreaData, MultipleAreaSeries>
     {
-        protected override IList<Series> Convert(ChartMultipleAreaData data)
+        protected override void SetSeriesItems(ChartMultipleAreaData data, MultipleAreaSeries series)
         {
-            var series = new MultipleAreaSeries
-            {
-                IsVisible = data.IsVisible,
-                Tag = data
-            };
+            series.Areas.Clear();
 
             foreach (var area in data.Areas)
             {
-                series.Areas.Add(area.Select(Point2DToDataPoint).ToArray());
+                series.Areas.Add(area.Select(p => new DataPoint(p.X, p.Y)).ToArray());
             }
-
-            CreateStyle(series, data.Style);
-
-            return new List<Series>
-            {
-                series
-            };
         }
 
-        private static void CreateStyle(MultipleAreaSeries series, ChartAreaStyle style)
+        protected override void SetSeriesStyle(ChartMultipleAreaData data, MultipleAreaSeries series)
         {
-            if (style != null)
+            if (data.Style != null)
             {
-                series.Fill = ChartDataHelper.Convert(style.FillColor);
-                series.Color = ChartDataHelper.Convert(style.StrokeColor);
-                series.StrokeThickness = style.Width;
+                series.Fill = ChartDataHelper.Convert(data.Style.FillColor);
+                series.Color = ChartDataHelper.Convert(data.Style.StrokeColor);
+                series.StrokeThickness = data.Style.Width;
             }
         }
     }
Index: Core/Components/src/Core.Components.OxyPlot/Converter/ChartPointDataConverter.cs
===================================================================
diff -u -red96d38a758365e4c0f117def83a2926c589c18a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.OxyPlot/Converter/ChartPointDataConverter.cs	(.../ChartPointDataConverter.cs)	(revision ed96d38a758365e4c0f117def83a2926c589c18a)
+++ Core/Components/src/Core.Components.OxyPlot/Converter/ChartPointDataConverter.cs	(.../ChartPointDataConverter.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -19,49 +19,34 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
-using System.Collections.Generic;
 using System.Linq;
 using Core.Components.Charting.Data;
-using Core.Components.Charting.Styles;
 using OxyPlot;
 using OxyPlot.Series;
 
 namespace Core.Components.OxyPlot.Converter
 {
     /// <summary>
-    /// This class converts <see cref="ChartPointData"/> into <see cref="LineSeries"/> with point styling.
+    /// The converter that converts <see cref="ChartPointData"/> data into <see cref="LineSeries"/> data.
     /// </summary>
-    public class ChartPointDataConverter : ChartDataConverter<ChartPointData>
+    public class ChartPointDataConverter : ItemBasedChartDataConverter<ChartPointData, LineSeries>
     {
-        protected override IList<Series> Convert(ChartPointData data)
+        protected override void SetSeriesItems(ChartPointData data, LineSeries series)
         {
-            var series = new LineSeries
-            {
-                ItemsSource = data.Points.ToArray(),
-                IsVisible = data.IsVisible,
-                Mapping = Point2DToDataPoint,
-                LineStyle = LineStyle.None,
-                MarkerType = MarkerType.Circle,
-                Tag = data
-            };
-
-            CreateStyle(series, data.Style);
-
-            return new List<Series>
-            {
-                series
-            };
+            series.ItemsSource = data.Points.Select(p => new DataPoint(p.X, p.Y));
         }
 
-        private static void CreateStyle(LineSeries series, ChartPointStyle style)
+        protected override void SetSeriesStyle(ChartPointData data, LineSeries series)
         {
-            if (style != null)
+            series.LineStyle = LineStyle.None;
+
+            if (data.Style != null)
             {
-                series.MarkerFill = ChartDataHelper.Convert(style.Color);
-                series.MarkerSize = style.Size;
-                series.MarkerType = ChartDataHelper.Convert(style.Symbol);
-                series.MarkerStroke = ChartDataHelper.Convert(style.StrokeColor);
-                series.MarkerStrokeThickness = style.StrokeThickness;
+                series.MarkerFill = ChartDataHelper.Convert(data.Style.Color);
+                series.MarkerSize = data.Style.Size;
+                series.MarkerType = ChartDataHelper.Convert(data.Style.Symbol);
+                series.MarkerStroke = ChartDataHelper.Convert(data.Style.StrokeColor);
+                series.MarkerStrokeThickness = data.Style.StrokeThickness;
             }
         }
     }
Fisheye: Tag 4dbfc20ef0200e34db43efeb8899d72e4046cc5b refers to a dead (removed) revision in file `Core/Components/src/Core.Components.OxyPlot/Converter/ChartSeriesFactory.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 4dbfc20ef0200e34db43efeb8899d72e4046cc5b refers to a dead (removed) revision in file `Core/Components/src/Core.Components.OxyPlot/Converter/IChartDataConverter.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Core/Components/src/Core.Components.OxyPlot/Converter/ItemBasedChartDataConverter.cs
===================================================================
diff -u
--- Core/Components/src/Core.Components.OxyPlot/Converter/ItemBasedChartDataConverter.cs	(revision 0)
+++ Core/Components/src/Core.Components.OxyPlot/Converter/ItemBasedChartDataConverter.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,94 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Components.Charting.Data;
+using OxyPlot.Series;
+
+namespace Core.Components.OxyPlot.Converter
+{
+    /// <summary>
+    /// Abstract base class for transforming <see cref="ItemBasedChartData"/> data into <see cref="Series"/> data.
+    /// </summary>
+    /// <typeparam name="TItemBasedChartData">The type of item based chart data to convert.</typeparam>
+    /// <typeparam name="TSeries">The type of series to set the converted data to.</typeparam>
+    public abstract class ItemBasedChartDataConverter<TItemBasedChartData, TSeries>
+        where TItemBasedChartData : ItemBasedChartData
+        where TSeries : Series
+    {
+        /// <summary>
+        /// Converts all item related data from <paramref name="data"/> to <paramref name="series"/>.
+        /// </summary>
+        /// <param name="data">The data to convert the item related data from.</param>
+        /// <param name="series">The series to convert the item related data to.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="data"/> or <paramref name="series"/> is <c>null</c>.</exception>
+        public void ConvertSeriesItems(TItemBasedChartData data, TSeries series)
+        {
+            ValidateParameters(data, series);
+
+            SetSeriesItems(data, series);
+        }
+
+        /// <summary>
+        /// Converts all general properties (like <see cref="ItemBasedChartData.Name"/> and <see cref="ItemBasedChartData.IsVisible"/>) 
+        /// from <paramref name="data"/> to <paramref name="series"/>.
+        /// </summary>
+        /// <param name="data">The data to convert the general properties from.</param>
+        /// <param name="series">The series to convert the general properties to.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="data"/> or <paramref name="series"/> is <c>null</c>.</exception>
+        public void ConvertSeriesProperties(TItemBasedChartData data, TSeries series)
+        {
+            ValidateParameters(data, series);
+
+            series.Title = data.Name;
+            series.IsVisible = data.IsVisible;
+
+            SetSeriesStyle(data, series);
+        }
+
+        /// <summary>
+        /// Sets items to <paramref name="series"/> based on <paramref name="data"/>.
+        /// </summary>
+        /// <param name="data">The data to create the items from.</param>
+        /// <param name="series">The series to set the items to.</param>
+        protected abstract void SetSeriesItems(TItemBasedChartData data, TSeries series);
+
+        /// <summary>
+        /// Set a style to <paramref name="series"/> based on <paramref name="data"/>.
+        /// </summary>
+        /// <param name="data">The data to create the style from.</param>
+        /// <param name="series">The series to set the style to.</param>
+        protected abstract void SetSeriesStyle(TItemBasedChartData data, TSeries series);
+
+        private static void ValidateParameters(TItemBasedChartData data, TSeries series)
+        {
+            if (data == null)
+            {
+                throw new ArgumentNullException("data", @"Null data cannot be converted into series data.");
+            }
+
+            if (series == null)
+            {
+                throw new ArgumentNullException("series", @"Null data cannot be used as conversion target.");
+            }
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/src/Core.Components.OxyPlot/Core.Components.OxyPlot.csproj
===================================================================
diff -u -r1795be9025cb0e054dca86a5275203966c0a9b2a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.OxyPlot/Core.Components.OxyPlot.csproj	(.../Core.Components.OxyPlot.csproj)	(revision 1795be9025cb0e054dca86a5275203966c0a9b2a)
+++ Core/Components/src/Core.Components.OxyPlot/Core.Components.OxyPlot.csproj	(.../Core.Components.OxyPlot.csproj)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -50,17 +50,20 @@
       <Link>Properties\GlobalAssembly.cs</Link>
     </Compile>
     <Compile Include="Converter\ChartAreaDataConverter.cs" />
-    <Compile Include="Converter\ChartDataCollectionConverter.cs" />
     <Compile Include="Converter\ChartDataHelper.cs" />
     <Compile Include="Converter\ChartMultipleAreaDataConverter.cs" />
-    <Compile Include="Converter\IChartDataConverter.cs" />
     <Compile Include="Converter\ChartLineDataConverter.cs" />
     <Compile Include="Converter\ChartPointDataConverter.cs" />
+    <Compile Include="DataSeries\ChartAreaDataSeries.cs" />
+    <Compile Include="DataSeries\ChartLineDataSeries.cs" />
+    <Compile Include="DataSeries\ChartMultipleAreaDataSeries.cs" />
+    <Compile Include="DataSeries\IItemBasedChartDataSeries.cs" />
     <Compile Include="CustomSeries\MultipleAreaSeries.cs" />
     <Compile Include="DynamicPlotController.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Converter\ChartDataConverter.cs" />
-    <Compile Include="Converter\ChartSeriesFactory.cs" />
+    <Compile Include="Converter\ItemBasedChartDataConverter.cs" />
+    <Compile Include="DataSeries\ItemBasedChartDataSeriesFactory.cs" />
+    <Compile Include="DataSeries\ChartPointDataSeries.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\..\..\build\Copying.Lesser.licenseheader">
@@ -80,6 +83,7 @@
       <Private>False</Private>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
Index: Core/Components/src/Core.Components.OxyPlot/CustomSeries/MultipleAreaSeries.cs
===================================================================
diff -u -red96d38a758365e4c0f117def83a2926c589c18a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/src/Core.Components.OxyPlot/CustomSeries/MultipleAreaSeries.cs	(.../MultipleAreaSeries.cs)	(revision ed96d38a758365e4c0f117def83a2926c589c18a)
+++ Core/Components/src/Core.Components.OxyPlot/CustomSeries/MultipleAreaSeries.cs	(.../MultipleAreaSeries.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -28,14 +28,14 @@
 namespace Core.Components.OxyPlot.CustomSeries
 {
     /// <summary>
-    /// Represents mutliple area series that fills the polygons defined by each collection of points.
+    /// Represents multiple area series that fills the polygons defined by each collection of points.
     /// </summary>
     public class MultipleAreaSeries : XYAxisSeries
     {
         private readonly OxyColor defaultColor = OxyColors.Fuchsia;
 
         /// <summary>
-        /// Creates a instance of <see cref="MultipleAreaSeries"/>.
+        /// Creates a new instance of <see cref="MultipleAreaSeries"/>.
         /// </summary>
         public MultipleAreaSeries()
         {
Index: Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartAreaDataSeries.cs
===================================================================
diff -u
--- Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartAreaDataSeries.cs	(revision 0)
+++ Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartAreaDataSeries.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,69 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Common.Base.Geometry;
+using Core.Components.Charting.Data;
+using Core.Components.OxyPlot.Converter;
+using OxyPlot.Series;
+
+namespace Core.Components.OxyPlot.DataSeries
+{
+    /// <summary>
+    /// A <see cref="AreaSeries"/> based on and updated according to the wrapped <see cref="ChartAreaData"/>.
+    /// </summary>
+    public class ChartAreaDataSeries : AreaSeries, IItemBasedChartDataSeries
+    {
+        private readonly ChartAreaData chartAreaData;
+        private readonly ChartAreaDataConverter converter = new ChartAreaDataConverter();
+
+        private Point2D[] drawnPoints;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="ChartAreaDataSeries"/>.
+        /// </summary>
+        /// <param name="chartAreaData">The <see cref="ChartAreaData"/> which the chart area data series is based upon.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="chartAreaData"/> is <c>null</c>.</exception>
+        public ChartAreaDataSeries(ChartAreaData chartAreaData)
+        {
+            if (chartAreaData == null)
+            {
+                throw new ArgumentNullException("chartAreaData");
+            }
+
+            this.chartAreaData = chartAreaData;
+
+            Update();
+        }
+
+        public void Update()
+        {
+            if (!ReferenceEquals(chartAreaData.Points, drawnPoints))
+            {
+                converter.ConvertSeriesItems(chartAreaData, this);
+
+                drawnPoints = chartAreaData.Points;
+            }
+
+            converter.ConvertSeriesProperties(chartAreaData, this);
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartLineDataSeries.cs
===================================================================
diff -u
--- Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartLineDataSeries.cs	(revision 0)
+++ Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartLineDataSeries.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,69 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Common.Base.Geometry;
+using Core.Components.Charting.Data;
+using Core.Components.OxyPlot.Converter;
+using OxyPlot.Series;
+
+namespace Core.Components.OxyPlot.DataSeries
+{
+    /// <summary>
+    /// A <see cref="LineSeries"/> based on and updated according to the wrapped <see cref="ChartLineData"/>.
+    /// </summary>
+    public class ChartLineDataSeries : LineSeries, IItemBasedChartDataSeries
+    {
+        private readonly ChartLineData chartLineData;
+        private readonly ChartLineDataConverter converter = new ChartLineDataConverter();
+
+        private Point2D[] drawnPoints;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="ChartLineDataSeries"/>.
+        /// </summary>
+        /// <param name="chartLineData">The <see cref="ChartLineData"/> which the chart line data series is based upon.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="chartLineData"/> is <c>null</c>.</exception>
+        public ChartLineDataSeries(ChartLineData chartLineData)
+        {
+            if (chartLineData == null)
+            {
+                throw new ArgumentNullException("chartLineData");
+            }
+
+            this.chartLineData = chartLineData;
+
+            Update();
+        }
+
+        public void Update()
+        {
+            if (!ReferenceEquals(chartLineData.Points, drawnPoints))
+            {
+                converter.ConvertSeriesItems(chartLineData, this);
+
+                drawnPoints = chartLineData.Points;
+            }
+
+            converter.ConvertSeriesProperties(chartLineData, this);
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartMultipleAreaDataSeries.cs
===================================================================
diff -u
--- Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartMultipleAreaDataSeries.cs	(revision 0)
+++ Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartMultipleAreaDataSeries.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,70 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using Core.Common.Base.Geometry;
+using Core.Components.Charting.Data;
+using Core.Components.OxyPlot.Converter;
+using Core.Components.OxyPlot.CustomSeries;
+
+namespace Core.Components.OxyPlot.DataSeries
+{
+    /// <summary>
+    /// A <see cref="MultipleAreaSeries"/> based on and updated according to the wrapped <see cref="ChartMultipleAreaData"/>.
+    /// </summary>
+    public class ChartMultipleAreaDataSeries : MultipleAreaSeries, IItemBasedChartDataSeries
+    {
+        private readonly ChartMultipleAreaData chartMultipleAreaData;
+        private readonly ChartMultipleAreaDataConverter converter = new ChartMultipleAreaDataConverter();
+
+        private IEnumerable<Point2D[]> drawnAreas;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="ChartMultipleAreaDataSeries"/>.
+        /// </summary>
+        /// <param name="chartMultipleAreaData">The <see cref="ChartMultipleAreaData"/> which the chart multiple area data series is based upon.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="chartMultipleAreaData"/> is <c>null</c>.</exception>
+        public ChartMultipleAreaDataSeries(ChartMultipleAreaData chartMultipleAreaData)
+        {
+            if (chartMultipleAreaData == null)
+            {
+                throw new ArgumentNullException("chartMultipleAreaData");
+            }
+
+            this.chartMultipleAreaData = chartMultipleAreaData;
+
+            Update();
+        }
+
+        public void Update()
+        {
+            if (!ReferenceEquals(chartMultipleAreaData.Areas, drawnAreas))
+            {
+                converter.ConvertSeriesItems(chartMultipleAreaData, this);
+
+                drawnAreas = chartMultipleAreaData.Areas;
+            }
+
+            converter.ConvertSeriesProperties(chartMultipleAreaData, this);
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartPointDataSeries.cs
===================================================================
diff -u
--- Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartPointDataSeries.cs	(revision 0)
+++ Core/Components/src/Core.Components.OxyPlot/DataSeries/ChartPointDataSeries.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,69 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Common.Base.Geometry;
+using Core.Components.Charting.Data;
+using Core.Components.OxyPlot.Converter;
+using OxyPlot.Series;
+
+namespace Core.Components.OxyPlot.DataSeries
+{
+    /// <summary>
+    /// A <see cref="LineSeries"/> based on and updated according to the wrapped <see cref="ChartPointData"/>.
+    /// </summary>
+    public class ChartPointDataSeries : LineSeries, IItemBasedChartDataSeries
+    {
+        private readonly ChartPointData chartPointData;
+        private readonly ChartPointDataConverter converter = new ChartPointDataConverter();
+
+        private Point2D[] drawnPoints;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="ChartPointDataSeries"/>.
+        /// </summary>
+        /// <param name="chartPointData">The <see cref="ChartPointData"/> which the chart point data series is based upon.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="chartPointData"/> is <c>null</c>.</exception>
+        public ChartPointDataSeries(ChartPointData chartPointData)
+        {
+            if (chartPointData == null)
+            {
+                throw new ArgumentNullException("chartPointData");
+            }
+
+            this.chartPointData = chartPointData;
+
+            Update();
+        }
+
+        public void Update()
+        {
+            if (!ReferenceEquals(chartPointData.Points, drawnPoints))
+            {
+                converter.ConvertSeriesItems(chartPointData, this);
+
+                drawnPoints = chartPointData.Points;
+            }
+
+            converter.ConvertSeriesProperties(chartPointData, this);
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/src/Core.Components.OxyPlot/DataSeries/IItemBasedChartDataSeries.cs
===================================================================
diff -u
--- Core/Components/src/Core.Components.OxyPlot/DataSeries/IItemBasedChartDataSeries.cs	(revision 0)
+++ Core/Components/src/Core.Components.OxyPlot/DataSeries/IItemBasedChartDataSeries.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,34 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+namespace Core.Components.OxyPlot.DataSeries
+{
+    /// <summary>
+    /// Interface for item based chart data series.
+    /// </summary>
+    public interface IItemBasedChartDataSeries
+    {
+        /// <summary>
+        /// Updates the chart data series.
+        /// </summary>
+        void Update();
+    }
+}
\ No newline at end of file
Index: Core/Components/src/Core.Components.OxyPlot/DataSeries/ItemBasedChartDataSeriesFactory.cs
===================================================================
diff -u
--- Core/Components/src/Core.Components.OxyPlot/DataSeries/ItemBasedChartDataSeriesFactory.cs	(revision 0)
+++ Core/Components/src/Core.Components.OxyPlot/DataSeries/ItemBasedChartDataSeriesFactory.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,67 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Components.Charting.Data;
+
+namespace Core.Components.OxyPlot.DataSeries
+{
+    /// <summary>
+    /// A factory to create <see cref="IItemBasedChartDataSeries"/> based on <see cref="ItemBasedChartData"/>.
+    /// </summary>
+    public static class ItemBasedChartDataSeriesFactory
+    {
+        /// <summary>
+        /// Creates a <see cref="IItemBasedChartDataSeries"/> based on <paramref name="data"/>.
+        /// </summary>
+        /// <param name="data">The <see cref="ItemBasedChartData"/> to create a <see cref="IItemBasedChartDataSeries"/> from.</param>
+        /// <returns>A <see cref="IItemBasedChartDataSeries"/> instance.</returns>
+        /// <exception cref="NotSupportedException">Thrown when the given <paramref name="data"/> type is not supported.</exception>
+        public static IItemBasedChartDataSeries Create(ItemBasedChartData data)
+        {
+            var chartPointData = data as ChartPointData;
+            if (chartPointData != null)
+            {
+                return new ChartPointDataSeries(chartPointData);
+            }
+
+            var chartLineData = data as ChartLineData;
+            if (chartLineData != null)
+            {
+                return new ChartLineDataSeries(chartLineData);
+            }
+
+            var chartAreaData = data as ChartAreaData;
+            if (chartAreaData != null)
+            {
+                return new ChartAreaDataSeries(chartAreaData);
+            }
+
+            var chartMultipleAreaData = data as ChartMultipleAreaData;
+            if (chartMultipleAreaData != null)
+            {
+                return new ChartMultipleAreaDataSeries(chartMultipleAreaData);
+            }
+
+            throw new NotSupportedException(string.Format("ItemBasedChartData of type {0} is not supported.", data.GetType().Name));
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/test/Core.Components.Charting.Test/Core.Components.Charting.Test.csproj
===================================================================
diff -u -r2d5e2d09b0cb1a7f48e1b0a067d332347c89d4a8 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.Charting.Test/Core.Components.Charting.Test.csproj	(.../Core.Components.Charting.Test.csproj)	(revision 2d5e2d09b0cb1a7f48e1b0a067d332347c89d4a8)
+++ Core/Components/test/Core.Components.Charting.Test/Core.Components.Charting.Test.csproj	(.../Core.Components.Charting.Test.csproj)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -56,6 +56,7 @@
     <Compile Include="Data\ChartDataTest.cs" />
     <Compile Include="Data\ChartLineDataTest.cs" />
     <Compile Include="Data\ChartMultipleAreaDataTest.cs" />
+    <Compile Include="Data\ItemBasedChartDataTest.cs" />
     <Compile Include="Data\PointBasedChartDataTest.cs" />
     <Compile Include="Data\ChartPointDataTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
Index: Core/Components/test/Core.Components.Charting.Test/Data/ChartMultipleAreaDataTest.cs
===================================================================
diff -u -rce31448a066c084f755439f3e7d453bfb042b291 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.Charting.Test/Data/ChartMultipleAreaDataTest.cs	(.../ChartMultipleAreaDataTest.cs)	(revision ce31448a066c084f755439f3e7d453bfb042b291)
+++ Core/Components/test/Core.Components.Charting.Test/Data/ChartMultipleAreaDataTest.cs	(.../ChartMultipleAreaDataTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -39,7 +39,7 @@
 
             // Assert
             Assert.AreEqual("test data", data.Name);
-            Assert.IsInstanceOf<ChartData>(data);
+            Assert.IsInstanceOf<ItemBasedChartData>(data);
         }
 
         [Test]
Index: Core/Components/test/Core.Components.Charting.Test/Data/ItemBasedChartDataTest.cs
===================================================================
diff -u
--- Core/Components/test/Core.Components.Charting.Test/Data/ItemBasedChartDataTest.cs	(revision 0)
+++ Core/Components/test/Core.Components.Charting.Test/Data/ItemBasedChartDataTest.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,62 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Common.TestUtil;
+using Core.Components.Charting.Data;
+using NUnit.Framework;
+
+namespace Core.Components.Charting.Test.Data
+{
+    [TestFixture]
+    public class ItemBasedChartDataTest
+    {
+        [Test]
+        public void Constructor_ValidName_NameAndDefaultValuesSet()
+        {
+            // Call
+            var data = new TestItemBasedChartData("test data");
+
+            // Assert
+            Assert.IsInstanceOf<ChartData>(data);
+            Assert.AreEqual("test data", data.Name);
+        }
+
+        [Test]
+        [TestCase(null)]
+        [TestCase("")]
+        [TestCase("        ")]
+        public void Constructor_InvalidName_ThrowsArgumentException(string invalidName)
+        {
+            // Call
+            TestDelegate test = () => new TestItemBasedChartData(invalidName);
+
+            // Assert
+            const string expectedMessage = "A name must be set to the chart data.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
+        }
+
+        private class TestItemBasedChartData : ItemBasedChartData
+        {
+            public TestItemBasedChartData(string name) : base(name) {}
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/test/Core.Components.Charting.Test/Data/PointBasedChartDataTest.cs
===================================================================
diff -u -red96d38a758365e4c0f117def83a2926c589c18a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.Charting.Test/Data/PointBasedChartDataTest.cs	(.../PointBasedChartDataTest.cs)	(revision ed96d38a758365e4c0f117def83a2926c589c18a)
+++ Core/Components/test/Core.Components.Charting.Test/Data/PointBasedChartDataTest.cs	(.../PointBasedChartDataTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -37,6 +37,7 @@
             var data = new TestPointBasedChartData("test data");
 
             // Assert
+            Assert.IsInstanceOf<ItemBasedChartData>(data);
             Assert.AreEqual("test data", data.Name);
             Assert.IsEmpty(data.Points);
         }
Index: Core/Components/test/Core.Components.DotSpatial.Test/Converter/FeatureBasedMapDataConverterTest.cs
===================================================================
diff -u -r0e524a720919848a33bb6bb331082c2d32ff1b5c -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.DotSpatial.Test/Converter/FeatureBasedMapDataConverterTest.cs	(.../FeatureBasedMapDataConverterTest.cs)	(revision 0e524a720919848a33bb6bb331082c2d32ff1b5c)
+++ Core/Components/test/Core.Components.DotSpatial.Test/Converter/FeatureBasedMapDataConverterTest.cs	(.../FeatureBasedMapDataConverterTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -26,7 +26,7 @@
 using System.Linq;
 using Core.Common.TestUtil;
 using Core.Components.DotSpatial.Converter;
-using Core.Components.Gis.Data;
+using Core.Components.DotSpatial.TestUtil;
 using Core.Components.Gis.Features;
 using Core.Components.Gis.Geometries;
 using DotSpatial.Controls;
@@ -44,25 +44,26 @@
         public void ConvertLayerFeatures_DataNull_ThrowsArgumentNullException()
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
+            var mapLayer = new TestFeatureLayer();
 
             // Call
-            TestDelegate test = () => testConverter.ConvertLayerFeatures(null, new TestFeatureLayer());
+            TestDelegate test = () => testConverter.ConvertLayerFeatures(null, mapLayer);
 
             // Assert
-            const string expectedMessage = "Null data cannot be converted into a feature layer data.";
+            const string expectedMessage = "Null data cannot be converted into feature layer data.";
             TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
         }
 
         [Test]
         public void ConvertLayerFeatures_TargetLayerNull_ThrowsArgumentNullException()
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestUtil.TestFeatureBasedMapData>();
-            var testFeatureBasedMapData = new TestUtil.TestFeatureBasedMapData("test data");
+            var testConverter = new TestFeatureBasedMapDataConverter();
+            var mapData = new TestFeatureBasedMapData("test data");
 
             // Call
-            TestDelegate test = () => testConverter.ConvertLayerFeatures(testFeatureBasedMapData, null);
+            TestDelegate test = () => testConverter.ConvertLayerFeatures(mapData, null);
 
             // Assert
             const string expectedMessage = "Null data cannot be used as conversion target.";
@@ -73,25 +74,26 @@
         public void ConvertLayerProperties_DataNull_ThrowsArgumentNullException()
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
+            var mapLayer = new TestFeatureLayer();
 
             // Call
-            TestDelegate test = () => testConverter.ConvertLayerProperties(null, new TestFeatureLayer());
+            TestDelegate test = () => testConverter.ConvertLayerProperties(null, mapLayer);
 
             // Assert
-            const string expectedMessage = "Null data cannot be converted into a feature layer data.";
+            const string expectedMessage = "Null data cannot be converted into feature layer data.";
             TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
         }
 
         [Test]
         public void ConvertLayerProperties_TargetLayerNull_ThrowsArgumentNullException()
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestUtil.TestFeatureBasedMapData>();
-            var testFeatureBasedMapData = new TestUtil.TestFeatureBasedMapData("test data");
+            var testConverter = new TestFeatureBasedMapDataConverter();
+            var mapData = new TestFeatureBasedMapData("test data");
 
             // Call
-            TestDelegate test = () => testConverter.ConvertLayerProperties(testFeatureBasedMapData, null);
+            TestDelegate test = () => testConverter.ConvertLayerProperties(mapData, null);
 
             // Assert
             const string expectedMessage = "Null data cannot be used as conversion target.";
@@ -102,7 +104,7 @@
         public void ConvertLayerFeatures_MapDataWithMetaData_MetaDataSetToLayer()
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
             var mapLayer = new TestFeatureLayer();
             var mapData = new TestFeatureBasedMapData("test")
             {
@@ -169,7 +171,7 @@
         {
             // Setup
             var name = "<Some name>";
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
             var mapData = new TestFeatureBasedMapData(name);
             var mapLayer = new TestFeatureLayer();
 
@@ -184,7 +186,7 @@
         public void ConvertLayerProperties_LayerWithoutDataColumns_DefaultLabelLayerSetToLayer()
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
             var mapData = new TestFeatureBasedMapData("test data")
             {
                 Features = new[]
@@ -219,7 +221,7 @@
         public void ConvertLayerProperties_MapDataWithoutMetaData_DefaultLabelLayerSetToLayer()
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
             var mapData = new TestFeatureBasedMapData("test data")
             {
                 Features = new[]
@@ -256,7 +258,7 @@
         public void ConvertLayerProperties_MapDataWithMetaAndSelectedMetaDataAttributeInDataColumns_CustomLabelLayerSetToLayer()
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
             var mapData = new TestFeatureBasedMapData("test data")
             {
                 Features = new[]
@@ -308,7 +310,7 @@
         public void ConvertLayerProperties_MapData_ShowLabelsSetToLayer(bool showLabels)
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
             var mapData = new TestFeatureBasedMapData("test data")
             {
                 ShowLabels = showLabels
@@ -327,7 +329,7 @@
         public void ConvertLayerProperties_MapData_IsVisibleSetToLayer(bool isVisible)
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
             var mapData = new TestFeatureBasedMapData("test data")
             {
                 IsVisible = isVisible
@@ -347,7 +349,7 @@
         public void ConvertLayerProperties_SelectedMetaDataAttributeEmptyOrUnknown_DefaultLabelLayerSetToLayer(string selectedMetaDataAttribute)
         {
             // Setup
-            var testConverter = new TestFeatureBasedMapDataConverter<TestFeatureBasedMapData>();
+            var testConverter = new TestFeatureBasedMapDataConverter();
             var mapData = new TestFeatureBasedMapData("test data")
             {
                 Features = new[]
@@ -391,20 +393,14 @@
             Assert.IsNull(mapLayer.LabelLayer.Symbology.Categories[0].Expression);
         }
 
-        private class TestFeatureBasedMapData : FeatureBasedMapData
-        {
-            public TestFeatureBasedMapData(string name) : base(name) {}
-        }
-
         private class TestFeatureLayer : MapPointLayer
         {
             public TestFeatureLayer() : base(new FeatureSet()) {}
         }
 
-        private class TestFeatureBasedMapDataConverter<TFeatureBasedMapData> : FeatureBasedMapDataConverter<TFeatureBasedMapData, TestFeatureLayer>
-            where TFeatureBasedMapData : FeatureBasedMapData
+        private class TestFeatureBasedMapDataConverter : FeatureBasedMapDataConverter<TestFeatureBasedMapData, TestFeatureLayer>
         {
-            protected override IFeatureSymbolizer CreateSymbolizer(TFeatureBasedMapData mapData)
+            protected override IFeatureSymbolizer CreateSymbolizer(TestFeatureBasedMapData mapData)
             {
                 return new PointSymbolizer();
             }
Index: Core/Components/test/Core.Components.Gis.Test/Core.Components.Gis.Test.csproj
===================================================================
diff -u -r2d5e2d09b0cb1a7f48e1b0a067d332347c89d4a8 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.Gis.Test/Core.Components.Gis.Test.csproj	(.../Core.Components.Gis.Test.csproj)	(revision 2d5e2d09b0cb1a7f48e1b0a067d332347c89d4a8)
+++ Core/Components/test/Core.Components.Gis.Test/Core.Components.Gis.Test.csproj	(.../Core.Components.Gis.Test.csproj)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -78,6 +78,10 @@
       <Project>{318ba582-88c9-4816-a54a-a7e431461de3}</Project>
       <Name>Core.Components.Gis</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Core.Components.DotSpatial.TestUtil\Core.Components.DotSpatial.TestUtil.csproj">
+      <Project>{9B6F3987-EAF7-4733-80C1-3DCAB44D87AE}</Project>
+      <Name>Core.Components.DotSpatial.TestUtil</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: Core/Components/test/Core.Components.Gis.Test/Data/FeatureBasedMapDataTest.cs
===================================================================
diff -u -r86b6ce2b77450d63016858e8e18796c02bdaad52 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.Gis.Test/Data/FeatureBasedMapDataTest.cs	(.../FeatureBasedMapDataTest.cs)	(revision 86b6ce2b77450d63016858e8e18796c02bdaad52)
+++ Core/Components/test/Core.Components.Gis.Test/Data/FeatureBasedMapDataTest.cs	(.../FeatureBasedMapDataTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -23,7 +23,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Core.Common.TestUtil;
-using Core.Components.Gis.Data;
+using Core.Components.DotSpatial.TestUtil;
 using Core.Components.Gis.Features;
 using Core.Components.Gis.Geometries;
 using NUnit.Framework;
@@ -143,10 +143,5 @@
                 "Attribute3",
             }, metaData);
         }
-
-        private class TestFeatureBasedMapData : FeatureBasedMapData
-        {
-            public TestFeatureBasedMapData(string name) : base(name) {}
-        }
     }
 }
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Forms.Test/ChartControlTest.cs
===================================================================
diff -u -r640df7c0609a81e19cc3661323ee461d801049b0 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.OxyPlot.Forms.Test/ChartControlTest.cs	(.../ChartControlTest.cs)	(revision 640df7c0609a81e19cc3661323ee461d801049b0)
+++ Core/Components/test/Core.Components.OxyPlot.Forms.Test/ChartControlTest.cs	(.../ChartControlTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -22,8 +22,10 @@
 using System.Drawing;
 using System.Linq;
 using System.Windows.Forms;
+using Core.Common.Base.Geometry;
 using Core.Common.Utils.Reflection;
 using Core.Components.Charting.Data;
+using Core.Components.Charting.Forms;
 using NUnit.Framework;
 using OxyPlot.WindowsForms;
 
@@ -40,19 +42,241 @@
             {
                 // Assert
                 Assert.IsInstanceOf<Control>(chart);
+                Assert.IsInstanceOf<IChartControl>(chart);
                 Assert.AreEqual(100, chart.MinimumSize.Height);
                 Assert.AreEqual(100, chart.MinimumSize.Width);
-                Assert.IsNotNull(chart.Data);
-                CollectionAssert.IsEmpty(chart.Data.Collection);
+                Assert.IsNull(chart.Data);
                 Assert.IsTrue(chart.IsPanningEnabled);
                 Assert.IsFalse(chart.IsRectangleZoomingEnabled);
 
-                var view = TypeUtils.GetField<PlotView>(chart, "view");
+                var view = TypeUtils.GetField<PlotView>(chart, "plotView");
                 Assert.AreEqual(Color.White, view.BackColor);
+                Assert.IsFalse(view.Model.IsLegendVisible);
             }
         }
 
         [Test]
+        public void GivenChartControlWithoutData_WhenDataSetToChartDataCollection_ThenChartControlUpdated()
+        {
+            // Given
+            using (var chart = new ChartControl())
+            {
+                var plotView = chart.Controls.OfType<LinearPlotView>().First();
+                var chartPointData = new ChartPointData("Points");
+                var chartLineData = new ChartLineData("Lines");
+                var chartAreaData = new ChartAreaData("Areas");
+                var chartDataCollection = new ChartDataCollection("Root collection");
+                var nestedChartDataCollection1 = new ChartDataCollection("Nested collection 1");
+                var nestedChartDataCollection2 = new ChartDataCollection("Nested collection 2");
+
+                chartDataCollection.Add(chartPointData);
+                chartDataCollection.Add(nestedChartDataCollection1);
+                nestedChartDataCollection1.Add(chartLineData);
+                nestedChartDataCollection1.Add(nestedChartDataCollection2);
+                nestedChartDataCollection2.Add(chartAreaData);
+
+                // When
+                chart.Data = chartDataCollection;
+
+                // Then
+                var series = plotView.Model.Series;
+                Assert.AreEqual(3, series.Count);
+                Assert.AreEqual("Points", series[0].Title);
+                Assert.AreEqual("Lines", series[1].Title);
+                Assert.AreEqual("Areas", series[2].Title);
+            }
+        }
+
+        [Test]
+        public void GivenChartControlWithData_WhenDataSetToOtherChartDataCollection_ThenChartControlUpdated()
+        {
+            // Given
+            using (var chart = new ChartControl())
+            {
+                var plotView = chart.Controls.OfType<LinearPlotView>().First();
+                var chartPointData = new ChartPointData("Points");
+                var chartLineData = new ChartLineData("Lines");
+                var chartAreaData = new ChartAreaData("Areas");
+                var chartDataCollection1 = new ChartDataCollection("Collection 1");
+                var chartDataCollection2 = new ChartDataCollection("Collection 2");
+
+                chartDataCollection1.Add(chartPointData);
+                chartDataCollection2.Add(chartLineData);
+                chartDataCollection2.Add(chartAreaData);
+
+                chart.Data = chartDataCollection1;
+
+                // Precondition
+                Assert.AreEqual(1, plotView.Model.Series.Count);
+                Assert.AreEqual("Points", plotView.Model.Series[0].Title);
+
+                // When
+                chart.Data = chartDataCollection2;
+
+                // Then
+                Assert.AreEqual(2, plotView.Model.Series.Count);
+                Assert.AreEqual("Lines", plotView.Model.Series[0].Title);
+                Assert.AreEqual("Areas", plotView.Model.Series[1].Title);
+            }
+        }
+
+        [Test]
+        public void GivenChartControlWithData_WhenChartDataNotifiesChange_ThenAllSeriesReused()
+        {
+            // Given
+            using (var chart = new ChartControl())
+            {
+                var plotView = chart.Controls.OfType<LinearPlotView>().First();
+                var chartPointData = new ChartPointData("Points");
+                var chartLineData = new ChartLineData("Lines");
+                var chartAreaData = new ChartAreaData("Areas");
+                var chartDataCollection = new ChartDataCollection("Root collection");
+                var nestedChartDataCollection1 = new ChartDataCollection("Nested collection 1");
+                var nestedChartDataCollection2 = new ChartDataCollection("Nested collection 2");
+
+                chartDataCollection.Add(chartPointData);
+                chartDataCollection.Add(nestedChartDataCollection1);
+                nestedChartDataCollection1.Add(chartLineData);
+                nestedChartDataCollection1.Add(nestedChartDataCollection2);
+                nestedChartDataCollection2.Add(chartAreaData);
+
+                chart.Data = chartDataCollection;
+
+                var seriesBeforeUpdate = plotView.Model.Series.ToList();
+
+                // When
+                chartLineData.Points = new Point2D[0];
+                chartLineData.NotifyObservers();
+
+                // Then
+                CollectionAssert.AreEqual(seriesBeforeUpdate, plotView.Model.Series);
+            }
+        }
+
+        [Test]
+        public void GivenChartControlWithData_WhenChartDataRemoved_ThenCorrespondingSeriesRemovedAndOtherSeriesReused()
+        {
+            // Given
+            using (var chart = new ChartControl())
+            {
+                var plotView = chart.Controls.OfType<LinearPlotView>().First();
+                var chartPointData = new ChartPointData("Points");
+                var chartLineData = new ChartLineData("Lines");
+                var chartAreaData = new ChartAreaData("Areas");
+                var chartDataCollection = new ChartDataCollection("Root collection");
+                var nestedChartDataCollection1 = new ChartDataCollection("Nested collection 1");
+                var nestedChartDataCollection2 = new ChartDataCollection("Nested collection 2");
+
+                chartDataCollection.Add(chartPointData);
+                chartDataCollection.Add(nestedChartDataCollection1);
+                nestedChartDataCollection1.Add(chartLineData);
+                nestedChartDataCollection1.Add(nestedChartDataCollection2);
+                nestedChartDataCollection2.Add(chartAreaData);
+
+                chart.Data = chartDataCollection;
+
+                var seriesBeforeUpdate = plotView.Model.Series.ToList();
+
+                // Precondition
+                Assert.AreEqual(3, seriesBeforeUpdate.Count);
+
+                // When
+                nestedChartDataCollection1.Remove(chartLineData);
+                nestedChartDataCollection1.NotifyObservers();
+
+                // Then
+                var series = plotView.Model.Series;
+                Assert.AreEqual(2, series.Count);
+                Assert.AreEqual("Points", series[0].Title);
+                Assert.AreEqual("Areas", series[1].Title);
+                Assert.AreEqual(0, series.Except(seriesBeforeUpdate).Count());
+            }
+        }
+
+        [Test]
+        public void GivenChartControlWithData_WhenChartDataAdded_ThenCorrespondingSeriesAddedAndOtherSeriesReused()
+        {
+            // Given
+            using (var chart = new ChartControl())
+            {
+                var plotView = chart.Controls.OfType<LinearPlotView>().First();
+                var chartPointData = new ChartPointData("Points");
+                var chartLineData = new ChartLineData("Lines");
+                var chartAreaData = new ChartAreaData("Areas");
+                var chartDataCollection = new ChartDataCollection("Root collection");
+                var nestedChartDataCollection1 = new ChartDataCollection("Nested collection 1");
+                var nestedChartDataCollection2 = new ChartDataCollection("Nested collection 2");
+
+                chartDataCollection.Add(chartPointData);
+                chartDataCollection.Add(nestedChartDataCollection1);
+                nestedChartDataCollection1.Add(chartLineData);
+                nestedChartDataCollection1.Add(nestedChartDataCollection2);
+                nestedChartDataCollection2.Add(chartAreaData);
+
+                chart.Data = chartDataCollection;
+
+                var seriesBeforeUpdate = plotView.Model.Series.ToList();
+
+                // Precondition
+                Assert.AreEqual(3, seriesBeforeUpdate.Count);
+
+                // When
+                nestedChartDataCollection1.Insert(0, new ChartAreaData("Additional areas"));
+                nestedChartDataCollection1.NotifyObservers();
+
+                // Then
+                var series = plotView.Model.Series;
+                Assert.AreEqual(4, series.Count);
+                Assert.AreEqual("Points", series[0].Title);
+                Assert.AreEqual("Additional areas", series[1].Title);
+                Assert.AreEqual("Lines", series[2].Title);
+                Assert.AreEqual("Areas", series[3].Title);
+                Assert.AreEqual(0, seriesBeforeUpdate.Except(series).Count());
+            }
+        }
+
+        [Test]
+        public void GivenChartControlWithData_WhenChartDataMoved_ThenCorrespondingSeriesMovedAndAllSeriesReused()
+        {
+            // Given
+            using (var chart = new ChartControl())
+            {
+                var plotView = chart.Controls.OfType<LinearPlotView>().First();
+                var chartPointData = new ChartPointData("Points");
+                var chartLineData = new ChartLineData("Lines");
+                var chartAreaData = new ChartAreaData("Areas");
+                var chartDataCollection = new ChartDataCollection("Root collection");
+
+                chartDataCollection.Add(chartPointData);
+                chartDataCollection.Add(chartLineData);
+                chartDataCollection.Add(chartAreaData);
+
+                chart.Data = chartDataCollection;
+
+                var seriesBeforeUpdate = plotView.Model.Series.ToList();
+
+                // Precondition
+                Assert.AreEqual(3, seriesBeforeUpdate.Count);
+                Assert.AreEqual("Points", seriesBeforeUpdate[0].Title);
+                Assert.AreEqual("Lines", seriesBeforeUpdate[1].Title);
+                Assert.AreEqual("Areas", seriesBeforeUpdate[2].Title);
+
+                // When
+                chartDataCollection.Remove(chartPointData);
+                chartDataCollection.Add(chartPointData);
+                chartDataCollection.NotifyObservers();
+
+                // Then
+                var series = plotView.Model.Series;
+                Assert.AreEqual(3, series.Count);
+                Assert.AreEqual("Lines", series[0].Title);
+                Assert.AreEqual("Areas", series[1].Title);
+                Assert.AreEqual("Points", series[2].Title);
+                Assert.AreEqual(0, seriesBeforeUpdate.Except(series).Count());
+            }
+        }
+
+        [Test]
         public void TogglePanning_Always_PanningEnabled()
         {
             // Setup
@@ -103,10 +327,14 @@
             {
                 var chart = new ChartControl();
                 var testData = new ChartLineData("test data");
-                var view = TypeUtils.GetField<PlotView>(chart, "view");
+                var collection = new ChartDataCollection("collection");
+                var view = TypeUtils.GetField<PlotView>(chart, "plotView");
                 var invalidated = 0;
 
-                chart.Data.Add(testData);
+                collection.Add(testData);
+
+                chart.Data = collection;
+
                 var series = view.Model.Series.ToList();
 
                 form.Controls.Add(chart);
@@ -124,36 +352,6 @@
         }
 
         [Test]
-        public void UpdateObserver_ChartInForm_ViewInvalidatedSeriesRenewed()
-        {
-            // Setup
-            using (var form = new Form())
-            {
-                var chart = new ChartControl();
-                var testData = new ChartLineData("test data");
-                var view = TypeUtils.GetField<PlotView>(chart, "view");
-                var invalidated = 0;
-
-                chart.Data.Add(testData);
-                chart.UpdateObserver();
-                var series = view.Model.Series.ToList();
-
-                form.Controls.Add(chart);
-                view.Invalidated += (sender, args) => invalidated++;
-
-                form.Show();
-
-                // Call
-                chart.UpdateObserver();
-
-                // Assert
-                Assert.AreEqual(1, invalidated);
-                Assert.AreEqual(1, view.Model.Series.Count);
-                Assert.AreNotSame(series[0], view.Model.Series[0]);
-            }
-        }
-
-        [Test]
         [TestCase("Title")]
         [TestCase("Test")]
         [TestCase("Label")]
@@ -163,7 +361,7 @@
             using (var form = new Form())
             {
                 var chart = new ChartControl();
-                var view = TypeUtils.GetField<PlotView>(chart, "view");
+                var view = TypeUtils.GetField<PlotView>(chart, "plotView");
                 form.Controls.Add(chart);
 
                 form.Show();
@@ -190,7 +388,7 @@
             using (var form = new Form())
             {
                 var chart = new ChartControl();
-                var view = TypeUtils.GetField<PlotView>(chart, "view");
+                var view = TypeUtils.GetField<PlotView>(chart, "plotView");
                 form.Controls.Add(chart);
 
                 form.Show();
@@ -217,7 +415,7 @@
             using (var form = new Form())
             {
                 var chart = new ChartControl();
-                var view = TypeUtils.GetField<PlotView>(chart, "view");
+                var view = TypeUtils.GetField<PlotView>(chart, "plotView");
                 form.Controls.Add(chart);
 
                 form.Show();
@@ -233,22 +431,5 @@
                 Assert.AreEqual(1, invalidated);
             }
         }
-
-        [Test]
-        public void ResetChartData_Always_SetsDataToNull()
-        {
-            // Setup
-            using (var chart = new ChartControl())
-            {
-                // Precondition
-                Assert.IsNotNull(chart.Data);
-
-                // Call
-                chart.ResetChartData();
-
-                // Assert
-                Assert.IsNull(chart.Data);
-            }
-        }
     }
 }
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartAreaDataConverterTest.cs
===================================================================
diff -u -rce31448a066c084f755439f3e7d453bfb042b291 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartAreaDataConverterTest.cs	(.../ChartAreaDataConverterTest.cs)	(revision ce31448a066c084f755439f3e7d453bfb042b291)
+++ Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartAreaDataConverterTest.cs	(.../ChartAreaDataConverterTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -20,15 +20,12 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Drawing;
 using System.Linq;
 using Core.Common.Base.Geometry;
-using Core.Common.TestUtil;
 using Core.Components.Charting.Data;
 using Core.Components.Charting.Styles;
-using Core.Components.Charting.TestUtil;
 using Core.Components.OxyPlot.Converter;
 using NUnit.Framework;
 using OxyPlot;
@@ -46,42 +43,15 @@
             var converter = new ChartAreaDataConverter();
 
             // Assert
-            Assert.IsInstanceOf<ChartDataConverter<ChartAreaData>>(converter);
+            Assert.IsInstanceOf<ItemBasedChartDataConverter<ChartAreaData, AreaSeries>>(converter);
         }
 
         [Test]
-        public void CanConvertSeries_AreaData_ReturnTrue()
+        public void ConvertSeriesItems_ChartAreaDataWithRandomPointData_ConvertsAllPointsToAreaSeries()
         {
             // Setup
             var converter = new ChartAreaDataConverter();
-            var areaData = new ChartAreaData("test data");
-
-            // Call
-            var canConvert = converter.CanConvertSeries(areaData);
-
-            // Assert
-            Assert.IsTrue(canConvert);
-        }
-
-        [Test]
-        public void CanConvertSeries_ChartData_ReturnsFalse()
-        {
-            // Setup
-            var converter = new ChartAreaDataConverter();
-            var chartData = new TestChartData();
-
-            // Call
-            var canConvert = converter.CanConvertSeries(chartData);
-
-            // Assert
-            Assert.IsFalse(canConvert);
-        }
-
-        [Test]
-        public void Convert_RandomPointData_ReturnsNewSeries()
-        {
-            // Setup
-            var converter = new ChartAreaDataConverter();
+            var areaSeries = new AreaSeries();
             var random = new Random(21);
             var randomCount = random.Next(5, 10);
             var points = new Collection<Point2D>();
@@ -96,122 +66,85 @@
             };
 
             // Call
-            var series = converter.Convert(areaData);
+            converter.ConvertSeriesItems(areaData, areaSeries);
 
             // Assert
-            Assert.IsInstanceOf<IList<Series>>(series);
-            var areaSeries = (AreaSeries) series[0];
-            var expectedData = points.Select(t => new DataPoint(t.X, t.Y)).ToArray();
-            CollectionAssert.AreEqual(expectedData, areaSeries.Points);
+            var expectedPoints = points.Select(t => new DataPoint(t.X, t.Y)).ToArray();
+            CollectionAssert.AreEqual(expectedPoints, areaSeries.Points);
             CollectionAssert.AreEqual(new Collection<DataPoint>
             {
-                expectedData.First()
+                expectedPoints.First()
             }, areaSeries.Points2);
         }
 
         [Test]
-        public void Convert_DataNull_ThrowsArgumentNullException()
-        {
-            // Setup
-            var testConverter = new ChartAreaDataConverter();
-
-            // Call
-            TestDelegate test = () => testConverter.Convert(null);
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(test);
-        }
-
-        [Test]
-        public void Convert_DataCannotBeConverted_ThrowsArgumentException()
-        {
-            // Setup
-            var testConverter = new ChartAreaDataConverter();
-            var testChartData = new TestChartData();
-
-            // Precondition
-            Assert.IsFalse(testConverter.CanConvertSeries(testChartData));
-
-            // Call
-            TestDelegate test = () => testConverter.Convert(testChartData);
-
-            // Assert
-            var expectedMessage = string.Format("The data of type {0} cannot be converted by this converter.", testChartData.GetType());
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
         [TestCase(KnownColor.AliceBlue)]
         [TestCase(KnownColor.Azure)]
         [TestCase(KnownColor.Beige)]
-        public void Convert_WithDifferentFillColors_AppliesStyleToSeries(KnownColor color)
+        public void ConvertSeriesProperties_WithDifferentFillColors_AppliesStyleToSeries(KnownColor color)
         {
             // Setup
             var converter = new ChartAreaDataConverter();
+            var areaSeries = new AreaSeries();
             var expectedColor = Color.FromKnownColor(color);
-            var style = new ChartAreaStyle(expectedColor, Color.Red, 3);
             var data = new ChartAreaData("test")
             {
-                Style = style
+                Style = new ChartAreaStyle(expectedColor, Color.Red, 3)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, areaSeries);
 
             // Assert
-            var areaSeries = (AreaSeries) series[0];
-            AssertColors(style.FillColor, areaSeries.Fill);
+            AssertColors(expectedColor, areaSeries.Fill);
         }
 
         [Test]
         [TestCase(KnownColor.AliceBlue)]
         [TestCase(KnownColor.Azure)]
         [TestCase(KnownColor.Beige)]
-        public void Convert_WithDifferentStrokeColors_AppliesStyleToSeries(KnownColor color)
+        public void ConvertSeriesProperties_WithDifferentStrokeColors_AppliesStyleToSeries(KnownColor color)
         {
             // Setup
             var converter = new ChartAreaDataConverter();
+            var areaSeries = new AreaSeries();
             var expectedColor = Color.FromKnownColor(color);
-            var style = new ChartAreaStyle(Color.Red, expectedColor, 3);
             var data = new ChartAreaData("test")
             {
-                Style = style
+                Style = new ChartAreaStyle(Color.Red, expectedColor, 3)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, areaSeries);
 
             // Assert
-            var areaSeries = (AreaSeries) series[0];
-            AssertColors(style.StrokeColor, areaSeries.Color);
+            AssertColors(expectedColor, areaSeries.Color);
         }
 
         [Test]
         [TestCase(1)]
         [TestCase(5)]
         [TestCase(7)]
-        public void Convert_WithDifferentStrokeWidths_AppliesStyleToSeries(int width)
+        public void ConvertSeriesProperties_WithDifferentStrokeWidths_AppliesStyleToSeries(int width)
         {
             // Setup
             var converter = new ChartAreaDataConverter();
-            var style = new ChartAreaStyle(Color.Red, Color.Red, width);
+            var areaSeries = new AreaSeries();
             var data = new ChartAreaData("test")
             {
-                Style = style
+                Style = new ChartAreaStyle(Color.Red, Color.Red, width)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, areaSeries);
 
             // Assert
-            var areaSeries = (AreaSeries) series[0];
             Assert.AreEqual(width, areaSeries.StrokeThickness);
         }
 
-        private void AssertColors(Color color, OxyColor oxyColor)
+        private static void AssertColors(Color color, OxyColor oxyColor)
         {
-            OxyColor originalColor = OxyColor.FromArgb(color.A, color.R, color.G, color.B);
-            Assert.AreEqual(originalColor, oxyColor);
+            Assert.AreEqual(OxyColor.FromArgb(color.A, color.R, color.G, color.B), oxyColor);
         }
     }
 }
\ No newline at end of file
Fisheye: Tag 4dbfc20ef0200e34db43efeb8899d72e4046cc5b refers to a dead (removed) revision in file `Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartDataCollectionConverterTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 4dbfc20ef0200e34db43efeb8899d72e4046cc5b refers to a dead (removed) revision in file `Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartDataConverterTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartDataHelperTest.cs
===================================================================
diff -u -r56ec7114c4c96eeee4a1bb16d0ecac2bb10a49b8 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartDataHelperTest.cs	(.../ChartDataHelperTest.cs)	(revision 56ec7114c4c96eeee4a1bb16d0ecac2bb10a49b8)
+++ Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartDataHelperTest.cs	(.../ChartDataHelperTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -169,6 +169,16 @@
             Assert.AreEqual(MarkerType.Triangle, markerType);
         }
 
+        [Test]
+        public void Convert_UnknownChartPointSymbol_ThrowsInvalidEnumArgumentException()
+        {
+            // Call
+            TestDelegate call = () => ChartDataHelper.Convert((ChartPointSymbol) 10);
+
+            // Assert
+            Assert.Throws<InvalidEnumArgumentException>(call);
+        }
+
         #endregion
     }
 }
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartLineDataConverterTest.cs
===================================================================
diff -u -rce31448a066c084f755439f3e7d453bfb042b291 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartLineDataConverterTest.cs	(.../ChartLineDataConverterTest.cs)	(revision ce31448a066c084f755439f3e7d453bfb042b291)
+++ Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartLineDataConverterTest.cs	(.../ChartLineDataConverterTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -20,16 +20,13 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Drawing;
 using System.Drawing.Drawing2D;
 using System.Linq;
 using Core.Common.Base.Geometry;
-using Core.Common.TestUtil;
 using Core.Components.Charting.Data;
 using Core.Components.Charting.Styles;
-using Core.Components.Charting.TestUtil;
 using Core.Components.OxyPlot.Converter;
 using NUnit.Framework;
 using OxyPlot;
@@ -47,42 +44,15 @@
             var converter = new ChartLineDataConverter();
 
             // Assert
-            Assert.IsInstanceOf<ChartDataConverter<ChartLineData>>(converter);
+            Assert.IsInstanceOf<ItemBasedChartDataConverter<ChartLineData, LineSeries>>(converter);
         }
 
         [Test]
-        public void CanConvertSeries_LineData_ReturnTrue()
+        public void ConvertSeriesItems_ChartLineDataWithRandomPointData_ConvertsAllPointsToLineSeries()
         {
             // Setup
             var converter = new ChartLineDataConverter();
-            var lineData = new ChartLineData("test data");
-
-            // Call
-            var canConvert = converter.CanConvertSeries(lineData);
-
-            // Assert
-            Assert.IsTrue(canConvert);
-        }
-
-        [Test]
-        public void CanConvertSeries_ChartData_ReturnsFalse()
-        {
-            // Setup
-            var converter = new ChartLineDataConverter();
-            var chartData = new TestChartData();
-
-            // Call
-            var canConvert = converter.CanConvertSeries(chartData);
-
-            // Assert
-            Assert.IsFalse(canConvert);
-        }
-
-        [Test]
-        public void Convert_RandomPointData_ReturnsNewSeries()
-        {
-            // Setup
-            var converter = new ChartLineDataConverter();
+            var lineSeries = new LineSeries();
             var random = new Random(21);
             var randomCount = random.Next(5, 10);
             var points = new Collection<Point2D>();
@@ -98,88 +68,52 @@
             };
 
             // Call
-            var series = converter.Convert(lineData);
+            converter.ConvertSeriesItems(lineData, lineSeries);
 
             // Assert
-            Assert.IsInstanceOf<IList<Series>>(series);
-            var lineSeries = (LineSeries) series[0];
-            CollectionAssert.AreEqual(points, lineSeries.ItemsSource);
-            Assert.AreNotSame(lineData.Points, lineSeries.ItemsSource);
+            CollectionAssert.AreEqual(points.Select(p => new DataPoint(p.X, p.Y)), lineSeries.ItemsSource);
         }
 
         [Test]
-        public void Convert_DataNull_ThrowsArgumentNullException()
-        {
-            // Setup
-            var testConverter = new ChartLineDataConverter();
-
-            // Call
-            TestDelegate test = () => testConverter.Convert(null);
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(test);
-        }
-
-        [Test]
-        public void Convert_DataCannotBeConverted_ThrowsArgumentException()
-        {
-            // Setup
-            var testConverter = new ChartLineDataConverter();
-            var testChartData = new TestChartData();
-
-            // Precondition
-            Assert.IsFalse(testConverter.CanConvertSeries(testChartData));
-
-            // Call
-            TestDelegate test = () => testConverter.Convert(testChartData);
-
-            // Assert
-            var expectedMessage = string.Format("The data of type {0} cannot be converted by this converter.", testChartData.GetType());
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
         [TestCase(KnownColor.AliceBlue)]
         [TestCase(KnownColor.Azure)]
         [TestCase(KnownColor.Beige)]
-        public void Convert_WithDifferentColors_AppliesStyleToSeries(KnownColor color)
+        public void ConvertSeriesProperties_ChartLineStyleSetWithDifferentColors_AppliesStyleToSeries(KnownColor color)
         {
             // Setup
             var converter = new ChartLineDataConverter();
+            var lineSeries = new LineSeries();
             var expectedColor = Color.FromKnownColor(color);
-            var style = new ChartLineStyle(expectedColor, 3, DashStyle.Solid);
             var data = new ChartLineData("test")
             {
-                Style = style
+                Style = new ChartLineStyle(expectedColor, 3, DashStyle.Solid)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, lineSeries);
 
             // Assert
-            var lineSeries = (LineSeries) series[0];
-            AssertColors(style.Color, lineSeries.Color);
+            AssertColors(expectedColor, lineSeries.Color);
         }
 
         [Test]
         [TestCase(1)]
         [TestCase(5)]
         [TestCase(7)]
-        public void Convert_WithDifferentWidths_AppliesStyleToSeries(int width)
+        public void ConvertSeriesProperties_ChartLineStyleSetWithDifferentWidths_AppliesStyleToSeries(int width)
         {
             // Setup
             var converter = new ChartLineDataConverter();
-            var style = new ChartLineStyle(Color.Red, width, DashStyle.Solid);
+            var lineSeries = new LineSeries();
             var data = new ChartLineData("test")
             {
-                Style = style
+                Style = new ChartLineStyle(Color.Red, width, DashStyle.Solid)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, lineSeries);
 
             // Assert
-            var lineSeries = (LineSeries) series[0];
             Assert.AreEqual(width, lineSeries.StrokeThickness);
         }
 
@@ -189,28 +123,26 @@
         [TestCase(DashStyle.Dot, LineStyle.Dot)]
         [TestCase(DashStyle.DashDot, LineStyle.DashDot)]
         [TestCase(DashStyle.DashDotDot, LineStyle.DashDotDot)]
-        public void Convert_WithDifferentDashStyles_AppliesStyleToSeries(DashStyle dashStyle, LineStyle expectedLineStyle)
+        public void ConvertSeriesProperties_ChartLineStyleSetWithDifferentDashStyles_AppliesStyleToSeries(DashStyle dashStyle, LineStyle expectedLineStyle)
         {
             // Setup
             var converter = new ChartLineDataConverter();
-            var style = new ChartLineStyle(Color.Red, 3, dashStyle);
+            var lineSeries = new LineSeries();
             var data = new ChartLineData("test")
             {
-                Style = style
+                Style = new ChartLineStyle(Color.Red, 3, dashStyle)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, lineSeries);
 
             // Assert
-            var lineSeries = (LineSeries) series[0];
             Assert.AreEqual(expectedLineStyle, lineSeries.LineStyle);
         }
 
-        private void AssertColors(Color color, OxyColor oxyColor)
+        private static void AssertColors(Color color, OxyColor oxyColor)
         {
-            OxyColor originalColor = OxyColor.FromArgb(color.A, color.R, color.G, color.B);
-            Assert.AreEqual(originalColor, oxyColor);
+            Assert.AreEqual(OxyColor.FromArgb(color.A, color.R, color.G, color.B), oxyColor);
         }
     }
 }
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartMultipleAreaDataConverterTest.cs
===================================================================
diff -u -rce31448a066c084f755439f3e7d453bfb042b291 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartMultipleAreaDataConverterTest.cs	(.../ChartMultipleAreaDataConverterTest.cs)	(revision ce31448a066c084f755439f3e7d453bfb042b291)
+++ Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartMultipleAreaDataConverterTest.cs	(.../ChartMultipleAreaDataConverterTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -25,15 +25,12 @@
 using System.Drawing;
 using System.Linq;
 using Core.Common.Base.Geometry;
-using Core.Common.TestUtil;
 using Core.Components.Charting.Data;
 using Core.Components.Charting.Styles;
-using Core.Components.Charting.TestUtil;
 using Core.Components.OxyPlot.Converter;
 using Core.Components.OxyPlot.CustomSeries;
 using NUnit.Framework;
 using OxyPlot;
-using OxyPlot.Series;
 
 namespace Core.Components.OxyPlot.Test.Converter
 {
@@ -47,55 +44,31 @@
             var converter = new ChartMultipleAreaDataConverter();
 
             // Assert
-            Assert.IsInstanceOf<ChartDataConverter<ChartMultipleAreaData>>(converter);
+            Assert.IsInstanceOf<ItemBasedChartDataConverter<ChartMultipleAreaData, MultipleAreaSeries>>(converter);
         }
 
         [Test]
-        public void CanConvertSeries_AreaData_ReturnTrue()
+        public void ConvertSeriesItems_ChartMultipleAreaDataWithRandomAreaData_ConvertsAllAreasToMultipleAreaSeries()
         {
             // Setup
             var converter = new ChartMultipleAreaDataConverter();
-            var areaData = new ChartMultipleAreaData("test data");
-
-            // Call
-            var canConvert = converter.CanConvertSeries(areaData);
-
-            // Assert
-            Assert.IsTrue(canConvert);
-        }
-
-        [Test]
-        public void CanConvertSeries_ChartData_ReturnsFalse()
-        {
-            // Setup
-            var converter = new ChartMultipleAreaDataConverter();
-            var chartData = new TestChartData();
-
-            // Call
-            var canConvert = converter.CanConvertSeries(chartData);
-
-            // Assert
-            Assert.IsFalse(canConvert);
-        }
-
-        [Test]
-        public void Convert_RandomAreaData_ReturnsNewSeries()
-        {
-            // Setup
-            var converter = new ChartMultipleAreaDataConverter();
+            var multipleAreaSeries = new MultipleAreaSeries();
             var random = new Random(21);
             var randomCount = random.Next(5, 10);
 
-            var points = new Collection<Point2D>();
+            var points1 = new Collection<Point2D>();
+            var points2 = new Collection<Point2D>();
 
             for (var i = 0; i < randomCount; i++)
             {
-                points.Add(new Point2D(random.NextDouble(), random.NextDouble()));
+                points1.Add(new Point2D(random.NextDouble(), random.NextDouble()));
+                points2.Add(new Point2D(random.NextDouble(), random.NextDouble()));
             }
 
             var areas = new List<Point2D[]>
             {
-                points.ToArray()
+                points1.ToArray(),
+                points2.ToArray()
             };
 
             var areaData = new ChartMultipleAreaData("test data")
@@ -104,118 +77,82 @@
             };
 
             // Call
-            var series = converter.Convert(areaData);
+            converter.ConvertSeriesItems(areaData, multipleAreaSeries);
 
             // Assert
-            Assert.IsInstanceOf<IList<Series>>(series);
-            var areaSeries = (MultipleAreaSeries) series[0];
-            var expectedData = areas.ElementAt(0).Select(t => new DataPoint(t.X, t.Y)).ToArray();
-            CollectionAssert.AreEqual(expectedData, areaSeries.Areas[0]);
+            Assert.AreEqual(2, multipleAreaSeries.Areas.Count);
+            CollectionAssert.AreEqual(areas.ElementAt(0).Select(t => new DataPoint(t.X, t.Y)), multipleAreaSeries.Areas[0]);
+            CollectionAssert.AreEqual(areas.ElementAt(1).Select(t => new DataPoint(t.X, t.Y)), multipleAreaSeries.Areas[1]);
         }
 
         [Test]
-        public void Convert_DataNull_ThrowsArgumentNullException()
-        {
-            // Setup
-            var testConverter = new ChartMultipleAreaDataConverter();
-
-            // Call
-            TestDelegate test = () => testConverter.Convert(null);
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(test);
-        }
-
-        [Test]
-        public void Convert_DataCannotBeConverted_ThrowsArgumentException()
-        {
-            // Setup
-            var testConverter = new ChartMultipleAreaDataConverter();
-            var testChartData = new TestChartData();
-
-            // Precondition
-            Assert.IsFalse(testConverter.CanConvertSeries(testChartData));
-
-            // Call
-            TestDelegate test = () => testConverter.Convert(testChartData);
-
-            // Assert
-            var expectedMessage = string.Format("The data of type {0} cannot be converted by this converter.", testChartData.GetType());
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
         [TestCase(KnownColor.AliceBlue)]
         [TestCase(KnownColor.Azure)]
         [TestCase(KnownColor.Beige)]
-        public void Convert_WithDifferentFillColors_AppliesStyleToSeries(KnownColor color)
+        public void ConvertSeriesProperties_ChartAreaStyleSetWithDifferentFillColors_AppliesStyleToSeries(KnownColor color)
         {
             // Setup
             var converter = new ChartMultipleAreaDataConverter();
+            var multipleAreaSeries = new MultipleAreaSeries();
             var expectedColor = Color.FromKnownColor(color);
-            var style = new ChartAreaStyle(expectedColor, Color.Red, 3);
             var data = new ChartMultipleAreaData("test")
             {
-                Style = style
+                Style = new ChartAreaStyle(expectedColor, Color.Red, 3)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, multipleAreaSeries);
 
             // Assert
-            var multipleAreaSeries = (MultipleAreaSeries) series[0];
-            AssertColors(style.FillColor, multipleAreaSeries.Fill);
+            AssertColors(expectedColor, multipleAreaSeries.Fill);
         }
 
         [Test]
         [TestCase(KnownColor.AliceBlue)]
         [TestCase(KnownColor.Azure)]
         [TestCase(KnownColor.Beige)]
-        public void Convert_WithDifferentStrokeColors_AppliesStyleToSeries(KnownColor color)
+        public void ConvertSeriesProperties_ChartAreaStyleSetWithDifferentStrokeColors_AppliesStyleToSeries(KnownColor color)
         {
             // Setup
             var converter = new ChartMultipleAreaDataConverter();
+            var multipleAreaSeries = new MultipleAreaSeries();
             var expectedColor = Color.FromKnownColor(color);
-            var style = new ChartAreaStyle(Color.Red, expectedColor, 3);
             var data = new ChartMultipleAreaData("test")
             {
-                Style = style
+                Style = new ChartAreaStyle(Color.Red, expectedColor, 3)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, multipleAreaSeries);
 
             // Assert
-            var multipleAreaSeries = (MultipleAreaSeries) series[0];
-            AssertColors(style.StrokeColor, multipleAreaSeries.Color);
+            AssertColors(expectedColor, multipleAreaSeries.Color);
         }
 
         [Test]
         [TestCase(1)]
         [TestCase(5)]
         [TestCase(7)]
-        public void Convert_WithDifferentStrokeWidths_AppliesStyleToSeries(int width)
+        public void ConvertSeriesProperties_ChartAreaStyleSetWithDifferentStrokeWidths_AppliesStyleToSeries(int width)
         {
             // Setup
             var converter = new ChartMultipleAreaDataConverter();
-            var style = new ChartAreaStyle(Color.Red, Color.Red, width);
+            var multipleAreaSeries = new MultipleAreaSeries();
             var data = new ChartMultipleAreaData("test")
             {
-                Style = style
+                Style = new ChartAreaStyle(Color.Red, Color.Red, width)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, multipleAreaSeries);
 
             // Assert
-            var multipleAreaSeries = (MultipleAreaSeries) series[0];
             Assert.AreEqual(width, multipleAreaSeries.StrokeThickness);
         }
 
-        private void AssertColors(Color color, OxyColor oxyColor)
+        private static void AssertColors(Color color, OxyColor oxyColor)
         {
-            OxyColor originalColor = OxyColor.FromArgb(color.A, color.R, color.G, color.B);
-            Assert.AreEqual(originalColor, oxyColor);
+            Assert.AreEqual(OxyColor.FromArgb(color.A, color.R, color.G, color.B), oxyColor);
         }
     }
 }
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartPointDataConverterTest.cs
===================================================================
diff -u -rce31448a066c084f755439f3e7d453bfb042b291 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartPointDataConverterTest.cs	(.../ChartPointDataConverterTest.cs)	(revision ce31448a066c084f755439f3e7d453bfb042b291)
+++ Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartPointDataConverterTest.cs	(.../ChartPointDataConverterTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -20,15 +20,12 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Drawing;
 using System.Linq;
 using Core.Common.Base.Geometry;
-using Core.Common.TestUtil;
 using Core.Components.Charting.Data;
 using Core.Components.Charting.Styles;
-using Core.Components.Charting.TestUtil;
 using Core.Components.OxyPlot.Converter;
 using NUnit.Framework;
 using OxyPlot;
@@ -46,42 +43,15 @@
             var converter = new ChartPointDataConverter();
 
             // Assert
-            Assert.IsInstanceOf<ChartDataConverter<ChartPointData>>(converter);
+            Assert.IsInstanceOf<ItemBasedChartDataConverter<ChartPointData, LineSeries>>(converter);
         }
 
         [Test]
-        public void CanConvertSeries_PointData_ReturnTrue()
+        public void ConvertSeriesItems_ChartPointDataWithRandomPointData_ConvertsAllPointsToPointSeries()
         {
             // Setup
             var converter = new ChartPointDataConverter();
-            var pointData = new ChartPointData("test data");
-
-            // Call
-            var canConvert = converter.CanConvertSeries(pointData);
-
-            // Assert
-            Assert.IsTrue(canConvert);
-        }
-
-        [Test]
-        public void CanConvertSeries_ChartData_ReturnsFalse()
-        {
-            // Setup
-            var converter = new ChartPointDataConverter();
-            var chartData = new TestChartData();
-
-            // Call
-            var canConvert = converter.CanConvertSeries(chartData);
-
-            // Assert
-            Assert.IsFalse(canConvert);
-        }
-
-        [Test]
-        public void Convert_RandomPointData_ReturnsNewSeries()
-        {
-            // Setup
-            var converter = new ChartPointDataConverter();
+            var lineSeries = new LineSeries();
             var random = new Random(21);
             var randomCount = random.Next(5, 10);
 
@@ -98,135 +68,95 @@
             };
 
             // Call
-            var series = converter.Convert(pointData);
+            converter.ConvertSeriesItems(pointData, lineSeries);
 
             // Assert
-            Assert.IsInstanceOf<IList<Series>>(series);
-            var lineSeries = (LineSeries) series[0];
-            CollectionAssert.AreEqual(points, lineSeries.ItemsSource);
-            Assert.AreNotSame(pointData.Points, lineSeries.ItemsSource);
-            Assert.AreEqual(LineStyle.None, lineSeries.LineStyle);
-            Assert.AreEqual(MarkerType.Circle, lineSeries.MarkerType);
+            CollectionAssert.AreEqual(points.Select(p => new DataPoint(p.X, p.Y)), lineSeries.ItemsSource);
         }
 
         [Test]
-        public void Convert_DataNull_ThrowsArgumentNullException()
-        {
-            // Setup
-            var testConverter = new ChartPointDataConverter();
-
-            // Call
-            TestDelegate test = () => testConverter.Convert(null);
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(test);
-        }
-
-        [Test]
-        public void Convert_DataCannotBeConverted_ThrowsArgumentException()
-        {
-            // Setup
-            var testConverter = new ChartPointDataConverter();
-            var testChartData = new TestChartData();
-
-            // Precondition
-            Assert.IsFalse(testConverter.CanConvertSeries(testChartData));
-
-            // Call
-            TestDelegate test = () => testConverter.Convert(testChartData);
-
-            // Assert
-            var expectedMessage = string.Format("The data of type {0} cannot be converted by this converter.", testChartData.GetType());
-            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
-        }
-
-        [Test]
         [TestCase(KnownColor.AliceBlue)]
         [TestCase(KnownColor.Azure)]
         [TestCase(KnownColor.Beige)]
-        public void Convert_WithDifferentColors_AppliesStyleToSeries(KnownColor color)
+        public void ConvertSeriesProperties_ChartPointStyleSetWithDifferentColors_AppliesStyleToSeries(KnownColor color)
         {
             // Setup
             var converter = new ChartPointDataConverter();
+            var lineSeries = new LineSeries();
             var expectedColor = Color.FromKnownColor(color);
-            var style = new ChartPointStyle(expectedColor, 3, Color.Red, 2, ChartPointSymbol.Circle);
             var data = new ChartPointData("test")
             {
-                Style = style
+                Style = new ChartPointStyle(expectedColor, 3, Color.Red, 2, ChartPointSymbol.Circle)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, lineSeries);
 
             // Assert
-            var lineSeries = (LineSeries) series[0];
-            AssertColors(style.Color, lineSeries.MarkerFill);
+            AssertColors(expectedColor, lineSeries.MarkerFill);
         }
 
         [Test]
         [TestCase(KnownColor.AliceBlue)]
         [TestCase(KnownColor.Azure)]
         [TestCase(KnownColor.Beige)]
-        public void Convert_WithDifferentStrokeColors_AppliesStyleToSeries(KnownColor color)
+        public void ConvertSeriesProperties_ChartPointStyleSetWithDifferentStrokeColors_AppliesStyleToSeries(KnownColor color)
         {
             // Setup
             var converter = new ChartPointDataConverter();
+            var lineSeries = new LineSeries();
             var expectedColor = Color.FromKnownColor(color);
-            var style = new ChartPointStyle(Color.Red, 3, expectedColor, 2, ChartPointSymbol.Circle);
             var data = new ChartPointData("test")
             {
-                Style = style
+                Style = new ChartPointStyle(Color.Red, 3, expectedColor, 2, ChartPointSymbol.Circle)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, lineSeries);
 
             // Assert
-            var lineSeries = (LineSeries) series[0];
-            AssertColors(style.StrokeColor, lineSeries.MarkerStroke);
+            AssertColors(expectedColor, lineSeries.MarkerStroke);
         }
 
         [Test]
         [TestCase(1)]
         [TestCase(5)]
         [TestCase(7)]
-        public void Convert_WithDifferentWidths_AppliesStyleToSeries(int width)
+        public void ConvertSeriesProperties_ChartPointStyleSetWithDifferentWidths_AppliesStyleToSeries(int width)
         {
             // Setup
             var converter = new ChartPointDataConverter();
-            var style = new ChartPointStyle(Color.Red, width, Color.Red, 2, ChartPointSymbol.Circle);
+            var lineSeries = new LineSeries();
             var data = new ChartPointData("test")
             {
-                Style = style
+                Style = new ChartPointStyle(Color.Red, width, Color.Red, 2, ChartPointSymbol.Circle)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, lineSeries);
 
             // Assert
-            var lineSeries = (LineSeries) series[0];
             Assert.AreEqual(width, lineSeries.MarkerSize);
         }
 
         [Test]
         [TestCase(1)]
         [TestCase(5)]
         [TestCase(7)]
-        public void Convert_WithDifferentStrokeThickness_AppliesStyleToSeries(int strokeThickness)
+        public void ConvertSeriesProperties_ChartPointStyleSetWithDifferentStrokeThickness_AppliesStyleToSeries(int strokeThickness)
         {
             // Setup
             var converter = new ChartPointDataConverter();
-            var style = new ChartPointStyle(Color.Red, 3, Color.Red, strokeThickness, ChartPointSymbol.Circle);
+            var lineSeries = new LineSeries();
             var data = new ChartPointData("test")
             {
-                Style = style
+                Style = new ChartPointStyle(Color.Red, 3, Color.Red, strokeThickness, ChartPointSymbol.Circle)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, lineSeries);
 
             // Assert
-            var lineSeries = (LineSeries) series[0];
             Assert.AreEqual(strokeThickness, lineSeries.MarkerStrokeThickness);
         }
 
@@ -236,28 +166,26 @@
         [TestCase(ChartPointSymbol.Square, MarkerType.Square)]
         [TestCase(ChartPointSymbol.Diamond, MarkerType.Diamond)]
         [TestCase(ChartPointSymbol.Triangle, MarkerType.Triangle)]
-        public void Convert_WithDifferentChartPointSymbols_AppliesStyleToSeries(ChartPointSymbol symbol, MarkerType expectedMarkerType)
+        public void ConvertSeriesProperties_ChartPointStyleSetWithDifferentChartPointSymbols_AppliesStyleToSeries(ChartPointSymbol symbol, MarkerType expectedMarkerType)
         {
             // Setup
             var converter = new ChartPointDataConverter();
-            var style = new ChartPointStyle(Color.Red, 3, Color.Red, 2, symbol);
+            var lineSeries = new LineSeries();
             var data = new ChartPointData("test")
             {
-                Style = style
+                Style = new ChartPointStyle(Color.Red, 3, Color.Red, 2, symbol)
             };
 
             // Call
-            var series = converter.Convert(data);
+            converter.ConvertSeriesProperties(data, lineSeries);
 
             // Assert
-            var lineSeries = (LineSeries) series[0];
             Assert.AreEqual(expectedMarkerType, lineSeries.MarkerType);
         }
 
-        private void AssertColors(Color color, OxyColor oxyColor)
+        private static void AssertColors(Color color, OxyColor oxyColor)
         {
-            OxyColor originalColor = OxyColor.FromArgb(color.A, color.R, color.G, color.B);
-            Assert.AreEqual(originalColor, oxyColor);
+            Assert.AreEqual(OxyColor.FromArgb(color.A, color.R, color.G, color.B), oxyColor);
         }
     }
 }
\ No newline at end of file
Fisheye: Tag 4dbfc20ef0200e34db43efeb8899d72e4046cc5b refers to a dead (removed) revision in file `Core/Components/test/Core.Components.OxyPlot.Test/Converter/ChartSeriesFactoryTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Core/Components/test/Core.Components.OxyPlot.Test/Converter/ItemBasedChartDataConverterTest.cs
===================================================================
diff -u
--- Core/Components/test/Core.Components.OxyPlot.Test/Converter/ItemBasedChartDataConverterTest.cs	(revision 0)
+++ Core/Components/test/Core.Components.OxyPlot.Test/Converter/ItemBasedChartDataConverterTest.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,143 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Common.TestUtil;
+using Core.Components.Charting.Data;
+using Core.Components.OxyPlot.Converter;
+using NUnit.Framework;
+using OxyPlot.Series;
+
+namespace Core.Components.OxyPlot.Test.Converter
+{
+    [TestFixture]
+    public class ItemBasedChartDataConverterTest
+    {
+        [Test]
+        public void ConvertSeriesItems_DataNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var testConverter = new TestItemBasedChartDataConverter();
+            var series = new TestSeries();
+
+            // Call
+            TestDelegate test = () => testConverter.ConvertSeriesItems(null, series);
+
+            // Assert
+            const string expectedMessage = "Null data cannot be converted into series data.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void ConvertSeriesItems_TargetSeriesNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var testConverter = new TestItemBasedChartDataConverter();
+            var chartData = new TestItemBasedChartData("test data");
+
+            // Call
+            TestDelegate test = () => testConverter.ConvertSeriesItems(chartData, null);
+
+            // Assert
+            const string expectedMessage = "Null data cannot be used as conversion target.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void ConvertSeriesProperties_DataNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var testConverter = new TestItemBasedChartDataConverter();
+            var series = new TestSeries();
+
+            // Call
+            TestDelegate test = () => testConverter.ConvertSeriesProperties(null, series);
+
+            // Assert
+            const string expectedMessage = "Null data cannot be converted into series data.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void ConvertSeriesProperties_TargetSeriesNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var testConverter = new TestItemBasedChartDataConverter();
+            var chartData = new TestItemBasedChartData("test data");
+
+            // Call
+            TestDelegate test = () => testConverter.ConvertSeriesProperties(chartData, null);
+
+            // Assert
+            const string expectedMessage = "Null data cannot be used as conversion target.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void ConvertSeriesProperties_ChartData_NameSetToSeries()
+        {
+            // Setup
+            var name = "<Some name>";
+            var testConverter = new TestItemBasedChartDataConverter();
+            var chartData = new TestItemBasedChartData(name);
+            var chartSeries = new TestSeries();
+
+            // Call
+            testConverter.ConvertSeriesProperties(chartData, chartSeries);
+
+            // Assert
+            Assert.AreEqual(name, chartSeries.Title);
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void ConvertSeriesProperties_ChartData_IsVisibleSetToSeries(bool isVisible)
+        {
+            // Setup
+            var testConverter = new TestItemBasedChartDataConverter();
+            var chartData = new TestItemBasedChartData("test data")
+            {
+                IsVisible = isVisible
+            };
+            var chartSeries = new TestSeries();
+
+            // Call
+            testConverter.ConvertSeriesProperties(chartData, chartSeries);
+
+            // Assert
+            Assert.AreEqual(isVisible, chartSeries.IsVisible);
+        }
+
+        private class TestSeries : LineSeries {}
+
+        private class TestItemBasedChartData : ItemBasedChartData
+        {
+            public TestItemBasedChartData(string name) : base(name) {}
+        }
+
+        private class TestItemBasedChartDataConverter : ItemBasedChartDataConverter<TestItemBasedChartData, TestSeries>
+        {
+            protected override void SetSeriesItems(TestItemBasedChartData data, TestSeries series) {}
+
+            protected override void SetSeriesStyle(TestItemBasedChartData data, TestSeries series) {}
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/Core.Components.OxyPlot.Test.csproj
===================================================================
diff -u -r2d5e2d09b0cb1a7f48e1b0a067d332347c89d4a8 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.OxyPlot.Test/Core.Components.OxyPlot.Test.csproj	(.../Core.Components.OxyPlot.Test.csproj)	(revision 2d5e2d09b0cb1a7f48e1b0a067d332347c89d4a8)
+++ Core/Components/test/Core.Components.OxyPlot.Test/Core.Components.OxyPlot.Test.csproj	(.../Core.Components.OxyPlot.Test.csproj)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -59,16 +59,19 @@
       <Link>Properties\GlobalAssembly.cs</Link>
     </Compile>
     <Compile Include="Converter\ChartAreaDataConverterTest.cs" />
-    <Compile Include="Converter\ChartDataCollectionConverterTest.cs" />
-    <Compile Include="Converter\ChartDataConverterTest.cs" />
+    <Compile Include="Converter\ItemBasedChartDataConverterTest.cs" />
     <Compile Include="Converter\ChartDataHelperTest.cs" />
     <Compile Include="Converter\ChartLineDataConverterTest.cs" />
     <Compile Include="Converter\ChartMultipleAreaDataConverterTest.cs" />
     <Compile Include="Converter\ChartPointDataConverterTest.cs" />
     <Compile Include="CustomSeries\MultipleAreaSeriesTest.cs" />
+    <Compile Include="DataSeries\ChartPointDataSeriesTest.cs" />
+    <Compile Include="DataSeries\ChartLineDataSeriesTest.cs" />
+    <Compile Include="DataSeries\ChartAreaDataSeriesTest.cs" />
+    <Compile Include="DataSeries\ChartMultipleAreaDataSeriesTest.cs" />
     <Compile Include="DynamicPlotControllerTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Converter\ChartSeriesFactoryTest.cs" />
+    <Compile Include="DataSeries\ItemBasedChartDataSeriesFactoryTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\..\..\build\Copying.Lesser.licenseheader">
Index: Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartAreaDataSeriesTest.cs
===================================================================
diff -u
--- Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartAreaDataSeriesTest.cs	(revision 0)
+++ Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartAreaDataSeriesTest.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,167 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Drawing;
+using Core.Common.Base.Geometry;
+using Core.Components.Charting.Data;
+using Core.Components.Charting.Styles;
+using Core.Components.OxyPlot.DataSeries;
+using NUnit.Framework;
+using OxyPlot;
+using OxyPlot.Series;
+
+namespace Core.Components.OxyPlot.Test.DataSeries
+{
+    [TestFixture]
+    public class ChartAreaDataSeriesTest
+    {
+        [Test]
+        public void Constructor_WithoutChartAreaData_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new ChartAreaDataSeries(null);
+
+            // Assert
+            string parameter = Assert.Throws<ArgumentNullException>(test).ParamName;
+            Assert.AreEqual("chartAreaData", parameter);
+        }
+
+        [Test]
+        public void Constructor_ChartAreaDataWithTestProperties_ChartAreaDataSeriesCreatedAccordingly()
+        {
+            // Setup
+            var chartAreaData = new ChartAreaData("Test name");
+
+            SetChartAreaDataTestProperties(chartAreaData);
+
+            // Call
+            var chartAreaDataSeries = new ChartAreaDataSeries(chartAreaData);
+
+            // Assert
+            Assert.IsInstanceOf<AreaSeries>(chartAreaDataSeries);
+            Assert.IsInstanceOf<IItemBasedChartDataSeries>(chartAreaDataSeries);
+            AssertChartAreaDataSeriesTestProperties(chartAreaDataSeries);
+        }
+
+        [Test]
+        public void Update_ChartAreaDataWithTestProperties_ChartAreaDataSeriesUpdatedAccordingly()
+        {
+            // Setup
+            var chartAreaData = new ChartAreaData("Test name");
+            var chartAreaDataSeries = new ChartAreaDataSeries(chartAreaData);
+
+            SetChartAreaDataTestProperties(chartAreaData);
+
+            // Precondition
+            AssertChartAreaDataSeriesDefaultProperties(chartAreaDataSeries);
+
+            // Call
+            chartAreaDataSeries.Update();
+
+            // Assert
+            AssertChartAreaDataSeriesTestProperties(chartAreaDataSeries);
+        }
+
+        [Test]
+        public void GivenChartAreaDataSeries_WhenUpdatedAfterChartAreaDataPointsChanged_ChartAreaDataSeriesPointsChanged()
+        {
+            // Given
+            var chartAreaData = new ChartAreaData("Test name")
+            {
+                Points = new[]
+                {
+                    new Point2D(1.1, 2.2)
+                }
+            };
+
+            var chartAreaDataSeries = new ChartAreaDataSeries(chartAreaData);
+            var drawnPoints = chartAreaDataSeries.Points.ToArray();
+
+            // When
+            chartAreaData.Points = new[]
+            {
+                new Point2D(3.3, 4.4)
+            };
+            chartAreaDataSeries.Update();
+
+            // Then
+            CollectionAssert.AreNotEqual(drawnPoints, chartAreaDataSeries.Points);
+        }
+
+        [Test]
+        public void GivenChartAreaDataSeries_WhenUpdatedAndChartAreaDataPointsNotChanged_PreviousChartAreaDataSeriesPointsPreserved()
+        {
+            // Given
+            var chartAreaData = new ChartAreaData("Test name")
+            {
+                Points = new[]
+                {
+                    new Point2D(1.1, 2.2)
+                }
+            };
+
+            var chartAreaDataSeries = new ChartAreaDataSeries(chartAreaData);
+            var drawnPoints = chartAreaDataSeries.Points.ToArray();
+
+            // When
+            chartAreaDataSeries.Update();
+
+            // Then
+            CollectionAssert.AreEqual(drawnPoints, chartAreaDataSeries.Points);
+        }
+
+        private static void SetChartAreaDataTestProperties(ChartAreaData chartAreaData)
+        {
+            chartAreaData.Name = "Another name";
+            chartAreaData.IsVisible = false;
+            chartAreaData.Style = new ChartAreaStyle(Color.Red, Color.Blue, 3);
+            chartAreaData.Points = new[]
+            {
+                new Point2D(1.1, 2.2)
+            };
+        }
+
+        private static void AssertChartAreaDataSeriesTestProperties(ChartAreaDataSeries chartAreaDataSeries)
+        {
+            Assert.AreEqual("Another name", chartAreaDataSeries.Title);
+            Assert.IsFalse(chartAreaDataSeries.IsVisible);
+
+            Assert.AreEqual(3, chartAreaDataSeries.StrokeThickness);
+            Assert.AreEqual(OxyColor.FromArgb(Color.Red.A, Color.Red.R, Color.Red.G, Color.Red.B), chartAreaDataSeries.Fill);
+            Assert.AreEqual(OxyColor.FromArgb(Color.Blue.A, Color.Blue.R, Color.Blue.G, Color.Blue.B), chartAreaDataSeries.Color);
+
+            Assert.AreEqual(1, chartAreaDataSeries.Points.Count);
+        }
+
+        private static void AssertChartAreaDataSeriesDefaultProperties(ChartAreaDataSeries chartAreaDataSeries)
+        {
+            Assert.AreEqual("Test name", chartAreaDataSeries.Title);
+            Assert.IsTrue(chartAreaDataSeries.IsVisible);
+
+            Assert.AreEqual(2, chartAreaDataSeries.StrokeThickness);
+            Assert.AreEqual(OxyColor.FromArgb(0, 0, 0, 1), chartAreaDataSeries.Color);
+            Assert.AreEqual(OxyColor.FromArgb(0, 0, 0, 1), chartAreaDataSeries.Fill);
+
+            Assert.AreEqual(0, chartAreaDataSeries.Points.Count);
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartLineDataSeriesTest.cs
===================================================================
diff -u
--- Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartLineDataSeriesTest.cs	(revision 0)
+++ Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartLineDataSeriesTest.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,169 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Linq;
+using Core.Common.Base.Geometry;
+using Core.Components.Charting.Data;
+using Core.Components.Charting.Styles;
+using Core.Components.OxyPlot.DataSeries;
+using NUnit.Framework;
+using OxyPlot;
+using OxyPlot.Series;
+
+namespace Core.Components.OxyPlot.Test.DataSeries
+{
+    [TestFixture]
+    public class ChartLineDataSeriesTest
+    {
+        [Test]
+        public void Constructor_WithoutChartLineData_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new ChartLineDataSeries(null);
+
+            // Assert
+            string parameter = Assert.Throws<ArgumentNullException>(test).ParamName;
+            Assert.AreEqual("chartLineData", parameter);
+        }
+
+        [Test]
+        public void Constructor_ChartLineDataWithTestProperties_ChartLineDataSeriesCreatedAccordingly()
+        {
+            // Setup
+            var chartLineData = new ChartLineData("Test name");
+
+            SetChartLineDataTestProperties(chartLineData);
+
+            // Call
+            var chartLineDataSeries = new ChartLineDataSeries(chartLineData);
+
+            // Assert
+            Assert.IsInstanceOf<LineSeries>(chartLineDataSeries);
+            Assert.IsInstanceOf<IItemBasedChartDataSeries>(chartLineDataSeries);
+            AssertChartLineDataSeriesTestProperties(chartLineDataSeries);
+        }
+
+        [Test]
+        public void Update_ChartLineDataWithTestProperties_ChartLineDataSeriesUpdatedAccordingly()
+        {
+            // Setup
+            var chartLineData = new ChartLineData("Test name");
+            var chartLineDataSeries = new ChartLineDataSeries(chartLineData);
+
+            SetChartLineDataTestProperties(chartLineData);
+
+            // Precondition
+            AssertChartLineDataSeriesDefaultProperties(chartLineDataSeries);
+
+            // Call
+            chartLineDataSeries.Update();
+
+            // Assert
+            AssertChartLineDataSeriesTestProperties(chartLineDataSeries);
+        }
+
+        [Test]
+        public void GivenChartLineDataSeries_WhenUpdatedAfterChartLineDataPointsChanged_ChartLineDataSeriesPointsChanged()
+        {
+            // Given
+            var chartLineData = new ChartLineData("Test name")
+            {
+                Points = new[]
+                {
+                    new Point2D(1.1, 2.2)
+                }
+            };
+
+            var chartLineDataSeries = new ChartLineDataSeries(chartLineData);
+            var drawnPoints = chartLineDataSeries.ItemsSource.Cast<DataPoint>();
+
+            // When
+            chartLineData.Points = new[]
+            {
+                new Point2D(3.3, 4.4)
+            };
+            chartLineDataSeries.Update();
+
+            // Then
+            CollectionAssert.AreNotEqual(drawnPoints, chartLineDataSeries.ItemsSource.Cast<DataPoint>());
+        }
+
+        [Test]
+        public void GivenChartLineDataSeries_WhenUpdatedAndChartLineDataPointsNotChanged_PreviousChartLineDataSeriesPointsPreserved()
+        {
+            // Given
+            var chartLineData = new ChartLineData("Test name")
+            {
+                Points = new[]
+                {
+                    new Point2D(1.1, 2.2)
+                }
+            };
+
+            var chartLineDataSeries = new ChartLineDataSeries(chartLineData);
+            var drawnPoints = chartLineDataSeries.ItemsSource.Cast<DataPoint>();
+
+            // When
+            chartLineDataSeries.Update();
+
+            // Then
+            CollectionAssert.AreEqual(drawnPoints, chartLineDataSeries.ItemsSource.Cast<DataPoint>());
+        }
+
+        private static void SetChartLineDataTestProperties(ChartLineData chartLineData)
+        {
+            chartLineData.Name = "Another name";
+            chartLineData.IsVisible = false;
+            chartLineData.Style = new ChartLineStyle(Color.Blue, 3, DashStyle.DashDot);
+            chartLineData.Points = new[]
+            {
+                new Point2D(1.1, 2.2)
+            };
+        }
+
+        private static void AssertChartLineDataSeriesTestProperties(ChartLineDataSeries chartLineDataSeries)
+        {
+            Assert.AreEqual("Another name", chartLineDataSeries.Title);
+            Assert.IsFalse(chartLineDataSeries.IsVisible);
+
+            Assert.AreEqual(3, chartLineDataSeries.StrokeThickness);
+            Assert.AreEqual(OxyColor.FromArgb(Color.Blue.A, Color.Blue.R, Color.Blue.G, Color.Blue.B), chartLineDataSeries.Color);
+            Assert.AreEqual(LineStyle.DashDot, chartLineDataSeries.LineStyle);
+
+            Assert.AreEqual(1, chartLineDataSeries.ItemsSource.Cast<DataPoint>().Count());
+        }
+
+        private static void AssertChartLineDataSeriesDefaultProperties(ChartLineDataSeries chartLineDataSeries)
+        {
+            Assert.AreEqual("Test name", chartLineDataSeries.Title);
+            Assert.IsTrue(chartLineDataSeries.IsVisible);
+
+            Assert.AreEqual(2, chartLineDataSeries.StrokeThickness);
+            Assert.AreEqual(OxyColor.FromArgb(0, 0, 0, 1), chartLineDataSeries.Color);
+            Assert.AreEqual(LineStyle.Automatic, chartLineDataSeries.LineStyle);
+
+            Assert.AreEqual(0, chartLineDataSeries.ItemsSource.Cast<DataPoint>().Count());
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartMultipleAreaDataSeriesTest.cs
===================================================================
diff -u
--- Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartMultipleAreaDataSeriesTest.cs	(revision 0)
+++ Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartMultipleAreaDataSeriesTest.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,179 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Drawing;
+using Core.Common.Base.Geometry;
+using Core.Components.Charting.Data;
+using Core.Components.Charting.Styles;
+using Core.Components.OxyPlot.CustomSeries;
+using Core.Components.OxyPlot.DataSeries;
+using NUnit.Framework;
+using OxyPlot;
+
+namespace Core.Components.OxyPlot.Test.DataSeries
+{
+    [TestFixture]
+    public class ChartMultipleAreaDataSeriesTest
+    {
+        [Test]
+        public void Constructor_WithoutChartMultipleAreaData_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new ChartMultipleAreaDataSeries(null);
+
+            // Assert
+            string parameter = Assert.Throws<ArgumentNullException>(test).ParamName;
+            Assert.AreEqual("chartMultipleAreaData", parameter);
+        }
+
+        [Test]
+        public void Constructor_ChartMultipleAreaDataWithTestProperties_ChartMultipleAreaDataSeriesCreatedAccordingly()
+        {
+            // Setup
+            var chartMultipleAreaData = new ChartMultipleAreaData("Test name");
+
+            SetChartMultipleAreaDataTestProperties(chartMultipleAreaData);
+
+            // Call
+            var chartMultipleAreaDataSeries = new ChartMultipleAreaDataSeries(chartMultipleAreaData);
+
+            // Assert
+            Assert.IsInstanceOf<MultipleAreaSeries>(chartMultipleAreaDataSeries);
+            Assert.IsInstanceOf<IItemBasedChartDataSeries>(chartMultipleAreaDataSeries);
+            AssertChartMultipleAreaDataSeriesTestProperties(chartMultipleAreaDataSeries);
+        }
+
+        [Test]
+        public void Update_ChartMultipleAreaDataWithTestProperties_ChartMultipleAreaDataSeriesUpdatedAccordingly()
+        {
+            // Setup
+            var chartMultipleAreaData = new ChartMultipleAreaData("Test name");
+            var chartMultipleAreaDataSeries = new ChartMultipleAreaDataSeries(chartMultipleAreaData);
+
+            SetChartMultipleAreaDataTestProperties(chartMultipleAreaData);
+
+            // Precondition
+            AssertChartMultipleAreaDataSeriesDefaultProperties(chartMultipleAreaDataSeries);
+
+            // Call
+            chartMultipleAreaDataSeries.Update();
+
+            // Assert
+            AssertChartMultipleAreaDataSeriesTestProperties(chartMultipleAreaDataSeries);
+        }
+
+        [Test]
+        public void GivenChartMultipleAreaDataSeries_WhenUpdatedAfterChartMultipleAreaDataAreasChanged_ChartMultipleAreaDataSeriesAreasChanged()
+        {
+            // Given
+            var chartMultipleAreaData = new ChartMultipleAreaData("Test name")
+            {
+                Areas = new[]
+                {
+                    new[]
+                    {
+                        new Point2D(1.1, 2.2)
+                    }
+                }
+            };
+
+            var chartMultipleAreaDataSeries = new ChartMultipleAreaDataSeries(chartMultipleAreaData);
+            var drawnAreas = chartMultipleAreaDataSeries.Areas.ToArray();
+
+            // When
+            chartMultipleAreaData.Areas = new[]
+            {
+                new[]
+                {
+                    new Point2D(3.3, 4.4)
+                }
+            };
+            chartMultipleAreaDataSeries.Update();
+
+            // Then
+            CollectionAssert.AreNotEqual(drawnAreas, chartMultipleAreaDataSeries.Areas);
+        }
+
+        [Test]
+        public void GivenChartMultipleAreaDataSeries_WhenUpdatedAndChartMultipleAreaDataAreasNotChanged_PreviousChartMultipleAreaDataSeriesAreasPreserved()
+        {
+            // Given
+            var chartMultipleAreaData = new ChartMultipleAreaData("Test name")
+            {
+                Areas = new[]
+                {
+                    new[]
+                    {
+                        new Point2D(1.1, 2.2)
+                    }
+                }
+            };
+
+            var chartMultipleAreaDataSeries = new ChartMultipleAreaDataSeries(chartMultipleAreaData);
+            var drawnAreas = chartMultipleAreaDataSeries.Areas.ToArray();
+
+            // When
+            chartMultipleAreaDataSeries.Update();
+
+            // Then
+            CollectionAssert.AreEqual(drawnAreas, chartMultipleAreaDataSeries.Areas);
+        }
+
+        private static void SetChartMultipleAreaDataTestProperties(ChartMultipleAreaData chartMultipleAreaData)
+        {
+            chartMultipleAreaData.Name = "Another name";
+            chartMultipleAreaData.IsVisible = false;
+            chartMultipleAreaData.Style = new ChartAreaStyle(Color.Red, Color.Blue, 3);
+            chartMultipleAreaData.Areas = new[]
+            {
+                new[]
+                {
+                    new Point2D(1.1, 2.2)
+                }
+            };
+        }
+
+        private static void AssertChartMultipleAreaDataSeriesTestProperties(ChartMultipleAreaDataSeries chartMultipleAreaDataSeries)
+        {
+            Assert.AreEqual("Another name", chartMultipleAreaDataSeries.Title);
+            Assert.IsFalse(chartMultipleAreaDataSeries.IsVisible);
+
+            Assert.AreEqual(3, chartMultipleAreaDataSeries.StrokeThickness);
+            Assert.AreEqual(OxyColor.FromArgb(Color.Red.A, Color.Red.R, Color.Red.G, Color.Red.B), chartMultipleAreaDataSeries.Fill);
+            Assert.AreEqual(OxyColor.FromArgb(Color.Blue.A, Color.Blue.R, Color.Blue.G, Color.Blue.B), chartMultipleAreaDataSeries.Color);
+
+            Assert.AreEqual(1, chartMultipleAreaDataSeries.Areas.Count);
+        }
+
+        private static void AssertChartMultipleAreaDataSeriesDefaultProperties(ChartMultipleAreaDataSeries chartMultipleAreaDataSeries)
+        {
+            Assert.AreEqual("Test name", chartMultipleAreaDataSeries.Title);
+            Assert.IsTrue(chartMultipleAreaDataSeries.IsVisible);
+
+            Assert.AreEqual(0, chartMultipleAreaDataSeries.StrokeThickness);
+            Assert.AreEqual(OxyColor.FromArgb(0, 0, 0, 1), chartMultipleAreaDataSeries.Color);
+            Assert.AreEqual(OxyColor.FromArgb(0, 0, 0, 1), chartMultipleAreaDataSeries.Fill);
+
+            Assert.AreEqual(0, chartMultipleAreaDataSeries.Areas.Count);
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartPointDataSeriesTest.cs
===================================================================
diff -u
--- Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartPointDataSeriesTest.cs	(revision 0)
+++ Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ChartPointDataSeriesTest.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,172 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Drawing;
+using System.Linq;
+using Core.Common.Base.Geometry;
+using Core.Components.Charting.Data;
+using Core.Components.Charting.Styles;
+using Core.Components.OxyPlot.DataSeries;
+using NUnit.Framework;
+using OxyPlot;
+using OxyPlot.Series;
+
+namespace Core.Components.OxyPlot.Test.DataSeries
+{
+    [TestFixture]
+    public class ChartPointDataSeriesTest
+    {
+        [Test]
+        public void Constructor_WithoutChartPointData_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new ChartPointDataSeries(null);
+
+            // Assert
+            string parameter = Assert.Throws<ArgumentNullException>(test).ParamName;
+            Assert.AreEqual("chartPointData", parameter);
+        }
+
+        [Test]
+        public void Constructor_ChartPointDataWithTestProperties_ChartPointDataSeriesCreatedAccordingly()
+        {
+            // Setup
+            var chartPointData = new ChartPointData("Test name");
+
+            SetChartPointDataTestProperties(chartPointData);
+
+            // Call
+            var chartPointDataSeries = new ChartPointDataSeries(chartPointData);
+
+            // Assert
+            Assert.IsInstanceOf<LineSeries>(chartPointDataSeries);
+            Assert.IsInstanceOf<IItemBasedChartDataSeries>(chartPointDataSeries);
+            AssertChartPointDataSeriesTestProperties(chartPointDataSeries);
+        }
+
+        [Test]
+        public void Update_ChartPointDataWithTestProperties_ChartPointDataSeriesUpdatedAccordingly()
+        {
+            // Setup
+            var chartPointData = new ChartPointData("Test name");
+            var chartPointDataSeries = new ChartPointDataSeries(chartPointData);
+
+            SetChartPointDataTestProperties(chartPointData);
+
+            // Precondition
+            AssertChartPointDataSeriesDefaultProperties(chartPointDataSeries);
+
+            // Call
+            chartPointDataSeries.Update();
+
+            // Assert
+            AssertChartPointDataSeriesTestProperties(chartPointDataSeries);
+        }
+
+        [Test]
+        public void GivenChartPointDataSeries_WhenUpdatedAfterChartPointDataPointsChanged_ChartPointDataSeriesPointsChanged()
+        {
+            // Given
+            var chartPointData = new ChartPointData("Test name")
+            {
+                Points = new[]
+                {
+                    new Point2D(1.1, 2.2)
+                }
+            };
+
+            var chartPointDataSeries = new ChartPointDataSeries(chartPointData);
+            var drawnPoints = chartPointDataSeries.ItemsSource.Cast<DataPoint>();
+
+            // When
+            chartPointData.Points = new[]
+            {
+                new Point2D(3.3, 4.4)
+            };
+            chartPointDataSeries.Update();
+
+            // Then
+            CollectionAssert.AreNotEqual(drawnPoints, chartPointDataSeries.ItemsSource.Cast<DataPoint>());
+        }
+
+        [Test]
+        public void GivenChartPointDataSeries_WhenUpdatedAndChartPointDataPointsNotChanged_PreviousChartPointDataSeriesPointsPreserved()
+        {
+            // Given
+            var chartPointData = new ChartPointData("Test name")
+            {
+                Points = new[]
+                {
+                    new Point2D(1.1, 2.2)
+                }
+            };
+
+            var chartPointDataSeries = new ChartPointDataSeries(chartPointData);
+            var drawnPoints = chartPointDataSeries.ItemsSource.Cast<DataPoint>();
+
+            // When
+            chartPointDataSeries.Update();
+
+            // Then
+            CollectionAssert.AreEqual(drawnPoints, chartPointDataSeries.ItemsSource.Cast<DataPoint>());
+        }
+
+        private static void SetChartPointDataTestProperties(ChartPointData chartPointData)
+        {
+            chartPointData.Name = "Another name";
+            chartPointData.IsVisible = false;
+            chartPointData.Style = new ChartPointStyle(Color.Red, 4, Color.Blue, 2, ChartPointSymbol.Circle);
+            chartPointData.Points = new[]
+            {
+                new Point2D(1.1, 2.2)
+            };
+        }
+
+        private static void AssertChartPointDataSeriesTestProperties(ChartPointDataSeries chartPointDataSeries)
+        {
+            Assert.AreEqual("Another name", chartPointDataSeries.Title);
+            Assert.IsFalse(chartPointDataSeries.IsVisible);
+
+            Assert.AreEqual(4, chartPointDataSeries.MarkerSize);
+            Assert.AreEqual(OxyColor.FromArgb(Color.Red.A, Color.Red.R, Color.Red.G, Color.Red.B), chartPointDataSeries.MarkerFill);
+            Assert.AreEqual(OxyColor.FromArgb(Color.Blue.A, Color.Blue.R, Color.Blue.G, Color.Blue.B), chartPointDataSeries.MarkerStroke);
+            Assert.AreEqual(2, chartPointDataSeries.MarkerStrokeThickness);
+            Assert.AreEqual(MarkerType.Circle, chartPointDataSeries.MarkerType);
+
+            Assert.AreEqual(1, chartPointDataSeries.ItemsSource.Cast<DataPoint>().Count());
+        }
+
+        private static void AssertChartPointDataSeriesDefaultProperties(ChartPointDataSeries chartPointDataSeries)
+        {
+            Assert.AreEqual("Test name", chartPointDataSeries.Title);
+            Assert.IsTrue(chartPointDataSeries.IsVisible);
+
+            Assert.AreEqual(3, chartPointDataSeries.MarkerSize);
+            Assert.AreEqual(OxyColor.FromArgb(0, 0, 0, 1), chartPointDataSeries.MarkerFill);
+            Assert.AreEqual(OxyColor.FromArgb(0, 0, 0, 1), chartPointDataSeries.MarkerStroke);
+            Assert.AreEqual(1, chartPointDataSeries.MarkerStrokeThickness);
+            Assert.AreEqual(MarkerType.None, chartPointDataSeries.MarkerType);
+
+            Assert.AreEqual(0, chartPointDataSeries.ItemsSource.Cast<DataPoint>().Count());
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ItemBasedChartDataSeriesFactoryTest.cs
===================================================================
diff -u
--- Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ItemBasedChartDataSeriesFactoryTest.cs	(revision 0)
+++ Core/Components/test/Core.Components.OxyPlot.Test/DataSeries/ItemBasedChartDataSeriesFactoryTest.cs	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -0,0 +1,90 @@
+// Copyright (C) Stichting Deltares 2016. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program 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 Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Components.Charting.Data;
+using Core.Components.OxyPlot.DataSeries;
+using NUnit.Framework;
+
+namespace Core.Components.OxyPlot.Test.DataSeries
+{
+    [TestFixture]
+    public class ItemBasedChartDataSeriesFactoryTest
+    {
+        [Test]
+        public void Create_ChartPointData_ReturnChartPointDataSeries()
+        {
+            // Call
+            IItemBasedChartDataSeries series = ItemBasedChartDataSeriesFactory.Create(new ChartPointData("test data"));
+
+            // Assert
+            Assert.IsInstanceOf<ChartPointDataSeries>(series);
+        }
+
+        [Test]
+        public void Create_ChartLineData_ReturnChartLineDataSeries()
+        {
+            // Call
+            IItemBasedChartDataSeries series = ItemBasedChartDataSeriesFactory.Create(new ChartLineData("test data"));
+
+            // Assert
+            Assert.IsInstanceOf<ChartLineDataSeries>(series);
+        }
+
+        [Test]
+        public void Create_ChartAreaData_ReturnChartAreaDataSeries()
+        {
+            // Call
+            IItemBasedChartDataSeries series = ItemBasedChartDataSeriesFactory.Create(new ChartAreaData("test data"));
+
+            // Assert
+            Assert.IsInstanceOf<ChartAreaDataSeries>(series);
+        }
+
+        [Test]
+        public void Create_ChartMultipleAreaData_ReturnChartMultipleAreaDataSeries()
+        {
+            // Call
+            IItemBasedChartDataSeries series = ItemBasedChartDataSeriesFactory.Create(new ChartMultipleAreaData("test data"));
+
+            // Assert
+            Assert.IsInstanceOf<ChartMultipleAreaDataSeries>(series);
+        }
+
+        [Test]
+        public void Create_OtherData_ThrownsNotSupportedException()
+        {
+            // Setup
+            var testData = new TestItemBasedChartData("test data");
+
+            // Call
+            TestDelegate test = () => ItemBasedChartDataSeriesFactory.Create(testData);
+
+            // Assert
+            Assert.Throws<NotSupportedException>(test);
+        }
+
+        private class TestItemBasedChartData : ItemBasedChartData
+        {
+            public TestItemBasedChartData(string name) : base(name) {}
+        }
+    }
+}
\ No newline at end of file
Index: Core/Components/test/Core.Components.OxyPlot.Test/DynamicPlotControllerTest.cs
===================================================================
diff -u -red96d38a758365e4c0f117def83a2926c589c18a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Core/Components/test/Core.Components.OxyPlot.Test/DynamicPlotControllerTest.cs	(.../DynamicPlotControllerTest.cs)	(revision ed96d38a758365e4c0f117def83a2926c589c18a)
+++ Core/Components/test/Core.Components.OxyPlot.Test/DynamicPlotControllerTest.cs	(.../DynamicPlotControllerTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -94,7 +94,7 @@
             Assert.AreEqual(PlotCommands.ZoomWheel, wheelZoomCommand.Command);
         }
 
-        private void AssertCustomRectangleZoomCommand(DynamicPlotController controller, int index)
+        private static void AssertCustomRectangleZoomCommand(DynamicPlotController controller, int index)
         {
             var rectangleZoomCommand = controller.InputCommandBindings[index];
             Assert.AreEqual(OxyMouseButton.Left, ((OxyMouseDownGesture) rectangleZoomCommand.Gesture).MouseButton);
Index: Demo/Ringtoets/src/Demo.Ringtoets/Views/ChartDataView.cs
===================================================================
diff -u -rae99d19be5c1bd59e6cc85669c96a3b9895e660d -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Demo/Ringtoets/src/Demo.Ringtoets/Views/ChartDataView.cs	(.../ChartDataView.cs)	(revision ae99d19be5c1bd59e6cc85669c96a3b9895e660d)
+++ Demo/Ringtoets/src/Demo.Ringtoets/Views/ChartDataView.cs	(.../ChartDataView.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -30,8 +30,6 @@
     /// </summary>
     public partial class ChartDataView : UserControl, IChartView
     {
-        private ChartDataCollection data;
-
         /// <summary>
         /// Creates a new instance of <see cref="ChartDataView"/>.
         /// </summary>
@@ -44,21 +42,11 @@
         {
             get
             {
-                return data;
+                return Chart.Data;
             }
             set
             {
-                data = (ChartDataCollection) value;
-
-                if (data != null)
-                {
-                    foreach (var chartData in data.Collection)
-                    {
-                        Chart.Data.Add(chartData);
-                    }
-
-                    Chart.Data.NotifyObservers();
-                }
+                Chart.Data = value as ChartDataCollection;
             }
         }
 
Index: Demo/Ringtoets/test/Demo.Ringtoets.Test/Views/ChartDataViewTest.cs
===================================================================
diff -u -rfea3ed82dfb6dfcad535eef16efcbaa9c01564ed -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Demo/Ringtoets/test/Demo.Ringtoets.Test/Views/ChartDataViewTest.cs	(.../ChartDataViewTest.cs)	(revision fea3ed82dfb6dfcad535eef16efcbaa9c01564ed)
+++ Demo/Ringtoets/test/Demo.Ringtoets.Test/Views/ChartDataViewTest.cs	(.../ChartDataViewTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -67,16 +67,17 @@
         }
 
         [Test]
-        public void Data_SetToObject_InvalidCastException()
+        public void Data_SetToObject_DoesNotThrow()
         {
             // Setup
             using (var chartView = new ChartDataView())
             {
                 // Call
-                TestDelegate test = () => chartView.Data = new object();
+                TestDelegate testDelegate = () => chartView.Data = new object();
 
                 // Assert
-                Assert.Throws<InvalidCastException>(test);
+                Assert.DoesNotThrow(testDelegate);
+                Assert.IsNull(chartView.Data);
             }
         }
 
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Forms/Views/GrassCoverErosionInwardsInputView.cs
===================================================================
diff -u -r0d98073e4ba2bdc6b69b7f875508488d1fa0148a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Forms/Views/GrassCoverErosionInwardsInputView.cs	(.../GrassCoverErosionInwardsInputView.cs)	(revision 0d98073e4ba2bdc6b69b7f875508488d1fa0148a)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Forms/Views/GrassCoverErosionInwardsInputView.cs	(.../GrassCoverErosionInwardsInputView.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -21,7 +21,6 @@
 
 using System.Windows.Forms;
 using Core.Common.Base;
-using Core.Common.Base.Geometry;
 using Core.Components.Charting.Data;
 using Core.Components.Charting.Forms;
 using Ringtoets.GrassCoverErosionInwards.Data;
@@ -40,6 +39,7 @@
         private readonly ChartLineData foreshoreChartData;
         private readonly ChartLineData dikeGeometryChartData;
         private readonly ChartLineData dikeHeightChartData;
+        private readonly ChartDataCollection chartDataCollection;
 
         private GrassCoverErosionInwardsCalculation data;
 
@@ -53,15 +53,14 @@
             calculationObserver = new Observer(UpdateChartTitle);
             calculationInputObserver = new Observer(UpdateChartData);
 
+            chartDataCollection = new ChartDataCollection(RingtoetsCommonFormsResources.Calculation_Input);
             foreshoreChartData = GrassCoverErosionInwardsChartDataFactory.CreateForeshoreGeometryChartData();
             dikeGeometryChartData = GrassCoverErosionInwardsChartDataFactory.CreateDikeGeometryChartData();
             dikeHeightChartData = GrassCoverErosionInwardsChartDataFactory.CreateDikeHeightChartData();
 
-            chartControl.Data.Add(foreshoreChartData);
-            chartControl.Data.Add(dikeGeometryChartData);
-            chartControl.Data.Add(dikeHeightChartData);
-
-            chartControl.Data.Name = RingtoetsCommonFormsResources.Calculation_Input;
+            chartDataCollection.Add(foreshoreChartData);
+            chartDataCollection.Add(dikeGeometryChartData);
+            chartDataCollection.Add(dikeHeightChartData);
         }
 
         public object Data
@@ -79,12 +78,16 @@
 
                 if (data == null)
                 {
-                    Chart.ResetChartData();
-                    return;
+                    chartControl.Data = null;
+                    chartControl.Name = string.Empty;
                 }
+                else
+                {
+                    SetChartData();
 
-                UpdateChartTitle();
-                UpdateChartData();
+                    chartControl.Data = chartDataCollection;
+                    chartControl.ChartTitle = data.Name;
+                }
             }
         }
 
@@ -110,31 +113,29 @@
 
         private void UpdateChartTitle()
         {
-            chartControl.ChartTitle = data != null ? data.Name : string.Empty;
+            chartControl.ChartTitle = data.Name;
         }
 
         private void UpdateChartData()
         {
-            var input = data != null ? data.InputParameters : null;
-            var dikeProfile = input != null ? input.DikeProfile : null;
+            SetChartData();
 
+            foreshoreChartData.NotifyObservers();
+            dikeGeometryChartData.NotifyObservers();
+            dikeHeightChartData.NotifyObservers();
+        }
+
+        private void SetChartData()
+        {
+            var input = data.InputParameters;
+            var dikeProfile = input.DikeProfile;
+
             GrassCoverErosionInwardsChartDataFactory.UpdateForeshoreGeometryChartDataName(foreshoreChartData, input);
             GrassCoverErosionInwardsChartDataFactory.UpdateDikeGeometryChartDataName(dikeGeometryChartData, dikeProfile);
 
-            UpdatePointBasedChartData(foreshoreChartData,
-                                      GrassCoverErosionInwardsChartDataPointsFactory.CreateForeshoreGeometryPoints(input));
-            UpdatePointBasedChartData(dikeGeometryChartData,
-                                      GrassCoverErosionInwardsChartDataPointsFactory.CreateDikeGeometryPoints(dikeProfile));
-            UpdatePointBasedChartData(dikeHeightChartData,
-                                      GrassCoverErosionInwardsChartDataPointsFactory.CreateDikeHeightPoints(input));
-
-            chartControl.Data.NotifyObservers();
+            foreshoreChartData.Points = GrassCoverErosionInwardsChartDataPointsFactory.CreateForeshoreGeometryPoints(input);
+            dikeGeometryChartData.Points = GrassCoverErosionInwardsChartDataPointsFactory.CreateDikeGeometryPoints(dikeProfile);
+            dikeHeightChartData.Points = GrassCoverErosionInwardsChartDataPointsFactory.CreateDikeHeightPoints(input);
         }
-
-        private static void UpdatePointBasedChartData(PointBasedChartData chartData, Point2D[] points)
-        {
-            chartData.Points = points;
-            chartData.NotifyObservers();
-        }
     }
 }
\ No newline at end of file
Index: Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Forms.Test/Views/GrassCoverErosionInwardsInputViewTest.cs
===================================================================
diff -u -r6c3a074511922fb175a1aa7f20168bbb6d63a688 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Forms.Test/Views/GrassCoverErosionInwardsInputViewTest.cs	(.../GrassCoverErosionInwardsInputViewTest.cs)	(revision 6c3a074511922fb175a1aa7f20168bbb6d63a688)
+++ Ringtoets/GrassCoverErosionInwards/test/Ringtoets.GrassCoverErosionInwards.Forms.Test/Views/GrassCoverErosionInwardsInputViewTest.cs	(.../GrassCoverErosionInwardsInputViewTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -29,7 +29,6 @@
 using Ringtoets.Common.Data.DikeProfiles;
 using Ringtoets.GrassCoverErosionInwards.Data;
 using Ringtoets.GrassCoverErosionInwards.Forms.Views;
-using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources;
 
 namespace Ringtoets.GrassCoverErosionInwards.Forms.Test.Views
 {
@@ -55,7 +54,7 @@
         }
 
         [Test]
-        public void DefaultConstructor_Always_AddChartControlWithCollectionOfEmptyChartData()
+        public void DefaultConstructor_Always_AddEmptyChartControl()
         {
             // Call
             using (var view = new GrassCoverErosionInwardsInputView())
@@ -64,10 +63,9 @@
                 Assert.AreEqual(1, view.Controls.Count);
                 Assert.AreSame(view.Chart, view.Controls[0]);
                 Assert.AreEqual(DockStyle.Fill, ((Control) view.Chart).Dock);
-                Assert.AreEqual("Invoer", view.Chart.Data.Name);
                 Assert.AreEqual("Afstand [m]", view.Chart.BottomAxisTitle);
                 Assert.AreEqual("Hoogte [m+NAP]", view.Chart.LeftAxisTitle);
-                AssertEmptyChartData(view.Chart.Data);
+                Assert.IsNull(view.Chart.Data);
             }
         }
 
@@ -124,42 +122,35 @@
         }
 
         [Test]
-        public void Data_SetChartData_ChartDataSet()
+        public void Data_EmptyGrassCoverErosionInwardsCalculation_NoMapDataSet()
         {
             // Setup
             using (var view = new GrassCoverErosionInwardsInputView())
             {
-                DikeProfile dikeProfile = GetDikeProfileWithGeometry();
-                var calculation = new GrassCoverErosionInwardsCalculation
-                {
-                    InputParameters =
-                    {
-                        DikeProfile = dikeProfile
-                    }
-                };
+                var calculation = new GrassCoverErosionInwardsCalculation();
 
                 // Call
                 view.Data = calculation;
 
                 // Assert
-                Assert.AreSame(calculation, view.Data);
-
-                var chartData = view.Chart.Data;
-                Assert.IsInstanceOf<ChartDataCollection>(chartData);
-                Assert.AreEqual(3, chartData.Collection.Count());
-                AssertDikeProfileChartData(dikeProfile, chartData.Collection.ElementAt(dikeProfileIndex));
-                AssertForeshoreChartData(dikeProfile, chartData.Collection.ElementAt(foreshoreIndex));
-                AssertDikeHeightChartData(dikeProfile, chartData.Collection.ElementAt(dikeHeightIndex));
+                AssertEmptyChartData(view.Chart.Data);
             }
         }
 
         [Test]
-        public void Data_WithoutDikeProfile_CollectionOfEmptyDataSet()
+        public void Data_SetChartData_ChartDataSet()
         {
             // Setup
             using (var view = new GrassCoverErosionInwardsInputView())
             {
-                var calculation = new GrassCoverErosionInwardsCalculation();
+                DikeProfile dikeProfile = GetDikeProfileWithGeometry();
+                var calculation = new GrassCoverErosionInwardsCalculation
+                {
+                    InputParameters =
+                    {
+                        DikeProfile = dikeProfile
+                    }
+                };
 
                 // Call
                 view.Data = calculation;
@@ -170,17 +161,9 @@
                 var chartData = view.Chart.Data;
                 Assert.IsInstanceOf<ChartDataCollection>(chartData);
                 Assert.AreEqual(3, chartData.Collection.Count());
-
-                var dikeGeometryData = (ChartLineData) chartData.Collection.ElementAt(dikeProfileIndex);
-                var foreshoreData = (ChartLineData) chartData.Collection.ElementAt(foreshoreIndex);
-                var dikeHeightData = (ChartLineData) chartData.Collection.ElementAt(dikeHeightIndex);
-
-                CollectionAssert.IsEmpty(dikeGeometryData.Points);
-                CollectionAssert.IsEmpty(foreshoreData.Points);
-                CollectionAssert.IsEmpty(dikeHeightData.Points);
-                Assert.AreEqual("Dijkprofiel", dikeGeometryData.Name);
-                Assert.AreEqual("Voorlandprofiel", foreshoreData.Name);
-                Assert.AreEqual("Dijkhoogte", dikeHeightData.Name);
+                AssertDikeProfileChartData(dikeProfile, chartData.Collection.ElementAt(dikeProfileIndex));
+                AssertForeshoreChartData(dikeProfile, chartData.Collection.ElementAt(foreshoreIndex));
+                AssertDikeHeightChartData(dikeProfile, chartData.Collection.ElementAt(dikeHeightIndex));
             }
         }
 
@@ -493,11 +476,11 @@
                                    });
         }
 
-        private static void AssertEmptyChartData(ChartDataCollection chartData)
+        private static void AssertEmptyChartData(ChartDataCollection chartDataCollection)
         {
-            Assert.IsInstanceOf<ChartDataCollection>(chartData);
+            Assert.AreEqual("Invoer", chartDataCollection.Name);
 
-            var chartDatasList = chartData.Collection.ToList();
+            var chartDatasList = chartDataCollection.Collection.ToList();
 
             Assert.AreEqual(3, chartDatasList.Count);
 
Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/Views/PipingInputView.cs
===================================================================
diff -u -r0d98073e4ba2bdc6b69b7f875508488d1fa0148a -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/Views/PipingInputView.cs	(.../PipingInputView.cs)	(revision 0d98073e4ba2bdc6b69b7f875508488d1fa0148a)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/Views/PipingInputView.cs	(.../PipingInputView.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -23,13 +23,11 @@
 using System.Linq;
 using System.Windows.Forms;
 using Core.Common.Base;
-using Core.Common.Base.Geometry;
 using Core.Common.Utils.Extensions;
 using Core.Components.Charting.Data;
 using Core.Components.Charting.Forms;
 using Ringtoets.Piping.Data;
 using Ringtoets.Piping.Primitives;
-using PipingDataResources = Ringtoets.Piping.Data.Properties.Resources;
 using RingtoetsCommonFormsResources = Ringtoets.Common.Forms.Properties.Resources;
 
 namespace Ringtoets.Piping.Forms.Views
@@ -52,6 +50,7 @@
         private readonly ChartPointData dikeToeAtRiverChartData;
         private readonly ChartPointData exitPointChartData;
         private readonly ChartPointData entryPointChartData;
+        private readonly ChartDataCollection chartDataCollection;
 
         private readonly List<ChartMultipleAreaData> soilLayerChartDataLookup;
 
@@ -70,6 +69,7 @@
             calculationObserver = new Observer(UpdateChartTitle);
             calculationInputObserver = new Observer(UpdateChartData);
 
+            chartDataCollection = new ChartDataCollection(RingtoetsCommonFormsResources.Calculation_Input);
             soilProfileChartData = PipingChartDataFactory.CreateSoilProfileChartData();
             surfaceLineChartData = PipingChartDataFactory.CreateSurfaceLineChartData();
             ditchPolderSideChartData = PipingChartDataFactory.CreateDitchPolderSideChartData();
@@ -81,19 +81,17 @@
             exitPointChartData = PipingChartDataFactory.CreateExitPointChartData();
             entryPointChartData = PipingChartDataFactory.CreateEntryPointChartData();
 
-            chartControl.Data.Add(soilProfileChartData);
-            chartControl.Data.Add(surfaceLineChartData);
-            chartControl.Data.Add(ditchPolderSideChartData);
-            chartControl.Data.Add(bottomDitchPolderSideChartData);
-            chartControl.Data.Add(bottomDitchDikeSideChartData);
-            chartControl.Data.Add(ditchDikeSideChartData);
-            chartControl.Data.Add(dikeToeAtPolderChartData);
-            chartControl.Data.Add(dikeToeAtRiverChartData);
-            chartControl.Data.Add(exitPointChartData);
-            chartControl.Data.Add(entryPointChartData);
+            chartDataCollection.Add(soilProfileChartData);
+            chartDataCollection.Add(surfaceLineChartData);
+            chartDataCollection.Add(ditchPolderSideChartData);
+            chartDataCollection.Add(bottomDitchPolderSideChartData);
+            chartDataCollection.Add(bottomDitchDikeSideChartData);
+            chartDataCollection.Add(ditchDikeSideChartData);
+            chartDataCollection.Add(dikeToeAtPolderChartData);
+            chartDataCollection.Add(dikeToeAtRiverChartData);
+            chartDataCollection.Add(exitPointChartData);
+            chartDataCollection.Add(entryPointChartData);
 
-            chartControl.Data.Name = RingtoetsCommonFormsResources.Calculation_Input;
-
             soilLayerChartDataLookup = new List<ChartMultipleAreaData>(); // Use lookup because the ordering in the chart data collection might change
         }
 
@@ -108,16 +106,22 @@
                 data = value as PipingCalculationScenario;
 
                 calculationObserver.Observable = data;
-                calculationInputObserver.Observable = GetPipingInput();
+                calculationInputObserver.Observable = data != null
+                                                          ? data.InputParameters
+                                                          : null;
 
                 if (data == null)
                 {
-                    Chart.ResetChartData();
-                    return;
+                    chartControl.Data = null;
+                    chartControl.Name = string.Empty;
                 }
+                else
+                {
+                    SetChartData();
 
-                UpdateChartTitle();
-                UpdateChartData();
+                    chartControl.Data = chartDataCollection;
+                    chartControl.ChartTitle = data.Name;
+                }
             }
         }
 
@@ -149,49 +153,48 @@
 
         private void UpdateChartTitle()
         {
-            chartControl.ChartTitle = data != null ? data.Name : string.Empty;
+            chartControl.ChartTitle = data.Name;
         }
 
         private void UpdateChartData()
         {
-            var pipingInput = GetPipingInput();
-            var surfaceLine = GetSurfaceLine();
+            SetChartData();
 
-            PipingChartDataFactory.UpdateSurfaceLineChartDataName(surfaceLineChartData, surfaceLine);
+            surfaceLineChartData.NotifyObservers();
+            ditchPolderSideChartData.NotifyObservers();
+            bottomDitchPolderSideChartData.NotifyObservers();
+            bottomDitchDikeSideChartData.NotifyObservers();
+            ditchDikeSideChartData.NotifyObservers();
+            dikeToeAtPolderChartData.NotifyObservers();
+            dikeToeAtRiverChartData.NotifyObservers();
+            exitPointChartData.NotifyObservers();
+            entryPointChartData.NotifyObservers();
+            soilProfileChartData.NotifyObservers();
+        }
 
-            UpdatePointBasedChartData(surfaceLineChartData,
-                                      PipingChartDataPointsFactory.CreateSurfaceLinePoints(surfaceLine));
-            UpdatePointBasedChartData(ditchPolderSideChartData,
-                                      PipingChartDataPointsFactory.CreateDitchPolderSidePoint(surfaceLine));
-            UpdatePointBasedChartData(bottomDitchPolderSideChartData,
-                                      PipingChartDataPointsFactory.CreateBottomDitchPolderSidePoint(surfaceLine));
-            UpdatePointBasedChartData(bottomDitchDikeSideChartData,
-                                      PipingChartDataPointsFactory.CreateBottomDitchDikeSidePoint(surfaceLine));
-            UpdatePointBasedChartData(ditchDikeSideChartData,
-                                      PipingChartDataPointsFactory.CreateDitchDikeSidePoint(surfaceLine));
-            UpdatePointBasedChartData(dikeToeAtPolderChartData,
-                                      PipingChartDataPointsFactory.CreateDikeToeAtPolderPoint(surfaceLine));
-            UpdatePointBasedChartData(dikeToeAtRiverChartData,
-                                      PipingChartDataPointsFactory.CreateDikeToeAtRiverPoint(surfaceLine));
-            UpdatePointBasedChartData(exitPointChartData,
-                                      PipingChartDataPointsFactory.CreateExitPointPoint(pipingInput));
-            UpdatePointBasedChartData(entryPointChartData,
-                                      PipingChartDataPointsFactory.CreateEntryPointPoint(pipingInput));
+        private void SetChartData()
+        {
+            var pipingInput = data.InputParameters;
+            var surfaceLine = data.InputParameters.SurfaceLine;
 
-            UpdateSoilProfileChartData();
+            PipingChartDataFactory.UpdateSurfaceLineChartDataName(surfaceLineChartData, surfaceLine);
 
-            chartControl.Data.NotifyObservers();
-        }
+            surfaceLineChartData.Points = PipingChartDataPointsFactory.CreateSurfaceLinePoints(surfaceLine);
+            ditchPolderSideChartData.Points = PipingChartDataPointsFactory.CreateDitchPolderSidePoint(surfaceLine);
+            bottomDitchPolderSideChartData.Points = PipingChartDataPointsFactory.CreateBottomDitchPolderSidePoint(surfaceLine);
+            bottomDitchDikeSideChartData.Points = PipingChartDataPointsFactory.CreateBottomDitchDikeSidePoint(surfaceLine);
+            ditchDikeSideChartData.Points = PipingChartDataPointsFactory.CreateDitchDikeSidePoint(surfaceLine);
+            dikeToeAtPolderChartData.Points = PipingChartDataPointsFactory.CreateDikeToeAtPolderPoint(surfaceLine);
+            dikeToeAtRiverChartData.Points = PipingChartDataPointsFactory.CreateDikeToeAtRiverPoint(surfaceLine);
+            exitPointChartData.Points = PipingChartDataPointsFactory.CreateExitPointPoint(pipingInput);
+            entryPointChartData.Points = PipingChartDataPointsFactory.CreateEntryPointPoint(pipingInput);
 
-        private static void UpdatePointBasedChartData(PointBasedChartData chartData, Point2D[] points)
-        {
-            chartData.Points = points;
-            chartData.NotifyObservers();
+            SetSoilProfileChartData();
         }
 
-        private void UpdateSoilProfileChartData()
+        private void SetSoilProfileChartData()
         {
-            var stochasticSoilProfile = GetStochasticSoilProfile();
+            var stochasticSoilProfile = data.InputParameters.StochasticSoilProfile;
 
             // If necessary, regenerate all soil layer chart data
             if (!ReferenceEquals(currentStochasticSoilProfile, stochasticSoilProfile))
@@ -208,8 +211,6 @@
                                });
 
                 PipingChartDataFactory.UpdateSoilProfileChartDataName(soilProfileChartData, stochasticSoilProfile);
-
-                soilProfileChartData.NotifyObservers();
             }
 
             // Update the areas of all soil layer chart data
@@ -219,32 +220,10 @@
             {
                 var soilLayerData = soilLayerChartDataLookup[i];
 
-                soilLayerData.Areas = PipingChartDataPointsFactory.CreateSoilLayerAreas(soilLayers[i], stochasticSoilProfile.SoilProfile, GetSurfaceLine());
-                soilLayerData.NotifyObservers();
+                soilLayerData.Areas = PipingChartDataPointsFactory.CreateSoilLayerAreas(soilLayers[i], stochasticSoilProfile.SoilProfile, data.InputParameters.SurfaceLine);
             }
         }
 
-        private RingtoetsPipingSurfaceLine GetSurfaceLine()
-        {
-            return data != null
-                       ? data.InputParameters.SurfaceLine
-                       : null;
-        }
-
-        private PipingInput GetPipingInput()
-        {
-            return data != null
-                       ? data.InputParameters
-                       : null;
-        }
-
-        private StochasticSoilProfile GetStochasticSoilProfile()
-        {
-            return data != null
-                       ? data.InputParameters.StochasticSoilProfile
-                       : null;
-        }
-
         private IList<PipingSoilLayer> GetSoilLayers()
         {
             return data != null && data.InputParameters.StochasticSoilProfile != null && data.InputParameters.StochasticSoilProfile.SoilProfile != null
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Views/PipingInputViewTest.cs
===================================================================
diff -u -r6c3a074511922fb175a1aa7f20168bbb6d63a688 -r4dbfc20ef0200e34db43efeb8899d72e4046cc5b
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Views/PipingInputViewTest.cs	(.../PipingInputViewTest.cs)	(revision 6c3a074511922fb175a1aa7f20168bbb6d63a688)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Views/PipingInputViewTest.cs	(.../PipingInputViewTest.cs)	(revision 4dbfc20ef0200e34db43efeb8899d72e4046cc5b)
@@ -61,7 +61,7 @@
         }
 
         [Test]
-        public void DefaultConstructor_Always_AddChartControlWithCollectionOfEmptyChartData()
+        public void DefaultConstructor_Always_AddEmptyChartControl()
         {
             // Call
             using (var view = new PipingInputView())
@@ -70,10 +70,9 @@
                 Assert.AreEqual(1, view.Controls.Count);
                 Assert.AreSame(view.Chart, view.Controls[0]);
                 Assert.AreEqual(DockStyle.Fill, ((Control) view.Chart).Dock);
-                Assert.AreEqual("Invoer", view.Chart.Data.Name);
                 Assert.AreEqual("Afstand [m]", view.Chart.BottomAxisTitle);
                 Assert.AreEqual("Hoogte [m+NAP]", view.Chart.LeftAxisTitle);
-                AssertEmptyChartData(view.Chart.Data);
+                Assert.IsNull(view.Chart.Data);
             }
         }
 
@@ -130,6 +129,22 @@
         }
 
         [Test]
+        public void Data_EmptyGrassCoverErosionInwardsCalculation_NoMapDataSet()
+        {
+            // Setup
+            using (var view = new PipingInputView())
+            {
+                var calculation = new PipingCalculationScenario(new GeneralPipingInput());
+
+                // Call
+                view.Data = calculation;
+
+                // Assert
+                AssertEmptyChartData(view.Chart.Data);
+            }
+        }
+
+        [Test]
         public void Data_WithSurfaceLineAndSoilProfile_DataUpdatedToCollectionOfFilledChartData()
         {
             // Setup
@@ -170,23 +185,6 @@
         }
 
         [Test]
-        public void Data_WithoutSurfaceLine_DataUpdatedToCollectionOfEmptyChartData()
-        {
-            // Setup
-            using (var view = new PipingInputView())
-            {
-                var calculation = new PipingCalculationScenario(new GeneralPipingInput());
-
-                // Call
-                view.Data = calculation;
-
-                // Assert
-                Assert.AreSame(calculation, view.Data);
-                AssertEmptyChartData(view.Chart.Data);
-            }
-        }
-
-        [Test]
         public void Data_WithSurfaceLineWithoutStochasticSoilProfile_CollectionOfEmptyChartDataSetForSoilProfile()
         {
             // Setup
@@ -588,11 +586,11 @@
             return surfaceLine;
         }
 
-        private static void AssertEmptyChartData(ChartDataCollection chartData)
+        private static void AssertEmptyChartData(ChartDataCollection chartDataCollection)
         {
-            Assert.IsInstanceOf<ChartDataCollection>(chartData);
+            Assert.AreEqual("Invoer", chartDataCollection.Name);
 
-            var chartDatasList = chartData.Collection.ToList();
+            var chartDatasList = chartDataCollection.Collection.ToList();
 
             Assert.AreEqual(10, chartDatasList.Count);