项目结构调整

Others/Live-Charts-master/.gitattributes

@@ -0,0 +1,63 @@
+###############################################################################
+# Set default behavior to automatically normalize line endings.
+###############################################################################
+* text=auto
+
+###############################################################################
+# Set default behavior for command prompt diff.
+#
+# This is need for earlier builds of msysgit that does not have it on by
+# default for csharp files.
+# Note: This is only used by command line
+###############################################################################
+#*.cs     diff=csharp
+
+###############################################################################
+# Set the merge driver for project and solution files
+#
+# Merging from the command prompt will add diff markers to the files if there
+# are conflicts (Merging from VS is not affected by the settings below, in VS
+# the diff markers are never inserted). Diff markers may cause the following 
+# file extensions to fail to load in VS. An alternative would be to treat
+# these files as binary and thus will always conflict and require user
+# intervention with every merge. To do so, just uncomment the entries below
+###############################################################################
+#*.sln       merge=binary
+#*.csproj    merge=binary
+#*.vbproj    merge=binary
+#*.vcxproj   merge=binary
+#*.vcproj    merge=binary
+#*.dbproj    merge=binary
+#*.fsproj    merge=binary
+#*.lsproj    merge=binary
+#*.wixproj   merge=binary
+#*.modelproj merge=binary
+#*.sqlproj   merge=binary
+#*.wwaproj   merge=binary
+
+###############################################################################
+# behavior for image files
+#
+# image files are treated as binary by default.
+###############################################################################
+#*.jpg   binary
+#*.png   binary
+#*.gif   binary
+
+###############################################################################
+# diff behavior for common document formats
+# 
+# Convert binary document formats to text before diffing them. This feature
+# is only available from the command line. Turn it on by uncommenting the 
+# entries below.
+###############################################################################
+#*.doc   diff=astextplain
+#*.DOC   diff=astextplain
+#*.docx  diff=astextplain
+#*.DOCX  diff=astextplain
+#*.dot   diff=astextplain
+#*.DOT   diff=astextplain
+#*.pdf   diff=astextplain
+#*.PDF   diff=astextplain
+#*.rtf   diff=astextplain
+#*.RTF   diff=astextplain

Others/Live-Charts-master/.github/CONTRIBUTING.md

@@ -0,0 +1,27 @@
+Please take a read at this article so we can help you better, we are always happy to support you at our [chat](https://gitter.im/beto-rodriguez/Live-Charts), normally we respond you really fast.
+
+### Features
+
+We are open to add new features to this library, but before suggesting one, ensure it is not implemented yet, There are a lot of examples showing the already supported features in the library, in the [website](http://lvcharts.net/App/examples/wpf/start) and in [in this repo](https://github.com/beto-rodriguez/Live-Charts/tree/master/Examples).
+
+After you are sure it is not implemented, open a [new issue](https://github.com/beto-rodriguez/Live-Charts/issues/new) that contains:
+
+* What you are trying to do and cannot be solved with the [latest](https://www.nuget.org/packages/LiveCharts/) library version, if you can do it but you think it can be easier, then exaplin so and how.
+* Since this is a visual library always adding an image with the expected result is helpful.
+
+### Bugs
+
+A bug should be ascertainable with the [latest](https://www.nuget.org/packages/LiveCharts/) version of the library.
+
+A good way to say thanks for this library is doing good reports, the better you report the faster we can fix it. the next list is ordered by "ease to attend" for the developers of the library, you can choose any of these methods to give us your feedback.
+
+* Create a repository that illustrates the issue, please use as less dependencies as possible.
+* If you are not very familiar with git, you could simply send us a mail with an example project that illustrates the issue at support@lvcharts.net
+* Simply open a [new issue](https://github.com/beto-rodriguez/Live-Charts/issues/new) following the sugested structure.
+* Comment it in our [chat](https://gitter.im/beto-rodriguez/Live-Charts).
+
+### Pull Request
+
+Please do suggest whatever you think is necessary to improve, name your PR with a clear name of what you have done, explain a bit about it and you are done, we will review your code and merge it if we think it is appropiated.
+
+Notice that by doing a PR you must respect and agree our [license](https://github.com/beto-rodriguez/Live-Charts/blob/master/LICENSE.TXT).

Others/Live-Charts-master/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,26 @@
+Instructions: replace text surrounded by '*' with your case, please delete this line.
+
+#### How to reproduce?
+
+*Explain how we can get this issue, if you created a repo with the issue, please add the link, blank if you are submitting a suggestion or improvement*
+
+#### Extra notes
+
+*Explain what you expect, feedback, images or anything you consider necessary*
+
+#### I am using
+
+<table>
+<tr>
+    <td>Live-Charts version</td>
+    <td>*your Live-Charts version here*</td>
+</tr>
+<tr>
+    <td>.Net Version</td>
+    <td>*your .net version here*</td>
+</tr>
+<tr>
+    <td>Windows</td>
+    <td>*your windows version here*</td>
+</tr>
+</table>

Others/Live-Charts-master/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,7 @@
+#### Summary
+
+*Explain the changes in this PR*
+
+#### Solves 
+
+*List the issues this PR solves, blank if none*

Others/Live-Charts-master/.gitignore

@@ -0,0 +1,242 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+build/
+bld/
+[Bb]in/
+[Oo]bj/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# Folders for Cake
+tools/
+!tools/packages.config
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# DNX
+project.lock.json
+artifacts/
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+*.cachefile
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+## TODO: Comment the next line if you want to checkin your
+## web deploy settings but do note that will include unencrypted
+## passwords
+#*.pubxml
+
+*.publishproj
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+
+# Windows Azure Build Output
+csx/
+*.build.csdef
+
+# Windows Store app package directory
+AppPackages/
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+orleans.codegen.cs
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# LightSwitch generated files
+GeneratedArtifacts/
+_Pvt_Extensions/
+ModelManifest.xml
+/LiveChartsCore/nuget.exe
+/Core/Test/LiveCharts.dll
+/WpfView/lib/net403/LiveCharts.dll
+/WpfView/lib/net403/LiveCharts.Wpf.dll
+/WpfView/lib/net45/LiveCharts.dll
+/WpfView/lib/net45/LiveCharts.Wpf.dll
+/WpfView/Test/LiveCharts.dll
+/WpfView/Test/LiveCharts.Wpf.dll
+/Core/Everything seems fine 
+*.xml
+/VirtualizedValues/VirtualizedValues.csproj
+/VirtualizedValues/Class1.cs
+/VirtualizedValues/Properties/AssemblyInfo.cs
+/binaries
+/binaries.zip
+/internals.txt
+/Autofac.dll
+/Cake.Common.dll
+/Cake.Core.dll
+/Cake.exe
+/Cake.NuGet.dll
+/LICENSE
+/Mono.CSharp.dll
+/NuGet.Core.dll
+/Roslyn.Compilers.CSharp.dll
+/Roslyn.Compilers.dll

Others/Live-Charts-master/Charts.sln.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/CodeAnnotations/NamespacesWithAnnotations/=LiveCharts_002EAnnotations/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Others/Live-Charts-master/Core/AxisCore.cs

@@ -0,0 +1,540 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using LiveCharts.Charts;
+using LiveCharts.Definitions.Charts;
+using LiveCharts.Dtos;
+using LiveCharts.Helpers;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class AxisCore
+    {
+        private double _topLimit;
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AxisCore"/> class.
+        /// </summary>
+        /// <param name="view">The view.</param>
+        public AxisCore(IAxisView view)
+        {
+            View = view;
+            CleanFactor = 3;
+            Cache = new Dictionary<double, SeparatorElementCore>();
+            LastAxisMax = null;
+            LastAxisMin = null;
+        }
+
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>
+        /// Gets or sets the chart.
+        /// </summary>
+        /// <value>
+        /// The chart.
+        /// </value>
+        public ChartCore Chart { get; set; }
+        /// <summary>
+        /// Gets or sets the view.
+        /// </summary>
+        /// <value>
+        /// The view.
+        /// </value>
+        public IAxisView View { get; set; }
+        /// <summary>
+        /// Gets or sets the labels.
+        /// </summary>
+        /// <value>
+        /// The labels.
+        /// </value>
+        public IList<string> Labels { get; set; }
+        /// <summary>
+        /// Gets or sets the sections.
+        /// </summary>
+        /// <value>
+        /// The sections.
+        /// </value>
+        public List<AxisSectionCore> Sections { get; set; }
+        /// <summary>
+        /// Gets or sets the label formatter.
+        /// </summary>
+        /// <value>
+        /// The label formatter.
+        /// </value>
+        public Func<double, string> LabelFormatter { get; set; }
+        /// <summary>
+        /// Gets or sets the stroke thickness.
+        /// </summary>
+        /// <value>
+        /// The stroke thickness.
+        /// </value>
+        public double StrokeThickness { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [show labels].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [show labels]; otherwise, <c>false</c>.
+        /// </value>
+        public bool ShowLabels { get; set; }
+        /// <summary>
+        /// Gets or sets the maximum value.
+        /// </summary>
+        /// <value>
+        /// The maximum value.
+        /// </value>
+        public double MaxValue { get; set; }
+        /// <summary>
+        /// Gets or sets the minimum value.
+        /// </summary>
+        /// <value>
+        /// The minimum value.
+        /// </value>
+        public double MinValue { get; set; }
+        /// <summary>
+        /// Gets or sets the title.
+        /// </summary>
+        /// <value>
+        /// The title.
+        /// </value>
+        public string Title { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [disable animations].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [disable animations]; otherwise, <c>false</c>.
+        /// </value>
+        public bool DisableAnimations { get; set; }
+        /// <summary>
+        /// Gets or sets the position.
+        /// </summary>
+        /// <value>
+        /// The position.
+        /// </value>
+        public AxisPosition Position { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is merged.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance is merged; otherwise, <c>false</c>.
+        /// </value>
+        public bool IsMerged { get; set; }
+        /// <summary>
+        /// Gets a value indicating whether [evaluates unit width].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [evaluates unit width]; otherwise, <c>false</c>.
+        /// </value>
+        public bool EvaluatesUnitWidth { get; internal set; }
+        /// <summary>
+        /// Gets the current separators.
+        /// </summary>
+        /// <value>
+        /// The current separators.
+        /// </value>
+        public IEnumerable<SeparatorElementCore> CurrentSeparators
+        {
+            get { return Cache.Values; }
+        }
+        /// <summary>
+        /// Gets or sets the separator.
+        /// </summary>
+        /// <value>
+        /// The separator.
+        /// </value>
+        public SeparatorConfigurationCore Separator { get; set; }
+        /// <summary>
+        /// Gets the s.
+        /// </summary>
+        /// <value>
+        /// The s.
+        /// </value>
+        public double S { get; internal set; }
+
+        #endregion
+
+        #region Internal Properties
+
+        internal double Tab { get; set; }
+
+        internal double TopLimit
+        {
+            get { return _topLimit; }
+            set
+            {
+                _topLimit = value;
+            }
+        }
+
+        internal double BotLimit { get; set; }
+        internal double TopSeriesLimit { get; set; }
+        internal double BotSeriesLimit { get; set; }
+        internal double MaxPointRadius { get; set; }
+        internal double Magnitude { get; set; }
+        internal double CleanFactor { get; set; }
+        internal Dictionary<double, SeparatorElementCore> Cache { get; set; }
+        internal double? LastAxisMax { get; set; }
+        internal double? LastAxisMin { get; set; }
+        internal CoreRectangle LastPlotArea { get; set; }
+        internal int GarbageCollectorIndex { get; set; }
+        internal double PreviousTop { get; set; }
+        internal double PreviousBot { get; set; }
+        internal double FirstSeparator { get; private set; }
+        internal double LastSeparator { get; private set; }
+
+        #endregion
+
+        #region Public Methods
+        /// <summary>
+        /// Gets the formatter.
+        /// </summary>
+        /// <returns></returns>
+        public Func<double, string> GetFormatter()
+        {
+            return Formatter;
+        }
+
+        /// <summary>
+        /// Clears the separators.
+        /// </summary>
+        public void ClearSeparators()
+        {
+            foreach (var separator in Cache)
+            {
+                separator.Value.View.Clear(Chart.View);
+            }
+            Cache = new Dictionary<double, SeparatorElementCore>();
+        }
+
+        #endregion
+
+        #region Internal Methods
+
+        internal void CalculateSeparator(ChartCore chart, AxisOrientation source)
+        {
+            var range = TopLimit - BotLimit;
+            range = range <= 0 ? 1 : range;
+
+            //ToDO: Improve this according to current labels!
+            var separations = source == AxisOrientation.Y
+                ? Math.Round(chart.ControlSize.Height / ((12) * CleanFactor), 0) // at least 3 font 12 labels per separator.
+                : Math.Round(chart.ControlSize.Width / (50 * CleanFactor), 0); // at least 150 pixels per separator.
+
+            separations = separations < 2 ? 2 : separations;
+
+            var minimum = range / separations;
+            Magnitude = Math.Pow(10, Math.Floor(Math.Log(minimum) / Math.Log(10)));
+
+            if (!double.IsNaN(Separator.Step))
+            {
+                S = Separator.Step;
+                return;
+            }
+
+            var residual = minimum / Magnitude;
+            double tick;
+            if (residual > 5)
+                tick = 10 * Magnitude;
+            else if (residual > 2)
+                tick = 5 * Magnitude;
+            else if (residual > 1)
+                tick = 2 * Magnitude;
+            else
+                tick = Magnitude;
+
+            S = tick;
+
+            if (Labels != null) S = S < 1 ? 1 : S;
+        }
+
+        internal virtual CoreMargin PrepareChart(AxisOrientation source, ChartCore chart)
+        {
+            if (!(Math.Abs(TopLimit - BotLimit) > S * .01) || !ShowLabels) return new CoreMargin();
+
+            CalculateSeparator(chart, source);
+
+            var f = GetFormatter();
+
+            var currentMargin = new CoreMargin();
+            var tolerance = S / 10;
+
+            InitializeGarbageCollector();
+
+            var m = !double.IsNaN(View.BarUnit)
+                ? View.BarUnit
+                : (!double.IsNaN(View.Unit)
+                    ? View.Unit
+                    : Magnitude);
+
+            var u = !double.IsNaN(View.BarUnit)
+                ? View.BarUnit
+                : (!double.IsNaN(View.Unit)
+                    ? View.Unit
+                    : 1);
+
+            if (TopLimit <= 0 && BotLimit < 0)
+            {
+                var l = TopLimit - (EvaluatesUnitWidth ? u : 0);
+                LastSeparator = l;
+                for (var i = l; i >= Math.Truncate(BotLimit / m) * m; i -= S)
+                {
+                    FirstSeparator = i;
+                    DrawSeparator(i, tolerance, currentMargin, f, source);
+                }
+            }
+            else
+            {
+                var l = Math.Truncate(BotLimit / m) * m;
+                FirstSeparator = l;
+                for (var i = l; i <= TopLimit - (EvaluatesUnitWidth ? u : 0); i += S)
+                {
+                     LastSeparator = i;
+                    DrawSeparator(i, tolerance, currentMargin, f, source);
+                }
+            }
+
+            return currentMargin;
+        }
+
+        internal void UpdateSeparators(AxisOrientation source, ChartCore chart, int axisIndex)
+        {
+            foreach (var element in Cache.Values.ToArray())
+            {
+                if (element.GarbageCollectorIndex < GarbageCollectorIndex)
+                {
+                    element.State = SeparationState.Remove;
+                    Cache.Remove(element.Key);
+                }
+
+                var toLine = ChartFunctions.ToPlotArea(element.Value, source, chart, axisIndex);
+
+                var direction = source == AxisOrientation.X ? 1 : -1;
+
+                toLine += EvaluatesUnitWidth ? direction * ChartFunctions.GetUnitWidth(source, chart, this) / 2 : 0;
+                var toLabel = toLine + element.View.LabelModel.GetOffsetBySource(source);
+
+                if (IsMerged)
+                {
+                    const double padding = 4;
+
+                    if (source == AxisOrientation.Y)
+                    {
+                        if (toLabel + element.View.LabelModel.ActualHeight >
+                            chart.DrawMargin.Top + chart.DrawMargin.Height)
+                            toLabel -= element.View.LabelModel.ActualHeight + padding;
+                    }
+                    else
+                    {
+                        if (toLabel + element.View.LabelModel.ActualWidth >
+                            chart.DrawMargin.Left + chart.DrawMargin.Width)
+                            toLabel -= element.View.LabelModel.ActualWidth + padding;
+                    }
+                }
+
+                var labelTab = Tab;
+                labelTab += element.View.LabelModel.GetOffsetBySource(source.Invert());
+
+                switch (element.State)
+                {
+                    case SeparationState.Remove:
+                        if (!chart.View.DisableAnimations && !View.DisableAnimations)
+                        {
+                            element.View.Move(chart, this, source, axisIndex, toLabel, toLine, labelTab);
+                            element.View.FadeOutAndRemove(chart);
+                        }
+                        else
+                        {
+                            element.View.Remove(chart);
+                        }
+                        break;
+                    case SeparationState.Keep:
+                        if (!chart.View.DisableAnimations && !View.DisableAnimations)
+                        {
+                            if (element.IsNew)
+                            {
+                                var toLinePrevious = FromPreviousState(element.Value, source, chart);
+                                toLinePrevious += EvaluatesUnitWidth ? ChartFunctions.GetUnitWidth(source, chart, this) / 2 : 0;
+                                var toLabelPrevious = toLinePrevious + element.View.LabelModel.GetOffsetBySource(source);
+                                element.View.Place(chart, this, source, axisIndex, toLabelPrevious,
+                                    toLinePrevious, labelTab);
+                                element.View.FadeIn(this, chart);
+                            }
+                            element.View.Move(chart, this, source, axisIndex, toLabel, toLine, labelTab);
+                        }
+                        else
+                        {
+                            element.View.Place(chart, this, source, axisIndex, toLabel, toLine, labelTab);
+                        }
+                        break;
+                    case SeparationState.InitialAdd:
+                        element.View.Place(chart, this, source, axisIndex, toLabel, toLine, labelTab);
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+
+            LastAxisMax = TopLimit;
+            LastAxisMin = BotLimit;
+            LastPlotArea = new CoreRectangle(chart.DrawMargin.Left, chart.DrawMargin.Top,
+                chart.DrawMargin.Width, chart.DrawMargin.Height);
+        }
+
+        internal double FromPreviousState(double value, AxisOrientation source, ChartCore chart)
+        {
+            if (LastAxisMax == null) return 0;
+
+            var p1 = new CorePoint();
+            var p2 = new CorePoint();
+
+            if (source == AxisOrientation.Y)
+            {
+                p1.X = LastAxisMax ?? 0;
+                p1.Y = LastPlotArea.Top;
+
+                p2.X = LastAxisMin ?? 0;
+                p2.Y = LastPlotArea.Top + LastPlotArea.Height;
+            }
+            else
+            {
+                p1.X = LastAxisMax ?? 0;
+                p1.Y = LastPlotArea.Width + LastPlotArea.Left;
+
+                p2.X = LastAxisMin ?? 0;
+                p2.Y = LastPlotArea.Left;
+            }
+
+            var deltaX = p2.X - p1.X;
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            var m = (p2.Y - p1.Y) / (deltaX == 0 ? double.MinValue : deltaX);
+            var d = m * (value - p1.X) + p1.Y;
+
+            return d;
+        }
+
+        #endregion
+
+        #region Protected Methods
+
+        /// <summary>
+        /// Initializes the garbage collector.
+        /// </summary>
+        protected void InitializeGarbageCollector()
+        {
+            if (GarbageCollectorIndex == int.MaxValue)
+            {
+                foreach (var value in Cache.Values)
+                {
+                    value.GarbageCollectorIndex = 0;
+                }
+                GarbageCollectorIndex = 0;
+            }
+
+            GarbageCollectorIndex++;
+        }
+        #endregion
+
+        #region Private Methods
+
+        private void DrawSeparator(double i, double tolerance, CoreMargin currentMargin, Func<double, string> f, AxisOrientation source)
+        {
+            if (i < BotLimit) return;
+           
+            SeparatorElementCore asc;
+
+            var key = Math.Round(i / tolerance) * tolerance;
+            if (!Cache.TryGetValue(key, out asc))
+            {
+                asc = new SeparatorElementCore { IsNew = true };
+                Cache[key] = asc;
+            }
+            else
+            {
+                asc.IsNew = false;
+            }
+
+            View.RenderSeparator(asc, Chart);
+
+            asc.Key = key;
+            asc.Value = i;
+            asc.GarbageCollectorIndex = GarbageCollectorIndex;
+
+            var labelsMargin = asc.View.UpdateLabel(f(i), this, source);
+
+            currentMargin.Width = labelsMargin.TakenWidth > currentMargin.Width
+                ? labelsMargin.TakenWidth
+                : currentMargin.Width;
+            currentMargin.Height = labelsMargin.TakenHeight > currentMargin.Height
+                ? labelsMargin.TakenHeight
+                : currentMargin.Height;
+
+            currentMargin.Left = labelsMargin.Left > currentMargin.Left
+                ? labelsMargin.Left
+                : currentMargin.Left;
+            currentMargin.Right = labelsMargin.Right > currentMargin.Right
+                ? labelsMargin.Right
+                : currentMargin.Right;
+
+            currentMargin.Top = labelsMargin.Top > currentMargin.Top
+                ? labelsMargin.Top
+                : currentMargin.Top;
+            currentMargin.Bottom = labelsMargin.Bottom > currentMargin.Bottom
+                ? labelsMargin.Bottom
+                : currentMargin.Bottom;
+
+            if (LastAxisMax == null)
+            {
+                asc.State = SeparationState.InitialAdd;
+                return;
+            }
+
+            asc.State = SeparationState.Keep;
+        }
+
+        private string Formatter(double x)
+        {
+            if (Labels == null)
+            {
+                return LabelFormatter == null
+                    ? x.ToString(CultureInfo.InvariantCulture)
+                    : LabelFormatter(x);
+            }
+
+            if (x < 0) x *= -1;
+            return Labels.Count > x && x >= 0
+                ? Labels[(int)x]
+                : "";
+        }
+
+        #endregion
+    }
+}

Others/Live-Charts-master/Core/AxisOrientation.cs

@@ -0,0 +1,44 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Cartesian Axis orientation
+    /// </summary>
+    public enum AxisOrientation
+    {
+        /// <summary>
+        /// Unknown orientation
+        /// </summary>
+        None,
+        /// <summary>
+        /// Horizontal (X)
+        /// </summary>
+        X,
+        /// <summary>
+        /// Vertical (Y)
+        /// </summary>
+        Y
+    }
+
+}

Others/Live-Charts-master/Core/AxisPosition.cs

@@ -0,0 +1,39 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Axis position
+    /// </summary>
+    public enum AxisPosition
+    {
+        /// <summary>
+        /// Left for Y axis, Bottom for X axis
+        /// </summary>
+        LeftBottom,
+        /// <summary>
+        /// Right for Y axis, Top for X axis
+        /// </summary>
+        RightTop
+    }
+}

Others/Live-Charts-master/Core/AxisSectionCore.cs

@@ -0,0 +1,72 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using LiveCharts.Charts;
+using LiveCharts.Definitions.Charts;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class AxisSectionCore
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AxisSectionCore"/> class.
+        /// </summary>
+        /// <param name="view">The view.</param>
+        /// <param name="chart">The chart.</param>
+        public AxisSectionCore(IAxisSectionView view, ChartCore chart)
+        {
+            View = view;
+            Chart = chart;
+        }
+        /// <summary>
+        /// Gets or sets the view.
+        /// </summary>
+        /// <value>
+        /// The view.
+        /// </value>
+        public IAxisSectionView View { get; set; }
+        /// <summary>
+        /// Gets or sets the source.
+        /// </summary>
+        /// <value>
+        /// The source.
+        /// </value>
+        public AxisOrientation Source { get; set; }
+        /// <summary>
+        /// Gets or sets the index of the axis.
+        /// </summary>
+        /// <value>
+        /// The index of the axis.
+        /// </value>
+        public int AxisIndex { get; set; }
+        /// <summary>
+        /// Gets or sets the chart.
+        /// </summary>
+        /// <value>
+        /// The chart.
+        /// </value>
+        public ChartCore Chart { get; set; }
+    }
+}

Others/Live-Charts-master/Core/BarLabelPosition.cs

@@ -0,0 +1,50 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Describes where a label should be placed
+    /// </summary>
+    public enum BarLabelPosition
+    {
+        /// <summary>
+        /// Places a label at the top of a bar
+        /// </summary>
+        Top,
+        /// <summary>
+        /// Places a labels inside the bar
+        /// </summary>
+        [Obsolete("Instead use BarLabelPosition.Parallel")]
+        Merged,
+        /// <summary>
+        /// Places a labels in a parallel orientation to the bar height.
+        /// </summary>
+        Parallel,
+        /// <summary>
+        /// Places a labels in a perpendicular orientation to the bar height.
+        /// </summary>
+        Perpendicular
+    }
+}

Others/Live-Charts-master/Core/BezierData.cs

@@ -0,0 +1,21 @@
+namespace LiveChartsCore
+{
+    public class BezierData
+    {
+        public BezierData()
+        {
+        }
+
+        public BezierData(LvcPoint point)
+        {
+            Point1 = point;
+            Point2 = point;
+            Point3 = point;
+        }
+
+        public LvcPoint Point1 { get; set; }
+        public LvcPoint Point2 { get; set; }
+        public LvcPoint Point3 { get; set; }
+        public LvcPoint StartPoint { get; set; }
+    }
+}

Others/Live-Charts-master/Core/ChartFunctions.cs

@@ -0,0 +1,311 @@
+//MIT License(MIT)
+
+//copyright(c) 2016 Alberto Rodriguez
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files ("Software"), to deal
+//in Software without restriction, including without limitation rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of Software, and to permit persons to whom Software is
+//furnished to do so, subject to following conditions:
+
+//above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of Software.
+
+//SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH SOFTWARE OR USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using LiveCharts.Charts;
+using LiveCharts.Definitions.Charts;
+using LiveCharts.Dtos;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Contains useful methods to apply to a chart
+    /// </summary>
+    public static class ChartFunctions
+    {
+        /// <summary>
+        /// Converts from chart values to chart control size.
+        /// </summary>
+        /// <param name="value">value to scale</param>
+        /// <param name="source">axis orientation to scale value at</param>
+        /// <param name="chart">chart model to scale value at</param>
+        /// <param name="axis">axis index in collection of chart.axis</param>
+        /// <returns></returns>
+        public static double ToPlotArea(double value, AxisOrientation source, ChartCore chart, int axis = 0)
+        {
+            var p1 = new CorePoint();
+            var p2 = new CorePoint();
+
+            if (source == AxisOrientation.Y)
+            {
+                p1.X = chart.AxisY[axis].TopLimit;
+                p1.Y = chart.DrawMargin.Top;
+
+                p2.X = chart.AxisY[axis].BotLimit;
+                p2.Y = chart.DrawMargin.Top + chart.DrawMargin.Height;
+            }
+            else
+            {
+                p1.X = chart.AxisX[axis].TopLimit;
+                p1.Y = chart.DrawMargin.Width + chart.DrawMargin.Left;
+
+                p2.X = chart.AxisX[axis].BotLimit;
+                p2.Y = chart.DrawMargin.Left;
+            }
+
+            var deltaX = p2.X - p1.X;
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            var m = (p2.Y - p1.Y)/(deltaX == 0 ? double.MinValue : deltaX);
+            return m * (value - p1.X) + p1.Y;
+        }
+
+        /// <summary>
+        /// Converts from chart values to chart control size.
+        /// </summary>
+        /// <param name="value">value to scale</param>
+        /// <param name="source">axis orientation to scale value at</param>
+        /// <param name="chart">chart model to scale value at</param>
+        /// <param name="axis">axis model instance</param>
+        /// <returns></returns>
+        public static double ToPlotArea(double value, AxisOrientation source, ChartCore chart, AxisCore axis)
+        {
+            var p1 = new CorePoint();
+            var p2 = new CorePoint();
+
+            if (source == AxisOrientation.Y)
+            {
+                p1.X = axis.TopLimit;
+                p1.Y = chart.DrawMargin.Top;
+
+                p2.X = axis.BotLimit;
+                p2.Y = chart.DrawMargin.Top + chart.DrawMargin.Height;
+            }
+            else
+            {
+                p1.X = axis.TopLimit;
+                p1.Y = chart.DrawMargin.Width + chart.DrawMargin.Left;
+
+                p2.X = axis.BotLimit;
+                p2.Y = chart.DrawMargin.Left;
+            }
+
+            var deltaX = p2.X - p1.X;
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            var m = (p2.Y - p1.Y) / (deltaX == 0 ? double.MinValue : deltaX);
+            return m * (value - p1.X) + p1.Y;
+        }
+
+        /// <summary>
+        /// Converts from chart control size to chart values.
+        /// </summary>
+        /// <param name="value">value to scale</param>
+        /// <param name="source">axis orientation to scale value at</param>
+        /// <param name="chart">chart model to scale value at</param>
+        /// <param name="axis">axis index in collection of chart.axis</param>
+        /// <returns></returns>
+        public static double FromPlotArea(double value, AxisOrientation source, ChartCore chart, int axis = 0)
+        {
+            var p1 = new CorePoint();
+            var p2 = new CorePoint();
+            
+            if (source == AxisOrientation.Y)
+            {
+                p1.X = chart.AxisY[axis].TopLimit;
+                p1.Y = chart.DrawMargin.Top;
+
+                p2.X = chart.AxisY[axis].BotLimit;
+                p2.Y = chart.DrawMargin.Top + chart.DrawMargin.Height;
+            }
+            else
+            {
+                p1.X = chart.AxisX[axis].TopLimit;
+                p1.Y = chart.DrawMargin.Width + chart.DrawMargin.Left;
+
+                p2.X = chart.AxisX[axis].BotLimit;
+                p2.Y = chart.DrawMargin.Left;
+            }
+
+            var deltaX = p2.X - p1.X;
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            var m = (p2.Y - p1.Y) / (deltaX == 0 ? double.MinValue : deltaX);
+            return (value + m * p1.X - p1.Y) / m;
+        }
+
+        /// <summary>
+        /// Converts from chart values to chart draw margin size.
+        /// </summary>
+        /// <param name="value">value to scale</param>
+        /// <param name="source">axis orientation</param>
+        /// <param name="chart">chart model to scale the value at</param>
+        /// <param name="axis">axis instance to scale the value at</param>
+        /// <returns></returns>
+        public static double ToDrawMargin(double value, AxisOrientation source, ChartCore chart, int axis = 0)
+        {
+            var o = source == AxisOrientation.X
+                ? chart.DrawMargin.Left
+                : chart.DrawMargin.Top;
+
+            return ToPlotArea(value, source, chart, axis) - o;
+        }
+
+        /// <summary>
+        /// Converts from chart values to chart draw margin size.
+        /// </summary>
+        /// <param name="value">value to scale</param>
+        /// <param name="source">axis orientation</param>
+        /// <param name="chart">chart model to scale the value at</param>
+        /// <param name="axis">axis instance to scale the value at</param>
+        /// <returns></returns>
+        public static double ToDrawMargin(double value, AxisOrientation source, ChartCore chart, AxisCore axis)
+        {
+            var o = source == AxisOrientation.X
+                ? chart.DrawMargin.Left
+                : chart.DrawMargin.Top;
+
+            return ToPlotArea(value, source, chart, axis) - o;
+        }
+
+        /// <summary>
+        /// Converts from chart values to chart draw margin size.
+        /// </summary>
+        /// <param name="point">point to scale</param>
+        /// <param name="axisXIndex">axis orientation</param>
+        /// <param name="axisYIndex">axis instance to scale the value at</param>
+        /// <param name="chart">chart model to scale the value at</param>
+        /// <returns></returns>
+        public static CorePoint ToDrawMargin(ChartPoint point, int axisXIndex, int axisYIndex, ChartCore chart)
+        {
+            return new CorePoint(
+                ToDrawMargin(point.X, AxisOrientation.X, chart, axisXIndex),
+                ToDrawMargin(point.Y, AxisOrientation.Y, chart, axisYIndex));
+        }
+
+        /// <summary>
+        /// Gets the width of a unit in the chart
+        /// </summary>
+        /// <param name="source">axis orientation</param>
+        /// <param name="chart">chart model to get the scale at</param>
+        /// <param name="axis">axis index in the axes collection</param>
+        /// <returns></returns>
+        public static double GetUnitWidth(AxisOrientation source, ChartCore chart, int axis = 0)
+        {
+            return GetUnitWidth(source, chart,
+                (source == AxisOrientation.X ? chart.AxisX : chart.AxisY)[axis]);
+        }
+
+        /// <summary>
+        /// Gets the width of a unit in the chart
+        /// </summary>
+        /// <param name="source">axis orientation</param>
+        /// <param name="chart">chart model to get the scale at</param>
+        /// <param name="axis">axis instance</param>
+        /// <returns></returns>
+        public static double GetUnitWidth(AxisOrientation source, ChartCore chart, AxisCore axis)
+        {
+            double min;
+            double u = !double.IsNaN(axis.View.BarUnit)
+                    ? axis.View.BarUnit
+                    : (!double.IsNaN(axis.View.Unit)
+                        ? axis.View.Unit
+                        : 1);
+
+            if (source == AxisOrientation.Y)
+            {
+                min = axis.BotLimit;
+                return ToDrawMargin(min, AxisOrientation.Y, chart, axis) -
+                       ToDrawMargin(min + u, AxisOrientation.Y, chart, axis);
+            }
+
+            min = axis.BotLimit;
+
+            return ToDrawMargin(min + u, AxisOrientation.X, chart, axis) -
+                   ToDrawMargin(min, AxisOrientation.X, chart, axis);
+        }
+
+        /// <summary>
+        /// Returns data in the chart according to:
+        /// </summary>
+        /// <param name="senderPoint">point that was hovered</param>
+        /// <param name="chart">chart model to get the data from</param>
+        /// <param name="selectionMode">selection mode</param>
+        /// <returns></returns>
+        public static TooltipDataViewModel GetTooltipData(ChartPoint senderPoint, ChartCore chart, TooltipSelectionMode selectionMode)
+        {
+            var ax = chart.AxisX[senderPoint.SeriesView.ScalesXAt];
+            var ay = chart.AxisY[senderPoint.SeriesView.ScalesYAt];
+
+            switch (selectionMode)
+            {
+                case TooltipSelectionMode.OnlySender:
+                    return new TooltipDataViewModel
+                    {
+                        XFormatter = ax.GetFormatter(),
+                        YFormatter = ay.GetFormatter(),
+                        Points = new List<ChartPoint> {senderPoint},
+                        Shares = null
+                    };
+                case TooltipSelectionMode.SharedXValues:
+                    var tx = Math.Abs(FromPlotArea(1, AxisOrientation.X, chart, senderPoint.SeriesView.ScalesXAt)
+                                      - FromPlotArea(2, AxisOrientation.X, chart, senderPoint.SeriesView.ScalesXAt)) * .01;
+                    return new TooltipDataViewModel
+                    {
+                        XFormatter = ax.GetFormatter(),
+                        YFormatter = ay.GetFormatter(),
+                        Points = chart.View.ActualSeries.Where(x => x.ScalesXAt == senderPoint.SeriesView.ScalesXAt)
+                            .SelectMany(x => x.Values.GetPoints(x))
+                            .Where(x => Math.Abs(x.X - senderPoint.X) < tx),
+                        Shares = (chart.View is IPieChart) ? null : (double?) senderPoint.X
+                    };
+                case TooltipSelectionMode.SharedYValues:
+                    var ty = Math.Abs(FromPlotArea(1, AxisOrientation.Y, chart, senderPoint.SeriesView.ScalesYAt)
+                                     - FromPlotArea(2, AxisOrientation.Y, chart, senderPoint.SeriesView.ScalesYAt)) * .01;
+                    return new TooltipDataViewModel
+                    {
+                        XFormatter = ax.GetFormatter(),
+                        YFormatter = ay.GetFormatter(),
+                        Points = chart.View.ActualSeries.Where(x => x.ScalesYAt == senderPoint.SeriesView.ScalesYAt)
+                            .SelectMany(x => x.Values.GetPoints(x))
+                            .Where(x => Math.Abs(x.Y - senderPoint.Y) < ty),
+                        Shares = senderPoint.Y
+                    };
+                case TooltipSelectionMode.SharedXInSeries:
+                    var txs = Math.Abs(FromPlotArea(1, AxisOrientation.X, chart, senderPoint.SeriesView.ScalesXAt)
+                                     - FromPlotArea(2, AxisOrientation.X, chart, senderPoint.SeriesView.ScalesXAt)) * .01;
+                    return new TooltipDataViewModel
+                    {
+                        XFormatter = ax.GetFormatter(),
+                        YFormatter = ay.GetFormatter(),
+                        Points = senderPoint.SeriesView.ActualValues.GetPoints(senderPoint.SeriesView)
+                            .Where(x => Math.Abs(x.X - senderPoint.X) < txs),
+                        Shares = senderPoint.X
+                    };
+                case TooltipSelectionMode.SharedYInSeries:
+                    var tys = Math.Abs(FromPlotArea(1, AxisOrientation.Y, chart, senderPoint.SeriesView.ScalesYAt)
+                                     - FromPlotArea(2, AxisOrientation.Y, chart, senderPoint.SeriesView.ScalesYAt)) * .01;
+                    return new TooltipDataViewModel
+                    {
+                        XFormatter = ax.GetFormatter(),
+                        YFormatter = ay.GetFormatter(),
+                        Points = senderPoint.SeriesView.ActualValues.GetPoints(senderPoint.SeriesView)
+                            .Where(x => Math.Abs(x.Y - senderPoint.Y) < tys),
+                        Shares = senderPoint.Y
+                    };
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+    }
+}
+ 

Others/Live-Charts-master/Core/ChartPoint.cs

@@ -0,0 +1,188 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using LiveCharts.Definitions.Charts;
+using LiveCharts.Definitions.Points;
+using LiveCharts.Definitions.Series;
+using LiveCharts.Dtos;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Defines a point in the chart
+    /// </summary>
+    public class ChartPoint
+    {
+
+        #region Cartesian 
+
+        /// <summary>
+        /// Gets the X point value
+        /// </summary>
+        public double X { get; internal set; }
+
+        /// <summary>
+        /// Gets the Y point value
+        /// </summary>
+        public double Y { get; internal set; }
+
+        #endregion
+
+        /// <summary>
+        /// Gets the Gantt x start value
+        /// </summary>
+        public double XStart { get; set; }
+
+        /// <summary>
+        /// Gets the Gantt y start value
+        /// </summary>
+        public double YStart { get; set; }
+
+        internal bool EvaluatesGantt { get; set; }
+
+        #region Gantt
+
+        #endregion
+
+        #region Weighted
+
+        /// <summary>
+        /// Gets the Weight of the point
+        /// </summary>
+        public double Weight { get; internal set; }
+
+        #endregion
+
+        #region stacked
+
+        /// <summary>
+        /// Gets where the stacked value started from
+        /// </summary>
+        public double From { get; internal set; }
+
+        /// <summary>
+        /// Gets where the stacked value finishes
+        /// </summary>
+        public double To { get; internal set; }
+
+        /// <summary>
+        /// Get the total sum of the stacked elements
+        /// </summary>
+        public double Sum { get; internal set; }
+
+        /// <summary>
+        /// Get the participation of the point in the stacked elements
+        /// </summary>
+        public double Participation { get; internal set; }
+
+        /// <summary>
+        /// gets the stacked participation of a point
+        /// </summary>
+        public double StackedParticipation { get; internal set; }
+
+        #endregion
+
+        #region Financial
+
+        /// <summary>
+        /// Gets the Open value of the point
+        /// </summary>
+        public double Open { get; internal set; }
+
+        /// <summary>
+        /// Gets the High value of the point
+        /// </summary>
+        public double High { get; internal set; }
+
+        /// <summary>
+        /// Gets the Low value of the point
+        /// </summary>
+        public double Low { get; internal set; }
+
+        /// <summary>
+        /// Gets the Close value of the point
+        /// </summary>
+        public double Close { get; internal set; }
+
+        #endregion
+
+        #region Polar
+
+        /// <summary>
+        /// Gets the Radius of a point
+        /// </summary>
+        public double Radius { get; internal set; }
+
+        /// <summary>
+        /// Gets the angle of a point
+        /// </summary>
+        public double Angle { get; internal set; }
+
+        #endregion
+
+        #region Appearance
+        /// <summary>
+        /// Gets the Fill brush of this point, this property overrides series Fill property 
+        /// </summary>
+        public object Fill { get; internal set; }
+        /// <summary>
+        /// Gets the Stroke brush of this point, this property overrides series Stroke property
+        /// </summary>
+        public object Stroke { get; internal set; }
+        #endregion
+
+        /// <summary>
+        /// Gets the coordinate where the value is placed at chart
+        /// </summary>
+        public CorePoint ChartLocation { get; internal set; }
+
+        /// <summary>
+        /// Gets the index of this point in the chart
+        /// </summary>
+        public int Key { get; internal set; }
+
+        /// <summary>
+        /// Gets the object where the chart pulled the point
+        /// </summary>
+        public object Instance { get; internal set; }
+
+        /// <summary >
+        /// Gets or sets the view of this chart point
+        /// </summary>
+        public IChartPointView View { get; internal set; }
+
+        /// <summary>
+        /// Gets the series where the point belongs to
+        /// </summary>
+        public ISeriesView SeriesView { get; internal set; }
+
+        /// <summary>
+        /// Gets the chart view.
+        /// </summary>
+        /// <value>
+        /// The chart view.
+        /// </value>
+        public IChartView ChartView { get { return SeriesView.Model.Chart.View; } }
+
+        internal double Gci { get; set; }
+    }
+}

Others/Live-Charts-master/Core/ChartUpdater.cs

@@ -0,0 +1,131 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using LiveCharts.Charts;
+using LiveCharts.Definitions.Series;
+using LiveCharts.Helpers;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ChartUpdater
+    {
+        /// <summary>
+        /// Gets or sets the chart.
+        /// </summary>
+        /// <value>
+        /// The chart.
+        /// </value>
+        public ChartCore Chart { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is updating.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance is updating; otherwise, <c>false</c>.
+        /// </value>
+        public bool IsUpdating { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [restart view requested].
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if [restart view requested]; otherwise, <c>false</c>.
+        /// </value>
+        public bool RestartViewRequested { get; set; }
+
+        private void InitializeSeriesView(ISeriesView seriesView)
+        {
+            Chart.View.EnsureElementBelongsToCurrentView(seriesView);
+        }
+
+        /// <summary>
+        /// Runs the specified restart view.
+        /// </summary>
+        /// <param name="restartView">if set to <c>true</c> [restart view].</param>
+        /// <param name="updateNow">if set to <c>true</c> [update now].</param>
+        /// <exception cref="System.NotImplementedException"></exception>
+        public virtual void Run(bool restartView = false, bool updateNow = false)   
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Updates the frequency.
+        /// </summary>
+        /// <param name="freq">The freq.</param>
+        /// <exception cref="System.NotImplementedException"></exception>
+        public virtual void UpdateFrequency(TimeSpan freq)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Updates the specified restarts animations.
+        /// </summary>
+        /// <param name="restartsAnimations">if set to <c>true</c> [restarts animations].</param>
+        /// <param name="force"></param>
+        protected void Update(bool restartsAnimations = false, bool force = false)   
+        {
+            if (Chart.View.UpdaterState == UpdaterState.Paused) return;
+             
+            if (!force && !Chart.View.IsControlLoaded) return;
+
+            if (restartsAnimations)
+                Chart.View.ActualSeries.ForEach(s =>
+                {
+                    if (s.ActualValues == null) return;
+                    s.ActualValues.GetPoints(s).ForEach(p =>
+                    {
+                        if (p == null || p.View == null) return;
+                        p.View.RemoveFromView(Chart);
+                        p.View = null;
+                    });
+                });
+
+            Chart.AxisX = Chart.View.MapXAxes(Chart);
+            Chart.AxisY = Chart.View.MapYAxes(Chart);
+
+            foreach (var series in Chart.View.ActualSeries)
+            {
+                InitializeSeriesView(series);
+                series.ActualValues.Initialize(series);
+                series.InitializeColors();
+                series.DrawSpecializedElements();
+            }
+
+            Chart.PrepareAxes();
+            Chart.RunSpecializedChartComponents();
+
+            foreach (var series in Chart.View.ActualSeries)
+            {
+                series.OnSeriesUpdateStart();
+                series.ActualValues.InitializeStep(series);
+                series.Model.Update();
+                series.ActualValues.CollectGarbage(series);
+                series.OnSeriesUpdatedFinish();
+                series.PlaceSpecializedElements();
+            }
+        }
+    }
+}

Others/Live-Charts-master/Core/ChartValues.cs

@@ -0,0 +1,354 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System.Collections.Generic;
+using System.Linq;
+using LiveCharts.Charts;
+using LiveCharts.Configurations;
+using LiveCharts.Definitions.Series;
+using LiveCharts.Dtos;
+using LiveCharts.Helpers;
+#if NET45
+using System.Reflection;
+#endif
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Creates a collection of chart values
+    /// </summary>
+    /// <typeparam name="T">Type to plot, notice you could need to configure the type.</typeparam>
+    public class ChartValues<T> : NoisyCollection<T>, IChartValues
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of chart values
+        /// </summary>
+        public ChartValues()
+        {
+            Trackers = new Dictionary<ISeriesView, PointTracker>();
+            NoisyCollectionChanged += OnChanged;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of chart values, with a given collection
+        /// </summary>
+        public ChartValues(IEnumerable<T> collection) : base(collection)
+        {
+            Trackers = new Dictionary<ISeriesView, PointTracker>();
+            NoisyCollectionChanged += OnChanged;
+        }
+
+        #endregion
+
+        #region Properties
+        private IPointEvaluator<T> DefaultConfiguration { get; set; }
+        private Dictionary<ISeriesView, PointTracker> Trackers { get; set; }
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Evaluates the limits in the chart values
+        /// </summary>
+        public void Initialize(ISeriesView seriesView)
+        {
+            var config = GetConfig(seriesView);
+            if (config == null) return;
+
+            var xMin = double.PositiveInfinity;
+            var xMax = double.NegativeInfinity;
+            var yMin = double.PositiveInfinity;
+            var yMax = double.NegativeInfinity;
+            var wMin = double.PositiveInfinity;
+            var wMax = double.NegativeInfinity;
+
+            var tracker = GetTracker(seriesView);
+
+            var cp = new ChartPoint();
+
+            var ax = seriesView.Model.Chart.AxisX[seriesView.ScalesXAt];
+            var ay = seriesView.Model.Chart.AxisY[seriesView.ScalesYAt];
+            double fx = double.IsNaN(ax.MinValue) ? double.NegativeInfinity : ax.MinValue,
+                tx = double.IsNaN(ax.MaxValue) ? double.PositiveInfinity : ax.MaxValue,
+                fy = double.IsNaN(ay.MinValue) ? double.NegativeInfinity : ay.MinValue,
+                ty = double.IsNaN(ay.MaxValue) ? double.PositiveInfinity : ay.MaxValue;
+
+            var isHorizontal = seriesView.Model.SeriesOrientation == SeriesOrientation.Horizontal;
+
+            var index = 0;
+            foreach(var item in this)
+            {
+                config.Evaluate(index, item, cp);
+                index++;
+
+                if (isHorizontal)
+                {
+                    if (cp.X < fx || cp.X > tx) continue;
+                }
+                else
+                {
+                    if (cp.Y < fy || cp.Y > ty) continue;
+                }
+
+                if (seriesView is IFinancialSeriesView)
+                {
+                    if (cp.X < xMin) xMin = cp.X;
+                    if (cp.X > xMax) xMax = cp.X;
+
+                    if (cp.Low < yMin) yMin = cp.Low;
+                    if (cp.High > yMax) yMax = cp.High;
+
+                    if (cp.Weight < wMin) wMin = cp.Weight;
+                    if (cp.Weight > wMax) wMax = cp.Weight;
+
+                }
+                else if (seriesView is IScatterSeriesView || seriesView is IHeatSeriesView)
+                {
+                    if (cp.X < xMin) xMin = cp.X;
+                    if (cp.X > xMax) xMax = cp.X;
+
+                    if (cp.Y < yMin) yMin = cp.Y;
+                    if (cp.Y > yMax) yMax = cp.Y;
+
+                    if (cp.Weight < wMin) wMin = cp.Weight;
+                    if (cp.Weight > wMax) wMax = cp.Weight;
+                }
+                else
+                {
+                    if (cp.X < xMin) xMin = cp.X;
+                    if (cp.X > xMax) xMax = cp.X;
+
+                    if (cp.Y < yMin) yMin = cp.Y;
+                    if (cp.Y > yMax) yMax = cp.Y;
+                }
+            }
+
+            tracker.XLimit = new CoreLimit(double.IsInfinity(xMin)
+                ? 0
+                : xMin, double.IsInfinity(yMin) ? 1 : xMax);
+            tracker.YLimit = new CoreLimit(double.IsInfinity(yMin)
+                ? 0
+                : yMin, double.IsInfinity(yMax) ? 1 : yMax);
+            tracker.WLimit = new CoreLimit(double.IsInfinity(wMin)
+                ? 0
+                : wMin, double.IsInfinity(wMax) ? 1 : wMax);
+
+        }
+
+        /// <summary>
+        /// Gets the current chart points in the view, the view is required as an argument, because an instance of IChartValues could hold many ISeriesView instances.
+        /// </summary>
+        /// <param name="seriesView">The series view</param>
+        /// <returns></returns>
+        public IEnumerable<ChartPoint> GetPoints(ISeriesView seriesView)
+        {
+            if (seriesView == null) yield break;
+
+            var config = GetConfig(seriesView);
+
+#if NET40
+            var isClass = typeof(T).IsClass;
+            var isObservable = isClass && typeof(IObservableChartPoint).IsAssignableFrom(typeof(T));
+#endif
+#if NET45
+            var isClass = typeof(T).GetTypeInfo().IsClass;
+            var isObservable = isClass &&
+                               typeof(IObservableChartPoint).GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo());
+#endif
+
+            var tracker = GetTracker(seriesView);
+            var gci = tracker.Gci;
+
+            var index = 0;
+            foreach (var value in this)
+            {
+                if (isObservable)
+                {
+                    var observable = (IObservableChartPoint)value;
+                    if (observable != null)
+                    {
+                        observable.PointChanged -= ObservableOnPointChanged;
+                        observable.PointChanged += ObservableOnPointChanged;
+                    }
+                }
+
+                var cp = GetChartPoint(isClass, tracker, index, value);
+
+                cp.Gci = gci;
+                cp.Instance = value;
+                cp.Key = index;
+                cp.SeriesView = seriesView;
+
+                config.Evaluate(index, value, cp);
+                index++;
+
+                yield return cp;
+            }
+        }
+
+        /// <summary>
+        /// Initializes the garbage collector
+        /// </summary>
+        public void InitializeStep(ISeriesView series)
+        {
+            ValidateGarbageCollector(series);
+            GetTracker(series).Gci++;
+        }
+
+        /// <summary>
+        /// Collects the unnecessary values 
+        /// </summary>
+        public void CollectGarbage(ISeriesView seriesView)
+        {
+#if NET40
+            var isclass = typeof(T).IsClass;
+#endif
+#if NET45
+            var isclass = typeof(T).GetTypeInfo().IsClass;
+#endif
+
+            var tracker = GetTracker(seriesView);
+
+            foreach (var garbage in GetGarbagePoints(seriesView).ToList())
+            {
+                if (garbage.View != null) //yes null, double.Nan Values, will generate null views.
+                    garbage.View.RemoveFromView(seriesView.Model.Chart);
+
+                if (!isclass)
+                {
+                    tracker.Indexed.Remove(garbage.Key);
+                }
+                else
+                {
+                    tracker.Referenced.Remove(garbage.Instance);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets series that owns the values
+        /// </summary>
+        /// <param name="view"></param>
+        /// <returns></returns>
+        public PointTracker GetTracker(ISeriesView view)
+        {
+            PointTracker tracker;
+
+            if (Trackers.TryGetValue(view, out tracker)) return tracker;
+
+            tracker = new PointTracker();
+            Trackers[view] = tracker;
+
+            return tracker;
+        }
+
+        #endregion
+
+        #region Privates
+
+        private IPointEvaluator<T> GetConfig(ISeriesView view)
+        {
+            //Trying to get the user defined configuration...
+
+            //series == null means that chart values are null, and LiveCharts
+            //could not set the Series Instance tho the current chart values...
+            if (view == null || view.Model.SeriesCollection == null) return null;
+
+            var config =
+                (view.Configuration ?? view.Model.SeriesCollection.Configuration) as IPointEvaluator<T>;
+
+            if (config != null) return config;
+
+            return DefaultConfiguration ??
+                   (DefaultConfiguration =
+                       ChartCore.Configurations.GetConfig<T>(view.Model.SeriesOrientation) as IPointEvaluator<T>);
+        }
+
+        private static ChartPoint GetChartPoint(bool isClass, PointTracker tracker, int index, T value)
+        {
+            ChartPoint cp;
+
+            if (!isClass)
+            {
+                if (tracker.Indexed.TryGetValue(index, out cp)) return cp;
+                cp = new ChartPoint
+                {
+                    Instance = value,
+                    Key = index
+                };
+                tracker.Indexed[index] = cp;
+            }
+            else
+            {
+                if (tracker.Referenced.TryGetValue(value, out cp)) return cp;
+                cp = new ChartPoint
+                {
+                    Instance = value,
+                    Key = index
+                };
+                tracker.Referenced[value] = cp;
+            }
+            return cp;
+        }
+
+        private void ObservableOnPointChanged()
+        {
+            Trackers.Keys.ForEach(x => x.Model.Chart.Updater.Run());
+        }
+
+        private IEnumerable<ChartPoint> GetGarbagePoints(ISeriesView view)
+        {
+            var tracker = GetTracker(view);
+
+            return tracker.Indexed.Values.Where(x => IsGarbage(x, tracker)).Concat(
+                tracker.Referenced.Values.Where(x => IsGarbage(x, tracker)));
+        }
+
+        private void ValidateGarbageCollector(ISeriesView view)
+        {
+            var tracker = GetTracker(view);
+
+            if (tracker.Gci != int.MaxValue) return;
+
+            tracker.Gci = 0;
+
+            foreach (var point in tracker.Indexed.Values.Concat(tracker.Referenced.Values))
+                point.Gci = 0;
+        }
+
+        private static bool IsGarbage(ChartPoint point, PointTracker tracker)
+        {
+            return point.Gci < tracker.Gci
+                   || double.IsNaN(point.X) || double.IsNaN(point.Y);
+        }
+
+        private void OnChanged(IEnumerable<T> oldItems, IEnumerable<T> newItems)
+        {
+            if (Trackers.Keys.All(x => x != null && x.Model.Chart != null))
+                Trackers.Keys.ForEach(x => x.Model.Chart.Updater.Run());
+        }
+
+        #endregion
+    }
+}

Others/Live-Charts-master/Core/Charting.cs

@@ -0,0 +1,234 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using LiveCharts.Configurations;
+using LiveCharts.Defaults;
+using LiveCharts.Helpers;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Global LiveCharts configuration
+    /// </summary>
+    public class Charting
+    {
+        private static readonly Dictionary<Type, ConfigWrapper> Configurations;
+
+        #region Constructors
+
+        //Lets define some default configurations, all charts should be able to detect any of these types and plot
+        //them correctly
+
+        static Charting()
+        {
+            Configurations = new Dictionary<Type, ConfigWrapper>();
+
+            // Live.Charts can plot any type, yes even any class defined by yourself.
+            // you just need to tell the charts how to plot it.
+            // for example the XY Mapper exposes an X and Y method,
+            // for example .X( "mapper" ) asks for the function to get the value of a point in X, same with Y
+            // live charts will inject a value and an index
+            // the value will be of type <T> and the index is only the value of the point in the array.
+
+            //the SeriesMappers class is just a reminder of the configurations that we have, it actually just
+            //returns a new instance of the related configuration
+            //a configuration is only a holder for the mappers.
+
+            //lets configure <int>
+
+            For<int>(Mappers.Xy<int>()
+                .X((value, index) => index) //use the index of the item in the array as X
+                .Y(value => value), SeriesOrientation.Horizontal); //use the value (of type int integer this case) as Y
+            For<int>(Mappers.Xy<int>()
+                .X(value => value) //use the value (int) as X
+                .Y((value, index) => index), SeriesOrientation.Vertical); //use the index of the item in the array as Y
+
+            //OK now lets configure a class I defined, the ObservablePoint class, it only has 2 properties, X and Y
+
+            For<ObservablePoint>(Mappers.Xy<ObservablePoint>() //in this case value is of type <ObservablePoint>
+                .X(value => value.X) //use the X property as X
+                .Y(value => value.Y)); //use the Y property as Y
+
+            //easy, now live charts know how to plot an ObservablePoint class and integers.
+
+            //OK, now lets use another mapper, in this case we are going to configure a class for a PolarChart
+            //polar chart requires a Radius and an Angle instead of X and Y
+            //so we will just pull the Mappers.Polar configuration
+            //and specify which property to use as Radius and which one as Angle
+            //in this case the PolarPoint class that I defined only contains these 2 properties.
+            //so it is really easy, now value is of type Polar point, because we said so when: SeriesMappers.Polar<PolarPoint>()
+
+            For<PolarPoint>(Mappers.Polar<PolarPoint>()
+                .Radius(value => value.Radius) //use the radius property as radius for the plotting
+                .Angle(value => value.Angle)); //use the angle property as angle for the plotting
+
+            //now a more complex situation
+            //the OhclPoint is ready to plot financial points,
+            //the financial series requires a Open, High, Low, and Close values at least
+            //that is just by definition of a CandleStick series
+            //so I created a OhclPoint class, and used the Financial mapper:
+            //and again the OhclPoint class only contains those 4 properties
+            //we just mapped them correctly and LiveCharts will know how to handle this class.
+
+            //the DateTime for now its tricky....
+            //I will explain better later if i do not find a better solution...
+
+            For<OhlcPoint>(Mappers.Financial<OhlcPoint>()
+                .X((value, index) => index)
+                .Open(value => value.Open)
+                .High(value => value.High)
+                .Low(value => value.Low)
+                .Close(value => value.Close), SeriesOrientation.Horizontal);
+
+            For<double>(Mappers.Xy<double>()
+                .X((value, index) => index)
+                .Y(value => value), SeriesOrientation.Horizontal);
+            For<double>(Mappers.Xy<double>()
+                .X(value => value)
+                .Y((value, index) => index), SeriesOrientation.Vertical);
+
+            For<decimal>(Mappers.Xy<decimal>()
+                .X((value, index) => index)
+                .Y(value => (double) value), SeriesOrientation.Horizontal);
+            For<decimal>(Mappers.Xy<decimal>()
+                .X(value => (double) value)
+                .Y((value, index) => index), SeriesOrientation.Vertical);
+
+            For<short>(Mappers.Xy<short>()
+                .X((value, index) => index)
+                .Y(value => value), SeriesOrientation.Horizontal);
+            For<short>(Mappers.Xy<short>()
+                .X(value => value)
+                .Y((value, index) => index), SeriesOrientation.Vertical);
+
+            For<float>(Mappers.Xy<float>()
+                .X((value, index) => index)
+                .Y(value => value), SeriesOrientation.Horizontal);
+            For<float>(Mappers.Xy<float>()
+                .X(value => value)
+                .Y((value, index) => index), SeriesOrientation.Vertical);
+
+            For<long>(Mappers.Xy<long>()
+                .X((value, index) => index)
+                .Y(value => value), SeriesOrientation.Horizontal);
+            For<long>(Mappers.Xy<long>()
+                .X(value => value)
+                .Y((value, index) => index), SeriesOrientation.Vertical);
+
+            For<ScatterPoint>(Mappers.Weighted<ScatterPoint>()
+                .X(value => value.X)
+                .Y(value => value.Y)
+                .Weight(value => value.Weight));
+
+            For<HeatPoint>(Mappers.Weighted<HeatPoint>()
+                .X(value => value.X)
+                .Y(value => value.Y)
+                .Weight(value => value.Weight));
+
+            For<ObservableValue>(Mappers.Xy<ObservableValue>()
+                .X((value, index) => index)
+                .Y(value => value.Value),
+                SeriesOrientation.Horizontal);
+            For<ObservableValue>(Mappers.Xy<ObservableValue>()
+                .X(value => value.Value)
+                .Y((value, index) => index),
+                SeriesOrientation.Vertical);
+
+            For<DateTimePoint>(Mappers.Xy<DateTimePoint>()
+                .X(value => value.DateTime.Ticks)
+                .Y(value => value.Value), SeriesOrientation.Horizontal);
+            For<DateTimePoint>(Mappers.Xy<DateTimePoint>()
+                .X(value => value.Value)
+                .Y(value => value.DateTime.Ticks), SeriesOrientation.Vertical);
+
+            For<GanttPoint>(Mappers.Gantt<GanttPoint>()
+                .X((v, i) => -i)
+                .YStart(v => v.StartPoint)
+                .Y(v => v.EndPoint), SeriesOrientation.Horizontal);
+            For<GanttPoint>(Mappers.Gantt<GanttPoint>()
+                .Y((v, i) => -i)
+                .XStart(v => v.StartPoint)
+                .X(v => v.EndPoint), SeriesOrientation.Vertical);
+        }
+
+        /// <summary>
+        /// Saves a type mapper globally.
+        /// </summary>
+        /// <typeparam name="T">Type to configure</typeparam>
+        /// <param name="config">mapper</param>
+        /// <param name="orientation">mapper orientation</param>
+        public static void For<T>(object config, SeriesOrientation orientation = SeriesOrientation.All)
+        {
+            ConfigWrapper wrapper;
+            var t = typeof (T);
+
+            if (!Configurations.TryGetValue(t, out wrapper))
+            {
+                wrapper = new ConfigWrapper();
+                Configurations[t] = wrapper;
+            }
+
+            if (orientation == SeriesOrientation.All)
+            {
+                wrapper.VerticalConfig = config;
+                wrapper.HorizontalConfig = config;
+
+                return;
+            }
+
+            if (orientation == SeriesOrientation.Horizontal) wrapper.HorizontalConfig = config;
+            else wrapper.VerticalConfig = config;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Gets the configuration of a given type and orientation
+        /// </summary>
+        /// <typeparam name="T">type to look for</typeparam>
+        /// <param name="orientation">orientation to look for</param>
+        /// <returns></returns>
+        public object GetConfig<T>(SeriesOrientation orientation = SeriesOrientation.Horizontal)
+        {
+            ConfigWrapper wrapper;
+
+            if (!Configurations.TryGetValue(typeof(T), out wrapper))
+                throw new LiveChartsException("LiveCharts does not know how to plot " + typeof(T).Name + ", " +
+                                              "you can either, use an already configured type " +
+                                              "or configure this type you are trying to use, " +
+                                              "For more info see " +
+                                              "http://lvcharts.net/App/examples/v1/wpf/Types%20and%20Configuration");
+
+            return orientation == SeriesOrientation.Horizontal || orientation == SeriesOrientation.All
+                ? wrapper.HorizontalConfig
+                : wrapper.VerticalConfig;
+        }
+    }
+
+    internal class ConfigWrapper
+    {
+        public object HorizontalConfig { get; set; }
+        public object VerticalConfig { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Charts/CartesianChartCore.cs

@@ -0,0 +1,323 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using LiveCharts.Definitions.Charts;
+using LiveCharts.Definitions.Series;
+using LiveCharts.Dtos;
+using LiveCharts.Helpers;
+
+namespace LiveCharts.Charts
+{
+    /// <summary>
+    /// Chart Model
+    /// </summary>
+    public class CartesianChartCore : ChartCore
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Initializes Chart model
+        /// </summary>
+        /// <param name="view">The view.</param>
+        /// <param name="updater">The updater.</param>
+        public CartesianChartCore(IChartView view, ChartUpdater updater) : base(view, updater)
+        {
+            updater.Chart = this;
+        }
+
+        #endregion
+
+        #region Publics
+
+        /// <summary>
+        /// Prepares Chart Axes
+        /// </summary>
+        public override void PrepareAxes()
+        {
+            base.PrepareAxes();
+
+            if (View.ActualSeries.Any(x => !(x.Model is ICartesianSeries)))
+                throw new LiveChartsException(
+                    "There is a invalid series in the series collection, " +
+                    "verify that all the series implement ICartesianSeries.");
+
+            var cartesianSeries = View.ActualSeries.Select(x => x.Model).Cast<ICartesianSeries>().ToArray();
+
+            for (var index = 0; index < AxisX.Count; index++)
+            {
+                var xi = AxisX[index];
+
+                xi.CalculateSeparator(this, AxisOrientation.X);
+
+                // ReSharper disable once AccessToModifiedClosure
+                SetAxisLimits(xi, cartesianSeries.Where(x => x.View.ScalesXAt == index).ToArray(), AxisOrientation.X);
+
+                if (Math.Abs(xi.BotLimit - xi.TopLimit) < xi.S * .01)
+                {
+                    if (Math.Abs(xi.PreviousBot - xi.PreviousTop) < xi.S * .01)
+                    {
+                        if (double.IsNaN(xi.MinValue)) xi.BotLimit -= xi.S;
+                        else xi.BotLimit = xi.MinValue;
+
+                        if (double.IsNaN(xi.MaxValue)) xi.TopLimit += xi.S;
+                        else xi.TopLimit = xi.MaxValue;
+
+                        if (Math.Abs(xi.BotLimit - xi.TopLimit) < xi.S * .01 && !View.IsInDesignMode)
+                            throw new LiveChartsException("One axis has an invalid range, it is or it is " +
+                                                          "tends to zero, please ensure your axis has a valid " +
+                                                          "range");
+                    }
+                    else
+                    {
+                        xi.BotLimit = xi.PreviousBot;
+                        xi.TopLimit = xi.PreviousTop;
+                    }
+                }
+                xi.PreviousBot = xi.BotLimit;
+                xi.PreviousTop = xi.TopLimit;
+            }
+
+            for (var index = 0; index < AxisY.Count; index++)
+            {
+                var yi = AxisY[index];
+
+                yi.CalculateSeparator(this, AxisOrientation.Y);
+
+                // ReSharper disable once AccessToModifiedClosure
+                SetAxisLimits(yi, cartesianSeries.Where(x => x.View.ScalesYAt == index).ToArray(), AxisOrientation.Y);
+
+                if (Math.Abs(yi.BotLimit - yi.TopLimit) < yi.S * .01)
+                {
+                    if (Math.Abs(yi.PreviousBot - yi.PreviousTop) < yi.S * .01)
+                    {
+                        if (double.IsNaN(yi.MinValue)) yi.BotLimit -= yi.S;
+                        else yi.BotLimit = yi.MinValue;
+
+                        if (double.IsNaN(yi.MaxValue)) yi.TopLimit += yi.S;
+                        else yi.TopLimit = yi.MaxValue;
+
+                        if (Math.Abs(yi.BotLimit - yi.TopLimit) < yi.S * .01)
+                            throw new LiveChartsException("One axis has an invalid range, it is or it " +
+                                                          "tends to zero, please ensure your axis has a valid " +
+                                                          "range");
+                    }
+                    else
+                    {
+                        yi.BotLimit = yi.PreviousBot;
+                        yi.TopLimit = yi.PreviousTop;
+                    }
+                }
+                yi.PreviousBot = yi.BotLimit;
+                yi.PreviousTop = yi.TopLimit;
+            }
+
+            PrepareSeries();
+            CalculateComponentsAndMargin();
+            DrawOrUpdateSections();
+
+            AreComponentsLoaded = true;
+        }
+
+        /// <summary>
+        /// Runs the specialized chart components.
+        /// </summary>
+        public override void RunSpecializedChartComponents()
+        {
+            foreach (var visualElement in ((ICartesianChart) View).VisualElements)
+            {
+                visualElement.AddOrMove(this);
+            }
+        }
+
+        /// <summary>
+        /// Draws the or update sections.
+        /// </summary>
+        public void DrawOrUpdateSections()
+        {
+            for (var index = 0; index < AxisX.Count; index++)
+            {
+                var xi = AxisX[index];
+                foreach (var section in xi.Sections)
+                {
+                    section.AxisIndex = index;
+                    section.Source = AxisOrientation.X;
+                    section.View.DrawOrMove(AxisOrientation.X, index);
+                }
+            }
+
+            for (var index = 0; index < AxisY.Count; index++)
+            {
+                var yi = AxisY[index];
+                foreach (var section in yi.Sections)
+                {
+                    section.AxisIndex = index;
+                    section.Source = AxisOrientation.Y;
+                    section.View.DrawOrMove(AxisOrientation.Y, index);
+                }
+            }
+            
+        }
+
+        #endregion
+
+        #region Privates
+
+        private static void SetAxisLimits(AxisCore ax, IList<ICartesianSeries> series, AxisOrientation orientation)
+        {
+            var first = new CoreLimit();
+            var firstR = 0d;
+
+            if (series.Count > 0)
+            {
+                first = orientation == AxisOrientation.X
+                    ? new CoreLimit(series[0].GetMinX(ax), series[0].GetMaxX(ax))
+                    : new CoreLimit(series[0].GetMinY(ax), series[0].GetMaxY(ax));
+                var view = series[0].View as IAreaPoint;
+                firstR = view != null ? view.GetPointDiameter() : 0;
+            }
+
+            //                     [ max, min, pointRadius ]
+            var boundries = new[] { first.Max, first.Min, firstR };
+
+            for (var index = 1; index < series.Count; index++)
+            {
+                var cartesianSeries = series[index];
+                var limit = orientation == AxisOrientation.X
+                    ? new CoreLimit(cartesianSeries.GetMinX(ax), cartesianSeries.GetMaxX(ax))
+                    : new CoreLimit(cartesianSeries.GetMinY(ax), cartesianSeries.GetMaxY(ax));
+                var view = cartesianSeries.View as IAreaPoint;
+                var radius = view != null ? view.GetPointDiameter() : 0;
+
+                if (limit.Max > boundries[0]) boundries[0] = limit.Max;
+                if (limit.Min < boundries[1]) boundries[1] = limit.Min;
+                if (radius > boundries[2]) boundries[2] = radius;
+            }
+
+            ax.TopSeriesLimit = boundries[0];
+            ax.BotSeriesLimit = boundries[1];
+
+            ax.TopLimit = double.IsNaN(ax.MaxValue) ? boundries[0] : ax.MaxValue;
+            ax.BotLimit = double.IsNaN(ax.MinValue) ? boundries[1] : ax.MinValue;
+
+            ax.MaxPointRadius = boundries[2];
+        }
+
+        private void PrepareSeries()
+        {
+            PrepareUnitWidth();
+            PrepareWeight();
+            PrepareStackedColumns();
+            PrepareStackedRows();
+            PrepareStackedAreas();
+            PrepareVerticalStackedAreas();
+        }
+
+        private void PrepareWeight()
+        {
+            if (!View.ActualSeries.Any(x => x is IScatterSeriesView || x is IHeatSeriesView)) return;
+
+            var vs = View.ActualSeries
+                .Select(x => x.ActualValues.GetTracker(x).WLimit)
+                .DefaultIfEmpty(new CoreLimit()).ToArray();
+            WLimit = new CoreLimit(vs.Select(x => x.Min).DefaultIfEmpty(0).Min(),
+                vs.Select(x => x.Max).DefaultIfEmpty(0).Max());
+        }
+
+        private void PrepareUnitWidth()
+        {
+            foreach (var series in View.ActualSeries)
+            {
+                if (series is IStackedColumnSeriesView || series is IColumnSeriesView || 
+                    series is IFinancialSeriesView || series is IHeatSeriesView)
+                {
+                    AxisX[series.ScalesXAt].EvaluatesUnitWidth = true;
+                }
+                if (series is IStackedRowSeriesView || series is IRowSeriesView || series is IHeatSeriesView)
+                {
+                    AxisY[series.ScalesYAt].EvaluatesUnitWidth = true;
+                }
+            }
+        }
+
+        private void PrepareStackedColumns()
+        {
+            if (!View.ActualSeries.Any(x => x is IStackedColumnSeriesView)) return;
+
+            var isPercentage =
+                View.ActualSeries.Any(x => x is IStackModelableSeriesView && x is IStackedColumnSeriesView &&
+                                           ((IStackModelableSeriesView) x).StackMode == StackMode.Percentage);
+
+            foreach (var group in View.ActualSeries.OfType<IStackedColumnSeriesView>().GroupBy(x => x.ScalesYAt))
+            {
+                StackPoints(group, AxisOrientation.Y, group.Key, isPercentage
+                    ? StackMode.Percentage : StackMode.Values);
+            }
+        }
+
+        private void PrepareStackedRows()
+        {
+            if (!View.ActualSeries.Any(x => x is IStackedRowSeriesView)) return;
+
+            var isPercentage =
+                View.ActualSeries.Any(x => x is IStackModelableSeriesView && x is IStackedRowSeriesView &&
+                                     ((IStackModelableSeriesView) x).StackMode == StackMode.Percentage);
+
+            foreach (var group in View.ActualSeries.OfType<IStackedRowSeriesView>().GroupBy(x => x.ScalesXAt))
+            {
+                StackPoints(group, AxisOrientation.X, group.Key, isPercentage ? StackMode.Percentage : StackMode.Values);
+            }
+        }
+
+        private void PrepareStackedAreas()
+        {
+            if (!View.ActualSeries.Any(x => x is IStackedAreaSeriesView)) return;
+
+            var isPercentage =
+                View.ActualSeries.Any(x => x is IStackModelableSeriesView && x is IStackedAreaSeriesView &&
+                                     ((IStackModelableSeriesView) x).StackMode == StackMode.Percentage);
+
+            foreach (var group in View.ActualSeries.OfType<IStackedAreaSeriesView>().GroupBy(x => x.ScalesYAt))
+            {
+                StackPoints(group, AxisOrientation.Y, group.Key, isPercentage ? StackMode.Percentage : StackMode.Values);
+            }
+        }
+
+        private void PrepareVerticalStackedAreas()
+        {
+            if (!View.ActualSeries.Any(x => x is IVerticalStackedAreaSeriesView)) return;
+
+            var isPercentage =
+                View.ActualSeries.Any(x => x is IStackModelableSeriesView && x is IVerticalStackedAreaSeriesView &&
+                                     ((IStackModelableSeriesView) x).StackMode == StackMode.Percentage);
+
+            foreach (var group in View.ActualSeries.OfType<IVerticalStackedAreaSeriesView>().GroupBy(x => x.ScalesXAt))
+            {
+                StackPoints(group, AxisOrientation.X, group.Key, isPercentage ? StackMode.Percentage : StackMode.Values);
+            }
+        }
+
+        #endregion
+    }
+}

Others/Live-Charts-master/Core/Charts/ChartCore.cs

@@ -0,0 +1,751 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.CodeDom.Compiler;
+using System.Collections.Generic;
+using System.Linq;
+using LiveCharts.Definitions.Charts;
+using LiveCharts.Definitions.Series;
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public abstract class ChartCore
+    {
+        #region Constructors
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ChartCore"/> class.
+        /// </summary>
+        /// <param name="view">The view.</param>
+        /// <param name="updater">The updater.</param>
+        protected ChartCore(IChartView view, ChartUpdater updater)
+        {
+            View = view;
+            Updater = updater;
+            DrawMargin = new CoreRectangle();
+            DrawMargin.SetHeight += view.SetDrawMarginHeight;
+            DrawMargin.SetWidth += view.SetDrawMarginWidth;
+            DrawMargin.SetTop += view.SetDrawMarginTop;
+            DrawMargin.SetLeft += view.SetDrawMarginLeft;
+        }
+
+        /// <summary>
+        /// Initializes the <see cref="ChartCore"/> class.
+        /// </summary>
+        static ChartCore()
+        {
+            Configurations = new Charting();
+        }
+
+        #endregion
+
+        #region Properties 
+
+        /// <summary>
+        /// Gets or sets the configurations.
+        /// </summary>
+        /// <value>
+        /// The configurations.
+        /// </value>
+        public static Charting Configurations { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [series initialized].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [series initialized]; otherwise, <c>false</c>.
+        /// </value>
+        public bool SeriesInitialized { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [are components loaded].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [are components loaded]; otherwise, <c>false</c>.
+        /// </value>
+        public bool AreComponentsLoaded { get; set; }
+        /// <summary>
+        /// Gets or sets the view.
+        /// </summary>
+        /// <value>
+        /// The view.
+        /// </value>
+        public IChartView View { get; set; }
+        /// <summary>
+        /// Gets or sets the updater.
+        /// </summary>
+        /// <value>
+        /// The updater.
+        /// </value>
+        public ChartUpdater Updater { get; set; }
+        /// <summary>
+        /// Gets or sets the size of the control.
+        /// </summary>
+        /// <value>
+        /// The size of the control.
+        /// </value>
+        public CoreSize ControlSize { get; set; }
+        /// <summary>
+        /// Gets or sets the draw margin.
+        /// </summary>
+        /// <value>
+        /// The draw margin.
+        /// </value>
+        public CoreRectangle DrawMargin { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance has unitary points.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance has unitary points; otherwise, <c>false</c>.
+        /// </value>
+        public bool HasUnitaryPoints { get; set; }
+        /// <summary>
+        /// Gets a value indicating whether [requires hover shape].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [requires hover shape]; otherwise, <c>false</c>.
+        /// </value>
+        public bool RequiresHoverShape
+        {
+            get
+            {
+                return View != null &&
+                       (View.HasTooltip || View.HasDataClickEventAttached || View.Hoverable);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the axis x.
+        /// </summary>
+        /// <value>
+        /// The axis x.
+        /// </value>
+        public List<AxisCore> AxisX { get; set; }
+        /// <summary>
+        /// Gets or sets the axis y.
+        /// </summary>
+        /// <value>
+        /// The axis y.
+        /// </value>
+        public List<AxisCore> AxisY { get; set; }
+
+        /// <summary>
+        /// Gets or sets the x limit.
+        /// </summary>
+        /// <value>
+        /// The x limit.
+        /// </value>
+        public CoreLimit XLimit { get; set; }
+        /// <summary>
+        /// Gets or sets the y limit.
+        /// </summary>
+        /// <value>
+        /// The y limit.
+        /// </value>
+        public CoreLimit YLimit { get; set; }
+        /// <summary>
+        /// Gets or sets the w limit.
+        /// </summary>
+        /// <value>
+        /// The w limit.
+        /// </value>
+        public CoreLimit WLimit { get; set; }
+
+        /// <summary>
+        /// Gets or sets the index of the current color.
+        /// </summary>
+        /// <value>
+        /// The index of the current color.
+        /// </value>
+        public int CurrentColorIndex { get; set; }
+
+        /// <summary>
+        /// Gets or sets the pan origin.
+        /// </summary>
+        /// <value>
+        /// The pan origin.
+        /// </value>
+        public CorePoint PanOrigin { get; set; }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Prepares the axes.
+        /// </summary>
+        public virtual void PrepareAxes()
+        {
+            for (var index = 0; index < AxisX.Count; index++)
+            {
+                SetAxisLimits(
+                    AxisX[index],
+                    View.ActualSeries
+                        // ReSharper disable once AccessToModifiedClosure
+                        .Where(series => series.Values != null && series.ScalesXAt == index).ToArray(),
+                    AxisOrientation.X);
+            }
+
+            for (var index = 0; index < AxisY.Count; index++)
+            {
+                SetAxisLimits(
+                    AxisY[index],
+                    View.ActualSeries
+                        // ReSharper disable once AccessToModifiedClosure
+                        .Where(series => series.Values != null && series.ScalesYAt == index).ToArray(),
+                    AxisOrientation.Y);
+            }
+        }
+
+        /// <summary>
+        /// Runs the specialized chart components.
+        /// </summary>
+        public virtual void RunSpecializedChartComponents()
+        {
+            
+        }
+
+        /// <summary>
+        /// Calculates the components and margin.
+        /// </summary>
+        public void CalculateComponentsAndMargin()
+        {
+            var curSize = new CoreRectangle(0, 0, ControlSize.Width, ControlSize.Height);
+
+            curSize = PlaceLegend(curSize);
+
+            const double padding = 4;
+
+            for (int index = 0; index < AxisY.Count; index++)
+            {
+                var ax = AxisY[index];
+                var titleSize = ax.View.UpdateTitle(this, -90d);
+                var biggest = ax.PrepareChart(AxisOrientation.Y, this);
+
+                var x = curSize.Left;
+
+                if (ax.Position == AxisPosition.LeftBottom)
+                {
+                    ax.View.SetTitleLeft(x);
+                    curSize.Left += titleSize.Height + biggest.Width + padding;
+                    curSize.Width -= (titleSize.Height + biggest.Width + padding);
+                    ax.Tab = curSize.Left;
+                }
+                else
+                {
+                    ax.View.SetTitleLeft(x + curSize.Width - titleSize.Height);
+                    curSize.Width -= (titleSize.Height + biggest.Width + padding);
+                    ax.Tab = curSize.Left + curSize.Width;
+                }
+
+                var uw = ax.EvaluatesUnitWidth ? ChartFunctions.GetUnitWidth(AxisOrientation.Y, this, index)/2 : 0;
+
+                var topE = biggest.Top - uw;
+                if (topE> curSize.Top)
+                {
+                    var dif = topE - curSize.Top;
+                    curSize.Top += dif;
+                    curSize.Height -= dif;
+                }
+
+                var botE = biggest.Bottom - uw;
+                if (botE > ControlSize.Height - (curSize.Top + curSize.Height))
+                {
+                    var dif = botE - (ControlSize.Height - (curSize.Top + curSize.Height));
+                    curSize.Height -= dif;
+                }
+            }
+
+            for (var index = 0; index < AxisX.Count; index++)
+            {
+                var xi = AxisX[index];
+                var titleSize = xi.View.UpdateTitle(this);
+                var biggest = xi.PrepareChart(AxisOrientation.X, this);
+                var top = curSize.Top;
+
+                if (xi.Position == AxisPosition.LeftBottom)
+                {
+                    xi.View.SetTitleTop(top + curSize.Height - titleSize.Height);
+                    curSize.Height -= (titleSize.Height + biggest.Height);
+                    xi.Tab = curSize.Top + curSize.Height;
+                }
+                else
+                {
+                    xi.View.SetTitleTop(top);
+                    curSize.Top += titleSize.Height + biggest.Height;
+                    curSize.Height -= (titleSize.Height + biggest.Height);
+                    xi.Tab = curSize.Top;
+                }
+
+                //Notice the unit width is not exact at this point...
+                var uw = xi.EvaluatesUnitWidth ? ChartFunctions.GetUnitWidth(AxisOrientation.X, this, index)/2 : 0;
+
+                var leftE = biggest.Left - uw > 0 ? biggest.Left - uw : 0;
+                if (leftE > curSize.Left)
+                {
+                    var dif = leftE - curSize.Left;
+                    curSize.Left += dif;
+                    curSize.Width -= dif;
+                    foreach (var correctedAxis in AxisY
+                        .Where(correctedAxis => correctedAxis.Position == AxisPosition.LeftBottom))
+                    {
+                        correctedAxis.Tab += dif;
+                    }
+                }
+
+                var rightE = biggest.Right - uw > 0 ? biggest.Right - uw : 0;
+                if (rightE > ControlSize.Width - (curSize.Left + curSize.Width))
+                {
+                    var dif = rightE - (ControlSize.Width - (curSize.Left + curSize.Width));
+                    curSize.Width -= dif;
+                    foreach (var correctedAxis in AxisY
+                        .Where(correctedAxis => correctedAxis.Position == AxisPosition.RightTop))
+                    {
+                        correctedAxis.Tab -= dif;
+                    }
+                }
+            }
+
+            DrawMargin.Top = curSize.Top;
+            DrawMargin.Left = curSize.Left;
+            DrawMargin.Width = curSize.Width;
+            DrawMargin.Height = curSize.Height;
+
+            for (var index = 0; index < AxisY.Count; index++)
+            {
+                var ax = AxisY[index];
+                var pr = ChartFunctions.FromPlotArea(ax.MaxPointRadius, AxisOrientation.Y, this, index) -
+                         ChartFunctions.FromPlotArea(0, AxisOrientation.Y, this, index);
+                if (!double.IsNaN(pr))
+                {
+                    ax.BotLimit += pr;
+                    ax.TopLimit -= pr;
+                }
+                ax.UpdateSeparators(AxisOrientation.Y, this, index);
+                ax.View.SetTitleTop(curSize.Top + curSize.Height*.5 + ax.View.GetLabelSize().Width*.5);
+            }
+
+            for (var index = 0; index < AxisX.Count; index++)
+            {
+                var xi = AxisX[index];
+                var pr = ChartFunctions.FromPlotArea(xi.MaxPointRadius, AxisOrientation.X, this, index) -
+                         ChartFunctions.FromPlotArea(0, AxisOrientation.X, this, index);
+                if (!double.IsNaN(pr))
+                {
+                    xi.BotLimit -= pr;
+                    xi.TopLimit += pr;
+                }
+                xi.UpdateSeparators(AxisOrientation.X, this, index);
+                xi.View.SetTitleLeft(curSize.Left + curSize.Width*.5 - xi.View.GetLabelSize().Width*.5);
+            }
+        }
+
+        /// <summary>
+        /// Places the legend.
+        /// </summary>
+        /// <param name="drawMargin">The draw margin.</param>
+        /// <returns></returns>
+        /// <exception cref="System.ArgumentOutOfRangeException"></exception>
+        public CoreRectangle PlaceLegend(CoreRectangle drawMargin)
+        {
+            var legendSize = View.LoadLegend();
+
+            const int padding = 10;
+
+            switch (View.LegendLocation)
+            {
+                case LegendLocation.None:
+                    View.HideLegend();
+                    break;
+                case LegendLocation.Top:
+                    drawMargin.Top += legendSize.Height;
+                    drawMargin.Height -= legendSize.Height;
+                    View.ShowLegend(new CorePoint(ControlSize.Width * .5 - legendSize.Width * .5, 0));
+                    break;
+                case LegendLocation.Bottom:
+                    var bot = new CorePoint(ControlSize.Width*.5 - legendSize.Width*.5,
+                        ControlSize.Height - legendSize.Height);
+                    drawMargin.Height -= legendSize.Height;
+                    View.ShowLegend(new CorePoint(bot.X, ControlSize.Height - legendSize.Height));
+                    break;
+                case LegendLocation.Left:
+                    drawMargin.Left = drawMargin.Left + legendSize.Width;
+                    View.ShowLegend(new CorePoint(0, ControlSize.Height*.5 - legendSize.Height*.5));
+                    break;
+                case LegendLocation.Right:
+                    drawMargin.Width -= legendSize.Width + padding;
+                    View.ShowLegend(new CorePoint(ControlSize.Width - legendSize.Width,
+                        ControlSize.Height*.5 - legendSize.Height*.5));
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            return drawMargin;
+        }
+
+        /// <summary>
+        /// Zooms the in.
+        /// </summary>
+        /// <param name="pivot">The pivot.</param>
+        public void ZoomIn(CorePoint pivot)
+        {
+            if (AxisX == null || AxisY == null) return;
+
+            View.HideTooltip();
+
+            var speed = View.ZoomingSpeed < 0.1 ? 0.1 : (View.ZoomingSpeed > 0.95 ? 0.95 : View.ZoomingSpeed);
+
+            if (View.Zoom == ZoomingOptions.X || View.Zoom == ZoomingOptions.Xy)
+            {
+                for (var index = 0; index < AxisX.Count; index++)
+                {
+                    var xi = AxisX[index];
+
+                    var px = ChartFunctions.FromPlotArea(pivot.X, AxisOrientation.X, this, index);
+
+                    var max = double.IsNaN(xi.View.MaxValue) ? xi.TopLimit : xi.View.MaxValue;
+                    var min = double.IsNaN(xi.View.MinValue) ? xi.BotLimit : xi.View.MinValue;
+                    var l = max - min;
+
+                    var rMin = (px - min) / l;
+                    var rMax = 1 - rMin;
+
+                    var target = l * speed;
+                    if (target < xi.View.MinRange) return;
+                    var mint = px - target * rMin;
+                    var maxt = px + target * rMax;
+                    xi.View.SetRange(mint, maxt);
+                }
+            }
+
+            if (View.Zoom == ZoomingOptions.Y || View.Zoom == ZoomingOptions.Xy)
+            {
+                for (var index = 0; index < AxisY.Count; index++)
+                {
+                    var ax = AxisY[index];
+
+                    var py = ChartFunctions.FromPlotArea(pivot.Y, AxisOrientation.Y, this, index);
+
+                    var max = double.IsNaN(ax.View.MaxValue) ? ax.TopLimit : ax.View.MaxValue;
+                    var min = double.IsNaN(ax.View.MinValue) ? ax.BotLimit : ax.View.MinValue;
+                    var l = max - min;
+                    var rMin = (py - min) / l;
+                    var rMax = 1 - rMin;
+
+                    var target = l * speed;
+                    if (target < ax.View.MinRange) return;
+                    var mint = py - target * rMin;
+                    var maxt = py + target * rMax;
+                    ax.View.SetRange(mint, maxt);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Zooms the out.
+        /// </summary>
+        /// <param name="pivot">The pivot.</param>
+        public void ZoomOut(CorePoint pivot)
+        {
+            View.HideTooltip();
+
+            var speed = View.ZoomingSpeed < 0.1 ? 0.1 : (View.ZoomingSpeed > 0.95 ? 0.95 : View.ZoomingSpeed);
+
+            if (View.Zoom == ZoomingOptions.X || View.Zoom == ZoomingOptions.Xy)
+            {
+                for (var index = 0; index < AxisX.Count; index++)
+                {
+                    var xi = AxisX[index];
+
+                    var px = ChartFunctions.FromPlotArea(pivot.X, AxisOrientation.X, this, index);
+
+                    var max = double.IsNaN(xi.View.MaxValue) ? xi.TopLimit : xi.View.MaxValue;
+                    var min = double.IsNaN(xi.View.MinValue) ? xi.BotLimit : xi.View.MinValue;
+                    var l = max - min;
+                    var rMin = (px - min) / l;
+                    var rMax = 1 - rMin;
+
+                    var target = l * (1 / speed);
+                    if (target > xi.View.MaxRange) return;
+                    var mint = px- target * rMin;
+                    var maxt = px + target * rMax;
+                    xi.View.SetRange(mint, maxt);
+                }
+            }
+
+            if (View.Zoom == ZoomingOptions.Y || View.Zoom == ZoomingOptions.Xy)
+            {
+                for (var index = 0; index < AxisY.Count; index++)
+                {
+                    var ax = AxisY[index];
+
+                    var py = ChartFunctions.FromPlotArea(pivot.Y, AxisOrientation.Y, this, index);
+                    
+                    var max = double.IsNaN(ax.View.MaxValue) ? ax.TopLimit : ax.View.MaxValue;
+                    var min = double.IsNaN(ax.View.MinValue) ? ax.BotLimit : ax.View.MinValue;
+                    var l = max - min;
+                    var rMin = (py - min) / l;
+                    var rMax = 1 - rMin;
+
+                    var target = l * (1 / speed);
+                    if (target > ax.View.MaxRange) return;
+                    var mint = py - target * rMin;
+                    var maxt = py + target * rMax;
+                    ax.View.SetRange(mint, maxt);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Clears the zoom.
+        /// </summary>
+        public void ClearZoom()
+        {
+            foreach (var xi in AxisX) xi.View.SetRange(double.NaN, double.NaN);
+            foreach (var ax in AxisY) ax.View.SetRange(double.NaN, double.NaN);
+        }
+
+        /// <summary>
+        /// Drags the specified delta.
+        /// </summary>
+        /// <param name="delta">The delta.</param>
+        public void Drag(CorePoint delta)
+        {
+            if (View.Pan == PanningOptions.Unset && View.Zoom == ZoomingOptions.None ||
+                View.Pan == PanningOptions.None) return;
+
+            var px = View.Pan == PanningOptions.Unset &&
+                     (View.Zoom == ZoomingOptions.X || View.Zoom == ZoomingOptions.Xy);
+            px = px || View.Pan == PanningOptions.X || View.Pan == PanningOptions.Xy;
+
+            if (px)
+            {
+                for (var index = 0; index < AxisX.Count; index++)
+                {
+                    var xi = AxisX[index];
+                    var dx = ChartFunctions.FromPlotArea(delta.X, AxisOrientation.X, this, index) -
+                             ChartFunctions.FromPlotArea(0, AxisOrientation.X, this, index);
+
+                    xi.View.SetRange((double.IsNaN(xi.View.MinValue) ? xi.BotLimit : xi.View.MinValue) + dx,
+                        (double.IsNaN(xi.View.MaxValue) ? xi.TopLimit : xi.View.MaxValue) + dx);
+                }
+            }
+
+            var py = View.Pan == PanningOptions.Unset &&
+                     (View.Zoom == ZoomingOptions.Y || View.Zoom == ZoomingOptions.Xy);
+            py = py || View.Pan == PanningOptions.Y || View.Pan == PanningOptions.Xy;
+            if (py)
+            {
+                for (var index = 0; index < AxisY.Count; index++)
+                {
+                    var ax = AxisY[index];
+                    var dy = ChartFunctions.FromPlotArea(delta.Y, AxisOrientation.Y, this, index) -
+                             ChartFunctions.FromPlotArea(0, AxisOrientation.Y, this, index);
+
+                    ax.View.SetRange((double.IsNaN(ax.View.MinValue) ? ax.BotLimit : ax.View.MinValue) + dy,
+                        (double.IsNaN(ax.View.MaxValue) ? ax.TopLimit : ax.View.MaxValue) + dy);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Protected
+
+        /// <summary>
+        /// Stacks the points.
+        /// </summary>
+        /// <param name="stackables">The stackables.</param>
+        /// <param name="stackAt">The stack at.</param>
+        /// <param name="stackIndex">Index of the stack.</param>
+        /// <param name="mode">The mode.</param>
+        protected void StackPoints(IEnumerable<ISeriesView> stackables, AxisOrientation stackAt, int stackIndex,
+            StackMode mode = StackMode.Values)
+        {
+            var stackedColumns = stackables.SelectMany(x => x.ActualValues.GetPoints(x))
+                .GroupBy(x => stackAt == AxisOrientation.X ? x.Y : x.X);
+
+            double mostLeft = 0, mostRight = 0;
+
+            foreach (var column in stackedColumns)
+            {
+                double sumLeft = 0, sumRight = 0;
+
+                foreach (var item in column)
+                {
+                    var s = stackAt == AxisOrientation.X ? item.X : item.Y;
+                    if (s < 0)
+                        sumLeft += s;
+                    else
+                        sumRight += s;
+                }
+
+                var lastLeft = 0d;
+                var lastRight = 0d;
+                var leftPart = 0d;
+                var rightPart = 0d;
+
+                foreach (var point in column)
+                {
+                    var pulled = stackAt == AxisOrientation.X ? point.X : point.Y;
+
+                    //notice using (pulled < 0) or (pulled <= 0) could cause an issue similar to
+                    //https://github.com/beto-rodriguez/Live-Charts/issues/231
+                    //from that issue I changed <= to <
+                    //only because it is more common to use positive values than negative
+                    //you could face a similar issue if you are stacking only negative values
+                    //a work around is forcing (pulled < 0) to be true,
+                    //instead of using zero values, use -0.000000001/
+
+                    if (pulled < 0)
+                    {
+                        point.From = lastLeft;
+                        point.To = lastLeft + pulled;
+                        point.Sum = sumLeft;
+                        point.Participation = (point.To - point.From) / point.Sum;
+                        point.Participation = double.IsNaN(point.Participation)
+                            ? 0
+                            : point.Participation;
+                        leftPart += point.Participation;
+                        point.StackedParticipation = leftPart;
+
+                        lastLeft = point.To;
+                    }
+                    else
+                    {
+                        point.From = lastRight;
+                        point.To = lastRight + pulled;
+                        point.Sum = sumRight;
+                        point.Participation = (point.To - point.From) / point.Sum;
+                        point.Participation = double.IsNaN(point.Participation)
+                            ? 0
+                            : point.Participation;
+                        rightPart += point.Participation;
+                        point.StackedParticipation = rightPart;
+
+                        lastRight = point.To;
+                    }
+                }
+
+                if (sumLeft < mostLeft) mostLeft = sumLeft;
+                if (sumRight > mostRight) mostRight = sumRight;
+            }
+
+            if (stackAt == AxisOrientation.X)
+            {
+                var ax = AxisX[stackIndex];
+
+                if (mode == StackMode.Percentage)
+                {
+                    if (double.IsNaN(ax.MinValue)) ax.BotLimit = 0;
+                    if (double.IsNaN(ax.MaxValue)) ax.TopLimit = 1;
+                }
+                else
+                {
+                    if (mostLeft < ax.BotLimit)
+                        // ReSharper disable once CompareOfFloatsByEqualityOperator
+                        if (double.IsNaN(ax.MinValue))
+                            ax.BotLimit = mostLeft == 0
+                                ? 0
+                                : ((int) (mostLeft/ax.S) - 1)*ax.S;
+                    if (mostRight > ax.TopLimit)
+                        // ReSharper disable once CompareOfFloatsByEqualityOperator
+                        if (double.IsNaN(ax.MaxValue))
+                            ax.TopLimit = mostRight == 0
+                                ? 0
+                                : ((int) (mostRight/ax.S) + 1)*ax.S;
+                }
+            }
+
+            if (stackAt == AxisOrientation.Y)
+            {
+                var ay = AxisY[stackIndex];
+
+                if (mode == StackMode.Percentage)
+                {
+                    if (double.IsNaN(ay.MinValue)) ay.BotLimit = 0;
+                    if (double.IsNaN(ay.MaxValue)) ay.TopLimit = 1;
+                }
+                else
+                {
+                    if (mostLeft < ay.BotLimit)
+                        // ReSharper disable once CompareOfFloatsByEqualityOperator
+                        if (double.IsNaN(ay.MinValue))
+                            ay.BotLimit = mostLeft == 0
+                                ? 0
+                                : ((int) (mostLeft/ay.S) - 1)*ay.S;
+                    if (mostRight > ay.TopLimit)
+                        // ReSharper disable once CompareOfFloatsByEqualityOperator
+                        if (double.IsNaN(ay.MaxValue))
+                            ay.TopLimit = mostRight == 0
+                                ? 0
+                                : ((int) (mostRight/ay.S) + 1)*ay.S;
+                }
+            }
+        }
+        #endregion
+
+        #region Privates
+        private static void SetAxisLimits(AxisCore ax, IList<ISeriesView> series, AxisOrientation orientation)
+        {
+            var first = new CoreLimit();
+            var firstR = 0d;
+
+            if (series.Count > 0)
+            {
+                first = orientation == AxisOrientation.X
+                    ? series[0].Values.GetTracker(series[0]).XLimit
+                    : series[0].Values.GetTracker(series[0]).YLimit;
+                var view = series[0] as IAreaPoint;
+                firstR = view != null ? view.GetPointDiameter() : 0;
+            }
+            
+            //                     [ max, min, pointRadius ]
+            var boundries = new[] {first.Max, first.Min, firstR};
+
+            for (var index = 1; index < series.Count; index++)
+            {
+                var seriesView = series[index];
+                var tracker = seriesView.Values.GetTracker(seriesView);
+                var limit = orientation == AxisOrientation.X ? tracker.XLimit : tracker.YLimit;
+                var view = seriesView as IAreaPoint;
+                var radius = view != null ? view.GetPointDiameter() : 0;
+
+                if (limit.Max > boundries[0]) boundries[0] = limit.Max;
+                if (limit.Min < boundries[1]) boundries[1] = limit.Min;
+                if (radius > boundries[2]) boundries[2] = radius;
+            }
+
+            ax.TopSeriesLimit = boundries[0];
+            ax.BotSeriesLimit = boundries[1];
+
+            ax.TopLimit = double.IsNaN(ax.MaxValue) ? boundries[0] : ax.MaxValue;
+            ax.BotLimit = double.IsNaN(ax.MinValue) ? boundries[1] : ax.MinValue;
+
+            ax.MaxPointRadius = boundries[2];
+        }
+        #endregion
+    }
+}

Others/Live-Charts-master/Core/Charts/PieChartCore.cs

@@ -0,0 +1,112 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.Linq;
+using LiveCharts.Definitions.Charts;
+using LiveCharts.Definitions.Series;
+using LiveCharts.Dtos;
+using LiveCharts.Helpers;
+
+namespace LiveCharts.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Charts.ChartCore" />
+    public class PieChartCore : ChartCore
+    {
+        #region Constructors
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PieChartCore"/> class.
+        /// </summary>
+        /// <param name="view">The view.</param>
+        /// <param name="updater">The updater.</param>
+        public PieChartCore(IChartView view, ChartUpdater updater) : base(view, updater)
+        {
+            updater.Chart = this;
+        }
+
+        #endregion
+
+        #region Publics
+
+        /// <summary>
+        /// Prepares the axes.
+        /// </summary>
+        /// <exception cref="LiveChartsException">There is a invalid series in the series collection, " +
+        ///                     "verify that all the series implement IPieSeries.</exception>
+        public override void PrepareAxes()
+        {
+            View.Zoom = ZoomingOptions.None;
+
+            if (View.ActualSeries.Any(x => !(x.Model is IPieSeries)))
+                throw new LiveChartsException(
+                    "There is a invalid series in the series collection, " +
+                    "verify that all the series implement IPieSeries.");
+
+            foreach (var xi in AxisX)
+            {
+                xi.S = 1;
+                xi.BotLimit = View.ActualSeries.Select(x => x.Values.GetTracker(x).XLimit.Min)
+                    .DefaultIfEmpty(0).Min();
+                xi.TopLimit = View.ActualSeries.Select(x => x.Values.GetTracker(x).XLimit.Max)
+                    .DefaultIfEmpty(0).Max();
+
+                if (Math.Abs(xi.BotLimit - xi.TopLimit) < xi.S * .01)
+                {
+                    xi.BotLimit -= xi.S;
+                    xi.TopLimit += xi.S;
+                }
+            }
+
+            foreach (var yi in AxisY)
+            {
+                //yi.CalculateSeparator(this, AxisTags.X);
+                yi.BotLimit = View.ActualSeries.Select(x => x.Values.GetTracker(x).YLimit.Min)
+                    .DefaultIfEmpty(0).Min();
+                yi.TopLimit = View.ActualSeries.Select(x => x.Values.GetTracker(x).YLimit.Max)
+                    .DefaultIfEmpty(0).Max();
+
+                if (Math.Abs(yi.BotLimit - yi.TopLimit) < yi.S * .01)
+                {
+                    yi.BotLimit -= yi.S;
+                    yi.TopLimit += yi.S;
+                }
+            }
+
+            StackPoints(View.ActualSeries, AxisOrientation.Y, 0);
+
+            var curSize = new CoreRectangle(0, 0, ControlSize.Width, ControlSize.Height);
+
+            curSize = PlaceLegend(curSize);
+
+            DrawMargin.Top = curSize.Top;
+            DrawMargin.Left = curSize.Left;
+            DrawMargin.Width = curSize.Width;
+            DrawMargin.Height = curSize.Height;
+        }
+
+        #endregion
+
+    }
+}

Others/Live-Charts-master/Core/Configurations/CartesianMapper.cs

@@ -0,0 +1,136 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Configurations
+{
+    /// <summary>
+    /// Mapper to configure X and Y points
+    /// </summary>
+    /// <typeparam name="T">Type to configure</typeparam>
+    public class CartesianMapper<T> : IPointEvaluator<T>
+    {
+        private Func<T, int, double> _x = (v, i) => i;
+        private Func<T, int, double> _y = (v, i) => i;
+        private Func<T, int, object> _stroke;
+        private Func<T, int, object> _fill;
+
+        /// <summary>
+        /// Sets values for a specific point
+        /// </summary>
+        /// <param name="point">Point to set</param>
+        /// <param name="value"></param>
+        /// <param name="key"></param>
+        public void Evaluate(int key, T value, ChartPoint point)
+        {
+            point.X = _x(value, key);
+            point.Y = _y(value, key);
+            if (_stroke != null) point.Stroke = _stroke(value, key);
+            if (_fill != null) point.Fill = _fill(value, key);
+        }
+
+        /// <summary>
+        /// Sets the X mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls X coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public CartesianMapper<T> X(Func<T, double> predicate)
+        {
+            return X((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the X mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls X coordinate, with value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public CartesianMapper<T> X(Func<T, int, double> predicate)
+        {
+            _x = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Y mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public CartesianMapper<T> Y(Func<T, double> predicate)
+        {
+            return Y((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Y mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate, with value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public CartesianMapper<T> Y(Func<T, int, double> predicate)
+        {
+            _y = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public CartesianMapper<T> Stroke(Func<T, object> predicate)
+        {
+            return Stroke((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public CartesianMapper<T> Stroke(Func<T, int, object> predicate)
+        {
+            _stroke = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public CartesianMapper<T> Fill(Func<T, object> predicate)
+        {
+            return Fill((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public CartesianMapper<T> Fill(Func<T, int, object> predicate)
+        {
+            _fill = predicate;
+            return this;
+        }
+    }
+}

Others/Live-Charts-master/Core/Configurations/FinancialMapper.cs

@@ -0,0 +1,176 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Configurations
+{
+    /// <summary>
+    /// Mapper to configure financial points
+    /// </summary>
+    /// <typeparam name="T">type to configure</typeparam>
+    public class FinancialMapper<T> : IPointEvaluator<T>
+    {
+        private Func<T, int, double> _x = (v, i) => i;
+        private Func<T, int, double> _y = (v, i) => 0;
+        private Func<T, int, double> _open;
+        private Func<T, int, double> _high;
+        private Func<T, int, double> _low;
+        private Func<T, int, double> _close;
+
+        /// <summary>
+        /// Sets values for a specific point
+        /// </summary>
+        /// <param name="point">Point to set</param>
+        /// <param name="value"></param>
+        /// <param name="key"></param>
+        public void Evaluate(int key, T value, ChartPoint point)
+        {
+            point.X = _x(value, key);
+            point.Y = _y(value, key);
+            point.Open = _open(value, key);
+            point.High = _high(value, key);
+            point.Close = _close(value, key);
+            point.Low = _low(value, key);
+        }
+
+        /// <summary>
+        /// Maps X value
+        /// </summary>
+        /// <param name="predicate">function that pulls X coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> X(Func<T, double> predicate)
+        {
+            return X((t, i) => predicate(t));
+        }
+        /// <summary>
+        /// Maps X value
+        /// </summary>
+        /// <param name="predicate">function that pulls X coordinate, with value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> X(Func<T, int, double> predicate)
+        {
+            _x = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Maps Y value
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> Y(Func<T, double> predicate)
+        {
+            return Y((t, i) => predicate(t));
+        }
+        /// <summary>
+        /// Maps Y value
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate, with value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> Y(Func<T, int, double> predicate)
+        {
+            _y = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Maps Open value
+        /// </summary>
+        /// <param name="predicate">function that pulls open value</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> Open(Func<T, double> predicate)
+        {
+            return Open((t, i) => predicate(t));
+        }
+        /// <summary>
+        /// Maps Open value
+        /// </summary>
+        /// <param name="predicate">function that pulls open value, value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> Open(Func<T, int, double> predicate)
+        {
+            _open = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Maps High value
+        /// </summary>
+        /// <param name="predicate">function that pulls High value</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> High(Func<T, double> predicate)
+        {
+            return High((t, i) => predicate(t));
+        }
+        /// <summary>
+        /// Maps High value
+        /// </summary>
+        /// <param name="predicate">function that pulls High value</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> High(Func<T, int, double> predicate)
+        {
+            _high = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Maps Close value
+        /// </summary>
+        /// <param name="predicate">function that pulls close value</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> Close(Func<T, double> predicate)
+        {
+            return Close((t, i) => predicate(t));
+        }
+        /// <summary>
+        /// Maps Close value
+        /// </summary>
+        /// <param name="predicate">function that pulls close value, value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> Close(Func<T, int, double> predicate)
+        {
+            _close = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Maps Low value
+        /// </summary>
+        /// <param name="predicate">function that pulls low value</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> Low(Func<T, double> predicate)
+        {
+            return Low((t, i) => predicate(t));
+        }
+        /// <summary>
+        /// Maps Low value
+        /// </summary>
+        /// <param name="predicate">function that pulls low value, index and value as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public FinancialMapper<T> Low(Func<T, int, double> predicate)
+        {
+            _low = predicate;
+            return this;
+        }
+    }
+}

Others/Live-Charts-master/Core/Configurations/GanttMapper.cs

@@ -0,0 +1,184 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Configurations
+{
+    /// <summary>
+    /// Mapper to configure X and Y points
+    /// </summary>
+    /// <typeparam name="T">Type to configure</typeparam>
+    public class GanttMapper<T> : IPointEvaluator<T>
+    {
+        private Func<T, int, double> _x = (v, i) => i;
+        private Func<T, int, double> _y = (v, i) => i;
+        private Func<T, int, double> _startX = (v, i) => 0;
+        private Func<T, int, double> _startY = (v, i) => 0;
+        private Func<T, int, object> _stroke;
+        private Func<T, int, object> _fill;
+
+        /// <summary>
+        /// Sets values for a specific point
+        /// </summary>
+        /// <param name="point">Point to set</param>
+        /// <param name="value"></param>
+        /// <param name="key"></param>
+        public void Evaluate(int key, T value, ChartPoint point)
+        {
+            point.X = _x(value, key);
+            point.Y = _y(value, key);
+            point.XStart = _startX(value, key);
+            point.YStart = _startY(value, key);
+            if (_stroke != null) point.Stroke = _stroke(value, key);
+            if (_fill != null) point.Fill = _fill(value, key);
+
+            point.EvaluatesGantt = true;
+        }
+
+        /// <summary>
+        /// Sets the X mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls X coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public GanttMapper<T> X(Func<T, double> predicate)
+        {
+            return X((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the X mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls X coordinate, with value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public GanttMapper<T> X(Func<T, int, double> predicate)
+        {
+            _x = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the XStart mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls X coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public GanttMapper<T> XStart(Func<T, double> predicate)
+        {
+            return XStart((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the XStart mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls X coordinate, with value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public GanttMapper<T> XStart(Func<T, int, double> predicate)
+        {
+            _startX = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Y mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public GanttMapper<T> Y(Func<T, double> predicate)
+        {
+            return Y((t, i) => predicate(t));
+        }
+        
+        /// <summary>
+        /// Sets the Y mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate, with value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public GanttMapper<T> Y(Func<T, int, double> predicate)
+        {
+            _y = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the YStart mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public GanttMapper<T> YStart(Func<T, double> predicate)
+        {
+            return YStart((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the YStart mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate, with value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public GanttMapper<T> YStart(Func<T, int, double> predicate)
+        {
+            _startY = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public GanttMapper<T> Stroke(Func<T, object> predicate)
+        {
+            return Stroke((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public GanttMapper<T> Stroke(Func<T, int, object> predicate)
+        {
+            _stroke = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public GanttMapper<T> Fill(Func<T, object> predicate)
+        {
+            return Fill((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public GanttMapper<T> Fill(Func<T, int, object> predicate)
+        {
+            _fill = predicate;
+            return this;
+        }
+    }
+}

Others/Live-Charts-master/Core/Configurations/IPointEvaluator.cs

@@ -0,0 +1,39 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Configurations
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface IPointEvaluator<in T>
+    {
+        /// <summary>
+        /// Evaluates the specified key.
+        /// </summary>
+        /// <param name="key">The key.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="point">The point.</param>
+        void Evaluate(int key, T value, ChartPoint point);
+    }
+}

Others/Live-Charts-master/Core/Configurations/Mappers.cs

@@ -0,0 +1,90 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Configurations
+{
+    /// <summary>
+    /// Gets the already built point mappers
+    /// </summary>
+    public static class Mappers
+    {
+        /// <summary>
+        /// Gets a mapper to configure X, Y points
+        /// </summary>
+        /// <typeparam name="T">Type to map</typeparam>
+        /// <returns>A new cartesian mapper instance</returns>
+        public static CartesianMapper<T> Xy<T>()
+        {
+            return new CartesianMapper<T>();
+        }
+
+        /// <summary>
+        /// Gets a mapper to configure financial points
+        /// </summary>
+        /// <typeparam name="T">type to map</typeparam>
+        /// <returns>a new financial mapper instance</returns>
+        public static FinancialMapper<T> Financial<T>()
+        {
+            return new FinancialMapper<T>();
+        }
+
+        /// <summary>
+        /// Gets a mapper to configure X, Y and Weight points
+        /// </summary>
+        /// <typeparam name="T">type to map</typeparam>
+        /// <returns>a new weighted mapper instance</returns>
+        public static WeightedMapper<T> Weighted<T>()
+        {
+            return new WeightedMapper<T>();
+        }
+
+        /// <summary>
+        /// Gets a Gantt Mapper
+        /// </summary>
+        /// <typeparam name="T">type to amp</typeparam>
+        /// <returns>a new polar mapper insance</returns>
+        public static GanttMapper<T> Gantt<T>()
+        {
+            return new GanttMapper<T>();
+        }
+
+        /// <summary>
+        /// Gets a mapper to configure Radius and Angle
+        /// </summary>
+        /// <typeparam name="T">type to amp</typeparam>
+        /// <returns>a new polar mapper insance</returns>
+        public static PolarMapper<T> Polar<T>()
+        {
+            return new PolarMapper<T>();
+        }
+
+        /// <summary>
+        /// PGets a mapper to configure a pie chart
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public static PieMapper<T> Pie<T>()
+        {
+            return new PieMapper<T>();
+        }
+    }
+}

Others/Live-Charts-master/Core/Configurations/PieMapper.cs

@@ -0,0 +1,94 @@
+using System;
+
+namespace LiveCharts.Configurations
+{
+    /// <summary>
+    /// Mapper to configure X and Y points
+    /// </summary>
+    /// <typeparam name="T">Type to configure</typeparam>
+    public class PieMapper<T> : IPointEvaluator<T>
+    {
+        private readonly Func<T, int, double> _x = (v, i) => i;
+        private Func<T, int, double> _y = (v, i) => i;
+        private Func<T, int, object> _stroke;
+        private Func<T, int, object> _fill;
+
+        /// <summary>
+        /// Sets values for a specific point
+        /// </summary>
+        /// <param name="point">Point to set</param>
+        /// <param name="value"></param>
+        /// <param name="key"></param>
+        public void Evaluate(int key, T value, ChartPoint point)
+        {
+            point.X = _x(value, key);
+            point.Y = _y(value, key);
+            if (_stroke != null) point.Stroke = _stroke(value, key);
+            if (_fill != null) point.Fill = _fill(value, key);
+        }
+
+
+        /// <summary>
+        /// Sets the Y mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public PieMapper<T> Value(Func<T, double> predicate)
+        {
+            return Value((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Y mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls Y coordinate, with value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public PieMapper<T> Value(Func<T, int, double> predicate)
+        {
+            _y = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public PieMapper<T> Stroke(Func<T, object> predicate)
+        {
+            return Stroke((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public PieMapper<T> Stroke(Func<T, int, object> predicate)
+        {
+            _stroke = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public PieMapper<T> Fill(Func<T, object> predicate)
+        {
+            return Fill((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public PieMapper<T> Fill(Func<T, int, object> predicate)
+        {
+            _fill = predicate;
+            return this;
+        }
+    }
+}

Others/Live-Charts-master/Core/Configurations/PolarMapper.cs

@@ -0,0 +1,134 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Configurations
+{
+    /// <summary>
+    /// Mapper to configure polar series
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class PolarMapper<T> : IPointEvaluator<T>
+    {
+        private Func<T, int, double> _r;
+        private Func<T, int, double> _angle;
+        private Func<T, int, object> _stroke;
+        private Func<T, int, object> _fill;
+
+        /// <summary>
+        /// Sets values for a specific point
+        /// </summary>
+        /// <param name="point">Point to set</param>
+        /// <param name="value"></param>
+        /// <param name="key"></param>
+        public void Evaluate(int key, T value, ChartPoint point)
+        {
+            point.Radius = _r(value, key);
+            point.Angle = _angle(value, key);
+            if (_stroke != null) point.Stroke = _stroke(value, key);
+            if (_fill != null) point.Fill = _fill(value, key);
+        }
+
+        /// <summary>
+        /// Maps X value
+        /// </summary>
+        /// <param name="predicate">function that pulls the radius value</param>
+        /// <returns>current mapper instance</returns>
+        public PolarMapper<T> Radius(Func<T, double> predicate)
+        {
+            return Radius((t, i) => predicate(t));
+        }
+        /// <summary>
+        /// Maps X value
+        /// </summary>
+        /// <param name="predicate">function that pulls the radius value, value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public PolarMapper<T> Radius(Func<T, int, double> predicate)
+        {
+            _r = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Maps Y value
+        /// </summary>
+        /// <param name="predicate">function that pulls the angle value</param>
+        /// <returns>current mapper instance</returns>
+        public PolarMapper<T> Angle(Func<T, double> predicate)
+        {
+            return Angle((t, i) => predicate(t));
+        }
+        /// <summary>
+        /// Maps Y value
+        /// </summary>
+        /// <param name="predicate">function that pulls the angle value, value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public PolarMapper<T> Angle(Func<T, int, double> predicate)
+        {
+            _angle = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public PolarMapper<T> Stroke(Func<T, object> predicate)
+        {
+            return Stroke((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public PolarMapper<T> Stroke(Func<T, int, object> predicate)
+        {
+            _stroke = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public PolarMapper<T> Fill(Func<T, object> predicate)
+        {
+            return Fill((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public PolarMapper<T> Fill(Func<T, int, object> predicate)
+        {
+            _fill = predicate;
+            return this;
+        }
+    }
+}

Others/Live-Charts-master/Core/Configurations/WeightedMapper.cs

@@ -0,0 +1,159 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Configurations
+{
+    /// <summary>
+    /// Mapper to configure Bubble points
+    /// </summary>
+    /// <typeparam name="T">type to configure</typeparam>
+    public class WeightedMapper<T> : IPointEvaluator<T>
+    {
+        private Func<T, int, double> _x = (v, i) => i;
+        private Func<T, int, double> _y = (v, i) => i;
+        private Func<T, int, double> _weight = (v, i) => 0;
+        private Func<T, int, object> _stroke;
+        private Func<T, int, object> _fill;
+
+        /// <summary>
+        /// Sets values for a specific point
+        /// </summary>
+        /// <param name="point">Point to set</param>
+        /// <param name="value"></param>
+        /// <param name="key"></param>
+        public void Evaluate(int key, T value, ChartPoint point)
+        {
+            point.X = _x(value, key);
+            point.Y = _y(value, key);
+            point.Weight = _weight(value, key);
+            if (_stroke != null) point.Stroke = _stroke(value, key);
+            if (_fill != null) point.Fill = _fill(value, key);
+        }
+
+        /// <summary>
+        /// Sets the X mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls the X coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public WeightedMapper<T> X(Func<T, double> predicate)
+        {
+            return X((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the X mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls the X coordinate, value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public WeightedMapper<T> X(Func<T, int, double> predicate)
+        {
+            _x = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Y mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls the Y coordinate</param>
+        /// <returns>current mapper instance</returns>
+        public WeightedMapper<T> Y(Func<T, double> predicate)
+        {
+            return Y((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Y mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls the Y coordinate, value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public WeightedMapper<T> Y(Func<T, int, double> predicate)
+        {
+            _y = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets Weight mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls the point's weight</param>
+        /// <returns>current mapper instance</returns>
+        public WeightedMapper<T> Weight(Func<T, double> predicate)
+        {
+            return Weight((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets Weight mapper
+        /// </summary>
+        /// <param name="predicate">function that pulls the point's weight, value and index as parameters</param>
+        /// <returns>current mapper instance</returns>
+        public WeightedMapper<T> Weight(Func<T, int, double> predicate)
+        {
+            _weight = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public WeightedMapper<T> Stroke(Func<T, object> predicate)
+        {
+            return Stroke((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Stroke of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public WeightedMapper<T> Stroke(Func<T, int, object> predicate)
+        {
+            _stroke = predicate;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public WeightedMapper<T> Fill(Func<T, object> predicate)
+        {
+            return Fill((t, i) => predicate(t));
+        }
+
+        /// <summary>
+        /// Sets the Fill of the point
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns></returns>
+        public WeightedMapper<T> Fill(Func<T, int, object> predicate)
+        {
+            _fill = predicate;
+            return this;
+        }
+    }
+}

Others/Live-Charts-master/Core/Core.csproj

@@ -0,0 +1,180 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <MinimumVisualStudioVersion>10.0</MinimumVisualStudioVersion>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{D447642C-A85F-4AB0-96D9-C66CFF91AADA}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>LiveCharts</RootNamespace>
+    <AssemblyName>LiveCharts</AssemblyName>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <TargetFrameworkProfile>Profile78</TargetFrameworkProfile>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DefineConstants Condition=" '$(TargetFrameworkVersion)' == 'v4.0' ">NET40</DefineConstants>
+    <DefineConstants Condition=" '$(TargetFrameworkVersion)' == 'v4.5' ">NET45</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Debug\LiveCharts.XML</DocumentationFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DefineConstants Condition=" '$(TargetFrameworkVersion)' == 'v4.0' ">NET40</DefineConstants>
+    <DefineConstants Condition=" '$(TargetFrameworkVersion)' == 'v4.5' ">NET45</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Release\LiveCharts.XML</DocumentationFile>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>false</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>sign.pfx</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup>
+    <DelaySign>false</DelaySign>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="AxisCore.cs" />
+    <Compile Include="AxisOrientation.cs" />
+    <Compile Include="AxisPosition.cs" />
+    <Compile Include="AxisSectionCore.cs" />
+    <Compile Include="BarLabelPosition.cs" />
+    <Compile Include="ChartFunctions.cs" />
+    <Compile Include="Charting.cs" />
+    <Compile Include="ChartPoint.cs" />
+    <Compile Include="Charts\CartesianChartCore.cs" />
+    <Compile Include="Charts\ChartCore.cs" />
+    <Compile Include="Charts\PieChartCore.cs" />
+    <Compile Include="ChartUpdater.cs" />
+    <Compile Include="ChartValues.cs" />
+    <Compile Include="Configurations\CartesianMapper.cs" />
+    <Compile Include="Configurations\FinancialMapper.cs" />
+    <Compile Include="Configurations\GanttMapper.cs" />
+    <Compile Include="Configurations\IPointEvaluator.cs" />
+    <Compile Include="Configurations\Mappers.cs" />
+    <Compile Include="Configurations\PieMapper.cs" />
+    <Compile Include="Configurations\PolarMapper.cs" />
+    <Compile Include="Configurations\WeightedMapper.cs" />
+    <Compile Include="DataLabelViewModel.cs" />
+    <Compile Include="Defaults\AxisLimits.cs" />
+    <Compile Include="Defaults\DateTimePoint.cs" />
+    <Compile Include="Defaults\GanttPoint.cs" />
+    <Compile Include="Defaults\HeatPoint.cs" />
+    <Compile Include="Defaults\ObservablePoint.cs" />
+    <Compile Include="Defaults\ObservableValue.cs" />
+    <Compile Include="Defaults\OHLCPoint.cs" />
+    <Compile Include="Defaults\PolarPoint.cs" />
+    <Compile Include="Defaults\ScatterPoint.cs" />
+    <Compile Include="Definitions\Charts\IAxisSectionView.cs" />
+    <Compile Include="Definitions\Charts\IAxisView.cs" />
+    <Compile Include="Definitions\Charts\ICartesianChart.cs" />
+    <Compile Include="Definitions\Charts\ICartesianVisualElement.cs" />
+    <Compile Include="Definitions\Charts\IChartView.cs" />
+    <Compile Include="Definitions\Charts\ILogarithmicAxisView.cs" />
+    <Compile Include="Definitions\Charts\IPieChart.cs" />
+    <Compile Include="Definitions\Charts\ISeparatorElementView.cs" />
+    <Compile Include="Definitions\Charts\ISeparatorView.cs" />
+    <Compile Include="Definitions\Points\IBezierPointView.cs" />
+    <Compile Include="Definitions\Points\IChartPointView.cs" />
+    <Compile Include="Definitions\Points\IHeatPointView.cs" />
+    <Compile Include="Definitions\Points\IOhlcPointView.cs" />
+    <Compile Include="Definitions\Points\IPieSlicePointView.cs" />
+    <Compile Include="Definitions\Points\IRectanglePointView.cs" />
+    <Compile Include="Definitions\Points\IScatterPointView.cs" />
+    <Compile Include="Definitions\Points\IStepPointView.cs" />
+    <Compile Include="Definitions\Series\IAreaPoint.cs" />
+    <Compile Include="Definitions\Series\ICartesianSeries.cs" />
+    <Compile Include="Definitions\Series\IColumnSeriesView.cs" />
+    <Compile Include="Definitions\Series\IFinancialSeriesView.cs" />
+    <Compile Include="Definitions\Series\IHeatSeriesView.cs" />
+    <Compile Include="Definitions\Series\ILineSeriesView.cs" />
+    <Compile Include="Definitions\Series\IPieSeries.cs" />
+    <Compile Include="Definitions\Series\IPieSeriesView.cs" />
+    <Compile Include="Definitions\Series\IRowSeriesView.cs" />
+    <Compile Include="Definitions\Series\IScatterSeriesView.cs" />
+    <Compile Include="Definitions\Series\ISeriesView.cs" />
+    <Compile Include="Definitions\Series\IStackedAreaSeriesView.cs" />
+    <Compile Include="Definitions\Series\IStackedColumnSeriesView.cs" />
+    <Compile Include="Definitions\Series\IStackedRowSeriesView.cs" />
+    <Compile Include="Definitions\Series\IStackModelableSeriesView.cs" />
+    <Compile Include="Definitions\Series\IVerticalStackedAreaSeriesView.cs" />
+    <Compile Include="Dtos\BezierData.cs" />
+    <Compile Include="Dtos\CoreColor.cs" />
+    <Compile Include="Dtos\CoreGradientStop.cs" />
+    <Compile Include="Dtos\CoreLimit.cs" />
+    <Compile Include="Dtos\CoreMargin.cs" />
+    <Compile Include="Dtos\CorePoint.cs" />
+    <Compile Include="Dtos\CoreRectangle.cs" />
+    <Compile Include="Dtos\CoreSize.cs" />
+    <Compile Include="Dtos\LabelEvaluation.cs" />
+    <Compile Include="Dtos\StackedSum.cs" />
+    <Compile Include="Dtos\TooltipDataViewModel.cs" />
+    <Compile Include="Events\Delegates.cs" />
+    <Compile Include="Events\PreviewRangeChangedEventArgs.cs" />
+    <Compile Include="Events\RangeChangedEventArgs.cs" />
+    <Compile Include="Helpers\Extentions.cs" />
+    <Compile Include="Helpers\LiveChartsException.cs" />
+    <Compile Include="Helpers\NoisyCollection.cs" />
+    <Compile Include="IChartValues.cs" />
+    <Compile Include="IObservableChartPoint.cs" />
+    <Compile Include="LegendLocation.cs" />
+    <Compile Include="LogarithmicAxisCore.cs" />
+    <Compile Include="Maps\MapData.cs" />
+    <Compile Include="PanningOptions.cs" />
+    <Compile Include="PieLabelPosition.cs" />
+    <Compile Include="PointTracker.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ScrollMode.cs" />
+    <Compile Include="SeparationState.cs" />
+    <Compile Include="SeparatorConfigurationCore.cs" />
+    <Compile Include="SeparatorElementCore.cs" />
+    <Compile Include="Seriesalgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\CandleAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\ColumnAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\HeatAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\LineAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\OhlcAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\PieAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\RowAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\ScatterAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\StackedAreaAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\StackedColumnAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\StackedRowAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\StepLineAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\VerticalLineAlgorithm.cs" />
+    <Compile Include="SeriesAlgorithms\VerticalStackedAreaAlgorithm.cs" />
+    <Compile Include="SeriesCollection.cs" />
+    <Compile Include="SeriesOrientation.cs" />
+    <Compile Include="StackMode.cs" />
+    <Compile Include="TooltipSelectionMode.cs" />
+    <Compile Include="UpdaterState.cs" />
+    <Compile Include="VisualElementsCollection.cs" />
+    <Compile Include="ZoomingOptions.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="sign.pfx" />
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.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.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

Others/Live-Charts-master/Core/Core.csproj.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeInspection/CSharpLanguageProject/LanguageLevel/@EntryValue">CSharp50</s:String></wpf:ResourceDictionary>

Others/Live-Charts-master/Core/Core.nuspec

@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>LiveCharts</id>
+    <version>0.0.0.0</version>
+    <title>LiveCharts</title>
+    <authors>Beto Rodriguez</authors>
+    <owners>Beto Rodriguez</owners>
+    <licenseUrl>https://github.com/beto-rodriguez/Live-Charts/blob/master/LICENSE.TXT</licenseUrl>
+    <projectUrl>http://lvcharts.net/</projectUrl>
+    <iconUrl>http://lvcharts.net/Content/Images/Logos/lcred.png</iconUrl>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description>Simple, flexible, interactive and powerful data visualization for .Net</description>
+    <releaseNotes>See https://github.com/beto-rodriguez/Live-Charts/releases</releaseNotes>
+    <copyright>Copyright 2016</copyright>
+    <tags>livechart, live, chart, charting, plot, plots, plotting, graph, graphs, graphing, data</tags>     
+  </metadata>
+  <files>
+    <file src="readme.txt" target="" />
+    <file src="bin\Release\LiveCharts.dll" target="lib\portable-net45+win8+wp8" />
+    <file src="bin\Release\LiveCharts.pdb" target="lib\portable-net45+win8+wp8" />
+    <file src="bin\Release\LiveCharts.xml" target="lib\portable-net45+win8+wp8" />
+    <file src="..\Core40\bin\Net40\LiveCharts.dll" target="lib\net40" />
+    <file src="..\Core40\bin\Net40\LiveCharts.pdb" target="lib\net40" />
+    <file src="..\Core40\bin\Net40\LiveCharts.xml" target="lib\net40" />
+    <file src="..\Core40\bin\Net45\LiveCharts.dll" target="lib\net45" />
+    <file src="..\Core40\bin\Net45\LiveCharts.pdb" target="lib\net45" />
+    <file src="..\Core40\bin\Net45\LiveCharts.xml" target="lib\net45" />
+  </files>
+</package>

Others/Live-Charts-master/Core/DataLabelViewModel.cs

@@ -0,0 +1,46 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Describes a data label view model
+    /// </summary>
+    public class DataLabelViewModel
+    {
+        /// <summary>
+        /// Gets or sets the formatted text of the current point
+        /// </summary>
+        /// <value>
+        /// The formatted text.
+        /// </value>
+        public string FormattedText { get; set; }
+        /// <summary>
+        /// Gets the instance of the current point.
+        /// </summary>
+        /// <value>
+        /// The instance.
+        /// </value>
+        public object Instance { get; internal set; }
+
+    }
+}

Others/Live-Charts-master/Core/Defaults/AxisLimits.cs

@@ -0,0 +1,64 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Defaults
+{
+    internal static class AxisLimits
+    {
+        internal static double StretchMax(AxisCore axis)
+        {
+            return axis.TopLimit; //Math.Ceiling(axis.TopLimit/axis.Magnitude)*axis.Magnitude;
+        }
+
+        internal static double StretchMin(AxisCore axis)
+        {
+            return axis.BotLimit; //Math.Floor(axis.BotLimit/axis.Magnitude)*axis.Magnitude;
+        }
+
+        internal static double UnitRight(AxisCore axis)
+        {
+            return Math.Ceiling(axis.TopLimit/axis.Magnitude)*axis.Magnitude + 1;
+        }
+
+        internal static double UnitLeft(AxisCore axis)
+        {
+            return Math.Floor(axis.BotLimit/axis.Magnitude)*axis.Magnitude - 1;
+        }
+
+        internal static double SeparatorMax(AxisCore axis)
+        {
+            return ((int) (axis.TopLimit/axis.S) + 1)*axis.S;
+        }
+
+        internal static double SeparatorMaxRounded(AxisCore axis)
+        {
+            return Math.Round((axis.TopLimit/axis.S) + 1, 0)*axis.S;
+        }
+
+        internal static double SeparatorMin(AxisCore axis)
+        {
+            return (((int) (axis.BotLimit/axis.S)) - 1)*axis.S;
+        }
+    }
+}

Others/Live-Charts-master/Core/Defaults/DateTimePoint.cs

@@ -0,0 +1,93 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Defaults
+{
+    /// <summary>
+    /// An already configured chart point with a date time and a double properties, this class notifies the chart to update every time a property changes
+    /// </summary>
+    public class DateTimePoint : IObservableChartPoint
+    {
+        private DateTime _dateTime;
+        private double _value;
+
+        /// <summary>
+        /// Initializes a new instance of DateTimePoint class
+        /// </summary>
+        public DateTimePoint()
+        {
+            
+        }
+
+        /// <summary>
+        /// Initializes a new instance of DateTimePoint class, giving date time and value
+        /// </summary>
+        /// <param name="dateTime"></param>
+        /// <param name="value"></param>
+        public DateTimePoint(DateTime dateTime, double value)
+        {
+            _dateTime = dateTime;
+            _value = value;
+        }
+
+        /// <summary>
+        /// DateTime Property
+        /// </summary>
+        public DateTime DateTime
+        {
+            get { return _dateTime; }
+            set
+            {
+                _dateTime = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// The Value property
+        /// </summary>
+        public double Value
+        {
+            get { return _value; }
+            set
+            {
+                _value = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// Point changed event
+        /// </summary>
+        public event Action PointChanged;
+
+        /// <summary>
+        /// On Point property changed method
+        /// </summary>
+        protected virtual void OnPointChanged()
+        {
+            if (PointChanged != null) PointChanged.Invoke();
+        }
+    }
+}

Others/Live-Charts-master/Core/Defaults/GanttPoint.cs

@@ -0,0 +1,92 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Defaults
+{
+    /// <summary>
+    /// Defines a Gantt point in a cartesian chart
+    /// </summary>
+    public class GanttPoint : IObservableChartPoint
+    {
+        private double _startPoint;
+        private double _endPoint;
+
+        /// <summary>
+        /// Initializes a new instance of GanttPoint class.
+        /// </summary>
+        public GanttPoint()
+        {
+            
+        }
+
+        /// <summary>
+        /// Initializes a new instance of GanttPoint class with given start and end points.
+        /// </summary>
+        public GanttPoint(double startPoint, double endPoint)
+        {
+            StartPoint = startPoint;
+            EndPoint = endPoint;
+        }
+         
+        /// <summary>
+        /// Gets or sets point start
+        /// </summary>
+        public double StartPoint
+        {
+            get { return _startPoint; }
+            set
+            {
+                _startPoint = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets point end
+        /// </summary>
+        public double EndPoint
+        {
+            get { return _endPoint; }
+            set
+            {
+                _endPoint = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// PointChanged event
+        /// </summary>
+        public event Action PointChanged;
+
+        /// <summary>
+        /// OnPoint property changed method
+        /// </summary>
+        protected virtual void OnPointChanged()
+        {
+            if (PointChanged != null)
+                PointChanged.Invoke();
+        }
+    }
+}

Others/Live-Charts-master/Core/Defaults/HeatPoint.cs

@@ -0,0 +1,51 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Defaults
+{
+    /// <summary>
+    /// An already configured weighted chart point, this class notifies the chart to update every time a property changes
+    /// </summary>
+    public class HeatPoint : ScatterPoint
+    {
+        /// <summary>
+        /// Initializes a new instance of HeatPoint class
+        /// </summary>
+        public HeatPoint()
+        {
+
+        }
+        
+        /// <summary>
+        /// _initializes a new instance of HeatPoint class, giving x, y and weight
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="weight"></param>
+        public HeatPoint(double x, double y, double weight)
+        {
+            X = x;
+            Y = y;
+            Weight = weight;
+        }
+    }
+}

Others/Live-Charts-master/Core/Defaults/OHLCPoint.cs

@@ -0,0 +1,125 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Defaults
+{
+    /// <summary>
+    /// An already configured chart point, this class notifies the chart to update every time a property changes
+    /// </summary>
+    public class OhlcPoint : IObservableChartPoint
+    {
+        private double _open;
+        private double _high;
+        private double _low;
+        private double _close;
+
+        /// <summary>
+        /// Initializes a new instance of OhclPoint class
+        /// </summary>
+        public OhlcPoint()
+        {
+            
+        }
+
+        /// <summary>
+        /// Initializes a new instance o OhclPointc class, giving open, high, low and close values
+        /// </summary>
+        /// <param name="open"></param>
+        /// <param name="high"></param>
+        /// <param name="low"></param>
+        /// <param name="close"></param>
+        public OhlcPoint(double open, double high, double low, double close)
+        {
+            Open = open;
+            High = high;
+            Low = low;
+            Close = close;
+        }
+
+        /// <summary>
+        /// The open value i the chart
+        /// </summary>
+        public double Open
+        {
+            get { return _open; }
+            set
+            {
+                _open = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// The high value in the chart
+        /// </summary>
+        public double High
+        {
+            get { return _high; }
+            set
+            {
+                _high = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// The low value in the chart
+        /// </summary>
+        public double Low
+        {
+            get { return _low; }
+            set
+            {
+                _low = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// The close value in the chart
+        /// </summary>
+        public double Close
+        {
+            get { return _close; }
+            set
+            {
+                _close = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// The Point changed event
+        /// </summary>
+        public event Action PointChanged;
+
+        /// <summary>
+        /// On point property changed method
+        /// </summary>
+        protected virtual void OnPointChanged()
+        {
+            if (PointChanged != null) PointChanged.Invoke();
+        }
+    }
+}

Others/Live-Charts-master/Core/Defaults/ObservablePoint.cs

@@ -0,0 +1,93 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Defaults
+{
+    /// <summary>
+    /// An already configured chart point, this class notifies a chart to update every time a property changes
+    /// </summary>
+    public class ObservablePoint : IObservableChartPoint
+    {
+        private double _x;
+        private double _y;
+        /// <summary>
+        /// The point changed event
+        /// </summary>
+        public event Action PointChanged;
+
+        /// <summary>
+        /// Initializes a new instance of ObservablePoint class
+        /// </summary>
+        public ObservablePoint()
+        {
+            
+        }
+        
+        /// <summary>
+        /// Initializes a new instance of ObservablePoint class giving the x and y coordinates
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        public ObservablePoint(double x, double y)
+        {
+            X = x;
+            Y = y;
+        }
+
+        /// <summary>
+        /// X coordinate
+        /// </summary>
+        public double X
+        {
+            get { return _x; }
+            set
+            {
+                _x = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// Y coordinate
+        /// </summary>
+        public double Y
+        {
+            get { return _y; }
+            set
+            {
+                _y = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// OnPoint property changed method
+        /// </summary>
+        protected virtual void OnPointChanged()
+        {
+            if (PointChanged != null)
+                PointChanged.Invoke();
+        }
+    }
+}

Others/Live-Charts-master/Core/Defaults/ObservableValue.cs

@@ -0,0 +1,76 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+namespace LiveCharts.Defaults
+{
+    /// <summary>
+    /// An already configured chart point, this class notifies the chart to update every time the value property changes
+    /// </summary>
+    public class ObservableValue : IObservableChartPoint
+    {
+        private double _value;
+
+        /// <summary>
+        /// Initializes a new instance of ObservableValue class
+        /// </summary>
+        public ObservableValue()
+        {
+            
+        }
+
+        /// <summary>
+        /// Initializes a new instance of ObservableValue class with a given value
+        /// </summary>
+        /// <param name="value"></param>
+        public ObservableValue(double value)
+        {
+            Value = value;
+        }
+
+        /// <summary>
+        /// Point changed event
+        /// </summary>
+        public event Action PointChanged;
+
+        /// <summary>
+        /// Value in he chart
+        /// </summary>
+        public double Value
+        {
+            get { return _value; }
+            set
+            {
+                _value = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// On point property changed event
+        /// </summary>
+        protected virtual  void OnPointChanged()
+        {
+            if (PointChanged != null) PointChanged.Invoke();
+        }
+    }
+}

Others/Live-Charts-master/Core/Defaults/PolarPoint.cs

@@ -0,0 +1,93 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Defaults
+{
+    /// <summary>
+    /// An already configured chart point, this class notifies the chart to update every time a property changes
+    /// </summary>
+    public class PolarPoint : IObservableChartPoint
+    {
+        private double _radius;
+        private double _angle;
+
+        /// <summary>
+        /// The point changed event
+        /// </summary>
+        public event Action PointChanged;
+
+        /// <summary>
+        /// Initializes a new instance of PolarPoint class
+        /// </summary>
+        public PolarPoint()
+        {
+            
+        }
+
+        /// <summary>
+        /// Initializes a new instance of PolarPoint class, giving angle and radius
+        /// </summary>
+        /// <param name="radius"></param>
+        /// <param name="angle"></param>
+        public PolarPoint(double radius, double angle)
+        {
+            Radius = radius;
+            Angle = angle;
+        }
+
+        /// <summary>
+        /// The radius of the point
+        /// </summary>
+        public double Radius
+        {
+            get { return _radius; }
+            set
+            {
+                _radius = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// The angle of the point
+        /// </summary>
+        public double Angle
+        {
+            get { return _angle; }
+            set
+            {
+                _angle = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// On point property changed method
+        /// </summary>
+        protected virtual void OnPointChanged()
+        {
+            if (PointChanged != null)PointChanged.Invoke();
+        }
+    }
+}

Others/Live-Charts-master/Core/Defaults/ScatterPoint.cs

@@ -0,0 +1,120 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Defaults
+{
+    /// <summary>
+    /// An already configured weighted chart point, this class notifies the chart to update every time a property changes
+    /// </summary>
+    public class ScatterPoint : IObservableChartPoint
+    {
+        private double _x;
+        private double _y;
+        private double _weight;
+
+        /// <summary>
+        /// Creates a new instance of BubblePoint class
+        /// </summary>
+        public ScatterPoint()
+        {
+            
+        }
+
+        /// <summary>
+        /// Create a new instance of BubblePoint class, giving x and y coordinates
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        public ScatterPoint(double x, double y)
+        {
+            X = x;
+            Y = y;
+        }
+
+        /// <summary>
+        /// Creates a new instance of BubblePoint class, giving x, y and weight
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="weight"></param>
+        public ScatterPoint(double x, double y, double weight)
+        {
+            X = x;
+            Y = y;
+            Weight = weight;
+        }
+
+        /// <summary>
+        /// X coordinate in the chart
+        /// </summary>
+        public double X
+        {
+            get { return _x; }
+            set
+            {
+                _x = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// Y coordinate in the chart
+        /// </summary>
+        public double Y
+        {
+            get { return _y; }
+            set
+            {
+                _y = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// Point's weight
+        /// </summary>
+        public double Weight
+        {
+            get { return _weight; }
+            set
+            {
+                _weight = value;
+                OnPointChanged();
+            }
+        }
+
+        /// <summary>
+        /// Point changed event
+        /// </summary>
+        public event Action PointChanged;
+
+        /// <summary>
+        /// On point property changed method
+        /// </summary>
+        protected virtual void OnPointChanged()
+        {
+            if (PointChanged != null) PointChanged.Invoke();
+        }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Charts/IAxisSectionView.cs

@@ -0,0 +1,91 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface IAxisSectionView
+    {
+        /// <summary>
+        /// Gets or sets the model.
+        /// </summary>
+        /// <value>
+        /// The model.
+        /// </value>
+        AxisSectionCore Model { get; set; }
+        /// <summary>
+        /// Gets or sets the value.
+        /// </summary>
+        /// <value>
+        /// The value.
+        /// </value>
+        double Value { get; set; }
+        /// <summary>
+        /// Gets or sets the width of the section.
+        /// </summary>
+        /// <value>
+        /// The width of the section.
+        /// </value>
+        double SectionWidth { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether this <see cref="IAxisSectionView"/> is draggable.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if draggable; otherwise, <c>false</c>.
+        /// </value>
+        bool Draggable { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether the section is animated
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [disable animations]; otherwise, <c>false</c>.
+        /// </value>
+        bool DisableAnimations { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether the section should display a label that displays its current value.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [data label]; otherwise, <c>false</c>.
+        /// </value>
+        bool DataLabel { get; set; }
+
+        /// <summary>
+        /// Draws the or move.
+        /// </summary>
+        /// <param name="source">The source.</param>
+        /// <param name="axis">The axis.</param>
+        void DrawOrMove(AxisOrientation source, int axis);
+        /// <summary>
+        /// Removes this instance.
+        /// </summary>
+        void Remove();
+        /// <summary>
+        /// Ases the core element.
+        /// </summary>
+        /// <param name="axis">The axis.</param>
+        /// <param name="source">The source.</param>
+        /// <returns></returns>
+        AxisSectionCore AsCoreElement(AxisCore axis, AxisOrientation source);
+    }
+}

Others/Live-Charts-master/Core/Definitions/Charts/IAxisView.cs

@@ -0,0 +1,190 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using LiveCharts.Charts;
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Definitions.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface IAxisView
+    {
+        /// <summary>
+        /// Gets or sets the model.
+        /// </summary>
+        /// <value>
+        /// The model.
+        /// </value>
+        AxisCore Model { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [disable animations].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [disable animations]; otherwise, <c>false</c>.
+        /// </value>
+        bool DisableAnimations { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [show labels].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [show labels]; otherwise, <c>false</c>.
+        /// </value>
+        bool ShowLabels { get; set; }
+        /// <summary>
+        /// Gets or sets the maximum value.
+        /// </summary>
+        /// <value>
+        /// The maximum value.
+        /// </value>
+        double MaxValue { get; set; }
+        /// <summary>
+        /// Gets or sets the minimum value.
+        /// </summary>
+        /// <value>
+        /// The minimum value.
+        /// </value>
+        double MinValue { get; set; }
+        /// <summary>
+        /// Gets or sets the minimum range.
+        /// </summary>
+        /// <value>
+        /// The minimum range.
+        /// </value>
+        double MinRange { get; set; }
+        /// <summary>
+        /// Gets or sets the maximum range.
+        /// </summary>
+        /// <value>
+        /// The maximum range.
+        /// </value>
+        double MaxRange { get; set; }
+        /// <summary>
+        /// Gets or sets the labels rotation.
+        /// </summary>
+        /// <value>
+        /// The labels rotation.
+        /// </value>
+        double LabelsRotation { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is merged.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance is merged; otherwise, <c>false</c>.
+        /// </value>
+        bool IsMerged { get; set; }
+        /// <summary>
+        /// Gets or sets the bar unit.
+        /// </summary>
+        /// <value>
+        /// The bar unit.
+        /// </value>
+        double Unit { get; set; }
+        /// <summary>
+        /// Gets or sets the bar unit.
+        /// </summary>
+        /// <value>
+        /// The bar unit.
+        /// </value>
+        [Obsolete]
+        double BarUnit { get; set; }
+        /// <summary>
+        /// Gets the previous maximum value.
+        /// </summary>
+        /// <value>
+        /// The previous maximum value.
+        /// </value>
+        double PreviousMaxValue { get; }
+        /// <summary>
+        /// Gets the previous minimum value.
+        /// </summary>
+        /// <value>
+        /// The previous minimum value.
+        /// </value>
+        double PreviousMinValue { get; }
+        /// <summary>
+        /// Gets the axis orientation.
+        /// </summary>
+        /// <value>
+        /// The axis orientation.
+        /// </value>
+        AxisOrientation AxisOrientation { get; }
+
+        /// <summary>
+        /// Updates the title.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        /// <param name="rotationAngle">The rotation angle.</param>
+        /// <returns></returns>
+        CoreSize UpdateTitle(ChartCore chart, double rotationAngle = 0);
+        /// <summary>
+        /// Sets the title top.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        void SetTitleTop(double value);
+        /// <summary>
+        /// Sets the title left.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        void SetTitleLeft(double value);
+        /// <summary>
+        /// Gets the title left.
+        /// </summary>
+        /// <returns></returns>
+        double GetTitleLeft();
+        /// <summary>
+        /// Gets the tile top.
+        /// </summary>
+        /// <returns></returns>
+        double GetTileTop();
+        /// <summary>
+        /// Gets the size of the label.
+        /// </summary>
+        /// <returns></returns>
+        CoreSize GetLabelSize();
+        /// <summary>
+        /// Ases the core element.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        /// <param name="source">The source.</param>
+        /// <returns></returns>
+        AxisCore AsCoreElement(ChartCore chart, AxisOrientation source);
+        /// <summary>
+        /// Renders the separator.
+        /// </summary>
+        /// <param name="model">The model.</param>
+        /// <param name="chart">The chart.</param>
+        void RenderSeparator(SeparatorElementCore model, ChartCore chart);
+        /// <summary>
+        /// Cleans this instance.
+        /// </summary>
+        void Clean();
+        /// <summary>
+        /// Sets the range.
+        /// </summary>
+        /// <param name="min">The minimum.</param>
+        /// <param name="max">The maximum.</param>
+        void SetRange(double min, double max);
+    }
+}

Others/Live-Charts-master/Core/Definitions/Charts/ICartesianChart.cs

@@ -0,0 +1,39 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Charts.IChartView" />
+    public interface ICartesianChart : IChartView
+    {
+        /// <summary>
+        /// Gets or sets the visual elements.
+        /// </summary>
+        /// <value>
+        /// The visual elements.
+        /// </value>
+        VisualElementsCollection VisualElements { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Charts/ICartesianVisualElement.cs

@@ -0,0 +1,71 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using LiveCharts.Charts;
+
+namespace LiveCharts.Definitions.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface ICartesianVisualElement
+    {
+        /// <summary>
+        /// Gets or sets the x.
+        /// </summary>
+        /// <value>
+        /// The x.
+        /// </value>
+        double X { get; set; }
+        /// <summary>
+        /// Gets or sets the y.
+        /// </summary>
+        /// <value>
+        /// The y.
+        /// </value>
+        double Y { get; set; }
+        /// <summary>
+        /// Gets or sets the axis x.
+        /// </summary>
+        /// <value>
+        /// The axis x.
+        /// </value>
+        int AxisX { get; set; }
+        /// <summary>
+        /// Gets or sets the axis y.
+        /// </summary>
+        /// <value>
+        /// The axis y.
+        /// </value>
+        int AxisY { get; set; }
+        /// <summary>
+        /// Adds the or move.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        void AddOrMove(ChartCore chart);
+        /// <summary>
+        /// Removes the specified chart.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        void Remove(ChartCore chart);
+    }
+}

Others/Live-Charts-master/Core/Definitions/Charts/IChartView.cs

@@ -0,0 +1,253 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using LiveCharts.Charts;
+using LiveCharts.Definitions.Series;
+using LiveCharts.Dtos;
+using LiveCharts.Events;
+
+namespace LiveCharts.Definitions.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface IChartView
+    {
+        /// <summary>
+        /// Gets the model.
+        /// </summary>
+        /// <value>
+        /// The model.
+        /// </value>
+        ChartCore Model { get; }
+
+        /// <summary>
+        /// Occurs when [data click].
+        /// </summary>
+        event DataClickHandler DataClick;
+
+        /// <summary>
+        /// Occurs when [data hover]
+        /// </summary>
+        event DataHoverHandler DataHover;
+
+        /// <summary>
+        /// Gets or sets the series.
+        /// </summary>
+        /// <value>
+        /// The series.
+        /// </value>
+        SeriesCollection Series { get; set; }
+        /// <summary>
+        /// Gets the actual series.
+        /// </summary>
+        /// <value>
+        /// The actual series.
+        /// </value>
+        IEnumerable<ISeriesView> ActualSeries { get; }
+        /// <summary>
+        /// Gets or sets the tooltip timeout.
+        /// </summary>
+        /// <value>
+        /// The tooltip timeout.
+        /// </value>
+        TimeSpan TooltipTimeout { get; set; }
+        /// <summary>
+        /// Gets or sets the zoom.
+        /// </summary>
+        /// <value>
+        /// The zoom.
+        /// </value>
+        ZoomingOptions Zoom { get; set; }
+        /// <summary>
+        /// Gets or sets the zoom.
+        /// </summary>
+        /// <value>
+        /// The zoom.
+        /// </value>
+        PanningOptions Pan { get; set; }
+        /// <summary>
+        /// Gets or sets the zooming speed.
+        /// </summary>
+        /// <value>
+        /// The zooming speed.
+        /// </value>
+        double ZoomingSpeed { get; set; }
+        /// <summary>
+        /// Gets or sets the legend location.
+        /// </summary>
+        /// <value>
+        /// The legend location.
+        /// </value>
+        LegendLocation LegendLocation { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [disable animations].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [disable animations]; otherwise, <c>false</c>.
+        /// </value>
+        bool DisableAnimations { get; set; }
+        /// <summary>
+        /// Gets or sets the animations speed.
+        /// </summary>
+        /// <value>
+        /// The animations speed.
+        /// </value>
+        TimeSpan AnimationsSpeed { get; set; }
+        /// <summary>
+        /// Gets or sets the state of the updater.
+        /// </summary>
+        /// <value>
+        /// The state of the updater.
+        /// </value>
+        UpdaterState UpdaterState { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance has tooltip.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance has tooltip; otherwise, <c>false</c>.
+        /// </value>
+        bool HasTooltip { get; }
+        /// <summary>
+        /// Gets a value indicating whether this instance has data click event attached.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance has data click event attached; otherwise, <c>false</c>.
+        /// </value>
+        bool HasDataClickEventAttached { get; }
+        /// <summary>
+        /// Gets a value indicating whether this instance has data hover event attached.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance has data hover event attached; otherwise, <c>false</c>.
+        /// </value>
+        bool HasDataHoverEventAttached { get; }
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="IChartView"/> is hoverable.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if hoverable; otherwise, <c>false</c>.
+        /// </value>
+        bool Hoverable { get; }
+        /// <summary>
+        /// Gets a value indicating whether this instance is control loaded.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance is control loaded; otherwise, <c>false</c>.
+        /// </value>
+        bool IsControlLoaded { get; }
+        /// <summary>
+        /// Gets a value indicating whether this instance is in design mode.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance is in design mode; otherwise, <c>false</c>.
+        /// </value>
+        bool IsInDesignMode { get; }
+
+        /// <summary>
+        /// Sets the draw margin top.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        void SetDrawMarginTop(double value);
+        /// <summary>
+        /// Sets the draw margin left.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        void SetDrawMarginLeft(double value);
+        /// <summary>
+        /// Sets the height of the draw margin.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        void SetDrawMarginHeight(double value);
+        /// <summary>
+        /// Sets the width of the draw margin.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        void SetDrawMarginWidth(double value);
+
+        /// <summary>
+        /// Adds to view.
+        /// </summary>
+        /// <param name="element">The element.</param>
+        void AddToView(object element);
+        /// <summary>
+        /// Adds to draw margin.
+        /// </summary>
+        /// <param name="element">The element.</param>
+        void AddToDrawMargin(object element);
+        /// <summary>
+        /// Removes from view.
+        /// </summary>
+        /// <param name="element">The element.</param>
+        void RemoveFromView(object element);
+        /// <summary>
+        /// Removes from draw margin.
+        /// </summary>
+        /// <param name="element">The element.</param>
+        void RemoveFromDrawMargin(object element);
+        /// <summary>
+        /// Ensures the element belongs to current view.
+        /// </summary>
+        /// <param name="element">The element.</param>
+        void EnsureElementBelongsToCurrentView(object element);
+        /// <summary>
+        /// Ensures the element belongs to current draw margin.
+        /// </summary>
+        /// <param name="element">The element.</param>
+        void EnsureElementBelongsToCurrentDrawMargin(object element);
+        
+        /// <summary>
+        /// Hides the tooltip.
+        /// </summary>
+        void HideTooltip();
+        /// <summary>
+        /// Shows the legend.
+        /// </summary>
+        /// <param name="at">At.</param>
+        void ShowLegend(CorePoint at);
+        /// <summary>
+        /// Hides the legend.
+        /// </summary>
+        void HideLegend();
+
+        /// <summary>
+        /// Loads the legend.
+        /// </summary>
+        /// <returns></returns>
+        CoreSize LoadLegend();
+        /// <summary>
+        /// Maps the x axes.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        /// <returns></returns>
+        List<AxisCore> MapXAxes(ChartCore chart);
+        /// <summary>
+        /// Maps the y axes.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        /// <returns></returns>
+        List<AxisCore> MapYAxes(ChartCore chart);
+    }
+}

Others/Live-Charts-master/Core/Definitions/Charts/ILogarithmicAxisView.cs

@@ -0,0 +1,39 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Charts.IAxisView" />
+    public interface ILogarithmicAxisView : IAxisView
+    {
+        /// <summary>
+        /// Gets or sets the base.
+        /// </summary>
+        /// <value>
+        /// The base.
+        /// </value>
+        double Base { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Charts/IPieChart.cs

@@ -0,0 +1,53 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Charts.IChartView" />
+    public interface IPieChart : IChartView
+    {
+        /// <summary>
+        /// Gets or sets the inner radius.
+        /// </summary>
+        /// <value>
+        /// The inner radius.
+        /// </value>
+        double InnerRadius { get; set; }
+        /// <summary>
+        /// Gets or sets the starting rotation angle.
+        /// </summary>
+        /// <value>
+        /// The starting rotation angle.
+        /// </value>
+        double StartingRotationAngle { get; set; }
+        /// <summary>
+        /// Gets or sets the hover push out.
+        /// </summary>
+        /// <value>
+        /// The hover push out.
+        /// </value>
+        double HoverPushOut { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Charts/ISeparatorElementView.cs

@@ -0,0 +1,105 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using LiveCharts.Charts;
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Definitions.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface ISeparatorElementView
+    {
+        /// <summary>
+        /// Gets the model.
+        /// </summary>
+        /// <value>
+        /// The model.
+        /// </value>
+        SeparatorElementCore Model { get; }
+        /// <summary>
+        /// Gets the label model.
+        /// </summary>
+        /// <value>
+        /// The label model.
+        /// </value>
+        LabelEvaluation LabelModel { get; }
+
+        /// <summary>
+        /// Updates the label.
+        /// </summary>
+        /// <param name="text">The text.</param>
+        /// <param name="axis">The axis.</param>
+        /// <param name="source">The source.</param>
+        /// <returns></returns>
+        LabelEvaluation UpdateLabel(string text, AxisCore axis, AxisOrientation source);
+
+        /// <summary>
+        /// Clears the specified chart.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        void Clear(IChartView chart);
+
+        //No animated methods
+        /// <summary>
+        /// Places the specified chart.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        /// <param name="axis">The axis.</param>
+        /// <param name="direction">The direction.</param>
+        /// <param name="axisIndex">Index of the axis.</param>
+        /// <param name="toLabel">To label.</param>
+        /// <param name="toLine">To line.</param>
+        /// <param name="tab">The tab.</param>
+        void Place(ChartCore chart, AxisCore axis, AxisOrientation direction, int axisIndex, double toLabel, double toLine, double tab);
+        /// <summary>
+        /// Removes the specified chart.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        void Remove(ChartCore chart);
+
+        //Animated methods
+        /// <summary>
+        /// Moves the specified chart.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        /// <param name="axis">The axis.</param>
+        /// <param name="direction">The direction.</param>
+        /// <param name="axisIndex">Index of the axis.</param>
+        /// <param name="toLabel">To label.</param>
+        /// <param name="toLine">To line.</param>
+        /// <param name="tab">The tab.</param>
+        void Move(ChartCore chart, AxisCore axis, AxisOrientation direction, int axisIndex, double toLabel, double toLine, double tab);
+        /// <summary>
+        /// Fades the in.
+        /// </summary>
+        /// <param name="axis">The axis.</param>
+        /// <param name="chart">The chart.</param>
+        void FadeIn(AxisCore axis, ChartCore chart);
+        /// <summary>
+        /// Fades the out and remove.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        void FadeOutAndRemove(ChartCore chart);
+    }
+}

Others/Live-Charts-master/Core/Definitions/Charts/ISeparatorView.cs

@@ -0,0 +1,57 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Charts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface ISeparatorView
+    {
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is enabled.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance is enabled; otherwise, <c>false</c>.
+        /// </value>
+        bool IsEnabled { get; set; }
+        /// <summary>
+        /// Gets or sets separator step, this means the value between each line, use double.NaN for auto.
+        /// </summary>
+        double Step { get; set; }
+        /// <summary>
+        /// Gets the axis orientation.
+        /// </summary>
+        /// <value>
+        /// The axis orientation.
+        /// </value>
+        AxisOrientation AxisOrientation { get; }
+
+        /// <summary>
+        /// Ases the core element.
+        /// </summary>
+        /// <param name="axis">The axis.</param>
+        /// <param name="source">The source.</param>
+        /// <returns></returns>
+        SeparatorConfigurationCore AsCoreElement(AxisCore axis, AxisOrientation source);
+    }
+}

Others/Live-Charts-master/Core/Definitions/Points/IBezierPointView.cs

@@ -0,0 +1,41 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Definitions.Points
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Points.IChartPointView" />
+    public interface IBezierPointView : IChartPointView
+    {
+        /// <summary>
+        /// Gets or sets the data.
+        /// </summary>
+        /// <value>
+        /// The data.
+        /// </value>
+        BezierData Data { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Points/IChartPointView.cs

@@ -0,0 +1,73 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using LiveCharts.Charts;
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Definitions.Points
+{
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface IChartPointView
+    {
+        /// <summary>
+        /// Gets a value indicating whether this instance is new.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance is new; otherwise, <c>false</c>.
+        /// </value>
+        bool IsNew { get; }
+        /// <summary>
+        /// Gets the valid area.
+        /// </summary>
+        /// <value>
+        /// The valid area.
+        /// </value>
+        CoreRectangle ValidArea { get; }
+        /// <summary>
+        /// Draws the or move.
+        /// </summary>
+        /// <param name="previousDrawn">The previous drawn.</param>
+        /// <param name="current">The current.</param>
+        /// <param name="index">The index.</param>
+        /// <param name="chart">The chart.</param>
+        void DrawOrMove(ChartPoint previousDrawn, ChartPoint current, int index, ChartCore chart);
+        /// <summary>
+        /// Removes from view.
+        /// </summary>
+        /// <param name="chart">The chart.</param>
+        void RemoveFromView(ChartCore chart);
+        /// <summary>
+        /// Called when [hover].
+        /// </summary>
+        /// <param name="point">The point.</param>
+        void OnHover(ChartPoint point);
+        /// <summary>
+        /// Called when [hover leave].
+        /// </summary>
+        /// <param name="point">The point.</param>
+        void OnHoverLeave(ChartPoint point);
+    }
+
+}

Others/Live-Charts-master/Core/Definitions/Points/IHeatPointView.cs

@@ -0,0 +1,55 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Definitions.Points
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Points.IChartPointView" />
+    public interface IHeatPointView : IChartPointView
+    {
+        /// <summary>
+        /// Gets or sets the color components.
+        /// </summary>
+        /// <value>
+        /// The color components.
+        /// </value>
+        CoreColor ColorComponents { get; set; }
+        /// <summary>
+        /// Gets or sets the width.
+        /// </summary>
+        /// <value>
+        /// The width.
+        /// </value>
+        double Width { get; set; }
+        /// <summary>
+        /// Gets or sets the height.
+        /// </summary>
+        /// <value>
+        /// The height.
+        /// </value>
+        double Height { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Points/IOhlcPointView.cs

@@ -0,0 +1,81 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Points
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Points.IChartPointView" />
+    public interface IOhlcPointView : IChartPointView
+    {
+        /// <summary>
+        /// Gets or sets the open.
+        /// </summary>
+        /// <value>
+        /// The open.
+        /// </value>
+        double Open { get; set; }
+        /// <summary>
+        /// Gets or sets the high.
+        /// </summary>
+        /// <value>
+        /// The high.
+        /// </value>
+        double High { get; set; }
+        /// <summary>
+        /// Gets or sets the close.
+        /// </summary>
+        /// <value>
+        /// The close.
+        /// </value>
+        double Close { get; set; }
+        /// <summary>
+        /// Gets or sets the low.
+        /// </summary>
+        /// <value>
+        /// The low.
+        /// </value>
+        double Low { get; set; }
+        /// <summary>
+        /// Gets or sets the width.
+        /// </summary>
+        /// <value>
+        /// The width.
+        /// </value>
+        double Width { get; set; }
+        /// <summary>
+        /// Gets or sets the left.
+        /// </summary>
+        /// <value>
+        /// The left.
+        /// </value>
+        double Left { get; set; }
+        /// <summary>
+        /// Gets or sets the start reference.
+        /// </summary>
+        /// <value>
+        /// The start reference.
+        /// </value>
+        double StartReference { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Points/IPieSlicePointView.cs

@@ -0,0 +1,60 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Points
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Points.IChartPointView" />
+    public interface IPieSlicePointView : IChartPointView
+    {
+        /// <summary>
+        /// Gets or sets the rotation.
+        /// </summary>
+        /// <value>
+        /// The rotation.
+        /// </value>
+        double Rotation { get; set; }
+        /// <summary>
+        /// Gets or sets the wedge.
+        /// </summary>
+        /// <value>
+        /// The wedge.
+        /// </value>
+        double Wedge { get; set; }
+        /// <summary>
+        /// Gets or sets the inner radius.
+        /// </summary>
+        /// <value>
+        /// The inner radius.
+        /// </value>
+        double InnerRadius { get; set; }
+        /// <summary>
+        /// Gets or sets the radius.
+        /// </summary>
+        /// <value>
+        /// The radius.
+        /// </value>
+        double Radius { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Points/IRectanglePointView.cs

@@ -0,0 +1,48 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Definitions.Points
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Points.IChartPointView" />
+    public interface IRectanglePointView : IChartPointView
+    {
+        /// <summary>
+        /// Gets or sets the data.
+        /// </summary>
+        /// <value>
+        /// The data.
+        /// </value>
+        CoreRectangle Data { get; set; }
+        /// <summary>
+        /// Gets or sets the zero reference.
+        /// </summary>
+        /// <value>
+        /// The zero reference.
+        /// </value>
+        double ZeroReference { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Points/IScatterPointView.cs

@@ -0,0 +1,39 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Points
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Points.IChartPointView" />
+    public interface IScatterPointView : IChartPointView
+    {
+        /// <summary>
+        /// Gets or sets the diameter.
+        /// </summary>
+        /// <value>
+        /// The diameter.
+        /// </value>
+        double Diameter { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Points/IStepPointView.cs

@@ -0,0 +1,46 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Points
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Points.IChartPointView" />
+    public interface IStepPointView : IChartPointView
+    {
+        /// <summary>
+        /// Gets or sets the delta x.
+        /// </summary>
+        /// <value>
+        /// The delta x.
+        /// </value>
+        double DeltaX { get; set; }
+        /// <summary>
+        /// Gets or sets the delta y.
+        /// </summary>
+        /// <value>
+        /// The delta y.
+        /// </value>
+        double DeltaY { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IAreaPoint.cs

@@ -0,0 +1,36 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface IAreaPoint
+    {
+        /// <summary>
+        /// Gets the point diameter.
+        /// </summary>
+        /// <returns></returns>
+        double GetPointDiameter();
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/ICartesianSeries.cs

@@ -0,0 +1,63 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface ICartesianSeries
+    {
+        /// <summary>
+        /// Gets the view.
+        /// </summary>
+        /// <value>
+        /// The view.
+        /// </value>
+        ISeriesView View { get; }
+
+        /// <summary>
+        /// Gets the minimum x.
+        /// </summary>
+        /// <param name="axis">The axis.</param>
+        /// <returns></returns>
+        double GetMinX(AxisCore axis);
+        /// <summary>
+        /// Gets the maximum x.
+        /// </summary>
+        /// <param name="axis">The axis.</param>
+        /// <returns></returns>
+        double GetMaxX(AxisCore axis);
+        /// <summary>
+        /// Gets the minimum y.
+        /// </summary>
+        /// <param name="axis">The axis.</param>
+        /// <returns></returns>
+        double GetMinY(AxisCore axis);
+        /// <summary>
+        /// Gets the maximum y.
+        /// </summary>
+        /// <param name="axis">The axis.</param>
+        /// <returns></returns>
+        double GetMaxY(AxisCore axis);
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IColumnSeriesView.cs

@@ -0,0 +1,53 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ISeriesView" />
+    public interface IColumnSeriesView : ISeriesView
+    {
+        /// <summary>
+        /// Gets or sets the maximum width of the column.
+        /// </summary>
+        /// <value>
+        /// The maximum width of the column.
+        /// </value>
+        double MaxColumnWidth { get; set; }
+        /// <summary>
+        /// Gets or sets the column padding.
+        /// </summary>
+        /// <value>
+        /// The column padding.
+        /// </value>
+        double ColumnPadding { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [shares position].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [shares position]; otherwise, <c>false</c>.
+        /// </value>
+        bool SharesPosition { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IFinancialSeriesView.cs

@@ -0,0 +1,39 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ISeriesView" />
+    public interface IFinancialSeriesView : ISeriesView
+    {
+        /// <summary>
+        /// Gets or sets the maximum width of the column.
+        /// </summary>
+        /// <value>
+        /// The maximum width of the column.
+        /// </value>
+        double MaxColumnWidth { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IHeatSeriesView.cs

@@ -0,0 +1,49 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System.Collections.Generic;
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ISeriesView" />
+    public interface IHeatSeriesView : ISeriesView
+    {
+        /// <summary>
+        /// Gets the stops.
+        /// </summary>
+        /// <value>
+        /// The stops.
+        /// </value>
+        IList<CoreGradientStop> Stops { get; }
+        /// <summary>
+        /// Gets a value indicating whether [draws heat range].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [draws heat range]; otherwise, <c>false</c>.
+        /// </value>
+        bool DrawsHeatRange { get; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/ILineSeriesView.cs

@@ -0,0 +1,60 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ISeriesView" />
+    public interface ILineSeriesView : ISeriesView
+    {
+        /// <summary>
+        /// Gets or sets the line smoothness.
+        /// </summary>
+        /// <value>
+        /// The line smoothness.
+        /// </value>
+        double LineSmoothness { get; set; }
+        /// <summary>
+        /// Gets or sets the area limit.
+        /// </summary>
+        /// <value>
+        /// The area limit.
+        /// </value>
+        double AreaLimit { get; set; }
+        /// <summary>
+        /// Starts the segment.
+        /// </summary>
+        /// <param name="atIndex">At index.</param>
+        /// <param name="location">The location.</param>
+        void StartSegment(int atIndex, CorePoint location);
+        /// <summary>
+        /// Ends the segment.
+        /// </summary>
+        /// <param name="atIndex">At index.</param>
+        /// <param name="location">The location.</param>
+        void EndSegment(int atIndex, CorePoint location);
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IPieSeries.cs

@@ -0,0 +1,38 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface IPieSeries
+    {
+        /// <summary>
+        /// Gets the view.
+        /// </summary>
+        /// <value>
+        /// The view.
+        /// </value>
+        ISeriesView View { get; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IPieSeriesView.cs

@@ -0,0 +1,39 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ISeriesView" />
+    public interface IPieSeriesView : ISeriesView
+    {
+        /// <summary>
+        /// Gets or sets the push out.
+        /// </summary>
+        /// <value>
+        /// The push out.
+        /// </value>
+        double PushOut { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IRowSeriesView.cs

@@ -0,0 +1,53 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ISeriesView" />
+    public interface IRowSeriesView : ISeriesView
+    {
+        /// <summary>
+        /// Gets or sets the maximum row heigth.
+        /// </summary>
+        /// <value>
+        /// The maximum row heigth.
+        /// </value>
+        double MaxRowHeigth { get; set; }
+        /// <summary>
+        /// Gets or sets the row padding.
+        /// </summary>
+        /// <value>
+        /// The row padding.
+        /// </value>
+        double RowPadding { get; set; }
+        /// <summary>
+        /// Gets or sets a value indicating whether [shares position].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [shares position]; otherwise, <c>false</c>.
+        /// </value>
+        bool SharesPosition { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IScatterSeriesView.cs

@@ -0,0 +1,46 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ISeriesView" />
+    public interface IScatterSeriesView : ISeriesView
+    {
+        /// <summary>
+        /// Gets or sets the maximum point shape diameter.
+        /// </summary>
+        /// <value>
+        /// The maximum point shape diameter.
+        /// </value>
+        double MaxPointShapeDiameter { get; set; }
+        /// <summary>
+        /// Gets or sets the minimum point shape diameter.
+        /// </summary>
+        /// <value>
+        /// The minimum point shape diameter.
+        /// </value>
+        double MinPointShapeDiameter { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/ISeriesView.cs

@@ -0,0 +1,149 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using LiveCharts.Definitions.Points;
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface ISeriesView
+    {
+        /// <summary>
+        /// Gets or sets the model.
+        /// </summary>
+        /// <value>
+        /// The model.
+        /// </value>
+        SeriesAlgorithm Model { get; set; }
+        /// <summary>
+        /// Gets or sets the values.
+        /// </summary>
+        /// <value>
+        /// The values.
+        /// </value>
+        IChartValues Values { get; set; }
+        /// <summary>
+        /// Gets a value indicating whether [data labels].
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if [data labels]; otherwise, <c>false</c>.
+        /// </value>
+        bool DataLabels { get; }
+        /// <summary>
+        /// Gets or sets the scales x at.
+        /// </summary>
+        /// <value>
+        /// The scales x at.
+        /// </value>
+        int ScalesXAt { get; set; }
+        /// <summary>
+        /// Gets or sets the scales y at.
+        /// </summary>
+        /// <value>
+        /// The scales y at.
+        /// </value>
+        int ScalesYAt { get; set; }
+        /// <summary>
+        /// Gets or sets the configuration.
+        /// </summary>
+        /// <value>
+        /// The configuration.
+        /// </value>
+        object Configuration { get; set; }
+        /// <summary>
+        /// Gets a value indicating whether this instance is series visible.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance is series visible; otherwise, <c>false</c>.
+        /// </value>
+        bool IsSeriesVisible { get; }
+        /// <summary>
+        /// Gets or sets the label point.
+        /// </summary>
+        /// <value>
+        /// The label point.
+        /// </value>
+        Func<ChartPoint, string> LabelPoint { get; set; }
+        /// <summary>
+        /// Gets the actual values.
+        /// </summary>
+        /// <value>
+        /// The actual values.
+        /// </value>
+        IChartValues ActualValues { get; }
+        /// <summary>
+        /// Gets the title.
+        /// </summary>
+        /// <value>
+        /// The title.
+        /// </value>
+        string Title { get; }
+        /// <summary>
+        /// Gets a value indicating whether this instance is first draw.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this instance is first draw; otherwise, <c>false</c>.
+        /// </value>
+        bool IsFirstDraw { get; }
+
+        /// <summary>
+        /// Gets the point view.
+        /// </summary>
+        /// <param name="point">The point.</param>
+        /// <param name="label">The label.</param>
+        /// <returns></returns>
+        IChartPointView GetPointView(ChartPoint point, string label);
+        /// <summary>
+        /// Called when [series update start].
+        /// </summary>
+        void OnSeriesUpdateStart();
+        /// <summary>
+        /// Erases the specified remove from view.
+        /// </summary>
+        /// <param name="removeFromView">if set to <c>true</c> [remove from view].</param>
+        void Erase(bool removeFromView);
+        /// <summary>
+        /// Called when [series updated finish].
+        /// </summary>
+        void OnSeriesUpdatedFinish();
+        /// <summary>
+        /// Initializes the colors.
+        /// </summary>
+        void InitializeColors();
+        /// <summary>
+        /// Draws the specialized elements.
+        /// </summary>
+        void DrawSpecializedElements();
+        /// <summary>
+        /// Places the specialized elements.
+        /// </summary>
+        void PlaceSpecializedElements();
+        /// <summary>
+        /// Gets the label point formatter.
+        /// </summary>
+        /// <returns></returns>
+        Func<ChartPoint, string> GetLabelPointFormatter();
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IStackModelableSeriesView.cs

@@ -0,0 +1,38 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface IStackModelableSeriesView
+    {
+        /// <summary>
+        /// Gets or sets the stack mode.
+        /// </summary>
+        /// <value>
+        /// The stack mode.
+        /// </value>
+        StackMode StackMode { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IStackedAreaSeriesView.cs

@@ -0,0 +1,34 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ILineSeriesView" />
+    /// <seealso cref="LiveCharts.Definitions.Series.IStackModelableSeriesView" />
+    public interface IStackedAreaSeriesView : ILineSeriesView, IStackModelableSeriesView
+    {
+
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IStackedColumnSeriesView.cs

@@ -0,0 +1,47 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ISeriesView" />
+    /// <seealso cref="LiveCharts.Definitions.Series.IStackModelableSeriesView" />
+    public interface IStackedColumnSeriesView : ISeriesView, IStackModelableSeriesView
+    {
+        /// <summary>
+        /// Gets or sets the maximum width of the column.
+        /// </summary>
+        /// <value>
+        /// The maximum width of the column.
+        /// </value>
+        double MaxColumnWidth { get; set; }
+        /// <summary>
+        /// Gets or sets the column padding.
+        /// </summary>
+        /// <value>
+        /// The column padding.
+        /// </value>
+        double ColumnPadding { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IStackedRowSeriesView.cs

@@ -0,0 +1,47 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ISeriesView" />
+    /// <seealso cref="LiveCharts.Definitions.Series.IStackModelableSeriesView" />
+    public interface IStackedRowSeriesView : ISeriesView, IStackModelableSeriesView
+    {
+        /// <summary>
+        /// Gets or sets the maximum height of the row.
+        /// </summary>
+        /// <value>
+        /// The maximum height of the row.
+        /// </value>
+        double MaxRowHeight { get; set; }
+        /// <summary>
+        /// Gets or sets the row padding.
+        /// </summary>
+        /// <value>
+        /// The row padding.
+        /// </value>
+        double RowPadding { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Definitions/Series/IVerticalStackedAreaSeriesView.cs

@@ -0,0 +1,34 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Definitions.Series
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Definitions.Series.ILineSeriesView" />
+    /// <seealso cref="LiveCharts.Definitions.Series.IStackModelableSeriesView" />
+    public interface IVerticalStackedAreaSeriesView : ILineSeriesView, IStackModelableSeriesView
+    {
+
+    }
+}

Others/Live-Charts-master/Core/Dtos/BezierData.cs

@@ -0,0 +1,79 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Dtos
+{
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class BezierData
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BezierData"/> class.
+        /// </summary>
+        public BezierData()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BezierData"/> class.
+        /// </summary>
+        /// <param name="point">The point.</param>
+        public BezierData(CorePoint point)
+        {
+            Point1 = point;
+            Point2 = point;
+            Point3 = point;
+        }
+
+        /// <summary>
+        /// Gets or sets the point1.
+        /// </summary>
+        /// <value>
+        /// The point1.
+        /// </value>
+        public CorePoint Point1 { get; set; }
+
+        /// <summary>
+        /// Gets or sets the point2.
+        /// </summary>
+        /// <value>
+        /// The point2.
+        /// </value>
+        public CorePoint Point2 { get; set; }
+        /// <summary>
+        /// Gets or sets the point3.
+        /// </summary>
+        /// <value>
+        /// The point3.
+        /// </value>
+        public CorePoint Point3 { get; set; }
+        /// <summary>
+        /// Gets or sets the start point.
+        /// </summary>
+        /// <value>
+        /// The start point.
+        /// </value>
+        public CorePoint StartPoint { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Dtos/CoreColor.cs

@@ -0,0 +1,63 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+namespace LiveCharts.Dtos
+{
+    /// <summary>
+    /// Defines a portable color
+    /// </summary>
+    public struct CoreColor
+    {
+        /// <summary>
+        /// Initializes a new instance of CoreColor
+        /// </summary>
+        /// <param name="a">alpha component</param>
+        /// <param name="r">red component</param>
+        /// <param name="g">green component</param>
+        /// <param name="b">blue component</param>
+        public CoreColor(byte a, byte r, byte g, byte b) : this()
+        {
+            A = a;
+            R = r;
+            G = g;
+            B = b;
+        }
+
+        /// <summary>
+        /// Alpha component
+        /// </summary>
+        public byte A { get; set; }
+        /// <summary>
+        /// Red component
+        /// </summary>
+        public byte R { get; set; }
+        /// <summary>
+        /// Green component
+        /// </summary>
+        public byte G { get; set; }
+        /// <summary>
+        /// Red component
+        /// </summary>
+        public byte B { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Dtos/CoreGradientStop.cs

@@ -0,0 +1,40 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+namespace LiveCharts.Dtos
+{
+    /// <summary>
+    /// Portable color gradient stop
+    /// </summary>
+    public struct CoreGradientStop
+    {
+        /// <summary>
+        /// Offset, goes from 0 to 1
+        /// </summary>
+        public double Offset { get; set; }
+        /// <summary>
+        /// Color at Offset
+        /// </summary>
+        public CoreColor Color { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Dtos/CoreLimit.cs

@@ -0,0 +1,54 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Dtos
+{
+    /// <summary>
+    /// Defines a portable limit
+    /// </summary>
+    public struct CoreLimit
+    {
+        /// <summary>
+        /// Initializes a new instance of CoreLimit
+        /// </summary>
+        /// <param name="min">minimum value</param>
+        /// <param name="max">maximum value</param>
+        public CoreLimit(double min, double max) : this()
+        {
+            Max = max;
+            Min = min;
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum value
+        /// </summary>
+        public double Max { get; set; }
+        /// <summary>
+        /// Gets or sets the minimum value
+        /// </summary>
+        public double Min { get; set; }
+        /// <summary>
+        /// Gets the range between max and min values
+        /// </summary>
+        public double Range { get { return Max - Min; } }
+    }
+}

Others/Live-Charts-master/Core/Dtos/CoreMargin.cs

@@ -0,0 +1,56 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+
+namespace LiveCharts.Dtos
+{
+    /// <summary>
+    /// Defines a portable margin
+    /// </summary>
+    public class CoreMargin
+    {
+        /// <summary>
+        /// Distance to top
+        /// </summary>
+        public double Top { get; set; }
+        /// <summary>
+        /// Distance to bottom
+        /// </summary>
+        public double Bottom { get; set; }
+        /// <summary>
+        /// Distance to left
+        /// </summary>
+        public double Left { get; set; }
+        /// <summary>
+        /// Distance to right
+        /// </summary>
+        public double Right { get; set; }
+        /// <summary>
+        /// Size width
+        /// </summary>
+        public double Width { get; set; }
+        /// <summary>
+        /// Size height
+        /// </summary>
+        public double Height { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Dtos/CorePoint.cs

@@ -0,0 +1,82 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Dtos
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public struct CorePoint
+    {
+        /// <summary>
+        /// Initializes a new instance of CorePoint
+        /// </summary>
+        /// <param name="x">x coordinate</param>
+        /// <param name="y">y coordinate</param>
+        public CorePoint(double x, double y) : this()
+        {
+            X = x;
+            Y = y;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of CorePoint
+        /// </summary>
+        /// <param name="point">source pont</param>
+        public CorePoint(CorePoint point) : this()
+        {
+            X = point.X;
+            Y = point.Y;
+        }
+
+        /// <summary>
+        /// X coordinate
+        /// </summary>
+        public double X { get; set; }
+        /// <summary>
+        /// Y coordinate
+        /// </summary>
+        public double Y { get; set; }
+
+        /// <summary>
+        /// Sums every property between 2 given points
+        /// </summary>
+        /// <param name="p1">point 1</param>
+        /// <param name="p2">point 2</param>
+        /// <returns></returns>
+        public static CorePoint operator +(CorePoint p1, CorePoint p2)
+        {
+            return new CorePoint(p1.X + p2.X, p1.Y + p2.Y);
+        }
+
+        /// <summary>
+        /// Subtracts every property between 2 given points
+        /// </summary>
+        /// <param name="p1">point 1</param>
+        /// <param name="p2">point 2</param>
+        /// <returns></returns>
+        public static CorePoint operator -(CorePoint p1, CorePoint p2)
+        {
+            return new CorePoint(p1.X - p2.X, p1.Y - p2.Y);
+        }
+    }
+}

Others/Live-Charts-master/Core/Dtos/CoreRectangle.cs

@@ -0,0 +1,142 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Dtos
+{
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CoreRectangle
+    {
+        private double _left;
+        private double _top;
+        private double _width;
+        private double _height;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CoreRectangle"/> class.
+        /// </summary>
+        public CoreRectangle()
+        {
+
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CoreRectangle"/> class.
+        /// </summary>
+        /// <param name="left">The left.</param>
+        /// <param name="top">The top.</param>
+        /// <param name="width">The width.</param>
+        /// <param name="height">The height.</param>
+        public CoreRectangle(double left, double top, double width, double height) : this()
+        {
+            Left = left;
+            Top = top;
+            Width = width;
+            Height = height;
+        }
+
+        /// <summary>
+        /// Occurs when [set top].
+        /// </summary>
+        public event Action<double> SetTop;
+        /// <summary>
+        /// Occurs when [set left].
+        /// </summary>
+        public event Action<double> SetLeft;
+        /// <summary>
+        /// Occurs when [set width].
+        /// </summary>
+        public event Action<double> SetWidth;
+        /// <summary>
+        /// Occurs when [set height].
+        /// </summary>
+        public event Action<double> SetHeight;
+
+        /// <summary>
+        /// Gets or sets the left.
+        /// </summary>
+        /// <value>
+        /// The left.
+        /// </value>
+        public double Left
+        {
+            get { return _left; }
+            set
+            {
+                _left = value;
+                if (SetLeft != null) SetLeft.Invoke(value);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the top.
+        /// </summary>
+        /// <value>
+        /// The top.
+        /// </value>
+        public double Top
+        {
+            get { return _top; }
+            set
+            {
+                _top = value;
+                if (SetTop != null) SetTop.Invoke(value);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the width.
+        /// </summary>
+        /// <value>
+        /// The width.
+        /// </value>
+        public double Width
+        {
+            get { return _width; }
+            set
+            {
+                _width = value < 0 ? 0 : value;
+                if (SetWidth != null) SetWidth.Invoke(value);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the height.
+        /// </summary>
+        /// <value>
+        /// The height.
+        /// </value>
+        public double Height
+        {
+            get { return _height; }
+            set
+            {
+                _height = value < 0 ? 0 : value;
+                if (SetHeight != null) SetHeight.Invoke(value);
+            }
+        }
+    }
+}

Others/Live-Charts-master/Core/Dtos/CoreSize.cs

@@ -0,0 +1,56 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Dtos
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public struct CoreSize
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CoreSize"/> struct.
+        /// </summary>
+        /// <param name="width">The width.</param>
+        /// <param name="heigth">The heigth.</param>
+        public CoreSize(double width, double heigth) : this()
+        {
+            Width = width;
+            Height = heigth;
+        }
+
+        /// <summary>
+        /// Gets or sets the width.
+        /// </summary>
+        /// <value>
+        /// The width.
+        /// </value>
+        public double Width { get; set; }
+        /// <summary>
+        /// Gets or sets the height.
+        /// </summary>
+        /// <value>
+        /// The height.
+        /// </value>
+        public double Height { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Dtos/LabelEvaluation.cs

@@ -0,0 +1,331 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Dtos
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public struct LabelEvaluation
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LabelEvaluation"/> struct.
+        /// </summary>
+        /// <param name="angle">The angle.</param>
+        /// <param name="w">The w.</param>
+        /// <param name="h">The h.</param>
+        /// <param name="axis">The axis.</param>
+        /// <param name="source">The source.</param>
+        public LabelEvaluation(double angle, double w, double h, AxisCore axis, AxisOrientation source) : this()
+        {
+            const double padding = 4;
+
+            ActualWidth = w;
+            ActualHeight = h;
+
+            // for now there is no support for rotated and merged labels.
+            // the labels will be rotated but there is no warranty that they are displayed correctly
+            if (axis.View.IsMerged)
+            {
+                Top = 0;
+                Bottom = 0;
+                Left = 0;
+                Right = 0;
+
+                if (source == AxisOrientation.Y)
+                {
+                    XOffset = padding;
+                    YOffset = padding;
+                }
+                else
+                {
+                    if (axis.Position == AxisPosition.LeftBottom)
+                    {
+                        //Bot
+                        XOffset = padding;
+                        YOffset = -h * 2 - padding;
+                    }
+                    else
+                    {
+                        //Top
+                        XOffset = padding;
+                        YOffset = padding + h * 2;
+                    }
+                }
+
+                return;
+            }
+
+            //OK now lets evaluate the rotation angle...
+
+            // the rotation angle starts from an horizontal line, yes like this text
+            // - 0°, | 90°, - 180°, | 270°
+            // notice normally rotating a label from 90 to 270° will show the label
+            // in a wrong orientation
+            // we need to fix that angle
+
+            const double toRadians = Math.PI / 180;
+
+            // 1. width components
+            // 2. height components
+
+            WFromW = Math.Abs(Math.Cos(angle * toRadians) * w); // W generated from the width of the label
+            WFromH = Math.Abs(Math.Sin(angle * toRadians) * h); // W generated from the height of the label
+
+            HFromW = Math.Abs(Math.Sin(angle * toRadians) * w); // H generated from the width of the label
+            HFromH = Math.Abs(Math.Cos(angle * toRadians) * h); // H generated from the height of the label
+
+            LabelAngle = angle % 360;
+            if (LabelAngle < 0) LabelAngle += 360;
+            if (LabelAngle > 90 && LabelAngle < 270)
+                LabelAngle = (LabelAngle + 180) % 360;
+
+            //at this points angles should only exist in 1st and 4th quadrant
+            //those are the only quadrants that generates readable labels
+            //the other 2 quadrants display inverted labels
+
+            var quadrant = ((int)(LabelAngle / 90)) % 4 + 1;
+
+            if (source == AxisOrientation.Y)
+            {
+                // Y Axis
+                if (quadrant == 1)
+                {
+                    if (axis.Position == AxisPosition.LeftBottom)
+                    {
+                        // 1, L
+                        Top = HFromW + (HFromH / 2);      //space taken from separator to top
+                        Bottom = TakenHeight - Top;          //space taken from separator to bottom
+                        XOffset = -WFromW - padding;    //distance from separator to label origin in X
+                        YOffset = -Top;                 //distance from separator to label origin in Y
+                    }
+                    else
+                    {
+                        // 1, R
+                        Bottom = HFromW + (HFromH / 2);
+                        Top = TakenHeight - Bottom;
+                        XOffset = padding + WFromH;
+                        YOffset = -Top;
+                    }
+                }
+                else
+                {
+                    if (axis.Position == AxisPosition.LeftBottom)
+                    {
+                        // 4, L
+                        Bottom = HFromW + (HFromH / 2);
+                        Top = TakenHeight - Bottom;
+                        XOffset = -TakenWidth - padding;
+                        YOffset = HFromW - (HFromH / 2);
+                    }
+                    else
+                    {
+                        // 4, R
+                        Top = HFromW + (HFromH / 2);
+                        Bottom = TakenHeight - Top;
+                        XOffset = padding;
+                        YOffset = -Bottom;
+                    }
+                }
+            }
+            else
+            {
+                // X Axis
+
+                //axis x has one exception, if labels rotation equals 0° then the label is centered
+                if (Math.Abs(axis.View.LabelsRotation) < .01)
+                {
+                    Left = TakenWidth / 2;
+                    Right = Left;
+                    XOffset = -Left;
+                    YOffset = axis.Position == AxisPosition.LeftBottom
+                        ? padding
+                        : -padding - TakenHeight;
+                }
+                else
+                {
+                    if (quadrant == 1)
+                    {
+                        if (axis.Position == AxisPosition.LeftBottom)
+                        {
+                            //1, B
+                            Right = WFromW + (WFromH / 2);  //space taken from separator to right
+                            Left = TakenWidth - Right;           //space taken from separator to left
+                            XOffset = Left;                 //distance from separator to label origin in X
+                            YOffset = padding;              //distance from separator to label origin in Y
+                        }
+                        else
+                        {
+                            //1, T
+                            Left = WFromW + (WFromH / 2);
+                            Right = TakenWidth - Left;
+                            XOffset = -WFromW;
+                            YOffset = -padding - TakenHeight;
+                        }
+                    }
+                    else
+                    {
+                        if (axis.Position == AxisPosition.LeftBottom)
+                        {
+                            //4, B
+                            Left = WFromW + (WFromH / 2);
+                            Right = TakenWidth - Left;
+                            XOffset = -Left;
+                            YOffset = padding + HFromW;
+                        }
+                        else
+                        {
+                            //4, T
+                            Right = WFromW + (WFromH / 2);
+                            Left = TakenWidth - Right;
+                            XOffset = -Left;
+                            YOffset = -HFromH;
+                        }
+                    }
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Gets or sets the label angle.
+        /// </summary>
+        /// <value>
+        /// The label angle.
+        /// </value>
+        public double LabelAngle { get; set; }
+        /// <summary>
+        /// Gets or sets the w from w.
+        /// </summary>
+        /// <value>
+        /// The w from w.
+        /// </value>
+        public double WFromW { get; set; }
+        /// <summary>
+        /// Gets or sets the w from h.
+        /// </summary>
+        /// <value>
+        /// The w from h.
+        /// </value>
+        public double WFromH { get; set; }
+        /// <summary>
+        /// Gets or sets the h from w.
+        /// </summary>
+        /// <value>
+        /// The h from w.
+        /// </value>
+        public double HFromW { get; set; }
+        /// <summary>
+        /// Gets or sets the h from h.
+        /// </summary>
+        /// <value>
+        /// The h from h.
+        /// </value>
+        public double HFromH { get; set; }
+        /// <summary>
+        /// Gets or sets the top.
+        /// </summary>
+        /// <value>
+        /// The top.
+        /// </value>
+        public double Top { get; set; }
+        /// <summary>
+        /// Gets or sets the bottom.
+        /// </summary>
+        /// <value>
+        /// The bottom.
+        /// </value>
+        public double Bottom { get; set; }
+        /// <summary>
+        /// Gets or sets the left.
+        /// </summary>
+        /// <value>
+        /// The left.
+        /// </value>
+        public double Left { get; set; }
+        /// <summary>
+        /// Gets or sets the right.
+        /// </summary>
+        /// <value>
+        /// The right.
+        /// </value>
+        public double Right { get; set; }
+        /// <summary>
+        /// Gets or sets the x offset.
+        /// </summary>
+        /// <value>
+        /// The x offset.
+        /// </value>
+        public double XOffset { get; set; }
+        /// <summary>
+        /// Gets or sets the y offset.
+        /// </summary>
+        /// <value>
+        /// The y offset.
+        /// </value>
+        public double YOffset { get; set; }
+
+        /// <summary>
+        /// Gets the width of the taken.
+        /// </summary>
+        /// <value>
+        /// The width of the taken.
+        /// </value>
+        public double TakenWidth { get { return WFromW + WFromH; } }
+        /// <summary>
+        /// Gets the height of the taken.
+        /// </summary>
+        /// <value>
+        /// The height of the taken.
+        /// </value>
+        public double TakenHeight { get { return HFromW + HFromH; } }
+
+        /// <summary>
+        /// Gets the actual width.
+        /// </summary>
+        /// <value>
+        /// The actual width.
+        /// </value>
+        public double ActualWidth { get; private set; }
+        /// <summary>
+        /// Gets the actual height.
+        /// </summary>
+        /// <value>
+        /// The actual height.
+        /// </value>
+        public double ActualHeight { get; private set; }
+
+        /// <summary>
+        /// Gets the offset by source.
+        /// </summary>
+        /// <param name="source">The source.</param>
+        /// <returns></returns>
+        public double GetOffsetBySource(AxisOrientation source)
+        {
+            return source == AxisOrientation.X
+                ? XOffset
+                : YOffset;
+        }
+    }
+}

Others/Live-Charts-master/Core/Dtos/StackedSum.cs

@@ -0,0 +1,42 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Dtos
+{
+    internal struct StackedSum
+    {
+        public StackedSum(double value) : this()
+        {
+            if (value < 0)
+            {
+                Left = value;
+            }
+            else
+            {
+                Right = value;
+            }
+        }
+
+        public double Left { get; set; }
+        public double Right { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Dtos/TooltipDataViewModel.cs

@@ -0,0 +1,62 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+
+namespace LiveCharts.Dtos
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public struct TooltipDataViewModel
+    {
+        /// <summary>
+        /// Gets or sets the points.
+        /// </summary>
+        /// <value>
+        /// The points.
+        /// </value>
+        public IEnumerable<ChartPoint> Points { get; set; }
+        /// <summary>
+        /// Gets or sets the shares.
+        /// </summary>
+        /// <value>
+        /// The shares.
+        /// </value>
+        public double? Shares { get; set; }
+        /// <summary>
+        /// Gets or sets the x formatter.
+        /// </summary>
+        /// <value>
+        /// The x formatter.
+        /// </value>
+        public Func<double, string> XFormatter { get; set; }
+        /// <summary>
+        /// Gets or sets the y formatter.
+        /// </summary>
+        /// <value>
+        /// The y formatter.
+        /// </value>
+        public Func<double, string> YFormatter { get; set; }
+    }
+}

Others/Live-Charts-master/Core/Events/Delegates.cs

@@ -0,0 +1,56 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Events
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="sender">The sender.</param>
+    /// <param name="chartPoint">The chart point.</param>
+    public delegate void DataClickHandler(object sender, ChartPoint chartPoint);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="sender"></param>
+    /// <param name="chartPoint"></param>
+    public delegate void DataHoverHandler(object sender, ChartPoint chartPoint);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="sender">The sender.</param>
+    public delegate void UpdaterTickHandler(object sender);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="eventArgs">The <see cref="RangeChangedEventArgs"/> instance containing the event data.</param>
+    public delegate void RangeChangedHandler(RangeChangedEventArgs eventArgs);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="eventArgs">The <see cref="PreviewRangeChangedEventArgs"/> instance containing the event data.</param>
+    public delegate void PreviewRangeChangedHandler(PreviewRangeChangedEventArgs eventArgs);
+}

Others/Live-Charts-master/Core/Events/PreviewRangeChangedEventArgs.cs

@@ -0,0 +1,73 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Events
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Events.RangeChangedEventArgs" />
+    public class PreviewRangeChangedEventArgs : RangeChangedEventArgs
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PreviewRangeChangedEventArgs"/> class.
+        /// </summary>
+        public PreviewRangeChangedEventArgs()
+        {
+            
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PreviewRangeChangedEventArgs"/> class.
+        /// </summary>
+        /// <param name="args">The <see cref="RangeChangedEventArgs"/> instance containing the event data.</param>
+        public PreviewRangeChangedEventArgs(RangeChangedEventArgs args)
+        {
+            LeftLimitChange = args.LeftLimitChange;
+            RightLimitChange = args.RightLimitChange;
+            Range = args.Range;
+            Axis = args.Axis;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the axis change was canceled by the user.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if cancel; otherwise, <c>false</c>.
+        /// </value>
+        public bool Cancel { get; set; }
+        /// <summary>
+        /// Gets the preview minimum value.
+        /// </summary>
+        /// <value>
+        /// The preview minimum value.
+        /// </value>
+        public double PreviewMinValue { get; internal set; }
+        /// <summary>
+        /// Gets the preview maximum value.
+        /// </summary>
+        /// <value>
+        /// The preview maximum value.
+        /// </value>
+        public double PreviewMaxValue { get; internal set; }
+    }
+}

Others/Live-Charts-master/Core/Events/RangeChangedEventArgs.cs

@@ -0,0 +1,47 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts.Events
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class RangeChangedEventArgs
+    {
+        /// <summary>
+        /// Gets the min limit difference compared with previous state
+        /// </summary>
+        public double LeftLimitChange { get; internal set; }
+        /// <summary>
+        /// Gets the max limit difference compared with previous state
+        /// </summary>
+        public double RightLimitChange { get; internal set; }
+        /// <summary>
+        /// Gets the current axis range
+        /// </summary>
+        public double Range { get; internal set; }
+        /// <summary>
+        /// Gets the axis that fired the change
+        /// </summary>
+        public object Axis { get; internal set; }
+    }
+}

Others/Live-Charts-master/Core/Helpers/Extentions.cs

@@ -0,0 +1,138 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using LiveCharts.Definitions.Series;
+using LiveCharts.Dtos;
+
+namespace LiveCharts.Helpers
+{
+    /// <summary>
+    /// LiveCharts extensions methods
+    /// </summary>
+    public static class Extentions
+    {
+        /// <summary>
+        /// Executes an Action in every item of a collection
+        /// </summary>
+        /// <typeparam name="T">type to iterate with</typeparam>
+        /// <param name="source">collection to iterate</param>
+        /// <param name="predicate">action to execute</param>
+        internal static void ForEach<T>(this IEnumerable<T> source, Action<T> predicate)
+        {
+            foreach (var item in source) predicate(item);
+        }
+
+        /// <summary>
+        /// Splits a collection of points every double.Nan
+        /// </summary>
+        /// <param name="toSplit">collection to split</param>
+        /// <returns>collection of collections</returns>
+        internal static IEnumerable<IList<ChartPoint>> SplitEachNaN(this IList<ChartPoint> toSplit)
+        {
+            var l = new List<ChartPoint>(toSplit.Count);
+            var acum = -1;
+
+            foreach (var point in toSplit)
+            {
+                if (double.IsNaN(point.X) || double.IsNaN(point.Y))
+                {
+                    yield return l;
+                    acum += l.Count;
+                    l = new List<ChartPoint>(toSplit.Count - acum);
+                }
+                else
+                {
+                    l.Add(point);
+                }
+            }
+
+            yield return l;
+        }
+
+        /// <summary>
+        /// Return the inverse axis orientation
+        /// </summary>
+        /// <param name="axis">current orientation</param>
+        /// <returns>inverted axis orientation</returns>
+        internal static AxisOrientation Invert(this AxisOrientation axis)
+        {
+            return axis == AxisOrientation.X
+                ? AxisOrientation.Y
+                : AxisOrientation.X;
+        }
+
+        /// <summary>
+        /// Converts any collection to chart values
+        /// </summary>
+        /// <typeparam name="T">type to convert</typeparam>
+        /// <param name="values">values to convert</param>
+        /// <returns>a new ChartValues instance containing the passed collection</returns>
+        public static ChartValues<T> AsChartValues<T>(this IEnumerable<T> values)
+        {
+            var l = new ChartValues<T>();
+            l.AddRange(values);
+            return l;
+        }
+
+        /// <summary>
+        /// Converts an enumeration of series to a SeriesCollection instance.
+        /// </summary>
+        /// <param name="series">The series.</param>
+        /// <returns></returns>
+        public static SeriesCollection AsSeriesCollection(this IEnumerable<ISeriesView> series)
+        {
+            var collection = new SeriesCollection();
+            collection.AddRange(series);
+            return collection;
+        }
+
+        /// <summary>
+        /// Gets the closest chart point with a given value.
+        /// </summary>
+        /// <param name="series">The target series.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="orientation">the axis orientation</param>
+        /// <returns></returns>
+        public static ChartPoint ClosestPointTo(this ISeriesView series, double value, AxisOrientation orientation)
+        {
+            ChartPoint t = null;
+            var delta = double.PositiveInfinity;
+
+            foreach (var point in series.Values.GetPoints(series))
+            {
+                var i = orientation == AxisOrientation.X ? point.X : point.Y;
+
+                var di = Math.Abs(i - value);
+
+                if (di < delta)
+                {
+                    t = point;
+                    delta = di;
+                }
+            }
+
+            return t;
+        }
+    }
+}

Others/Live-Charts-master/Core/Helpers/LiveChartsException.cs

@@ -0,0 +1,69 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+
+namespace LiveCharts.Helpers
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="System.Exception" />
+    public class LiveChartsException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiveChartsException"/> class.
+        /// </summary>
+        public LiveChartsException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiveChartsException"/> class.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public LiveChartsException(string message) : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiveChartsException"/> class.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>
+        public LiveChartsException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LiveChartsException"/> class.
+        /// </summary>
+        /// <param name="format">The format.</param>
+        /// <param name="innerException">The inner exception.</param>
+        /// <param name="args">The arguments.</param>
+        public LiveChartsException(string format, Exception innerException, params object[] args)
+            : base(string.Format(format, args), innerException)
+        {
+        }
+    }
+}

Others/Live-Charts-master/Core/Helpers/NoisyCollection.cs

@@ -0,0 +1,615 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Linq;
+
+namespace LiveCharts.Helpers
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="oldItems">The old items.</param>
+    /// <param name="newItems">The new items.</param>
+    public delegate void NoisyCollectionCollectionChanged<in T>(
+        IEnumerable<T> oldItems, IEnumerable<T> newItems);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="System.Collections.IList" />
+    public interface INoisyCollection : IList, INotifyPropertyChanged, INotifyCollectionChanged
+    {
+        /// <summary>
+        /// Occurs when [noisy collection changed].
+        /// </summary>
+        event NoisyCollectionCollectionChanged<object> NoisyCollectionChanged;
+        /// <summary>
+        /// Adds the range.
+        /// </summary>
+        /// <param name="items">The items.</param>
+        void AddRange(IEnumerable<object> items);
+        /// <summary>
+        /// Inserts the range.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        /// <param name="collection">The collection.</param>
+        void InsertRange(int index, IEnumerable<object> collection);
+    }
+
+    /// <summary>
+    /// A collection that notifies every time a value is added or removed
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class NoisyCollection<T> : INoisyCollection, IList<T>
+    {
+        #region Private Fields
+        private readonly object _sync = new object();
+        private readonly List<T> _source;
+        private const string CountString = "Count";
+        private const string IndexerString = "Item[]";
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of NoisyCollection class
+        /// </summary>
+        public NoisyCollection()
+        {
+            _source = new List<T>();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of NoisyCollection class with a given collection
+        /// </summary>
+        /// <param name="collection">given collection</param>
+        public NoisyCollection(IEnumerable<T> collection)
+        {
+            _source = new List<T>(collection);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of NoisiCollection class with a given capacity
+        /// </summary>
+        /// <param name="capacity">given capacity</param>
+        public NoisyCollection(int capacity)
+        {
+            _source = new List<T>(capacity);
+        }
+
+        #endregion
+
+        #region Events
+        /// <summary>
+        /// Occurs when [collection reset].
+        /// </summary>
+        public event Action CollectionReset;
+        /// <summary>
+        /// Occurs when [noisy collection changed].
+        /// </summary>
+        event NoisyCollectionCollectionChanged<object> INoisyCollection.NoisyCollectionChanged
+        {
+            add { NoisyCollectionChanged += value as NoisyCollectionCollectionChanged<T>; }
+            remove { NoisyCollectionChanged -= value as NoisyCollectionCollectionChanged<T>; }
+        }
+        /// <summary>
+        /// Occurs when [noisy collection changed].
+        /// </summary>
+        public event NoisyCollectionCollectionChanged<T> NoisyCollectionChanged;
+        /// <summary>
+        /// Occurs when the collection changes.
+        /// </summary>
+        public virtual event NotifyCollectionChangedEventHandler CollectionChanged;
+        /// <summary>
+        /// Occurs when a property value changes.
+        /// </summary>
+        protected virtual event PropertyChangedEventHandler PropertyChanged;
+        /// <summary>
+        /// Occurs when a property value changes.
+        /// </summary>
+        event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
+        {
+            add
+            {
+                PropertyChanged += value;
+            }
+            remove
+            {
+                PropertyChanged -= value;
+            }
+        }
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets an item from/in a specific index
+        /// </summary>
+        /// <param name="index">index to get/set</param>
+        /// <returns></returns>
+        public T this[int index]
+        {
+            get
+            {
+                lock (_sync)
+                {
+                    return _source[index];
+                }
+            }
+            set
+            {
+                var original = this[index];
+                lock (_sync)
+                {
+                    _source[index] = value;
+                }
+                ReplaceItem(original, value, index);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets an item from/in a specific index
+        /// </summary>
+        /// <param name="index">index to get/set</param>
+        /// <returns></returns>
+        object IList.this[int index]
+        {
+            get
+            {
+                lock (_sync)
+                {
+                    return _source[index];
+                }
+            }
+            set
+            {
+                var original = this[index];
+                lock (_sync)
+                {
+                    _source[index] = (T)value;
+                }
+                ReplaceItem(original, value, index);
+            }
+        }
+
+        /// <summary>
+        /// Enumerates the collection
+        /// </summary>
+        /// <returns>collection enumeration</returns>
+        public IEnumerator<T> GetEnumerator()
+        {
+            lock (_sync)
+            {
+                return new List<T>(_source).GetEnumerator();
+            }
+        }
+
+        /// <summary>
+        /// Enumerates the collection
+        /// </summary>
+        /// <returns>collection enumeration</returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        /// <summary>
+        /// Gets the number of items in the array
+        /// </summary>
+        /// <returns>items count</returns>
+        public int Count
+        {
+            get { return _source.Count; }
+        }
+
+        /// <summary>
+        /// Gets whether the collection is read only
+        /// </summary>
+        /// <returns>result</returns>
+        bool ICollection<T>.IsReadOnly
+        {
+            get { return ((ICollection<T>)_source).IsReadOnly; }
+        }
+        /// <summary>
+        /// Gets the number of items in the array
+        /// </summary>
+        /// <returns>result</returns>
+        bool IList.IsReadOnly
+        {
+            get { return ((IList)_source).IsReadOnly; }
+        }
+
+        /// <summary>
+        /// Gets whether the collection is synchronized
+        /// </summary>
+        /// <returns>result</returns>
+        public bool IsSynchronized
+        {
+            get { return ((ICollection)_source).IsSynchronized; }
+        }
+
+        /// <summary>
+        /// Gets the collections's sync root
+        /// </summary>
+        public object SyncRoot
+        {
+            get { return ((ICollection)_source).SyncRoot; }
+        }
+
+        /// <summary>
+        /// Gets whether the collection is fixed
+        /// </summary>
+        public bool IsFixedSize { get { return ((IList)_source).IsFixedSize; } }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Adds an object to the collection, and notifies the change
+        /// </summary>
+        /// <param name="value">item to add</param>
+        /// <returns>number of items in the collection</returns>
+        int IList.Add(object value)
+        {
+            var v = (T)value;
+            Add(v);
+            lock (_sync)
+            {
+                return _source.IndexOf(v);
+            }
+        }
+
+        /// <summary>
+        /// Add an item to the collection, and notifies the change
+        /// </summary>
+        /// <returns>number of items in the collection</returns>
+        public void Add(T item)
+        {
+            lock (_sync)
+            {
+                _source.Add(item);
+            }
+            OnNoisyCollectionChanged(null, new[] { item });
+            OnPropertyChanged(CountString);
+            OnPropertyChanged(IndexerString);
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(
+                NotifyCollectionChangedAction.Add, item, _source.Count - 1));
+        }
+
+        /// <summary>
+        /// Adds many items to the collection, and notifies the change
+        /// </summary>
+        /// <param name="items">collection to add</param>
+        public void AddRange(IEnumerable<object> items)
+        {
+            AddRange(items.Cast<T>());
+        }
+
+        /// <summary>
+        /// Adds many items to the collection, and notifies the change
+        /// </summary>
+        /// <param name="items">collection to add</param>
+        public void AddRange(IEnumerable<T> items)
+        {
+            var newItems = items as T[] ?? items.ToArray();
+            lock (_sync)
+            {
+                _source.AddRange(newItems);
+            }
+            OnNoisyCollectionChanged(null, newItems);
+            OnPropertyChanged(CountString);
+            OnPropertyChanged(IndexerString);
+            //This scenario is not supported normally in ObservableCollections
+            //in this case we'll send a reset action.
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(
+                NotifyCollectionChangedAction.Reset));
+        }
+
+        /// <summary>
+        /// Insert an item in a specific index, then notifies the change
+        /// </summary>
+        /// <param name="index">index to insert at</param>
+        /// <param name="item">item to insert</param>
+        public void Insert(int index, T item)
+        {
+            lock (_sync)
+            {
+                _source.Insert(index, item);
+            }
+            OnNoisyCollectionChanged(null, new[] { item });
+            OnPropertyChanged(CountString);
+            OnPropertyChanged(IndexerString);
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(
+                NotifyCollectionChangedAction.Add, item, index));
+        }
+
+        /// <summary>
+        /// Insert an item in a specific index, then notifies the change
+        /// </summary>
+        /// <param name="index">index to insert at</param>
+        /// <param name="value">item to insert</param>
+        public void Insert(int index, object value)
+        {
+            Insert(index, (T)value);
+        }
+
+        /// <summary>
+        /// Insert a range of values, starting in a specific index, then notifies the change
+        /// </summary>
+        /// <param name="index">index to start at</param>
+        /// <param name="collection">collection to insert</param>
+        public void InsertRange(int index, IEnumerable<object> collection)
+        {
+            InsertRange(index, collection.Cast<T>());
+        }
+
+        /// <summary>
+        /// Insert a range of values, starting in a specific index, then notifies the change
+        /// </summary>
+        /// <param name="index">index to start at</param>
+        /// <param name="collection">collection to insert</param>
+        public void InsertRange(int index, IEnumerable<T> collection)
+        {
+            var newItems = collection as T[] ?? collection.ToArray();
+            lock (_sync)
+            {
+                _source.InsertRange(index, newItems);
+            }
+            OnNoisyCollectionChanged(null, newItems);
+            OnPropertyChanged(CountString);
+            OnPropertyChanged(IndexerString);
+            //This scenario is not supported normally in ObservableCollections
+            //in this case we'll send a reset action.
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(
+                NotifyCollectionChangedAction.Reset));
+        }
+
+        /// <summary>
+        /// Removes an item from a collection, then notifies the change
+        /// </summary>
+        /// <param name="value">item to remove</param>
+        public void Remove(object value)
+        {
+            Remove((T)value);
+        }
+
+        /// <summary>
+        /// Remove an item from a collection, then notifies the change
+        /// </summary>
+        /// <param name="item">item to remove</param>
+        /// <returns>number of items in the collection</returns>
+        public bool Remove(T item)
+        {
+            int index;
+            lock (_sync)
+            {
+                index = _source.IndexOf(item);
+            }
+            if (index < 0) return false;
+            RemoveAt(index);
+            return true;
+        }
+
+        /// <summary>
+        /// Removes an item at a specific index, then notifies the change
+        /// </summary>
+        /// <param name="index">index to remove at</param>
+        void IList.RemoveAt(int index)
+        {
+            RemoveAt(index);
+        }
+
+        /// <summary>
+        /// Removes an item at a specific index, then notifies the change
+        /// </summary>
+        /// <param name="index">index to remove at</param>
+        void IList<T>.RemoveAt(int index)
+        {
+            RemoveAt(index);
+        }
+
+        /// <summary>
+        /// Removes an item at a specific index, then notifies the change
+        /// </summary>
+        /// <param name="index">index to remove at</param>
+        public void RemoveAt(int index)
+        {
+            T item;
+            lock (_sync)
+            {
+                item = _source[index];
+                _source.RemoveAt(index);
+            }
+            OnNoisyCollectionChanged(new[] { item }, null);
+            OnPropertyChanged(CountString);
+            OnPropertyChanged(IndexerString);
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(
+                NotifyCollectionChangedAction.Remove, item, index));
+        }
+
+        /// <summary>
+        /// Removes all the items from the collection, then notifies the change
+        /// </summary>
+        void IList.Clear()
+        {
+            Clear();
+        }
+
+        /// <summary>
+        /// Removes all the items from the collection, then notifies the change
+        /// </summary>
+        void ICollection<T>.Clear()
+        {
+            Clear();
+        }
+
+        /// <summary>
+        /// Removes all the items from the collection, then notifies the change
+        /// </summary>
+        public void Clear()
+        {
+            T[] backup;
+            lock (_sync)
+            {
+                backup = _source.ToArray();
+                _source.Clear();
+            }
+            OnNoisyCollectionChanged(backup, null);
+            OnNoisyCollectionReset();
+            OnPropertyChanged(CountString);
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(
+                NotifyCollectionChangedAction.Reset));
+        }
+
+        /// <summary>
+        /// Evaluates whether an item is in this collection
+        /// </summary>
+        /// <param name="value">object to look for</param>
+        /// <returns>evaluation</returns>
+        public bool Contains(object value)
+        {
+            return Contains((T)value);
+        }
+
+        /// <summary>
+        /// Evaluates whether an item is in this collection
+        /// </summary>
+        /// <param name="item">item to look for</param>
+        /// <returns>evaluation</returns>
+        public bool Contains(T item)
+        {
+            lock (_sync)
+            {
+                return _source.Contains(item);
+            }
+        }
+
+        /// <summary>
+        /// Copies the collection to another array
+        /// </summary>
+        /// <param name="array">backup array</param>
+        /// <param name="index">array index</param>
+        public void CopyTo(Array array, int index)
+        {
+            CopyTo(array.Cast<T>().ToArray(), index);
+        }
+
+        /// <summary>
+        /// Copies the collection to another array
+        /// </summary>
+        /// <param name="array">backup array</param>
+        /// <param name="index">array index</param>
+        public void CopyTo(T[] array, int index)
+        {
+            lock (_sync)
+            {
+                _source.CopyTo(array, index);
+            }
+        }
+
+        /// <summary>
+        /// Returns the index of an item in the collection
+        /// </summary>
+        /// <param name="value">item to look for</param>
+        /// <returns></returns>
+        public int IndexOf(object value)
+        {
+            return IndexOf((T)value);
+        }
+
+        /// <summary>
+        /// Returns the index of an item in the collection
+        /// </summary>
+        /// <param name="item">item to look for</param>
+        /// <returns></returns>
+        public int IndexOf(T item)
+        {
+            lock (_sync)
+            {
+                return _source.IndexOf(item);
+            }
+        }
+
+        #endregion
+
+        #region Protected Methods        
+        /// <summary>
+        /// Raises the <see cref="E:PropertyChanged" /> event.
+        /// </summary>
+        /// <param name="e">The <see cref="PropertyChangedEventArgs"/> instance containing the event data.</param>
+        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
+        {
+            if (PropertyChanged != null)
+            {
+                PropertyChanged.Invoke(this, e);
+            }
+        }
+
+        /// <summary>
+        /// Raises the <see cref="E:CollectionChanged" /> event.
+        /// </summary>
+        /// <param name="e">The <see cref="NotifyCollectionChangedEventArgs"/> instance containing the event data.</param>
+        protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
+        {
+            if (CollectionChanged != null)
+            {
+                CollectionChanged.Invoke(this, e);
+            }
+        }
+
+        #endregion
+
+        #region Private Methods
+        private void OnNoisyCollectionChanged(IEnumerable<T> olditems, IEnumerable<T> newItems)
+        {
+            if (NoisyCollectionChanged != null)
+                NoisyCollectionChanged.Invoke(olditems, newItems);
+        }
+
+        private void OnNoisyCollectionReset()
+        {
+            if (CollectionReset != null)
+                CollectionReset.Invoke();
+        }
+
+        private void OnPropertyChanged(string propertyName)
+        {
+            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
+        }
+
+        private void ReplaceItem(object original, object item, int index)
+        {
+            OnPropertyChanged(IndexerString);
+            OnNoisyCollectionChanged(new List<T> { (T)original }, new List<T> { (T)item });
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(
+                NotifyCollectionChangedAction.Replace, original, item, index));
+        }
+        #endregion
+    }
+}

Others/Live-Charts-master/Core/IBezierData.cs

@@ -0,0 +1,7 @@
+namespace LiveChartsCore
+{
+    public interface IBezierData
+    {
+        BezierData Data { get; set; }
+    }
+}

Others/Live-Charts-master/Core/IChartValues.cs

@@ -0,0 +1,60 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System.Collections.Generic;
+using LiveCharts.Definitions.Series;
+using LiveCharts.Helpers;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.Helpers.INoisyCollection" />
+    public interface IChartValues : INoisyCollection
+    {
+        /// <summary>
+        /// Forces values to calculate max, min and index data.
+        /// </summary>
+        void Initialize(ISeriesView seriesView);
+
+        /// <summary>
+        /// Gets the current chart points in the view, the view is required as an argument, because an instance of IChartValues could hold many ISeriesView instances.
+        /// </summary>
+        /// <param name="seriesView">The series view</param>
+        /// <returns></returns>
+        IEnumerable<ChartPoint> GetPoints(ISeriesView seriesView);
+        /// <summary>
+        /// Initializes the garbage collector
+        /// </summary>
+        void InitializeStep(ISeriesView seriesView);
+        /// <summary>
+        /// Removes all unnecessary points from the view
+        /// </summary>
+        void CollectGarbage(ISeriesView seriesView);
+
+        /// <summary>
+        /// Gets series that owns the values
+        /// </summary>
+        PointTracker GetTracker(ISeriesView view);
+    }
+}

Others/Live-Charts-master/Core/IObservableChartPoint.cs

@@ -0,0 +1,36 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+namespace LiveCharts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public interface IObservableChartPoint
+    {
+        /// <summary>
+        /// Occurs when [point changed].
+        /// </summary>
+        event Action PointChanged;
+    }
+}

Others/Live-Charts-master/Core/LegendLocation.cs

@@ -0,0 +1,51 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Charts legend locations
+    /// </summary>
+    public enum LegendLocation
+    {
+        /// <summary>
+        /// Disables legend
+        /// </summary>
+        None,
+        /// <summary>
+        /// PLaces legend at top
+        /// </summary>
+        Top,
+        /// <summary>
+        /// Places legend at bottom
+        /// </summary>
+        Bottom,
+        /// <summary>
+        /// Places legend at left
+        /// </summary>
+        Left,
+        /// <summary>
+        /// Places legend at right
+        /// </summary>
+        Right
+    }
+}

Others/Live-Charts-master/Core/LogarithmicAxisCore.cs

@@ -0,0 +1,157 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System;
+using LiveCharts.Charts;
+using LiveCharts.Definitions.Charts;
+using LiveCharts.Dtos;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="LiveCharts.AxisCore" />
+    public class LogarithmicAxisCore : AxisCore
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LogarithmicAxisCore"/> class.
+        /// </summary>
+        /// <param name="view">The view.</param>
+        public LogarithmicAxisCore(IAxisView view) : base(view)
+        {
+            CleanFactor = 1.5;
+        }
+
+        internal override CoreMargin PrepareChart(AxisOrientation source, ChartCore chart)
+        {
+            if (!(Math.Abs(TopLimit - BotLimit) > S * .01) || !ShowLabels) return new CoreMargin();
+
+            CalculateSeparator(chart, source);
+
+            var f = GetFormatter();
+
+            var currentMargin = new CoreMargin();
+            if (S < 1) S = 1;
+            var tolerance = S / 10;
+
+            InitializeGarbageCollector();
+
+            var bl = Math.Ceiling(BotLimit / Magnitude) * Magnitude;
+            var @base = ((ILogarithmicAxisView) View).Base;
+
+            for (var i = bl; i <= TopLimit - (EvaluatesUnitWidth ? 1 : 0); i += S)
+            {
+                var minTolerance = tolerance/10;
+                if (Math.Abs(i - bl) > tolerance)
+                {
+                    var step = Math.Pow(@base, i - 1);
+                    for (var j = Math.Pow(@base, i - 1) + step; 
+                        j < Math.Pow(@base, i); 
+                        j += step)
+                    {
+                        SeparatorElementCore minorAsc;
+                        var scaledJ = Math.Log(j, @base);
+
+                        var minorKey = Math.Round(scaledJ / minTolerance) * minTolerance;
+                        if (!Cache.TryGetValue(minorKey, out minorAsc))
+                        {
+                            minorAsc = new SeparatorElementCore { IsNew = true };
+                            Cache[minorKey] = minorAsc;
+                        }
+                        else
+                        {
+                            minorAsc.IsNew = false;
+                        }
+
+                        View.RenderSeparator(minorAsc, Chart);
+
+                        minorAsc.Key = minorKey;
+                        minorAsc.Value = scaledJ;
+                        minorAsc.GarbageCollectorIndex = GarbageCollectorIndex;
+
+                        minorAsc.View.UpdateLabel(string.Empty, this, source);
+
+                        if (LastAxisMax == null)
+                        {
+                            minorAsc.State = SeparationState.InitialAdd;
+                            continue;
+                        }
+
+                        minorAsc.State = SeparationState.Keep;
+                    }
+                }
+
+                SeparatorElementCore asc;
+
+                var key = Math.Round(i / tolerance) * tolerance;
+                if (!Cache.TryGetValue(key, out asc))
+                {
+                    asc = new SeparatorElementCore { IsNew = true };
+                    Cache[key] = asc;
+                }
+                else
+                {
+                    asc.IsNew = false;
+                }
+
+                View.RenderSeparator(asc, Chart);
+
+                asc.Key = key;
+                asc.Value = i;
+                asc.GarbageCollectorIndex = GarbageCollectorIndex;
+
+                var labelsMargin = asc.View.UpdateLabel(f(i), this, source);
+
+                currentMargin.Width = labelsMargin.TakenWidth > currentMargin.Width
+                    ? labelsMargin.TakenWidth
+                    : currentMargin.Width;
+                currentMargin.Height = labelsMargin.TakenHeight > currentMargin.Height
+                    ? labelsMargin.TakenHeight
+                    : currentMargin.Height;
+
+                currentMargin.Left = labelsMargin.Left > currentMargin.Left
+                    ? labelsMargin.Left
+                    : currentMargin.Left;
+                currentMargin.Right = labelsMargin.Right > currentMargin.Right
+                    ? labelsMargin.Right
+                    : currentMargin.Right;
+
+                currentMargin.Top = labelsMargin.Top > currentMargin.Top
+                    ? labelsMargin.Top
+                    : currentMargin.Top;
+                currentMargin.Bottom = labelsMargin.Bottom > currentMargin.Bottom
+                    ? labelsMargin.Bottom
+                    : currentMargin.Bottom;
+
+                if (LastAxisMax == null)
+                {
+                    asc.State = SeparationState.InitialAdd;
+                    continue;
+                }
+
+                asc.State = SeparationState.Keep;
+            }
+            return currentMargin;
+        }
+    }
+}

Others/Live-Charts-master/Core/Maps/MapData.cs

@@ -0,0 +1,96 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System.Collections.Generic;
+
+namespace LiveCharts.Maps
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class LvcMap
+    {
+        /// <summary>
+        /// Gets or sets the width of the desired.
+        /// </summary>
+        /// <value>
+        /// The width of the desired.
+        /// </value>
+        public double DesiredWidth { get; set; }
+        /// <summary>
+        /// Gets or sets the height of the desired.
+        /// </summary>
+        /// <value>
+        /// The height of the desired.
+        /// </value>
+        public double DesiredHeight { get; set; }
+        /// <summary>
+        /// Gets or sets the data.
+        /// </summary>
+        /// <value>
+        /// The data.
+        /// </value>
+        public List<MapData> Data { get; set; }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class MapData
+    {
+        /// <summary>
+        /// Gets or sets the identifier.
+        /// </summary>
+        /// <value>
+        /// The identifier.
+        /// </value>
+        public string Id { get; set; }
+        /// <summary>
+        /// Gets or sets the name.
+        /// </summary>
+        /// <value>
+        /// The name.
+        /// </value>
+        public string Name { get; set; }
+        /// <summary>
+        /// Gets or sets the data.
+        /// </summary>
+        /// <value>
+        /// The data.
+        /// </value>
+        public string Data { get; set; }
+        /// <summary>
+        /// Gets or sets the shape.
+        /// </summary>
+        /// <value>
+        /// The shape.
+        /// </value>
+        public object Shape { get; set; }
+        /// <summary>
+        /// Gets or sets the LVC map.
+        /// </summary>
+        /// <value>
+        /// The LVC map.
+        /// </value>
+        public LvcMap LvcMap { get; set; }
+    }
+}

Others/Live-Charts-master/Core/PanningOptions.cs

@@ -0,0 +1,51 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Chart Panning Options
+    /// </summary>
+    public enum PanningOptions
+    {
+        /// <summary>
+        /// By default chart Panning is Unset, this means it will be based the Chart Zooming selection
+        /// </summary>
+        Unset,
+        /// <summary>
+        /// Not panning allowed
+        /// </summary>
+        None,
+        /// <summary>
+        /// Panning only in the X axis
+        /// </summary>
+        X,
+        /// <summary>
+        /// Panning only in the Y axis
+        /// </summary>
+        Y,
+        /// <summary>
+        /// Panning in both X and Y axes
+        /// </summary>
+        Xy
+    }
+}

Others/Live-Charts-master/Core/PieLabelPosition.cs

@@ -0,0 +1,39 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// Describes where a label should be placed
+    /// </summary>
+    public enum PieLabelPosition
+    {
+        /// <summary>
+        /// Places the label inside the pie slice
+        /// </summary>
+        InsideSlice,
+        /// <summary>
+        /// Places the label outside the pie slice
+        /// </summary>
+        OutsideSlice
+    }
+}

Others/Live-Charts-master/Core/PointTracker.cs

@@ -0,0 +1,85 @@
+//The MIT License(MIT)
+
+//Copyright(c) 2016 Alberto Rodriguez & LiveCharts Contributors
+
+//Permission is hereby granted, free of charge, to any person obtaining a copy
+//of this software and associated documentation files (the "Software"), to deal
+//in the Software without restriction, including without limitation the rights
+//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//copies of the Software, and to permit persons to whom the Software is
+//furnished to do so, subject to the following conditions:
+
+//The above copyright notice and this permission notice shall be included in all
+//copies or substantial portions of the Software.
+
+//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//SOFTWARE.
+
+using System.Collections.Generic;
+using LiveCharts.Dtos;
+
+namespace LiveCharts
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class PointTracker
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PointTracker"/> class.
+        /// </summary>
+        public PointTracker()
+        {
+            Indexed = new Dictionary<int, ChartPoint>();
+            Referenced = new Dictionary<object, ChartPoint>();
+        }
+
+        /// <summary>
+        /// Gets the x limit.
+        /// </summary>
+        /// <value>
+        /// The x limit.
+        /// </value>
+        public CoreLimit XLimit { get; internal set; }
+        /// <summary>
+        /// Gets the y limit.
+        /// </summary>
+        /// <value>
+        /// The y limit.
+        /// </value>
+        public CoreLimit YLimit { get; internal set; }
+        /// <summary>
+        /// Gets the w limit.
+        /// </summary>
+        /// <value>
+        /// The w limit.
+        /// </value>
+        public CoreLimit WLimit { get; internal set; }
+        /// <summary>
+        /// Gets the gci.
+        /// </summary>
+        /// <value>
+        /// The gci.
+        /// </value>
+        public int Gci { get; internal set; }
+        /// <summary>
+        /// Gets or sets the indexed.
+        /// </summary>
+        /// <value>
+        /// The indexed.
+        /// </value>
+        public Dictionary<int, ChartPoint> Indexed { get; set; }
+        /// <summary>
+        /// Gets or sets the referenced.
+        /// </summary>
+        /// <value>
+        /// The referenced.
+        /// </value>
+        public Dictionary<object, ChartPoint> Referenced { get; set; }
+    }
+}