整理代码结构，支持Package Manager添加

Scripts/Runtime/API.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 94d1c19509a514ffab61efb88d3281fd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/API/BaseChart_API.cs

@@ -0,0 +1,471 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using System.Collections.Generic;
+using System;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    /// <summary>
+    /// The base class of all charts.
+    /// 所有Chart的基类，不可直接使用。
+    /// </summary>
+    public partial class BaseChart
+    {
+        /// <summary>
+        /// The title setting of chart.
+        /// 标题组件
+        /// </summary>
+        public Title title { get { return m_Title; } }
+        /// <summary>
+        /// The legend setting of chart.
+        /// 图例组件
+        /// </summary>
+        public Legend legend { get { return m_Legend; } }
+        /// <summary>
+        /// The tooltip setting of chart.
+        /// 提示框组件
+        /// </summary>
+        public Tooltip tooltip { get { return m_Tooltip; } }
+        /// <summary>
+        /// The series setting of chart.
+        /// 系列列表
+        /// </summary>
+        public Series series { get { return m_Series; } }
+        /// <summary>
+        /// Global parameter setting component.
+        /// 全局设置组件。
+        /// </summary>
+        public Settings settings { get { return m_Settings; } }
+        /// <summary>
+        /// The width of chart. 
+        /// 图表的宽
+        /// </summary>
+        public float chartWidth { get { return m_ChartWidth; } }
+        /// <summary>
+        /// The height of chart. 
+        /// 图表的高
+        /// </summary>
+        public float chartHeight { get { return m_ChartHeight; } }
+        /// <summary>
+        /// The postion of pointer.
+        /// 鼠标位置
+        /// </summary>
+        public Vector2 pointerPos { get; protected set; }
+        /// <summary>
+        /// 自定义绘制回调。
+        /// </summary>
+        public Action<VertexHelper> customDrawCallback { set { m_CustomDrawCallback = value; } }
+        /// <summary>
+        /// Set the size of chart.
+        /// 设置图表的大小。
+        /// </summary>
+        /// <param name="width">width</param>
+        /// <param name="height">height</param>
+        public virtual void SetSize(float width, float height)
+        {
+            m_ChartWidth = width;
+            m_ChartHeight = height;
+            m_CheckWidth = width;
+            m_CheckHeight = height;
+
+            rectTransform.sizeDelta = new Vector2(m_ChartWidth, m_ChartHeight);
+            OnSizeChanged();
+        }
+
+        /// <summary>
+        /// Remove all series and legend data.
+        /// It just emptying all of serie's data without emptying the list of series.
+        /// 清除所有数据，系列中只是移除数据，列表会保留。
+        /// </summary>
+        public virtual void ClearData()
+        {
+            m_Series.ClearData();
+            m_Legend.ClearData();
+            m_CheckAnimation = false;
+            RefreshChart();
+        }
+
+        /// <summary>
+        /// Remove all data from series and legend.
+        /// The series list is also cleared.
+        /// 清除所有系列和图例数据，系列的列表也会被清除。
+        /// </summary>
+        public virtual void RemoveData()
+        {
+            m_Legend.ClearData();
+            m_Series.RemoveAll();
+            m_CheckAnimation = false;
+            RefreshChart();
+        }
+
+        /// <summary>
+        /// Remove legend and serie by name.
+        /// 清除指定系列名称的数据。
+        /// </summary>
+        /// <param name="serieName">the name of serie</param>
+        public virtual void RemoveData(string serieName)
+        {
+            m_Series.Remove(serieName);
+            m_Legend.RemoveData(serieName);
+            RefreshChart();
+        }
+
+        /// <summary>
+        /// Add a serie to serie list.
+        /// 添加一个系列到系列列表中。
+        /// </summary>
+        /// <param name="serieName">the name of serie</param>
+        /// <param name="type">the type of serie</param>
+        /// <param name="show">whether to show this serie</param>
+        /// <returns>the added serie</returns>
+        public virtual Serie AddSerie(SerieType type, string serieName = null, bool show = true)
+        {
+            return m_Series.AddSerie(type, serieName);
+        }
+
+        /// <summary>
+        /// Add a data to serie.
+        /// If serieName doesn't exist in legend,will be add to legend.
+        /// 添加一个数据到指定的系列中。
+        /// </summary>
+        /// <param name="serieName">the name of serie</param>
+        /// <param name="data">the data to add</param>
+        /// <param name="dataName">the name of data</param>
+        /// <returns>Returns True on success</returns>
+        public virtual SerieData AddData(string serieName, float data, string dataName = null)
+        {
+            var serieData = m_Series.AddData(serieName, data, dataName);
+            if (serieData != null)
+            {
+                RefreshChart();
+                RefreshLabel();
+            }
+            return serieData;
+        }
+
+        /// <summary>
+        /// Add a data to serie.
+        /// 添加一个数据到指定的系列中。
+        /// </summary>
+        /// <param name="serieIndex">the index of serie</param>
+        /// <param name="data">the data to add</param>
+        /// <param name="dataName">the name of data</param>
+        /// <returns>Returns True on success</returns>
+        public virtual SerieData AddData(int serieIndex, float data, string dataName = null)
+        {
+            var serieData = m_Series.AddData(serieIndex, data, dataName);
+            if (serieData != null)
+            {
+                RefreshChart();
+                RefreshLabel();
+            }
+            return serieData;
+        }
+
+        /// <summary>
+        /// Add an arbitray dimension data to serie,such as (x,y,z,...).
+        /// 添加多维数据（x,y,z...）到指定的系列中。
+        /// </summary>
+        /// <param name="serieName">the name of serie</param>
+        /// <param name="multidimensionalData">the (x,y,z,...) data</param>
+        /// <param name="dataName">the name of data</param>
+        /// <returns>Returns True on success</returns>
+        public virtual SerieData AddData(string serieName, List<float> multidimensionalData, string dataName = null)
+        {
+            var serieData = m_Series.AddData(serieName, multidimensionalData, dataName);
+            if (serieData != null)
+            {
+                RefreshChart();
+                RefreshLabel();
+            }
+            return serieData;
+        }
+
+        /// <summary>
+        /// Add an arbitray dimension data to serie,such as (x,y,z,...).
+        /// 添加多维数据（x,y,z...）到指定的系列中。
+        /// </summary>
+        /// <param name="serieIndex">the index of serie,index starts at 0</param>
+        /// <param name="multidimensionalData">the (x,y,z,...) data</param>
+        /// <param name="dataName">the name of data</param>
+        /// <returns>Returns True on success</returns>
+        public virtual SerieData AddData(int serieIndex, List<float> multidimensionalData, string dataName = null)
+        {
+            var serieData = m_Series.AddData(serieIndex, multidimensionalData, dataName);
+            if (serieData != null)
+            {
+                RefreshChart();
+                RefreshLabel();
+            }
+            return serieData;
+        }
+
+        /// <summary>
+        /// Add a (x,y) data to serie.
+        /// 添加（x,y）数据到指定系列中。
+        /// </summary>
+        /// <param name="serieName">the name of serie</param>
+        /// <param name="xValue">x data</param>
+        /// <param name="yValue">y data</param>
+        /// <param name="dataName">the name of data</param>
+        /// <returns>Returns True on success</returns>
+        public virtual SerieData AddData(string serieName, float xValue, float yValue, string dataName)
+        {
+            var serieData = m_Series.AddXYData(serieName, xValue, yValue, dataName);
+            if (serieData != null)
+            {
+                RefreshChart();
+                RefreshLabel();
+            }
+            return serieData;
+        }
+
+        /// <summary>
+        /// Add a (x,y) data to serie.
+        /// 添加（x,y）数据到指定系列中。
+        /// </summary>
+        /// <param name="serieIndex">the index of serie</param>
+        /// <param name="xValue">x data</param>
+        /// <param name="yValue">y data</param>
+        /// <param name="dataName">the name of data</param>
+        /// <returns>Returns True on success</returns>
+        public virtual SerieData AddData(int serieIndex, float xValue, float yValue, string dataName = null)
+        {
+            var serieData = m_Series.AddXYData(serieIndex, xValue, yValue, dataName);
+            if (serieData != null)
+            {
+                RefreshChart();
+                RefreshLabel();
+            }
+            return serieData;
+        }
+
+        /// <summary>
+        /// Update serie data by serie name.
+        /// 更新指定系列中的指定索引数据。
+        /// </summary>
+        /// <param name="serieName">the name of serie</param>
+        /// <param name="dataIndex">the index of data</param>
+        /// <param name="value">the data will be update</param>
+        public virtual void UpdateData(string serieName, int dataIndex, float value)
+        {
+            m_Series.UpdateData(serieName, dataIndex, value);
+            RefreshChart();
+        }
+
+        /// <summary>
+        /// Update serie data by serie index.
+        /// 更新指定系列中的指定索引数据。
+        /// </summary>
+        /// <param name="serieIndex">the index of serie</param>
+        /// <param name="dataIndex">the index of data</param>
+        /// <param name="value">the data will be update</param>
+        public virtual void UpdateData(int serieIndex, int dataIndex, float value)
+        {
+            m_Series.UpdateData(serieIndex, dataIndex, value);
+            RefreshChart();
+        }
+
+        /// <summary>
+        /// Update serie data name.
+        /// 更新指定系列中的指定索引数据名称。
+        /// </summary>
+        /// <param name="serieName"></param>
+        /// <param name="dataIndex"></param>
+        /// <param name="dataName"></param>
+        public virtual void UpdateDataName(string serieName, int dataIndex, string dataName)
+        {
+            m_Series.UpdateDataName(serieName, dataIndex, dataName);
+        }
+
+        /// <summary>
+        /// Update serie data name.
+        /// 更新指定系列中的指定索引数据名称。
+        /// </summary>
+        /// <param name="serieIndex"></param>
+        /// <param name="dataName"></param>
+        /// <param name="dataIndex"></param>
+        public virtual void UpdateDataName(int serieIndex, int dataIndex, string dataName)
+        {
+            m_Series.UpdateDataName(serieIndex, dataIndex, dataName);
+        }
+
+        /// <summary>
+        /// Whether to show serie.
+        /// 设置指定系列是否显示。
+        /// </summary>
+        /// <param name="serieName">the name of serie</param>
+        /// <param name="active">Active or not</param>
+        public virtual void SetActive(string serieName, bool active)
+        {
+            var serie = m_Series.GetSerie(serieName);
+            if (serie != null)
+            {
+                SetActive(serie.index, active);
+            }
+        }
+
+        /// <summary>
+        /// Whether to show serie.
+        /// 设置指定系列是否显示。
+        /// </summary>
+        /// <param name="serieIndex">the index of serie</param>
+        /// <param name="active">Active or not</param>
+        public virtual void SetActive(int serieIndex, bool active)
+        {
+            m_Series.SetActive(serieIndex, active);
+            var serie = m_Series.GetSerie(serieIndex);
+            if (serie != null && !string.IsNullOrEmpty(serie.name))
+            {
+                var legendIndex = m_LegendRealShowName.IndexOf(serie.name);
+                var bgColor1 = active ? m_ThemeInfo.GetColor(legendIndex) : m_ThemeInfo.legendUnableColor;
+                m_Legend.UpdateButtonColor(serie.name, bgColor1);
+            }
+        }
+
+        /// <summary>
+        /// Whether serie is activated.
+        /// 获取指定系列是否显示。
+        /// </summary>
+        /// <param name="serieName">the name of serie</param>
+        /// <returns>True when activated</returns>
+        public virtual bool IsActive(string serieName)
+        {
+            return m_Series.IsActive(serieName);
+        }
+
+        /// <summary>
+        /// Whether serie is activated.
+        /// 获取指定系列是否显示。
+        /// </summary>
+        /// <param name="serieIndex">the index of serie</param>
+        /// <returns>True when activated</returns>
+        public virtual bool IsActive(int serieIndex)
+        {
+            return m_Series.IsActive(serieIndex);
+        }
+
+        /// <summary>
+        /// Whether serie is activated.
+        /// 获得指定图例名字的系列是否显示。
+        /// </summary>
+        /// <param name="legendName"></param>
+        /// <returns></returns>
+        public virtual bool IsActiveByLegend(string legendName)
+        {
+            foreach (var serie in m_Series.list)
+            {
+                if (serie.show && legendName.Equals(serie.name))
+                {
+                    return true;
+                }
+                else
+                {
+                    foreach (var serieData in serie.data)
+                    {
+                        if (serieData.show && legendName.Equals(serieData.name))
+                        {
+                            return true;
+                        }
+                    }
+                }
+
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Redraw chart in next frame.
+        /// 在下一帧刷新图表。
+        /// </summary>
+        public void RefreshChart()
+        {
+            m_RefreshChart = true;
+        }
+
+        [Obsolete("Use BaseChart.RefreshLabel() instead.", true)]
+        public void ReinitChartLabel()
+        {
+            RefreshLabel();
+        }
+
+        /// <summary>
+        /// 刷新文本标签Label，重新初始化，当有改动Label参数时手动调用改接口
+        /// </summary>
+        public void RefreshLabel()
+        {
+            m_ReinitLabel = true;
+        }
+
+        /// <summary>
+        /// Update chart theme.
+        /// 切换图表主题。
+        /// </summary>
+        /// <param name="theme">theme</param>
+        public void UpdateTheme(Theme theme)
+        {
+            m_ThemeInfo.theme = theme;
+            OnThemeChanged();
+            RefreshChart();
+        }
+
+        /// <summary>
+        /// Whether series animation enabel.
+        /// 启用或关闭起始动画。
+        /// </summary>
+        /// <param name="flag"></param>
+        public void AnimationEnable(bool flag)
+        {
+            m_Series.AnimationEnable(flag);
+        }
+
+        /// <summary>
+        /// Start play animation.
+        /// 开始初始动画。
+        /// </summary>
+        public void AnimationStart()
+        {
+            m_Series.AnimationStart();
+        }
+
+        /// <summary>
+        /// Stop play animation.
+        /// 停止初始化动画。
+        /// </summary>
+        public void AnimationStop()
+        {
+            m_CheckAnimation = false;
+            m_Series.AnimationStop();
+        }
+
+        /// <summary>
+        /// Reset animation to play.
+        /// 重置初始动画，重新播放。
+        /// </summary>
+        public void AnimationReset()
+        {
+            m_CheckAnimation = false;
+            m_Series.AnimationReset();
+            RefreshChart();
+        }
+
+        /// <summary>
+        /// 点击图例按钮
+        /// </summary>
+        /// <param name="legendIndex">图例按钮索引</param>
+        /// <param name="legendName">图例按钮名称</param>
+        /// <param name="show">显示还是隐藏</param>
+        public void ClickLegendButton(int legendIndex, string legendName, bool show)
+        {
+            OnLegendButtonClick(legendIndex, legendName, show);
+            RefreshChart();
+        }
+    }
+}

Scripts/Runtime/API/BaseChart_API.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d078e85e5877d4d0f990c8dc43006247
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/API/CoordinateChart_API.cs

@@ -0,0 +1,205 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// The basic class of rectangular coordinate chart，such as LineChart,BarChart and ScatterChart.
+    /// 直角坐标系类型图表的基类，如折线图LineChart，柱状图BarChart，散点图ScatterChart都属于这类型的图表。
+    /// 不可用直接将CoordinateChart绑定到GameObject上。
+    /// </summary>
+    public partial class CoordinateChart
+    {
+        /// <summary>
+        /// The lower left position x of coordinate system.
+        /// 坐标系的左下角坐标X。
+        /// </summary>
+        public float coordinateX { get { return m_Grid.left; } }
+        /// <summary>
+        /// The lower left position y of coordinate system.
+        /// 坐标系的左下角坐标Y。
+        /// </summary>
+        public float coordinateY { get { return m_Grid.bottom; } }
+
+        [Obsolete("Use CoordinateChart.coordinateWidth instead.", true)]
+        public float coordinateWid { get { return coordinateWidth; } }
+
+        [Obsolete("Use CoordinateChart.coordinateHeight instead.", true)]
+        public float coordinateHig { get { return coordinateHeight; } }
+
+        /// <summary>
+        /// the width of coordinate system。
+        /// 坐标系的宽。
+        /// </summary>
+        public float coordinateWidth { get { return chartWidth - m_Grid.left - m_Grid.right; } }
+        /// <summary>
+        /// the height of coordinate system。
+        /// 坐标系的高。
+        /// </summary>
+        public float coordinateHeight { get { return chartHeight - m_Grid.top - m_Grid.bottom; } }
+        /// <summary>
+        /// grid component.
+        /// 网格组件。
+        /// </summary>
+        public Grid grid { get { return m_Grid; } }
+        /// <summary>
+        /// the x axises，xAxises[0] is the first x axis, xAxises[1] is the second x axis.
+        /// 两个x轴。
+        /// </summary>
+        public List<XAxis> xAxises { get { return m_XAxises; } }
+        /// <summary>
+        /// the y axises, yAxises[0] is the first y axis, yAxises[1] is the second y axis.
+        /// 两个y轴。
+        /// </summary>
+        public List<YAxis> yAxises { get { return m_YAxises; } }
+        /// <summary>
+        /// dataZoom component.
+        /// 区域缩放组件。
+        /// </summary>
+        public DataZoom dataZoom { get { return m_DataZoom; } }
+        /// <summary>
+        /// visualMap component.
+        /// 视觉映射组件。
+        /// </summary>
+        public VisualMap visualMap { get { return m_VisualMap; } }
+        /// <summary>
+        /// X轴（下）
+        /// </summary>
+        public XAxis xAxis0 { get { return m_XAxises[0]; } }
+        /// <summary>
+        /// X轴（上）
+        /// </summary>
+        public XAxis xAxis1 { get { return m_XAxises[1]; } }
+        /// <summary>
+        /// Y轴（左）
+        /// </summary>
+        public YAxis yAxis0 { get { return m_YAxises[0]; } }
+        /// <summary>
+        /// Y轴（右）
+        /// </summary>
+        public YAxis yAxis1 { get { return m_YAxises[1]; } }
+
+
+        /// <summary>
+        /// Remove all data from series,legend and axis.
+        /// It just emptying all of serie's data without emptying the list of series.
+        /// 清空所有图例，系列和坐标轴类目数据。系列中指示清空系列中的数据，会保留系列列表。
+        /// </summary>
+        public override void ClearData()
+        {
+            base.ClearData();
+            ClearAxisData();
+        }
+
+        /// <summary>
+        /// Remove all data from series,legend and axis.
+        /// The series list is also cleared.
+        /// 清空所有图例，系列和坐标轴类目数据。系列的列表也会被清空。
+        /// </summary>
+        public override void RemoveData()
+        {
+            base.RemoveData();
+            ClearAxisData();
+        }
+
+        /// <summary>
+        /// Remove all data of axises.
+        /// 清除所有x轴和y轴的类目数据。
+        /// </summary>
+        public void ClearAxisData()
+        {
+            foreach (var item in m_XAxises) item.data.Clear();
+            foreach (var item in m_YAxises) item.data.Clear();
+        }
+
+        /// <summary>
+        /// Add a category data to xAxis.
+        /// 添加一个类目数据到指定的x轴。
+        /// </summary>
+        /// <param name="category">the category data</param>
+        /// <param name="xAxisIndex">which xAxis should category add to</param>
+        public void AddXAxisData(string category, int xAxisIndex = 0)
+        {
+            m_XAxises[xAxisIndex].AddData(category);
+            m_XAxisChanged = true;
+        }
+
+        /// <summary>
+        /// Add a category data to yAxis.
+        /// 添加一个类目数据到指定的y轴。
+        /// </summary>
+        /// <param name="category">the category data</param>
+        /// <param name="yAxisIndex">which yAxis should category add to</param>
+        public void AddYAxisData(string category, int yAxisIndex = 0)
+        {
+            m_YAxises[yAxisIndex].AddData(category);
+            m_YAxisChanged = true;
+        }
+
+        /// <summary>
+        /// reutrn true when all the show axis is `Value` type.
+        /// 纯数值坐标。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsValue()
+        {
+            foreach (var axis in m_XAxises)
+            {
+                if (axis.show && !axis.IsValue()) return false;
+            }
+            foreach (var axis in m_YAxises)
+            {
+                if (axis.show && !axis.IsValue()) return false;
+            }
+            return true;
+        }
+
+        public bool IsCategory()
+        {
+            foreach (var axis in m_XAxises)
+            {
+                if (axis.show && !axis.IsCategory()) return false;
+            }
+            foreach (var axis in m_YAxises)
+            {
+                if (axis.show && !axis.IsCategory()) return false;
+            }
+            return true;
+        }
+
+        public bool IsInCooridate(Vector2 local)
+        {
+            if (local.x < coordinateX - 1 || local.x > coordinateX + coordinateWidth + 1 ||
+                local.y < coordinateY - 1 || local.y > coordinateY + coordinateHeight + 1)
+            {
+                return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// 在下一帧刷新DataZoom
+        /// </summary>
+        public void RefreshDataZoom()
+        {
+            RefreshDataZoomLabel();
+        }
+
+        /// <summary>
+        /// 立即刷新数值坐标轴的最大最小值
+        /// </summary>
+        public void RefreshAxisMinMaxValue()
+        {
+            CheckMinMaxValue();
+        }
+    }
+}
+

Scripts/Runtime/API/CoordinateChart_API.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 032e5d8f514854bf39f5fd7052119271
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/BarChart.cs

@@ -0,0 +1,35 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+
+namespace XCharts
+{
+    [AddComponentMenu("XCharts/BarChart", 14)]
+    [ExecuteInEditMode]
+    [RequireComponent(typeof(RectTransform))]
+    [DisallowMultipleComponent]
+    public class BarChart : CoordinateChart
+    {
+
+#if UNITY_EDITOR
+        protected override void Reset()
+        {
+            base.Reset();
+            m_Title.text = "BarChart";
+            m_Tooltip.type = Tooltip.Type.Shadow;
+            RemoveData();
+            AddSerie(SerieType.Bar, "serie1");
+            for (int i = 0; i < 5; i++)
+            {
+                AddXAxisData("x" + (i + 1));
+                AddData(0, Random.Range(10, 90));
+            }
+        }
+#endif
+    }
+}

Scripts/Runtime/BarChart.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 535d2697503c2a94a887354e22a5414d
+timeCreated: 1536795169
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3be5f1d3b129a47dd8e41cffe3b8e428
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/ChartComponent.cs

@@ -0,0 +1,42 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using UnityEngine;
+
+namespace XCharts
+{
+    public class ChartComponent
+    {
+        [SerializeField] protected string m_JsonData;
+        [SerializeField] protected bool m_DataFromJson;
+
+        /// <summary>
+        /// json格式的字符串数据
+        /// </summary>
+        /// <returns></returns>
+        public string jsonData { get { return m_JsonData; } set { m_JsonData = value; ParseJsonData(value); } }
+
+        public void OnAfterDeserialize()
+        {
+            if (m_DataFromJson)
+            {
+                ParseJsonData(m_JsonData);
+                m_DataFromJson = false;
+            }
+        }
+
+        public void OnBeforeSerialize()
+        {
+        }
+
+        public virtual void ParseJsonData(string json)
+        {
+            throw new Exception("no support yet");
+        }
+    }
+}

Scripts/Runtime/Component/ChartComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b0af5e768fe0e407cb5b023b37c41597
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d1d3ce01c4a6f4e3482c1dc22f388889
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Axis.cs

@@ -0,0 +1,794 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    /// <summary>
+    /// The axis in rectangular coordinate.
+    /// 直角坐标系的坐标轴组件。
+    /// </summary>
+    [System.Serializable]
+    public class Axis : MainComponent, IEquatable<Axis>
+    {
+        /// <summary>
+        /// the type of axis.
+        /// 坐标轴类型。
+        /// </summary>
+        public enum AxisType
+        {
+            /// <summary>
+            /// Numerical axis, suitable for continuous data.
+            /// 数值轴，适用于连续数据。
+            /// </summary>
+            Value,
+            /// <summary>
+            /// Category axis, suitable for discrete category data. Data should only be set via data for this type.
+            /// 类目轴，适用于离散的类目数据，为该类型时必须通过 data 设置类目数据。
+            /// </summary>
+            Category
+        }
+
+        /// <summary>
+        /// the type of axis min and max value.
+        /// 坐标轴最大最小刻度显示类型。
+        /// </summary>
+        public enum AxisMinMaxType
+        {
+            /// <summary>
+            /// 0 - maximum.
+            /// 0-最大值。
+            /// </summary>
+            Default,
+            /// <summary>
+            /// minimum - maximum.
+            /// 最小值-最大值。
+            /// </summary>
+            MinMax,
+            /// <summary>
+            /// Customize the minimum and maximum.
+            /// 自定义最小值最大值。
+            /// </summary>
+            Custom
+        }
+
+        /// <summary>
+        /// the type of split line. 
+        /// 分割线类型
+        /// </summary>
+        public enum SplitLineType
+        {
+            /// <summary>
+            /// 不显示分割线
+            /// </summary>
+            None,
+            /// <summary>
+            /// 实线
+            /// </summary>
+            Solid,
+            /// <summary>
+            /// 虚线
+            /// </summary>
+            Dashed,
+            /// <summary>
+            /// 点线
+            /// </summary>
+            Dotted,
+            /// <summary>
+            /// 点划线
+            /// </summary>
+            DashDot,
+            /// <summary>
+            /// 双点划线
+            /// </summary>
+            DashDotDot
+        }
+
+        [SerializeField] protected bool m_Show = true;
+        [SerializeField] protected AxisType m_Type;
+        [SerializeField] protected AxisMinMaxType m_MinMaxType;
+        [SerializeField] protected int m_Min;
+        [SerializeField] protected int m_Max;
+        [SerializeField] protected int m_SplitNumber = 5;
+        [SerializeField] protected float m_Interval = 0;
+        [SerializeField] protected bool m_ShowSplitLine = false;
+        [SerializeField] protected SplitLineType m_SplitLineType = SplitLineType.Dashed;
+        [SerializeField] protected bool m_BoundaryGap = true;
+        [SerializeField] protected int m_MaxCache = 0;
+        [SerializeField] protected List<string> m_Data = new List<string>();
+        [SerializeField] protected AxisLine m_AxisLine = AxisLine.defaultAxisLine;
+        [SerializeField] protected AxisName m_AxisName = AxisName.defaultAxisName;
+        [SerializeField] protected AxisTick m_AxisTick = AxisTick.defaultTick;
+        [SerializeField] protected AxisLabel m_AxisLabel = AxisLabel.defaultAxisLabel;
+        [SerializeField] protected AxisSplitArea m_SplitArea = AxisSplitArea.defaultSplitArea;
+
+        [NonSerialized] private float m_ValueRange;
+        [NonSerialized] private bool m_NeedUpdateFilterData;
+
+        /// <summary>
+        /// Set this to false to prevent the axis from showing.
+        /// 是否显示坐标轴。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// the type of axis. 
+        /// 坐标轴类型。
+        /// </summary>
+        public AxisType type { get { return m_Type; } set { m_Type = value; } }
+        /// <summary>
+        /// the type of axis minmax.
+        /// 坐标轴刻度最大最小值显示类型。
+        /// </summary>
+        public AxisMinMaxType minMaxType { get { return m_MinMaxType; } set { m_MinMaxType = value; } }
+        /// <summary>
+        /// The minimun value of axis.
+        /// 设定的坐标轴刻度最小值，当minMaxType为Custom时有效。
+        /// </summary>
+        public int min { get { return m_Min; } set { m_Min = value; } }
+        /// <summary>
+        /// The maximum value of axis.
+        /// 设定的坐标轴刻度最大值，当minMaxType为Custom时有效。
+        /// </summary>
+        public int max { get { return m_Max; } set { m_Max = value; } }
+        /// <summary>
+        /// Number of segments that the axis is split into.
+        /// 坐标轴的分割段数。
+        /// </summary>
+        public int splitNumber { get { return m_SplitNumber; } set { m_SplitNumber = value; } }
+        /// <summary>
+        /// 强制设置坐标轴分割间隔。无法在类目轴中使用。
+        /// Compulsively set segmentation interval for axis.This is unavailable for category axis.
+        /// </summary>
+        public float interval { get { return m_Interval; } set { m_Interval = value; } }
+        /// <summary>
+        /// showSplitLineSet this to false to prevent the splitLine from showing. value type axes are shown by default, while category type axes are hidden.
+        /// 是否显示分隔线。默认数值轴显示，类目轴不显示。
+        /// </summary>
+        public bool showSplitLine { get { return m_ShowSplitLine; } set { m_ShowSplitLine = value; } }
+        /// <summary>
+        /// the type of split line. 
+        /// 分割线类型。
+        /// </summary>
+        public SplitLineType splitLineType { get { return m_SplitLineType; } set { m_SplitLineType = value; } }
+        /// <summary>
+        /// The boundary gap on both sides of a coordinate axis. 
+        /// 坐标轴两边是否留白。
+        /// </summary>
+        public bool boundaryGap { get { return m_BoundaryGap; } set { m_BoundaryGap = value; } }
+        /// <summary>
+        /// The max number of axis data cache.
+        /// The first data will be remove when the size of axis data is larger then maxCache.
+        /// 可缓存的最大数据量。默认为0没有限制，大于0时超过指定值会移除旧数据再插入新数据。
+        /// </summary>
+        public int maxCache { get { return m_MaxCache; } set { m_MaxCache = value < 0 ? 0 : value; } }
+        /// <summary>
+        /// Category data, available in type: 'Category' axis.
+        /// 类目数据，在类目轴（type: 'category'）中有效。
+        /// </summary>
+        public List<string> data { get { return m_Data; } set { if (value != null) m_Data = value; } }
+        /// <summary>
+        /// axis Line.
+        /// 坐标轴轴线。
+        /// </summary>
+        public AxisLine axisLine { get { return m_AxisLine; } set { m_AxisLine = value; } }
+        /// <summary>
+        /// axis name.
+        /// 坐标轴名称。
+        /// </summary>
+        public AxisName axisName { get { return m_AxisName; } set { m_AxisName = value; } }
+        /// <summary>
+        /// axis tick.
+        /// 坐标轴刻度。
+        /// </summary>
+        public AxisTick axisTick { get { return m_AxisTick; } set { m_AxisTick = value; } }
+        /// <summary>
+        /// axis label.
+        /// 坐标轴刻度标签。
+        /// </summary>
+        public AxisLabel axisLabel { get { return m_AxisLabel; } set { m_AxisLabel = value; } }
+        /// <summary>
+        /// axis split area.
+        /// 坐标轴分割区域。
+        /// </summary>
+        public AxisSplitArea splitArea { get { return m_SplitArea; } set { m_SplitArea = value; } }
+        /// <summary>
+        /// the axis label text list. 
+        /// 坐标轴刻度标签的Text列表。
+        /// </summary>
+        public List<Text> axisLabelTextList { get { return m_AxisLabelTextList; } set { m_AxisLabelTextList = value; } }
+        /// <summary>
+        /// the current minimun value.
+        /// 当前最小值。
+        /// </summary>
+        public float minValue { get; set; }
+        /// <summary>
+        /// the current maximum value.
+        /// 当前最大值。
+        /// </summary>
+        public float maxValue { get; set; }
+        /// <summary>
+        /// the x offset of zero position.
+        /// 坐标轴原点在X轴的偏移。
+        /// </summary>
+        public float zeroXOffset { get; set; }
+        /// <summary>
+        /// the y offset of zero position.
+        /// 坐标轴原点在Y轴的偏移。
+        /// </summary>
+        public float zeroYOffset { get; set; }
+
+        private int filterStart;
+        private int filterEnd;
+        private List<string> filterData;
+        private List<Text> m_AxisLabelTextList = new List<Text>();
+        private GameObject m_TooltipLabel;
+        private Text m_TooltipLabelText;
+        private RectTransform m_TooltipLabelRect;
+
+        public void Copy(Axis other)
+        {
+            m_Show = other.show;
+            m_Type = other.type;
+            m_Min = other.min;
+            m_Max = other.max;
+            m_SplitNumber = other.splitNumber;
+            m_Interval = other.interval;
+
+            m_ShowSplitLine = other.showSplitLine;
+            m_SplitLineType = other.splitLineType;
+            m_BoundaryGap = other.boundaryGap;
+            m_AxisName.Copy(other.axisName);
+            m_AxisLabel.Copy(other.axisLabel);
+            m_Data.Clear();
+            m_Data.Capacity = m_Data.Count;
+            foreach (var d in other.data) m_Data.Add(d);
+        }
+
+        /// <summary>
+        /// 清空类目数据
+        /// </summary>
+        public void ClearData()
+        {
+            m_Data.Clear();
+        }
+
+        /// <summary>
+        /// 当前坐标轴是否时类目轴
+        /// </summary>
+        /// <returns></returns>
+        public bool IsCategory()
+        {
+            return type == AxisType.Category;
+        }
+
+        /// <summary>
+        /// 当前坐标轴是否时数值轴
+        /// </summary>
+        /// <returns></returns>
+        public bool IsValue()
+        {
+            return type == AxisType.Value;
+        }
+
+        /// <summary>
+        /// 添加一个类目到类目数据列表
+        /// </summary>
+        /// <param name="category"></param>
+        public void AddData(string category)
+        {
+            if (maxCache > 0)
+            {
+                while (m_Data.Count > maxCache)
+                {
+                    m_NeedUpdateFilterData = true;
+                    m_Data.RemoveAt(0);
+                }
+            }
+            m_Data.Add(category);
+        }
+
+        /// <summary>
+        /// 获得在dataZoom范围内指定索引的类目数据
+        /// </summary>
+        /// <param name="index">类目数据索引</param>
+        /// <param name="dataZoom">区域缩放</param>
+        /// <returns></returns>
+        public string GetData(int index, DataZoom dataZoom)
+        {
+            var showData = GetDataList(dataZoom);
+            if (index >= 0 && index < showData.Count)
+                return showData[index];
+            else
+                return "";
+        }
+
+        /// <summary>
+        /// 获得指定区域缩放的类目数据列表
+        /// </summary>
+        /// <param name="dataZoom">区域缩放</param>
+        /// <returns></returns>
+        public List<string> GetDataList(DataZoom dataZoom)
+        {
+            if (dataZoom != null && dataZoom.enable)
+            {
+                UpdateFilterData(dataZoom);
+                return filterData;
+            }
+            else
+            {
+                return m_Data;
+            }
+        }
+
+        private List<string> emptyFliter = new List<string>();
+        /// <summary>
+        /// 更新dataZoom对应的类目数据列表
+        /// </summary>
+        /// <param name="dataZoom"></param>
+        public void UpdateFilterData(DataZoom dataZoom)
+        {
+            if (dataZoom != null && dataZoom.enable)
+            {
+                var startIndex = (int)((data.Count - 1) * dataZoom.start / 100);
+                var endIndex = (int)((data.Count - 1) * dataZoom.end / 100);
+                if (startIndex != filterStart || endIndex != filterEnd || m_NeedUpdateFilterData)
+                {
+                    filterStart = startIndex;
+                    filterEnd = endIndex;
+                    m_NeedUpdateFilterData = false;
+                    if (m_Data.Count > 0)
+                    {
+                        var count = endIndex == startIndex ? 1 : endIndex - startIndex + 1;
+                        filterData = m_Data.GetRange(startIndex, count);
+                    }
+                    else
+                    {
+                        filterData = m_Data;
+                    }
+                }
+                else if (endIndex == 0)
+                {
+                    filterData = emptyFliter;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 获得分割段数
+        /// </summary>
+        /// <param name="dataZoom"></param>
+        /// <returns></returns>
+        public int GetSplitNumber(float coordinateWid, DataZoom dataZoom)
+        {
+            if (type == AxisType.Value)
+            {
+                if (m_Interval > 0)
+                {
+                    if (coordinateWid <= 0) return 0;
+                    int num = Mathf.CeilToInt(m_ValueRange / m_Interval) + 1;
+                    int maxNum = Mathf.CeilToInt(coordinateWid / 15);
+                    if (num > maxNum)
+                    {
+                        m_Interval = m_ValueRange / (maxNum - 1);
+                        num = Mathf.CeilToInt(m_ValueRange / m_Interval) + 1;
+                    }
+                    return num;
+                }
+                else return m_SplitNumber;
+            }
+            int dataCount = GetDataList(dataZoom).Count;
+            if (m_SplitNumber <= 0) return dataCount;
+            if (dataCount > 2 * m_SplitNumber || dataCount <= 0)
+                return m_SplitNumber;
+            else
+                return dataCount;
+        }
+
+        /// <summary>
+        /// 获得分割段的宽度
+        /// </summary>
+        /// <param name="coordinateWidth"></param>
+        /// <param name="dataZoom"></param>
+        /// <returns></returns>
+        public float GetSplitWidth(float coordinateWidth, DataZoom dataZoom)
+        {
+            int split = GetSplitNumber(coordinateWidth, dataZoom);
+            int segment = (m_BoundaryGap ? split : split - 1);
+            segment = segment <= 0 ? 1 : segment;
+            return coordinateWidth / segment;
+        }
+
+        /// <summary>
+        /// 获得类目数据个数
+        /// </summary>
+        /// <param name="dataZoom"></param>
+        /// <returns></returns>
+        public int GetDataNumber(DataZoom dataZoom)
+        {
+            return GetDataList(dataZoom).Count;
+        }
+
+        /// <summary>
+        /// 获得一个类目数据在坐标系中代表的宽度
+        /// </summary>
+        /// <param name="coordinateWidth"></param>
+        /// <param name="dataZoom"></param>
+        /// <returns></returns>
+        public float GetDataWidth(float coordinateWidth, DataZoom dataZoom)
+        {
+            var dataCount = GetDataNumber(dataZoom);
+            int segment = (m_BoundaryGap ? dataCount : dataCount - 1);
+            segment = segment <= 0 ? 1 : segment;
+            return coordinateWidth / segment;
+        }
+
+        /// <summary>
+        /// 获得标签显示的名称
+        /// </summary>
+        /// <param name="index"></param>
+        /// <param name="minValue"></param>
+        /// <param name="maxValue"></param>
+        /// <param name="dataZoom"></param>
+        /// <returns></returns>
+        public string GetLabelName(float coordinateWidth, int index, float minValue, float maxValue,
+            DataZoom dataZoom, bool forcePercent)
+        {
+            int split = GetSplitNumber(coordinateWidth, dataZoom);
+            if (m_Type == AxisType.Value)
+            {
+                float value = 0;
+                if (forcePercent) maxValue = 100;
+                if (m_Interval > 0)
+                {
+                    if (index == split - 1) value = maxValue;
+                    else value = minValue + index * m_Interval;
+                }
+                else
+                {
+                    value = (minValue + (maxValue - minValue) * index / (split - 1));
+                }
+                if (forcePercent) return string.Format("{0}%", (int)value);
+                else return m_AxisLabel.GetFormatterContent(value);
+            }
+            var showData = GetDataList(dataZoom);
+            int dataCount = showData.Count;
+            if (dataCount <= 0) return "";
+
+            if (index == split - 1 && !m_BoundaryGap)
+            {
+                return m_AxisLabel.GetFormatterContent(showData[dataCount - 1]);
+            }
+            else
+            {
+                float rate = dataCount / split;
+                if (rate < 1) rate = 1;
+                int offset = m_BoundaryGap ? (int)(rate / 2) : 0;
+                int newIndex = (int)(index * rate >= dataCount - 1 ?
+                    dataCount - 1 : offset + index * rate);
+                return m_AxisLabel.GetFormatterContent(showData[newIndex]);
+            }
+        }
+
+        /// <summary>
+        /// 获得分割线条数
+        /// </summary>
+        /// <param name="dataZoom"></param>
+        /// <returns></returns>
+        public int GetScaleNumber(float coordinateWidth, DataZoom dataZoom)
+        {
+            if (type == AxisType.Value)
+            {
+                int splitNum = GetSplitNumber(coordinateWidth, dataZoom);
+                return m_BoundaryGap ? splitNum + 1 : splitNum;
+            }
+            else
+            {
+                var showData = GetDataList(dataZoom);
+                int dataCount = showData.Count;
+                if (m_SplitNumber <= 0) return m_BoundaryGap ? dataCount + 1 : dataCount;
+                if (dataCount > 2 * splitNumber || dataCount <= 0)
+                    return m_BoundaryGap ? m_SplitNumber + 1 : m_SplitNumber;
+                else
+                    return m_BoundaryGap ? dataCount + 1 : dataCount;
+            }
+        }
+
+        /// <summary>
+        /// 获得分割段宽度
+        /// </summary>
+        /// <param name="coordinateWidth"></param>
+        /// <param name="dataZoom"></param>
+        /// <returns></returns>
+        public float GetScaleWidth(float coordinateWidth, int index, DataZoom dataZoom)
+        {
+            int num = GetScaleNumber(coordinateWidth, dataZoom) - 1;
+            if (num <= 0) num = 1;
+            if (type == AxisType.Value && m_Interval > 0)
+            {
+                if (index == num - 1) return coordinateWidth - (num - 1) * m_Interval * coordinateWidth / m_ValueRange;
+                else return m_Interval * coordinateWidth / m_ValueRange;
+            }
+            else
+            {
+                return coordinateWidth / num;
+            }
+
+        }
+
+        /// <summary>
+        /// 更新刻度标签文字
+        /// </summary>
+        /// <param name="dataZoom"></param>
+        public void UpdateLabelText(float coordinateWidth, DataZoom dataZoom, bool forcePercent)
+        {
+            for (int i = 0; i < axisLabelTextList.Count; i++)
+            {
+                if (axisLabelTextList[i] != null)
+                {
+                    axisLabelTextList[i].text = GetLabelName(coordinateWidth, i, minValue, maxValue, dataZoom, forcePercent);
+                }
+            }
+        }
+
+        public void SetTooltipLabel(GameObject label)
+        {
+            m_TooltipLabel = label;
+            m_TooltipLabelRect = label.GetComponent<RectTransform>();
+            m_TooltipLabelText = label.GetComponentInChildren<Text>();
+            m_TooltipLabel.SetActive(true);
+        }
+
+        public void SetTooltipLabelColor(Color bgColor, Color textColor)
+        {
+            m_TooltipLabel.GetComponent<Image>().color = bgColor;
+            m_TooltipLabelText.color = textColor;
+        }
+
+        public void SetTooltipLabelActive(bool flag)
+        {
+            if (m_TooltipLabel && m_TooltipLabel.activeInHierarchy != flag)
+            {
+                m_TooltipLabel.SetActive(flag);
+            }
+        }
+
+        public void UpdateTooptipLabelText(string text)
+        {
+            if (m_TooltipLabelText)
+            {
+                m_TooltipLabelText.text = text;
+                m_TooltipLabelRect.sizeDelta = new Vector2(m_TooltipLabelText.preferredWidth + 8,
+                    m_TooltipLabelText.preferredHeight + 8);
+            }
+        }
+
+        public void UpdateTooltipLabelPos(Vector2 pos)
+        {
+            if (m_TooltipLabel)
+            {
+                m_TooltipLabel.transform.localPosition = pos;
+            }
+        }
+
+        /// <summary>
+        /// 调整最大最小值
+        /// </summary>
+        /// <param name="minValue"></param>
+        /// <param name="maxValue"></param>
+        public void AdjustMinMaxValue(ref int minValue, ref int maxValue)
+        {
+            if (minMaxType == Axis.AxisMinMaxType.Custom)
+            {
+                if (min != 0 || max != 0)
+                {
+                    minValue = min;
+                    maxValue = max;
+                }
+            }
+            else
+            {
+                switch (minMaxType)
+                {
+                    case Axis.AxisMinMaxType.Default:
+                        if (minValue > 0 && maxValue > 0)
+                        {
+                            minValue = 0;
+                            maxValue = ChartHelper.GetMaxDivisibleValue(maxValue);
+                        }
+                        else if (minValue < 0 && maxValue < 0)
+                        {
+                            minValue = ChartHelper.GetMinDivisibleValue(minValue);
+                            maxValue = 0;
+                        }
+                        else
+                        {
+                            minValue = ChartHelper.GetMinDivisibleValue(minValue);
+                            maxValue = ChartHelper.GetMaxDivisibleValue(maxValue);
+                        }
+                        break;
+                    case Axis.AxisMinMaxType.MinMax:
+                        minValue = ChartHelper.GetMinDivisibleValue(minValue);
+                        maxValue = ChartHelper.GetMaxDivisibleValue(maxValue);
+                        break;
+                }
+            }
+            m_ValueRange = maxValue - minValue;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+            else if (obj is Axis)
+            {
+                return Equals((Axis)obj);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool Equals(Axis other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+            return show == other.show &&
+                type == other.type &&
+                min == other.min &&
+                max == other.max &&
+                splitNumber == other.splitNumber &&
+                interval == other.interval &&
+                showSplitLine == other.showSplitLine &&
+                m_AxisLabel.Equals(other.axisLabel) &&
+                splitLineType == other.splitLineType &&
+                boundaryGap == other.boundaryGap &&
+                axisName.Equals(other.axisName) &&
+                ChartHelper.IsValueEqualsList<string>(m_Data, other.data);
+        }
+
+        public static bool operator ==(Axis left, Axis right)
+        {
+            if (ReferenceEquals(left, null) && ReferenceEquals(right, null))
+            {
+                return true;
+            }
+            else if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
+            {
+                return false;
+            }
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(Axis left, Axis right)
+        {
+            return !(left == right);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        public override void ParseJsonData(string jsonData)
+        {
+            if (string.IsNullOrEmpty(jsonData) || !m_DataFromJson) return;
+            m_Data = ChartHelper.ParseStringFromString(jsonData);
+        }
+    }
+
+    /// <summary>
+    /// The x axis in cartesian(rectangular) coordinate. a grid component can place at most 2 x axis, 
+    /// one on the bottom and another on the top.
+    /// <para>直角坐标系 grid 中的 x 轴，单个 grid 组件最多只能放上下两个 x 轴。</para>
+    /// </summary>
+    [System.Serializable]
+    public class XAxis : Axis
+    {
+        public XAxis Clone()
+        {
+            var axis = XAxisPool.Get();
+            axis.show = show;
+            axis.type = type;
+            axis.min = min;
+            axis.max = max;
+            axis.splitNumber = splitNumber;
+            axis.interval = interval;
+
+            axis.showSplitLine = showSplitLine;
+            axis.splitLineType = splitLineType;
+            axis.boundaryGap = boundaryGap;
+            axis.axisName.Copy(axisName);
+            axis.axisLabel.Copy(axisLabel);
+            axis.data.Clear();
+            if (axis.data.Capacity < data.Count) axis.data.Capacity = data.Count;
+            foreach (var d in data) axis.data.Add(d);
+            return axis;
+        }
+
+        public static XAxis defaultXAxis
+        {
+            get
+            {
+                var axis = new XAxis
+                {
+                    m_Show = true,
+                    m_Type = AxisType.Category,
+                    m_Min = 0,
+                    m_Max = 0,
+                    m_SplitNumber = 5,
+                    m_ShowSplitLine = false,
+                    m_SplitLineType = SplitLineType.Dashed,
+                    m_BoundaryGap = true,
+                    m_Data = new List<string>()
+                    {
+                        "x1","x2","x3","x4","x5"
+                    }
+                };
+                return axis;
+            }
+        }
+    }
+
+    /// <summary>
+    /// The x axis in cartesian(rectangular) coordinate. a grid component can place at most 2 x axis, 
+    /// one on the bottom and another on the top.
+    /// <para>直角坐标系 grid 中的 y 轴，单个 grid 组件最多只能放左右两个 y 轴</para>
+    /// </summary>
+    [System.Serializable]
+    public class YAxis : Axis
+    {
+        public YAxis Clone()
+        {
+            var axis = YAxisPool.Get();
+            axis.show = show;
+            axis.type = type;
+            axis.min = min;
+            axis.max = max;
+            axis.splitNumber = splitNumber;
+            axis.interval = interval;
+
+            axis.showSplitLine = showSplitLine;
+            axis.splitLineType = splitLineType;
+            axis.boundaryGap = boundaryGap;
+            axis.axisName.Copy(axisName);
+            axis.axisLabel.Copy(axisLabel);
+            axis.data.Clear();
+            if (axis.data.Capacity < data.Count) axis.data.Capacity = data.Count;
+            foreach (var d in data) axis.data.Add(d);
+            return axis;
+        }
+
+        public static YAxis defaultYAxis
+        {
+            get
+            {
+                var axis = new YAxis
+                {
+                    m_Show = true,
+                    m_Type = AxisType.Value,
+                    m_Min = 0,
+                    m_Max = 0,
+                    m_SplitNumber = 5,
+                    m_ShowSplitLine = true,
+                    m_SplitLineType = SplitLineType.Dashed,
+                    m_BoundaryGap = false,
+                    m_Data = new List<string>(5),
+                };
+                return axis;
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Main/Axis.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f4e87b6a821d94304af45b2955c293bb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/DataZoom.cs

@@ -0,0 +1,346 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    /// <summary>
+    /// DataZoom component is used for zooming a specific area,
+    /// which enables user to investigate data in detail,
+    /// or get an overview of the data, or get rid of outlier points.
+    /// <para>DataZoom 组件 用于区域缩放，从而能自由关注细节的数据信息，或者概览数据整体，或者去除离群点的影响。</para>
+    /// </summary>
+    [System.Serializable]
+    public class DataZoom : MainComponent
+    {
+        /// <summary>
+        /// Generally dataZoom component zoom or roam coordinate system through data filtering
+        /// and set the windows of axes internally.
+        /// Its behaviours vary according to filtering mode settings.
+        /// dataZoom 的运行原理是通过 数据过滤 来达到 数据窗口缩放 的效果。数据过滤模式的设置不同，效果也不同。
+        /// </summary>
+        public enum FilterMode
+        {
+            /// <summary>
+            /// data that outside the window will be filtered, which may lead to some changes of windows of other axes.
+            /// For each data item, it will be filtered if one of the relevant dimensions is out of the window.
+            /// 当前数据窗口外的数据，被 过滤掉。即 会 影响其他轴的数据范围。每个数据项，只要有一个维度在数据窗口外，整个数据项就会被过滤掉。
+            /// </summary>
+            Filter,
+            /// <summary>
+            /// data that outside the window will be filtered, which may lead to some changes of windows of other axes.
+            /// For each data item, it will be filtered only if all of the relevant dimensions are out of the same side of the window.
+            /// 当前数据窗口外的数据，被 过滤掉。即 会 影响其他轴的数据范围。每个数据项，只有当全部维度都在数据窗口同侧外部，整个数据项才会被过滤掉。
+            /// </summary>
+            WeakFilter,
+            /// <summary>
+            /// data that outside the window will be set to NaN, which will not lead to changes of windows of other axes. 
+            /// 当前数据窗口外的数据，被 设置为空。即 不会 影响其他轴的数据范围。
+            /// </summary>
+            Empty,
+            /// <summary>
+            /// Do not filter data.
+            /// 不过滤数据，只改变数轴范围。
+            /// </summary>
+            None
+        }
+        /// <summary>
+        /// The value type of start and end.取值类型
+        /// </summary>
+        public enum RangeMode
+        {
+            //Value,
+            /// <summary>
+            /// percent value. 百分比
+            /// </summary>
+            Percent
+        }
+        [SerializeField] private bool m_Enable;
+        [SerializeField] private FilterMode m_FilterMode;
+        [SerializeField] private int m_XAxisIndex;
+        [SerializeField] private int m_YAxisIndex;
+        [SerializeField] private bool m_SupportInside;
+        [SerializeField] private bool m_SupportSlider;
+        [SerializeField] private bool m_SupportSelect;
+        [SerializeField] private bool m_ShowDataShadow;
+        [SerializeField] private bool m_ShowDetail;
+        [SerializeField] private bool m_ZoomLock;
+        [SerializeField] private bool m_Realtime;
+        [SerializeField] private Color m_BackgroundColor;
+        [SerializeField] private float m_Height;
+        [SerializeField] private float m_Bottom;
+        [SerializeField] private RangeMode m_RangeMode;
+        [SerializeField] private float m_Start;
+        [SerializeField] private float m_End;
+        [SerializeField] private float m_StartValue;
+        [SerializeField] private float m_EndValue;
+        [Range(1f, 20f)]
+        [SerializeField] private float m_ScrollSensitivity = 1.1f;
+        [SerializeField] private int m_FontSize = 18;
+        [SerializeField] private FontStyle m_FontStyle;
+
+        /// <summary>
+        /// Whether to show dataZoom. 
+        /// 是否显示缩放区域。
+        /// </summary>
+        public bool enable { get { return m_Enable; } set { m_Enable = value; } }
+        /// <summary>
+        /// The mode of data filter. 
+        /// 数据过滤类型。
+        /// </summary>
+        public FilterMode filterMode { get { return m_FilterMode; } set { m_FilterMode = value; } }
+        /// <summary>
+        /// Specify which xAxis is controlled by the dataZoom. 
+        /// 控制哪一个 x 轴。
+        /// </summary>
+        public int xAxisIndex { get { return m_XAxisIndex; } set { m_XAxisIndex = value; } }
+        /// <summary>
+        /// Specify which yAxis is controlled by the dataZoom. 
+        /// 控制哪一个 y 轴。
+        /// </summary>
+        public int yAxisIndex { get { return m_YAxisIndex; } set { m_YAxisIndex = value; } }
+        /// <summary>
+        /// 是否支持内置。内置于坐标系中，使用户可以在坐标系上通过鼠标拖拽、鼠标滚轮、手指滑动（触屏上）来缩放或漫游坐标系。
+        /// </summary>
+        public bool supportInside { get { return m_SupportInside; } set { m_SupportInside = value; } }
+        /// <summary>
+        /// 是否支持滑动条。有单独的滑动条，用户在滑动条上进行缩放或漫游。
+        /// </summary>
+        public bool supportSlider { get { return m_SupportSlider; } set { m_SupportSlider = value; } }
+        /// <summary>
+        /// 是否支持框选。提供一个选框进行数据区域缩放。
+        /// </summary>
+        private bool supportSelect { get { return m_SupportSelect; } set { m_SupportSelect = value; } }
+        /// <summary>
+        /// Whether to show data shadow, to indicate the data tendency in brief.
+        /// default:true
+        /// 是否显示数据阴影。数据阴影可以简单地反应数据走势。
+        /// </summary>
+        public bool showDataShadow { get { return m_ShowDataShadow; } set { m_ShowDataShadow = value; } }
+        /// <summary>
+        /// Whether to show detail, that is, show the detailed data information when dragging.
+        /// 是否显示detail，即拖拽时候显示详细数值信息。
+        /// </summary>
+        public bool showDetail { get { return m_ShowDetail; } set { m_ShowDetail = value; } }
+        /// <summary>
+        /// Specify whether to lock the size of window (selected area).
+        /// default:false
+        /// 是否锁定选择区域（或叫做数据窗口）的大小。
+        /// 如果设置为 true 则锁定选择区域的大小，也就是说，只能平移，不能缩放。
+        /// </summary>
+        public bool zoomLock { get { return m_ZoomLock; } set { m_ZoomLock = value; } }
+        /// <summary>
+        /// Whether to show data shadow in dataZoom-silder component, to indicate the data tendency in brief.
+        /// default:true
+        /// 拖动时，是否实时更新系列的视图。如果设置为 false，则只在拖拽结束的时候更新。默认为true，暂不支持修改。
+        /// </summary>
+        public bool realtime { get { return true; } }
+        /// <summary>
+        /// The background color of the component.
+        /// 组件的背景颜色。
+        /// </summary>
+        private Color backgroundColor { get { return m_BackgroundColor; } set { m_BackgroundColor = value; } }
+        /// <summary>
+        /// Distance between dataZoom component and the bottom side of the container.
+        /// bottom value is a instant pixel value like 10.
+        /// default:10
+        /// 组件离容器下侧的距离。
+        /// </summary>
+        public float bottom { get { return m_Bottom; } set { m_Bottom = value; } }
+        /// <summary>
+        /// The height of dataZoom component.
+        /// height value is a instant pixel value like 10.
+        /// default:50
+        /// 组件高度。
+        /// </summary>
+        public float height { get { return m_Height; } set { m_Height = value; } }
+        /// <summary>
+        /// Use absolute value or percent value in DataZoom.start and DataZoom.end.
+        /// default:RangeMode.Percent.
+        /// 取绝对值还是百分比。
+        /// </summary>
+        public RangeMode rangeMode { get { return m_RangeMode; } set { m_RangeMode = value; } }
+        /// <summary>
+        /// The start percentage of the window out of the data extent, in the range of 0 ~ 100.
+        /// default:30
+        /// 数据窗口范围的起始百分比。范围是：0 ~ 100。
+        /// </summary>
+        public float start
+        {
+            get { return m_Start; }
+            set { m_Start = value; if (m_Start < 0) m_Start = 0; if (m_Start > 100) m_Start = 100; }
+        }
+        /// <summary>
+        /// The end percentage of the window out of the data extent, in the range of 0 ~ 100.
+        /// default:70
+        /// 数据窗口范围的结束百分比。范围是：0 ~ 100。
+        /// </summary>
+        public float end
+        {
+            get { return m_End; }
+            set { m_End = value; if (m_End < 0) m_End = 0; if (m_End > 100) m_End = 100; }
+        }
+        /// <summary>
+        /// The sensitivity of dataZoom scroll.
+        /// The larger the number, the more sensitive it is.
+        /// default:10
+        /// 缩放区域组件的敏感度。值越高每次缩放所代表的数据越多。
+        /// </summary>
+        public float scrollSensitivity { get { return m_ScrollSensitivity; } set { m_ScrollSensitivity = value; } }
+        /// <summary>
+        /// font size.
+        /// 文字的字体大小。
+        /// </summary>
+        public int fontSize { get { return m_FontSize; } set { m_FontSize = value; } }
+        /// <summary>
+        /// font style.
+        /// 文字字体的风格。
+        /// </summary>
+        public FontStyle fontStyle { get { return m_FontStyle; } set { m_FontStyle = value; } }
+
+        /// <summary>
+        /// The start label.
+        /// 组件的开始信息文本。
+        /// </summary>
+        public Text startLabel { get; set; }
+        /// <summary>
+        /// The end label.
+        /// 组件的结束信息文本。
+        /// </summary>
+        public Text endLabel { get; set; }
+
+        public static DataZoom defaultDataZoom
+        {
+            get
+            {
+                return new DataZoom()
+                {
+                    filterMode = FilterMode.None,
+                    xAxisIndex = 0,
+                    yAxisIndex = 0,
+                    showDataShadow = true,
+                    showDetail = false,
+                    zoomLock = false,
+                    m_Height = 0,
+                    m_Bottom = 10,
+                    rangeMode = RangeMode.Percent,
+                    start = 30,
+                    end = 70,
+                    m_ScrollSensitivity = 10,
+                };
+            }
+        }
+
+        /// <summary>
+        /// 给定的坐标是否在缩放区域内
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <param name="startX"></param>
+        /// <param name="width"></param>
+        /// <returns></returns>
+        public bool IsInZoom(Vector2 pos, float startX, float width)
+        {
+            Rect rect = Rect.MinMaxRect(startX, m_Bottom, startX + width, m_Bottom + m_Height);
+            return rect.Contains(pos);
+        }
+
+        /// <summary>
+        /// 给定的坐标是否在选中区域内
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <param name="startX"></param>
+        /// <param name="width"></param>
+        /// <returns></returns>
+        public bool IsInSelectedZoom(Vector2 pos, float startX, float width)
+        {
+            var start = startX + width * m_Start / 100;
+            var end = startX + width * m_End / 100;
+            Rect rect = Rect.MinMaxRect(start, m_Bottom, end, m_Bottom + m_Height);
+            return rect.Contains(pos);
+        }
+
+        /// <summary>
+        /// 给定的坐标是否在开始活动条触发区域内
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <param name="startX"></param>
+        /// <param name="width"></param>
+        /// <returns></returns>
+        public bool IsInStartZoom(Vector2 pos, float startX, float width)
+        {
+            var start = startX + width * m_Start / 100;
+            Rect rect = Rect.MinMaxRect(start - 10, m_Bottom, start + 10, m_Bottom + m_Height);
+            return rect.Contains(pos);
+        }
+
+        /// <summary>
+        /// 给定的坐标是否在结束活动条触发区域内
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <param name="startX"></param>
+        /// <param name="width"></param>
+        /// <returns></returns>
+        public bool IsInEndZoom(Vector2 pos, float startX, float width)
+        {
+            var end = startX + width * m_End / 100;
+            Rect rect = Rect.MinMaxRect(end - 10, m_Bottom, end + 10, m_Bottom + m_Height);
+            return rect.Contains(pos);
+        }
+
+        /// <summary>
+        /// 是否显示文本
+        /// </summary>
+        /// <param name="flag"></param>
+        public void SetLabelActive(bool flag)
+        {
+            if (startLabel && startLabel.gameObject.activeInHierarchy != flag)
+            {
+                startLabel.gameObject.SetActive(flag);
+            }
+            if (endLabel && endLabel.gameObject.activeInHierarchy != flag)
+            {
+                endLabel.gameObject.SetActive(flag);
+            }
+        }
+
+        /// <summary>
+        /// 设置开始文本内容
+        /// </summary>
+        /// <param name="text"></param>
+        public void SetStartLabelText(string text)
+        {
+            if (startLabel) startLabel.text = text;
+        }
+
+        /// <summary>
+        /// 设置结束文本内容
+        /// </summary>
+        /// <param name="text"></param>
+        public void SetEndLabelText(string text)
+        {
+            if (endLabel) endLabel.text = text;
+        }
+
+        /// <summary>
+        /// 获取DataZoom的高，当height设置为0时，自动计算合适的偏移。
+        /// </summary>
+        /// <param name="gridBottom"></param>
+        /// <returns></returns>
+        public float GetHeight(float gridBottom)
+        {
+            if (height <= 0)
+            {
+                height = gridBottom - bottom - 30;
+                if (height < 10) height = 10;
+                return height;
+            }
+            else return height;
+        }
+    }
+}

Scripts/Runtime/Component/Main/DataZoom.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c2aa26f9acb5344a59c924a1f23f90d5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Grid.cs

@@ -0,0 +1,143 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Grid component.
+    /// Drawing grid in rectangular coordinate. In a single grid, at most two X and Y axes each is allowed. 
+    /// Line chart, bar chart, and scatter chart can be drawn in grid.
+    /// There is only one single grid component at most in a single echarts instance.
+    /// <para>
+    /// 网格组件。
+    /// 直角坐标系内绘图网格，单个 grid 内最多可以放置上下两个 X 轴，左右两个 Y 轴。可以在网格上绘制折线图，柱状图，散点图。
+    /// 单个xcharts实例中只能存在一个grid组件。
+    /// </para>
+    /// </summary>
+    [Serializable]
+    public class Grid : MainComponent, IEquatable<Grid>
+    {
+        [SerializeField] private bool m_Show = true;
+        [SerializeField] private float m_Left;
+        [SerializeField] private float m_Right;
+        [SerializeField] private float m_Top;
+        [SerializeField] private float m_Bottom;
+        [SerializeField] private Color m_BackgroundColor;
+
+        /// <summary>
+        /// Whether to show the grid in rectangular coordinate.
+        /// 是否显示直角坐标系网格。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// Distance between grid component and the left side of the container.
+        /// grid 组件离容器左侧的距离。
+        /// </summary>
+        public float left { get { return m_Left; } set { m_Left = value; } }
+        /// <summary>
+        /// Distance between grid component and the right side of the container.
+        /// grid 组件离容器右侧的距离。
+        /// </summary>
+        public float right { get { return m_Right; } set { m_Right = value; } }
+        /// <summary>
+        /// Distance between grid component and the top side of the container.
+        /// grid 组件离容器上侧的距离。
+        /// </summary>
+        public float top { get { return m_Top; } set { m_Top = value; } }
+        /// <summary>
+        /// Distance between grid component and the bottom side of the container.
+        /// grid 组件离容器下侧的距离。
+        /// </summary>
+        public float bottom { get { return m_Bottom; } set { m_Bottom = value; } }
+        /// <summary>
+        /// Background color of grid, which is transparent by default.
+        /// 网格背景色，默认透明。
+        /// </summary>
+        public Color backgroundColor { get { return m_BackgroundColor; } set { m_BackgroundColor = value; } }
+
+        public static Grid defaultGrid
+        {
+            get
+            {
+                var coordinate = new Grid
+                {
+                    m_Show = true,
+                    m_Left = 50,
+                    m_Right = 30,
+                    m_Top = 50,
+                    m_Bottom = 30
+                };
+                return coordinate;
+            }
+        }
+        public void Copy(Grid other)
+        {
+            m_Show = other.show;
+            m_Left = other.left;
+            m_Right = other.right;
+            m_Top = other.top;
+            m_Bottom = other.bottom;
+            m_BackgroundColor = other.backgroundColor;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+            else if (obj is Grid)
+            {
+                return Equals((Grid)obj);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool Equals(Grid other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+            return m_Show == other.show &&
+                m_Left == other.left &&
+                m_Right == other.right &&
+                m_Top == other.top &&
+                m_Bottom == other.bottom &&
+                ChartHelper.IsValueEqualsColor(m_BackgroundColor, other.backgroundColor);
+        }
+
+        public static bool operator ==(Grid left, Grid right)
+        {
+            if (ReferenceEquals(left, null) && ReferenceEquals(right, null))
+            {
+                return true;
+            }
+            else if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
+            {
+                return false;
+            }
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(Grid left, Grid right)
+        {
+            return !(left == right);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+    }
+}

Scripts/Runtime/Component/Main/Grid.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5420ab107823641e49c2df9e3556ea30
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Legend.cs

@@ -0,0 +1,397 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    /// <summary>
+    /// 图例组件。
+    /// 图例组件展现了不同系列的标记，颜色和名字。可以通过点击图例控制哪些系列不显示。
+    /// </summary>
+    [System.Serializable]
+    public class Legend : MainComponent, IPropertyChanged, IEquatable<Legend>
+    {
+        /// <summary>
+        /// Selected mode of legend, which controls whether series can be toggled displaying by clicking legends. 
+        /// It is enabled by default, and you may set it to be false to disabled it.
+        /// 图例选择的模式，控制是否可以通过点击图例改变系列的显示状态。默认开启图例选择，可以设成 None 关闭。
+        /// </summary>
+        public enum SelectedMode
+        {
+            /// <summary>
+            /// 多选。
+            /// </summary>
+            Multiple,
+            /// <summary>
+            /// 单选。
+            /// </summary>
+            Single,
+            /// <summary>
+            /// 无法选择。
+            /// </summary>
+            None
+        }
+        [SerializeField] private bool m_Show = true;
+        [SerializeField] private SelectedMode m_SelectedMode;
+        [SerializeField] private Orient m_Orient = Orient.Horizonal;
+        [SerializeField] private Location m_Location = Location.defaultRight;
+        [SerializeField] private float m_ItemWidth = 50.0f;
+        [SerializeField] private float m_ItemHeight = 20.0f;
+        [SerializeField] private float m_ItemGap = 5;
+        [SerializeField] private int m_ItemFontSize = 18;
+        [SerializeField] private string m_Formatter;
+        [SerializeField] private List<string> m_Data = new List<string>();
+
+        private Dictionary<string, Button> m_DataBtnList = new Dictionary<string, Button>();
+
+        /// <summary>
+        /// Whether to show legend component. 
+        /// 是否显示图例组件。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// Selected mode of legend, which controls whether series can be toggled displaying by clicking legends. 
+        /// 选择模式。控制是否可以通过点击图例改变系列的显示状态。默认开启图例选择，可以设成 None 关闭。
+        /// </summary>
+        /// <value></value>
+        public SelectedMode selectedMode { get { return m_SelectedMode; } set { m_SelectedMode = value; } }
+        /// <summary>
+        /// Specify whether the layout of legend component is horizontal or vertical. 
+        /// 布局方式是横还是竖。
+        /// </summary>
+        public Orient orient { get { return m_Orient; } set { m_Orient = value; } }
+        /// <summary>
+        /// The location of legend.
+        /// 图例显示的位置。
+        /// </summary>
+        public Location location { get { return m_Location; } set { m_Location = value; } }
+        /// <summary>
+        /// the width of legend item.
+        /// 每个图例项的宽度。
+        /// </summary>
+        public float itemWidth { get { return m_ItemWidth; } set { m_ItemWidth = value; } }
+        /// <summary>
+        /// the height of legend item.
+        /// 每个图例项的高度。
+        /// </summary>
+        public float itemHeight { get { return m_ItemHeight; } set { m_ItemHeight = value; } }
+        /// <summary>
+        /// The distance between each legend, horizontal distance in horizontal layout, and vertical distance in vertical layout.
+        /// 图例每项之间的间隔。横向布局时为水平间隔，纵向布局时为纵向间隔。
+        /// </summary>
+        public float itemGap { get { return m_ItemGap; } set { m_ItemGap = value; } }
+        /// <summary>
+        /// font size of item text.
+        /// 图例项的字体大小。
+        /// </summary>
+        public int itemFontSize { get { return m_ItemFontSize; } set { m_ItemFontSize = value; } }
+        /// <summary>
+        /// 图例内容字符串模版格式器。支持用 \n 换行。
+        /// 模板变量为图例名称 {name}
+        /// </summary>
+        public string formatter { get { return m_Formatter; } set { m_Formatter = value; } }
+        /// <summary>
+        /// Data array of legend. An array item is usually a name representing string. (If it is a pie chart, 
+        /// it could also be the name of a single data in the pie chart) of a series. 
+        /// If data is not specified, it will be auto collected from series. 
+        /// 图例的数据数组。数组项通常为一个字符串，每一项代表一个系列的 name（如果是饼图，也可以是饼图单个数据的 name）。
+        /// 如果 data 没有被指定，会自动从当前系列中获取。指定data时里面的数据项和serie匹配时才会生效。
+        /// </summary>
+        public List<string> data { get { return m_Data; } }
+        /// <summary>
+        /// the button list of legend.
+        /// 图例按钮列表。
+        /// </summary>
+        /// <value></value>
+        public Dictionary<string, Button> buttonList { get { return m_DataBtnList; } }
+
+        /// <summary>
+        /// 一个在顶部居中显示的默认图例。
+        /// </summary>
+        public static Legend defaultLegend
+        {
+            get
+            {
+                var legend = new Legend
+                {
+                    m_Show = false,
+                    m_SelectedMode = SelectedMode.Multiple,
+                    m_Orient = Orient.Horizonal,
+                    m_Location = Location.defaultTop,
+                    m_ItemWidth = 60.0f,
+                    m_ItemHeight = 20.0f,
+                    m_ItemGap = 5,
+                    m_ItemFontSize = 16
+                };
+                legend.location.top = 30;
+                return legend;
+            }
+        }
+        public void Copy(Legend legend)
+        {
+            m_Show = legend.show;
+            m_SelectedMode = legend.selectedMode;
+            m_Orient = legend.orient;
+            m_Location.Copy(legend.location);
+            m_ItemWidth = legend.itemWidth;
+            m_ItemHeight = legend.itemHeight;
+            m_ItemGap = legend.itemGap;
+            m_ItemFontSize = legend.itemFontSize;
+            m_Data.Clear();
+            foreach (var d in legend.data) m_Data.Add(d);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+            else if (obj is Legend)
+            {
+                return Equals((Legend)obj);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool Equals(Legend other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+            return show == other.show &&
+                selectedMode == other.selectedMode &&
+                orient == other.orient &&
+                location == other.location &&
+                itemWidth == other.itemWidth &&
+                itemHeight == other.itemHeight &&
+                itemGap == other.itemGap &&
+                itemFontSize == other.itemFontSize &&
+                ChartHelper.IsValueEqualsList<string>(m_Data, other.data);
+        }
+
+        public static bool operator ==(Legend left, Legend right)
+        {
+            if (ReferenceEquals(left, null) && ReferenceEquals(right, null))
+            {
+                return true;
+            }
+            else if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
+            {
+                return false;
+            }
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(Legend left, Legend right)
+        {
+            return !(left == right);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <summary>
+        /// 清空
+        /// </summary>
+        public void ClearData()
+        {
+            m_Data.Clear();
+        }
+
+        /// <summary>
+        /// 是否包括由指定名字的图例
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public bool ContainsData(string name)
+        {
+            return m_Data.Contains(name);
+        }
+
+        /// <summary>
+        /// 移除指定名字的图例
+        /// </summary>
+        /// <param name="name"></param>
+        public void RemoveData(string name)
+        {
+            if (m_Data.Contains(name))
+            {
+                m_Data.Remove(name);
+            }
+        }
+
+        /// <summary>
+        /// 添加图例项
+        /// </summary>
+        /// <param name="name"></param>
+        public void AddData(string name)
+        {
+            if (!m_Data.Contains(name) && !string.IsNullOrEmpty(name))
+            {
+                m_Data.Add(name);
+            }
+        }
+
+        /// <summary>
+        /// 获得指定索引的图例
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public string GetData(int index)
+        {
+            if (index >= 0 && index < m_Data.Count)
+            {
+                return m_Data[index];
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 获得指定图例的索引
+        /// </summary>
+        /// <param name="legendName"></param>
+        /// <returns></returns>
+        public int GetIndex(string legendName)
+        {
+            return m_Data.IndexOf(legendName);
+        }
+
+        /// <summary>
+        /// 移除所有图例按钮
+        /// </summary>
+        public void RemoveButton()
+        {
+            m_DataBtnList.Clear();
+        }
+
+        /// <summary>
+        /// 给图例绑定按钮
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="btn"></param>
+        /// <param name="total"></param>
+        public void SetButton(string name, Button btn, int total)
+        {
+            int index = m_DataBtnList.Values.Count;
+            btn.transform.localPosition = GetButtonLocationPosition(total, index);
+            m_DataBtnList[name] = btn;
+            btn.gameObject.SetActive(show);
+            btn.GetComponentInChildren<Text>().text = name;
+        }
+
+        /// <summary>
+        /// 更新图例按钮颜色
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="color"></param>
+        public void UpdateButtonColor(string name, Color color)
+        {
+            if (m_DataBtnList.ContainsKey(name))
+            {
+                m_DataBtnList[name].GetComponent<Image>().color = color;
+            }
+        }
+
+        /// <summary>
+        /// 参数变更时的回调处理
+        /// </summary>
+        public void OnChanged()
+        {
+            m_Location.OnChanged();
+        }
+
+        /// <summary>
+        /// 根据图例的布局和位置类型获得具体位置
+        /// </summary>
+        /// <param name="size"></param>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        private Vector2 GetButtonLocationPosition(int size, int index)
+        {
+            switch (m_Orient)
+            {
+                case Orient.Vertical:
+                    switch (m_Location.align)
+                    {
+                        case Location.Align.TopCenter:
+                        case Location.Align.TopLeft:
+                        case Location.Align.TopRight:
+                            return new Vector2(0, -index * (itemHeight + itemGap));
+
+                        case Location.Align.Center:
+                        case Location.Align.CenterLeft:
+                        case Location.Align.CenterRight:
+                            float totalHeight = size * itemHeight + (size - 1) * itemGap;
+                            float startY = totalHeight / 2;
+                            return new Vector2(0, startY - index * (itemHeight + itemGap));
+
+                        case Location.Align.BottomCenter:
+                        case Location.Align.BottomLeft:
+                        case Location.Align.BottomRight:
+                            return new Vector2(0, (size - index - 1) * (itemHeight + itemGap));
+                    }
+                    return Vector2.zero;
+
+                case Orient.Horizonal:
+                    switch (m_Location.align)
+                    {
+                        case Location.Align.TopLeft:
+                        case Location.Align.CenterLeft:
+                        case Location.Align.BottomLeft:
+                            return new Vector2(index * (itemWidth + itemGap), 0);
+
+                        case Location.Align.TopCenter:
+                        case Location.Align.Center:
+                        case Location.Align.BottomCenter:
+                            float totalWidth = size * itemWidth + (size - 1) * itemGap;
+                            float startX = totalWidth / 2;
+                            return new Vector2(-startX + itemWidth / 2 + index * (itemWidth + itemGap), 0);
+                        case Location.Align.TopRight:
+                        case Location.Align.CenterRight:
+                        case Location.Align.BottomRight:
+                            return new Vector2(-(size - index - 1) * (itemWidth + itemGap), 0);
+                    }
+                    return Vector2.zero;
+            }
+            return Vector2.zero;
+        }
+
+        /// <summary>
+        /// 从json字符串解析数据，json格式如：['邮件营销','联盟广告','视频广告','直接访问','搜索引擎']
+        /// </summary>
+        /// <param name="jsonData"></param>
+        public override void ParseJsonData(string jsonData)
+        {
+            if (string.IsNullOrEmpty(jsonData) || !m_DataFromJson) return;
+            m_Data = ChartHelper.ParseStringFromString(jsonData);
+        }
+
+        public string GetFormatterContent(string category)
+        {
+            if (string.IsNullOrEmpty(m_Formatter))
+                return category;
+            else
+            {
+                var content = m_Formatter.Replace("{name}", category);
+                content = content.Replace("\\n", "\n");
+                content = content.Replace("<br/>", "\n");
+                return content;
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Main/Legend.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4a708805f5d8147b3b9a90b2f1d38e75
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Radar.cs

@@ -0,0 +1,376 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using System.Collections.Generic;
+using System;
+using System.Text.RegularExpressions;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Coordinate for radar charts. 
+    /// 雷达图坐标系组件，只适用于雷达图。
+    /// </summary>
+    [System.Serializable]
+    public class Radar : MainComponent, IEquatable<Radar>
+    {
+        /// <summary>
+        /// Radar render type, in which 'Polygon' and 'Circle' are supported.
+        /// 雷达图绘制类型，支持 'Polygon' 和 'Circle'。
+        /// </summary>
+        public enum Shape
+        {
+            Polygon,
+            Circle
+        }
+        /// <summary>
+        /// Indicator of radar chart, which is used to assign multiple variables(dimensions) in radar chart. 
+        /// 雷达图的指示器，用来指定雷达图中的多个变量（维度）。
+        /// </summary>
+        [System.Serializable]
+        public class Indicator : IEquatable<Indicator>
+        {
+            [SerializeField] private string m_Name;
+            [SerializeField] private float m_Max;
+            [SerializeField] private float m_Min;
+            [SerializeField] private Color m_Color;
+            /// <summary>
+            /// 指示器名称。
+            /// </summary>
+            public string name { get { return m_Name; } set { m_Name = value; } }
+            /// <summary>
+            /// The maximum value of indicator, with default value of 0, but we recommend to set it manually.
+            /// 指示器的最大值，默认为 0 无限制。
+            /// </summary>
+            public float max { get { return m_Max; } set { m_Max = value; } }
+            /// <summary>
+            /// The minimum value of indicator, with default value of 0.
+            /// 指示器的最小值，默认为 0 无限制。
+            /// </summary>
+            public float min { get { return m_Min; } set { m_Min = value; } }
+            /// <summary>
+            /// Specfy a color the the indicator.
+            /// 标签特定的颜色。默认取自主题的axisTextColor。
+            /// </summary>
+            public Color color { get { return m_Color; } set { m_Color = value; } }
+            /// <summary>
+            /// the text conponent of indicator.
+            /// 指示器的文本组件。
+            /// </summary>
+            public Text text { get; set; }
+
+            public Indicator Clone()
+            {
+                return new Indicator()
+                {
+                    m_Name = name,
+                    m_Max = max,
+                    m_Min = min,
+                    m_Color = color
+                };
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (ReferenceEquals(null, obj))
+                {
+                    return false;
+                }
+                else if (obj is Indicator)
+                {
+                    return Equals((Indicator)obj);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            public bool Equals(Indicator other)
+            {
+                if (ReferenceEquals(null, other))
+                {
+                    return false;
+                }
+                return m_Name.Equals(other.name) &&
+                    ChartHelper.IsValueEqualsColor(m_Color, other.color);
+            }
+
+            public override int GetHashCode()
+            {
+                return base.GetHashCode();
+            }
+        }
+        [SerializeField] private Shape m_Shape;
+        [SerializeField] private float m_Radius = 100;
+        [SerializeField] private int m_SplitNumber = 5;
+        [SerializeField] private float[] m_Center = new float[2] { 0.5f, 0.5f };
+        [SerializeField] private LineStyle m_LineStyle = new LineStyle();
+        [SerializeField] private AxisSplitArea m_SplitArea = AxisSplitArea.defaultSplitArea;
+        [SerializeField] private bool m_Indicator = true;
+        [SerializeField] private List<Indicator> m_IndicatorList = new List<Indicator>();
+        /// <summary>
+        /// Radar render type, in which 'Polygon' and 'Circle' are supported.
+        /// 雷达图绘制类型，支持 'Polygon' 和 'Circle'。
+        /// </summary>
+        /// <value></value>
+        public Shape shape { get { return m_Shape; } set { m_Shape = value; } }
+        /// <summary>
+        /// the radius of radar.
+        /// 雷达图的半径。
+        /// </summary>
+        public float radius { get { return m_Radius; } set { m_Radius = value; } }
+        /// <summary>
+        /// Segments of indicator axis.
+        /// 指示器轴的分割段数。
+        /// </summary>
+        public int splitNumber { get { return m_SplitNumber; } set { m_SplitNumber = value; } }
+        /// <summary>
+        /// the center of radar chart.
+        /// 雷达图的中心点。数组的第一项是横坐标，第二项是纵坐标。
+        /// 当值为0-1之间时表示百分比，设置成百分比时第一项是相对于容器宽度，第二项是相对于容器高度。
+        /// </summary>
+        public float[] center { get { return m_Center; } set { m_Center = value; } }
+        /// <summary>
+        /// the line style of radar.
+        /// 线条样式。
+        /// </summary>
+        public LineStyle lineStyle { get { return m_LineStyle; } set { m_LineStyle = value; } }
+        /// <summary>
+        /// Split area of axis in grid area.
+        /// 分割区域。
+        /// </summary>
+        public AxisSplitArea splitArea { get { return m_SplitArea; } set { m_SplitArea = value; } }
+        /// <summary>
+        /// Whether to show indicator.
+        /// 是否显示指示器。
+        /// </summary>
+        public bool indicator { get { return m_Indicator; } set { m_Indicator = value; } }
+        /// <summary>
+        /// the indicator list.
+        /// 指示器列表。
+        /// </summary>
+        public List<Indicator> indicatorList { get { return m_IndicatorList; } }
+
+        /// <summary>
+        /// the center position of radar in container.
+        /// 雷达图在容器中的具体中心点。
+        /// </summary>
+        /// <value></value>
+        public Vector2 centerPos { get; set; }
+        /// <summary>
+        /// the true radius of radar.
+        /// 雷达图的运行时实际半径。
+        /// </summary>
+        /// <value></value>
+        public float actualRadius { get; set; }
+        /// <summary>
+        /// the data position list of radar.
+        /// 雷达图的所有数据坐标点列表。
+        /// </summary>
+        /// <returns></returns>
+        public Dictionary<int, List<Vector3>> dataPosList = new Dictionary<int, List<Vector3>>();
+
+        public static Radar defaultRadar
+        {
+            get
+            {
+                var radar = new Radar
+                {
+                    m_Shape = Shape.Polygon,
+                    m_Radius = 0.4f,
+                    m_SplitNumber = 5,
+                    m_Indicator = true,
+                    m_IndicatorList = new List<Indicator>(5){
+                        new Indicator(){name="indicator1",max = 100},
+                        new Indicator(){name="indicator2",max = 100},
+                        new Indicator(){name="indicator3",max = 100},
+                        new Indicator(){name="indicator4",max = 100},
+                        new Indicator(){name="indicator5",max = 100},
+                    }
+                };
+                radar.center[0] = 0.5f;
+                radar.center[1] = 0.45f;
+                radar.splitArea.show = true;
+                radar.lineStyle.width = 0.6f;
+                return radar;
+            }
+        }
+
+        public void Copy(Radar other)
+        {
+            m_Shape = other.shape;
+            m_Radius = other.radius;
+            m_SplitNumber = other.splitNumber;
+            m_Center[0] = other.center[0];
+            m_Center[1] = other.center[1];
+            m_Indicator = other.indicator;
+            indicatorList.Clear();
+            foreach (var d in other.indicatorList) indicatorList.Add(d.Clone());
+        }
+
+        public Radar Clone()
+        {
+            var radar = new Radar();
+            radar.shape = shape;
+            radar.radius = radius;
+            radar.splitNumber = splitNumber;
+            radar.center[0] = center[0];
+            radar.center[1] = center[1];
+            radar.indicatorList.Clear();
+            radar.indicator = indicator;
+            foreach (var d in indicatorList) radar.indicatorList.Add(d.Clone());
+            return radar;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+            else if (obj is Radar)
+            {
+                return Equals((Radar)obj);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool Equals(Radar other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+            return radius == other.radius &&
+                shape == other.shape &&
+                splitNumber == other.splitNumber &&
+                center[0] == other.center[0] &&
+                center[1] == other.center[1] &&
+                indicator == other.indicator &&
+                IsEqualsIndicatorList(indicatorList, other.indicatorList);
+        }
+
+        private bool IsEqualsIndicatorList(List<Indicator> indicators1, List<Indicator> indicators2)
+        {
+            if (indicators1.Count != indicators2.Count) return false;
+            for (int i = 0; i < indicators1.Count; i++)
+            {
+                var indicator1 = indicators1[i];
+                var indicator2 = indicators2[i];
+                if (!indicator1.Equals(indicator2)) return false;
+            }
+            return true;
+        }
+
+        public static bool operator ==(Radar left, Radar right)
+        {
+            if (ReferenceEquals(left, null) && ReferenceEquals(right, null))
+            {
+                return true;
+            }
+            else if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
+            {
+                return false;
+            }
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(Radar left, Radar right)
+        {
+            return !(left == right);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        public override void ParseJsonData(string jsonData)
+        {
+            if (string.IsNullOrEmpty(jsonData) || !m_DataFromJson) return;
+            string pattern = "[\"|'](.*?)[\"|']";
+            if (Regex.IsMatch(jsonData, pattern))
+            {
+                m_IndicatorList.Clear();
+                MatchCollection m = Regex.Matches(jsonData, pattern);
+                foreach (Match match in m)
+                {
+                    m_IndicatorList.Add(new Indicator()
+                    {
+                        name = match.Groups[1].Value
+                    });
+                }
+            }
+            pattern = "(\\d+)";
+            if (Regex.IsMatch(jsonData, pattern))
+            {
+                MatchCollection m = Regex.Matches(jsonData, pattern);
+                int index = 0;
+                foreach (Match match in m)
+                {
+                    if (m_IndicatorList[index] != null)
+                    {
+                        m_IndicatorList[index].max = int.Parse(match.Groups[1].Value);
+                    }
+                    index++;
+                }
+            }
+        }
+
+        public float GetIndicatorMin(int index)
+        {
+            if (index >= 0 && index < m_IndicatorList.Count)
+            {
+                return m_IndicatorList[index].min;
+            }
+            return 0;
+        }
+        public float GetIndicatorMax(int index)
+        {
+            if (index >= 0 && index < m_IndicatorList.Count)
+            {
+                return m_IndicatorList[index].max;
+            }
+            return 0;
+        }
+
+        public void UpdateRadarCenter(float chartWidth, float chartHeight)
+        {
+            if (center.Length < 2) return;
+            var centerX = center[0] <= 1 ? chartWidth * center[0] : center[0];
+            var centerY = center[1] <= 1 ? chartHeight * center[1] : center[1];
+            centerPos = new Vector2(centerX, centerY);
+            if (radius <= 0)
+            {
+                actualRadius = 0;
+            }
+            else if (radius <= 1)
+            {
+                actualRadius = Mathf.Min(chartWidth, chartHeight) * radius;
+            }
+            else
+            {
+                actualRadius = radius;
+            }
+        }
+
+        public Vector3 GetIndicatorPosition(int index)
+        {
+            int indicatorNum = indicatorList.Count;
+            var angle = 2 * Mathf.PI / indicatorNum * index;
+            var x = centerPos.x + actualRadius * Mathf.Sin(angle);
+            var y = centerPos.y + actualRadius * Mathf.Cos(angle);
+            return new Vector3(x, y);
+        }
+    }
+}

Scripts/Runtime/Component/Main/Radar.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0874fd6b295f24cdb8b3cedb1faaa40f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Serie.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aa9c09045961a4ea9a34a098f099f2a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Series.cs

@@ -0,0 +1,967 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using System.Collections.Generic;
+using System;
+
+namespace XCharts
+{
+    /// <summary>
+    /// the list of series.
+    /// 系列列表。每个系列通过 type 决定自己的图表类型。
+    /// </summary>
+    [System.Serializable]
+    public class Series : MainComponent
+    {
+
+        [SerializeField] protected List<Serie> m_Series;
+
+        [Obsolete("Use Series.list instead.", true)]
+        public List<Serie> series { get { return m_Series; } }
+
+        /// <summary>
+        /// the list of serie
+        /// 系列列表。
+        /// </summary>
+        public List<Serie> list { get { return m_Series; } }
+        /// <summary>
+        /// the size of serie list.
+        /// 系列个数。
+        /// </summary>
+        public int Count { get { return m_Series.Count; } }
+
+        public static Series defaultSeries
+        {
+            get
+            {
+                var series = new Series
+                {
+                    m_Series = new List<Serie>(){new Serie(){
+                        show  = true,
+                        name = "serie1",
+                        index = 0
+                    }}
+                };
+                return series;
+            }
+        }
+
+        /// <summary>
+        /// 清空所有系列的数据
+        /// </summary>
+        public void ClearData()
+        {
+            AnimationStop();
+            foreach (var serie in m_Series)
+            {
+                serie.ClearData();
+            }
+        }
+
+        /// <summary>
+        /// 获得指定序列指定索引的数据值
+        /// </summary>
+        /// <param name="serieIndex"></param>
+        /// <param name="dataIndex"></param>
+        /// <returns></returns>
+        public float GetData(int serieIndex, int dataIndex)
+        {
+            if (serieIndex >= 0 && serieIndex < Count)
+            {
+                return m_Series[serieIndex].GetYData(dataIndex);
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 获得指定系列名的第一个系列
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public Serie GetSerie(string name)
+        {
+            for (int i = 0; i < m_Series.Count; i++)
+            {
+                bool match = false;
+                if (string.IsNullOrEmpty(name))
+                {
+                    if (string.IsNullOrEmpty(m_Series[i].name)) match = true;
+                }
+                else if (name.Equals(m_Series[i].name))
+                {
+                    match = true;
+                }
+                if (match)
+                {
+                    m_Series[i].index = i;
+                    return m_Series[i];
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 获得指定系列名的所有系列
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public List<Serie> GetSeries(string name)
+        {
+            var list = new List<Serie>();
+            if (name == null) return list;
+            foreach (var serie in m_Series)
+            {
+                if (name.Equals(serie.name)) list.Add(serie);
+            }
+            return list;
+        }
+
+        /// <summary>
+        /// 获得指定索引的系列
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public Serie GetSerie(int index)
+        {
+            if (index >= 0 && index < m_Series.Count)
+            {
+                return m_Series[index];
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 获得上一个同堆叠且显示的serie。
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public Serie GetLastStackSerie(int index)
+        {
+            var serie = GetSerie(index);
+            return GetLastStackSerie(serie);
+        }
+
+        /// <summary>
+        /// 同堆叠的serie是否有渐变色的。
+        /// </summary>
+        /// <param name="stack"></param>
+        /// <returns></returns>
+        public bool IsAnyGradientSerie(string stack)
+        {
+            if (string.IsNullOrEmpty(stack)) return false;
+            foreach (var serie in m_Series)
+            {
+                if (serie.show && serie.areaStyle.show && stack.Equals(serie.stack))
+                {
+                    if (serie.areaStyle.color != serie.areaStyle.toColor && serie.areaStyle.toColor != Color.clear) return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 获得上一个同堆叠且显示的serie。
+        /// </summary>
+        /// <param name="serie"></param>
+        /// <returns></returns>
+        public Serie GetLastStackSerie(Serie serie)
+        {
+            if (serie == null || string.IsNullOrEmpty(serie.stack)) return null;
+            for (int i = serie.index - 1; i >= 0; i--)
+            {
+                var temp = m_Series[i];
+                if (temp.show && serie.stack.Equals(temp.stack)) return temp;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 是否包含指定名字的系列
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public bool Contains(string name)
+        {
+            for (int i = 0; i < m_Series.Count; i++)
+            {
+                if (name.Equals(m_Series[i].name))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Remove serie from series.
+        /// 移除指定名字的系列。
+        /// </summary>
+        /// <param name="serieName">the name of serie</param>
+        public void Remove(string serieName)
+        {
+            var serie = GetSerie(serieName);
+            if (serie != null)
+            {
+                m_Series.Remove(serie);
+            }
+        }
+
+        /// <summary>
+        /// Remove all serie from series.
+        /// 移除所有系列。
+        /// </summary>
+        public void RemoveAll()
+        {
+            AnimationStop();
+            m_Series.Clear();
+        }
+
+        /// <summary>
+        /// 添加一个系列到列表中。
+        /// </summary>
+        /// <param name="serieName"></param>
+        /// <param name="type"></param>
+        /// <param name="show"></param>
+        /// <returns></returns>
+        public Serie AddSerie(SerieType type, string serieName, bool show = true)
+        {
+            var serie = new Serie();
+            serie.type = type;
+            serie.show = show;
+            serie.name = serieName;
+            serie.index = m_Series.Count;
+
+            if (type == SerieType.Scatter)
+            {
+                serie.symbol.type = SerieSymbolType.Circle;
+                serie.symbol.size = 20f;
+                serie.symbol.selectedSize = 30f;
+            }
+            else if (type == SerieType.Line)
+            {
+                serie.symbol.type = SerieSymbolType.EmptyCircle;
+                serie.symbol.size = 2.5f;
+                serie.symbol.selectedSize = 5f;
+            }
+            else
+            {
+                serie.symbol.type = SerieSymbolType.None;
+            }
+            serie.animation.Reset();
+            m_Series.Add(serie);
+            return serie;
+        }
+
+        /// <summary>
+        /// 添加一个数据到指定系列的维度Y数据中
+        /// </summary>
+        /// <param name="serieName"></param>
+        /// <param name="value"></param>
+        /// <param name="dataName"></param>
+        /// <returns>添加成功返回SerieData，否则返回null</returns>
+        public SerieData AddData(string serieName, float value, string dataName = null)
+        {
+            var serie = GetSerie(serieName);
+            if (serie != null)
+            {
+                return serie.AddYData(value, dataName);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 添加一个数据到指定系列的维度Y中
+        /// </summary>
+        /// <param name="index"></param>
+        /// <param name="value"></param>
+        /// <param name="dataName"></param>
+        /// <returns>添加成功返回SerieData，否则返回null</returns>
+        public SerieData AddData(int index, float value, string dataName = null)
+        {
+            var serie = GetSerie(index);
+            if (serie != null)
+            {
+                return serie.AddYData(value, dataName);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 添加一组数据到指定的系列中
+        /// </summary>
+        /// <param name="serieName"></param>
+        /// <param name="multidimensionalData"></param>
+        /// <param name="dataName"></param>
+        /// <returns>添加成功返回SerieData，否则返回null</returns>
+        public SerieData AddData(string serieName, List<float> multidimensionalData, string dataName = null)
+        {
+            var serie = GetSerie(serieName);
+            if (serie != null)
+            {
+                return serie.AddData(multidimensionalData, dataName);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 添加一组数据到指定的系列中
+        /// </summary>
+        /// <param name="serieIndex"></param>
+        /// <param name="multidimensionalData"></param>
+        /// <param name="dataName"></param>
+        /// <returns>添加成功返回SerieData，否则返回null</returns>
+        public SerieData AddData(int serieIndex, List<float> multidimensionalData, string dataName = null)
+        {
+            var serie = GetSerie(serieIndex);
+            if (serie != null)
+            {
+                return serie.AddData(multidimensionalData, dataName);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 添加(x,y)数据到指定的系列中
+        /// </summary>
+        /// <param name="serieName"></param>
+        /// <param name="xValue"></param>
+        /// <param name="yValue"></param>
+        /// <param name="dataName"></param>
+        /// <returns>添加成功返回SerieData，否则返回null</returns>
+        public SerieData AddXYData(string serieName, float xValue, float yValue, string dataName = null)
+        {
+            var serie = GetSerie(serieName);
+            if (serie != null)
+            {
+                return serie.AddXYData(xValue, yValue, dataName);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 添加(x,y)数据到指定的系列中
+        /// </summary>
+        /// <param name="index"></param>
+        /// <param name="xValue"></param>
+        /// <param name="yValue"></param>
+        /// <param name="dataName"></param>
+        /// <returns>添加成功返回SerieData，否则返回null</returns>
+        public SerieData AddXYData(int index, float xValue, float yValue, string dataName = null)
+        {
+            var serie = GetSerie(index);
+            if (serie != null)
+            {
+                return serie.AddXYData(xValue, yValue, dataName);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 更新指定系列的维度Y数据
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="value"></param>
+        /// <param name="dataIndex"></param>
+        public void UpdateData(string serieName, int dataIndex, float value)
+        {
+            var serie = GetSerie(serieName);
+            if (serie != null)
+            {
+                serie.UpdateYData(dataIndex, value);
+            }
+        }
+
+        /// <summary>
+        /// 更新指定系列的数据项名称
+        /// </summary>
+        /// <param name="serieName"></param>
+        /// <param name="dataIndex"></param>
+        /// <param name="dataName"></param>
+        public void UpdateDataName(string serieName, int dataIndex, string dataName)
+        {
+            var serie = GetSerie(serieName);
+            if (serie != null)
+            {
+                serie.UpdateDataName(dataIndex, dataName);
+            }
+        }
+
+        /// <summary>
+        /// 更新指定系列的数据项名称
+        /// </summary>
+        /// <param name="serieIndex"></param>
+        /// <param name="dataIndex"></param>
+        /// <param name="dataName"></param>
+        public void UpdateDataName(int serieIndex, int dataIndex, string dataName)
+        {
+            var serie = GetSerie(serieIndex);
+            if (serie != null)
+            {
+                serie.UpdateDataName(dataIndex, dataName);
+            }
+        }
+
+        /// <summary>
+        /// 更新指定系列的维度Y数据项的值
+        /// </summary>
+        /// <param name="serieIndex"></param>
+        /// <param name="dataIndex"></param>
+        /// <param name="value"></param>
+        public void UpdateData(int serieIndex, int dataIndex, float value)
+        {
+            var serie = GetSerie(serieIndex);
+            if (serie != null)
+            {
+                serie.UpdateYData(dataIndex, value);
+            }
+        }
+
+
+        /// <summary>
+        /// 更新指定系列的维度X和维度Y数据
+        /// </summary>
+        /// <param name="serieName"></param>
+        /// <param name="dataIndex"></param>
+        /// <param name="xValue"></param>
+        /// <param name="yValue"></param>
+        public void UpdateXYData(string serieName, int dataIndex, float xValue, float yValue)
+        {
+            var serie = GetSerie(serieName);
+            if (serie != null)
+            {
+                serie.UpdateXYData(dataIndex, xValue, yValue);
+            }
+        }
+
+        /// <summary>
+        /// 更新指定系列的维度X和维度Y数据
+        /// </summary>
+        /// <param name="serieIndex"></param>
+        /// <param name="dataIndex"></param>
+        /// <param name="xValue"></param>
+        /// <param name="yValue"></param>
+        public void UpdateXYData(int serieIndex, int dataIndex, float xValue, float yValue)
+        {
+            var serie = GetSerie(serieIndex);
+            if (serie != null)
+            {
+                serie.UpdateXYData(dataIndex, xValue, yValue);
+            }
+        }
+
+        /// <summary>
+        /// dataZoom由变化是更新系列的缓存数据
+        /// </summary>
+        /// <param name="dataZoom"></param>
+        public void UpdateFilterData(DataZoom dataZoom)
+        {
+            if (dataZoom != null && dataZoom.enable)
+            {
+                for (int i = 0; i < m_Series.Count; i++)
+                {
+                    m_Series[i].UpdateFilterData(dataZoom);
+                }
+            }
+        }
+
+        /// <summary>
+        /// 指定系列是否显示
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public bool IsActive(string name)
+        {
+            var serie = GetSerie(name);
+            return serie == null ? false : serie.show;
+        }
+
+        /// <summary>
+        /// 指定系列是否显示
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public bool IsActive(int index)
+        {
+            var serie = GetSerie(index);
+            return serie == null ? false : serie.show;
+        }
+
+        /// <summary>
+        /// 设置指定系列是否显示
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="active"></param>
+        public void SetActive(string name, bool active)
+        {
+            var serie = GetSerie(name);
+            if (serie != null)
+            {
+                serie.show = active;
+            }
+        }
+
+        /// <summary>
+        /// 设置指定系列是否显示
+        /// </summary>
+        /// <param name="index"></param>
+        /// <param name="active"></param>
+        public void SetActive(int index, bool active)
+        {
+            var serie = GetSerie(index);
+            if (serie != null)
+            {
+                serie.show = active;
+            }
+        }
+
+        /// <summary>
+        /// 是否由系列在用指定索引的axis
+        /// </summary>
+        /// <param name="axisIndex"></param>
+        /// <returns></returns>
+        public bool IsUsedAxisIndex(int axisIndex)
+        {
+            foreach (var serie in list)
+            {
+                if (serie.axisIndex == axisIndex) return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 指定系列是否处于高亮选中状态
+        /// </summary>
+        /// <param name="serieIndex"></param>
+        /// <returns></returns>
+        public bool IsHighlight(int serieIndex)
+        {
+            var serie = GetSerie(serieIndex);
+            if (serie != null) return serie.highlighted;
+            else return false;
+        }
+
+        /// <summary>
+        /// 获得维度X的最大最小值
+        /// </summary>
+        /// <param name="dataZoom"></param>
+        /// <param name="axisIndex"></param>
+        /// <param name="minVaule"></param>
+        /// <param name="maxValue"></param>
+        public void GetXMinMaxValue(DataZoom dataZoom, int axisIndex, bool isValueAxis,
+            out int minVaule, out int maxValue)
+        {
+            GetMinMaxValue(dataZoom, axisIndex, isValueAxis, false, out minVaule, out maxValue);
+        }
+
+        /// <summary>
+        /// 获得维度Y的最大最小值
+        /// </summary>
+        /// <param name="dataZoom"></param>
+        /// <param name="axisIndex"></param>
+        /// <param name="minVaule"></param>
+        /// <param name="maxValue"></param>
+        public void GetYMinMaxValue(DataZoom dataZoom, int axisIndex, bool isValueAxis,
+            out int minVaule, out int maxValue)
+        {
+            GetMinMaxValue(dataZoom, axisIndex, isValueAxis, true, out minVaule, out maxValue);
+        }
+
+        private Dictionary<int, List<Serie>> _stackSeriesForMinMax = new Dictionary<int, List<Serie>>();
+        private Dictionary<int, float> _serieTotalValueForMinMax = new Dictionary<int, float>();
+        public void GetMinMaxValue(DataZoom dataZoom, int axisIndex, bool isValueAxis, bool yValue,
+            out int minVaule, out int maxValue)
+        {
+            float min = int.MaxValue;
+            float max = int.MinValue;
+            var isPercentStack = IsPercentStack(SerieType.Bar);
+            if (!IsStack() || (isValueAxis && !yValue))
+            {
+                for (int i = 0; i < m_Series.Count; i++)
+                {
+                    var serie = m_Series[i];
+                    if (serie.axisIndex != axisIndex) continue;
+
+                    if (IsActive(i))
+                    {
+                        if (isPercentStack && IsPercentStack(serie.name, SerieType.Bar))
+                        {
+                            Debug.LogError("minmax:" + serie.name);
+                            if (100 > max) max = 100;
+                            if (0 < min) min = 0;
+                        }
+                        else
+                        {
+                            var showData = m_Series[i].GetDataList(dataZoom);
+                            foreach (var data in showData)
+                            {
+                                if (yValue)
+                                {
+                                    if (data.data[1] > max) max = data.data[1];
+                                    if (data.data[1] < min) min = data.data[1];
+                                }
+                                else
+                                {
+                                    if (data.data[0] > max) max = data.data[0];
+                                    if (data.data[0] < min) min = data.data[0];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else
+            {
+                GetStackSeries(ref _stackSeriesForMinMax);
+                foreach (var ss in _stackSeriesForMinMax)
+                {
+                    _serieTotalValueForMinMax.Clear();
+                    for (int i = 0; i < ss.Value.Count; i++)
+                    {
+                        var serie = ss.Value[i];
+                        if (serie.axisIndex != axisIndex || !IsActive(i)) continue;
+                        var showData = serie.GetDataList(dataZoom);
+                        if (IsPercentStack(serie.stack, SerieType.Bar))
+                        {
+                            for (int j = 0; j < showData.Count; j++)
+                            {
+                                _serieTotalValueForMinMax[j] = 100;
+                            }
+                        }
+                        else
+                        {
+                            for (int j = 0; j < showData.Count; j++)
+                            {
+                                if (!_serieTotalValueForMinMax.ContainsKey(j))
+                                    _serieTotalValueForMinMax[j] = 0;
+                                _serieTotalValueForMinMax[j] = _serieTotalValueForMinMax[j] +
+                                    (yValue ? showData[j].data[1] : showData[i].data[0]);
+                            }
+                        }
+
+                    }
+                    float tmax = int.MinValue;
+                    float tmin = int.MaxValue;
+                    foreach (var tt in _serieTotalValueForMinMax)
+                    {
+                        if (tt.Value > tmax) tmax = tt.Value;
+                        if (tt.Value < tmin) tmin = tt.Value;
+                    }
+                    if (tmax > max) max = tmax;
+                    if (tmin < min) min = tmin;
+                }
+            }
+            if (max == int.MinValue && min == int.MaxValue)
+            {
+                minVaule = 0;
+                maxValue = 0;
+            }
+            else
+            {
+                minVaule = Mathf.FloorToInt(min);
+                maxValue = Mathf.CeilToInt(max);
+            }
+        }
+
+        private HashSet<string> _setForStack = new HashSet<string>();
+        /// <summary>
+        /// 是否由数据堆叠
+        /// </summary>
+        /// <returns></returns>
+        public bool IsStack()
+        {
+            _setForStack.Clear();
+            foreach (var serie in m_Series)
+            {
+                if (string.IsNullOrEmpty(serie.stack)) continue;
+                if (_setForStack.Contains(serie.stack)) return true;
+                else
+                {
+                    _setForStack.Add(serie.stack);
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 是否堆叠
+        /// </summary>
+        /// <param name="stackName"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public bool IsStack(string stackName, SerieType type)
+        {
+            if (string.IsNullOrEmpty(stackName)) return false;
+            int count = 0;
+            foreach (var serie in m_Series)
+            {
+                if (serie.show && serie.type == type)
+                {
+                    if (stackName.Equals(serie.stack)) count++;
+                    if (count >= 2) return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 是否时百分比堆叠
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public bool IsPercentStack(SerieType type)
+        {
+            int count = 0;
+            bool isPercentStack = false;
+            foreach (var serie in m_Series)
+            {
+                if (serie.show && serie.type == type)
+                {
+                    if (!string.IsNullOrEmpty(serie.stack))
+                    {
+                        count++;
+                        if (serie.barPercentStack) isPercentStack = true;
+                    }
+                    if (count >= 2 && isPercentStack) return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 是否时百分比堆叠
+        /// </summary>
+        /// <param name="stackName"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public bool IsPercentStack(string stackName, SerieType type)
+        {
+            if (string.IsNullOrEmpty(stackName)) return false;
+            int count = 0;
+            bool isPercentStack = false;
+            foreach (var serie in m_Series)
+            {
+                if (serie.show && serie.type == type)
+                {
+                    if (stackName.Equals(serie.stack))
+                    {
+                        count++;
+                        if (serie.barPercentStack) isPercentStack = true;
+                    }
+                    if (count >= 2 && isPercentStack) return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 获得堆叠系列列表
+        /// </summary>
+        /// <returns></returns>
+        public Dictionary<int, List<Serie>> GetStackSeries()
+        {
+            int count = 0;
+            Dictionary<string, int> sets = new Dictionary<string, int>();
+            Dictionary<int, List<Serie>> stackSeries = new Dictionary<int, List<Serie>>();
+            for (int i = 0; i < m_Series.Count; i++)
+            {
+                var serie = m_Series[i];
+                serie.index = i;
+                if (string.IsNullOrEmpty(serie.stack))
+                {
+                    stackSeries[count] = new List<Serie>();
+                    stackSeries[count].Add(serie);
+                    count++;
+                }
+                else
+                {
+                    if (!sets.ContainsKey(serie.stack))
+                    {
+                        sets.Add(serie.stack, count);
+                        stackSeries[count] = new List<Serie>();
+                        stackSeries[count].Add(serie);
+                        count++;
+                    }
+                    else
+                    {
+                        int stackIndex = sets[serie.stack];
+                        stackSeries[stackIndex].Add(serie);
+                    }
+                }
+            }
+            return stackSeries;
+        }
+
+        private Dictionary<string, int> sets = new Dictionary<string, int>();
+        /// <summary>
+        /// 获得堆叠系列列表
+        /// </summary>
+        /// <param name="Dictionary<int"></param>
+        /// <param name="stackSeries"></param>
+        public void GetStackSeries(ref Dictionary<int, List<Serie>> stackSeries)
+        {
+            int count = 0;
+            sets.Clear();
+            if (stackSeries == null)
+            {
+                stackSeries = new Dictionary<int, List<Serie>>(m_Series.Count);
+            }
+            else
+            {
+                foreach (var kv in stackSeries)
+                {
+                    kv.Value.Clear();
+                }
+            }
+            for (int i = 0; i < m_Series.Count; i++)
+            {
+                var serie = m_Series[i];
+                serie.index = i;
+                if (string.IsNullOrEmpty(serie.stack))
+                {
+                    if (!stackSeries.ContainsKey(count))
+                        stackSeries[count] = new List<Serie>(m_Series.Count);
+                    stackSeries[count].Add(serie);
+                    count++;
+                }
+                else
+                {
+                    if (!sets.ContainsKey(serie.stack))
+                    {
+                        sets.Add(serie.stack, count);
+                        if (!stackSeries.ContainsKey(count))
+                            stackSeries[count] = new List<Serie>(m_Series.Count);
+                        stackSeries[count].Add(serie);
+                        count++;
+                    }
+                    else
+                    {
+                        int stackIndex = sets[serie.stack];
+                        stackSeries[stackIndex].Add(serie);
+                    }
+                }
+            }
+        }
+
+        private List<string> serieNameList = new List<string>();
+        /// <summary>
+        /// 获得所有系列名，不包含空名字。
+        /// </summary>
+        /// <returns></returns>
+        public List<string> GetSerieNameList()
+        {
+            serieNameList.Clear();
+            for (int n = 0; n < m_Series.Count; n++)
+            {
+                var serie = m_Series[n];
+                switch (serie.type)
+                {
+                    case SerieType.Pie:
+                    case SerieType.Radar:
+                        for (int i = 0; i < serie.data.Count; i++)
+                        {
+                            if (string.IsNullOrEmpty(serie.data[i].name))
+                                serieNameList.Add(ChartCached.IntToStr(i));
+                            else if (!serieNameList.Contains(serie.data[i].name))
+                                serieNameList.Add(serie.data[i].name);
+                        }
+                        break;
+                    default:
+                        if (string.IsNullOrEmpty(serie.name))
+                            serieNameList.Add(ChartCached.IntToStr(n));
+                        else if (!serieNameList.Contains(serie.name))
+                            serieNameList.Add(serie.name);
+                        break;
+                }
+            }
+            return serieNameList;
+        }
+
+        /// <summary>
+        /// 设置获得标志图形大小的回调
+        /// </summary>
+        /// <param name="size"></param>
+        /// <param name="selectedSize"></param>
+        public void SetSerieSymbolSizeCallback(SymbolSizeCallback size, SymbolSizeCallback selectedSize)
+        {
+            foreach (var serie in m_Series)
+            {
+                serie.symbol.sizeCallback = size;
+                serie.symbol.selectedSizeCallback = selectedSize;
+            }
+        }
+
+        /// <summary>
+        /// 启用或取消初始动画
+        /// </summary>
+        public void AnimationEnable(bool flag)
+        {
+            foreach (var serie in m_Series)
+            {
+                serie.animation.enable = flag;
+            }
+        }
+
+        /// <summary>
+        /// 开始初始动画
+        /// </summary>
+        public void AnimationStart()
+        {
+            foreach (var serie in m_Series)
+            {
+                if (serie.animation.enable)
+                {
+                    serie.animation.Start();
+                }
+            }
+        }
+
+        /// <summary>
+        /// 停止初始动画
+        /// </summary>
+        public void AnimationStop()
+        {
+            foreach (var serie in m_Series)
+            {
+                if (serie.animation.enable) serie.animation.Stop();
+            }
+        }
+
+        /// <summary>
+        /// 重置初始动画
+        /// </summary>
+        public void AnimationReset()
+        {
+            foreach (var serie in m_Series)
+            {
+                if (serie.animation.enable) serie.animation.Reset();
+            }
+        }
+
+        public bool IsLegalLegendName(string name)
+        {
+            int numName = -1;
+            if (int.TryParse(name, out numName))
+            {
+                if (numName >= 0 && numName < 100) return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// 从json中解析数据
+        /// </summary>
+        /// <param name="jsonData"></param>
+        public override void ParseJsonData(string jsonData)
+        {
+            //TODO:
+        }
+    }
+}

Scripts/Runtime/Component/Main/Series.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 57c808a15402a4d25a51a37cbb655a85
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Settings.cs

@@ -0,0 +1,69 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using System;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Global parameter setting component. The default value can be used in general, and can be adjusted when necessary.
+    /// 全局参数设置组件。一般情况下可使用默认值，当有需要时可进行调整。
+    /// </summary>
+    [Serializable]
+    public class Settings : MainComponent
+    {
+        [SerializeField] [Range(1, 10)] protected float m_LineSmoothStyle = 3f;
+        [SerializeField] [Range(1f, 20)] protected float m_LineSmoothness = 2f;
+        [SerializeField] [Range(1f, 20)] protected float m_LineSegmentDistance = 3f;
+        [SerializeField] [Range(1, 10)] protected float m_CicleSmoothness = 2f;
+        [SerializeField] [Range(10, 50)] protected float m_VisualMapTriangeLen = 20f;
+        [SerializeField] [Range(1, 20)] protected float m_PieTooltipExtraRadius = 8f;
+        [SerializeField] [Range(1, 20)] protected float m_PieSelectedOffset = 8f;
+
+        /// <summary>
+        /// Curve smoothing factor. By adjusting the smoothing coefficient, the curvature of the curve can be changed, 
+        /// and different curves with slightly different appearance can be obtained.
+        /// 曲线平滑系数。通过调整平滑系数可以改变曲线的曲率，得到外观稍微有变化的不同曲线。
+        /// </summary>
+        public float lineSmoothStyle { get { return m_LineSmoothStyle; } set { m_LineSmoothStyle = value <= 0 ? 1f : value; } }
+        /// <summary>
+        /// Smoothness of curve. The smaller the value, the smoother the curve, but the number of vertices will increase. 
+        /// When the area with gradient is filled, the larger the value, the worse the transition effect.
+        /// 曲线平滑度。值越小曲线越平滑，但顶点数也会随之增加。当开启有渐变的区域填充时，数值越大渐变过渡效果越差。
+        /// </summary>
+        /// <value></value>
+        public float lineSmoothness { get { return m_LineSmoothness; } set { m_LineSmoothness = value <= 0 ? 1f : value; } }
+        /// <summary>
+        /// The partition distance of a line segment. A line in a normal line chart is made up of many segments, 
+        /// the number of which is determined by the change in value. The smaller the number of segments, 
+        /// the higher the number of vertices. When the area with gradient is filled, the larger the value, the worse the transition effect.
+        /// 线段的分割距离。普通折线图的线是由很多线段组成，段数由该数值决定。值越小段数越多，但顶点数也会随之增加。当开启有渐变的区域填充时，数值越大渐变过渡效果越差。
+        /// </summary>
+        /// <value></value>
+        public float lineSegmentDistance { get { return m_LineSegmentDistance; } set { m_LineSegmentDistance = value <= 0 ? 1f : value; } }
+        /// <summary>
+        /// the smoothess of cricle.
+        /// 圆形的平滑度。数越小圆越平滑，但顶点数也会随之增加。
+        /// </summary>
+        public float cicleSmoothness { get { return m_CicleSmoothness; } set { m_CicleSmoothness = value <= 0 ? 1f : value; } }
+        /// <summary>
+        /// 可视化组件的调节三角形变长。
+        /// </summary>
+        /// <value></value>
+        public float visualMapTriangeLen { get { return m_VisualMapTriangeLen; } set { m_VisualMapTriangeLen = value <= 0 ? 1f : value; } }
+        /// <summary>
+        /// 饼图鼠标移到高亮时的额外半径
+        /// </summary>
+        public float pieTooltipExtraRadius { get { return m_PieTooltipExtraRadius; } set { m_PieTooltipExtraRadius = value <= 0 ? 0 : value; } }
+        /// <summary>
+        /// 饼图选中时的中心点偏移
+        /// </summary>
+        public float pieSelectedOffset { get { return m_PieSelectedOffset; } set { m_PieSelectedOffset = value <= 0 ? 0 : value; } }
+
+    }
+}

Scripts/Runtime/Component/Main/Settings.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40d2c2f38d80f4b42acdba7db6918f14
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Theme.cs

@@ -0,0 +1,643 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+using UnityEngine.Serialization;
+
+namespace XCharts
+{
+    /// <summary>
+    /// 主题
+    /// </summary>
+    public enum Theme
+    {
+        /// <summary>
+        /// 默认主题。
+        /// </summary>
+        Default,
+        /// <summary>
+        /// 亮主题。
+        /// </summary>
+        Light,
+        /// <summary>
+        /// 暗主题。
+        /// </summary>
+        Dark
+    }
+
+    [Serializable]
+    /// <summary>
+    /// Theme.
+    /// 主题相关配置。
+    /// </summary>
+    public class ThemeInfo : MainComponent, IEquatable<ThemeInfo>
+    {
+        [SerializeField] private Theme m_Theme = Theme.Default;
+        [SerializeField] private Font m_Font;
+        [SerializeField] private Color32 m_BackgroundColor;
+        [FormerlySerializedAs("m_TextColor")]
+        [SerializeField] private Color32 m_TitleTextColor;
+        [SerializeField] private Color32 m_TitleSubTextColor;
+        [SerializeField] private Color32 m_LegendTextColor;
+        [SerializeField] private Color32 m_LegendUnableColor;
+        [SerializeField] private Color32 m_AxisTextColor;
+        [SerializeField] private Color32 m_AxisLineColor;
+        [SerializeField] private Color32 m_AxisSplitLineColor;
+        [SerializeField] private Color32 m_TooltipBackgroundColor;
+        [SerializeField] private Color32 m_TooltipFlagAreaColor;
+        [SerializeField] private Color32 m_TooltipTextColor;
+        [SerializeField] private Color32 m_TooltipLabelColor;
+        [SerializeField] private Color32 m_TooltipLineColor;
+        [SerializeField] private Color32 m_DataZoomTextColor;
+        [SerializeField] private Color32 m_DataZoomLineColor;
+        [SerializeField] private Color32 m_DataZoomSelectedColor;
+        [SerializeField] private Color32 m_VisualMapBackgroundColor;
+        [SerializeField] private Color32 m_VisualMapBorderColor;
+        [SerializeField] private Color32[] m_ColorPalette;
+
+        [SerializeField] private Font m_CustomFont;
+        [SerializeField] private Color32 m_CustomBackgroundColor;
+        [FormerlySerializedAs("m_CustomTextColor")]
+        [SerializeField] private Color32 m_CustomTitleTextColor;
+        [SerializeField] private Color32 m_CustomTitleSubTextColor;
+        [SerializeField] private Color32 m_CustomLegendTextColor;
+        [SerializeField] private Color32 m_CustomLegendUnableColor;
+        [SerializeField] private Color32 m_CustomAxisTextColor;
+        [SerializeField] private Color32 m_CustomAxisLineColor;
+        [SerializeField] private Color32 m_CustomAxisSplitLineColor;
+        [SerializeField] private Color32 m_CustomTooltipBackgroundColor;
+        [SerializeField] private Color32 m_CustomTooltipFlagAreaColor;
+        [SerializeField] private Color32 m_CustomTooltipTextColor;
+        [SerializeField] private Color32 m_CustomTooltipLabelColor;
+        [SerializeField] private Color32 m_CustomTooltipLineColor;
+        [SerializeField] private Color32 m_CustomDataZoomTextColor;
+        [SerializeField] private Color32 m_CustomDataZoomLineColor;
+        [SerializeField] private Color32 m_CustomDataZoomSelectedColor;
+        [SerializeField] private Color32 m_CustomVisualMapBackgroundColor;
+        [SerializeField] private Color32 m_CustomVisualMapBorderColor;
+        [SerializeField] private List<Color32> m_CustomColorPalette = new List<Color32>(13);
+        /// <summary>
+        /// the theme of chart.
+        /// 主题类型。
+        /// </summary>
+        public Theme theme { get { return m_Theme; } set { m_Theme = value; } }
+        /// <summary>
+        /// the font of chart text。
+        /// 字体。
+        /// </summary>
+        public Font font
+        {
+            get { return m_CustomFont != null ? m_CustomFont : m_Font; }
+            set { m_CustomFont = value; }
+        }
+        /// <summary>
+        /// the background color of chart.
+        /// 背景颜色。
+        /// </summary>
+        public Color32 backgroundColor
+        {
+            get { return m_CustomBackgroundColor != Color.clear ? m_CustomBackgroundColor : m_BackgroundColor; }
+            set { m_CustomBackgroundColor = value; }
+        }
+        /// <summary>
+        /// the main title text color.
+        /// 主标题颜色。
+        /// </summary>
+        public Color32 titleTextColor
+        {
+            get { return m_CustomTitleTextColor != Color.clear ? m_CustomTitleTextColor : m_TitleTextColor; }
+            set { m_CustomTitleTextColor = value; }
+        }
+        /// <summary>
+        /// the subtitie text color.
+        /// 副标题颜色。
+        /// </summary>
+        public Color32 titleSubTextColor
+        {
+            get { return m_CustomTitleSubTextColor != Color.clear ? m_CustomTitleSubTextColor : m_TitleSubTextColor; }
+            set { m_CustomTitleSubTextColor = value; }
+        }
+        /// <summary>
+        /// the legend text color.
+        /// 图例文字的颜色。
+        /// </summary>
+        public Color32 legendTextColor
+        {
+            get { return m_CustomLegendTextColor != Color.clear ? m_CustomLegendTextColor : m_LegendTextColor; }
+            set { m_CustomLegendTextColor = value; }
+        }
+        /// <summary>
+        /// the legend unable text color.
+        /// 图例变为不可用时的按钮颜色。
+        /// </summary>
+        public Color32 legendUnableColor
+        {
+            get { return m_CustomLegendUnableColor != Color.clear ? m_CustomLegendUnableColor : m_LegendUnableColor; }
+            set { m_CustomLegendUnableColor = value; }
+        }
+        /// <summary>
+        /// the axis text color.
+        /// 坐标轴上标签的颜色。
+        /// </summary>
+        public Color32 axisTextColor
+        {
+            get { return m_CustomAxisTextColor != Color.clear ? m_CustomAxisTextColor : m_AxisTextColor; }
+            set { m_CustomAxisTextColor = value; }
+        }
+        /// <summary>
+        /// the color of axis line.
+        /// 坐标轴轴线的颜色。
+        /// </summary>
+        public Color32 axisLineColor
+        {
+            get { return m_CustomAxisLineColor != Color.clear ? m_CustomAxisLineColor : m_AxisLineColor; }
+            set { m_CustomAxisLineColor = value; }
+        }
+        /// <summary>
+        /// the color of axis split line.
+        /// 分割线的颜色，默认和坐标轴轴线颜色一致。
+        /// </summary>
+        public Color32 axisSplitLineColor
+        {
+            get { return m_CustomAxisSplitLineColor != Color.clear ? m_CustomAxisSplitLineColor : m_AxisSplitLineColor; }
+            set { m_CustomAxisSplitLineColor = value; }
+        }
+        /// <summary>
+        /// the tooltip background color.
+        /// 提示框背景颜色。
+        /// </summary>
+        public Color32 tooltipBackgroundColor
+        {
+            get { return m_CustomTooltipBackgroundColor != Color.clear ? m_CustomTooltipBackgroundColor : m_TooltipBackgroundColor; }
+            set { m_CustomTooltipBackgroundColor = value; }
+        }
+        /// <summary>
+        /// the color of tooltip shadow crosshair indicator. 
+        /// 提示框阴影指示器的颜色。
+        /// </summary>
+        public Color32 tooltipFlagAreaColor
+        {
+            get { return m_CustomTooltipFlagAreaColor != Color.clear ? m_CustomTooltipFlagAreaColor : m_TooltipFlagAreaColor; }
+            set { m_CustomTooltipFlagAreaColor = value; }
+        }
+        /// <summary>
+        /// the color of tooltip text.
+        /// 提示框文字颜色。
+        /// </summary>
+        public Color32 tooltipTextColor
+        {
+            get { return m_CustomTooltipTextColor != Color.clear ? m_CustomTooltipTextColor : m_TooltipTextColor; }
+            set { m_CustomTooltipTextColor = value; }
+        }
+        /// <summary>
+        /// the background color of tooltip cross indicator's axis label.
+        /// 提示框的十字指示器坐标轴标签的背景颜色。
+        /// </summary>
+        public Color32 tooltipLabelColor
+        {
+            get { return m_CustomTooltipLabelColor != Color.clear ? m_CustomTooltipLabelColor : m_TooltipLabelColor; }
+            set { m_CustomTooltipLabelColor = value; }
+        }
+        /// <summary>
+        /// the color tooltip indicator line.
+        /// 提示框的指示线的颜色。
+        /// </summary>
+        public Color32 tooltipLineColor
+        {
+            get { return m_CustomTooltipLineColor != Color.clear ? m_CustomTooltipLineColor : m_TooltipLineColor; }
+            set { m_CustomTooltipLineColor = value; }
+        }
+        /// <summary>
+        /// the color of datazoom text.
+        /// 区域缩放的文字颜色。
+        /// </summary>
+        public Color32 dataZoomTextColor
+        {
+            get { return m_CustomDataZoomTextColor != Color.clear ? m_CustomDataZoomTextColor : m_DataZoomTextColor; }
+            set { m_CustomDataZoomTextColor = value; }
+        }
+        /// <summary>
+        /// the color of datazoom line.
+        /// 区域缩放的线条颜色。
+        /// </summary>
+        public Color32 dataZoomLineColor
+        {
+            get { return m_CustomDataZoomLineColor != Color.clear ? m_CustomDataZoomLineColor : m_DataZoomLineColor; }
+            set { m_CustomDataZoomLineColor = value; }
+        }
+        /// <summary>
+        /// the color of datazoom selected area.
+        /// 区域缩放的选中区域颜色。
+        /// </summary>
+        public Color32 dataZoomSelectedColor
+        {
+            get { return m_CustomDataZoomSelectedColor != Color.clear ? m_CustomDataZoomSelectedColor : m_DataZoomSelectedColor; }
+            set { m_CustomDataZoomSelectedColor = value; }
+        }
+
+        /// <summary>
+        /// 视觉映射组件的背景色。
+        /// </summary>
+        public Color32 visualMapBackgroundColor
+        {
+            get { return m_CustomVisualMapBackgroundColor != Color.clear ? m_CustomVisualMapBackgroundColor : m_VisualMapBackgroundColor; }
+            set { m_CustomVisualMapBackgroundColor = value; }
+        }
+
+        /// <summary>
+        /// 视觉映射的边框色。
+        /// </summary>
+        public Color32 visualMapBorderColor
+        {
+            get { return m_CustomVisualMapBorderColor != Color.clear ? m_CustomVisualMapBorderColor : m_VisualMapBorderColor; }
+            set { m_CustomVisualMapBorderColor = value; }
+        }
+
+        /// <summary>
+        /// The color list of palette. If no color is set in series, the colors would be adopted sequentially and circularly from this list as the colors of series.
+        /// 调色盘颜色列表。如果系列没有设置颜色，则会依次循环从该列表中取颜色作为系列颜色。
+        /// </summary>
+        public List<Color32> colorPalette { set { m_CustomColorPalette = value; } }
+
+        /// <summary>
+        /// Gets the color of the specified index from the palette. 
+        /// 获得调色盘对应系列索引的颜色值。
+        /// </summary>
+        /// <param name="index">编号索引</param>
+        /// <returns>the color,or Color.clear when failed.颜色值，失败时返回Color.clear</returns>
+        public Color32 GetColor(int index)
+        {
+            if (index < 0) index = 0;
+            if (m_CustomColorPalette.Count > 0)
+            {
+                var customIndex = index < m_CustomColorPalette.Count ? index : index % m_CustomColorPalette.Count;
+                if (customIndex < m_CustomColorPalette.Count && m_CustomColorPalette[customIndex] != Color.clear)
+                {
+                    return m_CustomColorPalette[customIndex];
+                }
+            }
+            var newIndex = index < m_ColorPalette.Length ? index : index % m_ColorPalette.Length;
+            if (newIndex < m_ColorPalette.Length)
+                return m_ColorPalette[newIndex];
+            else return Color.clear;
+        }
+
+        Dictionary<int, string> _colorDic = new Dictionary<int, string>();
+        /// <summary>
+        /// Gets the hexadecimal color string of the specified index from the palette. 
+        /// 获得指定索引的十六进制颜色值字符串。
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public string GetColorStr(int index)
+        {
+            if (index < 0)
+            {
+                index = 0;
+            }
+            index = index % m_ColorPalette.Length;
+            if (_colorDic.ContainsKey(index)) return _colorDic[index];
+            else
+            {
+                _colorDic[index] = ColorUtility.ToHtmlStringRGBA(GetColor(index));
+                return _colorDic[index];
+            }
+        }
+
+        /// <summary>
+        /// copy all configurations from theme. 
+        /// 复制主题的所有配置。
+        /// </summary>
+        /// <param name="theme"></param>
+        public void Copy(ThemeInfo theme)
+        {
+            m_Theme = theme.theme;
+            m_Font = theme.m_Font;
+            m_BackgroundColor = theme.m_BackgroundColor;
+            m_LegendUnableColor = theme.m_LegendUnableColor;
+            m_TitleTextColor = theme.m_TitleTextColor;
+            m_TitleSubTextColor = theme.m_TitleSubTextColor;
+            m_LegendTextColor = theme.m_LegendTextColor;
+            m_AxisTextColor = theme.m_AxisTextColor;
+            m_AxisLineColor = theme.m_AxisLineColor;
+            m_AxisSplitLineColor = theme.m_AxisSplitLineColor;
+            m_TooltipBackgroundColor = theme.m_TooltipBackgroundColor;
+            m_TooltipTextColor = theme.m_TooltipTextColor;
+            m_TooltipLabelColor = theme.m_TooltipLabelColor;
+            m_TooltipLineColor = theme.m_TooltipLineColor;
+            m_DataZoomLineColor = theme.m_DataZoomLineColor;
+            m_DataZoomSelectedColor = theme.m_DataZoomSelectedColor;
+            m_DataZoomTextColor = theme.m_DataZoomTextColor;
+            m_VisualMapBackgroundColor = theme.m_VisualMapBackgroundColor;
+            m_VisualMapBorderColor = theme.m_VisualMapBorderColor;
+            m_ColorPalette = new Color32[theme.m_ColorPalette.Length];
+            for (int i = 0; i < theme.m_ColorPalette.Length; i++)
+            {
+                m_ColorPalette[i] = theme.m_ColorPalette[i];
+            }
+        }
+
+        /// <summary>
+        /// Clear all custom configurations. 
+        /// 重置，清除所有自定义配置。
+        /// </summary>
+        public void Reset()
+        {
+            m_Theme = Theme.Default;
+            m_Font = null;
+            m_BackgroundColor = Color.clear;
+            m_LegendUnableColor = Color.clear;
+            m_TitleTextColor = Color.clear;
+            m_TitleSubTextColor = Color.clear;
+            m_LegendTextColor = Color.clear;
+            m_AxisTextColor = Color.clear;
+            m_AxisLineColor = Color.clear;
+            m_AxisSplitLineColor = Color.clear;
+            m_TooltipBackgroundColor = Color.clear;
+            m_TooltipTextColor = Color.clear;
+            m_TooltipLabelColor = Color.clear;
+            m_TooltipLineColor = Color.clear;
+            m_DataZoomLineColor = Color.clear;
+            m_DataZoomSelectedColor = Color.clear;
+            m_DataZoomTextColor = Color.clear;
+            m_VisualMapBackgroundColor = Color.clear;
+            m_VisualMapBorderColor = Color.clear;
+            for (int i = 0; i < m_CustomColorPalette.Count; i++)
+            {
+                m_CustomColorPalette[i] = Color.clear;
+            }
+        }
+
+        /// <summary>
+        /// default theme. 
+        /// 默认主题。
+        /// </summary>
+        /// <value></value>
+        public static ThemeInfo Default
+        {
+            get
+            {
+                return new ThemeInfo()
+                {
+                    m_Theme = Theme.Default,
+                    m_Font = Resources.GetBuiltinResource<Font>("Arial.ttf"),
+                    m_BackgroundColor = new Color32(255, 255, 255, 255),
+                    m_LegendUnableColor = GetColor("#cccccc"),
+                    m_TitleTextColor = GetColor("#514D4D"),
+                    m_TitleSubTextColor = GetColor("#514D4D"),
+                    m_LegendTextColor = GetColor("#eee"),
+                    m_AxisTextColor = GetColor("#514D4D"),
+                    m_AxisLineColor = GetColor("#514D4D"),
+                    m_AxisSplitLineColor = GetColor("#51515120"),
+                    m_TooltipBackgroundColor = GetColor("#515151C8"),
+                    m_TooltipTextColor = GetColor("#FFFFFFFF"),
+                    m_TooltipFlagAreaColor = GetColor("#51515120"),
+                    m_TooltipLabelColor = GetColor("#292929FF"),
+                    m_TooltipLineColor = GetColor("#29292964"),
+                    m_DataZoomLineColor = GetColor("#51515120"),
+                    m_DataZoomSelectedColor = GetColor("#51515120"),
+                    m_DataZoomTextColor = GetColor("#514D4D"),
+                    m_VisualMapBackgroundColor = GetColor("#51515120"),
+                    m_VisualMapBorderColor = GetColor("#cccccc"),
+                    m_ColorPalette = new Color32[]
+                    {
+                        new Color32(194, 53, 49, 255),
+                        new Color32(47, 69, 84, 255),
+                        new Color32(97, 160, 168, 255),
+                        new Color32(212, 130, 101, 255),
+                        new Color32(145, 199, 174, 255),
+                        new Color32(116, 159, 131, 255),
+                        new Color32(202, 134, 34, 255),
+                        new Color32(189, 162, 154, 255),
+                        new Color32(110, 112, 116, 255),
+                        new Color32(84, 101, 112, 255),
+                        new Color32(196, 204, 211, 255)
+                    },
+                    m_CustomColorPalette = new List<Color32>{
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear
+                    }
+                };
+            }
+        }
+
+        /// <summary>
+        /// light theme. 
+        /// 亮主题。
+        /// </summary>
+        /// <value></value>
+        public static ThemeInfo Light
+        {
+            get
+            {
+                return new ThemeInfo()
+                {
+                    m_Theme = Theme.Light,
+                    m_Font = Resources.GetBuiltinResource<Font>("Arial.ttf"),
+                    m_BackgroundColor = new Color32(255, 255, 255, 255),
+                    m_LegendUnableColor = GetColor("#cccccc"),
+                    m_TitleTextColor = GetColor("#514D4D"),
+                    m_TitleSubTextColor = GetColor("#514D4D"),
+                    m_LegendTextColor = GetColor("#514D4D"),
+                    m_AxisTextColor = GetColor("#514D4D"),
+                    m_AxisLineColor = GetColor("#514D4D"),
+                    m_AxisSplitLineColor = GetColor("#51515120"),
+                    m_TooltipBackgroundColor = GetColor("#515151C8"),
+                    m_TooltipTextColor = GetColor("#FFFFFFFF"),
+                    m_TooltipFlagAreaColor = GetColor("#51515120"),
+                    m_TooltipLabelColor = GetColor("#292929FF"),
+                    m_TooltipLineColor = GetColor("#29292964"),
+                    m_DataZoomLineColor = GetColor("#51515120"),
+                    m_DataZoomSelectedColor = GetColor("#51515120"),
+                    m_DataZoomTextColor = GetColor("#514D4D"),
+                    m_VisualMapBackgroundColor = GetColor("#51515120"),
+                    m_VisualMapBorderColor = GetColor("#cccccc"),
+                    m_ColorPalette = new Color32[]
+                    {
+                        new Color32(55, 162, 218, 255),
+                        new Color32(255, 159, 127, 255),
+                        new Color32(50, 197, 233, 255),
+                        new Color32(251, 114, 147, 255),
+                        new Color32(103, 224, 227, 255),
+                        new Color32(224, 98, 174, 255),
+                        new Color32(159, 230, 184, 255),
+                        new Color32(230, 144, 209, 255),
+                        new Color32(255, 219, 92, 255),
+                        new Color32(230, 188, 243, 255),
+                        new Color32(157, 150, 245, 255),
+                        new Color32(131, 120, 234, 255),
+                        new Color32(150, 191, 255, 255)
+                    },
+                    m_CustomColorPalette = new List<Color32>{
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear
+                    }
+                };
+            }
+        }
+
+        /// <summary>
+        /// dark theme. 
+        /// 暗主题。
+        /// </summary>
+        /// <value></value>
+        public static ThemeInfo Dark
+        {
+            get
+            {
+                return new ThemeInfo()
+                {
+                    m_Theme = Theme.Dark,
+                    m_Font = Resources.GetBuiltinResource<Font>("Arial.ttf"),
+                    m_LegendUnableColor = GetColor("#cccccc"),
+                    m_BackgroundColor = new Color32(34, 34, 34, 255),
+                    m_TitleTextColor = GetColor("#eee"),
+                    m_TitleSubTextColor = GetColor("#eee"),
+                    m_LegendTextColor = GetColor("#eee"),
+                    m_AxisTextColor = GetColor("#eee"),
+                    m_AxisLineColor = GetColor("#eee"),
+                    m_AxisSplitLineColor = GetColor("#aaa"),
+                    m_TooltipBackgroundColor = GetColor("#515151C8"),
+                    m_TooltipTextColor = GetColor("#FFFFFFFF"),
+                    m_TooltipFlagAreaColor = GetColor("#51515120"),
+                    m_TooltipLabelColor = GetColor("#A7A7A7FF"),
+                    m_TooltipLineColor = GetColor("#eee"),
+                    m_DataZoomLineColor = GetColor("#FFFFFF45"),
+                    m_DataZoomSelectedColor = GetColor("#D0D0D03D"),
+                    m_DataZoomTextColor = GetColor("#FFFFFFFF"),
+                    m_VisualMapBackgroundColor = GetColor("#aaa"),
+                    m_VisualMapBorderColor = GetColor("#cccccc"),
+                    m_ColorPalette = new Color32[]
+                    {
+                        new Color32(221, 107, 102, 255),
+                        new Color32(117, 154, 160, 255),
+                        new Color32(230, 157, 135, 255),
+                        new Color32(141, 193, 169, 255),
+                        new Color32(234, 126, 83, 255),
+                        new Color32(238, 221, 120, 255),
+                        new Color32(115, 163, 115, 255),
+                        new Color32(115, 185, 188, 255),
+                        new Color32(114, 137, 171, 255),
+                        new Color32(145, 202, 140, 255),
+                        new Color32(244, 159, 66, 255)
+                    },
+                    m_CustomColorPalette = new List<Color32>{
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear,
+                        Color.clear
+                    }
+                };
+            }
+        }
+
+        /// <summary>
+        /// Convert the html string to color. 
+        /// 将字符串颜色值转成Color。
+        /// </summary>
+        /// <param name="hexColorStr"></param>
+        /// <returns></returns>
+        public static Color32 GetColor(string hexColorStr)
+        {
+            Color color;
+            ColorUtility.TryParseHtmlString(hexColorStr, out color);
+            return (Color32)color;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+            else if (obj is ThemeInfo)
+            {
+                return Equals((ThemeInfo)obj);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool Equals(ThemeInfo other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+            return m_Font == other.m_Font &&
+                ChartHelper.IsValueEqualsColor(m_LegendUnableColor, other.m_LegendUnableColor) &&
+                ChartHelper.IsValueEqualsColor(m_BackgroundColor, other.m_BackgroundColor) &&
+                ChartHelper.IsValueEqualsColor(m_TitleTextColor, other.m_TitleTextColor) &&
+                ChartHelper.IsValueEqualsColor(m_TitleSubTextColor, other.m_TitleSubTextColor) &&
+                ChartHelper.IsValueEqualsColor(m_AxisTextColor, other.m_AxisTextColor) &&
+                ChartHelper.IsValueEqualsColor(m_AxisLineColor, other.m_AxisLineColor) &&
+                ChartHelper.IsValueEqualsColor(m_AxisSplitLineColor, other.m_AxisSplitLineColor) &&
+                ChartHelper.IsValueEqualsColor(m_TooltipBackgroundColor, other.m_TooltipBackgroundColor) &&
+                ChartHelper.IsValueEqualsColor(m_AxisSplitLineColor, other.m_AxisSplitLineColor) &&
+                ChartHelper.IsValueEqualsColor(m_TooltipTextColor, other.m_TooltipTextColor) &&
+                ChartHelper.IsValueEqualsColor(m_TooltipFlagAreaColor, other.m_TooltipFlagAreaColor) &&
+                ChartHelper.IsValueEqualsColor(m_DataZoomLineColor, other.m_DataZoomLineColor) &&
+                ChartHelper.IsValueEqualsColor(m_DataZoomSelectedColor, other.m_DataZoomSelectedColor) &&
+                ChartHelper.IsValueEqualsColor(m_DataZoomTextColor, other.m_DataZoomTextColor) &&
+                m_ColorPalette.Length == other.m_ColorPalette.Length;
+        }
+
+        public static bool operator ==(ThemeInfo left, ThemeInfo right)
+        {
+            if (ReferenceEquals(left, null) && ReferenceEquals(right, null))
+            {
+                return true;
+            }
+            else if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
+            {
+                return false;
+            }
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(ThemeInfo left, ThemeInfo right)
+        {
+            return !(left == right);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+    }
+}

Scripts/Runtime/Component/Main/Theme.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7fa63cd119419441789620060693a7cb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Title.cs

@@ -0,0 +1,155 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using System;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Title component, including main title and subtitle.
+    /// 标题组件，包含主标题和副标题。
+    /// </summary>
+    [Serializable]
+    public class Title : MainComponent, IPropertyChanged, IEquatable<Title>
+    {
+        [SerializeField] private bool m_Show = true;
+        [SerializeField] private string m_Text;
+        [SerializeField] private int m_TextFontSize;
+        [SerializeField] private string m_SubText;
+        [SerializeField] private int m_SubTextFontSize;
+        [SerializeField] private float m_ItemGap;
+        [SerializeField] private Location m_Location;
+
+        /// <summary>
+        /// [default:true]
+        /// Set this to false to prevent the title from showing.
+        /// 是否显示标题组件。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// The main title text, supporting for \n for newlines.
+        /// 主标题文本，支持使用 \n 换行。
+        /// </summary>
+        public string text { get { return m_Text; } set { m_Text = value; } }
+        /// <summary>
+        /// [default:16]
+        /// main title font size.
+        /// 主标题文字的字体大小。
+        /// </summary>
+        public int textFontSize { get { return m_TextFontSize; } set { m_TextFontSize = value; } }
+        /// <summary>
+        /// Subtitle text, supporting for \n for newlines.
+        /// 副标题文本，支持使用 \n 换行。
+        /// </summary>
+        public string subText { get { return m_SubText; } set { m_SubText = value; } }
+        /// <summary>
+        /// [default:14]
+        /// subtitle font size.
+        /// 副标题文字的字体大小。
+        /// </summary>
+        public int subTextFontSize { get { return m_SubTextFontSize; } set { m_SubTextFontSize = value; } }
+        /// <summary>
+        /// [default:14]
+        /// The gap between the main title and subtitle.
+        /// 主副标题之间的间距。
+        /// </summary>
+        public float itemGap { get { return m_ItemGap; } set { m_ItemGap = value; } }
+        /// <summary>
+        /// The location of title component.
+        /// 标题显示位置。
+        /// </summary>
+        public Location location { get { return m_Location; } set { m_Location = value; } }
+
+        public static Title defaultTitle
+        {
+            get
+            {
+                var title = new Title
+                {
+                    m_Show = true,
+                    m_Text = "Chart Title",
+                    m_TextFontSize = 16,
+                    m_SubText = "",
+                    m_SubTextFontSize = 14,
+                    m_ItemGap = 8,
+                    m_Location = Location.defaultTop
+                };
+                return title;
+            }
+        }
+        public void Copy(Title title)
+        {
+            m_Show = title.show;
+            m_Text = title.text;
+            m_TextFontSize = title.textFontSize;
+            m_SubText = title.subText;
+            m_SubTextFontSize = title.subTextFontSize;
+            m_ItemGap = title.itemGap;
+            m_Location.Copy(title.location);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+            else if (obj is Title)
+            {
+                return Equals((Title)obj);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool Equals(Title other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+            return m_Show == other.show &&
+                m_Text.Equals(other.text) &&
+                m_TextFontSize == other.textFontSize &&
+                m_SubText.Equals(other.subText) &&
+                m_SubTextFontSize == other.subTextFontSize &&
+                m_ItemGap == other.itemGap &&
+                m_Location.Equals(other.location);
+        }
+
+        public static bool operator ==(Title left, Title right)
+        {
+            if (ReferenceEquals(left, null) && ReferenceEquals(right, null))
+            {
+                return true;
+            }
+            else if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
+            {
+                return false;
+            }
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(Title left, Title right)
+        {
+            return !(left == right);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        public void OnChanged()
+        {
+            m_Location.OnChanged();
+        }
+    }
+}

Scripts/Runtime/Component/Main/Title.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 91e9a1a59b4b64142a9aa260f618c1c1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/Tooltip.cs

@@ -0,0 +1,396 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Tooltip component.
+    /// 提示框组件
+    /// </summary>
+    [System.Serializable]
+    public class Tooltip : MainComponent
+    {
+        /// <summary>
+        /// Indicator type.
+        /// 指示器类型。
+        /// </summary>
+        public enum Type
+        {
+            /// <summary>
+            /// line indicator.
+            /// 直线指示器
+            /// </summary>
+            Line,
+            /// <summary>
+            /// shadow crosshair indicator.
+            /// 阴影指示器
+            /// </summary>
+            Shadow,
+            /// <summary>
+            /// no indicator displayed.
+            /// 无指示器
+            /// </summary>
+            None,
+            /// <summary>
+            /// crosshair indicator, which is actually the shortcut of enable two axisPointers of two orthometric axes.
+            /// 十字准星指示器。坐标轴显示Label和交叉线。
+            /// </summary>
+            Corss
+        }
+
+        [SerializeField] private bool m_Show;
+        [SerializeField] private Type m_Type;
+        [SerializeField] private string m_Formatter;
+        [SerializeField] private float m_FixedWidth = 0;
+        [SerializeField] private float m_FixedHeight = 0;
+        [SerializeField] private float m_MinWidth = 0;
+        [SerializeField] private float m_MinHeight = 0;
+        [SerializeField] private int m_FontSize = 18;
+        [SerializeField] private FontStyle m_FontStyle = FontStyle.Normal;
+
+        private GameObject m_GameObject;
+        private GameObject m_Content;
+        private Text m_ContentText;
+        private RectTransform m_ContentRect;
+        private List<int> lastDataIndex { get; set; }
+
+        /// <summary>
+        /// Whether to show the tooltip component.
+        /// 是否显示提示框组件。
+        /// </summary>
+        /// <returns></returns>
+        public bool show { get { return m_Show; } set { m_Show = value; SetActive(value); } }
+        /// <summary>
+        /// Indicator type.
+        /// 提示框指示器类型。
+        /// </summary>
+        public Type type { get { return m_Type; } set { m_Type = value; } }
+        /// <summary>
+        /// 提示框内容字符串模版格式器。支持用 \n 或 "<br/>" 换行。
+        /// 模板变量有 {a}, {b}，{c}，{d}，{e}，分别表示系列名，数据名，数据值等。
+        /// 其中变量{a}, {b}, {c}, {d}在不同图表类型下代表数据含义为：
+        /// <list type="bullet">
+        /// <item><description>折线（区域）图、柱状（条形）图、K线图 : {a}（系列名称），{b}（类目值），{c}（数值）, {d}（无）。</description></item>
+        /// <item><description>散点图（气泡）图 : {a}（系列名称），{b}（数据名称），{c}（数值数组）, {d}（无）。</description></item>
+        /// <item><description>地图 : {a}（系列名称），{b}（区域名称），{c}（合并数值）, {d}（无）。</description></item>
+        /// <item><description>饼图、仪表盘、漏斗图: {a}（系列名称），{b}（数据项名称），{c}（数值）, {d}（百分比）。</description></item>
+        /// </list>
+        /// </summary>
+        /// <example>
+        /// 示例：“{a}:{c}”
+        /// </example>
+        public string formatter { get { return m_Formatter; } set { m_Formatter = value; } }
+        /// <summary>
+        /// 固定宽度。比 minWidth 优先。
+        /// </summary>
+        public float fixedWidth { get { return m_FixedWidth; } set { m_FixedWidth = value; } }
+        /// <summary>
+        /// 固定高度。比 minHeight 优先。
+        /// </summary>
+        public float fixedHeight { get { return m_FixedHeight; } set { m_FixedHeight = value; } }
+        /// <summary>
+        /// 最小宽度。如若 fixedWidth 设有值，优先取 fixedWidth。
+        /// </summary>
+        public float minWidth { get { return m_MinWidth; } set { m_MinWidth = value; } }
+        /// <summary>
+        /// 最小高度。如若 fixedHeight 设有值，优先取 fixedHeight。
+        /// </summary>
+        public float minHeight { get { return m_MinHeight; } set { m_MinHeight = value; } }
+        /// <summary>
+        /// font size.
+        /// 文字的字体大小。
+        /// </summary>
+        public int fontSize { get { return m_FontSize; } set { m_FontSize = value; } }
+        /// <summary>
+        /// font style.
+        /// 文字的字体风格。
+        /// </summary>
+        public FontStyle fontStyle { get { return m_FontStyle; } set { m_FontStyle = value; } }
+
+        /// <summary>
+        /// The data index currently indicated by Tooltip.
+        /// 当前提示框所指示的数据项索引。
+        /// </summary>
+        public List<int> dataIndex { get; set; }
+        /// <summary>
+        /// the value for x indicator label.
+        /// 指示器X轴上要显示的值。
+        /// </summary>
+        public float[] xValues { get; set; }
+        /// <summary>
+        /// the value for y indicator label. 
+        /// 指示器Y轴上要显示的值。
+        /// </summary>
+        public float[] yValues { get; set; }
+        /// <summary>
+        /// the current pointer position.
+        /// 当前鼠标位置。
+        /// </summary>
+        public Vector2 pointerPos { get; set; }
+        /// <summary>
+        /// the width of tooltip. 
+        /// 提示框宽。
+        /// </summary>
+        public float width { get { return m_ContentRect.sizeDelta.x; } }
+        /// <summary>
+        /// the height of tooltip. 
+        /// 提示框高。
+        /// </summary>
+        public float height { get { return m_ContentRect.sizeDelta.y; } }
+        /// <summary>
+        /// Whether the tooltip has been initialized. 
+        /// 提示框是否已初始化。
+        /// </summary>
+        public bool inited { get { return m_GameObject != null; } }
+        /// <summary>
+        /// the gameObject of tooltip. 
+        /// 提示框的gameObject。
+        /// </summary>
+        public GameObject gameObject { get { return m_GameObject; } }
+
+        public static Tooltip defaultTooltip
+        {
+            get
+            {
+                var tooltip = new Tooltip
+                {
+                    m_Show = true,
+                    xValues = new float[2] { -1, -1 },
+                    yValues = new float[2] { -1, -1 },
+                    dataIndex = new List<int>() { -1, -1 },
+                    lastDataIndex = new List<int>() { -1, -1 }
+                };
+                return tooltip;
+            }
+        }
+
+        /// <summary>
+        /// 绑定提示框gameObject
+        /// </summary>
+        /// <param name="obj"></param>
+        public void SetObj(GameObject obj)
+        {
+            m_GameObject = obj;
+            m_GameObject.SetActive(false);
+        }
+
+        /// <summary>
+        /// 绑定提示框的文本框gameObject
+        /// </summary>
+        /// <param name="content"></param>
+        public void SetContentObj(GameObject content)
+        {
+            m_Content = content;
+            m_ContentRect = m_Content.GetComponent<RectTransform>();
+            m_ContentText = m_Content.GetComponentInChildren<Text>();
+        }
+
+        /// <summary>
+        /// Keep Tooltiop displayed at the top. 
+        /// 保持Tooltiop显示在最顶上
+        /// </summary>
+        public void UpdateToTop()
+        {
+            int count = m_GameObject.transform.parent.childCount;
+            m_GameObject.GetComponent<RectTransform>().SetSiblingIndex(count - 1);
+        }
+
+        /// <summary>
+        /// 设置提示框文本背景色
+        /// </summary>
+        /// <param name="color"></param>
+        public void SetContentBackgroundColor(Color color)
+        {
+            m_Content.GetComponent<Image>().color = color;
+        }
+
+        /// <summary>
+        /// 设置提示框文本字体颜色
+        /// </summary>
+        /// <param name="color"></param>
+        public void SetContentTextColor(Color color)
+        {
+            if (m_ContentText)
+            {
+                m_ContentText.color = color;
+            }
+        }
+
+        /// <summary>
+        /// 设置提示框文本内容
+        /// </summary>
+        /// <param name="txt"></param>
+        public void UpdateContentText(string txt)
+        {
+            if (m_ContentText)
+            {
+                m_ContentText.text = txt;
+                float wid, hig;
+                if (m_FixedWidth > 0) wid = m_FixedWidth;
+                else if (m_MinWidth > 0 && m_ContentText.preferredWidth < m_MinWidth) wid = m_MinWidth;
+                else wid = m_ContentText.preferredWidth + 8;
+                if (m_FixedHeight > 0) hig = m_FixedHeight;
+                else if (m_MinHeight > 0 && m_ContentText.preferredHeight < m_MinHeight) hig = m_MinHeight;
+                else hig = m_ContentText.preferredHeight + 8;
+                m_ContentRect.sizeDelta = new Vector2(wid, hig);
+            }
+        }
+
+        /// <summary>
+        /// 清除提示框指示数据
+        /// </summary>
+        public void ClearValue()
+        {
+            dataIndex[0] = dataIndex[1] = -1;
+            xValues[0] = xValues[1] = -1;
+            yValues[0] = yValues[1] = -1;
+        }
+
+        /// <summary>
+        /// 提示框是否显示
+        /// </summary>
+        /// <returns></returns>
+        public bool IsActive()
+        {
+            return m_GameObject != null && m_GameObject.activeInHierarchy;
+        }
+
+        /// <summary>
+        /// 设置提示框是否显示
+        /// </summary>
+        /// <param name="flag"></param>
+        public void SetActive(bool flag)
+        {
+            lastDataIndex[0] = lastDataIndex[1] = -1;
+            if (m_GameObject && m_GameObject.activeInHierarchy != flag)
+                m_GameObject.SetActive(flag);
+        }
+
+        /// <summary>
+        /// 更新文本框位置
+        /// </summary>
+        /// <param name="pos"></param>
+        public void UpdateContentPos(Vector2 pos)
+        {
+            if (m_Content)
+                m_Content.transform.localPosition = pos;
+        }
+
+        /// <summary>
+        /// 获得当前提示框的位置
+        /// </summary>
+        /// <returns></returns>
+        public Vector3 GetContentPos()
+        {
+            if (m_Content)
+                return m_Content.transform.localPosition;
+            else
+                return Vector3.zero;
+        }
+
+        /// <summary>
+        /// Whether the data item indicated by tooltip has changed. 
+        /// 提示框所指示的数据项是否发生变化。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsDataIndexChanged()
+        {
+            return dataIndex[0] != lastDataIndex[0] ||
+                dataIndex[1] != lastDataIndex[1];
+        }
+
+        /// <summary>
+        /// 当前索引缓存
+        /// </summary>
+        public void UpdateLastDataIndex()
+        {
+            lastDataIndex[0] = dataIndex[0];
+            lastDataIndex[1] = dataIndex[1];
+        }
+
+        /// <summary>
+        /// 当前提示框是否选中数据项
+        /// </summary>
+        /// <returns></returns>
+        public bool IsSelected()
+        {
+            return dataIndex[0] >= 0 || dataIndex[1] >= 0;
+        }
+
+        /// <summary>
+        /// 指定索引的数据项是否被提示框选中
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public bool IsSelected(int index)
+        {
+            return dataIndex[0] == index || dataIndex[1] == index;
+        }
+
+        public string GetFormatterContent(int dataIndex, Series series, string category, DataZoom dataZoom = null)
+        {
+            if (string.IsNullOrEmpty(m_Formatter))
+            {
+                return "";
+            }
+            else
+            {
+                string content = m_Formatter;
+                for (int i = 0; i < series.Count; i++)
+                {
+                    var serie = series.GetSerie(i);
+                    if (serie.show)
+                    {
+                        var needCategory = serie.type == SerieType.Line || serie.type == SerieType.Bar;
+                        var serieData = serie.GetSerieData(dataIndex, dataZoom);
+                        if (i == 0)
+                        {
+                            content = content.Replace("{a}", serie.name);
+                            content = content.Replace("{b}", needCategory ? category : serieData.name);
+                            content = content.Replace("{c}", ChartCached.FloatToStr(serieData.GetData(1)));
+                            //if (serie.type == SerieType.Pie)
+                            {
+                                var percent = serieData.GetData(1) / serie.yTotal * 100;
+                                content = content.Replace("{d}", ChartCached.FloatToStr(percent, 1));
+                            }
+                        }
+                        content = content.Replace("{a" + i + "}", serie.name);
+                        content = content.Replace("{b" + i + "}", needCategory ? category : serieData.name);
+                        content = content.Replace("{c" + i + "}", ChartCached.FloatToStr(serieData.GetData(1)));
+                        //if (serie.type == SerieType.Pie)
+                        {
+                            var percent = serieData.GetData(1) / serie.yTotal * 100;
+                            content = content.Replace("{d" + i + "}", ChartCached.FloatToStr(percent, 1));
+                        }
+                    }
+                }
+                content = content.Replace("\\n", "\n");
+                content = content.Replace("<br/>", "\n");
+                return content;
+            }
+        }
+
+        public string GetFormatterContent(string serieName, string dataName, float dataValue)
+        {
+            if (string.IsNullOrEmpty(m_Formatter))
+                return ChartCached.FloatToStr(dataValue);
+            else
+            {
+                var content = m_Formatter.Replace("{a}", serieName);
+                content = content.Replace("{b}", dataName);
+                content = content.Replace("{c}", ChartCached.FloatToStr(dataValue));
+                content = content.Replace("\\n", "\n");
+                content = content.Replace("<br/>", "\n");
+                return content;
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Main/Tooltip.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c75ff9b455a74482db10158ca81afe89
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Main/VisualMap.cs

@@ -0,0 +1,394 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// VisualMap component.
+    /// 视觉映射组件。用于进行『视觉编码』，也就是将数据映射到视觉元素（视觉通道）。
+    /// </summary>
+    [System.Serializable]
+    public class VisualMap : MainComponent
+    {
+        /// <summary>
+        /// 类型。分为连续型和分段型。
+        /// </summary>
+        public enum Type
+        {
+            /// <summary>
+            /// 连续型。
+            /// </summary>
+            Continuous,
+            /// <summary>
+            /// 分段型。
+            /// </summary>
+            Piecewise
+        }
+
+        /// <summary>
+        /// 选择模式
+        /// </summary>
+        public enum SelectedMode
+        {
+            /// <summary>
+            /// 多选。
+            /// </summary>
+            Multiple,
+            /// <summary>
+            /// 单选。
+            /// </summary>
+            Single
+        }
+
+        [SerializeField] private bool m_Enable = false;
+        [SerializeField] private bool m_Show = true;
+        [SerializeField] private Type m_Type = Type.Continuous;
+        [SerializeField] private SelectedMode m_SelectedMode = SelectedMode.Multiple;
+        [SerializeField] private float m_Min = 0;
+        [SerializeField] private float m_Max = 100f;
+
+        [SerializeField] private float[] m_Range = new float[2] { 0, 100f };
+        [SerializeField] private string[] m_Text = new string[2] { "", "" };
+        [SerializeField] private float[] m_TextGap = new float[2] { 10f, 10f };
+        [SerializeField] private int m_SplitNumber = 5;
+        [SerializeField] private bool m_Calculable = false;
+        [SerializeField] private bool m_Realtime = true;
+        [SerializeField] private float m_ItemWidth = 20f;
+        [SerializeField] private float m_ItemHeight = 140f;
+        [SerializeField] private float m_BorderWidth = 0;
+        [SerializeField] private int m_Dimension = 0;
+        [SerializeField] private bool m_HoverLink = true;
+        [SerializeField] private Orient m_Orient = Orient.Horizonal;
+        [SerializeField] private Location m_Location = Location.defaultLeft;
+        [SerializeField] private List<Color> m_InRange = new List<Color>();
+        [SerializeField] private List<Color> m_OutOfRange = new List<Color>();
+
+        /// <summary>
+        /// 是否开启组件功能。
+        /// </summary>
+        public bool enable { get { return m_Enable; } set { m_Enable = value; } }
+        /// <summary>
+        /// 是否显示组件。如果设置为 false，不会显示，但是数据映射的功能还存在。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// 组件类型。
+        /// </summary>
+        public Type type { get { return m_Type; } set { m_Type = value; } }
+        /// <summary>
+        /// 选择模式。
+        /// </summary>
+        public SelectedMode selectedMode { get { return m_SelectedMode; } set { m_SelectedMode = value; } }
+        /// <summary>
+        /// 允许的最小值。'min' 必须用户指定。[visualMap.min, visualMap.max] 形成了视觉映射的『定义域』。
+        /// </summary>
+        public float min { get { return m_Min; } set { m_Min = value; } }
+        /// <summary>
+        /// 允许的最大值。'max' 必须用户指定。[visualMap.min, visualMax.max] 形成了视觉映射的『定义域』。
+        /// </summary>
+        public float max { get { return m_Max; } set { m_Max = value < min ? min + 1 : value; } }
+        /// <summary>
+        /// 指定手柄对应数值的位置。range 应在 min max 范围内。
+        /// </summary>
+        public float[] range { get { return m_Range; } }
+        /// <summary>
+        /// 两端的文本，如 ['High', 'Low']。
+        /// </summary>
+        public string[] text { get { return m_Text; } }
+        /// <summary>
+        /// 两端文字主体之间的距离，单位为px。
+        /// </summary>
+        public float[] textGap { get { return m_TextGap; } }
+        /// <summary>
+        /// 对于连续型数据，自动平均切分成几段，默认为0时自动匹配inRange颜色列表大小。
+        /// </summary>
+        /// <value></value>
+        public int splitNumber { get { return m_SplitNumber; } set { m_SplitNumber = value; } }
+        /// <summary>
+        /// 是否显示拖拽用的手柄（手柄能拖拽调整选中范围）。
+        /// </summary>
+        public bool calculable { get { return m_Calculable; } set { m_Calculable = value; } }
+        /// <summary>
+        /// 拖拽时，是否实时更新。
+        /// </summary>
+        public bool realtime { get { return m_Realtime; } set { m_Realtime = value; } }
+        /// <summary>
+        /// 图形的宽度，即颜色条的宽度。
+        /// </summary>
+        public float itemWidth { get { return m_ItemWidth; } set { m_ItemWidth = value; } }
+        /// <summary>
+        /// 图形的高度，即颜色条的高度。
+        /// </summary>
+        public float itemHeight { get { return m_ItemHeight; } set { m_ItemHeight = value; } }
+        /// <summary>
+        /// 边框线宽，单位px。
+        /// </summary>
+        public float borderWidth { get { return m_BorderWidth; } set { m_BorderWidth = value; } }
+        /// <summary>
+        /// 指定用数据的『哪个维度』，映射到视觉元素上。『数据』即 series.data。从1开始，默认为0取 data 中最后一个维度。
+        /// </summary>
+        public int dimension { get { return m_Dimension; } set { m_Dimension = value; } }
+        /// <summary>
+        /// 打开 hoverLink 功能时，鼠标悬浮到 visualMap 组件上时，鼠标位置对应的数值 在 图表中对应的图形元素，会高亮。
+        /// 反之，鼠标悬浮到图表中的图形元素上时，在 visualMap 组件的相应位置会有三角提示其所对应的数值。
+        /// </summary>
+        /// <value></value>
+        public bool hoverLink { get { return m_HoverLink; } set { m_HoverLink = value; } }
+        /// <summary>
+        /// Specify whether the layout of component is horizontal or vertical. 
+        /// 布局方式是横还是竖。
+        /// </summary>
+        public Orient orient { get { return m_Orient; } set { m_Orient = value; } }
+        /// <summary>
+        /// The location of component.
+        /// 组件显示的位置。
+        /// </summary>
+        public Location location { get { return m_Location; } set { m_Location = value; } }
+        /// <summary>
+        /// 定义 在选中范围中 的视觉颜色。
+        /// </summary>
+        public List<Color> inRange { get { return m_InRange; } set { if (value != null) m_InRange = value; } }
+        /// <summary>
+        /// 定义 在选中范围外 的视觉颜色。
+        /// </summary>
+        public List<Color> outOfRange { get { return m_OutOfRange; } set { if (value != null) m_OutOfRange = value; } }
+
+        /// <summary>
+        /// 鼠标悬停选中的index
+        /// </summary>
+        /// <value></value>
+        public int rtSelectedIndex { get; set; }
+        public float rtSelectedValue { get; set; }
+        /// <summary>
+        /// the current pointer position.
+        /// 当前鼠标位置。
+        /// </summary>
+        public Vector2 pointerPos { get; set; }
+        public bool isVertical { get { return orient == Orient.Vertical; } }
+        public float rangeMin
+        {
+            get
+            {
+                if (m_Range[0] < min || m_Range[0] > max) return min;
+                else return m_Range[0];
+            }
+            set
+            {
+                if (value >= min && value <= m_Range[1]) m_Range[0] = value;
+            }
+        }
+
+        public float rangeMax
+        {
+            get
+            {
+                if (m_Range[1] >= m_Range[0] && m_Range[1] < max) return m_Range[1];
+                else return max;
+            }
+            set
+            {
+                if (value >= m_Range[0] && value <= max) m_Range[1] = value;
+            }
+        }
+
+        public int rtSplitNumber
+        {
+            get
+            {
+                if (splitNumber > 0 && splitNumber <= m_InRange.Count) return splitNumber;
+                else return inRange.Count;
+            }
+        }
+
+        public float rangeMinHeight { get { return (rangeMin - min) / (max - min) * itemHeight; } }
+        public float rangeMaxHeight { get { return (rangeMax - min) / (max - min) * itemHeight; } }
+
+        private List<Color> m_RtInRange = new List<Color>();
+        public List<Color> rtInRange
+        {
+            get
+            {
+                if (splitNumber == 0 || m_InRange.Count >= splitNumber || m_InRange.Count < 1) return m_InRange;
+                else
+                {
+                    if (m_RtInRange.Count != rtSplitNumber)
+                    {
+                        m_RtInRange.Clear();
+                        var total = max - min;
+                        var diff1 = total / (m_InRange.Count - 1);
+                        var diff2 = total / splitNumber;
+
+                        var inCount = 0;
+                        var inValue = min;
+                        var rtValue = min;
+
+
+                        for (int i = 0; i < splitNumber; i++)
+                        {
+                            rtValue += diff2;
+                            if (rtValue > inValue + diff1)
+                            {
+                                inValue += diff1;
+                                inCount++;
+                            }
+                            if (i == splitNumber - 1)
+                            {
+                                m_RtInRange.Add(m_InRange[m_InRange.Count - 1]);
+                            }
+                            else
+                            {
+                                var rate = (rtValue - inValue) / diff1;
+                                m_RtInRange.Add(Color.Lerp(m_InRange[inCount], m_InRange[inCount + 1], rate));
+                            }
+                        }
+                    }
+                    return m_RtInRange;
+                }
+            }
+        }
+
+        public Color GetColor(float value)
+        {
+            int splitNumber = rtInRange.Count;
+            if (splitNumber <= 0) return Color.clear;
+            value = Mathf.Clamp(value, min, max);
+
+            var diff = (max - min) / (splitNumber - 1);
+            var index = GetIndex(value);
+            var nowMin = min + index * diff;
+            var rate = (value - nowMin) / diff;
+            if (index == splitNumber - 1) return rtInRange[index];
+            else return Color.Lerp(rtInRange[index], rtInRange[index + 1], rate);
+        }
+
+        public int GetIndex(float value)
+        {
+            int splitNumber = rtInRange.Count;
+            if (splitNumber <= 0) return -1;
+            value = Mathf.Clamp(value, min, max);
+
+            var diff = (max - min) / (splitNumber - 1);
+            var index = -1;
+            for (int i = 0; i < splitNumber; i++)
+            {
+                if (value <= min + (i + 1) * diff)
+                {
+                    index = i;
+                    break;
+                }
+            }
+            return index;
+        }
+
+        public bool IsInSelectedValue(float value)
+        {
+            if (rtSelectedIndex < 0) return true;
+            else
+            {
+                return rtSelectedIndex == GetIndex(value);
+            }
+        }
+
+        public float GetValue(Vector3 pos, float chartWidth, float chartHeight)
+        {
+            var centerPos = location.GetPosition(chartWidth, chartHeight);
+            var pos1 = centerPos + (isVertical ? Vector3.down : Vector3.left) * itemHeight / 2;
+            var pos2 = centerPos + (isVertical ? Vector3.up : Vector3.right) * itemHeight / 2;
+            if (isVertical)
+            {
+                if (pos.y < pos1.y) return min;
+                else if (pos.y > pos2.y) return max;
+                else return min + (pos.y - pos1.y) / (pos2.y - pos1.y) * (max - min);
+            }
+            else
+            {
+                if (pos.x < pos1.x) return min;
+                else if (pos.x > pos2.x) return max;
+                else return min + (pos.x - pos1.x) / (pos2.x - pos1.x) * (max - min);
+            }
+        }
+
+        public bool IsInRect(Vector3 local, float chartWidth, float chartHeight, float triangleLen = 20)
+        {
+            var centerPos = location.GetPosition(chartWidth, chartHeight);
+            var diff = calculable ? triangleLen : 0;
+            if (local.x >= centerPos.x - itemWidth / 2 - diff && local.x <= centerPos.x + itemWidth / 2 + diff &&
+                local.y >= centerPos.y - itemHeight / 2 - diff && local.y <= centerPos.y + itemHeight / 2 + diff)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool IsInRangeRect(Vector3 local, float chartWidth, float chartHeight)
+        {
+            var centerPos = location.GetPosition(chartWidth, chartHeight);
+            if (orient == Orient.Vertical)
+            {
+                var pos1 = centerPos + Vector3.down * itemHeight / 2;
+                return local.x >= centerPos.x - itemWidth / 2 && local.x <= centerPos.x + itemWidth / 2 &&
+                local.y >= pos1.y + rangeMinHeight && local.y <= pos1.y + rangeMaxHeight;
+            }
+            else
+            {
+                var pos1 = centerPos + Vector3.left * itemHeight / 2;
+                return local.x >= pos1.x + rangeMinHeight && local.x <= pos1.x + rangeMaxHeight &&
+                local.y >= centerPos.y - itemWidth / 2 && local.y <= centerPos.y + itemWidth / 2;
+            }
+        }
+
+        public bool IsInRangeMinRect(Vector3 local, float chartWidth, float chartHeight, float triangleLen)
+        {
+            var centerPos = location.GetPosition(chartWidth, chartHeight);
+            if (orient == Orient.Vertical)
+            {
+                var radius = triangleLen / 2;
+                var pos1 = centerPos + Vector3.down * itemHeight / 2;
+                var cpos = new Vector3(pos1.x + itemWidth / 2 + radius, pos1.y + rangeMinHeight - radius);
+
+                return local.x >= cpos.x - radius && local.x <= cpos.x + radius &&
+                local.y >= cpos.y - radius && local.y <= cpos.y + radius;
+            }
+            else
+            {
+                var radius = triangleLen / 2;
+                var pos1 = centerPos + Vector3.left * itemHeight / 2;
+                var cpos = new Vector3(pos1.x + rangeMinHeight, pos1.y + itemWidth / 2 + radius);
+                return local.x >= cpos.x - radius && local.x <= cpos.x + radius &&
+                local.y >= cpos.y - radius && local.y <= cpos.y + radius;
+            }
+        }
+
+        public bool IsInRangeMaxRect(Vector3 local, float chartWidth, float chartHeight, float triangleLen)
+        {
+            var centerPos = location.GetPosition(chartWidth, chartHeight);
+            if (orient == Orient.Vertical)
+            {
+                var radius = triangleLen / 2;
+                var pos1 = centerPos + Vector3.down * itemHeight / 2;
+                var cpos = new Vector3(pos1.x + itemWidth / 2 + radius, pos1.y + rangeMaxHeight + radius);
+
+                return local.x >= cpos.x - radius && local.x <= cpos.x + radius &&
+                local.y >= cpos.y - radius && local.y <= cpos.y + radius;
+            }
+            else
+            {
+                var radius = triangleLen / 2;
+                var pos1 = centerPos + Vector3.left * itemHeight / 2;
+                var cpos = new Vector3(pos1.x + rangeMaxHeight + radius, pos1.y + itemWidth / 2 + radius);
+                return local.x >= cpos.x - radius && local.x <= cpos.x + radius &&
+                local.y >= cpos.y - radius && local.y <= cpos.y + radius;
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Main/VisualMap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2df2ffc144e3347828462bb972eec23a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/MainComponent.cs

@@ -0,0 +1,13 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+namespace XCharts
+{
+    public class MainComponent : ChartComponent
+    {
+    }
+}

Scripts/Runtime/Component/MainComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a0b05891df2284bc588cf6b668bfeb7b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 20d31ade0390641698e6b846b4294b74
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/Animation.cs

@@ -0,0 +1,241 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// the animation of serie.
+    /// 动画表现。
+    /// </summary>
+    [System.Serializable]
+    public class Animation : SubComponent
+    {
+        public enum Easing
+        {
+            Linear,
+        }
+        [SerializeField] private bool m_Enable = true;
+        [SerializeField] private Easing m_Easting;
+        [SerializeField] private int m_Duration = 1000;
+        [SerializeField] private int m_Threshold = 2000;
+        [SerializeField] private int m_Delay = 0;
+        [SerializeField] private int m_ActualDuration;
+
+        /// <summary>
+        /// Whether to enable animation.
+        /// 是否开启动画效果。
+        /// </summary>
+        public bool enable { get { return m_Enable; } set { m_Enable = value; } }
+        /// <summary>
+        /// Easing method used for the first animation. 
+        /// 动画的缓动效果。
+        /// </summary>
+        /// <value></value>
+        public Easing easing { get { return m_Easting; } set { m_Easting = value; } }
+        /// <summary>
+        /// The milliseconds duration of the first animation.
+        /// 设定的动画时长（毫秒）。
+        /// </summary>
+        /// <value></value>
+        public int duration { get { return m_Duration; } set { m_Duration = value; } }
+        /// <summary>
+        /// The milliseconds actual duration of the first animation.
+        /// 实际的动画时长（毫秒）。
+        /// </summary>
+        /// <value></value>
+        public int actualDuration { get { return m_ActualDuration; } }
+        /// <summary>
+        /// Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.
+        /// 是否开启动画的阈值，当单个系列显示的图形数量大于这个阈值时会关闭动画。
+        /// </summary>
+        /// <value></value>
+        public int threshold { get { return m_Threshold; } set { m_Threshold = value; } }
+        /// <summary>
+        /// The milliseconds delay before updating the first animation.
+        /// 动画延时（毫秒）。
+        /// </summary>
+        /// <value></value>
+        public int delay { get { return m_Delay; } set { m_Delay = value; if (m_Delay < 0) m_Delay = 0; } }
+
+        private Dictionary<int, float> m_DataAnimationState = new Dictionary<int, float>();
+        private bool m_IsStart = false;
+        private bool m_IsEnd = true;
+        private bool m_Inited = false;
+
+        private float startTime { get; set; }
+        private int m_CurrDataProgress { get; set; }
+        private int m_DestDataProgress { get; set; }
+        [SerializeField] private float m_CurrDetailProgress;
+        [SerializeField] private float m_DestDetailProgress;
+        private float m_CurrSymbolProgress;
+
+        public void Start()
+        {
+            if (m_IsStart) return;
+            startTime = Time.time;
+            m_IsStart = true;
+            m_IsEnd = false;
+            m_Inited = false;
+            m_CurrDataProgress = 1;
+            m_DestDataProgress = 1;
+            m_CurrDetailProgress = 0;
+            m_DestDetailProgress = 1;
+            m_CurrSymbolProgress = 0;
+            m_DataAnimationState.Clear();
+        }
+
+        public void Stop()
+        {
+            m_IsStart = false;
+            m_IsEnd = true;
+            m_Inited = false;
+            m_DataAnimationState.Clear();
+        }
+
+        public void End()
+        {
+            if (m_IsEnd) return;
+            m_ActualDuration = (int)((Time.time - startTime) * 1000) - delay;
+            m_CurrDataProgress = m_DestDataProgress + 1;
+            m_IsEnd = true;
+        }
+
+        public void Reset()
+        {
+            Stop();
+            Start();
+        }
+
+        public void InitProgress(int data, float curr, float dest)
+        {
+            if (!m_Inited && !m_IsEnd)
+            {
+                m_Inited = true;
+                m_DestDataProgress = data;
+                m_CurrDetailProgress = curr;
+                m_DestDetailProgress = dest;
+            }
+        }
+
+        public void SetDataFinish(int dataIndex)
+        {
+            if (!m_IsEnd)
+            {
+                m_CurrDataProgress = dataIndex + 1;
+            }
+        }
+
+        public void SetDataState(int index, float state)
+        {
+            m_DataAnimationState[index] = state;
+        }
+
+        public float GetDataState(int index)
+        {
+            if (IsInDelay()) return 0;
+            if (!m_DataAnimationState.ContainsKey(index))
+            {
+                m_DataAnimationState.Add(index, 0);
+            }
+            return m_DataAnimationState[index];
+        }
+
+        public bool IsFinish()
+        {
+#if UNITY_EDITOR
+            if (!Application.isPlaying) return true;
+#endif
+            return !enable || (m_CurrDataProgress > m_DestDataProgress && m_CurrDetailProgress > m_DestDetailProgress);
+        }
+
+        public bool IsInDelay()
+        {
+            return (delay > 0 && Time.time - startTime < delay / 1000);
+        }
+
+        public bool CheckDetailBreak(int dataIndex, float detail)
+        {
+            return !IsFinish() && detail > m_CurrDetailProgress;
+        }
+
+        public bool CheckDetailBreak(Vector3 pos, bool isYAxis)
+        {
+            if (IsFinish()) return false;
+            if (isYAxis) return pos.y > m_CurrDetailProgress;
+            else return pos.x > m_CurrDetailProgress;
+        }
+
+        public bool NeedAnimation(int dataIndex)
+        {
+            if (!m_Enable || m_IsEnd) return true;
+            if (IsInDelay()) return false;
+            return dataIndex <= m_CurrDataProgress;
+        }
+
+        public void CheckProgress(float delta)
+        {
+            if (!enable) return;
+            if (IsInDelay()) return;
+            if (m_IsEnd) return;
+            if (m_CurrDetailProgress > m_DestDetailProgress)
+            {
+                End();
+            }
+            else
+            {
+                m_ActualDuration = (int)((Time.time - startTime) * 1000) - delay;
+                m_CurrDetailProgress += delta;
+            }
+        }
+
+        public void CheckSymbol(float delta, float dest)
+        {
+            m_CurrSymbolProgress += delta;
+            if (m_CurrSymbolProgress > dest) m_CurrSymbolProgress = dest;
+        }
+
+        public float GetSysmbolSize(float dest)
+        {
+#if UNITY_EDITOR
+            if (!Application.isPlaying) return dest;
+#endif
+            if (!enable || m_IsEnd) return dest;
+            return m_CurrSymbolProgress;
+        }
+
+        public float GetCurrDetail()
+        {
+            return m_CurrDetailProgress;
+        }
+
+        public float GetCurrRate()
+        {
+#if UNITY_EDITOR
+            if (!Application.isPlaying) return 1;
+#endif
+            if (!enable || m_IsEnd) return 1;
+            return m_CurrDetailProgress;
+        }
+
+        public int GetCurrIndex()
+        {
+#if UNITY_EDITOR
+            if (!Application.isPlaying) return -1;
+#endif
+            if (!enable || m_IsEnd) return -1;
+            return (int)m_CurrDetailProgress;
+        }
+
+        public float GetCurrData()
+        {
+            return m_CurrDataProgress;
+        }
+    }
+}

Scripts/Runtime/Component/Sub/Animation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3d15d91eaba394eb5a7f19d499b3a61f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/AreaStyle.cs

@@ -0,0 +1,106 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// The style of area.
+    /// 区域填充样式。
+    /// </summary>
+    [System.Serializable]
+    public class AreaStyle : SubComponent
+    {
+        /// <summary>
+        /// Origin position of area.
+        /// 图形区域的起始位置。默认情况下，图形会从坐标轴轴线到数据间进行填充。如果需要填充的区域是坐标轴最大值到数据间，或者坐标轴最小值到数据间，则可以通过这个配置项进行设置。
+        /// </summary>
+        public enum AreaOrigin
+        {
+            /// <summary>
+            /// to fill between axis line to data.
+            /// 填充坐标轴轴线到数据间的区域。
+            /// </summary>
+            Auto,
+            /// <summary>
+            /// to fill between min axis value (when not inverse) to data.
+            /// 填充坐标轴底部到数据间的区域。
+            /// </summary>
+            Start,
+            /// <summary>
+            /// to fill between max axis value (when not inverse) to data.
+            /// 填充坐标轴顶部到数据间的区域。
+            /// </summary>
+            End
+        }
+        [SerializeField] private bool m_Show;
+        [SerializeField] private AreaOrigin m_Origin;
+        [SerializeField] private Color m_Color;
+        [SerializeField] private Color m_ToColor;
+        [SerializeField] [Range(0, 1)] private float m_Opacity;
+        [SerializeField] private bool m_TooltipHighlight;
+        [SerializeField] private Color m_HighlightColor;
+        [SerializeField] private Color m_HighlightToColor;
+
+        /// <summary>
+        /// Set this to false to prevent the areafrom showing.
+        /// 是否显示区域填充。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// the origin of area.
+        /// 区域填充的起始位置。
+        /// </summary>
+        public AreaOrigin origin { get { return m_Origin; } set { m_Origin = value; } }
+        /// <summary>
+        /// the color of area,default use serie color.
+        /// 区域填充的颜色，如果toColor不是默认值，则表示渐变色的起点颜色。
+        /// </summary>
+        public Color color { get { return m_Color; } set { m_Color = value; } }
+        /// <summary>
+        /// Gradient color, start color to toColor.
+        /// 渐变色的终点颜色。
+        /// </summary>
+        public Color toColor { get { return m_ToColor; } set { m_ToColor = value; } }
+        /// <summary>
+        /// Opacity of the component. Supports value from 0 to 1, and the component will not be drawn when set to 0.
+        /// 图形透明度。支持从 0 到 1 的数字，为 0 时不绘制该图形。
+        /// </summary>
+        public float opacity { get { return m_Opacity; } set { m_Opacity = value; } }
+        /// <summary>
+        /// 鼠标悬浮时是否高亮之前的区域
+        /// </summary>
+        public bool tooltipHighlight { get { return m_TooltipHighlight; } set { m_TooltipHighlight = value; } }
+        /// <summary>
+        /// the color of area,default use serie color.
+        /// 高亮时区域填充的颜色，如果highlightToColor不是默认值，则表示渐变色的起点颜色。
+        /// </summary>
+        public Color highlightColor { get { return m_HighlightColor; } set { m_HighlightColor = value; } }
+        /// <summary>
+        /// Gradient color, start highlightColor to highlightToColor.
+        /// 高亮时渐变色的终点颜色。
+        /// </summary>
+        public Color highlightToColor { get { return m_HighlightToColor; } set { m_HighlightToColor = value; } }
+
+        public static AreaStyle defaultAreaStyle
+        {
+            get
+            {
+                var area = new AreaStyle
+                {
+                    m_Show = false,
+                    m_Color = Color.clear,
+                    m_ToColor = Color.clear,
+                    m_Opacity = 1
+                };
+                return area;
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Sub/AreaStyle.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ec0d95a9298bb4c159dcae36020beec9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/AxisLabel.cs

@@ -0,0 +1,171 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Settings related to axis label.
+    /// 坐标轴刻度标签的相关设置。
+    /// </summary>
+    [Serializable]
+    public class AxisLabel : SubComponent
+    {
+        [SerializeField] private bool m_Show = true;
+        [SerializeField] private string m_Formatter;
+        [SerializeField] private int m_Interval = 0;
+        [SerializeField] private bool m_Inside = false;
+        [SerializeField] private float m_Rotate;
+        [SerializeField] private float m_Margin;
+        [SerializeField] private Color m_Color;
+        [SerializeField] private int m_FontSize;
+        [SerializeField] private FontStyle m_FontStyle;
+
+        /// <summary>
+        /// Set this to false to prevent the axis label from appearing.
+        /// 是否显示刻度标签。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// The display interval of the axis label.
+        /// 坐标轴刻度标签的显示间隔，在类目轴中有效。0表示显示所有标签，1表示隔一个隔显示一个标签，以此类推。
+        /// </summary>
+        public int interval { get { return m_Interval; } set { m_Interval = value; } }
+        /// <summary>
+        /// Set this to true so the axis labels face the inside direction.
+        /// 刻度标签是否朝内，默认朝外。
+        /// </summary>
+        public bool inside { get { return m_Inside; } set { m_Inside = value; } }
+        /// <summary>
+        /// Rotation degree of axis label, which is especially useful when there is no enough space for category axis.
+        /// 刻度标签旋转的角度，在类目轴的类目标签显示不下的时候可以通过旋转防止标签之间重叠。
+        /// </summary>
+        public float rotate { get { return m_Rotate; } set { m_Rotate = value; } }
+        /// <summary>
+        /// The margin between the axis label and the axis line.
+        /// 刻度标签与轴线之间的距离。
+        /// </summary>
+        public float margin { get { return m_Margin; } set { m_Margin = value; } }
+        /// <summary>
+        /// the color of axis label text. 
+        /// 刻度标签文字的颜色，默认取Theme的axisTextColor。
+        /// </summary>
+        public Color color { get { return m_Color; } set { m_Color = value; } }
+        /// <summary>
+        /// font size.
+        /// 文字的字体大小。
+        /// </summary>
+        public int fontSize { get { return m_FontSize; } set { m_FontSize = value; } }
+        /// <summary>
+        /// font style.
+        /// 文字字体的风格。
+        /// </summary>
+        public FontStyle fontStyle { get { return m_FontStyle; } set { m_FontStyle = value; } }
+        /// <summary>
+        /// 图例内容字符串模版格式器。支持用 \n 换行。
+        /// 模板变量为图例名称 {value}，{value:f1} 表示取1为小数
+        /// </summary>
+        public string formatter { get { return m_Formatter; } set { m_Formatter = value; } }
+
+        public static AxisLabel defaultAxisLabel
+        {
+            get
+            {
+                return new AxisLabel()
+                {
+                    m_Show = true,
+                    m_Interval = 0,
+                    m_Inside = false,
+                    m_Rotate = 0,
+                    m_Margin = 8,
+                    m_Color = Color.clear,
+                    m_FontSize = 18,
+                    m_FontStyle = FontStyle.Normal
+                };
+            }
+        }
+        public void Copy(AxisLabel other)
+        {
+            m_Show = other.show;
+            m_Interval = other.interval;
+            m_Inside = other.inside;
+            m_Rotate = other.rotate;
+            m_Margin = other.margin;
+            m_Color = other.color;
+            m_FontSize = other.fontSize;
+            m_FontStyle = other.fontStyle;
+            m_Formatter = other.formatter;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null || GetType() != obj.GetType())
+            {
+                return false;
+            }
+            var other = (AxisLabel)obj;
+            return m_Show == other.show &&
+                m_Interval.Equals(other.interval) &&
+                m_Inside == other.inside &&
+                m_Rotate == other.rotate &&
+                m_Margin == other.margin &&
+                m_Color == other.color &&
+                m_FontSize == other.fontSize &&
+                m_FontStyle == other.fontStyle &&
+                m_Formatter == other.formatter;
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        public string GetFormatterContent(string category)
+        {
+            if (string.IsNullOrEmpty(m_Formatter))
+                return category;
+            else
+            {
+                var content = m_Formatter.Replace("{value}", category);
+                content = content.Replace("\\n", "\n");
+                content = content.Replace("<br/>", "\n");
+                return content;
+            }
+        }
+
+        public string GetFormatterContent(float value)
+        {
+            if (string.IsNullOrEmpty(m_Formatter))
+                if (value - (int)value == 0)
+                    return ChartCached.IntToStr((int)value);
+                else
+                    return ChartCached.FloatToStr(value, 1);
+            else
+            {
+                var content = m_Formatter;
+                if (content.Contains("{value:f2}"))
+                    content = m_Formatter.Replace("{value:f2}", ChartCached.FloatToStr(value, 2));
+                else if (content.Contains("{value:f1}"))
+                    content = m_Formatter.Replace("{value:f1}", ChartCached.FloatToStr(value, 1));
+                else if (content.Contains("{value}"))
+                {
+                    if (value - (int)value == 0)
+
+                        content = m_Formatter.Replace("{value}", ChartCached.IntToStr((int)value));
+                    else
+                        content = m_Formatter.Replace("{value}", ChartCached.FloatToStr(value, 1));
+                }
+
+                content = content.Replace("\\n", "\n");
+                content = content.Replace("<br/>", "\n");
+                return content;
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Sub/AxisLabel.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 867b1c4fd101c43f79a82de245e9c1d2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/AxisLine.cs

@@ -0,0 +1,88 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Settings related to axis line.
+    /// 坐标轴的分隔线。
+    /// </summary>
+    [System.Serializable]    
+    public class AxisLine : SubComponent
+    {
+        [SerializeField] private bool m_Show;
+        [SerializeField] private bool m_OnZero;
+        [SerializeField] private float m_Width = 0.6f;
+        [SerializeField] private bool m_Symbol;
+        [SerializeField] private float m_SymbolWidth;
+        [SerializeField] private float m_SymbolHeight;
+        [SerializeField] private float m_SymbolOffset;
+        [SerializeField] private float m_SymbolDent;
+
+        /// <summary>
+        /// Set this to false to prevent the axis line from showing.
+        /// 是否显示坐标轴轴线。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// When mutiple axes exists, this option can be used to specify which axis can be "onZero" to.
+        /// X 轴或者 Y 轴的轴线是否在另一个轴的 0 刻度上，只有在另一个轴为数值轴且包含 0 刻度时有效。
+        /// </summary>
+        public bool onZero { get { return m_OnZero; } set { m_OnZero = value; } }
+        /// <summary>
+        /// line style line width.
+        /// 坐标轴线线宽。
+        /// </summary>
+        public float width { get { return m_Width; } set { m_Width = value; } }
+        /// <summary>
+        /// Whether to show the arrow symbol of axis. 
+        /// 是否显示箭头。
+        /// </summary>
+        public bool symbol { get { return m_Symbol; } set { m_Symbol = value; } }
+        /// <summary>
+        /// the width of arrow symbol. 
+        /// 箭头宽。
+        /// </summary>
+        public float symbolWidth { get { return m_SymbolWidth; } set { m_SymbolWidth = value; } }
+        /// <summary>
+        /// the height of arrow symbol. 
+        /// 箭头高。
+        /// </summary>
+        public float symbolHeight { get { return m_SymbolHeight; } set { m_SymbolHeight = value; } }
+        /// <summary>
+        /// the offset of arrow symbol. 
+        /// 箭头偏移。
+        /// </summary>
+        public float symbolOffset { get { return m_SymbolOffset; } set { m_SymbolOffset = value; } }
+        /// <summary>
+        /// the dent of arrow symbol. 
+        /// 箭头的凹陷程度。
+        /// </summary>
+        public float symbolDent { get { return m_SymbolDent; } set { m_SymbolDent = value; } }
+
+        public static AxisLine defaultAxisLine
+        {
+            get
+            {
+                var axisLine = new AxisLine
+                {
+                    m_Show = true,
+                    m_OnZero = true,
+                    m_Width = 0.7f,
+                    m_Symbol = false,
+                    m_SymbolWidth = 10,
+                    m_SymbolHeight = 15,
+                    m_SymbolOffset = 0,
+                    m_SymbolDent = 3,
+                };
+                return axisLine;
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Sub/AxisLine.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dee861621714d43519f0f1581e027a57
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/AxisName.cs

@@ -0,0 +1,131 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// the name of axis.
+    /// 坐标轴名称。
+    /// </summary>
+    [Serializable]
+    public class AxisName : SubComponent
+    {
+        /// <summary>
+        /// the location of axis name.
+        /// 坐标轴名称显示位置。
+        /// </summary>
+        public enum Location
+        {
+            Start,
+            Middle,
+            End
+        }
+        [SerializeField] private bool m_Show;
+        [SerializeField] private string m_Name;
+        [SerializeField] private Location m_Location;
+        [SerializeField] private Vector2 m_Offset;
+        [SerializeField] private float m_Rotate;
+        [SerializeField] private Color m_Color;
+        [SerializeField] private int m_FontSize;
+        [SerializeField] private FontStyle m_FontStyle;
+
+        /// <summary>
+        /// Whether to show axis name. 
+        /// 是否显示坐标名称。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// the name of axis.
+        /// 坐标轴名称。
+        /// </summary>
+        public string name { get { return m_Name; } set { m_Name = value; } }
+        /// <summary>
+        /// Location of axis name.
+        /// 坐标轴名称显示位置。
+        /// </summary>
+        public Location location { get { return m_Location; } set { m_Location = value; } }
+        /// <summary>
+        /// the offset of axis name and axis line.
+        /// 坐标轴名称与轴线之间的偏移。
+        /// </summary>
+        public Vector2 offset { get { return m_Offset; } set { m_Offset = value; } }
+        /// <summary>
+        /// Rotation of axis name.
+        /// 坐标轴名字旋转，角度值。
+        /// </summary>
+        public float rotate { get { return m_Rotate; } set { m_Rotate = value; } }
+        /// <summary>
+        /// Color of axis name. 
+        /// 坐标轴名称的文字颜色。
+        /// </summary>
+        public Color color { get { return m_Color; } set { m_Color = value; } }
+        /// <summary>
+        /// axis name font size. 
+        /// 坐标轴名称的文字大小。
+        /// </summary>
+        public int fontSize { get { return m_FontSize; } set { m_FontSize = value; } }
+        /// <summary>
+        /// axis name font style. 
+        /// 坐标轴名称的文字风格。
+        /// </summary>
+        public FontStyle fontStyle { get { return m_FontStyle; } set { m_FontStyle = value; } }
+
+        public static AxisName defaultAxisName
+        {
+            get
+            {
+                return new AxisName()
+                {
+                    m_Show = false,
+                    m_Name = "axisName",
+                    m_Location = Location.End,
+                    m_Rotate = 0,
+                    m_Color = Color.clear,
+                    m_FontSize = 18,
+                    m_FontStyle = FontStyle.Normal
+                };
+            }
+        }
+
+        public void Copy(AxisName other)
+        {
+            m_Show = other.show;
+            m_Name = other.name;
+            m_Location = other.location;
+            m_Offset = other.offset;
+            m_Rotate = other.rotate;
+            m_Color = other.color;
+            m_FontSize = other.fontSize;
+            m_FontStyle = other.fontStyle;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null || GetType() != obj.GetType())
+            {
+                return false;
+            }
+            var other = (AxisName)obj;
+            return m_Show == other.show &&
+                m_Name.Equals(other.name) &&
+                m_Location == other.location &&
+                m_Rotate == other.rotate &&
+                m_Color == other.color &&
+                m_Offset == other.offset &&
+                m_FontSize == other.fontSize &&
+                m_FontStyle == other.fontStyle;
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+    }
+}

Scripts/Runtime/Component/Sub/AxisName.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6f354d1d9b4e841c1b0068bf656b28c7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/AxisSplitArea.cs

@@ -0,0 +1,58 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Split area of axis in grid area, not shown by default.
+    /// 坐标轴在 grid 区域中的分隔区域，默认不显示。
+    /// </summary>
+    [Serializable]
+    public class AxisSplitArea : SubComponent
+    {
+        [SerializeField] private bool m_Show;
+        [SerializeField] private List<Color> m_Color;
+
+        /// <summary>
+        /// Set this to true to show the splitArea.
+        /// 是否显示分隔区域。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// Color of split area. SplitArea color could also be set in color array,
+        /// which the split lines would take as their colors in turns. 
+        /// Dark and light colors in turns are used by default.
+        /// 分隔区域颜色。分隔区域会按数组中颜色的顺序依次循环设置颜色。默认是一个深浅的间隔色。
+        /// </summary>
+        public List<Color> color { get { return m_Color; } set { m_Color = value; } }
+
+        public static AxisSplitArea defaultSplitArea
+        {
+            get
+            {
+                return new AxisSplitArea()
+                {
+                    m_Show = false,
+                    m_Color = new List<Color>(){
+                            new Color32(250,250,250,77),
+                            new Color32(200,200,200,77)
+                        }
+                };
+            }
+        }
+
+        public Color getColor(int index)
+        {
+            var i = index % color.Count;
+            return color[i];
+        }
+    }
+}

Scripts/Runtime/Component/Sub/AxisSplitArea.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1e3ad5d1729154c73b47342a46f0d3b5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/AxisTick.cs

@@ -0,0 +1,61 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Settings related to axis tick.
+    /// 坐标轴刻度相关设置。
+    /// </summary>
+    [System.Serializable]
+    public class AxisTick : SubComponent
+    {
+        [SerializeField] private bool m_Show;
+        [SerializeField] private bool m_AlignWithLabel;
+        [SerializeField] private bool m_Inside;
+        [SerializeField] private float m_Length;
+
+        /// <summary>
+        /// Set this to false to prevent the axis tick from showing.
+        /// 是否显示坐标轴刻度。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// Align axis tick with label, which is available only when boundaryGap is set to be true in category axis.
+        /// 类目轴中在 boundaryGap 为 true 的时候有效，可以保证刻度线和标签对齐。
+        /// </summary>
+        public bool alignWithLabel { get { return m_AlignWithLabel; } set { m_AlignWithLabel = value; } }
+        /// <summary>
+        /// Set this to true so the axis labels face the inside direction.
+        /// 坐标轴刻度是否朝内，默认朝外。
+        /// </summary>
+        public bool inside { get { return m_Inside; } set { m_Inside = value; } }
+        /// <summary>
+        /// The length of the axis tick.
+        /// 坐标轴刻度的长度。
+        /// </summary>
+        public float length { get { return m_Length; } set { m_Length = value; } }
+
+        public static AxisTick defaultTick
+        {
+            get
+            {
+                var tick = new AxisTick
+                {
+                    m_Show = true,
+                    m_AlignWithLabel = false,
+                    m_Inside = false,
+                    m_Length = 5f
+                };
+                return tick;
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Sub/AxisTick.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a9cff8225584c4d9492c252c09977060
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/Emphasis.cs

@@ -0,0 +1,35 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// 高亮的图形样式和文本标签样式。
+    /// </summary>
+    [System.Serializable]
+    public class Emphasis : SubComponent
+    {
+        [SerializeField] private bool m_Show;
+        [SerializeField] private SerieLabel m_Label = new SerieLabel();
+        [SerializeField] private ItemStyle m_ItemStyle = new ItemStyle();
+        /// <summary>
+        /// 是否启用高亮样式。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// 图形文本标签。
+        /// </summary>
+        public SerieLabel label { get { return m_Label; } }
+        /// <summary>
+        /// 图形样式。
+        /// </summary>
+        public ItemStyle itemStyle { get { return m_ItemStyle; } }
+    }
+}

Scripts/Runtime/Component/Sub/Emphasis.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6e0b1690532674b24952a87e0aead6fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/ItemStyle.cs

@@ -0,0 +1,69 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// 图形样式。
+    /// </summary>
+    [System.Serializable]
+    public class ItemStyle : SubComponent
+    {
+        /// <summary>
+        /// 线的类型。
+        /// </summary>
+        public enum Type
+        {
+            /// <summary>
+            /// 实线
+            /// </summary>
+            Solid,
+            /// <summary>
+            /// 虚线
+            /// </summary>
+            Dashed,
+            /// <summary>
+            /// 点线
+            /// </summary>
+            Dotted
+        }
+        [SerializeField] private bool m_Show = false;
+        [SerializeField] private Color m_Color;
+        [SerializeField] private Type m_BorderType = Type.Solid;
+        [SerializeField] private float m_BorderWidth = 0;
+        [SerializeField] private Color m_BorderColor;
+        [SerializeField] [Range(0, 1)] private float m_Opacity = 1;
+
+        /// <summary>
+        /// 是否启用。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// 数据项颜色。
+        /// </summary>
+        public Color color { get { return m_Color; } set { m_Color = value; } }
+        /// <summary>
+        /// 边框的类型。
+        /// </summary>
+        public Type borderType { get { return m_BorderType; } set { m_BorderType = value; } }
+        /// <summary>
+        /// 边框的颜色。
+        /// </summary>
+        public Color borderColor { get { return m_BorderColor; } set { m_BorderColor = value; } }
+        /// <summary>
+        /// 边框宽。
+        /// </summary>
+        public float borderWidth { get { return m_BorderWidth; } set { m_BorderWidth = value; } }
+        /// <summary>
+        /// 透明度。支持从 0 到 1 的数字，为 0 时不绘制该图形。
+        /// </summary>
+        public float opacity { get { return m_Opacity; } set { m_Opacity = value; } }
+    }
+}

Scripts/Runtime/Component/Sub/ItemStyle.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3ca9b30f9779c4a16b60cc21334828b0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/LineArrow.cs

@@ -0,0 +1,67 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// </summary>
+    [Serializable]
+    public class LineArrow : SubComponent
+    {
+        public enum Position
+        {
+            /// <summary>
+            /// 末端箭头
+            /// </summary>
+            End,
+            /// <summary>
+            /// 头端箭头
+            /// </summary>
+            Start
+        }
+        [SerializeField] private bool m_Show;
+        [SerializeField] Position m_Position;
+        [SerializeField] private float m_Width = 10;
+        [SerializeField] private float m_Height = 15;
+        [SerializeField] private float m_Offset = 0;
+        [SerializeField] private float m_Dent = 3;
+
+        /// <summary>
+        /// Whether to show the arrow.
+        /// 是否显示箭头。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// The position of arrow.
+        /// 箭头位置。
+        /// </summary>
+        public Position position { get { return m_Position; } set { m_Position = value; } }
+        /// <summary>
+        /// The widht of arrow.
+        /// 箭头宽。
+        /// </summary>
+        public float width { get { return m_Width; } set { m_Width = value; } }
+        /// <summary>
+        /// The height of arrow.
+        /// 箭头高。
+        /// </summary>
+        public float height { get { return m_Height; } set { m_Height = value; } }
+        /// <summary>
+        /// The offset of arrow.
+        /// 箭头偏移。
+        /// </summary>
+        public float offset { get { return m_Offset; } set { m_Offset = value; } }
+        /// <summary>
+        /// The dent of arrow.
+        /// 箭头的凹度。
+        /// </summary>
+        public float dent { get { return m_Dent; } set { m_Dent = value; } }
+    }
+}

Scripts/Runtime/Component/Sub/LineArrow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8f2455acb3ba34409896bf03ddba593e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/LineStyle.cs

@@ -0,0 +1,79 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// The style of line.
+    /// 线条样式。
+    /// 注： 修改 lineStyle 中的颜色不会影响图例颜色，如果需要图例颜色和折线图颜色一致，需修改 itemStyle.color，线条颜色默认也会取改颜色。
+    /// </summary>
+    [System.Serializable]
+    public class LineStyle : SubComponent
+    {
+        /// <summary>
+        /// 线的类型。
+        /// </summary>
+        public enum Type
+        {
+            /// <summary>
+            /// 实线
+            /// </summary>
+            Solid,
+            /// <summary>
+            /// 虚线
+            /// </summary>
+            Dashed,
+            /// <summary>
+            /// 点线
+            /// </summary>
+            Dotted,
+            /// <summary>
+            /// 点划线
+            /// </summary>
+            DashDot,
+            /// <summary>
+            /// 双点划线
+            /// </summary>
+            DashDotDot,
+        }
+        [SerializeField] private bool m_Show = true;
+        [SerializeField] private Type m_Type = Type.Solid;
+        [SerializeField] private Color m_Color;
+        [SerializeField] private float m_Width = 0.8f;
+        [SerializeField] [Range(0, 1)] private float m_Opacity = 1;
+
+        /// <summary>
+        /// Whether show line.
+        /// 是否显示线条。在折线图中无效。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// the type of line.
+        /// 线的类型。
+        /// </summary>
+        public Type type { get { return m_Type; } set { m_Type = value; } }
+        /// <summary>
+        /// the color of line, default use serie color.
+        /// 线的颜色。
+        /// </summary>
+        public Color color { get { return m_Color; } set { m_Color = value; } }
+        /// <summary>
+        /// the width of line.
+        /// 线宽。
+        /// </summary>
+        public float width { get { return m_Width; } set { m_Width = value; } }
+        /// <summary>
+        /// Opacity of the line. Supports value from 0 to 1, and the line will not be drawn when set to 0.
+        /// 线的透明度。支持从 0 到 1 的数字，为 0 时不绘制该图形。
+        /// </summary>
+        public float opacity { get { return m_Opacity; } set { m_Opacity = value; } }
+    }
+}

Scripts/Runtime/Component/Sub/LineStyle.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 092f08a2daa4b4013a72ffc3c9a18f85
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/Location.cs

@@ -0,0 +1,322 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Location type. Quick to set the general location.
+    /// 位置类型。通过Align快速设置大体位置，再通过left，right，top，bottom微调具体位置。
+    /// </summary>
+    [Serializable]
+    public class Location : SubComponent, IPropertyChanged, IEquatable<Location>
+    {
+        /// <summary>
+        /// 对齐方式
+        /// </summary>
+        public enum Align
+        {
+            TopLeft,
+            TopRight,
+            TopCenter,
+            BottomLeft,
+            BottomRight,
+            BottomCenter,
+            Center,
+            CenterLeft,
+            CenterRight
+        }
+
+        [SerializeField] private Align m_Align = Align.TopCenter;
+        [SerializeField] private float m_Left;
+        [SerializeField] private float m_Right;
+        [SerializeField] private float m_Top;
+        [SerializeField] private float m_Bottom;
+
+        private TextAnchor m_TextAnchor;
+        private Vector2 m_AnchorMin;
+        private Vector2 m_AnchorMax;
+        private Vector2 m_Pivot;
+
+        /// <summary>
+        /// 对齐方式。
+        /// </summary>
+        public Align align { get { return m_Align; } set { m_Align = value; UpdateAlign(); } }
+        /// <summary>
+        /// Distance between component and the left side of the container.
+        /// 离容器左侧的距离。
+        /// </summary>
+        public float left { get { return m_Left; } set { m_Left = value; UpdateAlign(); } }
+        /// <summary>
+        /// Distance between component and the left side of the container.
+        /// 离容器右侧的距离。
+        /// </summary>
+        public float right { get { return m_Right; } set { m_Right = value; UpdateAlign(); } }
+        /// <summary>
+        /// Distance between component and the left side of the container.
+        /// 离容器上侧的距离。
+        /// </summary>
+        public float top { get { return m_Top; } set { m_Top = value; UpdateAlign(); } }
+        /// <summary>
+        /// Distance between component and the left side of the container.
+        /// 离容器下侧的距离。
+        /// </summary>
+        public float bottom { get { return m_Bottom; } set { m_Bottom = value; UpdateAlign(); } }
+
+        /// <summary>
+        /// the anchor of text.
+        /// Location对应的Anchor锚点
+        /// </summary>
+        /// <value></value>
+        public TextAnchor textAnchor { get { return m_TextAnchor; } }
+        /// <summary>
+        /// the minimum achor.
+        /// Location对应的anchorMin。
+        /// </summary>
+        /// <value></value>
+        public Vector2 anchorMin { get { return m_AnchorMin; } }
+        /// <summary>
+        /// the maximun achor.
+        /// Location对应的anchorMax.
+        /// </summary>
+        /// <value></value>
+        public Vector2 anchorMax { get { return m_AnchorMax; } }
+        /// <summary>
+        /// the povot.
+        /// Loation对应的中心点。
+        /// </summary>
+        /// <value></value>
+        public Vector2 pivot { get { return m_Pivot; } }
+
+        public static Location defaultLeft
+        {
+            get
+            {
+                return new Location()
+                {
+                    align = Align.CenterLeft,
+                    left = 5,
+                    right = 0,
+                    top = 0,
+                    bottom = 0
+                };
+            }
+        }
+
+        public static Location defaultRight
+        {
+            get
+            {
+                return new Location()
+                {
+                    align = Align.CenterRight,
+                    left = 0,
+                    right = 5,
+                    top = 0,
+                    bottom = 0
+                };
+            }
+        }
+
+        public static Location defaultTop
+        {
+            get
+            {
+                return new Location()
+                {
+                    align = Align.TopCenter,
+                    left = 0,
+                    right = 0,
+                    top = 5,
+                    bottom = 0
+                };
+            }
+        }
+
+        public static Location defaultBottom
+        {
+            get
+            {
+                return new Location()
+                {
+                    align = Align.BottomCenter,
+                    left = 0,
+                    right = 0,
+                    top = 0,
+                    bottom = 5
+                };
+            }
+        }
+
+        private void UpdateAlign()
+        {
+            switch (m_Align)
+            {
+                case Align.BottomCenter:
+                    m_TextAnchor = TextAnchor.LowerCenter;
+                    m_AnchorMin = new Vector2(0.5f, 0);
+                    m_AnchorMax = new Vector2(0.5f, 0);
+                    m_Pivot = new Vector2(0.5f, 0);
+                    break;
+                case Align.BottomLeft:
+                    m_TextAnchor = TextAnchor.LowerLeft;
+                    m_AnchorMin = new Vector2(0, 0);
+                    m_AnchorMax = new Vector2(0, 0);
+                    m_Pivot = new Vector2(0, 0);
+                    break;
+                case Align.BottomRight:
+                    m_TextAnchor = TextAnchor.LowerRight;
+                    m_AnchorMin = new Vector2(1, 0);
+                    m_AnchorMax = new Vector2(1, 0);
+                    m_Pivot = new Vector2(1, 0);
+                    break;
+                case Align.Center:
+                    m_TextAnchor = TextAnchor.MiddleCenter;
+                    m_AnchorMin = new Vector2(0.5f, 0.5f);
+                    m_AnchorMax = new Vector2(0.5f, 0.5f);
+                    m_Pivot = new Vector2(0.5f, 0.5f);
+                    break;
+                case Align.CenterLeft:
+                    m_TextAnchor = TextAnchor.MiddleLeft;
+                    m_AnchorMin = new Vector2(0, 0.5f);
+                    m_AnchorMax = new Vector2(0, 0.5f);
+                    m_Pivot = new Vector2(0, 0.5f);
+                    break;
+                case Align.CenterRight:
+                    m_TextAnchor = TextAnchor.MiddleRight;
+                    m_AnchorMin = new Vector2(1, 0.5f);
+                    m_AnchorMax = new Vector2(1, 0.5f);
+                    m_Pivot = new Vector2(1, 0.5f);
+                    break;
+                case Align.TopCenter:
+                    m_TextAnchor = TextAnchor.UpperCenter;
+                    m_AnchorMin = new Vector2(0.5f, 1);
+                    m_AnchorMax = new Vector2(0.5f, 1);
+                    m_Pivot = new Vector2(0.5f, 1);
+                    break;
+                case Align.TopLeft:
+                    m_TextAnchor = TextAnchor.UpperLeft;
+                    m_AnchorMin = new Vector2(0, 1);
+                    m_AnchorMax = new Vector2(0, 1);
+                    m_Pivot = new Vector2(0, 1);
+                    break;
+                case Align.TopRight:
+                    m_TextAnchor = TextAnchor.UpperRight;
+                    m_AnchorMin = new Vector2(1, 1);
+                    m_AnchorMax = new Vector2(1, 1);
+                    m_Pivot = new Vector2(1, 1);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// 返回在坐标系中的具体位置
+        /// </summary>
+        /// <param name="chartWidth"></param>
+        /// <param name="chartHeight"></param>
+        /// <returns></returns>
+        public Vector3 GetPosition(float chartWidth, float chartHeight)
+        {
+            switch (align)
+            {
+                case Align.BottomCenter:
+                    return new Vector3(chartWidth / 2, bottom);
+                case Align.BottomLeft:
+                    return new Vector3(left, bottom);
+                case Align.BottomRight:
+                    return new Vector3(chartWidth - right, bottom);
+                case Align.Center:
+                    return new Vector3(chartWidth / 2, chartHeight / 2);
+                case Align.CenterLeft:
+                    return new Vector3(left, chartHeight / 2);
+                case Align.CenterRight:
+                    return new Vector3(chartWidth - right, chartHeight / 2);
+                case Align.TopCenter:
+                    return new Vector3(chartWidth / 2, chartHeight - top);
+                case Align.TopLeft:
+                    return new Vector3(left, chartHeight - top);
+                case Align.TopRight:
+                    return new Vector3(chartWidth - right, chartHeight - top);
+                default:
+                    return Vector2.zero;
+            }
+        }
+
+        public void Copy(Location location)
+        {
+            m_Align = location.align;
+            m_Left = location.left;
+            m_Right = location.right;
+            m_Top = location.top;
+            m_Bottom = location.bottom;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+            else if (obj is Location)
+            {
+                return Equals((Location)obj);
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool Equals(Location other)
+        {
+            if (ReferenceEquals(null, other))
+            {
+                return false;
+            }
+            return align == other.align &&
+                left == other.left &&
+                right == other.right &&
+                top == other.top &&
+                bottom == other.bottom;
+        }
+
+        public static bool operator ==(Location left, Location right)
+        {
+            if (ReferenceEquals(left, null) && ReferenceEquals(right, null))
+            {
+                return true;
+            }
+            else if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
+            {
+                return false;
+            }
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(Location left, Location right)
+        {
+            return !(left == right);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        /// <summary>
+        /// 属性变更时更新textAnchor,minAnchor,maxAnchor,pivot
+        /// </summary>
+        public void OnChanged()
+        {
+            UpdateAlign();
+        }
+    }
+}

Scripts/Runtime/Component/Sub/Location.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7922ce86a6b0f4813a7f34e004b92e9a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/SerieData.cs

@@ -0,0 +1,264 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Linq;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    /// <summary>
+    /// A data item of serie.
+    /// 系列中的一个数据项。可存储数据名和1-n维的数据。
+    /// </summary>
+    [System.Serializable]
+    public class SerieData : SubComponent
+    {
+        [SerializeField] private string m_Name;
+        [SerializeField] private bool m_Selected;
+        [SerializeField] private float m_Radius;
+        [SerializeField] private bool m_ShowIcon;
+        [SerializeField] private Sprite m_IconImage;
+        [SerializeField] private Color m_IconColor = Color.white;
+        [SerializeField] private float m_IconWidth = 40;
+        [SerializeField] private float m_IconHeight = 40;
+        [SerializeField] private Vector3 m_IconOffset;
+
+        [SerializeField] private List<float> m_Data = new List<float>();
+
+        private bool m_Show = true;
+        private bool m_LabelAutoSize;
+        private float m_LabelPaddingLeftRight;
+        private float m_LabelPaddingTopBottom;
+        private float m_RtPieOutsideRadius;
+
+        public int index { get; set; }
+        /// <summary>
+        /// the name of data item.
+        /// 数据项名称。
+        /// </summary>
+        public string name { get { return m_Name; } set { m_Name = value; } }
+        /// <summary>
+        /// 数据项图例名称。当数据项名称不为空时，图例名称即为系列名称；反之则为索引index。
+        /// </summary>
+        /// <value></value>
+        public string legendName { get { return string.IsNullOrEmpty(name) ? ChartCached.IntToStr(index) : name; } }
+        /// <summary>
+        /// 自定义半径。可用在饼图中自定义某个数据项的半径。
+        /// </summary>
+        public float radius { get { return m_Radius; } set { m_Radius = value; } }
+        /// <summary>
+        /// Whether the data item is selected.
+        /// 该数据项是否被选中。
+        /// </summary>
+        public bool selected { get { return m_Selected; } set { m_Selected = value; } }
+        /// <summary>
+        /// Whether the data icon is show.
+        /// 是否显示图标。
+        /// </summary>
+        public bool showIcon { get { return m_ShowIcon; } set { m_ShowIcon = value; } }
+        /// <summary>
+        /// The image of icon.
+        /// 图标的图片。
+        /// </summary>
+        public Sprite iconImage { get { return m_IconImage; } set { m_IconImage = value; } }
+        /// <summary>
+        /// 图标颜色。
+        /// </summary>
+        public Color iconColor { get { return m_IconColor; } set { m_IconColor = value; } }
+        /// <summary>
+        /// 图标宽。
+        /// </summary>
+        public float iconWidth { get { return m_IconWidth; } set { m_IconWidth = value; } }
+        /// <summary>
+        /// 图标高。
+        /// </summary>
+        public float iconHeight { get { return m_IconHeight; } set { m_IconHeight = value; } }
+        /// <summary>
+        /// 图标偏移。
+        /// </summary>
+        public Vector3 iconOffset { get { return m_IconOffset; } set { m_IconOffset = value; } }
+
+        /// <summary>
+        /// An arbitrary dimension data list of data item.
+        /// 可指定任意维数的数值列表。
+        /// </summary>
+        public List<float> data { get { return m_Data; } set { m_Data = value; } }
+        /// <summary>
+        /// [default:true] Whether the data item is showed.
+        /// 该数据项是否要显示。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// Whether the data item is highlighted.
+        /// 该数据项是否被高亮，一般由鼠标悬停或图例悬停触发高亮。
+        /// </summary>
+        public bool highlighted { get; set; }
+        /// <summary>
+        /// the label of data item.
+        /// 该数据项的文本标签。
+        /// </summary>
+        public Text labelText { get; private set; }
+        public RectTransform labelRect { get; private set; }
+        /// <summary>
+        /// 标志位置。
+        /// </summary>
+        public Vector3 labelPosition { get; set; }
+        public bool m_CanShowLabel = true;
+        /// <summary>
+        /// 是否可以显示Label
+        /// </summary>
+        public bool canShowLabel { get { return m_CanShowLabel; } set { m_CanShowLabel = value; } }
+        /// <summary>
+        /// the maxinum value.
+        /// 最大值。
+        /// </summary>
+        public float max { get { return m_Data.Max(); } }
+        /// <summary>
+        /// the mininum value.
+        /// 最小值。
+        /// </summary>
+        public float min { get { return m_Data.Min(); } }
+        public Image icon { get; private set; }
+        public RectTransform iconRect { get; private set; }
+        /// <summary>
+        /// 关联的gameObject
+        /// </summary>
+        public GameObject gameObject { get; private set; }
+        /// <summary>
+        /// 饼图数据项的开始角度（运行时自动计算）
+        /// </summary>
+        public float pieStartAngle { get; set; }
+        /// <summary>
+        /// 饼图数据项的结束角度（运行时自动计算）
+        /// </summary>
+        public float pieToAngle { get; set; }
+        /// <summary>
+        /// 饼图数据项的一半时的角度（运行时自动计算）
+        /// </summary>
+        public float pieHalfAngle { get; set; }
+        /// <summary>
+        /// 饼图数据项的当前角度（运行时自动计算）
+        /// </summary>
+        public float pieCurrAngle { get; set; }
+        /// <summary>
+        /// 饼图数据项的内半径
+        /// </summary>
+        public float pieInsideRadius { get; set; }
+        /// <summary>
+        /// 饼图数据项的外半径
+        /// </summary>
+        public float pieOutsideRadius
+        {
+            get
+            {
+                if (radius > 0) return radius;
+                else return m_RtPieOutsideRadius;
+            }
+            set
+            {
+                m_RtPieOutsideRadius = value;
+            }
+        }
+        /// <summary>
+        /// 饼图数据项的偏移半径
+        /// </summary>
+        public float pieOffsetRadius { get; set; }
+        public Vector3 pieOffsetCenter { get; set; }
+
+        public float GetData(int index)
+        {
+            if (index >= 0 && index < m_Data.Count) return m_Data[index];
+            else return 0;
+        }
+
+        public void InitLabel(GameObject labelObj, bool autoSize, float paddingLeftRight, float paddingTopBottom)
+        {
+            gameObject = labelObj;
+            m_LabelAutoSize = autoSize;
+            m_LabelPaddingLeftRight = paddingLeftRight;
+            m_LabelPaddingTopBottom = paddingTopBottom;
+            labelText = labelObj.GetComponentInChildren<Text>();
+            labelRect = labelText.GetComponent<RectTransform>();
+        }
+
+        public void SetLabelActive(bool active)
+        {
+            if (labelRect)
+            {
+                ChartHelper.SetActive(labelRect, active);
+            }
+        }
+
+        public bool SetLabelText(string text)
+        {
+            if (labelText)
+            {
+                labelText.text = text;
+                if (m_LabelAutoSize)
+                {
+                    var newSize = new Vector2(labelText.preferredWidth + m_LabelPaddingLeftRight * 2,
+                                        labelText.preferredHeight + m_LabelPaddingTopBottom * 2);
+                    var sizeChange = newSize.x != labelRect.sizeDelta.x || newSize.y != labelRect.sizeDelta.y;
+                    if (sizeChange) labelRect.sizeDelta = newSize;
+                    return sizeChange;
+                }
+            }
+            return false;
+        }
+
+        public float GetLabelWidth()
+        {
+            if (labelRect) return labelRect.sizeDelta.x;
+            else return 0;
+        }
+
+        public float GetLabelHeight()
+        {
+            if (labelRect) return labelRect.sizeDelta.y;
+            return 0;
+        }
+
+        public void SetGameObjectPosition(Vector3 position)
+        {
+            if (gameObject)
+            {
+                gameObject.transform.localPosition = position;
+            }
+        }
+
+        public void SetLabelPosition(Vector3 position)
+        {
+            if (labelRect) labelRect.localPosition = position;
+        }
+
+        public void SetIconObj(GameObject iconObj)
+        {
+            icon = iconObj.GetComponent<Image>();
+            iconRect = iconObj.GetComponent<RectTransform>();
+            UpdateIcon();
+        }
+
+        public void UpdateIcon()
+        {
+            if (icon == null) return;
+            if (m_ShowIcon)
+            {
+                ChartHelper.SetActive(icon.gameObject, true);
+                icon.sprite = m_IconImage;
+                icon.color = m_IconColor;
+                iconRect.sizeDelta = new Vector2(m_IconWidth, m_IconHeight);
+                icon.transform.localPosition = m_IconOffset;
+            }
+            else
+            {
+                ChartHelper.SetActive(icon.gameObject, false);
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Sub/SerieData.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fce2a5796a5ab4817a4a91d0f7af39ce
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/SerieLabel.cs

@@ -0,0 +1,250 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Text label of chart, to explain some data information about graphic item like value, name and so on.
+    /// 图形上的文本标签，可用于说明图形的一些数据信息，比如值，名称等。
+    /// </summary>
+    [System.Serializable]
+    public class SerieLabel : SubComponent
+    {
+        /// <summary>
+        /// The position of label.
+        /// 标签的位置。
+        /// </summary>
+        public enum Position
+        {
+            /// <summary>
+            /// Outside of sectors of pie chart, which relates to corresponding sector through visual guide line.
+            /// 饼图扇区外侧，通过视觉引导线连到相应的扇区。
+            /// </summary>
+            Outside,
+            /// <summary>
+            /// Inside the sectors of pie chart.
+            /// 饼图扇区内部。
+            /// </summary>
+            Inside,
+            /// <summary>
+            /// In the center of pie chart.
+            /// 在饼图中心位置。
+            /// </summary>
+            Center,
+            /// <summary>
+            /// top of symbol.
+            /// 图形标志的顶部。
+            /// </summary>
+            Top,
+            /// <summary>
+            /// the left of symbol.
+            /// 图形标志的左边。
+            /// </summary>
+            //Left,
+            /// <summary>
+            /// the right of symbol.
+            /// 图形标志的右边。
+            /// </summary>
+            //Right,
+            /// <summary>
+            /// the bottom of symbol.
+            /// 图形标志的底部。
+            /// </summary>
+            Bottom,
+        }
+
+        /// <summary>
+        /// 标签视觉引导线类型
+        /// </summary>
+        public enum LineType
+        {
+            /// <summary>
+            /// 折线
+            /// </summary>
+            BrokenLine,
+            /// <summary>
+            /// 曲线
+            /// </summary>
+            Curves,
+            /// <summary>
+            /// 水平线
+            /// </summary>
+            HorizontalLine
+        }
+        [SerializeField] private bool m_Show = false;
+        [SerializeField] Position m_Position;
+        [SerializeField] private Vector3 m_Offset;
+        [SerializeField] private string m_Formatter;
+        [SerializeField] private float m_Rotate = 0;
+        [SerializeField] private float m_PaddingLeftRight = 2f;
+        [SerializeField] private float m_PaddingTopBottom = 2f;
+        [SerializeField] private Color m_Color;
+        [SerializeField] private Color m_BackgroundColor;
+        [SerializeField] private float m_BackgroundWidth = 0;
+        [SerializeField] private float m_BackgroundHeight = 0;
+        [SerializeField] private int m_FontSize = 18;
+        [SerializeField] private FontStyle m_FontStyle = FontStyle.Normal;
+        [SerializeField] private bool m_Line = true;
+        [SerializeField] private LineType m_LineType = LineType.BrokenLine;
+        [SerializeField] private Color m_LineColor = Color.clear;
+        [SerializeField] private float m_LineWidth = 1.0f;
+        [SerializeField] private float m_LineLength1 = 25f;
+        [SerializeField] private float m_LineLength2 = 15f;
+        [SerializeField] private bool m_Border = true;
+        [SerializeField] private float m_BorderWidth = 0.5f;
+        [SerializeField] private Color m_BorderColor = Color.grey;
+        /// <summary>
+        /// Whether the label is showed.
+        /// 是否显示文本标签。
+        /// </summary>
+        public bool show { get { return m_Show; } set { m_Show = value; } }
+        /// <summary>
+        /// The position of label.
+        /// 标签的位置。
+        /// </summary>
+        public Position position { get { return m_Position; } set { m_Position = value; } }
+        /// <summary>
+        /// 标签内容字符串模版格式器。支持用 \n 换行。
+        /// 模板变量有：
+        /// <list type="bullet">
+        /// <item><description>{a}：系列名。</description></item>
+        /// <item><description>{b}：数据名。</description></item>
+        /// <item><description>{c}：数据值。</description></item>
+        /// <item><description>{d}：百分比。</description></item>
+        /// </list>
+        /// </summary>
+        /// <example>
+        /// 示例：“{b}:{c}”
+        /// </example>
+        public string formatter { get { return m_Formatter; } set { m_Formatter = value; } }
+        /// <summary>
+        /// offset to the host graphic element. 
+        /// 距离图形元素的偏移
+        /// </summary>
+        public Vector3 offset { get { return m_Offset; } set { m_Offset = value; } }
+        /// <summary>
+        /// Text color,If set as default ,the color will assigned as series color.
+        /// 自定义文字颜色，默认和系列的颜色一致。
+        /// </summary>
+        public Color color { get { return m_Color; } set { m_Color = value; } }
+        /// <summary>
+        /// the background color. If set as default, it means than don't show background.
+        /// 标签的背景色，默认无颜色。
+        /// </summary>
+        public Color backgroundColor { get { return m_BackgroundColor; } set { m_BackgroundColor = value; } }
+        /// <summary>
+        /// the width of background. If set as default value 0, it means than the background width auto set as the text width.
+        /// 标签的背景宽度。一般不用指定，不指定时则自动是文字的宽度。
+        /// </summary>
+        /// <value></value>
+        public float backgroundWidth { get { return m_BackgroundWidth; } set { m_BackgroundWidth = value; } }
+        /// <summary>
+        /// the height of background. If set as default value 0, it means than the background height auto set as the text height.
+        /// 标签的背景高度。一般不用指定，不指定时则自动是文字的高度。
+        /// </summary>
+        /// <value></value>
+        public float backgroundHeight { get { return m_BackgroundHeight; } set { m_BackgroundHeight = value; } }
+        /// <summary>
+        /// Rotate label.
+        /// 标签旋转。
+        /// </summary>
+        public float rotate { get { return m_Rotate; } set { m_Rotate = value; } }
+        /// <summary>
+        /// the text padding of left and right. defaut:2.
+        /// 左右边距。
+        /// </summary>
+        public float paddingLeftRight { get { return m_PaddingLeftRight; } set { m_PaddingLeftRight = value; } }
+        /// <summary>
+        /// the text padding of top and bottom. defaut:2.
+        /// 上下边距。
+        /// </summary>
+        public float paddingTopBottom { get { return m_PaddingTopBottom; } set { m_PaddingTopBottom = value; } }
+        /// <summary>
+        /// font size.
+        /// 文字的字体大小。
+        /// </summary>
+        public int fontSize { get { return m_FontSize; } set { m_FontSize = value; } }
+        /// <summary>
+        /// font style.
+        /// 文字的字体风格。
+        /// </summary>
+        public FontStyle fontStyle { get { return m_FontStyle; } set { m_FontStyle = value; } }
+        /// <summary>
+        /// Whether to show visual guide line.Will show when label position is set as 'outside'.
+        /// 是否显示视觉引导线。在 label 位置 设置为'outside'的时候会显示视觉引导线。
+        /// </summary>
+        public bool line { get { return m_Line; } set { m_Line = value; } }
+        /// <summary>
+        /// the type of visual guide line.
+        /// 视觉引导线类型。
+        /// </summary>
+        public LineType lineType { get { return m_LineType; } set { m_LineType = value; } }
+        /// <summary>
+        /// the color of visual guild line.
+        /// 视觉引导线颜色。默认和serie一致取自调色板。
+        /// </summary>
+        public Color lineColor { get { return m_LineColor; } set { m_LineColor = value; } }
+        /// <summary>
+        /// the width of visual guild line.
+        /// 视觉引导线的宽度。
+        /// </summary>
+        public float lineWidth { get { return m_LineWidth; } set { m_LineWidth = value; } }
+        /// <summary>
+        /// The length of the first segment of visual guide line.
+        /// 视觉引导线第一段的长度。
+        /// </summary>
+        public float lineLength1 { get { return m_LineLength1; } set { m_LineLength1 = value; } }
+        /// <summary>
+        /// The length of the second segment of visual guide line.
+        /// 视觉引导线第二段的长度。
+        /// </summary>
+        public float lineLength2 { get { return m_LineLength2; } set { m_LineLength2 = value; } }
+        /// <summary>
+        /// Whether to show border.
+        /// 是否显示边框。
+        /// </summary>
+        public bool border { get { return m_Border; } set { m_Border = value; } }
+        /// <summary>
+        /// the width of border.
+        /// 边框宽度。
+        /// </summary>
+        public float borderWidth { get { return m_BorderWidth; } set { m_BorderWidth = value; } }
+        /// <summary>
+        /// the color of border.
+        /// 边框颜色。
+        /// </summary>
+        public Color borderColor { get { return m_BorderColor; } set { m_BorderColor = value; } }
+
+        public string GetFormatterContent(string serieName, string dataName, float dataValue, float dataTotal = 0)
+        {
+            if (string.IsNullOrEmpty(m_Formatter))
+                return ChartCached.FloatToStr(dataValue);
+            else
+            {
+                var content = m_Formatter.Replace("{a}", serieName);
+                content = content.Replace("{b}", dataName);
+                content = content.Replace("{c}", ChartCached.FloatToStr(dataValue));
+                content = content.Replace("{c:f0}", ChartCached.IntToStr((int)Mathf.Round(dataValue)));
+                content = content.Replace("{c:f1}", ChartCached.FloatToStr(dataValue, 1));
+                content = content.Replace("{c:f2}", ChartCached.FloatToStr(dataValue, 2));
+                if (dataTotal > 0)
+                {
+                    var percent = dataValue / dataTotal * 100;
+                    content = content.Replace("{d}", ChartCached.FloatToStr(percent, 1));
+                    content = content.Replace("{d:f0}", ChartCached.IntToStr((int)Mathf.Round(percent)));
+                    content = content.Replace("{d:f1}", ChartCached.FloatToStr(percent, 1));
+                    content = content.Replace("{d:f2}", ChartCached.FloatToStr(percent, 2));
+                }
+                content = content.Replace("\\n", "\n");
+                content = content.Replace("<br/>", "\n");
+                return content;
+            }
+        }
+    }
+}

Scripts/Runtime/Component/Sub/SerieLabel.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c595e94871c8a4c12a5bc5d5dc533652
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/Sub/SerieSymbol.cs

@@ -0,0 +1,238 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// the type of symbol.
+    /// 标记图形的类型。
+    /// </summary>
+    public enum SerieSymbolType
+    {
+        /// <summary>
+        /// 空心圆。
+        /// </summary>
+        EmptyCircle,
+        /// <summary>
+        /// 圆形。
+        /// </summary>
+        Circle,
+        /// <summary>
+        /// 正方形。
+        /// </summary>
+        Rect,
+        /// <summary>
+        /// 三角形。
+        /// </summary>
+        Triangle,
+        /// <summary>
+        /// 菱形。
+        /// </summary>
+        Diamond,
+        /// <summary>
+        /// 不显示标记。
+        /// </summary>
+        None,
+    }
+
+    /// <summary>
+    /// The way to get serie symbol size.
+    /// 获取标记图形大小的方式。
+    /// </summary>
+    public enum SerieSymbolSizeType
+    {
+        /// <summary>
+        /// Specify constant for symbol size.
+        /// 自定义大小。
+        /// </summary>
+        Custom,
+        /// <summary>
+        /// Specify the dataIndex and dataScale to calculate symbol size.
+        /// 通过 dataIndex 从数据中获取，再乘以一个比例系数 dataScale 。
+        /// </summary>
+        FromData,
+        /// <summary>
+        /// Specify callback function for symbol size.
+        /// 通过回调函数获取。
+        /// </summary>
+        Callback,
+    }
+
+    /// <summary>
+    /// 获取标记大小的回调。
+    /// </summary>
+    /// <param name="data"></param>
+    /// <returns></returns>
+    public delegate float SymbolSizeCallback(List<float> data);
+
+    /// <summary>
+    /// 系列数据项的标记的图形
+    /// </summary>
+    [System.Serializable]
+    public class SerieSymbol : SubComponent
+    {
+        [SerializeField] private SerieSymbolType m_Type = SerieSymbolType.EmptyCircle;
+        [SerializeField] private SerieSymbolSizeType m_SizeType = SerieSymbolSizeType.Custom;
+        [SerializeField] private float m_Size = 6f;
+        [SerializeField] private float m_SelectedSize = 10f;
+        [SerializeField] private int m_DataIndex = 1;
+        [SerializeField] private float m_DataScale = 1;
+        [SerializeField] private float m_SelectedDataScale = 1.5f;
+        [SerializeField] private SymbolSizeCallback m_SizeCallback;
+        [SerializeField] private SymbolSizeCallback m_SelectedSizeCallback;
+        [SerializeField] private Color m_Color;
+        [SerializeField] [Range(0, 1)] private float m_Opacity = 1;
+        [SerializeField] private int m_StartIndex;
+        [SerializeField] private int m_Interval;
+        [SerializeField] private bool m_ForceShowLast = false;
+
+        /// <summary>
+        /// the type of symbol.
+        /// 标记类型。
+        /// </summary>
+        public SerieSymbolType type { get { return m_Type; } set { m_Type = value; } }
+        /// <summary>
+        /// the type of symbol size.
+        /// 标记图形的大小获取方式。
+        /// </summary>
+        public SerieSymbolSizeType sizeType { get { return m_SizeType; } set { m_SizeType = value; } }
+        /// <summary>
+        /// the size of symbol.
+        /// 标记的大小。
+        /// </summary>
+        public float size { get { return m_Size; } set { m_Size = value; } }
+        /// <summary>
+        /// the size of selected symbol.
+        /// 被选中的标记的大小。
+        /// </summary>
+        public float selectedSize { get { return m_SelectedSize; } set { m_SelectedSize = value; } }
+        /// <summary>
+        /// whitch data index is when the sizeType assined as FromData.
+        /// 当sizeType指定为FromData时，指定的数据源索引。
+        /// </summary>
+        public int dataIndex { get { return m_DataIndex; } set { m_DataIndex = value; } }
+        /// <summary>
+        /// the scale of data when sizeType assined as FromData.
+        /// 当sizeType指定为FromData时，指定的倍数系数。
+        /// </summary>
+        public float dataScale { get { return m_DataScale; } set { m_DataScale = value; } }
+        /// <summary>
+        /// the scale of selected data when sizeType assined as FromData.
+        /// 当sizeType指定为FromData时，指定的高亮倍数系数。
+        /// </summary>
+        public float selectedDataScale { get { return m_SelectedDataScale; } set { m_SelectedDataScale = value; } }
+        /// <summary>
+        /// the callback of size when sizeType assined as Callback.
+        /// 当sizeType指定为Callback时，指定的回调函数。
+        /// </summary>
+        public SymbolSizeCallback sizeCallback { get { return m_SizeCallback; } set { m_SizeCallback = value; } }
+        /// <summary>
+        /// the callback of size when sizeType assined as Callback.
+        /// 当sizeType指定为Callback时，指定的高亮回调函数。
+        /// </summary>
+        public SymbolSizeCallback selectedSizeCallback { get { return m_SelectedSizeCallback; } set { m_SelectedSizeCallback = value; } }
+        /// <summary>
+        /// the color of symbol,default from serie.
+        /// 标记图形的颜色，默认和系列一致。
+        /// </summary>
+        public Color color { get { return m_Color; } set { m_Color = value; } }
+        /// <summary>
+        /// the opacity of color.
+        /// 图形标记的透明度。
+        /// </summary>
+        public float opacity { get { return m_Opacity; } set { m_Opacity = value; } }
+        /// <summary>
+        /// the index start to show symbol.
+        /// 开始显示图形标记的索引。
+        /// </summary>
+        public int startIndex { get { return m_StartIndex; } set { m_StartIndex = value; } }
+        /// <summary>
+        /// the interval of show symbol.
+        /// 显示图形标记的间隔。0表示显示所有标签，1表示隔一个隔显示一个标签，以此类推。
+        /// </summary>
+        public int interval { get { return m_Interval; } set { m_Interval = value; } }
+        /// <summary>
+        /// whether to show the last symbol.
+        /// 是否强制显示最后一个图形标记。
+        /// </summary>
+        public bool forceShowLast { get { return m_ForceShowLast; } set { m_ForceShowLast = value; } }
+        private List<float> m_AnimationSize = new List<float>() { 0, 5, 10 };
+        /// <summary>
+        /// the setting for effect scatter.
+        /// 带有涟漪特效动画的散点图的动画参数。
+        /// </summary>
+        public List<float> animationSize { get { return m_AnimationSize; } }
+
+        /// <summary>
+        /// 根据指定的sizeType获得标记的大小
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public float GetSize(List<float> data)
+        {
+            if (data == null) return size;
+            switch (m_SizeType)
+            {
+                case SerieSymbolSizeType.Custom:
+                    return size;
+                case SerieSymbolSizeType.FromData:
+                    if (dataIndex >= 0 && dataIndex < data.Count)
+                    {
+                        return data[dataIndex] * m_DataScale;
+                    }
+                    else
+                    {
+                        return size;
+                    }
+                case SerieSymbolSizeType.Callback:
+                    if (sizeCallback != null) return sizeCallback(data);
+                    else return size;
+                default: return size;
+            }
+        }
+
+        /// <summary>
+        /// 根据sizeType获得高亮时的标记大小
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public float GetSelectedSize(List<float> data)
+        {
+            if (data == null) return selectedSize;
+            switch (m_SizeType)
+            {
+                case SerieSymbolSizeType.Custom:
+                    return selectedSize;
+                case SerieSymbolSizeType.FromData:
+                    if (dataIndex >= 0 && dataIndex < data.Count)
+                    {
+                        return data[dataIndex] * m_SelectedDataScale;
+                    }
+                    else
+                    {
+                        return selectedSize;
+                    }
+                case SerieSymbolSizeType.Callback:
+                    if (selectedSizeCallback != null) return selectedSizeCallback(data);
+                    else return selectedSize;
+                default: return selectedSize;
+            }
+        }
+
+        public bool ShowSymbol(int dataIndex, int dataCount)
+        {
+            if (type == SerieSymbolType.None) return false;
+            if (dataIndex < startIndex) return false;
+            if (m_Interval <= 0) return true;
+            if (m_ForceShowLast && dataIndex == dataCount - 1) return true;
+            return (dataIndex - startIndex) % (m_Interval + 1) == 0;
+        }
+    }
+}

Scripts/Runtime/Component/Sub/SerieSymbol.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a1f0c7348b7f54d4bbccc777a74c1d77
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Component/SubComponent.cs

@@ -0,0 +1,13 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+namespace XCharts
+{
+    public class SubComponent : ChartComponent
+    {
+    }
+}

Scripts/Runtime/Component/SubComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 94e905091d07140de987a531a6ff90d9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/HeatmapChart.cs

@@ -0,0 +1,141 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XCharts
+{
+    [AddComponentMenu("XCharts/HeatmapChart", 18)]
+    [ExecuteInEditMode]
+    [RequireComponent(typeof(RectTransform))]
+    [DisallowMultipleComponent]
+    public class HeatmapChart : CoordinateChart
+    {
+
+#if UNITY_EDITOR
+        protected override void Reset()
+        {
+            base.Reset();
+            m_Title.text = "HeatmapChart";
+            m_Tooltip.type = Tooltip.Type.None;
+            m_Grid.left = 100;
+            m_Grid.right = 60;
+            m_Grid.bottom = 60;
+
+            m_XAxises[0].type = Axis.AxisType.Category;
+            m_XAxises[0].boundaryGap = false;
+            m_YAxises[0].type = Axis.AxisType.Category;
+            m_YAxises[0].boundaryGap = false;
+            m_XAxises[0].splitNumber = 10;
+            m_YAxises[0].splitNumber = 10;
+            RemoveData();
+            var serie = AddSerie(SerieType.Heatmap, "serie1");
+            var heatmapGridWid = 10f;
+            int xSplitNumber = (int)(coordinateWidth / heatmapGridWid);
+            int ySplitNumber = (int)(coordinateHeight / heatmapGridWid);
+            serie.itemStyle.show = true;
+            serie.itemStyle.borderWidth = 1;
+            serie.itemStyle.borderColor = Color.clear;
+            serie.emphasis.show = true;
+            serie.emphasis.itemStyle.show = true;
+            serie.emphasis.itemStyle.borderWidth = 1;
+            serie.emphasis.itemStyle.borderColor = Color.black;
+
+            m_VisualMap.enable = true;
+            m_VisualMap.max = 10;
+            m_VisualMap.range[0] = 0f;
+            m_VisualMap.range[1] = 10f;
+            m_VisualMap.orient = Orient.Vertical;
+            m_VisualMap.calculable = true;
+            m_VisualMap.location.align = Location.Align.BottomLeft;
+            m_VisualMap.location.bottom = 100;
+            m_VisualMap.location.left = 30;
+            var colors = new List<string>{"#313695", "#4575b4", "#74add1", "#abd9e9", "#e0f3f8", "#ffffbf",
+                "#fee090", "#fdae61", "#f46d43", "#d73027", "#a50026"};
+            m_VisualMap.inRange.Clear();
+            foreach (var str in colors)
+            {
+                m_VisualMap.inRange.Add(ThemeInfo.GetColor(str));
+            }
+            for (int i = 0; i < xSplitNumber; i++)
+            {
+                m_XAxises[0].data.Add((i + 1).ToString());
+            }
+            for (int i = 0; i < ySplitNumber; i++)
+            {
+                m_YAxises[0].data.Add((i + 1).ToString());
+            }
+            for (int i = 0; i < xSplitNumber; i++)
+            {
+                for (int j = 0; j < ySplitNumber; j++)
+                {
+                    var value = 0f;
+                    var rate = Random.Range(0, 101);
+                    if (rate > 70) value = Random.Range(8f, 10f);
+                    else value = Random.Range(1f, 8f);
+                    var list = new List<float> { i, j, value };
+                    AddData(0, list);
+                }
+            }
+        }
+#endif
+
+        protected override void RefreshTooltip()
+        {
+            var xData = m_Tooltip.xValues[0];
+            var yData = m_Tooltip.yValues[0];
+            if (IsCategory() && (xData < 0 || yData < 0)) return;
+            sb.Length = 0;
+            for (int i = 0; i < m_Series.Count; i++)
+            {
+                var serie = m_Series.GetSerie(i);
+                var xAxis = m_XAxises[serie.axisIndex];
+                var yAxis = m_YAxises[serie.axisIndex];
+                var xCount = xAxis.data.Count;
+                var yCount = yAxis.data.Count;
+                if (serie.show && serie.type == SerieType.Heatmap)
+                {
+                    if (IsCategory())
+                    {
+                        string key = serie.name;
+                        var serieData = serie.data[(int)xData * yCount + (int)yData];
+                        var value = serieData.data[2];
+                        var color = m_VisualMap.enable ? m_VisualMap.GetColor(value) :
+                            (Color)m_ThemeInfo.GetColor(serie.index);
+                        sb.Append("\n")
+                            .Append(key).Append(!string.IsNullOrEmpty(key) ? "\n" : "")
+                            .Append("<color=#").Append(ChartCached.ColorToStr(color)).Append(">● </color>")
+                            .Append(xAxis.data[(int)xData]).Append(": ")
+                            .Append(ChartCached.FloatToStr(value));
+                    }
+                }
+            }
+            m_Tooltip.UpdateContentText(sb.ToString().Trim());
+            var pos = m_Tooltip.GetContentPos();
+            if (pos.x + m_Tooltip.width > chartWidth)
+            {
+                pos.x = chartWidth - m_Tooltip.width;
+            }
+            if (pos.y - m_Tooltip.height < 0)
+            {
+                pos.y = m_Tooltip.height;
+            }
+            m_Tooltip.UpdateContentPos(pos);
+            m_Tooltip.SetActive(true);
+
+            for (int i = 0; i < m_XAxises.Count; i++)
+            {
+                UpdateAxisTooltipLabel(i, m_XAxises[i]);
+            }
+            for (int i = 0; i < m_YAxises.Count; i++)
+            {
+                UpdateAxisTooltipLabel(i, m_YAxises[i]);
+            }
+        }
+    }
+}

Scripts/Runtime/HeatmapChart.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 31aa03cd4ce594c239ae746791b3b59f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Helper.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 58d150a402b5e4bfcbec6a28cba7ed44
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Helper/VisualMapHelper.cs

@@ -0,0 +1,14 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+namespace XCharts
+{
+    public static class VisualMapHelper
+    {
+        
+    }
+}

Scripts/Runtime/Helper/VisualMapHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 947fc87a63dec45f8b27ade5f0d050c4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Interface.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 253203a243755c744880211dbbc988a2
+folderAsset: yes
+timeCreated: 1554979427
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Interface/IJsonData.cs

@@ -0,0 +1,17 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+namespace XCharts
+{
+    /// <summary>
+    /// 从json导入数据接口
+    /// </summary>
+    public interface IJsonData
+    {
+        void ParseJsonData(string json);
+    }
+}

Scripts/Runtime/Interface/IJsonData.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: e9132f4c137015247b44450c2cb23606
+timeCreated: 1555379601
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Interface/IPropertyChanged.cs

@@ -0,0 +1,18 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+namespace XCharts
+{
+    /// <summary>
+    /// 属性变更接口
+    /// </summary>
+    public interface IPropertyChanged
+    {
+        void OnChanged();
+    }
+}
+

Scripts/Runtime/Interface/IPropertyChanged.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 24f32e2d632f08245ae885545f14a2a3
+timeCreated: 1554979427
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 750348e0c6842d74e872391f6ea942da
+folderAsset: yes
+timeCreated: 1554221587
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/AxisPool.cs

@@ -0,0 +1,39 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+namespace XCharts
+{
+    public static class XAxisPool
+    {
+        private static readonly ObjectPool<XAxis> s_ListPool = new ObjectPool<XAxis>(null, null);
+
+        public static XAxis Get()
+        {
+            return s_ListPool.Get();
+        }
+
+        public static void Release(XAxis toRelease)
+        {
+            s_ListPool.Release(toRelease);
+        }
+    }
+
+    public static class YAxisPool
+    {
+        private static readonly ObjectPool<YAxis> s_ListPool = new ObjectPool<YAxis>(null, null);
+
+        public static YAxis Get()
+        {
+            return s_ListPool.Get();
+        }
+
+        public static void Release(YAxis toRelease)
+        {
+            s_ListPool.Release(toRelease);
+        }
+    }
+}

Scripts/Runtime/Internal/AxisPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6d6006e13d2c640b9909e4d4121c01ea
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/BaseChart.cs

@@ -0,0 +1,782 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Linq;
+using UnityEngine;
+using UnityEngine.UI;
+using System.Collections.Generic;
+using System;
+using UnityEngine.EventSystems;
+
+namespace XCharts
+{
+    /// <summary>
+    /// the layout is horizontal or vertical.
+    /// 垂直还是水平布局方式。
+    /// </summary>
+    public enum Orient
+    {
+        /// <summary>
+        /// 水平
+        /// </summary>
+        Horizonal,
+        /// <summary>
+        /// 垂直
+        /// </summary>
+        Vertical
+    }
+
+    public partial class BaseChart : Graphic, IPointerDownHandler, IPointerUpHandler,
+        IPointerEnterHandler, IPointerExitHandler, IBeginDragHandler,
+        IDragHandler, IEndDragHandler, IScrollHandler
+    {
+        private static readonly string s_TitleObjectName = "title";
+        private static readonly string s_LegendObjectName = "legend";
+        private static readonly string s_SerieLabelObjectName = "label";
+
+        [SerializeField] protected float m_ChartWidth;
+        [SerializeField] protected float m_ChartHeight;
+        [SerializeField] protected ThemeInfo m_ThemeInfo;
+        [SerializeField] protected Title m_Title = Title.defaultTitle;
+        [SerializeField] protected Legend m_Legend = Legend.defaultLegend;
+        [SerializeField] protected Tooltip m_Tooltip = Tooltip.defaultTooltip;
+        [SerializeField] protected Series m_Series = Series.defaultSeries;
+        [SerializeField] protected Settings m_Settings = new Settings();
+        [SerializeField] protected float m_Large = 1;
+        [SerializeField] protected Action<VertexHelper> m_CustomDrawCallback;
+
+        [NonSerialized] private Theme m_CheckTheme = 0;
+        [NonSerialized] private Title m_CheckTitle = Title.defaultTitle;
+        [NonSerialized] private Legend m_CheckLegend = Legend.defaultLegend;
+        [NonSerialized] private float m_CheckWidth = 0;
+        [NonSerialized] private float m_CheckHeight = 0;
+        [NonSerialized] private float m_CheckSerieCount = 0;
+        [NonSerialized] private List<string> m_CheckSerieName = new List<string>();
+        [NonSerialized] private bool m_RefreshChart = false;
+        [NonSerialized] private bool m_RefreshLabel = false;
+        [NonSerialized] private bool m_ReinitLabel = false;
+        [NonSerialized] private bool m_CheckAnimation = false;
+        [NonSerialized] protected List<string> m_LegendRealShowName = new List<string>();
+
+        protected Vector2 chartAnchorMax { get { return rectTransform.anchorMax; } }
+        protected Vector2 chartAnchorMin { get { return rectTransform.anchorMin; } }
+        protected Vector2 chartPivot { get { return rectTransform.pivot; } }
+
+        protected override void Awake()
+        {
+            if (m_ThemeInfo == null)
+            {
+                m_ThemeInfo = ThemeInfo.Default;
+            }
+            raycastTarget = false;
+            rectTransform.anchorMax = Vector2.zero;
+            rectTransform.anchorMin = Vector2.zero;
+            rectTransform.pivot = Vector2.zero;
+            m_ChartWidth = rectTransform.sizeDelta.x;
+            m_ChartHeight = rectTransform.sizeDelta.y;
+            m_CheckWidth = m_ChartWidth;
+            m_CheckHeight = m_ChartHeight;
+            m_CheckTheme = m_ThemeInfo.theme;
+            InitTitle();
+            InitLegend();
+            InitSerieLabel();
+            InitTooltip();
+            m_Series.AnimationStop();
+            m_Series.AnimationStart();
+        }
+
+        protected override void Start()
+        {
+            RefreshChart();
+        }
+
+        protected virtual void Update()
+        {
+            CheckSize();
+            CheckTheme();
+            CheckTile();
+            CheckLegend();
+            CheckPointerPos();
+            CheckTooltip();
+            CheckRefreshChart();
+            CheckRefreshLabel();
+            CheckAnimation();
+        }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            Awake();
+        }
+
+        protected override void OnDisable()
+        {
+            base.OnDisable();
+            ChartHelper.HideAllObject(transform);
+        }
+
+#if UNITY_EDITOR
+        protected override void Reset()
+        {
+            var sizeDelta = rectTransform.sizeDelta;
+            if (sizeDelta.x < 580 && sizeDelta.y < 300)
+            {
+                rectTransform.sizeDelta = new Vector2(580, 300);
+            }
+            ChartHelper.HideAllObject(transform);
+            m_ThemeInfo = ThemeInfo.Default;
+            m_Title = Title.defaultTitle;
+            m_Legend = Legend.defaultLegend;
+            m_Tooltip = Tooltip.defaultTooltip;
+            m_Series = Series.defaultSeries;
+            Awake();
+        }
+#endif
+
+        protected override void OnDestroy()
+        {
+            for (int i = transform.childCount - 1; i >= 0; i--)
+            {
+                DestroyImmediate(transform.GetChild(i).gameObject);
+            }
+        }
+
+        private void InitTitle()
+        {
+            m_Title.OnChanged();
+            TextAnchor anchor = m_Title.location.textAnchor;
+            Vector2 anchorMin = m_Title.location.anchorMin;
+            Vector2 anchorMax = m_Title.location.anchorMax;
+            Vector2 pivot = m_Title.location.pivot;
+            Vector3 titlePosition = m_Title.location.GetPosition(chartWidth, chartHeight);
+            Vector3 subTitlePosition = -new Vector3(0, m_Title.textFontSize + m_Title.itemGap, 0);
+            float titleWid = chartWidth;
+
+            var titleObject = ChartHelper.AddObject(s_TitleObjectName, transform, anchorMin, anchorMax,
+                pivot, new Vector2(chartWidth, chartHeight));
+            titleObject.transform.localPosition = titlePosition;
+            ChartHelper.HideAllObject(titleObject);
+
+            Text titleText = ChartHelper.AddTextObject(s_TitleObjectName, titleObject.transform,
+                        m_ThemeInfo.font, m_ThemeInfo.titleTextColor, anchor, anchorMin, anchorMax, pivot,
+                        new Vector2(titleWid, m_Title.textFontSize), m_Title.textFontSize);
+
+            titleText.alignment = anchor;
+            titleText.gameObject.SetActive(m_Title.show);
+            titleText.transform.localPosition = Vector2.zero;
+            titleText.text = m_Title.text.Replace("\\n", "\n");
+
+            Text subText = ChartHelper.AddTextObject(s_TitleObjectName + "_sub", titleObject.transform,
+                        m_ThemeInfo.font, m_ThemeInfo.titleTextColor, anchor, anchorMin, anchorMax, pivot,
+                        new Vector2(titleWid, m_Title.subTextFontSize), m_Title.subTextFontSize);
+
+            subText.alignment = anchor;
+            subText.gameObject.SetActive(m_Title.show && !string.IsNullOrEmpty(m_Title.subText));
+            subText.transform.localPosition = subTitlePosition;
+            subText.text = m_Title.subText.Replace("\\n", "\n");
+        }
+
+        private void InitLegend()
+        {
+            m_Legend.OnChanged();
+            TextAnchor anchor = m_Legend.location.textAnchor;
+            Vector2 anchorMin = m_Legend.location.anchorMin;
+            Vector2 anchorMax = m_Legend.location.anchorMax;
+            Vector2 pivot = m_Legend.location.pivot;
+
+            var legendObject = ChartHelper.AddObject(s_LegendObjectName, transform, anchorMin, anchorMax,
+                pivot, new Vector2(chartWidth, chartHeight));
+            legendObject.transform.localPosition = m_Legend.location.GetPosition(chartWidth, chartHeight);
+
+            m_LegendRealShowName = m_Series.GetSerieNameList();
+            List<string> datas;
+            if (m_Legend.show && m_Legend.data.Count > 0)
+            {
+                datas = new List<string>();
+                for (int i = 0; i < m_LegendRealShowName.Count; i++)
+                {
+                    if (m_Legend.data.Contains(m_LegendRealShowName[i])) datas.Add(m_LegendRealShowName[i]);
+                }
+            }
+            else
+            {
+                datas = m_LegendRealShowName;
+            }
+            int totalLegend = 0;
+            for (int i = 0; i < datas.Count; i++)
+            {
+                if (!m_Series.IsLegalLegendName(datas[i])) continue;
+                totalLegend++;
+            }
+            m_Legend.RemoveButton();
+            ChartHelper.DestoryAllChilds(legendObject.transform);
+            if (!m_Legend.show) return;
+            for (int i = 0; i < datas.Count; i++)
+            {
+                if (!m_Series.IsLegalLegendName(datas[i])) continue;
+                string legendName = m_Legend.GetFormatterContent(datas[i]);
+                var readIndex = m_LegendRealShowName.IndexOf(datas[i]);
+                var objName = s_LegendObjectName + "_" + i + "_" + datas[i];
+                Button btn = ChartHelper.AddButtonObject(objName, legendObject.transform,
+                    m_ThemeInfo.font, m_Legend.itemFontSize, m_ThemeInfo.legendTextColor, anchor,
+                    anchorMin, anchorMax, pivot, new Vector2(m_Legend.itemWidth, m_Legend.itemHeight));
+                var bgColor = IsActiveByLegend(datas[i]) ?
+                    m_ThemeInfo.GetColor(readIndex) : m_ThemeInfo.legendUnableColor;
+                m_Legend.SetButton(legendName, btn, totalLegend);
+                m_Legend.UpdateButtonColor(legendName, bgColor);
+                btn.GetComponentInChildren<Text>().text = legendName;
+                ChartHelper.ClearEventListener(btn.gameObject);
+                ChartHelper.AddEventListener(btn.gameObject, EventTriggerType.PointerDown, (data) =>
+                {
+                    if (data.selectedObject == null || m_Legend.selectedMode == Legend.SelectedMode.None) return;
+                    var temp = data.selectedObject.name.Split('_');
+                    string selectedName = temp[2];
+                    int clickedIndex = int.Parse(temp[1]);
+                    if (m_Legend.selectedMode == Legend.SelectedMode.Multiple)
+                    {
+                        OnLegendButtonClick(clickedIndex, selectedName, !IsActiveByLegend(selectedName));
+                    }
+                    else
+                    {
+                        var btnList = m_Legend.buttonList.Values.ToArray();
+                        if (btnList.Length == 1)
+                        {
+                            OnLegendButtonClick(0, selectedName, !IsActiveByLegend(selectedName));
+                        }
+                        else
+                        {
+                            for (int n = 0; n < btnList.Length; n++)
+                            {
+                                temp = btnList[n].name.Split('_');
+                                selectedName = temp[2];
+                                var index = int.Parse(temp[1]);
+                                OnLegendButtonClick(n, selectedName, index == clickedIndex ? true : false);
+                            }
+                        }
+                    }
+                });
+                ChartHelper.AddEventListener(btn.gameObject, EventTriggerType.PointerEnter, (data) =>
+                {
+                    if (btn == null) return;
+                    var temp = btn.name.Split('_');
+                    string selectedName = temp[2];
+                    int index = int.Parse(temp[1]);
+                    OnLegendButtonEnter(index, selectedName);
+                });
+                ChartHelper.AddEventListener(btn.gameObject, EventTriggerType.PointerExit, (data) =>
+                {
+                    if (btn == null) return;
+                    var temp = btn.name.Split('_');
+                    string selectedName = temp[2];
+                    int index = int.Parse(temp[1]);
+                    OnLegendButtonExit(index, selectedName);
+                });
+            }
+            if (m_Legend.selectedMode == Legend.SelectedMode.Single)
+            {
+                for (int n = 0; n < m_LegendRealShowName.Count; n++)
+                {
+                    OnLegendButtonClick(n, m_LegendRealShowName[n], n == 0 ? true : false);
+                }
+            }
+        }
+
+        private void InitSerieLabel()
+        {
+            var labelObject = ChartHelper.AddObject(s_SerieLabelObjectName, transform, chartAnchorMin,
+                chartAnchorMax, chartPivot, new Vector2(chartWidth, chartHeight));
+            ChartHelper.DestoryAllChilds(labelObject.transform);
+            int count = 0;
+            for (int i = 0; i < m_Series.Count; i++)
+            {
+                var serie = m_Series.list[i];
+                for (int j = 0; j < serie.data.Count; j++)
+                {
+                    var serieData = serie.data[j];
+                    if (!serie.label.show  && j > 100) continue;
+                    var textName = s_SerieLabelObjectName + "_" + i + "_" + j + "_" + serieData.name;
+                    var color = Color.grey;
+                    if (serie.type == SerieType.Pie)
+                    {
+                        color = (serie.label.position == SerieLabel.Position.Inside) ? Color.white :
+                            (Color)m_ThemeInfo.GetColor(count);
+                    }
+                    else
+                    {
+                        color = serie.label.color != Color.clear ? serie.label.color :
+                            (Color)m_ThemeInfo.GetColor(i);
+                    }
+                    var backgroundColor = serie.label.backgroundColor;
+                    var labelObj = ChartHelper.AddSerieLabel(textName, labelObject.transform, m_ThemeInfo.font,
+                        color, backgroundColor, serie.label.fontSize, serie.label.fontStyle, serie.label.rotate,
+                        serie.label.backgroundWidth, serie.label.backgroundHeight);
+
+                    var iconObj = ChartHelper.AddIcon("Icon", labelObj.transform, serieData.iconWidth, serieData.iconHeight);
+                    serieData.SetIconObj(iconObj);
+                
+                    var isAutoSize = serie.label.backgroundWidth == 0 || serie.label.backgroundHeight == 0;
+                    serieData.InitLabel(labelObj, isAutoSize, serie.label.paddingLeftRight, serie.label.paddingTopBottom);
+                    serieData.SetLabelActive(false);
+                    serieData.SetLabelText(serieData.name);
+
+                    count++;
+                }
+            }
+        }
+
+        private void InitTooltip()
+        {
+            var tooltipObject = ChartHelper.AddObject("tooltip", transform, chartAnchorMin,
+                chartAnchorMax, chartPivot, new Vector2(chartWidth, chartHeight));
+            tooltipObject.transform.localPosition = Vector3.zero;
+            DestroyImmediate(tooltipObject.GetComponent<Image>());
+            var parent = tooltipObject.transform;
+            ChartHelper.HideAllObject(tooltipObject.transform);
+            GameObject content = ChartHelper.AddTooltipContent("content", parent, m_ThemeInfo.font,
+                m_Tooltip.fontSize, m_Tooltip.fontStyle);
+            m_Tooltip.SetObj(tooltipObject);
+            m_Tooltip.SetContentObj(content);
+            m_Tooltip.SetContentBackgroundColor(m_ThemeInfo.tooltipBackgroundColor);
+            m_Tooltip.SetContentTextColor(m_ThemeInfo.tooltipTextColor);
+            m_Tooltip.SetActive(false);
+        }
+
+        private Vector3 GetLegendPosition(int i)
+        {
+            return m_Legend.location.GetPosition(chartWidth, chartHeight);
+        }
+
+        private void CheckSize()
+        {
+            var sizeDelta = rectTransform.sizeDelta;
+            if (m_CheckWidth == 0 && m_CheckHeight == 0 && (sizeDelta.x != 0 || sizeDelta.y != 0))
+            {
+                Awake();
+            }
+            else if (m_CheckWidth != sizeDelta.x || m_CheckHeight != sizeDelta.y)
+            {
+                SetSize(sizeDelta.x, sizeDelta.y);
+            }
+        }
+
+        private void CheckTheme()
+        {
+            if (m_CheckTheme != m_ThemeInfo.theme)
+            {
+                m_CheckTheme = m_ThemeInfo.theme;
+                OnThemeChanged();
+            }
+        }
+
+        private void CheckTile()
+        {
+            if (!m_CheckTitle.Equals(m_Title))
+            {
+                m_CheckTitle.Copy(m_Title);
+                OnTitleChanged();
+            }
+        }
+
+        private void CheckLegend()
+        {
+            if (m_CheckLegend != m_Legend)
+            {
+                m_CheckLegend.Copy(m_Legend);
+                OnLegendChanged();
+            }
+            else if (m_Legend.show)
+            {
+                if (m_CheckSerieCount != m_Series.Count)
+                {
+                    m_CheckSerieCount = m_Series.Count;
+                    m_CheckSerieName.Clear();
+                    var serieNames = m_Series.GetSerieNameList();
+                    foreach (var name in serieNames) m_CheckSerieName.Add(name);
+                    OnLegendChanged();
+                }
+                else if (!ChartHelper.IsValueEqualsList(m_CheckSerieName, m_Series.GetSerieNameList()))
+                {
+                    var serieNames = m_Series.GetSerieNameList();
+                    foreach (var name in serieNames) m_CheckSerieName.Add(name);
+                    OnLegendChanged();
+                }
+            }
+        }
+
+        private void CheckPointerPos()
+        {
+            var needCheck = (m_Tooltip.show && m_Tooltip.inited)
+                || raycastTarget;
+            if (needCheck)
+            {
+                if (canvas == null) return;
+                Vector2 local;
+                if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform,
+                    Input.mousePosition, canvas.worldCamera, out local))
+                {
+                    pointerPos = Vector2.zero;
+                }
+                else
+                {
+                    pointerPos = local;
+                }
+            }
+        }
+
+        private void CheckTooltip()
+        {
+            if (!m_Tooltip.show || !m_Tooltip.inited)
+            {
+                if (m_Tooltip.IsActive())
+                {
+                    m_Tooltip.ClearValue();
+                    m_Tooltip.SetActive(false);
+                    RefreshChart();
+                }
+                return;
+            }
+            for (int i = 0; i < m_Tooltip.dataIndex.Count; i++)
+            {
+                m_Tooltip.dataIndex[i] = -1;
+            }
+            Vector2 local = pointerPos;
+            if (canvas == null) return;
+
+            if (local == Vector2.zero)
+            {
+                if (m_Tooltip.IsActive())
+                {
+                    m_Tooltip.SetActive(false);
+                    RefreshChart();
+                }
+                return;
+            }
+            if (local.x < 0 || local.x > chartWidth ||
+                local.y < 0 || local.y > chartHeight)
+            {
+                if (m_Tooltip.IsActive())
+                {
+                    m_Tooltip.SetActive(false);
+                    RefreshChart();
+                }
+                return;
+            }
+            m_Tooltip.pointerPos = local;
+            CheckTootipArea(local);
+        }
+
+        protected virtual void CheckTootipArea(Vector2 localPostion)
+        {
+        }
+
+        protected void CheckRefreshChart()
+        {
+            if (m_RefreshChart)
+            {
+                int tempWid = (int)chartWidth;
+                rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, tempWid - 1);
+                rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, tempWid);
+                m_RefreshChart = false;
+            }
+        }
+
+        protected void CheckRefreshLabel()
+        {
+            if (m_ReinitLabel)
+            {
+                m_ReinitLabel = false;
+                m_LegendRealShowName = m_Series.GetSerieNameList();
+                InitSerieLabel();
+            }
+            if (m_RefreshLabel)
+            {
+                m_RefreshLabel = false;
+                OnRefreshLabel();
+            }
+        }
+
+        protected void CheckAnimation()
+        {
+            if (!m_CheckAnimation)
+            {
+                m_CheckAnimation = true;
+                m_Series.AnimationStart();
+            }
+        }
+
+        protected virtual void OnRefreshLabel()
+        {
+
+        }
+
+        protected virtual void OnSizeChanged()
+        {
+            InitTitle();
+            InitLegend();
+            InitTooltip();
+        }
+
+        protected virtual void OnThemeChanged()
+        {
+            switch (m_ThemeInfo.theme)
+            {
+                case Theme.Dark:
+                    m_ThemeInfo.Copy(ThemeInfo.Dark);
+                    break;
+                case Theme.Default:
+                    m_ThemeInfo.Copy(ThemeInfo.Default);
+                    break;
+                case Theme.Light:
+                    m_ThemeInfo.Copy(ThemeInfo.Light);
+                    break;
+            }
+            InitTitle();
+            InitLegend();
+            InitTooltip();
+        }
+
+        protected virtual void OnTitleChanged()
+        {
+            InitTitle();
+        }
+
+        protected virtual void OnLegendChanged()
+        {
+            InitLegend();
+        }
+
+        protected virtual void OnYMaxValueChanged()
+        {
+        }
+
+        protected virtual void OnLegendButtonClick(int index, string legendName, bool show)
+        {
+            foreach (var serie in m_Series.GetSeries(legendName))
+            {
+                SetActive(serie.index, show);
+            }
+            OnYMaxValueChanged();
+            RefreshChart();
+        }
+
+        protected virtual void OnLegendButtonEnter(int index, string legendName)
+        {
+            var serie = m_Series.GetSerie(index);
+            serie.highlighted = true;
+            RefreshChart();
+        }
+
+        protected virtual void OnLegendButtonExit(int index, string legendName)
+        {
+            var serie = m_Series.GetSerie(index);
+            serie.highlighted = false;
+            RefreshChart();
+        }
+
+        protected bool CheckDataShow(string legendName, bool show)
+        {
+            bool needShow = false;
+            foreach (var serie in m_Series.list)
+            {
+                if (legendName.Equals(serie.name))
+                {
+                    serie.show = show;
+                    serie.highlighted = false;
+                    if (serie.show) needShow = true;
+                }
+                else
+                {
+                    foreach (var data in serie.data)
+                    {
+                        if (legendName.Equals(data.name))
+                        {
+                            data.show = show;
+                            data.highlighted = false;
+                            if (data.show) needShow = true;
+                        }
+                    }
+                }
+            }
+            return needShow;
+        }
+
+        protected bool CheckDataHighlighted(string legendName, bool heighlight)
+        {
+            bool show = false;
+            foreach (var serie in m_Series.list)
+            {
+                if (legendName.Equals(serie.name))
+                {
+                    serie.highlighted = heighlight;
+                }
+                else
+                {
+                    foreach (var data in serie.data)
+                    {
+                        if (legendName.Equals(data.name))
+                        {
+                            data.highlighted = heighlight;
+                            if (data.highlighted) show = true;
+                        }
+                    }
+                }
+            }
+            return show;
+        }
+
+        protected virtual void RefreshTooltip()
+        {
+        }
+
+        protected override void OnPopulateMesh(VertexHelper vh)
+        {
+            vh.Clear();
+            DrawBackground(vh);
+            DrawChart(vh);
+            if (m_CustomDrawCallback != null)
+            {
+                m_CustomDrawCallback(vh);
+            }
+            DrawTooltip(vh);
+            m_RefreshLabel = true;
+        }
+
+        protected virtual void DrawChart(VertexHelper vh)
+        {
+        }
+
+        protected virtual void DrawTooltip(VertexHelper vh)
+        {
+        }
+
+        private void DrawBackground(VertexHelper vh)
+        {
+            // draw bg
+            Vector3 p1 = new Vector3(0, chartHeight);
+            Vector3 p2 = new Vector3(chartWidth, chartHeight);
+            Vector3 p3 = new Vector3(chartWidth, 0);
+            Vector3 p4 = new Vector3(0, 0);
+            ChartDrawer.DrawPolygon(vh, p1, p2, p3, p4, m_ThemeInfo.backgroundColor);
+        }
+
+        protected void DrawSymbol(VertexHelper vh, SerieSymbolType type, float symbolSize,
+            float tickness, Vector3 pos, Color color)
+        {
+            switch (type)
+            {
+                case SerieSymbolType.None:
+                    break;
+                case SerieSymbolType.Circle:
+                    ChartDrawer.DrawCricle(vh, pos, symbolSize, color, m_Settings.cicleSmoothness);
+                    break;
+                case SerieSymbolType.EmptyCircle:
+                    ChartDrawer.DrawEmptyCricle(vh, pos, symbolSize, tickness, color, m_ThemeInfo.backgroundColor, m_Settings.cicleSmoothness);
+                    break;
+                case SerieSymbolType.Rect:
+                    ChartDrawer.DrawPolygon(vh, pos, symbolSize, color);
+                    break;
+                case SerieSymbolType.Triangle:
+                    var x = symbolSize * Mathf.Cos(30 * Mathf.PI / 180);
+                    var y = symbolSize * Mathf.Sin(30 * Mathf.PI / 180);
+                    var p1 = new Vector2(pos.x - x, pos.y - y);
+                    var p2 = new Vector2(pos.x, pos.y + symbolSize);
+                    var p3 = new Vector2(pos.x + x, pos.y - y);
+                    ChartDrawer.DrawTriangle(vh, p1, p2, p3, color);
+                    break;
+                case SerieSymbolType.Diamond:
+                    p1 = new Vector2(pos.x - symbolSize, pos.y);
+                    p2 = new Vector2(pos.x, pos.y + symbolSize);
+                    p3 = new Vector2(pos.x + symbolSize, pos.y);
+                    var p4 = new Vector2(pos.x, pos.y - symbolSize);
+                    ChartDrawer.DrawPolygon(vh, p1, p2, p3, p4, color);
+                    break;
+            }
+        }
+
+        protected void DrawLabelBackground(VertexHelper vh, Serie serie, SerieData serieData)
+        {
+            var labelHalfWid = serieData.GetLabelWidth() / 2;
+            var labelHalfHig = serieData.GetLabelHeight() / 2;
+            var centerPos = serieData.labelPosition + serie.label.offset;
+            var p1 = new Vector3(centerPos.x - labelHalfWid, centerPos.y + labelHalfHig);
+            var p2 = new Vector3(centerPos.x + labelHalfWid, centerPos.y + labelHalfHig);
+            var p3 = new Vector3(centerPos.x + labelHalfWid, centerPos.y - labelHalfHig);
+            var p4 = new Vector3(centerPos.x - labelHalfWid, centerPos.y - labelHalfHig);
+
+            if (serie.label.rotate > 0)
+            {
+                p1 = ChartHelper.RotateRound(p1, centerPos, Vector3.forward, serie.label.rotate);
+                p2 = ChartHelper.RotateRound(p2, centerPos, Vector3.forward, serie.label.rotate);
+                p3 = ChartHelper.RotateRound(p3, centerPos, Vector3.forward, serie.label.rotate);
+                p4 = ChartHelper.RotateRound(p4, centerPos, Vector3.forward, serie.label.rotate);
+            }
+
+            ChartDrawer.DrawPolygon(vh, p1, p2, p3, p4, serie.label.backgroundColor);
+
+            if (serie.label.border)
+            {
+                var borderWid = serie.label.borderWidth;
+                p1 = new Vector3(centerPos.x - labelHalfWid, centerPos.y + labelHalfHig + borderWid);
+                p2 = new Vector3(centerPos.x + labelHalfWid + 2 * borderWid, centerPos.y + labelHalfHig + borderWid);
+                p3 = new Vector3(centerPos.x + labelHalfWid + borderWid, centerPos.y + labelHalfHig);
+                p4 = new Vector3(centerPos.x + labelHalfWid + borderWid, centerPos.y - labelHalfHig - 2 * borderWid);
+                var p5 = new Vector3(centerPos.x + labelHalfWid, centerPos.y - labelHalfHig - borderWid);
+                var p6 = new Vector3(centerPos.x - labelHalfWid - 2 * borderWid, centerPos.y - labelHalfHig - borderWid);
+                var p7 = new Vector3(centerPos.x - labelHalfWid - borderWid, centerPos.y - labelHalfHig);
+                var p8 = new Vector3(centerPos.x - labelHalfWid - borderWid, centerPos.y + labelHalfHig + 2 * borderWid);
+                if (serie.label.rotate > 0)
+                {
+                    p1 = ChartHelper.RotateRound(p1, centerPos, Vector3.forward, serie.label.rotate);
+                    p2 = ChartHelper.RotateRound(p2, centerPos, Vector3.forward, serie.label.rotate);
+                    p3 = ChartHelper.RotateRound(p3, centerPos, Vector3.forward, serie.label.rotate);
+                    p4 = ChartHelper.RotateRound(p4, centerPos, Vector3.forward, serie.label.rotate);
+                    p5 = ChartHelper.RotateRound(p5, centerPos, Vector3.forward, serie.label.rotate);
+                    p6 = ChartHelper.RotateRound(p6, centerPos, Vector3.forward, serie.label.rotate);
+                    p7 = ChartHelper.RotateRound(p7, centerPos, Vector3.forward, serie.label.rotate);
+                    p8 = ChartHelper.RotateRound(p8, centerPos, Vector3.forward, serie.label.rotate);
+                }
+                ChartDrawer.DrawLine(vh, p1, p2, borderWid, serie.label.borderColor);
+                ChartDrawer.DrawLine(vh, p3, p4, borderWid, serie.label.borderColor);
+                ChartDrawer.DrawLine(vh, p5, p6, borderWid, serie.label.borderColor);
+                ChartDrawer.DrawLine(vh, p7, p8, borderWid, serie.label.borderColor);
+            }
+        }
+
+        public virtual void OnPointerDown(PointerEventData eventData)
+        {
+        }
+
+        public virtual void OnPointerUp(PointerEventData eventData)
+        {
+
+        }
+
+        public virtual void OnPointerEnter(PointerEventData eventData)
+        {
+        }
+
+        public virtual void OnPointerExit(PointerEventData eventData)
+        {
+        }
+
+        public virtual void OnBeginDrag(PointerEventData eventData)
+        {
+        }
+
+        public virtual void OnEndDrag(PointerEventData eventData)
+        {
+        }
+
+        public virtual void OnDrag(PointerEventData eventData)
+        {
+        }
+
+        public virtual void OnScroll(PointerEventData eventData)
+        {
+        }
+    }
+}

Scripts/Runtime/Internal/BaseChart.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: d5053a63a1ebdfe4f8972f194156c3d3
+timeCreated: 1536967243
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/CoordinateChart.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c20b1e83703d1084c899f1f1b605c278
+timeCreated: 1538087401
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/CoordinateChart_DrawBar.cs

@@ -0,0 +1,299 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    public partial class CoordinateChart
+    {
+        protected float m_BarLastOffset = 0;
+
+        protected void DrawYBarSerie(VertexHelper vh, Serie serie, int colorIndex, ref List<float> seriesHig)
+        {
+            if (!IsActive(serie.name)) return;
+            var xAxis = m_XAxises[serie.axisIndex];
+            var yAxis = m_YAxises[serie.axisIndex];
+            if (!yAxis.show) yAxis = m_YAxises[(serie.axisIndex + 1) % m_YAxises.Count];
+
+            float categoryWidth = yAxis.GetDataWidth(coordinateHeight, m_DataZoom);
+            float barGap = GetBarGap();
+            float totalBarWidth = GetBarTotalWidth(categoryWidth, barGap);
+            float barWidth = serie.GetBarWidth(categoryWidth);
+            float offset = (categoryWidth - totalBarWidth) / 2;
+            float barGapWidth = barWidth + barWidth * barGap;
+            float space = serie.barGap == -1 ? offset : offset + m_BarLastOffset;
+
+            var showData = serie.GetDataList(m_DataZoom);
+            int maxCount = serie.maxShow > 0 ?
+                (serie.maxShow > showData.Count ? showData.Count : serie.maxShow)
+                : showData.Count;
+            if (seriesHig.Count < serie.minShow)
+            {
+                for (int i = 0; i < serie.minShow; i++)
+                {
+                    seriesHig.Add(0);
+                }
+            }
+            var isPercentStack = m_Series.IsPercentStack(serie.stack, SerieType.Bar);
+            for (int i = serie.minShow; i < maxCount; i++)
+            {
+                if (i >= seriesHig.Count)
+                {
+                    seriesHig.Add(0);
+                }
+                float value = showData[i].data[1];
+                float pX = seriesHig[i] + coordinateX + xAxis.zeroXOffset + yAxis.axisLine.width;
+                float pY = coordinateY + +i * categoryWidth;
+                if (!yAxis.boundaryGap) pY -= categoryWidth / 2;
+
+                var barHig = 0f;
+                var valueTotal = 0f;
+                if (isPercentStack)
+                {
+                    valueTotal = GetSameStackTotalValue(serie.stack, i);
+                    barHig = value / valueTotal * coordinateWidth;
+                    seriesHig[i] += barHig;
+                }
+                else
+                {
+                    valueTotal = xAxis.maxValue - xAxis.minValue;
+                    barHig = (xAxis.minValue > 0 ? value - xAxis.minValue : value)
+                        / valueTotal * coordinateWidth;
+                    seriesHig[i] += barHig;
+                }
+
+                float currHig = CheckAnimation(serie, i, barHig);
+
+                Vector3 p1 = new Vector3(pX, pY + space + barWidth);
+                Vector3 p2 = new Vector3(pX + currHig, pY + space + barWidth);
+                Vector3 p3 = new Vector3(pX + currHig, pY + space);
+                Vector3 p4 = new Vector3(pX, pY + space);
+                serie.dataPoints.Add(new Vector3(pX + currHig, pY + space + barWidth / 2));
+                var highlight = (m_Tooltip.show && m_Tooltip.IsSelected(i))
+                    || serie.data[i].highlighted
+                    || serie.highlighted;
+                if (serie.show)
+                {
+                    Color areaColor = serie.GetAreaColor(m_ThemeInfo, colorIndex, highlight);
+                    Color areaToColor = serie.GetAreaToColor(m_ThemeInfo, colorIndex, highlight);
+                    if (serie.barType == BarType.Zebra)
+                    {
+                        p1 = (p4 + p1) / 2;
+                        p2 = (p2 + p3) / 2;
+                        ChartDrawer.DrawZebraLine(vh, p1, p2, barWidth / 2, serie.barZebraWidth, serie.barZebraGap, areaColor);
+                    }
+                    else
+                    {
+                        ChartDrawer.DrawPolygon(vh, p4, p1, p2, p3, areaColor, areaToColor);
+                    }
+                }
+            }
+            if (!m_Series.IsStack(serie.stack, SerieType.Bar))
+            {
+                m_BarLastOffset += barGapWidth;
+            }
+        }
+
+        private float CheckAnimation(Serie serie, int dataIndex, float barHig)
+        {
+            float currHig = barHig;
+            if (!serie.animation.IsFinish())
+            {
+                if (serie.animation.IsInDelay()) currHig = 0;
+                else
+                {
+                    var speed = serie.animation.duration > 0 ? barHig / serie.animation.duration * 1000 : barHig;
+                    currHig = serie.animation.GetDataState(dataIndex) + speed * Time.deltaTime;
+                    serie.animation.SetDataState(dataIndex, currHig);
+                    if (Mathf.Abs(currHig) >= Mathf.Abs(barHig))
+                    {
+                        serie.animation.End();
+                        currHig = barHig;
+                    }
+                }
+                RefreshChart();
+            }
+            return currHig;
+        }
+
+        protected void DrawXBarSerie(VertexHelper vh, Serie serie, int colorIndex, ref List<float> seriesHig)
+        {
+            if (!IsActive(serie.name)) return;
+            var showData = serie.GetDataList(m_DataZoom);
+            var yAxis = m_YAxises[serie.axisIndex];
+            var xAxis = m_XAxises[serie.axisIndex];
+            if (!xAxis.show) xAxis = m_XAxises[(serie.axisIndex + 1) % m_XAxises.Count];
+
+            float categoryWidth = xAxis.GetDataWidth(coordinateWidth, m_DataZoom);
+            float barGap = GetBarGap();
+            float totalBarWidth = GetBarTotalWidth(categoryWidth, barGap);
+            float barWidth = serie.GetBarWidth(categoryWidth);
+            float offset = (categoryWidth - totalBarWidth) / 2;
+            float barGapWidth = barWidth + barWidth * barGap;
+            float space = serie.barGap == -1 ? offset : offset + m_BarLastOffset;
+            int maxCount = serie.maxShow > 0 ?
+                (serie.maxShow > showData.Count ? showData.Count : serie.maxShow)
+                : showData.Count;
+
+            if (seriesHig.Count < serie.minShow)
+            {
+                for (int i = 0; i < serie.minShow; i++)
+                {
+                    seriesHig.Add(0);
+                }
+            }
+
+            var isPercentStack = m_Series.IsPercentStack(serie.stack, SerieType.Bar);
+            for (int i = serie.minShow; i < maxCount; i++)
+            {
+                if (i >= seriesHig.Count)
+                {
+                    seriesHig.Add(0);
+                }
+                float value = showData[i].data[1];
+                float pX = coordinateX + i * categoryWidth;
+                float zeroY = coordinateY + yAxis.zeroYOffset;
+                if (!xAxis.boundaryGap) pX -= categoryWidth / 2;
+                float pY = seriesHig[i] + zeroY + xAxis.axisLine.width;
+
+                var barHig = 0f;
+                var valueTotal = 0f;
+                if (isPercentStack)
+                {
+                    valueTotal = GetSameStackTotalValue(serie.stack, i);
+                    barHig = value / valueTotal * coordinateHeight;
+                    seriesHig[i] += barHig;
+                }
+                else
+                {
+                    valueTotal = yAxis.maxValue - yAxis.minValue;
+                    barHig = (yAxis.minValue > 0 ? value - yAxis.minValue : value)
+                        / valueTotal * coordinateHeight;
+                    seriesHig[i] += barHig;
+                }
+
+                float currHig = CheckAnimation(serie, i, barHig);
+
+                Vector3 p1 = new Vector3(pX + space, pY);
+                Vector3 p2 = new Vector3(pX + space, pY + currHig);
+                Vector3 p3 = new Vector3(pX + space + barWidth, pY + currHig);
+                Vector3 p4 = new Vector3(pX + space + barWidth, pY);
+                serie.dataPoints.Add(new Vector3(pX + space + barWidth / 2, pY + currHig));
+                var highlight = (m_Tooltip.show && m_Tooltip.IsSelected(i))
+                    || serie.data[i].highlighted
+                    || serie.highlighted;
+
+                if (serie.show)
+                {
+                    Color areaColor = serie.GetAreaColor(m_ThemeInfo, colorIndex, highlight);
+                    Color areaToColor = serie.GetAreaToColor(m_ThemeInfo, colorIndex, highlight);
+                    if (serie.barType == BarType.Zebra)
+                    {
+                        p1 = (p4 + p1) / 2;
+                        p2 = (p2 + p3) / 2;
+                        ChartDrawer.DrawZebraLine(vh, p1, p2, barWidth / 2, serie.barZebraWidth, serie.barZebraGap, areaColor);
+                    }
+                    else
+                    {
+                        ChartDrawer.DrawPolygon(vh, p4, p1, p2, p3, areaColor, areaToColor);
+                    }
+                }
+            }
+            if (!m_Series.IsStack(serie.stack, SerieType.Bar))
+            {
+                m_BarLastOffset += barGapWidth;
+            }
+        }
+
+        private float GetBarGap()
+        {
+            float gap = 0.3f;
+            for (int i = 0; i < m_Series.Count; i++)
+            {
+                var serie = m_Series.list[i];
+                if (serie.type == SerieType.Bar)
+                {
+                    if (serie.barGap != 0)
+                    {
+                        gap = serie.barGap;
+                    }
+                }
+            }
+            return gap;
+        }
+
+        private float GetSameStackTotalValue(string stack, int dataIndex)
+        {
+            if (string.IsNullOrEmpty(stack)) return 0;
+            float total = 0;
+            foreach (var serie in m_Series.list)
+            {
+                if (serie.type == SerieType.Bar)
+                {
+                    if (stack.Equals(serie.stack))
+                    {
+                        total += serie.data[dataIndex].data[1];
+                    }
+                }
+            }
+            return total;
+        }
+
+
+        private HashSet<string> barStackSet = new HashSet<string>();
+        private float GetBarTotalWidth(float categoryWidth, float gap)
+        {
+            float total = 0;
+            float lastGap = 0;
+            barStackSet.Clear();
+            for (int i = 0; i < m_Series.Count; i++)
+            {
+                var serie = m_Series.list[i];
+                if (serie.type == SerieType.Bar && serie.show)
+                {
+                    if (!string.IsNullOrEmpty(serie.stack))
+                    {
+                        if (barStackSet.Contains(serie.stack)) continue;
+                        barStackSet.Add(serie.stack);
+                    }
+                    var width = GetStackBarWidth(categoryWidth, serie);
+                    if (gap == -1)
+                    {
+                        if (width > total) total = width;
+                    }
+                    else
+                    {
+                        lastGap = width * gap;
+                        total += width;
+                        total += lastGap;
+                    }
+                }
+            }
+            if (total > 0 && gap != -1) total -= lastGap;
+            return total;
+        }
+
+        private float GetStackBarWidth(float categoryWidth, Serie now)
+        {
+            if (string.IsNullOrEmpty(now.stack)) return now.GetBarWidth(categoryWidth);
+            float barWidth = 0;
+            for (int i = 0; i < m_Series.Count; i++)
+            {
+                var serie = m_Series.list[i];
+                if (serie.type == SerieType.Bar && serie.show && now.stack.Equals(serie.stack))
+                {
+                    if (serie.barWidth > barWidth) barWidth = serie.barWidth;
+                }
+            }
+            if (barWidth > 1) return barWidth;
+            else return barWidth * categoryWidth;
+        }
+    }
+}

Scripts/Runtime/Internal/CoordinateChart_DrawBar.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2abce1026caf74ffbb653c6e1a8d1e3f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/CoordinateChart_DrawHeatmap.cs

@@ -0,0 +1,384 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    public partial class CoordinateChart
+    {
+        private bool m_VisualMapMinDrag;
+        private bool m_VisualMapMaxDrag;
+
+        protected void CheckVisualMap()
+        {
+            if (!m_VisualMap.enable || !m_VisualMap.show) return;
+            Vector2 local;
+            if (canvas == null) return;
+
+            if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform,
+                Input.mousePosition, canvas.worldCamera, out local))
+            {
+                if (m_VisualMap.rtSelectedIndex >= 0)
+                {
+                    m_VisualMap.rtSelectedIndex = -1;
+                    RefreshChart();
+                }
+                return;
+            }
+            if (local.x < 0 || local.x > chartWidth ||
+                local.y < 0 || local.y > chartHeight ||
+                !m_VisualMap.IsInRangeRect(local, chartWidth, chartHeight))
+            {
+                if (m_VisualMap.rtSelectedIndex >= 0)
+                {
+                    m_VisualMap.rtSelectedIndex = -1;
+                    RefreshChart();
+                }
+                return;
+            }
+            var pos1 = Vector3.zero;
+            var pos2 = Vector3.zero;
+            var halfHig = m_VisualMap.itemHeight / 2;
+            var centerPos = m_VisualMap.location.GetPosition(chartWidth, chartHeight);
+            var selectedIndex = -1;
+            var value = 0f;
+            switch (m_VisualMap.orient)
+            {
+                case Orient.Horizonal:
+                    pos1 = centerPos + Vector3.left * halfHig;
+                    pos2 = centerPos + Vector3.right * halfHig;
+                    value = m_VisualMap.min + (local.x - pos1.x) / (pos2.x - pos1.x) * (m_VisualMap.max - m_VisualMap.min);
+                    selectedIndex = m_VisualMap.GetIndex(value);
+                    break;
+                case Orient.Vertical:
+                    pos1 = centerPos + Vector3.down * halfHig;
+                    pos2 = centerPos + Vector3.up * halfHig;
+                    value = m_VisualMap.min + (local.y - pos1.y) / (pos2.y - pos1.y) * (m_VisualMap.max - m_VisualMap.min);
+                    selectedIndex = m_VisualMap.GetIndex(value);
+                    break;
+            }
+            m_VisualMap.rtSelectedValue = value;
+            m_VisualMap.rtSelectedIndex = selectedIndex;
+            RefreshChart();
+        }
+
+        protected void OnDragVisualMapStart()
+        {
+            if (!m_VisualMap.enable || !m_VisualMap.show || !m_VisualMap.calculable) return;
+            var inMinRect = m_VisualMap.IsInRangeMinRect(pointerPos, chartWidth, chartHeight, m_Settings.visualMapTriangeLen);
+            var inMaxRect = m_VisualMap.IsInRangeMaxRect(pointerPos, chartWidth, chartHeight, m_Settings.visualMapTriangeLen);
+            if (inMinRect || inMaxRect)
+            {
+                if (inMinRect)
+                {
+                    m_VisualMapMinDrag = true;
+                }
+                else
+                {
+                    m_VisualMapMaxDrag = true;
+                }
+            }
+        }
+
+        protected void OnDragVisualMap()
+        {
+            if (!m_VisualMap.enable || !m_VisualMap.show || !m_VisualMap.calculable) return;
+            if (!m_VisualMapMinDrag && !m_VisualMapMaxDrag) return;
+
+            var value = m_VisualMap.GetValue(pointerPos, chartWidth, chartHeight);
+            if (m_VisualMapMinDrag)
+            {
+                m_VisualMap.rangeMin = value;
+            }
+            else
+            {
+                m_VisualMap.rangeMax = value;
+            }
+            RefreshChart();
+        }
+
+        protected void OnDragVisualMapEnd()
+        {
+            if (!m_VisualMap.enable || !m_VisualMap.show || !m_VisualMap.calculable) return;
+            if (m_VisualMapMinDrag || m_VisualMapMaxDrag)
+            {
+                RefreshChart();
+                m_VisualMapMinDrag = false;
+                m_VisualMapMaxDrag = false;
+            }
+        }
+
+        protected void DrawHeatmapSerie(VertexHelper vh, int colorIndex, Serie serie)
+        {
+            var yAxis = m_YAxises[serie.axisIndex];
+            var xAxis = m_XAxises[serie.axisIndex];
+            var xCount = xAxis.data.Count;
+            var yCount = yAxis.data.Count;
+            var xWidth = coordinateWidth / xCount;
+            var yWidth = coordinateHeight / yCount;
+
+            var zeroX = coordinateX;
+            var zeroY = coordinateY;
+            var dataList = serie.GetDataList();
+            var rangeMin = m_VisualMap.rangeMin;
+            var rangeMax = m_VisualMap.rangeMax;
+            var color = m_ThemeInfo.GetColor(serie.index);
+            var borderWidth = serie.itemStyle.show ? serie.itemStyle.borderWidth : 0;
+            var borderColor = serie.itemStyle.opacity > 0 ? serie.itemStyle.borderColor : Color.clear;
+            borderColor.a *= serie.itemStyle.opacity;
+            serie.dataPoints.Clear();
+            serie.animation.InitProgress(1, 0, xCount);
+            var animationIndex = serie.animation.GetCurrIndex();
+            for (int i = 0; i < xCount; i++)
+            {
+                for (int j = 0; j < yCount; j++)
+                {
+                    var dataIndex = i * yCount + j;
+                    if (dataIndex >= dataList.Count) continue;
+                    var serieData = dataList[dataIndex];
+                    var dimension = m_VisualMap.enable && m_VisualMap.dimension > 0 ? m_VisualMap.dimension - 1 :
+                        serieData.data.Count - 1;
+                    var value = serieData.data[dimension];
+                    var pos = new Vector3(zeroX + (i + 0.5f) * xWidth, zeroY + (j + 0.5f) * yWidth);
+                    serie.dataPoints.Add(pos);
+                    serieData.canShowLabel = false;
+                    if (value == 0) continue;
+                    if (m_VisualMap.enable)
+                    {
+                        if ((value < rangeMin && rangeMin != m_VisualMap.min)
+                            || (value > rangeMax && rangeMax != m_VisualMap.max))
+                        {
+                            continue;
+                        }
+                        if (!m_VisualMap.IsInSelectedValue(value)) continue;
+                        color = m_VisualMap.GetColor(value);
+                    }
+                    if(animationIndex>= 0 && i> animationIndex) continue;
+                    serieData.canShowLabel = true;
+                    var emphasis = (m_Tooltip.show && i == (int)m_Tooltip.xValues[0] && j == (int)m_Tooltip.yValues[0])
+                        || m_VisualMap.rtSelectedIndex > 0;
+                    var rectWid = xWidth - 2 * borderWidth;
+                    var rectHig = yWidth - 2 * borderWidth;
+                    ChartDrawer.DrawPolygon(vh, pos, rectWid / 2, rectHig / 2, color);
+                    if (borderWidth > 0 && borderColor != Color.clear)
+                    {
+                        ChartDrawer.DrawBorder(vh, pos, rectWid, rectHig, borderWidth, borderColor);
+                    }
+                    if (m_VisualMap.hoverLink && emphasis && serie.emphasis.show && serie.emphasis.itemStyle.borderWidth > 0)
+                    {
+                        var emphasisBorderWidth = serie.emphasis.itemStyle.borderWidth;
+                        var emphasisBorderColor = serie.emphasis.itemStyle.opacity > 0 ? serie.emphasis.itemStyle.borderColor : Color.clear;
+                        ChartDrawer.DrawBorder(vh, pos, rectWid, rectHig, emphasisBorderWidth, emphasisBorderColor);
+                    }
+                }
+            }
+            if (!serie.animation.IsFinish())
+            {
+                float duration = serie.animation.duration > 0 ? (float)serie.animation.duration / 1000 : 1;
+                float speed = xCount / duration;
+                serie.animation.CheckProgress(Time.deltaTime * speed);
+                RefreshChart();
+            }
+        }
+
+        protected void DrawVisualMap(VertexHelper vh)
+        {
+            if (!m_VisualMap.enable || !m_VisualMap.show) return;
+            var centerPos = m_VisualMap.location.GetPosition(chartWidth, chartHeight);
+
+            var pos1 = Vector3.zero;
+            var pos2 = Vector3.zero;
+            var dir = Vector3.zero;
+            var halfWid = m_VisualMap.itemWidth / 2;
+            var halfHig = m_VisualMap.itemHeight / 2;
+            var xRadius = 0f;
+            var yRadius = 0f;
+            var splitNum = m_VisualMap.rtInRange.Count;
+            var splitWid = m_VisualMap.itemHeight / (splitNum - 1);
+            var isVertical = false;
+            var colors = m_VisualMap.rtInRange;
+            var triangeLen = m_Settings.visualMapTriangeLen;
+            switch (m_VisualMap.orient)
+            {
+                case Orient.Horizonal:
+                    pos1 = centerPos + Vector3.left * halfHig;
+                    pos2 = centerPos + Vector3.right * halfHig;
+                    dir = Vector3.right;
+                    xRadius = splitWid / 2;
+                    yRadius = halfWid;
+                    isVertical = false;
+                    if (m_VisualMap.calculable)
+                    {
+                        var p0 = pos1 + Vector3.right * m_VisualMap.rangeMinHeight;
+                        var p1 = p0 + Vector3.up * halfWid;
+                        var p2 = p0 + Vector3.up * (halfWid + triangeLen);
+                        var p3 = p2 + Vector3.left * triangeLen;
+                        var color = m_VisualMap.GetColor(m_VisualMap.rangeMin);
+                        ChartDrawer.DrawTriangle(vh, p1, p2, p3, color);
+                        p0 = pos1 + Vector3.right * m_VisualMap.rangeMaxHeight;
+                        p1 = p0 + Vector3.up * halfWid;
+                        p2 = p0 + Vector3.up * (halfWid + triangeLen);
+                        p3 = p2 + Vector3.right * triangeLen;
+                        color = m_VisualMap.GetColor(m_VisualMap.rangeMax);
+                        ChartDrawer.DrawTriangle(vh, p1, p2, p3, color);
+                    }
+                    break;
+                case Orient.Vertical:
+                    pos1 = centerPos + Vector3.down * halfHig;
+                    pos2 = centerPos + Vector3.up * halfHig;
+                    dir = Vector3.up;
+                    xRadius = halfWid;
+                    yRadius = splitWid / 2;
+                    isVertical = true;
+                    if (m_VisualMap.calculable)
+                    {
+                        var p0 = pos1 + Vector3.up * m_VisualMap.rangeMinHeight;
+                        var p1 = p0 + Vector3.right * halfWid;
+                        var p2 = p0 + Vector3.right * (halfWid + triangeLen);
+                        var p3 = p2 + Vector3.down * triangeLen;
+                        var color = m_VisualMap.GetColor(m_VisualMap.rangeMin);
+                        ChartDrawer.DrawTriangle(vh, p1, p2, p3, color);
+                        p0 = pos1 + Vector3.up * m_VisualMap.rangeMaxHeight;
+                        p1 = p0 + Vector3.right * halfWid;
+                        p2 = p0 + Vector3.right * (halfWid + triangeLen);
+                        p3 = p2 + Vector3.up * triangeLen;
+                        color = m_VisualMap.GetColor(m_VisualMap.rangeMax);
+                        ChartDrawer.DrawTriangle(vh, p1, p2, p3, color);
+                    }
+                    break;
+            }
+            if (m_VisualMap.calculable && (m_VisualMap.rangeMin > m_VisualMap.min
+                || m_VisualMap.rangeMax < m_VisualMap.max))
+            {
+                var rangeMin = m_VisualMap.rangeMin;
+                var rangeMax = m_VisualMap.rangeMax;
+                var diff = (m_VisualMap.max - m_VisualMap.min) / (splitNum - 1);
+                for (int i = 1; i < splitNum; i++)
+                {
+                    var splitMin = m_VisualMap.min + (i - 1) * diff;
+                    var splitMax = splitMin + diff;
+                    if (rangeMin > splitMax || rangeMax < splitMin)
+                    {
+                        continue;
+                    }
+                    else if (rangeMin <= splitMin && rangeMax >= splitMax)
+                    {
+                        var splitPos = pos1 + dir * (i - 1 + 0.5f) * splitWid;
+                        var startColor = colors[i - 1];
+                        var toColor = colors[i];
+                        ChartDrawer.DrawPolygon(vh, splitPos, xRadius, yRadius, startColor, toColor, isVertical);
+                    }
+                    else if (rangeMin > splitMin && rangeMax >= splitMax)
+                    {
+                        var p0 = pos1 + dir * m_VisualMap.rangeMinHeight;
+                        var splitMaxPos = pos1 + dir * i * splitWid;
+                        var splitPos = p0 + (splitMaxPos - p0) / 2;
+                        var startColor = m_VisualMap.GetColor(m_VisualMap.rangeMin);
+                        var toColor = colors[i];
+                        var yRadius1 = Vector3.Distance(p0, splitMaxPos) / 2;
+                        if (m_VisualMap.orient == Orient.Vertical)
+                            ChartDrawer.DrawPolygon(vh, splitPos, xRadius, yRadius1, startColor, toColor, isVertical);
+                        else
+                            ChartDrawer.DrawPolygon(vh, splitPos, yRadius1, yRadius, startColor, toColor, isVertical);
+                    }
+                    else if (rangeMax < splitMax && rangeMin <= splitMin)
+                    {
+                        var p0 = pos1 + dir * m_VisualMap.rangeMaxHeight;
+                        var splitMinPos = pos1 + dir * (i - 1) * splitWid;
+                        var splitPos = splitMinPos + (p0 - splitMinPos) / 2;
+                        var startColor = colors[i - 1];
+                        var toColor = m_VisualMap.GetColor(m_VisualMap.rangeMax);
+                        var yRadius1 = Vector3.Distance(p0, splitMinPos) / 2;
+                        if (m_VisualMap.orient == Orient.Vertical)
+                            ChartDrawer.DrawPolygon(vh, splitPos, xRadius, yRadius1, startColor, toColor, isVertical);
+                        else
+                            ChartDrawer.DrawPolygon(vh, splitPos, yRadius1, yRadius, startColor, toColor, isVertical);
+                    }
+                    else
+                    {
+                        var p0 = pos1 + dir * m_VisualMap.rangeMinHeight;
+                        var p1 = pos1 + dir * m_VisualMap.rangeMaxHeight;
+                        var splitPos = (p0 + p1) / 2;
+                        var startColor = m_VisualMap.GetColor(m_VisualMap.rangeMin);
+                        var toColor = m_VisualMap.GetColor(m_VisualMap.rangeMax);
+                        var yRadius1 = Vector3.Distance(p0, p1) / 2;
+                        if (m_VisualMap.orient == Orient.Vertical)
+                            ChartDrawer.DrawPolygon(vh, splitPos, xRadius, yRadius1, startColor, toColor, isVertical);
+                        else
+                            ChartDrawer.DrawPolygon(vh, splitPos, yRadius1, yRadius, startColor, toColor, isVertical);
+                    }
+                }
+            }
+            else
+            {
+                for (int i = 1; i < splitNum; i++)
+                {
+                    var splitPos = pos1 + dir * (i - 1 + 0.5f) * splitWid;
+                    var startColor = colors[i - 1];
+                    var toColor = colors[i];
+                    ChartDrawer.DrawPolygon(vh, splitPos, xRadius, yRadius, startColor, toColor, isVertical);
+                }
+            }
+
+            if (m_VisualMap.rangeMin > m_VisualMap.min)
+            {
+                var p0 = pos1 + dir * m_VisualMap.rangeMinHeight;
+                ChartDrawer.DrawPolygon(vh, pos1, p0, m_VisualMap.itemWidth / 2, m_ThemeInfo.visualMapBackgroundColor);
+            }
+            if (m_VisualMap.rangeMax < m_VisualMap.max)
+            {
+                var p1 = pos1 + dir * m_VisualMap.rangeMaxHeight;
+                ChartDrawer.DrawPolygon(vh, p1, pos2, m_VisualMap.itemWidth / 2, m_ThemeInfo.visualMapBackgroundColor);
+            }
+
+            if (m_VisualMap.hoverLink)
+            {
+                if (m_VisualMap.rtSelectedIndex >= 0)
+                {
+                    var p0 = pos1 + dir * m_VisualMap.rangeMinHeight;
+                    var p1 = pos1 + dir * m_VisualMap.rangeMaxHeight;
+
+                    if (m_VisualMap.orient == Orient.Vertical)
+                    {
+                        var p2 = new Vector3(centerPos.x + halfWid, Mathf.Clamp(pointerPos.y + (triangeLen / 2), p0.y, p1.y));
+                        var p3 = new Vector3(centerPos.x + halfWid, Mathf.Clamp(pointerPos.y - (triangeLen / 2), p0.y, p1.y));
+                        var p4 = new Vector3(centerPos.x + halfWid + triangeLen / 2, pointerPos.y);
+                        ChartDrawer.DrawTriangle(vh, p2, p3, p4, colors[m_VisualMap.rtSelectedIndex]);
+                    }
+                    else
+                    {
+                        var p2 = new Vector3(Mathf.Clamp(pointerPos.x + (triangeLen / 2), p0.x, p1.x), centerPos.y + halfWid);
+                        var p3 = new Vector3(Mathf.Clamp(pointerPos.x - (triangeLen / 2), p0.x, p1.x), centerPos.y + halfWid);
+                        var p4 = new Vector3(pointerPos.x, centerPos.y + halfWid + triangeLen / 2);
+                        ChartDrawer.DrawTriangle(vh, p2, p3, p4, colors[m_VisualMap.rtSelectedIndex]);
+                    }
+                }
+                else if (m_Tooltip.show && m_Tooltip.xValues[0] >= 0 && m_Tooltip.yValues[0] >= 0)
+                {
+                    // var p0 = pos1 + dir * m_VisualMap.rangeMinHeight;
+                    // var p1 = pos1 + dir * m_VisualMap.rangeMaxHeight;
+                    // if (m_VisualMap.orient == Orient.Vertical)
+                    // {
+                    //     var p2 = new Vector3(centerPos.x + halfWid, Mathf.Clamp(pointerPos.y + (triangeLen / 2), p0.y, p1.y));
+                    //     var p3 = new Vector3(centerPos.x + halfWid, Mathf.Clamp(pointerPos.y - (triangeLen / 2), p0.y, p1.y));
+                    //     var p4 = new Vector3(centerPos.x + halfWid + triangeLen / 2, pointerPos.y);
+                    //     ChartDrawer.DrawTriangle(vh, p2, p3, p4, colors[m_VisualMap.rtSelectedIndex]);
+                    // }
+                    // else
+                    // {
+                    //     var p2 = new Vector3(Mathf.Clamp(pointerPos.x + (triangeLen / 2), p0.x, p1.x), centerPos.y + halfWid);
+                    //     var p3 = new Vector3(Mathf.Clamp(pointerPos.x - (triangeLen / 2), p0.x, p1.x), centerPos.y + halfWid);
+                    //     var p4 = new Vector3(pointerPos.x, centerPos.y + halfWid + triangeLen / 2);
+                    //     ChartDrawer.DrawTriangle(vh, p2, p3, p4, colors[m_VisualMap.rtSelectedIndex]);
+                    // }
+                }
+            }
+        }
+    }
+}

Scripts/Runtime/Internal/CoordinateChart_DrawHeatmap.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2713cb84109d8491aa61bf37d1fa850e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/CoordinateChart_DrawLine.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e81383a033c064b2cbc5f63387113bb3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/CoordinateChart_DrawScatter.cs

@@ -0,0 +1,73 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts
+{
+    public partial class CoordinateChart
+    {
+        protected void DrawScatterSerie(VertexHelper vh, int colorIndex, Serie serie)
+        {
+            var yAxis = m_YAxises[serie.axisIndex];
+            var xAxis = m_XAxises[serie.axisIndex];
+            var color = serie.symbol.color != Color.clear ? serie.symbol.color : (Color)m_ThemeInfo.GetColor(colorIndex);
+            color.a *= serie.symbol.opacity;
+            int maxCount = serie.maxShow > 0 ?
+                (serie.maxShow > serie.dataCount ? serie.dataCount : serie.maxShow)
+                : serie.dataCount;
+            serie.animation.InitProgress(1, 0, 1);
+            var rate = serie.animation.GetCurrRate();
+            for (int n = serie.minShow; n < maxCount; n++)
+            {
+                var serieData = serie.GetDataList(m_DataZoom)[n];
+                float xValue = serieData.data[0];
+                float yValue = serieData.data[1];
+                float pX = coordinateX + xAxis.axisLine.width;
+                float pY = coordinateY + yAxis.axisLine.width;
+                float xDataHig = (xValue - xAxis.minValue) / (xAxis.maxValue - xAxis.minValue) * coordinateWidth;
+                float yDataHig = (yValue - yAxis.minValue) / (yAxis.maxValue - yAxis.minValue) * coordinateHeight;
+                var pos = new Vector3(pX + xDataHig, pY + yDataHig);
+
+                var datas = serie.data[n].data;
+                float symbolSize = 0;
+                if (serie.highlighted || serieData.highlighted)
+                {
+                    symbolSize = serie.symbol.GetSelectedSize(datas);
+                }
+                else
+                {
+                    symbolSize = serie.symbol.GetSize(datas);
+                }
+                symbolSize *= rate;
+                if (symbolSize > 100) symbolSize = 100;
+                if (serie.type == SerieType.EffectScatter)
+                {
+                    for (int count = 0; count < serie.symbol.animationSize.Count; count++)
+                    {
+                        var nowSize = serie.symbol.animationSize[count];
+                        color.a = (symbolSize - nowSize) / symbolSize;
+                        DrawSymbol(vh, serie.symbol.type, nowSize, 3, pos, color);
+                    }
+                    RefreshChart();
+                }
+                else
+                {
+                    DrawSymbol(vh, serie.symbol.type, symbolSize, 3, pos, color);
+                }
+            }
+            if (!serie.animation.IsFinish())
+            {
+                float duration = serie.animation.duration > 0 ? (float)serie.animation.duration / 1000 : 1;
+                float speed = 1 / duration;
+                serie.animation.CheckProgress(Time.deltaTime * speed);
+                RefreshChart();
+            }
+        }
+    }
+}

Scripts/Runtime/Internal/CoordinateChart_DrawScatter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2f06734940c9e4f92897bb83573394a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/JsonDataSupport.cs

@@ -0,0 +1,45 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using System;
+
+namespace XCharts
+{
+    /// <summary>
+    /// 支持从json格式的字符串中导入数据
+    /// </summary>
+    public class JsonDataSupport : IJsonData, ISerializationCallbackReceiver
+    {
+        [SerializeField] protected string m_JsonData;
+        [SerializeField] protected bool m_DataFromJson;
+
+        /// <summary>
+        /// json格式的字符串数据
+        /// </summary>
+        /// <returns></returns>
+        public string jsonData { get { return m_JsonData; } set { m_JsonData = value; ParseJsonData(value); } }
+
+        public void OnAfterDeserialize()
+        {
+            if (m_DataFromJson)
+            {
+                ParseJsonData(m_JsonData);
+                m_DataFromJson = false;
+            }
+        }
+
+        public void OnBeforeSerialize()
+        {
+        }
+
+        public virtual void ParseJsonData(string json)
+        {
+            throw new Exception("no support yet");
+        }
+    }
+}

Scripts/Runtime/Internal/JsonDataSupport.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 73e326ed8a76f90408bfa9feb1797433
+timeCreated: 1555379601
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/ListPool.cs

@@ -0,0 +1,27 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+
+namespace XCharts
+{
+    internal static class ListPool<T>
+    {
+        private static readonly ObjectPool<List<T>> s_ListPool = new ObjectPool<List<T>>(null, Clear);
+        static void Clear(List<T> l) { l.Clear(); }
+
+        public static List<T> Get()
+        {
+            return s_ListPool.Get();
+        }
+
+        public static void Release(List<T> toRelease)
+        {
+            s_ListPool.Release(toRelease);
+        }
+    }
+}

Scripts/Runtime/Internal/ListPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 359b8b077c5954701a132fe69eb8ba9c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Scripts/Runtime/Internal/ObjectPool.cs

@@ -0,0 +1,56 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace XCharts
+{
+    public class ObjectPool<T> where T : new()
+    {
+        private readonly Stack<T> m_Stack = new Stack<T>();
+        private readonly UnityAction<T> m_ActionOnGet;
+        private readonly UnityAction<T> m_ActionOnRelease;
+
+        public int countAll { get; private set; }
+        public int countActive { get { return countAll - countInactive; } }
+        public int countInactive { get { return m_Stack.Count; } }
+
+        public ObjectPool(UnityAction<T> actionOnGet, UnityAction<T> actionOnRelease)
+        {
+            m_ActionOnGet = actionOnGet;
+            m_ActionOnRelease = actionOnRelease;
+        }
+
+        public T Get()
+        {
+            T element;
+            if (m_Stack.Count == 0)
+            {
+                element = new T();
+                countAll++;
+            }
+            else
+            {
+                element = m_Stack.Pop();
+            }
+            if (m_ActionOnGet != null)
+                m_ActionOnGet(element);
+            return element;
+        }
+
+        public void Release(T element)
+        {
+            if (m_Stack.Count > 0 && ReferenceEquals(m_Stack.Peek(), element))
+                Debug.LogError("Internal error. Trying to destroy object that is already released to pool.");
+            if (m_ActionOnRelease != null)
+                m_ActionOnRelease(element);
+            m_Stack.Push(element);
+        }
+    }
+}