发布v1.5.2版本

support standard c# string formatters in axis labels

.gitignore

@@ -6,15 +6,17 @@
 /Temp
 /Logs
 /UnityPackageManager
+/Packages
+/ProjectSettings/XRSettings.asset
 /Assets/Res
 /Assets/Res.meta
 /Assets/Package
 /Assets/Package.meta
 
-/Assets/XCharts/Demo/demo_test.unity
-/Assets/XCharts/Demo/demo_test.unity.meta
-/Assets/XCharts/Demo/empty.unity
-/Assets/XCharts/Demo/empty.unity.meta
+/Assets/XChartsDemo/demo_test.unity
+/Assets/XChartsDemo/demo_test.unity.meta
+/Assets/XChartsDemo/empty.unity
+/Assets/XChartsDemo/empty.unity.meta
 
 *.sln
 *.csproj

Assets/XCharts/CHANGELOG.md

@@ -1,6 +1,133 @@
 
 # 更新日志
 
+* (2020.06.25) 发布`v1.5.2`版本
+* (2020.06.25) 修复`BarChart`在数值为`0`时还会绘制一小部分柱条的问题
+* (2020.06.24) 修复`PieChart`在设置`clockwise`后绘制异常的问题#65
+* (2020.06.23) 优化`LineChart`在峰谷差异过大时的绘制效果#64
+* (2020.06.18) 修复`SerieLabel`在重新添加数据时可能不显示的问题
+* (2020.06.17) 增加`SerieData`可单独设置`SerieSymbol`#66
+* (2020.06.17) 修复`Check For Update`在`Unity 2018`部分版本报错的问题#63
+* (2020.06.16) 增加`Serie`的`avoidLabelOverlap`参数避免饼图标签堆叠的情况#56
+* (2020.06.15) 修复`SerieLabel`单独控制显示时可能错乱的问题
+* (2020.06.11) 修复`Check warning`不生效的问题
+* (2020.06.11) 修复`PieChart`和`RingChart`在数据占比很小时不显示的问题
+* (2020.06.11) 增加`Tooltip`的`titleFormatter`支持配置占位符`{i}`表示忽略不显示标题
+* (2020.06.07) 增加`Animation`的`customFadeInDelay`等自定义数据项延时和时长回调函数#58
+* (2020.06.07) 优化`PieChart`在数据全为`0`时的显示为等份的效果#59
+* (2020.06.04) 增加`SerieLabel`的`autoOffset`参数设置是否自动判断上下偏移
+* (2020.06.04) 增加`Tooltip`的`alwayShow`参数设置触发后一直显示
+* (2020.06.04) 优化`Tooltip`的`formatter`支持`{.1}`通配符
+* (2020.06.04) 优化`Legend`数量过多时自动换行显示#53
+* (2020.06.03) 发布`v1.5.1`版本
+* (2020.06.02) 增加`Radar`的`ceilRate`，设置最大最小值的取整倍率
+* (2020.06.02) 优化`Tooltip`的`formatter`，支持`{c1:1-1:f1}`格式配置
+* (2020.05.31) 优化`Background`组件的生效条件，需要有单独的父节点（升级前需要自己处理旧的背景节点）
+* (2020.05.30) 优化`PieChart`支持设置`ignoreValue`不显示指定数据
+* (2020.05.30) 修复`RadarChart`为`Circle`时不绘制`SplitArea`的问题
+* (2020.05.30) 优化`RadarChart`在设置`max`为`0`时可自动刷新最大值
+* (2020.05.29) 修复`PieChart`设置`space`时只有一个数据时绘制异常的问题
+* (2020.05.27) 修复调用`UpdateDataName()`接口时不会自动刷新的问题
+* (2020.05.27) 优化`柱状图`的渐变色效果
+* (2020.05.24) 修复`Axis`同时设置`boundaryGap`和`alignWithLabel`时`Tick`绘制异常的问题
+* (2020.05.24) 优化版本更新检测
+* (2020.05.22) 发布`v1.5.0`版本
+* (2020.05.21) 增加`圆角柱图`支持渐变
+* (2020.05.21) 增加`Background`背景组件
+* (2020.05.19) 隐藏`Hierarchy`试图下自动生成的子节点
+* (2020.05.18) 增加`chartName`属性可指定图表的别称，可通过`XChartMgr.Instance.GetChart(chartName)`获取图表
+* (2020.05.16) 增加部分鼠标事件回调
+* (2020.05.15) 优化自带例子，`Demo`改名为`Example`
+* (2020.05.13) 增加`Serie`的`large`和`largeThreshold`参数配置折线图和柱状图的性能模式
+* (2020.05.13) 完善Demo，增加性能演示Demo
+* (2020.05.13) 优化性能，优化大数据绘制，重构代码
+* (2020.05.04) 增加`numericFormatter`参数可配置数值格式化显示，去掉`forceENotation`参数
+* (2020.04.28) 增加`自由锚点`支持，任意对齐方式
+* (2020.04.23) 优化`ScatterChart`的`Tooltip`显示效果
+* (2020.04.23) 增加`Tooltip`的`formatter`对`{.}`、`{c:0}`、`{c1:1}`的支持
+* (2020.04.19) 优化`LineChart`折线图的区域填充渐变效果
+* (2020.04.19) 增加`AxisLabel`的`onZero`参数可将`Label`显示在`0`刻度上
+* (2020.04.19) 增加`Serie`和`AxisLabel`的`showAsPositiveNumber`参数将负数数值显示为正数
+* (2020.04.18) 增加`Covert XY Axis`互换XY轴配置
+* (2020.04.17) 增加`Axis`可通过`inverse`参数设置坐标轴反转
+* (2020.04.16) 修复`Check warning`在`Unity2019.3`上的显示问题
+* (2020.04.16) 修复`PieChart`在设置`Space`参数后动画绘制异常的问题
+* (2020.04.11) 发布`v1.4.0`版本
+* (2020.04.11) 增加`Check warning`检测功能
+* (2020.04.09) 修复`Legend`初始化异常的问题
+* (2020.04.08) 增加`PieChart`通过`ItemStyle`设置边框的支持
+* (2020.03.29) 增加`Axis`的`ceilRate`设置最大最小值的取整倍率
+* (2020.03.29) 增加`BarChart`可通过`itemStyle`的`cornerRadius`设置`圆角柱图`
+* (2020.03.29) 增加`itemStyle`的`cornerRadius`支持圆角矩形
+* (2020.03.24) 优化`Editor`参数编辑，兼容`Unity2019.3`及以上版本
+* (2020.03.24) 增加`Serie`在`inspector`上可进行调整顺序、添加和删除操作
+* (2020.03.23) 修复`Title`的`textStyle`和`subTextStyle`无效的问题
+* (2020.03.22) 增加`BarChart`通过`barType`参数设置`胶囊柱状图`
+* (2020.03.21) 增加`BarChart`和`HeatmapChart`可通过`ignore`参数设置忽略数据的支持
+* (2020.03.21) 增加`ItemStyle`的`tooltipFormatter`参数可单独配置`Serie`的`Tooltip`显示
+* (2020.03.20) 修复`X Axis 1`和`Y Axis 1`配置变更时不会自动刷新的问题
+* (2020.03.20) 增加`AxisTick`的`width`参数可单独设置坐标轴刻度的宽度
+* (2020.03.20) 增加`Serie`的`radarType`参数设置`多圈`和`单圈`雷达图
+* (2020.03.17) 增加`BarChart`可用`ItemStyle`的`backgroundColor`设置数据项背景颜色
+* (2020.03.17) 增加`SerieData`的`ItemStyle`和`Emphasis`可单独配置数据项样式的支持
+* (2020.03.15) 重构`EmptyCricle`类型的`Symbol`边宽取自`ItemStyle`的`borderWidth`参数
+* (2020.03.15) 重构`SerieSymbol`，去掉`color`和`opacity`参数，取自`ItemStyle`
+* (2020.03.14) 发布`v1.3.1`版本
+* (2020.03.14) 修复`LineChart`开启`ingore`时部分数据可能绘制异常的问题
+* (2020.03.13) 修复`LineChart`的`label`偏移显示异常的问题
+* (2020.03.11) 发布`v1.3.0`版本
+* (2020.03.11) 优化`LineChart`的`label`偏移显示
+* (2020.03.11) 优化清空并重新添加数据后的自动刷新问题
+* (2020.03.10) 增加`LineChart`的普通折线图可通过`ignore`参数设置忽略数据的支持
+* (2020.03.09) 增加`BarChart`可通过`ItemStyle`配置边框的支持
+* (2020.03.08) 增加`RingChart`环形图
+* (2020.03.05) 调整`Serie`的`arcShaped`参数重命名为`roundCap`
+* (2020.03.05) 增加运行时和非运行时参数变更自动刷新图表
+* (2020.02.26) 重构`Legend`图例，改变样式，增加自定义图标等设置
+* (2020.02.23) 增加`BaseChart.AnimationFadeOut()`渐出动画，重构动画系统
+* (2020.02.13) 增加`BaseChart.RefreshTooltip()`接口立即重新初始化`Tooltip`组件
+* (2020.02.13) 增加`Tooltip`的`textStyle`参数配置内容文本样式，去掉`fontSize`和`fontStyle`参数
+* (2020.02.13) 增加`TextStyle`的`lineSpacing`参数配置行间距
+* (2020.02.11) 增加`Radar`的`splitLine`参数配置分割线，去掉`lineStyle`参数
+* (2020.02.11) 增加`Tooltip`的`backgroundImage`参数配置背景图
+* (2020.02.11) 增加`Tooltip`的`paddingLeftRight`和`paddingTopBottom`参数配置文字和边框的间距
+* (2020.02.11) 增加`Tooltip`的`lineStyle`参数配置指示线样式
+* (2020.02.11) 增加`Axis`的`splitLine`参数控制分割线，去掉`showSplitLine`和`splitLineType`参数（更新时需要重新设置分割线相关设置）
+* (2020.02.10) 增加`Serie`的`clip`参数控制是否超出坐标系外裁剪（只适用于折线图、柱状图、散点图）
+* (2020.02.08) 增加`SerieSymbol`的`gap`参数控制图形标记的外留白距离
+* (2020.01.26) 增加`TextLimit`组件可以设置`AxisLabel`的文本自适应
+* (2020.01.20) 优化`Tooltip`设置`itemFormatter`时显示系列颜色
+* (2020.01.20) 增加`Radar`雷达图在`inspector`配置`areaStyle`的支持
+* (2020.01.15) 发布`v1.2.0`版本
+* (2020.01.15) 增加`AxisLabel`格式化为整数的支持（`{value:f0}`）
+* (2020.01.15) 增加折线图对数轴`Log`的支持
+* (2020.01.09) 修复当设置`DataZoom`的`minShowNum`时可能异常的问题
+* (2020.01.08) 修复当设置`AxisLine`的`onZero`时刻度显示异常的问题
+* (2020.01.08) 增加`Mask`遮罩遮挡支持
+* (2019.12.21) 增加`Tooltip`的单个数据项和标题的字符串模版格式器
+* (2019.12.21) 增加`DataZoom`的最小显示数据个数`minShowNum`
+* (2019.12.20) 增加`Demo40_Radar.cs`雷达图代码操作`Demo`
+* (2019.12.20) 添加`RadarChart`相关API接口
+* (2019.12.17) 发布`v1.1.0`版本
+* (2019.12.16) 修复`Overlay`模式下不显示`Tooltip`的问题
+* (2019.12.15) 增加`Title`的`TextStyle`支持
+* (2019.12.11) 修复`Legend`都隐藏时`Value轴`还显示数值的问题
+* (2019.12.11) 修复`Series->Data->Size`重置为0后设置无效的问题
+* (2019.12.06) 修复数据过小时`AxisLabel`直接科学计数法显示的问题
+* (2019.12.04) 优化和完善数据更新`UpdateData`接口
+* (2019.12.03) 增加圆环饼图的圆角支持，参数：`serie.arcShaped`
+* (2019.12.03) 增加数据更新动画,参数：`serie.animation.dataChangeEnable`
+* (2019.11.30) 增加`GaugeChart`仪表盘
+* (2019.11.22) 修复`BarChart`清空数据重新赋值后`SerieLabel`显示异常的问题
+* (2019.11.16) 修复`SerieLabel`设置`color`等参数不生效的问题
+* (2019.11.12) 发布`v1.0.5`版本
+* (2019.11.12) 修复`2018.3`以下版本打开项目报错的问题
+* (2019.11.12) 增加`IconStyle`子组件，优化`SerieData`的图标配置
+* (2019.11.11) 修复`Serie`的图标显示在上层遮挡`Label`的问题
+* (2019.11.11) 修复饼图当数据过小时视觉引导线会穿透的的问题
+* (2019.11.09) 修复饼图添加数据时`Label`异常的问题
+* (2019.11.09) 优化结构，分离为`XCharts`和`XChartsDemo`两部分
+* (2019.11.05) 发布`v1.0.4`版本
 * (2019.11.05) 增加`Radar`雷达组件文本样式参数配置支持
 * (2019.11.04) 修复`Unity2018.3`以下版本代码不兼容的问题
 * (2019.11.04) 优化`SerieLabel`过多时引起的性能问题

Assets/XCharts/Demo/Editor/XCharts.Editor.Demo.asmdef

@@ -1,17 +0,0 @@
-{
-    "name": "XCharts.Editor.Demo",
-    "references": [
-        "XCharts.Demo.Runtime",
-        "XCharts.Runtime"
-    ],
-    "optionalUnityReferences": [],
-    "includePlatforms": [
-        "Editor"
-    ],
-    "excludePlatforms": [],
-    "allowUnsafeCode": false,
-    "overrideReferences": false,
-    "precompiledReferences": [],
-    "autoReferenced": true,
-    "defineConstraints": []
-}

Assets/XCharts/Demo/Runtime/Demo13_LineSimple.cs.meta

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

Assets/XCharts/Demo/Runtime/Demo20_BarChart.cs.meta

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

Assets/XCharts/Demo/Runtime/Demo30_PieChart.cs.meta

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

Assets/XCharts/Demo/Runtime/Demo50_Scatter.cs.meta

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

Assets/XCharts/Demo/Runtime/Demo60_Heatmap.cs.meta

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

Assets/XCharts/Demo/Runtime/Demo_Dynamic.cs.meta

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

Assets/XCharts/Demo/Runtime/Demo_LargeData.cs.meta

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

Assets/XCharts/Demo/Runtime/Demo_PieChart.cs.meta

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

Assets/XCharts/Demo/Runtime/Demo_Test.cs

@@ -1,41 +0,0 @@
-/******************************************/
-/*                                        */
-/*     Copyright (c) 2018 monitor1394     */
-/*     https://github.com/monitor1394     */
-/*                                        */
-/******************************************/
-
-using UnityEngine;
-using UnityEngine.UI;
-
-namespace XCharts
-{
-    [DisallowMultipleComponent]
-    [ExecuteInEditMode]
-    public class Demo_Test : MonoBehaviour
-    {
-        LineChart chart;
-        void Awake()
-        {
-            chart = gameObject.GetComponent<LineChart>();
-            if (chart == null)
-            {
-                chart = gameObject.AddComponent<LineChart>();
-            }
-
-            var buttom = transform.parent.gameObject.GetComponentInChildren<Button>();
-            buttom.onClick.AddListener(AddData);
-        }
-
-        void AddData()
-        {
-            chart.series.list[0].ClearData();
-            chart.series.list[1].ClearData();
-            for (int i = 0; i < 5; i++)
-            {
-                chart.AddData(0, Random.Range(20, 100));
-                chart.AddData(1, Random.Range(1, 10));
-            }
-        }
-    }
-}

Assets/XCharts/Demo/Runtime/Demo_Test.cs.meta

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

Assets/XCharts/Documentation/XChartsAPI.md

@@ -6,17 +6,26 @@
 
 ## `BaseChart`
 
----
-
 * `BaseChart.themeInfo`：主题组件`ThemeInfo`。
 * `BaseChart.title`：标题组件`Title`。
 * `BaseChart.legend`：图例组件`Legend`。
 * `BaseChart.tooltip`：提示框组件`Tooltip`。
 * `BaseChart.series`：系列列表`Series`。
+* `BaseChart.chartName`：图表的别称。
 * `BaseChart.chartWidth`：图表的宽。
 * `BaseChart.chartHeight`：图表的高。
-* `BaseChart.customDrawCallback`：自定义绘制回调函数。
-* `BaseChart.SetSize(float width, float height)`：设置图表的大小。
+* `BaseChart.forceOpenRaycastTarget`：强制开启鼠标事件检测。一般不用手动设置，内部会自动判断是否需要检测。
+* `BaseChart.onCustomDraw`：自定义绘制回调。
+* `BaseChart.onPointerClick`：鼠标点击回调。
+* `BaseChart.onPointerDown`：鼠标按下回调。
+* `BaseChart.onPointerUp`：鼠标弹起回调。
+* `BaseChart.onPointerEnter`：鼠标进入图表回调。
+* `BaseChart.onPointerExit`：鼠标退出图表回调。
+* `BaseChart.onBeginDrag`：鼠标开始拖拽回调。
+* `BaseChart.onDrag`：鼠标拖拽回调。
+* `BaseChart.onEndDrag`：鼠标结束拖拽回调。
+* `BaseChart.onScroll`：鼠标滚动回调。
+* `BaseChart.SetSize(float width, float height)`： 设置图表的宽高（在非stretch pivot下才有效，其他情况需要自己调整RectTransform）。
 * `BaseChart.ClearData()`：清除所有数据，系列列表会保留，只是移除列表中系列的数据。
 * `BaseChart.RemoveData()`：清除所有系列和图例数据，系列列表也会被清除。
 * `BaseChart.RemoveData(string serieName)`：清除指定系列名称的数据。
@@ -29,6 +38,10 @@
 * `BaseChart.AddData(int serieIndex, float xValue, float yValue, string dataName = null)`：添加`（x,y）`数据到指定系列中。
 * `BaseChart.UpdateData(string serieName,int dataIndex, float value)`：更新指定系列中的指定索引数据。
 * `BaseChart.UpdateData(int serieIndex,int dataIndex, float value)`：更新指定系列中的指定索引数据。
+* `BaseChart.UpdateData(string serieName, int dataIndex, List<float> multidimensionalData)`：更新指定系列指定索引的数据项的多维数据。
+* `BaseChart.UpdateData(int serieIndex, int dataIndex, List<float> multidimensionalData)`：更新指定系列指定索引的数据项的多维数据。
+* `BaseChart.UpdateData(string serieName, int dataIndex, int dimension, float value)`：更新指定系列指定索引指定维数的数据。维数从0开始。
+* `BaseChart.UpdateData(int serieIndex, int dataIndex, int dimension, float value)`：更新指定系列指定索引指定维数的数据。维数从0开始。
 * `BaseChart.UpdateDataName(string serieName,int dataIndex, string dataName)`：更新指定系列中的指定索引数据名称。
 * `BaseChart.UpdateDataName(int serieIndex, int dataIndex, string dataName)`：更新指定系列中的指定索引数据名称。
 * `BaseChart.SetActive(string serieName, bool active)`：设置指定系列是否显示。
@@ -38,17 +51,21 @@
 * `BaseChart.IsActiveByLegend(string legendName)`：获得指定图例名字的系列是否显示。
 * `BaseChart.RefreshChart()`：在下一帧刷新图表。
 * `BaseChart.RefreshLabel()`：在下一帧刷新文本标签。
+* `BaseChart.RefreshTooltip()`：立即刷新`Tooltip`组件。
 * `BaseChart.UpdateTheme(Theme theme)`：切换图表主题。
-* `BaseChart.AnimationEnable(bool flag)`：启用或关闭起始动画。
-* `BaseChart.AnimationStart()`：开始初始动画。
-* `BaseChart.AnimationStop()`：停止初始化动画。
-* `BaseChart.AnimationReset()`：重置初始动画，重新播放。
+* `BaseChart.AnimationEnable(bool flag)`：启用或关闭动画。
+* `BaseChart.AnimationFadeIn()`：渐入动画。
+* `BaseChart.AnimationFadeOut()`：渐出动画。
+* `BaseChart.AnimationPause()`：暂停动画。
+* `BaseChart.AnimationResume()`：继续动画。
+* `BaseChart.AnimationReset()`：重置动画。
 * `BaseChart.ClickLegendButton(int legendIndex, string legendName, bool show)`：点击图例按钮。
+* `BaseChart.IsInChart(Vector2 local)`：坐标是否在图表范围内。
+* `BaseChart.IsInChart(float x, float y)`：坐标是否在图表范围内。
+* `BaseChart.EnableBackground(bool flag)`：开启背景组件。背景组件在`chart`受上层布局控制时无法开启。
 
 ## `CoordinateChart`
 
----
-
 * `CoordinateChart.grid`：网格组件 `Grid`。
 * `CoordinateChart.xAxises`：左右两个 `X` 轴组件 `XAxis`。
 * `CoordinateChart.yAxises`：左右两个 `Y` 轴组件 `YAxis`。
@@ -67,48 +84,59 @@
 * `CoordinateChart.IsValue()`：是否是纯数值坐标。
 * `CoordinateChart.RefreshDataZoom()`：在下一帧刷新DataZoom组件。
 * `CoordinateChart.RefreshAxisMinMaxValue()`：立即刷新数值坐标轴的最大最小值（更新坐标轴标签并触发重绘）。
+* `CoordinateChart.IsInCooridate(Vector2 local)`：坐标是否在坐标轴内。
+* `CoordinateChart.IsInCooridate(Vector3 local)`：坐标是否在坐标轴内。
+* `CoordinateChart.IsInCooridate(float x, float y)`：坐标是否在坐标轴内。
+* `CoordinateChart.IsInCooridate(Vector2 local)`：坐标是否在坐标轴内。
+* `CoordinateChart.ClampInCoordinate(Vector3 pos)`：将坐标限制在坐标系内。
+* `CoordinateChart.CovertXYAxis(int index)`：转换X轴和Y轴的配置。
+* `CoordinateChart.UpdateCoordinate()`：更新坐标系原点和宽高。一般内部会自动更新，也可强制更新。
+* `CoordinateChart.SetMaxCache(int maxCache)`：设置可缓存的最大数据量。当数据量超过该值时，会自动删除第一个值再加入最新值。
 
 ## `LineChart`
 
----
-
 * 继承 `BaseChart`。
 * 继承自 `CoordinateChart`。
 
 ## `BarChart`
 
----
-
 * 继承自 `BaseChart`。
 * 继承自 `CoordinateChart`。
 
 ## `PieChart`
 
----
-
 * 继承自 `BaseChart`。
 
 ## `RadarChart`
 
----
-
 * 继承自 `BaseChart`。
-* `radars`：雷达组件列表 `Radar`。
+* `RadarChart.radars`：雷达坐标系组件列表 `Radar`。
+* `RadarChart.RemoveRadar()`：移除所有雷达坐标系组件。
+* `RadarChart.AddRadar(Radar radar)`：添加雷达坐标系组件。
+* `RadarChart.AddRadar(Radar.Shape shape, Vector2 center, float radius, int splitNumber = 5,float lineWidth = 0.6f, bool showIndicator = true, bool showSplitArea = true)`：添加雷达坐标系组件。
+* `RadarChart.AddIndicator(int radarIndex, string name, float min, float max)`：添加指示器。
+* `RadarChart.UpdateIndicator(int radarIndex, int indicatorIndex, string name, float min, float max)`：更新指示器。
+* `RadarChart.GetRadar(int radarIndex)`：获得指定索引的雷达坐标系组件。
+* `RadarChart.GetIndicator(int radarIndex, int indicatorIndex)`：获得指定雷达坐标系组件指定索引的指示器。
 
 ## `ScatterChart`
 
----
-
 * 继承自 `BaseChart`。
 * 继承自 `CoordinateChart`。
 
 ## `HeatmapChart`
 
----
-
 * 继承自 `BaseChart`。
 * 继承自 `CoordinateChart`。
 
+## `RingChart`
+
+* 继承自 `BaseChart`。
+* `RingChart.UpdateMax(int serieIndex, int dataIndex, float value)`：更新指定系列执行数据项的最大值。
+* `RingChart.UpdateMax(int serieIndex, float value)`：更新指定系列的所有数据项的最大值。
+* `RingChart.UpdateMax(float value)`：更新第一个系列第一个数据项的最大值。
+
 [返回首页](https://github.com/monitor1394/unity-ugui-XCharts)  
 [XCharts配置项手册](XCharts配置项手册.md)  
 [XCharts问答](XCharts问答.md)
+

Assets/XCharts/Documentation/XCharts配置项手册.md

@@ -7,11 +7,20 @@
 主组件：
 
 * [Axis 坐标轴](#XAxis)  
+* [Background 背景图](#Background)  
 * [DataZoom 区域缩放](#DataZoom)  
 * [Grid 网格](#Grid)  
 * [Legend 图例](#Legend)  
 * [Radar 雷达](#Radar)  
 * [Series 系列](#Series)  
+* [Serie-Line 折线图](#Serie-Line)  
+* [Serie-Bar 柱形图](#Serie-Bar)  
+* [Serie-Pie 饼图](#Serie-Pie)  
+* [Serie-Radar 雷达图](#Serie-Radar)  
+* [Serie-Scatter 散点图](#Serie-Scatter)  
+* [Serie-Heatmap 热力图](#Serie-Heatmap)  
+* [Serie-Gauge 仪表盘](#Serie-Gauge)  
+* [Serie-Ring 环形图](#Serie-Ring)  
 * [Settings 设置](#Settings)
 * [Theme 主题](#Theme)  
 * [Tooltip 提示框](#Tooltip)  
@@ -24,10 +33,11 @@
 * [AxisLabel 坐标轴刻度标签](#AxisLabel)  
 * [AxisLine 坐标轴轴线](#AxisLine)  
 * [AxisName 坐标轴名称](#AxisName)  
+* [AxisSplitLine 坐标轴分割线条](#AxisSplitLine)  
 * [AxisSplitArea 坐标轴分割区域](#AxisSplitArea)  
 * [AxisTick 坐标轴刻度](#AxisTick)  
 * [Emphasis 高亮样式](#Emphasis)  
-* [ItemStyle 图形样式](#ItemStyle)  
+* [ItemStyle 数据项样式](#ItemStyle)  
 * [LineArrow 折线图箭头](#LineArrow)  
 * [LineStyle 折线图样式](#LineStyle)  
 * [Location 位置](#Location)  
@@ -35,11 +45,11 @@
 * [SerieData 数据项](#SerieData)  
 * [SerieLabel 图形上的文本标签](#SerieLabel)  
 * [SerieSymbol 图形标记](#SerieSymbol)  
+* [TextLimit 文本自适应](#TextLimit)  
 * [TextStyle 文本样式](#TextStyle)  
 
 ## `Theme`
 
----
 主题组件。主题用来配置图表的全局配色等其他参数。
 
 相关参数：
@@ -72,22 +82,31 @@
 
 ## `Title`
 
----
 标题组件，包含主标题和副标题。
 
 相关参数：
 
 * `show`：是否显示标题组件。
 * `text`：主标题文本，支持使用 `\n` 换行。
-* `textFontSize`：主标题文字的字体大小。
+* `textStyle`：主标题文本样式 [TextStyle](#TextStyle)。
 * `subText`：副标题文本，支持使用 `\n` 换行。
-* `subTextFontSize`：副标题文字的字体大小。
+* `subTextStyle`：副标题文本样式 [TextStyle](#TextStyle)。
 * `itemGap`：主副标题之间的间距。
 * `location`：标题显示位置 [Location](#Location)。
 
+## `TitleStyle`
+
+标题样式。
+
+* `show`：是否显示标题组件。
+* `rotate`：旋转。
+* `offset`：偏移。
+* `color`：颜色。
+* `fontSize`：字体大小。
+* `fontStyle`：字体风格。
+
 ## `Legend`
 
----
 图例组件。图例组件展现了不同系列的标记，颜色和名字。可以通过点击图例控制哪些系列不显示。
 
 相关参数：
@@ -101,12 +120,14 @@
   * `Horizonal`：水平。
   * `Vertical`：垂直。
 * `location`：图例的显示位置 [Location](#Location)。
-* `itemWidth`：每个图例项的宽度。
-* `itemHeight`：每个图例项的高度。
+* `itemWidth`：图例标记的图形宽度。
+* `itemHeight`：图例标记的图形高度。
 * `itemGap`：图例每项之间的间隔。横向布局时为水平间隔，纵向布局时为纵向间隔。
-* `itemFontSize`：图例项的字体大小。
+* `itemAutoColor`：图例标记的图形是否自动匹配颜色。
 * `formatter`：图例内容字符串模版格式器。支持用 `\n` 换行。模板变量为图例名称 `{name}`
 * `data`：图例的数据数组。数组项通常为一个字符串，每一项代表一个系列的 `name`（如果是饼图，也可以是饼图单个数据的 `name`）。如果 `data` 没有被指定，会自动从当前系列中获取。指定 `data` 时里面的数据项和 `serie` 匹配时才会生效。
+* `icons`：自定义的图例标记图形。
+* `textStyle`：图例的内容文本样式 [TextStyle](#TextStyle)。
 
 相关接口：
 
@@ -119,8 +140,6 @@
 
 ## `Radar`
 
----
-
 * `shape`：雷达图绘制类型。
   * `Polygon`：多边形。
   * `Circle`：圆形。
@@ -129,7 +148,9 @@
   * `Between`：显示在顶点之间。
 * `radius`：雷达图的半径。
 * `center`：雷达图的中心点。数组的第一项是横坐标，第二项是纵坐标。当值为0-1之间时表示百分比，设置成百分比时第一项是相对于容器宽度，第二项是相对于容器高度。
-* `lineStyle`：线条样式 [LineStyle](#LineStyle)。
+* `ceilRate`：最大最小值向上取整的倍率。默认为0时自动计算。
+* `splitNumber`：分割段数。默认为 `5`。
+* `splitLine`：分割线条 [AxisSplitLine](#AxisSplitLine)。
 * `splitArea`：分割区域 [AxisSplitArea](#AxisSplitArea)。
 * `indicator`：是否显示指示器。
 * `indicatorGap`：指示器和雷达的间距。
@@ -137,27 +158,31 @@
 
 ## `Radar.Indicator`
 
----
-
 * `name`：指示器名称。
 * `max`：指示器的最大值，默认为 0 无限制。
 * `min`：指示器的最小值，默认为 0 无限制。
 * `textStyle`：文本样式 [TextStyle](#TextStyle)。
 
-## `TextStyle`
+## `TextLimit`
 
----
+* `enable`：是否启用文本自适应。默认为`true`。
+* `maxWidth`：设定最大宽度。默认为`0`表示自动获取，否则表示自定义。当文本的宽度大于该值进行裁剪。
+* `gap`：两边留白像素距离。默认为`10`。
+* `suffix`： 长度超出被裁剪后附加的后缀。默认为`...`。
+
+## `TextStyle`
 
 * `rotate`：旋转。
 * `offset`：偏移。
 * `color`：颜色。
+* `backgroundColor`：背景颜色。
+* `font`：字体。
 * `fontSize`：字体大小。
 * `fontStyle`：字体风格。
+* `lineSpacing`：行间距。
 
 ## `Tooltip`
 
----
-
 提示框组件。
 
 相关参数：
@@ -167,24 +192,37 @@
   * `Line`：线性指示器。
   * `Shadow`：阴影指示器。
   * `None`：无指示器。
-  * `Corss`：十字准星指示器。坐标轴显示Label和交叉线。
-* `formatter`：提示框内容字符串模版格式器。支持用 `\n` 或 `<br/>` 换行。其中变量 `{a}`, `{b}`, `{c}`, `{d}` 在不同图表类型下代表数据含义为：
-  * 折线（区域）图、柱状（条形）图、K线图 : `{a}`（系列名称），`{b}`（类目值），`{c}`（数值）, `{d}`（无）。
-  * 散点图（气泡）图 : `{a}`（系列名称），`{b}`（数据名称），`{c}`（数值数组）, `{d}`（无）。
-  * 地图 : `{a}`（系列名称），`{b}`（区域名称），`{c}`（合并数值）, `{d}`（无）。
-  * 饼图、仪表盘、漏斗图: `{a}`（系列名称），`{b}`（数据项名称），`{c}`（数值）, `{d}`（百分比）。
+  * `Corss`：十字准星指示器。坐标轴显示`Label`和交叉线。
+* `formatter`：提示框内容字符串模版格式器。支持用 `\n` 换行。当`formatter`不为空时，优先使用`formatter`，否则使用`itemFormatter`。
+  * 模板变量有`{.}`、`{a}`、`{b}`、`{c}`、`{d}`。
+  * `{.}`为当前所指示或`index`为`0`的`serie`的对应颜色的圆点。
+  * `{a}`为当前所指示或`index`为`0`的`serie`的系列名`name`。
+  * `{b}`为当前所指示或`index`为`0`的`serie`的数据项`serieData`的`name`，或者类目值（如折线图的`X`轴）。
+  * `{c}`为当前所指示或`index`为`0`的`serie`的`y`维（`dimesion`为`1`）的数值。
+  * `{d}`为当前所指示或`index`为`0`的`serie`的`y`维（`dimesion`为`1`）百分比值，注意不带`%`号。
+  * `{.1}`表示指定`index`为`1`的`serie`对应颜色的圆点。
+  * `{a1}`、`{b1}`、`{c1}`中的`1`表示指定`index`为`1`的`serie`。
+  * `{c1:2}`表示索引为`1`的`serie`的当前指示数据项的第`3`个数据（一个数据项有多个数据，index为`2`表示第`3`个数据）。
+  * `{c1:2-2}`表示索引为`1`的`serie`的第`3`个数据项的第`3`个数据（也就是要指定第几个数据项时必须要指定第几个数据）。
+  * `{d1:2:f2}`表示单独指定了数值的格式化字符串为`f2`（不指定时用`numericFormatter`）。
+  * 示例：`"{a}:{c}"`、`"{a1}:{c1:f1}"`、`"{a1}:{c1:1f1}"`
+* `titleFormatter`：提示框标题内容的字符串模版格式器。支持用 `\n` 换行。仅当`itemFormatter`生效时才有效。可以单独设置占位符`{i}`表示忽略不显示标题内容。
+* `itemFormatter`：提示框单个`serie`或数据项内容的字符串模版格式器。支持用 `\n`  换行。当`formatter`不为空时，优先使用`formatter`，否则使用`itemFormatter`。
+* `numericFormatter`：标准数字格式字符串。用于将数值格式化显示为字符串。使用`Axx`的形式：`A`是格式说明符的单字符，支持`C`货币、`D`十进制、`E`指数、`F`顶点数、`G`常规、`N`数字、`P`百分比、`R`往返过程、`X`十六进制等九种。`xx`是精度说明，从`0`-`99`。
 * `fixedWidth`：固定宽度。当同时设置 `fixedWidth` 和 `minWidth` 时，`fixedWidth` 比 `minWidth` 优先级高。
 * `fixedHeight`：固定高度。当同时设置 `fixedHeight` 和 `minHeight` 时，`fixedHeight` 比 `minHeight` 优先级高。
 * `minWidth`：最小宽度。当同时设置 `fixedWidth` 和 `minWidth` 时，`fixedWidth` 比 `minWidth` 优先级高。
 * `minHeight`：最小高度。当同时设置 f`ixedHeight` 和 `minHeight` 时，`fixedHeight` 比 `minHeight` 优先级高。
-* `fontSize`：文字的字体大小。
-* `fontStyle`：文字的字体风格。
-* `forceENotation`：是否强制使用科学计数法格式化显示数值。默认为false，当小数精度大于3时才采用科学计数法。
+* `paddingLeftRight`：文字和边框的左右边距。
+* `paddingTopBottom`：文字和边框的上下边距。
+* `backgroundImage`：提示框的背景图。
+* `ignoreDataDefaultContent`：被忽略数据的默认显示字符信息。
+* `alwayShow`：是否触发后一直显示。
+* `lineStyle`：指示器线条样式 [LineStyle](#LineStyle)。
+* `textStyle`：显示内容文本样式 [TextStyle](#TextStyle)。
 
 ## `DataZoom`
 
----
-
 区域缩放组件。用于区域缩放，从而能自由关注细节的数据信息，或者概览数据整体，或者去除离群点的影响。  
 目前只支持控制 `X` 轴。
 
@@ -214,15 +252,14 @@
 * `scrollSensitivity`：缩放区域组件的敏感度。值越高每次缩放所代表的数据越多。
 * `fontSize`：字体大小。
 * `fontStyle`：字体样式。
+* `minShowNum`：最小显示数据个数。当DataZoom放大到最大时，最小显示的数据个数。
 
 ## `VisualMap`
 
----
-
 视觉映射组件。用于进行『视觉编码』，也就是将数据映射到视觉元素（视觉通道）。
 
 * `enable`：开启或关闭视觉映射功能。
-* `show`：是否显示组件。如果设置为 false，不会显示，但是数据映射的功能还存在。
+* `show`：是否显示组件。如果设置为 `false`，不会显示，但是数据映射的功能还存在。
 * `type`：组件类型。支持以下类型：
   * `Continuous`：连续型。
   * ~~`Piecewise`：分段型。~~
@@ -249,9 +286,7 @@
 
 ## `Grid`
 
----
-
-网格组件。直角坐标系内绘图网格，单个 `grid` 内最多可以放置上下两个 `X` 轴，左右两个 `Y` 轴。可以在网格上绘制折线图，柱状图，散点图（气泡图）。目前最多只能存在一个 `grid` 组件。
+网格组件。直角坐标系内绘图网格，单个 `grid` 内最多可以放置上下两个 `X` 轴，左右两个 `Y` 轴。可以在网格上绘制折线图，柱状图，散点图。目前最多只能存在一个 `grid` 组件。
 
 相关参数：
 
@@ -262,41 +297,55 @@
 * `bottom`：组件离容器底部的距离。
 * `backgroundColor`：背景颜色。
 
-## `XAxis`
+## `GaugeAxis`
 
----
+仪表盘坐标轴。
+
+* `axisLine`：坐标轴轴线样式。
+* `splitLine`：坐标轴分割线样式。
+* `axisTick`：坐标轴刻度样式。
+* `axisLabel`：坐标轴刻度标签样式。
+* `axisLabelText`：坐标轴刻度标签自定义内容。当内容为空时，`axisLabel`根据刻度自动显示内容，否则取自该列表定义的内容。
+
+## `GaugePointer`
+
+仪表盘指针。
+
+* `width`：指针宽度。
+* `length`：指针长度。当为`0-1`的浮点数时表示相对仪表盘半径的百分比。
+
+## `XAxis`
 
 直角坐标系 `grid` 中的 `X` 轴。单个 `grid` 组件最多只能放上下两个 `X` 轴。两个 `X` 轴存储在 `xAxises` 中。
 
 相关参数：
 
 * `show`：是否显示 `X` 轴。默认 `xAxises[0]` 为 `true`，`xAxises[1]` 为 `false`。
-* `type`：坐标轴类型。默认为 `Category`。有以下两种类型：
+* `type`：坐标轴类型。默认为 `Category`。支持以下类型：
   * `Value`：数值轴，用于连续数据。
   * `Category`：类目轴，适用于离散的类目数据，为该类型时必须通过 `data` 设置类目数据。
+  * `Log`：对数轴，适用于对数数据。
+* `logBaseE`：对数轴是否以自然数 `e` 为底数，为 `true` 时 `logBase` 失效，只在对数轴（`type:'Log'`）中有效。
+* `logBase`：对数轴的底数，只在对数轴（`type:'Log'`）中有效。
 * `minMaxType`：坐标轴刻度最大最小值显示类型。默认为 `Default`。有以下三种类型：
   * `Default`：0-最大值。
   * `MinMax`：最小值-最大值。
   * `Custom`：自定义的最小值-最大值。
 * `min`：设定的坐标轴刻度最小值，当 `minMaxType` 为 `Custom` 时有效。
 * `max`：设定的坐标轴刻度最大值，当 `minMaxType` 为 `Custom` 时有效。
+* `ceilRate`：最大最小值向上取整的倍率。默认为0时自动计算。
 * `splitNumber`：坐标轴的分割段数。默认为 `5`。当 `splitNumber` 设为 `0` 时，表示绘制所有的类目数据。
-* `interval`：强制设置坐标轴分割间隔。无法在类目轴中使用。设置改值时 `splitNumber` 无效。
-* `splitLineType`：分割线类型。默认为 `Dashed`。有以下五种类型：
-  * `None`：不显示分割线。
-  * `Solid`：实线。
-  * `Dashed`：虚线。
-  * `Dotted`：点线。
-  * `DashDot`：点划线。
-  * `DashDotDot`：双点划线。
+* `interval`：强制设置坐标轴分割间隔。无法在类目轴中使用。设置该值时 `splitNumber` 无效。
 * `boundaryGap`：坐标轴两边是否留白。默认为 `true`。
-* `maxCache`：类目数据中可缓存的最大数据量。默认为0没有限制，大于0时超过指定值会移除旧数据再插入新数据。
+* `maxCache`：类目数据中可缓存的最大数据量。默认为`0`没有限制，大于0时超过指定值会移除旧数据再插入新数据。
+* `inverse`：是否反向坐标轴。只在数值轴`Value`中有效。
 * `data`：类目数据，在类目轴（`type: 'Category'`）中有效。
 * `axisLine`：坐标轴轴线相关配置 [AxisLine](#AxisLine)。
 * `axisName`：坐标轴名称相关配置 [AxisName](#AxisName)。
 * `axisTick`：坐标轴刻度相关配置 [AxisTick](#AxisTick)。
 * `axisLabel`：坐标轴刻度标签 [AxisLabel](#AxisLabel)。
-* `splitArea`：坐标轴轴线坐标轴分割区域 [SplitArea](#SplitArea)。
+* `splitLine`：坐标轴轴线坐标轴分割线 [AxisSplitLine](#SplitLine)。
+* `splitArea`：坐标轴轴线坐标轴分割区域 [AxisSplitArea](#AxisSplitArea)。
 
 相关接口：
 
@@ -305,9 +354,23 @@
 * `IsValue()`：是否为数值轴。
 * `AddData(string category, int maxDataNumber)`：添加一个类目到类目数据列表。
 
-## `YAxis`
+## `Background`
 
----
+背景组件。
+由于框架的局限性，背景组件使用有以下两个限制：
+1：`chart`的父节点不能有布局控制类组件。
+2：`chart`的父节点只能有当前`chart`一个子节点。
+背景组件的开启需要通过接口来开启：`BaseChart.EnableBackground(bool flag)`。
+
+相关参数：
+
+* `show`：是否显示启用背景组件。但能否激活背景组件还要受其他条件限制。
+* `image`：背景图。
+* `imageType`：背景图填充类型。
+* `imageColor`背景图颜色。默认`white`。
+* `hideThemeBackgroundColor`：当背景组件启用时，是否隐藏主题中设置的背景色。
+
+## `YAxis`
 
 直角坐标系 `grid` 中的 `Y` 轴。单个 `grid` 组件最多只能放左右两个 `Y` 轴。两个 `Y` 轴存储在 `yAxises` 中。
 
@@ -349,8 +412,6 @@
 
 ## `Series`
 
----
-
 系列列表。每个系列通过 type 决定自己的图表类型。
 
 相关参数：
@@ -407,18 +468,214 @@
 * `pieSpace`：饼图项间的空隙留白。
 * `pieCenter`：饼图的中心点。
 * `pieRadius`：饼图的半径。`radius[0]` 表示内径，`radius[1]` 表示外径。
+* `roundCap`：启用圆弧效果。
 * `label`：图形上的文本标签 [SerieLabel](#SerieLabel)，可用于说明图形的一些数据信息，比如值，名称等。
 * `emphasis`：高亮样式 [Emphasis](#Emphasis)。
 * `animation`：起始动画 [SerieAnimation](#SerieAnimation)。
 * `lineArrow`：折线图的箭头 [LineArrow](#LineArrow)。
 * `data`：系列中的数据项 [SerieData](#SerieData) 数组，可以设置`1`到`n`维数据。
 
-相关接口：
+## `Serie-Line`
+
+折线图系列。
+
+* `show`：系列是否显示在图表上。
+* `type`：`Line`。
+* `name`：系列名称。用于 `tooltip` 的显示，`legend` 的图例筛选。
+* `stack`：数据堆叠。同个类目轴上系列配置相同的 `stack` 值后，后一个系列的值会在前一个系列的值上相加。
+* `axisIndex`：使用的坐标轴轴的 `index`，在单个图表实例中存在多个坐标轴轴的时候有用。
+* `minShow`：系列显示数据的最小索引。
+* `maxShow`：系列显示数据的最大索引。
+* `maxCache`：系列中可缓存的最大数据量。默认为`0`没有限制，大于0时超过指定值会移除旧数据再插入新数据。
+* `sampleDist`采样的最小水平像素距离，默认为`0`时不采样。当两个数据点间的水平像素距离小于该值时，开启采样，保证两点间的水平像素距离不小于该值。
+* `sampleType`：采样类型。当`sampleDist`大于`0`时有效。支持以下五种采样类型：
+  * `Peak`：取峰值。当过滤点的平均值大于等于`sampleAverage`时，取最大值；反之取最小值。
+  * `Average`：取过滤点的平均值。
+  * `Max`：取过滤点的最大值。
+  * `Min`：取过滤点的最小值。
+  * `Sum`：取过滤点之和。
+* `sampleAverage`：设定的采样平均值。当 `sampleType` 为 `Peak` 时，用于和过滤数据的平均值做对比是取最大值还是最小值。默认为`0`时会实时计算所有数据的平均值。
+* `clip`：是否裁剪超出坐标系部分的图形。
+* `ignore`：是否开启忽略数据。当为 `true` 时，数据值为 `ignoreValue` 时不进行绘制。
+* `ignoreValue`：忽略数据的默认值。默认值默认为0，当 `ignore` 为 `true` 才有效。
+* `showAsPositiveNumber`：将负数数值显示为正数。一般和`AxisLabel`的`showAsPositiveNumber`配合使用。仅在折线图和柱状图中有效。
+* `large`：是否开启大数据量优化，在数据图形特别多而出现卡顿时候可以开启。开启后配合 largeThreshold 在数据量大于指定阈值的时候对绘制进行优化。缺点：优化后不能自定义设置单个数据项的样式，不能显示Label，折线图不绘制Symbol。
+* `largeThreshold`：开启大数量优化的阈值。只有当开启了large并且数据量大于该阀值时才进入性能模式。
+* `areaStyle`：区域填充样式 [AreaStyle](#AreaStyle)。
+* `symbol`：标记的图形 [SerieSymbol](#SerieSymbol)。
+* `lineType`：折线图样式类型。支持以下十种类型：
+  * `Normal`：普通折线图。
+  * `Smooth`：平滑曲线。
+  * `SmoothDash`：平滑虚线。
+  * `StepStart`：阶梯线图：当前点。
+  * `StepMiddle`：阶梯线图：当前点和下一个点的中间。
+  * `StepEnd`：阶梯线图：下一个拐点。
+  * `Dash`：虚线。
+  * `Dot`：点线。
+  * `DashDot`：点划线。
+  * `DashDotDot`：双点划线。
+* `lineStyle`：线条样式 [LineStyle](#LineStyle)。
+* `label`：图形上的文本标签 [SerieLabel](#SerieLabel)，可用于说明图形的一些数据信息，比如值，名称等。
+* `emphasis`：高亮样式 [Emphasis](#Emphasis)。
+* `animation`：起始动画 [SerieAnimation](#SerieAnimation)。
+* `lineArrow`：折线图的箭头 [LineArrow](#LineArrow)。
+* `data`：系列中的数据项 [SerieData](#SerieData) 数组，可以设置`1`到`n`维数据。
+
+## `Serie-Bar`
+
+折线图系列。
+
+* `show`：系列是否显示在图表上。
+* `type`：`Bar`。
+* `name`：系列名称。用于 `tooltip` 的显示，`legend` 的图例筛选。
+* `stack`：数据堆叠。同个类目轴上系列配置相同的 `stack` 值后，后一个系列的值会在前一个系列的值上相加。
+* `axisIndex`：使用的坐标轴轴的 `index`，在单个图表实例中存在多个坐标轴轴的时候有用。
+* `minShow`：系列显示数据的最小索引。
+* `maxShow`：系列显示数据的最大索引。
+* `maxCache`：系列中可缓存的最大数据量。默认为`0`没有限制，大于0时超过指定值会移除旧数据再插入新数据。
+* `barType`：柱状图类型。以下几种类型：
+  * `Normal`：普通柱状图。
+  * `Zebra`：斑马柱状图。
+  * `Capsule`：胶囊柱状图。
+* `barPercentStack`：是否百分比堆叠柱状图，相同 `stack` 的 `serie` 只要有一个 `barPercentStack` 为 `true`，则就显示成百分比堆叠柱状图。
+* `barWidth`：柱条的宽度，不设时自适应。支持设置成相对于类目宽度的百分比。
+* `barGap`：不同系列的柱间距离。为百分比（如 `'0.3f'`，表示柱子宽度的 `30%`）。如果想要两个系列的柱子重叠，可以设置 `barGap` 为 `'-1f'`。这在用柱子做背景的时候有用。在同一坐标系上，此属性会被多个 `'bar'` 系列共享。此属性应设置于此坐标系中最后一个 `'bar'` 系列上才会生效，并且是对此坐标系中所有 `'bar'` 系列生效。
+* `barCategoryGap`：同一系列的柱间距离，默认为类目间距的20%，可设固定值。在同一坐标系上，此属性会被多个 `'bar'` 系列共享。此属性应设置于此坐标系中最后一个 `'bar'` 系列上才会生效，并且是对此坐标系中所有 `'bar'` 系列生效。
+* `barZebraWidth`：斑马线的粗细。`barType` 为 `Zebra` 时有效。
+* `barZebraGap`：斑马线的间距。`barType` 为 `Zebra` 时有效。
+* `clip`：是否裁剪超出坐标系部分的图形。
+* `ignore`：是否开启忽略数据。当为 `true` 时，数据值为 `ignoreValue` 时不进行绘制。
+* `ignoreValue`：忽略数据的默认值。默认值默认为0，当 `ignore` 为 `true` 才有效。
+* `showAsPositiveNumber`：将负数数值显示为正数。一般和`AxisLabel`的`showAsPositiveNumber`配合使用。仅在折线图和柱状图中有效。
+* `large`：是否开启大数据量优化，在数据图形特别多而出现卡顿时候可以开启。开启后配合 largeThreshold 在数据量大于指定阈值的时候对绘制进行优化。缺点：优化后不能自定义设置单个数据项的样式，不能显示Label，折线图不绘制Symbol。
+* `largeThreshold`：开启大数量优化的阈值。只有当开启了large并且数据量大于该阀值时才进入性能模式。
+* `symbol`：标记的图形 [SerieSymbol](#SerieSymbol)。
+* `itemStyle`：柱条样式 [ItemStyle](#ItemStyle)。
+* `areaStyle`：区域填充样式 [AreaStyle](#AreaStyle)。
+* `label`：图形上的文本标签 [SerieLabel](#SerieLabel)，可用于说明图形的一些数据信息，比如值，名称等。
+* `emphasis`：高亮样式 [Emphasis](#Emphasis)。
+* `animation`：起始动画 [SerieAnimation](#SerieAnimation)。
+* `data`：系列中的数据项 [SerieData](#SerieData) 数组，可以设置`1`到`n`维数据。
+
+## `Serie-Pie`
+
+饼图系列。
+
+* `show`：系列是否显示在图表上。
+* `type`：`Pie`。
+* `name`：系列名称。用于 `tooltip` 的显示，`legend` 的图例筛选。
+* `pieRoseType`：南丁格尔玫瑰图类型，支持以下类型：
+  * `None`：不展示成南丁格尔玫瑰图。
+  * `Radius`：扇区圆心角展现数据的百分比，半径展现数据的大小。
+  * `Area`：所有扇区圆心角相同，仅通过半径展现数据大小。
+* `space`：扇区间隙。
+* `center`：中心点坐标。当值为`0-1`的浮点数时表示百分比。
+* `radius`：半径。`radius[0]`为内径，`radius[1]`为外径。当内径大于0时即为圆环图。
+* `roundCap`：是否启用圆弧效果。
+* `ignore`：是否开启忽略数据。当为 `true` 时，数据值为 `ignoreValue` 时不进行绘制，对应的`Label`和`Legend`也不会显示。
+* `ignoreValue`：忽略数据的默认值。默认值默认为0，当 `ignore` 为 `true` 才有效。
+* `avoidLabelOverlap`：在饼图且标签外部显示的情况下，是否启用防止标签重叠策略，默认关闭，在标签拥挤重叠的情况下会挪动各个标签的位置，防止标签间的重叠。
+* `label`：图形上的文本标签 [SerieLabel](#SerieLabel)，可用于说明图形的一些数据信息，比如值，名称等。
+* `emphasis`：高亮样式 [Emphasis](#Emphasis)。
+* `animation`：起始动画 [SerieAnimation](#SerieAnimation)。
+* `data`：系列中的数据项 [SerieData](#SerieData) 数组，可以设置`1`到`n`维数据。
+
+## `Serie-Radar`
+
+雷达图系列。
+
+* `show`：系列是否显示在图表上。
+* `type`：`Radar`。
+* `name`：系列名称。用于 `tooltip` 的显示，`legend` 的图例筛选。
+* `radarType`：雷达图类型`RadarType`，支持以下类型：
+  * `Multiple`：多圈雷达图。此时可一个雷达里绘制多个圈，一个`serieData`就可组成一个圈（多维数据）。
+  * `Single`：单圈雷达图。此时一个雷达只能绘制一个圈，多个`serieData`组成一个圈，数据取自`data[1]`。
+* `radarIndex`：雷达图所使用的 `radar` 组件的 `index`。
+* `symbol`：标记的图形 [SerieSymbol](#SerieSymbol)。
+* `lineStyle`：线条样式 [LineStyle](#LineStyle)。
+* `itemStyle`：标记样式 [ItemStyle](#ItemStyle)。
+* `areaStyle`：区域填充样式 [AreaStyle](#AreaStyle)。
+* `label`：图形上的文本标签 [SerieLabel](#SerieLabel)，可用于说明图形的一些数据信息，比如值，名称等。
+* `animation`：起始动画 [SerieAnimation](#SerieAnimation)。
+* `data`：系列中的数据项 [SerieData](#SerieData) 数组，可以设置`1`到`n`维数据。
+
+## `Serie-Scatter`
+
+散点图系列。
+
+* `show`：系列是否显示在图表上。
+* `type`：`Scatter`。
+* `name`：系列名称。用于 `tooltip` 的显示，`legend` 的图例筛选。
+* `clip`：是否裁剪超出坐标系部分的图形。
+* `symbol`：标记的图形 [SerieSymbol](#SerieSymbol)。
+* `label`：图形上的文本标签 [SerieLabel](#SerieLabel)，可用于说明图形的一些数据信息，比如值，名称等。
+* `emphasis`：高亮样式 [Emphasis](#Emphasis)。
+* `animation`：起始动画 [SerieAnimation](#SerieAnimation)。
+* `data`：系列中的数据项 [SerieData](#SerieData) 数组，可以设置`1`到`n`维数据。
+
+## `Serie-Heatmap`
+
+热力图系列。
+
+* `show`：系列是否显示在图表上。
+* `type`：`Scatter`。
+* `name`：系列名称。用于 `tooltip` 的显示，`legend` 的图例筛选。
+* `ignore`：是否开启忽略数据。当为 `true` 时，数据值为 `ignoreValue` 时不进行绘制。
+* `ignoreValue`：忽略数据的默认值。默认值默认为`0`，当 `ignore` 为 `true` 才有效。
+* `label`：图形上的文本标签 [SerieLabel](#SerieLabel)，可用于说明图形的一些数据信息，比如值，名称等。
+* `emphasis`：高亮样式 [Emphasis](#Emphasis)。
+* `animation`：起始动画 [SerieAnimation](#SerieAnimation)。
+* `data`：系列中的数据项 [SerieData](#SerieData) 数组，可以设置`1`到`n`维数据。
+
+## `Serie-Gauge`
+
+仪表盘系列。
+
+* `show`：系列是否显示在图表上。
+* `type`：`Gauge`。
+* `name`：系列名称。用于 `tooltip` 的显示，`legend` 的图例筛选。
+* `gaugeType`：仪表盘类型，支持以下类型：
+  * `Pointer`：指针类型。
+  * `ProgressBar`：进度条类型。
+* `center`：中心点坐标。当值为0-1的浮点数时表示百分比。
+* `radius`：仪表盘半径。
+* `min`：最小的数据值。映射到`startAngle`。
+* `max`：最大的数据值。映射到`endAngle`。
+* `startAngle`：仪表盘起始角度。和时钟一样，`12`点钟位置是`0`度，顺时针到`360`度。
+* `endAngle`：仪表盘结束角度。和时钟一样，`12`点钟位置是`0`度，顺时针到`360`度。
+* `splitNumber`：仪表盘刻度分割段数。
+* `roundCap`：是否启用圆弧效果。
+* `titleStyle`：仪表盘标题 [TitleStyle](#TitleStyle)。
+* `gaugeAxis`： 仪表盘坐标轴 [GaugeAxis](#GaugeAxis)。
+* `gaugePointer`：仪表盘指针 [GaugePointer](#GaugePointer)。
+* `itemStyle`：仪表盘指针样式 [ItemStyle](#ItemStyle)。
+* `label`：图形上的文本标签 [SerieLabel](#SerieLabel)，可用于说明图形的一些数据信息，比如值，名称等。
+* `emphasis`：高亮样式 [Emphasis](#Emphasis)。
+* `animation`：起始动画 [SerieAnimation](#SerieAnimation)。
+* `data`：系列中的数据项 [SerieData](#SerieData) 数组，可以设置`1`到`n`维数据。仪表盘的数据一般只有一个，值通过`label`样式显示，`name`通过`titleStyle`样式显示。
+
+## `Serie-Ring`
+
+环形图系列。
+
+* `show`：系列是否显示在图表上。
+* `type`：`Ring`。
+* `name`：系列名称。用于 `tooltip` 的显示，`legend` 的图例筛选。
+* `center`：中心点坐标。当值为`0-1`的浮点数时表示百分比。
+* `radius`：仪表盘半径。
+* `startAngle`：仪表盘起始角度。和时钟一样，`12`点钟位置是`0`度，顺时针到`360`度。
+* `ringGap`：环形图的环间隙。
+* `roundCap`：是否启用圆弧效果。
+* `clockwise`：是否顺时针，默认为`true`。
+* `titleStyle`：环形图中心标题 [TitleStyle](#TitleStyle)。
+* `itemStyle`：环形图的圆环样式，包括设置背景颜色和边框等 [ItemStyle](#ItemStyle)。
+* `label`：图形上的文本标签 [SerieLabel](#SerieLabel)，可用于说明图形的一些数据信息，比如值，名称等。
+* `emphasis`：高亮样式 [Emphasis](#Emphasis)。
+* `animation`：起始动画 [SerieAnimation](#SerieAnimation)。
+* `data`：系列中的数据项 [SerieData](#SerieData) 数组，可以设置`1`到`n`维数据。环形图的数据只有二维，`data[0]`表示当前值，`data[1]`表示最大值。
 
 ## `Settings`
 
----
-
 全局参数设置组件。一般情况下可使用默认值，当有需要时可进行调整。
 
 * `lineSmoothStyle`：曲线平滑系数。通过调整平滑系数可以改变曲线的曲率，得到外观稍微有变化的不同曲线。
@@ -426,21 +683,19 @@
 * `lineSegmentDistance`： 线段的分割距离。普通折线图的线是由很多线段组成，段数由该数值决定。值越小段数越多，但顶点数也会随之增加。当开启有渐变的区域填充时，数值越大渐变过渡效果越差。
 * `cicleSmoothness`：圆形（包括扇形、环形等）的平滑度。数越小圆越平滑，但顶点数也会随之增加。
 
-## `Animation`
+## `SerieAnimation`
 
----
-
-* `enable`：是否开起始画效果。
-* `easing`：动画的缓动效果。支持以下动画效果：
-  * `Linear`：线性效果。
-* `duration`：设定的动画时长，单位毫秒。
-* `threshold`：是否开启动画的阈值，当单个系列显示的图形数量大于这个阈值时会关闭动画。
-* `delay`：动画延时，单位毫秒。
+* `enable`：是否开启动画系统。
+* ~~`threshold`：是否开启动画的阈值，当单个系列显示的图形数量大于这个阈值时会关闭动画。~~
+* `fadeInDelay`：设定的渐入动画延时，单位毫秒。如果要设置单个数据项的延时，可以用代码定制：`customFadeInDelay`。
+* `fadeInDuration`：设定的渐入动画时长，单位毫秒。如果要设置单个数据项的渐入时长，可以用代码定制：`customFadeInDuration`。
+* `fadeOutDelay`：设定的渐出动画延时，单位毫秒。如果要设置单个数据项的延时，可以用代码定制：`customFadeOutDelay`。
+* `fadeOutDuration`：设定的渐出动画时长，单位毫秒。如果要设置单个数据项的渐出时长，可以用代码定制：`customFadeOutDuration`。
+* `dataChangeEnable`：是否开启数据变更动画。
+* `dataChangeDuration`：数据变更动画时长，单位毫秒。
 
 ## `AreaStyle`
 
----
-
 * `show`：是否显示区域填充。
 * `origin`：区域填充的起始位置 `AreaOrigin`。有以下三种填充方式：
   * `Auto`：填充坐标轴轴线到数据间的区域。
@@ -450,30 +705,29 @@
 * `toColor`：区域填充的渐变色的终点颜色。
 * `highlightColor`：高亮时区域填充的颜色，默认取 `serie` 对应的颜色。如果 `highlightToColor` 不是默认值，则表示渐变色的起点颜色。
 * `highlightToColor`：高亮时区域填充的渐变色的终点颜色。
-* `opacity`：图形透明度。支持从 0 到 1 的数字，为 0 时不绘制该图形。
+* `opacity`：图形透明度。支持从 `0` 到 `1` 的数字，为 `0` 时不绘制该图形。
 * `tooltipHighlight`：鼠标悬浮时是否高亮之前的区域。
 
 ## `AxisLabel`
 
----
-
 * `show`：是否显示刻度标签。
-* `interval`：坐标轴刻度标签的显示间隔，在类目轴中有效。0表示显示所有标签，1表示隔一个隔显示一个标签，以此类推。
+* `interval`：坐标轴刻度标签的显示间隔，在类目轴中有效。`0`表示显示所有标签，`1`表示隔一个隔显示一个标签，以此类推。
 * `inside`：刻度标签是否朝内，默认朝外。
 * `rotate`：刻度标签旋转的角度，在类目轴的类目标签显示不下的时候可以通过旋转防止标签之间重叠。
 * `margin`：刻度标签与轴线之间的距离。
-* `color`：刻度标签文字的颜色，默认取主题Theme的axisTextColor。
+* `color`：刻度标签文字的颜色，默认取主题`Theme`的`axisTextColor`。
 * `fontSize`：文字的字体大小。
 * `fontStyle`：文字字体的风格。
-* `formatter`：图例内容字符串模版格式器。支持用 \n 换行。模板变量为图例名称 {value}，{value:f1} 表示取1为小数
-* `forceENotation`：是否强制使用科学计数法格式化显示数值。默认为false，当小数精度大于3时才采用科学计数法。
+* `formatter`：图例内容字符串模版格式器。支持用 `\n` 换行。模板变量为图例名称 `{value}`，数值格式化通过`numericFormatter`。
+* `numericFormatter`：标准数字格式字符串。用于将数值格式化显示为字符串。使用`Axx`的形式：`A`是格式说明符的单字符，支持`C`货币、`D`十进制、`E`指数、`F`顶点数、`G`常规、`N`数字、`P`百分比、`R`往返过程、`X`十六进制等九种。`xx`是精度说明，从`0`-`99`。
+* `showAsPositiveNumber`：将负数数值显示为正数。一般和`Serie`的`showAsPositiveNumber`配合使用。
+* `onZero`：刻度标签显示在`0`刻度上。
+* `textLimit`：文本自适应 [TextLimit](#TextLimit)。只在类目轴中有效。
 
 ## `AxisLine`
 
----
-
 * `show`：是否显示坐标轴轴线。
-* `onZero`：X 轴或者 Y 轴的轴线是否在另一个轴的 0 刻度上，只有在另一个轴为数值轴且包含 0 刻度时有效。
+* `onZero`： `X` 轴或者 `Y` 轴的轴线是否在另一个轴的 `0` 刻度上，只有在另一个轴为数值轴且包含 `0` 刻度时有效。
 * `width`：坐标轴线线宽。
 * `symbol`：是否显示箭头。
 * `symbolWidth`：箭头宽。
@@ -483,8 +737,6 @@
 
 ## `AxisName`
 
----
-
 * `show`：是否显示坐标名称。
 * `name`：坐标轴名称。
 * `location`：坐标轴名称的位置。支持以下类型：
@@ -497,45 +749,49 @@
 * `fontSize`：坐标轴名称的文字大小。
 * `fontStyle`：坐标轴名称的文字风格。
 
-## `AxisSplitArea`
+## `AxisSplitLine`
 
----
+* `show`：是否显示坐标分割线。
+* `interval`：分割线的显示间隔。`0` 表示显示所有分割线，`1` 表示隔一个隔显示一个分割线，以此类推。
+* `lineStyle`：线条样式 [LineStyle](#LineStyle)。
+
+## `AxisSplitArea`
 
 * `show`：是否显示坐标分割区域。
 * `color`：分隔区域颜色。分隔区域会按数组中颜色的顺序依次循环设置颜色。默认是一个深浅的间隔色。
 
 ## `AxisTick`
 
----
-
 * `show`：是否显示坐标轴刻度。
-* `alignWithLabel`：类目轴中在 boundaryGap 为 true 的时候有效，可以保证刻度线和标签对齐。
+* `alignWithLabel`：类目轴中在 `boundaryGap` 为 `true` 的时候有效，可以保证刻度线和标签对齐。
 * `inside`：坐标轴刻度是否朝内，默认朝外。
 * `length`：坐标轴刻度的长度。
+* `width`：坐标轴刻度的宽度。默认为0时宽度和坐标轴一致。
 
 ## `Emphasis`
 
----
-
 * `show`：是否启用高亮样式。
 * `label`：图形文本标签样式 [SerieLabel](#SerieLabel)。
 * `itemStyle`：图形样式 [ItemStyle](#ItemStyle)。
 
 ## `ItemStyle`
 
----
-
 * `show`：是否启用。
 * `color`：颜色。
+* `backgroundColor`：背景颜色。
+* `backgroundWidth`：背景的宽。
+* `centerColor`：中心区域的颜色。如环形图的中心区域。
+* `centerGap`：中心区域的间隙。如环形图的中心区域于最内环的间隙。
 * `borderType`：边框的类型。
 * `borderColor`：边框的颜色。
 * `borderWidth`：边框宽。
-* `borderWidth`：opacity。
+* `opacity`：透明度。
+* `tooltipFormatter`：提示框单项的字符串模版格式器。具体配置参考`Tooltip`的`formatter`。
+* `numericFormatter`：标准数字格式字符串。用于将数值格式化显示为字符串。使用`Axx`的形式：`A`是格式说明符的单字符，支持`C`货币、`D`十进制、`E`指数、`F`顶点数、`G`常规、`N`数字、`P`百分比、`R`往返过程、`X`十六进制等九种。`xx`是精度说明，从`0`-`99`。此字段优先于`SerieLabel`和`Tooltip`的`numericFormatter`。
+* `cornerRadius`：圆角半径。用数组分别指定4个圆角半径（顺时针左上，右上，右下，左下）。支持用0-1的浮点数设置百分比。
 
 ## `LineArrow`
 
----
-
 * `show`：是否显示箭头。
 * `position`：箭头显示位置。支持以下两种位置：
   * `End`：末端显示。最后一个数据上显示箭头。
@@ -547,9 +803,7 @@
 
 ## `LineStyle`
 
----
-
-* `show`：是否显示线条。在折线图中无效。
+* `show`：是否显示线条。当作为子组件，它的父组件有参数控制是否显示时，改参数无效。
 * `type`：线条类型。支持以下五种类型：
   * `None`：不显示分割线。
   * `Solid`：实线。
@@ -559,12 +813,10 @@
   * `DashDotDot`：双点划线。
 * `color`：线条颜色。默认和 `serie` 一致。
 * `width`：线条宽。
-* `opacity`：线条的透明度。支持从 0 到 1 的数字，为 0 时不绘制该图形。
+* `opacity`：线条的透明度。支持从 `0` 到 `1` 的数字，为 `0` 时不绘制该图形。
 
 ## `Location`
 
----
-
 * `align`：对齐方式。有以下对齐方式。
   * `TopLeft`：左上角对齐。
   * `TopRight`：右上角对齐。
@@ -582,22 +834,22 @@
 
 ## `SerieData`
 
----
-
 * `name`：数据项名称。
 * `selected`：该数据项是否被选中。
 * `radius`：自定义半径。可用在饼图中自定义某个数据项的半径。
-* `showIcon`：是否显示图标。
-* `iconImage`：图标的图片。
-* `iconColor`：图标颜色。
-* `iconWidth`：图标宽。
-* `iconHeight`：图标高。
-* `iconOffset`：图标偏移。
+* `iconStyle`：数据项图标样式。
+* `enableLabel`：是否启用单个数据项的标签设置。
+* `label`：单个数据项的标签设置。
+* `enableItemStyle`：是否启用单个数据项的样式。
+* `itemStyle`：单个数据项的样式设置。
+* `enableEmphasis`：是否启用单个数据项的高亮样式。
+* `emphasis`：单个数据项的高亮样式设置。
+* `enableSymbol`：是否启用单个数据项的标记设置。
+* `symbol`：单个数据项的标记设置。
+* `data`：可指定任意维数的数值列表。对于折线图和柱状图，`data`其实是`size`为`2`的数组，`data[0]`是x的编号，`data[1]`是`y`的数值，默认显示`data[1]`。其他图表看需求而定是长度大于`2`的数组。可通过`Serie`的`showDataDimension`指定数据长度。
 
 ## `SerieLabel`
 
----
-
 * `show`：是否显示文本标签。
 * `position`：标签的位置。折线图时强制默认为 `Center`，支持以下 `5` 种位置：
   * `Outside`：饼图扇区外侧，通过视觉引导线连到相应的扇区。只在饼图种可用。
@@ -605,8 +857,10 @@
   * `Center`：在中心位置（折线图，柱状图，饼图）。
   * `Top`：顶部（柱状图）。
   * `Bottom`：底部（柱状图）。
-* `formatter`：标签内容字符串模版格式器。支持用 `\n` 换行。模板变量有：`{a}`：系列名；`{b}`：数据名；`{c}`：数据值；`{d}`：百分比。示例：`{b}:{c:f1}`。
+* `formatter`：标签内容字符串模版格式器。支持用 `\n` 换行。模板变量有：`{a}`：系列名；`{b}`：数据名；`{c}`：数据值；`{d}`：百分比。示例：`{b}:{c}`。
+* `numericFormatter`：标准数字格式字符串。用于将数值格式化显示为字符串。使用`Axx`的形式：`A`是格式说明符的单字符，支持`C`货币、`D`十进制、`E`指数、`F`顶点数、`G`常规、`N`数字、`P`百分比、`R`往返过程、`X`十六进制等九种。`xx`是精度说明，从`0`-`99`。
 * `offset`：距离图形元素的偏移。
+* `autoOffset`：是否开启自动偏移。当开启时，Y的偏移会自动判断曲线的开口来决定向上还是向下偏移。
 * `color`：自定义文字颜色，默认和系列的颜色一致。
 * `backgroundColor`：标签的背景色，默认无颜色。
 * `backgroundWidth`：标签的背景宽度。一般不用指定，不指定时则自动是文字的宽度。
@@ -628,19 +882,18 @@
 * `border`：是否显示边框。
 * `borderWidth`：边框宽度。
 * `borderColor`：边框颜色。
-* `forceENotation`：是否强制使用科学计数法格式化显示数值。默认为false，当小数精度大于3时才采用科学计数法。
 
 ## `SerieSymbol`
 
----
-
+* `show`：是否显示标记。
 * `type`：标记类型。支持以下六种类型：
   * `EmptyCircle`：空心圆。
   * `Circle`：实心圆。
-  * `Rect`：正方形。
+  * `Rect`：正方形。可通过设置`itemStyle`的`cornerRadius`变成圆角矩形。
   * `Triangle`：三角形。
   * `Diamond`：菱形。
   * `None`：不显示标记。
+* `gap`：图形标记的外留白距离。
 * `sizeType`：标记图形的大小获取方式。支持以下三种类型：
   * `Custom`：自定义大小。
   * `FromData`：通过 `dataIndex` 从数据中获取，再乘以一个比例系数 `dataScale` 。
@@ -655,7 +908,7 @@
 * `color`：标记图形的颜色，默认和系列一致。
 * `opacity`：图形标记的透明度。
 * `startIndex`：开始显示图形标记的索引。
-* `interval`：显示图形标记的间隔。0表示显示所有标签，1表示隔一个隔显示一个标签，以此类推。
+* `interval`：显示图形标记的间隔。`0`表示显示所有标签，`1`表示隔一个隔显示一个标签，以此类推。
 * `forceShowLast`：是否强制显示最后一个图形标记。默认为 `false`。
 
 [返回首页](https://github.com/monitor1394/unity-ugui-XCharts)  

Assets/XCharts/Documentation/XCharts问答.md

@@ -20,13 +20,18 @@
 [QA 14：如何在数据项顶上显示文本？](#如何在数据项顶上显示文本)  
 [QA 15：如何给数据项自定义图标？](#如何给数据项自定义图标)  
 [QA 16：锯齿太严重，如何让图表更顺滑？](#锯齿太严重，如何让图表更顺滑)  
-[QA 17：为什么鼠标移上图表Tooltip不显示？](#为什么鼠标移上图表`Tooltip`不显示)  
-[QA 18：如何取消Tooltip的竖线？](#如何取消`Tooltip`的竖线)  
-[QA 19：如何让Y轴（数值轴）显示多位小数？](#如何让Y轴（数值轴）显示多位小数)  
-[QA 20：如何用代码动态更新数据？](#如何用代码动态更新数据)  
-[QA 21：如何显示图例？](#如何显示图例)  
-[QA 22：如何做成预设？](#如何做成预设)  
-[QA 23：如何在图表上画点画线等自定义内容？](#如何在图表上画点画线等自定义内容)  
+[QA 17：为什么鼠标移上图表 Tooltip 不显示？](#为什么鼠标移上图表`Tooltip`不显示)  
+[QA 18：如何取消 Tooltip 的竖线？](#如何取消`Tooltip`的竖线)  
+[QA 19：如何自定义 Tooltip 的显示内容？](#如何自定义`Tooltip`的显示内容)  
+[QA 20：如何让Y轴（数值轴）显示多位小数？](#如何让Y轴（数值轴）显示多位小数)  
+[QA 21：如何用代码动态更新数据？](#如何用代码动态更新数据)  
+[QA 22：如何显示图例？为什么有时候图例无法显示？](#如何显示图例？为什么有时候图例无法显示)  
+[QA 23：如何做成预设？](#如何做成预设)  
+[QA 24：如何在图表上画点画线等自定义内容？](#如何在图表上画点画线等自定义内容)  
+[QA 25：如何实现心电图类似的数据移动效果？](#如何实现心电图类似的数据移动效果)  
+[QA 26：如何使用背景组件？有什么条件限制？](#如何使用背景组件？有什么条件限制)  
+[QA 27：Mesh can not have more than 65000 vertices?](#Mesh_cannot_have_more_than_65000_vertices)  
+[QA 28：为什么serie里设置的参数运行后又被重置了?](#为什么serie里设置的参数运行后又被重置了)  
 
 ## 如何调整坐标轴与背景的边距
 
@@ -42,7 +47,7 @@
 
 ## 如何格式化文字，如我想给坐标轴标签加上单位
 
-答：通过`formatter`参数，在`Legend`、`Axis`的`AxisLabel`、`Tooltop`、`Serie`的`Label`都提供改参数的配置。
+答：通过`formatter`和`numericFormatter`参数，在`Legend`、`Axis`的`AxisLabel`、`Tooltop`、`Serie`的`Label`都提供该参数的配置。
 
 ## 如何让柱形图的柱子堆叠显示
 
@@ -58,15 +63,15 @@
 
 ## 如何调整柱形图单个柱子的颜色
 
-答：目前暂不支持调整单子柱子的颜色，但可以通过两个`serie`同柱不堆叠来实现，通过设置数据项为`0`来达到类似效果。
+答：可通过调整单个`Data`下的`ItemStyle`调整，也可以通过两个`serie`同柱不堆叠来实现，通过设置数据项为`0`来达到类似效果。
 
 ## 如何调整图表的对齐方式
 
-答：默认为左下角对齐，暂不支持调整。可以通过包一层parent来辅助控制。
+答：默认为左下角对齐，暂不支持调整。可以通过包一层parent来辅助控制。（最新版本`1.5.0`及以上已支持任意锚点，可和做UI一样任意调整对其方式）。
 
 ## 可以显示超过1000以上的大数据吗
 
-答：可以。但`UGUI`对单个`Graphic`限制`65000`个顶点，所以太多的数据不一定能显示完全。可通过设置采样距离`sampleDist`开启采样简化过密曲线。也可以通过设置一些参数来减少图表的顶点数有助于显示更多数据。如缩小图表的尺寸，关闭或减少坐标轴的客户端绘制，关闭`Serie`的`symbol`和`label`显示等。折线图的普通线图`Normal`比平滑线图`Smooth`占用顶点数更少。
+答：可以。但`UGUI`对单个`Graphic`限制`65000`个顶点，所以太多的数据不一定能显示完全。可通过设置采样距离`sampleDist`开启采样简化过密曲线。也可以通过设置一些参数来减少图表的顶点数有助于显示更多数据。如缩小图表的尺寸，关闭或减少坐标轴的客户端绘制，关闭`Serie`的`symbol`和`label`显示等。折线图的普通线图`Normal`比平滑线图`Smooth`占用顶点数更少。`1.5.0`以上版本可以设置`large`和`largeThreshold`参数来开启性能模式。
 
 ## 折线图可以画虚线、点线、点划线吗
 
@@ -90,7 +95,7 @@
 
 ## 锯齿太严重，如何让图表更顺滑
 
-答：开启抗锯齿设置。调整UI渲染模式为Camera模式，开启MSAA，设置4倍或更高抗锯齿。锯齿只能减少难以避免，像素越高锯齿越不明显。
+答：开启抗锯齿设置（在`Unity`里设置）。调整UI渲染模式为`Camera`模式，开启`MSAA`，设置`4`倍或更高抗锯齿。锯齿只能减少难以避免，像素越高锯齿越不明显。
 
 ## 为什么鼠标移上图表`Tooltip`不显示
 
@@ -98,19 +103,23 @@
 
 ## 如何取消`Tooltip`的竖线
 
-答：设置`Tooltip`的`type`为`None`。
+答：设置`Tooltip`的`type`为`None`。或者调整`lineStyle`的参数。
+
+## 如何自定义`Tooltip`的显示内容
+
+答：自定义总的内容可以通过`Tooltip`的`formatter`。如果只是想调整所有的`serie`的显示格式可以用`itemFormatter`和`titleFormatter`结合。如果想每个`serie`的显示格式不一样，可以定制`serie`的`itemStyle`里的`tooltipFormatter`。具体的用法请查阅[XCharts配置项手册](XCharts配置项手册.md)。
 
 ## 如何让Y轴（数值轴）显示多位小数
 
-答：设置`Axis`下的`AxisLabel`中的`formatter`为`{value:f1}`或`{value:f2}`
+答：设置`Axis`下的`AxisLabel`中的`formatter`为`{value:f1}`或`{value:f2}`。`1.5.0`及以上版本通过`numericFormatter`设置。
 
 ## 如何用代码动态更新数据
 
-答：请查阅`Demo`下的代码，`Demo10_LineSimple.cs`就是一个简单添加数据构建折线图的例子，其他`Demo`也都是通过代码控制不同的组件实现不同的功能。
+答：请查阅`Example`下的代码，`Example13_LineSimple.cs`就是一个简单添加数据构建折线图的例子，其他`Demo`也都是通过代码控制不同的组件实现不同的功能，相关API请查看文档：[XChartsAPI接口](XChartsAPI.md)  。
 
-## 如何显示图例
+## 如何显示图例？为什么有时候图例无法显示
 
-答：首先，你的`serie`里的`name`需有值不为空。然后开启`Legend`显示，里面的`data`可以默认为空，表示显示所有的图例。如果你只想显示部分`serie`的图例，在`data`中填入要显示的图例即可。
+答：首先，你的`serie`里的`name`需有值不为空。然后开启`Legend`显示，里面的`data`可以默认为空，表示显示所有的图例。如果你只想显示部分`serie`的图例，在`data`中填入要显示的图例的`name`即可。如果`data`中的值都不是系列的`name`，那图例就不会显示。
 
 ## 如何做成预设
 
@@ -118,7 +127,27 @@
 
 ## 如何在图表上画点画线等自定义内容
 
-答：xcharts有自定义绘制回调`customDrawCallback`，具体可参考`Demo12_CustomDrawing.cs`
+答：`XCharts`有自定义绘制回调`onCustomDraw`，具体可参考`Example12_CustomDrawing.cs`
+
+## 如何实现心电图类似的数据移动效果
+
+答：参考`Example`目录下的`Example_Dynamic.cs`。主要通过设置`maxCache`参数实现。`axis`和`serie`都设置相同的`maxCache`。`maxCache`可固定数据个数，当数据超过设定时会先删除第一个在添加新数据，实现数据移动效果。
+
+## 如何使用背景组件？有什么条件限制
+
+答：设置`background`组件的`show`为`true`，但不一定就能激活背景组件。由于框架的局限性，背景组件有两个前提条件：一是图表的父节点不能用布局控制，因为背景组件和图表的节点关系是并行的，用了布局控制背景组件的位置就无法控制。二是图表的父节点只能有图表自己一个子节点，这是方便管理背景组件节点的需要，要不然并行关系的原因，容易错乱对不上。另外，调整图表的层级关系时最好先隐藏背景组件，这是会自动删除关联的背景组件节点。
+
+## 区域折线图在用半透明颜色时有时候会一条叠加的线
+
+答：这是区域折线图绘制的bug。可以用浅的不透的颜色替代半透明颜色。
+
+## Mesh_cannot_have_more_than_65000_vertices
+
+答：这是`UGUI`对单个`Graphic`的顶点数限制。`XCharts`是将图形绘制在单个`Graphic`上，所以也会有这个限制。解决的办法可以参考：[QA 10：可以显示超过1000以上的大数据吗？](#可以显示超过1000以上的大数据吗)  
+
+## 为什么serie里设置的参数运行后又被重置了
+
+答：检测下代码里是否调用了`RemoveData()`并重新添加`Serie`了。如果想保留`Serie`的配置可以只`ClearData()`，然后重新添加数据。
 
 [返回首页](https://github.com/monitor1394/unity-ugui-XCharts)  
 [XChartsAPI接口](XChartsAPI.md)  

Assets/XCharts/Editor/BaseChartEditor.cs

@@ -6,6 +6,8 @@
 /******************************************/
 
 using UnityEditor;
+using UnityEngine;
+using System.Text;
 
 namespace XCharts
 {
@@ -22,25 +24,33 @@ namespace XCharts
         protected SerializedProperty m_ChartHeight;
         protected SerializedProperty m_Theme;
         protected SerializedProperty m_ThemeInfo;
+        protected SerializedProperty m_Background;
         protected SerializedProperty m_Title;
         protected SerializedProperty m_Legend;
         protected SerializedProperty m_Tooltip;
         protected SerializedProperty m_Series;
         protected SerializedProperty m_Settings;
         protected SerializedProperty m_Large;
+        protected SerializedProperty m_ChartName;
+        protected SerializedProperty m_DebugMode;
 
         protected float m_DefaultLabelWidth;
         protected float m_DefaultFieldWidth;
         private int m_SeriesSize;
+        private Vector2 scrollPos;
+        private bool m_CheckWarning = false;
+        private StringBuilder sb = new StringBuilder();
 
         protected virtual void OnEnable()
         {
             m_Target = (BaseChart)target;
             m_Script = serializedObject.FindProperty("m_Script");
+            m_ChartName = serializedObject.FindProperty("m_ChartName");
             m_ChartWidth = serializedObject.FindProperty("m_ChartWidth");
             m_ChartHeight = serializedObject.FindProperty("m_ChartHeight");
             m_Theme = serializedObject.FindProperty("m_Theme");
             m_ThemeInfo = serializedObject.FindProperty("m_ThemeInfo");
+            m_Background = serializedObject.FindProperty("m_Background");
             m_Title = serializedObject.FindProperty("m_Title");
             m_Legend = serializedObject.FindProperty("m_Legend");
             m_Tooltip = serializedObject.FindProperty("m_Tooltip");
@@ -48,6 +58,7 @@ namespace XCharts
 
             m_Large = serializedObject.FindProperty("m_Large");
             m_Settings = serializedObject.FindProperty("m_Settings");
+            m_DebugMode = serializedObject.FindProperty("m_DebugMode");
         }
 
         public override void OnInspectorGUI()
@@ -65,15 +76,26 @@ namespace XCharts
             OnMiddleInspectorGUI();
             OnEndInspectorGUI();
 
+            CheckWarning();
             serializedObject.ApplyModifiedProperties();
         }
 
         protected virtual void OnStartInspectorGUI()
         {
             EditorGUILayout.PropertyField(m_Script);
-            EditorGUILayout.PropertyField(m_ChartWidth);
-            EditorGUILayout.PropertyField(m_ChartHeight);
+
+            EditorGUILayout.PropertyField(m_ChartName);
             EditorGUILayout.PropertyField(m_ThemeInfo, true);
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(m_Background, true);
+
+            var m_Show = m_Background.FindPropertyRelative("m_Show");
+            if (m_Show.boolValue && !m_Target.CanShowBackgroundComponent())
+            {
+                var msg = "The background component cannot be activated because chart is controlled by LayoutGroup,"
+                + " or its parent have more than one child.";
+                EditorGUILayout.HelpBox(msg, MessageType.Error);
+            }
             EditorGUILayout.PropertyField(m_Title, true);
             EditorGUILayout.PropertyField(m_Legend, true);
             EditorGUILayout.PropertyField(m_Tooltip, true);
@@ -87,6 +109,54 @@ namespace XCharts
 
         protected virtual void OnEndInspectorGUI()
         {
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            EditorGUILayout.PropertyField(m_DebugMode);
+        }
+
+        private void CheckWarning()
+        {
+            if (GUILayout.Button("Check XCharts Update "))
+            {
+                CheckVersionEditor.ShowWindow();
+            }
+            if (m_CheckWarning)
+            {
+                EditorGUILayout.BeginHorizontal();
+                if (GUILayout.Button("Check Warning"))
+                {
+                    m_CheckWarning = true;
+                    m_Target.CheckWarning();
+                }
+                if (GUILayout.Button("Hide Warning"))
+                {
+                    m_CheckWarning = false;
+                }
+                EditorGUILayout.EndHorizontal();
+                sb.Length = 0;
+                sb.AppendFormat("version:{0}", XChartsMgr.Instance.nowVersion);
+                if (!string.IsNullOrEmpty(m_Target.warningInfo))
+                {
+                    sb.AppendLine();
+                    sb.Append(m_Target.warningInfo);
+                }
+                else
+                {
+                    sb.AppendLine();
+                    sb.Append("Perfect! No warning!");
+                }
+                EditorGUILayout.HelpBox(sb.ToString(), MessageType.Warning);
+            }
+            else
+            {
+                if (GUILayout.Button("Check warning"))
+                {
+                    m_CheckWarning = true;
+                    m_Target.CheckWarning();
+                }
+            }
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
         }
     }
 }

Assets/XCharts/Editor/CheckVersionEditor.cs

@@ -15,8 +15,8 @@ namespace XCharts
         private Vector2 scrollPos;
         private static CheckVersionEditor window;
 
-        [MenuItem("Component/XCharts/Check For Update")]
-        private static void ShowWindow()
+        [MenuItem("XCharts/Check For Update")]
+        public static void ShowWindow()
         {
             window = GetWindow<CheckVersionEditor>();
             window.titleContent = new GUIContent("XCharts Check For Update");
@@ -25,6 +25,11 @@ namespace XCharts
             XChartsMgr.Instance.CheckVersion();
         }
 
+        void OnInspectorUpdate()
+        {
+            Repaint();
+        }
+
         private void OnGUI()
         {
             var mgr = XChartsMgr.Instance;
@@ -32,46 +37,70 @@ namespace XCharts
             GUILayout.Label("当前版本：" + mgr.nowVersion);
             if (mgr.needUpdate && !mgr.isCheck)
             {
-                GUILayout.BeginHorizontal();
                 GUILayout.Label("最新版本：" + mgr.newVersion);
+                GUILayout.Label("");
                 if (mgr.isCheck) GUILayout.Label("检测中...");
-                else GUILayout.Label("有更新！");
-                if (GUILayout.Button("去Github主页"))
+                else if (mgr.isNetworkError) GUILayout.Label("检测失败：" + mgr.networkError);
+                else
                 {
-                    Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts");
+                    GUILayout.Label("有更新！");
                 }
-                GUILayout.EndHorizontal();
 
                 GUILayout.Label("");
                 if (!string.IsNullOrEmpty(mgr.desc))
                 {
                     GUILayout.Label(mgr.desc);
-                    GUILayout.Label("");
                 }
-
-                scrollPos = GUILayout.BeginScrollView(scrollPos);
-                GUILayout.TextArea(mgr.changeLog);
-                GUILayout.EndScrollView();
+                if (GUILayout.Button("去Github主页"))
+                {
+                    Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts");
+                }
+                if (GUILayout.Button("点Star支持"))
+                {
+                    Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts/stargazers");
+                }
+                if (GUILayout.Button("问题反馈"))
+                {
+                    Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts/issues");
+                }
+                if (!string.IsNullOrEmpty(mgr.changeLog))
+                {
+                    scrollPos = GUILayout.BeginScrollView(scrollPos);
+                    GUILayout.TextArea(mgr.changeLog);
+                    GUILayout.EndScrollView();
+                }
             }
             else
             {
                 if (mgr.isCheck) GUILayout.Label("最新版本：检测中...");
+                else if (mgr.isNetworkError) GUILayout.Label("检测失败：" + mgr.networkError);
                 else GUILayout.Label("最新版本：" + mgr.newVersion);
 
-                if (!mgr.needUpdate && !mgr.isCheck)
+                GUILayout.Label("");
+                if (!mgr.isNetworkError && !mgr.needUpdate && !mgr.isCheck)
                 {
-                    GUILayout.Label("");
                     GUILayout.Label("已是最新版本！");
-                    GUILayout.Label("");
-                    if (!string.IsNullOrEmpty(mgr.desc))
-                    {
-                        GUILayout.Label(mgr.desc);
-                        GUILayout.Label("");
-                    }
-                    if (GUILayout.Button("去Github主页"))
-                    {
-                        Application.OpenURL(mgr.homepage);
-                    }
+                }
+                GUILayout.Label("");
+                if (!string.IsNullOrEmpty(mgr.desc))
+                {
+                    GUILayout.Label(mgr.desc);
+                }
+                if (GUILayout.Button("去Github主页"))
+                {
+                    Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts");
+                }
+                if (GUILayout.Button("点Star支持"))
+                {
+                    Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts/stargazers");
+                }
+                if (GUILayout.Button("问题反馈"))
+                {
+                    Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts/issues");
+                }
+                if (mgr.isNetworkError && GUILayout.Button("重新检测"))
+                {
+                    XChartsMgr.Instance.CheckVersion();
                 }
             }
         }

Assets/XCharts/Editor/CoordinateChartEditor.cs

@@ -6,6 +6,7 @@
 /******************************************/
 
 using UnityEditor;
+using UnityEngine;
 
 namespace XCharts
 {
@@ -38,8 +39,14 @@ namespace XCharts
         protected override void OnStartInspectorGUI()
         {
             base.OnStartInspectorGUI();
-            EditorGUILayout.PropertyField(m_DataZoom);
-            EditorGUILayout.PropertyField(m_VisualMap);
+            if (m_Target is LineChart || m_Target is BarChart)
+            {
+                EditorGUILayout.PropertyField(m_DataZoom);
+            }
+            if (m_Target is HeatmapChart)
+            {
+                EditorGUILayout.PropertyField(m_VisualMap);
+            }
             EditorGUILayout.PropertyField(m_Grid);
             for (int i = 0; i < m_XAxises.arraySize; i++)
             {
@@ -52,5 +59,19 @@ namespace XCharts
                 EditorGUILayout.PropertyField(axis);
             }
         }
+
+        protected override void OnEndInspectorGUI()
+        {
+            base.OnEndInspectorGUI();
+            CovertXYAxis();
+        }
+
+        private void CovertXYAxis()
+        {
+            if (GUILayout.Button("Covert XY Axis"))
+            {
+                (m_Target as CoordinateChart).CovertXYAxis(0);
+            }
+        }
     }
 }

Assets/XCharts/Editor/GaugeChartEditor.cs

@@ -0,0 +1,33 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEditor;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Editor class used to edit UI GaugeChart.
+    /// </summary>
+
+    [CustomEditor(typeof(GaugeChart), false)]
+    public class GaugeChartEditor : BaseChartEditor
+    {
+        protected SerializedProperty m_Radar;
+        protected SerializedProperty m_Radars;
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            m_Target = (GaugeChart)target;
+        }
+
+        protected override void OnEndInspectorGUI()
+        {
+            base.OnEndInspectorGUI();
+        }
+    }
+}

Assets/XCharts/Editor/GaugeChartEditor.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: dfc9b72c568f74d1dbf37310311aac8e
+guid: bd96c5068df484d1c95748a85d8380a8
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/XCharts/Editor/PropertyDrawers/AnimationDrawer.cs

@@ -22,35 +22,51 @@ namespace XCharts
             drawRect.height = EditorGUIUtility.singleLineHeight;
 
             SerializedProperty m_Enable = prop.FindPropertyRelative("m_Enable");
-            SerializedProperty m_Easting = prop.FindPropertyRelative("m_Easting");
-            SerializedProperty m_Duration = prop.FindPropertyRelative("m_Duration");
-            SerializedProperty m_Delay = prop.FindPropertyRelative("m_Delay");
-            SerializedProperty m_Threshold = prop.FindPropertyRelative("m_Threshold");
+            //SerializedProperty m_Easting = prop.FindPropertyRelative("m_Easting");
+            SerializedProperty m_FadeInDuration = prop.FindPropertyRelative("m_FadeInDuration");
+            SerializedProperty m_FadeOutDuration = prop.FindPropertyRelative("m_FadeOutDuration");
+            SerializedProperty m_DataChangeEnable = prop.FindPropertyRelative("m_DataChangeEnable");
+            SerializedProperty m_DataChangeDuration = prop.FindPropertyRelative("m_DataChangeDuration");
+            SerializedProperty m_FadeInDelay = prop.FindPropertyRelative("m_FadeInDelay");
+            //SerializedProperty m_Threshold = prop.FindPropertyRelative("m_Threshold");
             SerializedProperty m_ActualDuration = prop.FindPropertyRelative("m_ActualDuration");
-            SerializedProperty m_CurrDetailProgress = prop.FindPropertyRelative("m_CurrDetailProgress");
-            SerializedProperty m_DestDetailProgress = prop.FindPropertyRelative("m_DestDetailProgress");
+            SerializedProperty m_FadeOutDelay = prop.FindPropertyRelative("m_FadeOutDelay");
+            // SerializedProperty m_CurrDetailProgress = prop.FindPropertyRelative("m_CurrDetailProgress");
+            // SerializedProperty m_DestDetailProgress = prop.FindPropertyRelative("m_DestDetailProgress");
 
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_AnimationModuleToggle, prop, null, m_Enable, false);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             if (ChartEditorHelper.IsToggle(m_AnimationModuleToggle, prop))
             {
                 ++EditorGUI.indentLevel;
-                EditorGUI.PropertyField(drawRect, m_Easting);
+                //EditorGUI.PropertyField(drawRect, m_Easting);
+                //drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                // EditorGUI.PropertyField(drawRect, m_Threshold);
+                // if (m_Threshold.intValue < 0) m_Threshold.intValue = 0;
+                // drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_FadeInDelay);
+                if (m_FadeInDelay.floatValue < 0) m_FadeInDelay.floatValue = 0;
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_Duration);
-                if (m_Duration.intValue < 0) m_Duration.intValue = 0;
+                EditorGUI.PropertyField(drawRect, m_FadeInDuration);
+                if (m_FadeInDuration.floatValue < 0) m_FadeInDuration.floatValue = 0;
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_Delay);
-                if (m_Delay.intValue < 0) m_Delay.intValue = 0;
+                EditorGUI.PropertyField(drawRect, m_FadeOutDelay);
+                if (m_FadeOutDelay.floatValue < 0) m_FadeOutDelay.floatValue = 0;
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_Threshold);
-                if (m_Threshold.intValue < 0) m_Threshold.intValue = 0;
+                EditorGUI.PropertyField(drawRect, m_FadeOutDuration);
+                if (m_FadeOutDuration.floatValue < 0) m_FadeOutDuration.floatValue = 0;
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.LabelField(drawRect, "CurrDetailProgress:" + m_CurrDetailProgress.floatValue);
+                EditorGUI.PropertyField(drawRect, m_DataChangeEnable);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.LabelField(drawRect, "DestDetailProgress:" + m_DestDetailProgress.floatValue);
+                EditorGUI.PropertyField(drawRect, m_DataChangeDuration);
+                if (m_DataChangeDuration.floatValue < 0) m_DataChangeDuration.floatValue = 0;
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.LabelField(drawRect, "Actual duration:" + m_ActualDuration.intValue + " ms");
+
+                // EditorGUI.LabelField(drawRect, "CurrDetailProgress:" + m_CurrDetailProgress.floatValue);
+                // drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                // EditorGUI.LabelField(drawRect, "DestDetailProgress:" + m_DestDetailProgress.floatValue);
+                // drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.LabelField(drawRect, "Actual duration:" + m_ActualDuration.floatValue + " ms");
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 --EditorGUI.indentLevel;
             }

Assets/XCharts/Editor/PropertyDrawers/AxisDrawer.cs

@@ -33,20 +33,23 @@ namespace XCharts
 
             SerializedProperty m_Show = prop.FindPropertyRelative("m_Show");
             SerializedProperty m_Type = prop.FindPropertyRelative("m_Type");
+            SerializedProperty m_LogBaseE = prop.FindPropertyRelative("m_LogBaseE");
+            SerializedProperty m_LogBase = prop.FindPropertyRelative("m_LogBase");
             SerializedProperty m_SplitNumber = prop.FindPropertyRelative("m_SplitNumber");
             SerializedProperty m_Interval = prop.FindPropertyRelative("m_Interval");
             SerializedProperty m_AxisLabel = prop.FindPropertyRelative("m_AxisLabel");
-            SerializedProperty m_ShowSplitLine = prop.FindPropertyRelative("m_ShowSplitLine");
-            SerializedProperty m_SplitLineType = prop.FindPropertyRelative("m_SplitLineType");
             SerializedProperty m_BoundaryGap = prop.FindPropertyRelative("m_BoundaryGap");
             SerializedProperty m_Data = prop.FindPropertyRelative("m_Data");
             SerializedProperty m_AxisLine = prop.FindPropertyRelative("m_AxisLine");
             SerializedProperty m_AxisName = prop.FindPropertyRelative("m_AxisName");
             SerializedProperty m_AxisTick = prop.FindPropertyRelative("m_AxisTick");
             SerializedProperty m_SplitArea = prop.FindPropertyRelative("m_SplitArea");
+            SerializedProperty m_SplitLine = prop.FindPropertyRelative("m_SplitLine");
             SerializedProperty m_MinMaxType = prop.FindPropertyRelative("m_MinMaxType");
             SerializedProperty m_Min = prop.FindPropertyRelative("m_Min");
             SerializedProperty m_Max = prop.FindPropertyRelative("m_Max");
+            SerializedProperty m_CeilRate = prop.FindPropertyRelative("m_CeilRate");
+            SerializedProperty m_Inverse = prop.FindPropertyRelative("m_Inverse");
 
             int index = InitToggle(prop);
             bool toggle = m_AxisModuleToggle[index];
@@ -59,6 +62,13 @@ namespace XCharts
                 EditorGUI.indentLevel++;
                 EditorGUI.PropertyField(drawRect, m_Type);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                if (type == Axis.AxisType.Log)
+                {
+                    EditorGUI.PropertyField(drawRect, m_LogBaseE);
+                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                    EditorGUI.PropertyField(drawRect, m_LogBase);
+                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                }
                 if (type == Axis.AxisType.Value)
                 {
                     EditorGUI.PropertyField(drawRect, m_MinMaxType);
@@ -79,28 +89,15 @@ namespace XCharts
                             EditorGUI.indentLevel--;
                             break;
                     }
+                    EditorGUI.PropertyField(drawRect, m_CeilRate);
+                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                    EditorGUI.PropertyField(drawRect, m_Inverse);
+                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 }
                 EditorGUI.PropertyField(drawRect, m_SplitNumber);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Interval);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                if (m_ShowSplitLine.boolValue)
-                {
-                    drawRect.width = EditorGUIUtility.labelWidth + 10;
-                    EditorGUI.PropertyField(drawRect, m_ShowSplitLine);
-                    //drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    drawRect.x = EditorGUIUtility.labelWidth + 35;
-                    drawRect.width = EditorGUIUtility.currentViewWidth - EditorGUIUtility.labelWidth - 55;
-                    EditorGUI.PropertyField(drawRect, m_SplitLineType, GUIContent.none);
-                    drawRect.x = pos.x;
-                    drawRect.width = pos.width;
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                }
-                else
-                {
-                    EditorGUI.PropertyField(drawRect, m_ShowSplitLine);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                }
                 EditorGUI.PropertyField(drawRect, m_BoundaryGap);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_AxisLine);
@@ -115,6 +112,8 @@ namespace XCharts
                 EditorGUI.PropertyField(drawRect, m_AxisLabel);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 drawRect.y += EditorGUI.GetPropertyHeight(m_AxisLabel);
+                EditorGUI.PropertyField(drawRect, m_SplitLine);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_SplitLine);
                 EditorGUI.PropertyField(drawRect, m_SplitArea);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 drawRect.y += EditorGUI.GetPropertyHeight(m_SplitArea);
@@ -149,8 +148,9 @@ namespace XCharts
                 SerializedProperty m_AxisName = prop.FindPropertyRelative("m_AxisName");
                 SerializedProperty m_AxisLabel = prop.FindPropertyRelative("m_AxisLabel");
                 SerializedProperty m_SplitArea = prop.FindPropertyRelative("m_SplitArea");
+                SerializedProperty m_SplitLine = prop.FindPropertyRelative("m_SplitLine");
                 float height = 0;
-                height += 11 * EditorGUIUtility.singleLineHeight + 10 * EditorGUIUtility.standardVerticalSpacing;
+                height += 10 * EditorGUIUtility.singleLineHeight + 9 * EditorGUIUtility.standardVerticalSpacing;
                 Axis.AxisType type = (Axis.AxisType)m_Type.enumValueIndex;
                 if (type == Axis.AxisType.Category)
                 {
@@ -173,7 +173,16 @@ namespace XCharts
                 }
                 else if (type == Axis.AxisType.Value)
                 {
-                    height += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                    height += 3 * EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
+                    SerializedProperty m_MinMaxType = prop.FindPropertyRelative("m_MinMaxType");
+                    if (m_MinMaxType.enumValueIndex == (int)Axis.AxisMinMaxType.Custom)
+                    {
+                        height += EditorGUIUtility.singleLineHeight * 2 + EditorGUIUtility.standardVerticalSpacing;
+                    }
+                }
+                else if (type == Axis.AxisType.Log)
+                {
+                    height += 2 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
                     SerializedProperty m_MinMaxType = prop.FindPropertyRelative("m_MinMaxType");
                     if (m_MinMaxType.enumValueIndex == (int)Axis.AxisMinMaxType.Custom)
                     {
@@ -185,6 +194,7 @@ namespace XCharts
                 height += EditorGUI.GetPropertyHeight(m_AxisTick);
                 height += EditorGUI.GetPropertyHeight(m_AxisLabel);
                 height += EditorGUI.GetPropertyHeight(m_SplitArea);
+                height += EditorGUI.GetPropertyHeight(m_SplitLine);
                 return height;
             }
         }
@@ -192,7 +202,7 @@ namespace XCharts
         private int InitToggle(SerializedProperty prop)
         {
             int index = 0;
-            int.TryParse(prop.displayName.Split(' ')[1],out index);
+            int.TryParse(prop.displayName.Split(' ')[1], out index);
             if (index >= m_DataFoldout.Count)
             {
                 m_DataFoldout.Add(false);

Assets/XCharts/Editor/PropertyDrawers/AxisLabelDrawer.cs

@@ -29,13 +29,18 @@ namespace XCharts
             SerializedProperty m_Color = prop.FindPropertyRelative("m_Color");
             SerializedProperty m_FontSize = prop.FindPropertyRelative("m_FontSize");
             SerializedProperty m_FontStyle = prop.FindPropertyRelative("m_FontStyle");
-            SerializedProperty m_ForceENotation = prop.FindPropertyRelative("m_ForceENotation");
+            SerializedProperty m_NumericFormatter = prop.FindPropertyRelative("m_NumericFormatter");
+            SerializedProperty m_ShowAsPositiveNumber = prop.FindPropertyRelative("m_ShowAsPositiveNumber");
+            SerializedProperty m_OnZero = prop.FindPropertyRelative("m_OnZero");
+            SerializedProperty m_TextLimit = prop.FindPropertyRelative("m_TextLimit");
 
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_AxisLabelToggle, prop, "Axis Label", show, false);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             if (ChartEditorHelper.IsToggle(m_AxisLabelToggle, prop))
             {
                 ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_OnZero);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Inside);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Interval);
@@ -52,8 +57,12 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Formatter);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_ForceENotation);
+                EditorGUI.PropertyField(drawRect, m_NumericFormatter);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_ShowAsPositiveNumber);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_TextLimit);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_TextLimit);
                 --EditorGUI.indentLevel;
             }
         }
@@ -63,7 +72,8 @@ namespace XCharts
             float height = 0;
             if (ChartEditorHelper.IsToggle(m_AxisLabelToggle, prop))
             {
-                height += 9 * EditorGUIUtility.singleLineHeight + 10 * EditorGUIUtility.standardVerticalSpacing;
+                height += 12 * EditorGUIUtility.singleLineHeight + 11 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_TextLimit"));
             }
             return height;
         }

Assets/XCharts/Editor/PropertyDrawers/AxisNameDrawer.cs

@@ -66,7 +66,8 @@ namespace XCharts
             float height = 0;
             if (ChartEditorHelper.IsToggle(m_AxisNameToggle, prop))
             {
-                height += 7 * EditorGUIUtility.singleLineHeight + 6 * EditorGUIUtility.standardVerticalSpacing;
+                height += 6 * EditorGUIUtility.singleLineHeight + 5 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Offset"));
             }
             return height;
         }

Assets/XCharts/Editor/PropertyDrawers/AxisSplitLineDrawer.cs

@@ -0,0 +1,55 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(AxisSplitLine), true)]
+    public class AxisSplitLineDrawer : PropertyDrawer
+    {
+        private Dictionary<string, bool> m_AxisSplitLineToggle = new Dictionary<string, bool>();
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty show = prop.FindPropertyRelative("m_Show");
+            SerializedProperty m_Interval = prop.FindPropertyRelative("m_Interval");
+            SerializedProperty m_LineStyle = prop.FindPropertyRelative("m_LineStyle");
+
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_AxisSplitLineToggle, prop, "Split Line", show, false);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (ChartEditorHelper.IsToggle(m_AxisSplitLineToggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_Interval);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_LineStyle);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_LineStyle);
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            float height = 0;
+            if (ChartEditorHelper.IsToggle(m_AxisSplitLineToggle, prop))
+            {
+                height += 2 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineStyle"));
+            }
+            else
+            {
+                height = EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            }
+            return height;
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/AxisSplitLineDrawer.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 060e74df53e174634b42ea5f3c852e94
+guid: af473e9aba20f4f168b8f83a4db13f81
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/XCharts/Editor/PropertyDrawers/AxisTickDrawer.cs

@@ -23,6 +23,7 @@ namespace XCharts
             SerializedProperty m_AlignWithLabel = prop.FindPropertyRelative("m_AlignWithLabel");
             SerializedProperty m_Inside = prop.FindPropertyRelative("m_Inside");
             SerializedProperty m_Length = prop.FindPropertyRelative("m_Length");
+            SerializedProperty m_Width = prop.FindPropertyRelative("m_Width");
 
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_AxisTickToggle, "Axis Tick", show, false);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
@@ -35,6 +36,8 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Length);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Width);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 --EditorGUI.indentLevel;
             }
         }
@@ -44,7 +47,7 @@ namespace XCharts
             float height = 0;
             if (m_AxisTickToggle)
             {
-                height += 3 * EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
+                height += 4 * EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
             }
             return height;
         }

Assets/XCharts/Editor/PropertyDrawers/BackgroundDrawer.cs

@@ -0,0 +1,67 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(Background), true)]
+    public class BackgroundDrawer : PropertyDrawer
+    {
+        private bool m_BackgroundModuleToggle = false;
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+
+            SerializedProperty m_Show = prop.FindPropertyRelative("m_Show");
+            SerializedProperty m_Image = prop.FindPropertyRelative("m_Image");
+            SerializedProperty m_ImageType = prop.FindPropertyRelative("m_ImageType");
+            // SerializedProperty m_Left = prop.FindPropertyRelative("m_Left");
+            // SerializedProperty m_Right = prop.FindPropertyRelative("m_Right");
+            // SerializedProperty m_Top = prop.FindPropertyRelative("m_Top");
+            // SerializedProperty m_Bottom = prop.FindPropertyRelative("m_Bottom");
+            SerializedProperty m_ImageColor = prop.FindPropertyRelative("m_ImageColor");
+            SerializedProperty m_HideThemeBackgroundColor = prop.FindPropertyRelative("m_HideThemeBackgroundColor");
+
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_BackgroundModuleToggle, "Background", m_Show);
+            EditorGUI.LabelField(drawRect, "Background", EditorStyles.boldLabel);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (m_BackgroundModuleToggle)
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_Image);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_ImageType);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                // EditorGUI.PropertyField(drawRect, m_Left);
+                // drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                // EditorGUI.PropertyField(drawRect, m_Right);
+                // drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                // EditorGUI.PropertyField(drawRect, m_Top);
+                // drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                // EditorGUI.PropertyField(drawRect, m_Bottom);
+                // drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_ImageColor);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_HideThemeBackgroundColor);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            if (m_BackgroundModuleToggle)
+                return 5 * EditorGUIUtility.singleLineHeight + 4 * EditorGUIUtility.standardVerticalSpacing;
+            else
+                return 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/BackgroundDrawer.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: e27021e8c8377464a8b439cf785080ee
+guid: 24e3f8609cdf9494cb350a110566176f
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/XCharts/Editor/PropertyDrawers/DataZoomDrawer.cs

@@ -35,6 +35,7 @@ namespace XCharts
             SerializedProperty m_RangeMode = prop.FindPropertyRelative("m_RangeMode");
             SerializedProperty m_Start = prop.FindPropertyRelative("m_Start");
             SerializedProperty m_End = prop.FindPropertyRelative("m_End");
+            SerializedProperty m_MinShowNum = prop.FindPropertyRelative("m_MinShowNum");
             SerializedProperty m_ScrollSensitivity = prop.FindPropertyRelative("m_ScrollSensitivity");
             SerializedProperty m_FontSize = prop.FindPropertyRelative("m_FontSize");
             SerializedProperty m_FontStyle = prop.FindPropertyRelative("m_FontStyle");
@@ -79,8 +80,11 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_End);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_MinShowNum);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 if (m_Start.floatValue < 0) m_Start.floatValue = 0;
                 if (m_End.floatValue > 100) m_End.floatValue = 100;
+                if (m_MinShowNum.intValue < 0) m_MinShowNum.intValue = 0;
                 --EditorGUI.indentLevel;
             }
         }
@@ -91,7 +95,7 @@ namespace XCharts
             int num = 1;
             if (m_DataZoomModuleToggle)
             {
-                num += 7;
+                num += 8;
                 if (prop.FindPropertyRelative("m_SupportSlider").boolValue) num += 6;
 
             }

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisDrawer.cs

@@ -0,0 +1,82 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(GaugeAxis), true)]
+    public class GaugeAxisDrawer : PropertyDrawer
+    {
+        private bool m_DataFoldout = false;
+        private int m_DataSize = 0;
+        private Dictionary<string, bool> m_AxisLineToggle = new Dictionary<string, bool>();
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty show = prop.FindPropertyRelative("m_Show");
+            SerializedProperty m_AxisLine = prop.FindPropertyRelative("m_AxisLine");
+            SerializedProperty m_SplitLine = prop.FindPropertyRelative("m_SplitLine");
+            SerializedProperty m_AxisTick = prop.FindPropertyRelative("m_AxisTick");
+            SerializedProperty m_AxisLabel = prop.FindPropertyRelative("m_AxisLabel");
+            SerializedProperty m_AxisLabelText = prop.FindPropertyRelative("m_AxisLabelText");
+
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_AxisLineToggle, prop, "Gauge Axis", show, false);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (ChartEditorHelper.IsToggle(m_AxisLineToggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_AxisLine);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_AxisLine);
+                EditorGUI.PropertyField(drawRect, m_SplitLine);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_SplitLine);
+                EditorGUI.PropertyField(drawRect, m_AxisTick);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_AxisTick);
+                EditorGUI.PropertyField(drawRect, m_AxisLabel);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_AxisLabel);
+                drawRect.width = EditorGUIUtility.labelWidth + 10;
+                m_DataFoldout = EditorGUI.Foldout(drawRect, m_DataFoldout, "Axis Label Text");
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                drawRect.width = pos.width;
+                if (m_DataFoldout)
+                {
+                    ChartEditorHelper.MakeList(ref drawRect, ref m_DataSize, m_AxisLabelText);
+                }
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            float height = 0;
+            if (ChartEditorHelper.IsToggle(m_AxisLineToggle, prop))
+            {
+                height += 2 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_AxisLine"));
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_SplitLine"));
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_AxisTick"));
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_AxisLabel"));
+                if (m_DataFoldout)
+                {
+                    SerializedProperty m_Data = prop.FindPropertyRelative("m_AxisLabelText");
+                    int num = m_Data.arraySize + 1;
+                    height += num * EditorGUIUtility.singleLineHeight + (num - 1) * EditorGUIUtility.standardVerticalSpacing;
+                    height += EditorGUIUtility.standardVerticalSpacing;
+                }
+                return height;
+            }
+            else
+            {
+                return 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+            }
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisDrawer.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: ce2fe7c8c98c644b9a8585050ea1d963
+guid: dec6cfc5ef85147738a81d8de84b079a
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisLineDrawer.cs

@@ -0,0 +1,76 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(GaugeAxis.AxisLine), true)]
+    public class GaugeAxisLineDrawer : PropertyDrawer
+    {
+        private bool m_DataFoldout = false;
+        private int m_DataSize = 0;
+        private Dictionary<string, bool> m_Toggle = new Dictionary<string, bool>();
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty show = prop.FindPropertyRelative("m_Show");
+            SerializedProperty m_Width = prop.FindPropertyRelative("m_Width");
+            SerializedProperty m_Opacity = prop.FindPropertyRelative("m_Opacity");
+            SerializedProperty m_BarBackgroundColor = prop.FindPropertyRelative("m_BarBackgroundColor");
+            SerializedProperty m_BarColor = prop.FindPropertyRelative("m_BarColor");
+            SerializedProperty m_StageColor = prop.FindPropertyRelative("m_StageColor");
+
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_Toggle, prop, "Axis Line", show, false);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (ChartEditorHelper.IsToggle(m_Toggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_Width);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Opacity);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_BarColor);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_BarBackgroundColor);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                m_DataFoldout = EditorGUI.Foldout(drawRect, m_DataFoldout, "Stage Color");
+                drawRect.width = pos.width;
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                if (m_DataFoldout)
+                {
+                    ChartEditorHelper.MakeList(ref drawRect, ref m_DataSize, m_StageColor);
+                }
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            if (ChartEditorHelper.IsToggle(m_Toggle, prop))
+            {
+                float height = 6 * EditorGUIUtility.singleLineHeight + 5 * EditorGUIUtility.standardVerticalSpacing;
+                if (m_DataFoldout)
+                {
+                    var arraySize = prop.FindPropertyRelative("m_StageColor").arraySize + 1;
+                    height += arraySize * EditorGUIUtility.singleLineHeight + (arraySize) * EditorGUIUtility.standardVerticalSpacing;
+                    height += 2 * EditorGUIUtility.standardVerticalSpacing;
+                    return height;
+                }
+                return height;
+            }
+            else
+            {
+                return 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+            }
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisLineDrawer.cs.meta

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

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisLineStageColorDrawer.cs

@@ -0,0 +1,33 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(GaugeAxis.AxisLine.StageColor), true)]
+    public class GaugeAxisLineStageColorDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty m_Percent = prop.FindPropertyRelative("m_Percent");
+            SerializedProperty m_Color = prop.FindPropertyRelative("m_Color");
+
+            ChartEditorHelper.MakeTwoField(ref drawRect, drawRect.width, m_Percent, m_Color, "Stage");
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            return 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisLineStageColorDrawer.cs.meta

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

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisSplitDrawer.cs

@@ -0,0 +1,54 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(GaugeAxis.SplitLine), true)]
+    public class GaugeAxisSplitDrawer : PropertyDrawer
+    {
+        private Dictionary<string, bool> m_Toggle = new Dictionary<string, bool>();
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty show = prop.FindPropertyRelative("m_Show");
+            SerializedProperty m_Length = prop.FindPropertyRelative("m_Length");
+            SerializedProperty m_LineStyle = prop.FindPropertyRelative("m_LineStyle");
+
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_Toggle, prop, "Split Line", show, false);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (ChartEditorHelper.IsToggle(m_Toggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_Length);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_LineStyle);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_LineStyle);
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            if (ChartEditorHelper.IsToggle(m_Toggle, prop))
+            {
+                float height = 2 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineStyle"));
+                return height;
+            }
+            else
+            {
+                return 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+            }
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisSplitDrawer.cs.meta

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

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisTickDrawer.cs

@@ -0,0 +1,57 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(GaugeAxis.AxisTick), true)]
+    public class GaugeAxisTickDrawer : PropertyDrawer
+    {
+        private Dictionary<string, bool> m_Toggle = new Dictionary<string, bool>();
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty show = prop.FindPropertyRelative("m_Show");
+            SerializedProperty m_Length = prop.FindPropertyRelative("m_Length");
+            SerializedProperty m_SplitNumber = prop.FindPropertyRelative("m_SplitNumber");
+            SerializedProperty m_LineStyle = prop.FindPropertyRelative("m_LineStyle");
+
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_Toggle, prop, "Axis Tick", show, false);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (ChartEditorHelper.IsToggle(m_Toggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_Length);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_SplitNumber);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_LineStyle);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_LineStyle);
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            if (ChartEditorHelper.IsToggle(m_Toggle, prop))
+            {
+                float height = 3 * EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineStyle"));
+                return height;
+            }
+            else
+            {
+                return 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+            }
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/GaugeAxisTickDrawer.cs.meta

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

Assets/XCharts/Editor/PropertyDrawers/GaugePointerDrawer.cs

@@ -0,0 +1,51 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(GaugePointer), true)]
+    public class GaugePointerDrawer : PropertyDrawer
+    {
+        private Dictionary<string, bool> m_Toggle = new Dictionary<string, bool>();
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty show = prop.FindPropertyRelative("m_Show");
+            SerializedProperty m_Width = prop.FindPropertyRelative("m_Width");
+            SerializedProperty m_Length = prop.FindPropertyRelative("m_Length");
+
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_Toggle, prop, "Gauge Pointer", show, false);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (ChartEditorHelper.IsToggle(m_Toggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_Width);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Length);
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            if (ChartEditorHelper.IsToggle(m_Toggle, prop))
+            {
+                return 3 * EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
+            }
+            else
+            {
+                return 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+            }
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/GaugePointerDrawer.cs.meta

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

Assets/XCharts/Editor/PropertyDrawers/IconStyleDrawer.cs

@@ -0,0 +1,67 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(IconStyle), true)]
+    public class IconStyleDrawer : PropertyDrawer
+    {
+        private Dictionary<string, bool> m_IconStyleToggle = new Dictionary<string, bool>();
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty m_Show = prop.FindPropertyRelative("m_Show");
+            SerializedProperty m_Layer = prop.FindPropertyRelative("m_Layer");
+            SerializedProperty m_Sprite = prop.FindPropertyRelative("m_Sprite");
+            SerializedProperty m_Color = prop.FindPropertyRelative("m_Color");
+            SerializedProperty m_Width = prop.FindPropertyRelative("m_Width");
+            SerializedProperty m_Height = prop.FindPropertyRelative("m_Height");
+            SerializedProperty m_Offset = prop.FindPropertyRelative("m_Offset");
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_IconStyleToggle, prop, null, m_Show, false);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (ChartEditorHelper.IsToggle(m_IconStyleToggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+
+                EditorGUI.PropertyField(drawRect, m_Layer);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Sprite);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Color);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Width);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Height);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Offset);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_Offset);
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            if (ChartEditorHelper.IsToggle(m_IconStyleToggle, prop))
+            {
+                var hight = 6 * EditorGUIUtility.singleLineHeight + 6 * EditorGUIUtility.standardVerticalSpacing;
+                hight += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Offset"));
+                hight += EditorGUIUtility.standardVerticalSpacing;
+                return hight;
+            }
+            else
+            {
+                return EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            }
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/IconStyleDrawer.cs.meta

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

Assets/XCharts/Editor/PropertyDrawers/ItemStyleDrawer.cs

@@ -14,7 +14,9 @@ namespace XCharts
     [CustomPropertyDrawer(typeof(ItemStyle), true)]
     public class ItemStyleDrawer : PropertyDrawer
     {
+        private int m_CornerRadius = 0;
         private Dictionary<string, bool> m_ItemStyleToggle = new Dictionary<string, bool>();
+        private Dictionary<string, bool> m_CornerRadiusToggle = new Dictionary<string, bool>();
 
         public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
         {
@@ -22,10 +24,18 @@ namespace XCharts
             drawRect.height = EditorGUIUtility.singleLineHeight;
             SerializedProperty show = prop.FindPropertyRelative("m_Show");
             SerializedProperty m_Color = prop.FindPropertyRelative("m_Color");
+            SerializedProperty m_ToColor = prop.FindPropertyRelative("m_ToColor");
+            SerializedProperty m_BackgroundColor = prop.FindPropertyRelative("m_BackgroundColor");
+            SerializedProperty m_BackgroundWidth = prop.FindPropertyRelative("m_BackgroundWidth");
+            SerializedProperty m_CenterColor = prop.FindPropertyRelative("m_CenterColor");
+            SerializedProperty m_CenterGap = prop.FindPropertyRelative("m_CenterGap");
             SerializedProperty m_BorderType = prop.FindPropertyRelative("m_BorderType");
             SerializedProperty m_BorderWidth = prop.FindPropertyRelative("m_BorderWidth");
             SerializedProperty m_BorderColor = prop.FindPropertyRelative("m_BorderColor");
             SerializedProperty m_Opacity = prop.FindPropertyRelative("m_Opacity");
+            SerializedProperty m_TooltipFormatter = prop.FindPropertyRelative("m_TooltipFormatter");
+            SerializedProperty m_NumericFormatter = prop.FindPropertyRelative("m_NumericFormatter");
+            SerializedProperty m_CornerRadius = prop.FindPropertyRelative("m_CornerRadius");
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_ItemStyleToggle, prop, "Item Style", show, false);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             if (ChartEditorHelper.IsToggle(m_ItemStyleToggle, prop))
@@ -33,6 +43,16 @@ namespace XCharts
                 ++EditorGUI.indentLevel;
                 EditorGUI.PropertyField(drawRect, m_Color);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_ToColor);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_BackgroundColor);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_BackgroundWidth);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_CenterColor);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_CenterGap);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_BorderType);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_BorderWidth);
@@ -41,6 +61,16 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Opacity);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_TooltipFormatter);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_NumericFormatter);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                ChartEditorHelper.MakeFoldout(ref drawRect, ref m_CornerRadiusToggle, m_CornerRadius, "Corner Radius", null, false);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                if (ChartEditorHelper.IsToggle(m_CornerRadiusToggle, m_CornerRadius))
+                {
+                    ChartEditorHelper.MakeList(ref drawRect, ref this.m_CornerRadius, m_CornerRadius, false, false);
+                }
                 --EditorGUI.indentLevel;
             }
         }
@@ -50,7 +80,12 @@ namespace XCharts
             float height = 0;
             if (ChartEditorHelper.IsToggle(m_ItemStyleToggle, prop))
             {
-                height += 6 * EditorGUIUtility.singleLineHeight + 5 * EditorGUIUtility.standardVerticalSpacing;
+                height += 14 * EditorGUIUtility.singleLineHeight + 13 * EditorGUIUtility.standardVerticalSpacing;
+                var m_CornerRadius = prop.FindPropertyRelative("m_CornerRadius");
+                if (ChartEditorHelper.IsToggle(m_CornerRadiusToggle, m_CornerRadius))
+                {
+                    height += 4 * EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
+                }
             }
             else
             {

Assets/XCharts/Editor/PropertyDrawers/LegendDrawer.cs

@@ -14,7 +14,9 @@ namespace XCharts
     public class LegendDrawer : PropertyDrawer
     {
         private bool m_DataFoldout = false;
+        private bool m_IconsFoldout = false;
         private int m_DataSize = 0;
+        private int m_IconsSize = 0;
         private bool m_ShowJsonDataArea = false;
         private string m_JsonDataAreaText;
         private bool m_LegendModuleToggle = false;
@@ -30,9 +32,11 @@ namespace XCharts
             SerializedProperty itemWidth = prop.FindPropertyRelative("m_ItemWidth");
             SerializedProperty itemHeight = prop.FindPropertyRelative("m_ItemHeight");
             SerializedProperty itemGap = prop.FindPropertyRelative("m_ItemGap");
-            SerializedProperty itemFontSize = prop.FindPropertyRelative("m_ItemFontSize");
+            SerializedProperty m_ItemAutoColor = prop.FindPropertyRelative("m_ItemAutoColor");
             SerializedProperty m_Formatter = prop.FindPropertyRelative("m_Formatter");
             SerializedProperty m_Data = prop.FindPropertyRelative("m_Data");
+            SerializedProperty m_Icons = prop.FindPropertyRelative("m_Icons");
+            SerializedProperty m_TextStyle = prop.FindPropertyRelative("m_TextStyle");
 
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_LegendModuleToggle, "Legend", show);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
@@ -45,7 +49,7 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, itemGap);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, itemFontSize);
+                EditorGUI.PropertyField(drawRect, m_ItemAutoColor);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_SelectedMode);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
@@ -57,12 +61,20 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 drawRect.width = EditorGUIUtility.labelWidth + 10;
                 m_DataFoldout = EditorGUI.Foldout(drawRect, m_DataFoldout, "Data");
-                ChartEditorHelper.MakeJsonData(ref drawRect, ref m_ShowJsonDataArea, ref m_JsonDataAreaText, prop,pos.width);
+                ChartEditorHelper.MakeJsonData(ref drawRect, ref m_ShowJsonDataArea, ref m_JsonDataAreaText, prop, pos.width);
                 drawRect.width = pos.width;
                 if (m_DataFoldout)
                 {
                     ChartEditorHelper.MakeList(ref drawRect, ref m_DataSize, m_Data);
                 }
+                m_IconsFoldout = EditorGUI.Foldout(drawRect, m_IconsFoldout, "Icons");
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                if (m_IconsFoldout)
+                {
+                    ChartEditorHelper.MakeList(ref drawRect, ref m_IconsSize, m_Icons);
+                }
+                 EditorGUI.PropertyField(drawRect, m_TextStyle);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_TextStyle);
                 --EditorGUI.indentLevel;
             }
         }
@@ -73,7 +85,7 @@ namespace XCharts
             if (m_LegendModuleToggle)
             {
                 SerializedProperty location = prop.FindPropertyRelative("m_Location");
-                height += 7 * EditorGUIUtility.singleLineHeight + 6 * EditorGUIUtility.standardVerticalSpacing;
+                height += 8 * EditorGUIUtility.singleLineHeight + 7 * EditorGUIUtility.standardVerticalSpacing;
                 height += EditorGUI.GetPropertyHeight(location);
                 height += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 if (m_DataFoldout)
@@ -83,6 +95,14 @@ namespace XCharts
                     height += num * EditorGUIUtility.singleLineHeight + (num - 1) * EditorGUIUtility.standardVerticalSpacing;
                     height += EditorGUIUtility.standardVerticalSpacing;
                 }
+                if (m_IconsFoldout)
+                {
+                    SerializedProperty m_Icons = prop.FindPropertyRelative("m_Icons");
+                    int num = m_Icons.arraySize + 1;
+                    height += num * EditorGUIUtility.singleLineHeight + (num - 1) * EditorGUIUtility.standardVerticalSpacing;
+                    height += EditorGUIUtility.standardVerticalSpacing;
+                }
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_TextStyle"));
             }
             if (m_ShowJsonDataArea)
             {

Assets/XCharts/Editor/PropertyDrawers/LocationDrawer.cs

@@ -25,69 +25,78 @@ namespace XCharts
             EditorGUI.PropertyField(drawRect, align, new GUIContent("Location"));
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             ++EditorGUI.indentLevel;
-            switch ((Location.Align)align.enumValueIndex)
-            {
-                case Location.Align.TopCenter:
-                    EditorGUI.PropertyField(drawRect, top);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    break;
-                case Location.Align.TopLeft:
-                    EditorGUI.PropertyField(drawRect, top);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, left);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    break;
-                case Location.Align.TopRight:
-                    EditorGUI.PropertyField(drawRect, top);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, right);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    break;
-                case Location.Align.BottomCenter:
-                    EditorGUI.PropertyField(drawRect, bottom);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    break;
-                case Location.Align.BottomLeft:
-                    EditorGUI.PropertyField(drawRect, bottom);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, left);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    break;
-                case Location.Align.BottomRight:
-                    EditorGUI.PropertyField(drawRect, bottom);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, right);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    break;
-                case Location.Align.Center:
-                    break;
-                case Location.Align.CenterLeft:
-                    EditorGUI.PropertyField(drawRect, left);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    break;
-                case Location.Align.CenterRight:
-                    EditorGUI.PropertyField(drawRect, right);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    break;
-            }
+            EditorGUI.PropertyField(drawRect, top);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            EditorGUI.PropertyField(drawRect, bottom);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            EditorGUI.PropertyField(drawRect, left);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            EditorGUI.PropertyField(drawRect, right);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            // switch ((Location.Align)align.enumValueIndex)
+            // {
+            //     case Location.Align.TopCenter:
+            //         EditorGUI.PropertyField(drawRect, top);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         break;
+            //     case Location.Align.TopLeft:
+            //         EditorGUI.PropertyField(drawRect, top);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         EditorGUI.PropertyField(drawRect, left);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         break;
+            //     case Location.Align.TopRight:
+            //         EditorGUI.PropertyField(drawRect, top);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         EditorGUI.PropertyField(drawRect, right);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         break;
+            //     case Location.Align.BottomCenter:
+            //         EditorGUI.PropertyField(drawRect, bottom);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         break;
+            //     case Location.Align.BottomLeft:
+            //         EditorGUI.PropertyField(drawRect, bottom);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         EditorGUI.PropertyField(drawRect, left);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         break;
+            //     case Location.Align.BottomRight:
+            //         EditorGUI.PropertyField(drawRect, bottom);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         EditorGUI.PropertyField(drawRect, right);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         break;
+            //     case Location.Align.Center:
+            //         break;
+            //     case Location.Align.CenterLeft:
+            //         EditorGUI.PropertyField(drawRect, left);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         break;
+            //     case Location.Align.CenterRight:
+            //         EditorGUI.PropertyField(drawRect, right);
+            //         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            //         break;
+            // }
             --EditorGUI.indentLevel;
         }
 
         public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
         {
-            SerializedProperty align = prop.FindPropertyRelative("m_Align");
-            switch ((Location.Align)align.enumValueIndex)
-            {
-                case Location.Align.Center:
-                    return 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
-                case Location.Align.TopCenter:
-                case Location.Align.BottomCenter:
-                case Location.Align.CenterLeft:
-                case Location.Align.CenterRight:
-                    return 2 * EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
-                default:
-                    return 3 * EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
-            }
+            return 5 * EditorGUIUtility.singleLineHeight + 4 * EditorGUIUtility.standardVerticalSpacing;
+            // SerializedProperty align = prop.FindPropertyRelative("m_Align");
+            // switch ((Location.Align)align.enumValueIndex)
+            // {
+            //     case Location.Align.Center:
+            //         return 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+            //     case Location.Align.TopCenter:
+            //     case Location.Align.BottomCenter:
+            //     case Location.Align.CenterLeft:
+            //     case Location.Align.CenterRight:
+            //         return 2 * EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
+            //     default:
+            //         return 3 * EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
+            // }
         }
     }
 }

Assets/XCharts/Editor/PropertyDrawers/RadarDrawer.cs

@@ -19,10 +19,11 @@ namespace XCharts
         SerializedProperty m_Radius;
         SerializedProperty m_SplitNumber;
         SerializedProperty m_Center;
-        SerializedProperty m_LineStyle;
+        SerializedProperty m_SplitLine;
         SerializedProperty m_SplitArea;
         SerializedProperty m_Indicator;
         SerializedProperty m_IndicatorGap;
+        SerializedProperty m_CeilRate;
         SerializedProperty m_IndicatorList;
 
         private Dictionary<string, bool> m_RadarModuleToggle = new Dictionary<string, bool>();
@@ -39,10 +40,11 @@ namespace XCharts
             m_Radius = prop.FindPropertyRelative("m_Radius");
             m_SplitNumber = prop.FindPropertyRelative("m_SplitNumber");
             m_Center = prop.FindPropertyRelative("m_Center");
-            m_LineStyle = prop.FindPropertyRelative("m_LineStyle");
+            m_SplitLine = prop.FindPropertyRelative("m_SplitLine");
             m_SplitArea = prop.FindPropertyRelative("m_SplitArea");
             m_Indicator = prop.FindPropertyRelative("m_Indicator");
             m_IndicatorGap = prop.FindPropertyRelative("m_IndicatorGap");
+            m_CeilRate = prop.FindPropertyRelative("m_CeilRate");
             m_IndicatorList = prop.FindPropertyRelative("m_IndicatorList");
         }
 
@@ -72,10 +74,7 @@ namespace XCharts
                 var tempWidth = (pos.width - startX + 35) / 2;
                 var centerXRect = new Rect(startX, drawRect.y, tempWidth, drawRect.height);
                 var centerYRect = new Rect(centerXRect.x + tempWidth - 20, drawRect.y, tempWidth, drawRect.height);
-                while (m_Center.arraySize < 2)
-                {
-                    m_Center.InsertArrayElementAtIndex(m_Center.arraySize);
-                }
+                while (m_Center.arraySize < 2) m_Center.arraySize++;
                 EditorGUI.PropertyField(centerXRect, m_Center.GetArrayElementAtIndex(0), GUIContent.none);
                 EditorGUI.PropertyField(centerYRect, m_Center.GetArrayElementAtIndex(1), GUIContent.none);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
@@ -84,9 +83,11 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_SplitNumber);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_CeilRate);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
 
-                EditorGUI.PropertyField(drawRect, m_LineStyle);
-                drawRect.y += EditorGUI.GetPropertyHeight(m_LineStyle);
+                EditorGUI.PropertyField(drawRect, m_SplitLine);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_SplitLine);
                 EditorGUI.PropertyField(drawRect, m_SplitArea);
                 drawRect.y += EditorGUI.GetPropertyHeight(m_SplitArea);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
@@ -109,10 +110,10 @@ namespace XCharts
             int propNum = 1;
             if (ChartEditorHelper.IsToggle(m_RadarModuleToggle, prop))
             {
-                propNum += 7;
+                propNum += 8;
                 if (m_IndicatorJsonAreaToggle) propNum += 4;
                 float height = propNum * EditorGUIUtility.singleLineHeight + (propNum - 1) * EditorGUIUtility.standardVerticalSpacing;
-                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineStyle"));
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_SplitLine"));
                 height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_SplitArea"));
 
                 if (ChartEditorHelper.IsToggle(m_IndicatorToggle, prop))

Assets/XCharts/Editor/PropertyDrawers/SerieDrawer.cs

@@ -28,6 +28,7 @@ namespace XCharts
             SerializedProperty name = prop.FindPropertyRelative("m_Name");
             SerializedProperty stack = prop.FindPropertyRelative("m_Stack");
             SerializedProperty m_AxisIndex = prop.FindPropertyRelative("m_AxisIndex");
+            SerializedProperty m_RadarType = prop.FindPropertyRelative("m_RadarType");
             SerializedProperty m_RadarIndex = prop.FindPropertyRelative("m_RadarIndex");
             SerializedProperty m_MinShow = prop.FindPropertyRelative("m_MinShow");
             SerializedProperty m_MaxShow = prop.FindPropertyRelative("m_MaxShow");
@@ -58,6 +59,25 @@ namespace XCharts
             SerializedProperty m_DataDimension = prop.FindPropertyRelative("m_ShowDataDimension");
             SerializedProperty m_ShowDataName = prop.FindPropertyRelative("m_ShowDataName");
             SerializedProperty m_ShowDataIcon = prop.FindPropertyRelative("m_ShowDataIcon");
+            SerializedProperty m_Min = prop.FindPropertyRelative("m_Min");
+            SerializedProperty m_Max = prop.FindPropertyRelative("m_Max");
+            SerializedProperty m_StartAngle = prop.FindPropertyRelative("m_StartAngle");
+            SerializedProperty m_EndAngle = prop.FindPropertyRelative("m_EndAngle");
+            SerializedProperty m_RingGap = prop.FindPropertyRelative("m_RingGap");
+            SerializedProperty m_SplitNumber = prop.FindPropertyRelative("m_SplitNumber");
+            SerializedProperty m_Clockwise = prop.FindPropertyRelative("m_Clockwise");
+            SerializedProperty m_RoundCap = prop.FindPropertyRelative("m_RoundCap");
+            SerializedProperty m_GaugeType = prop.FindPropertyRelative("m_GaugeType");
+            SerializedProperty m_GaugeAxis = prop.FindPropertyRelative("m_GaugeAxis");
+            SerializedProperty m_GaugePointer = prop.FindPropertyRelative("m_GaugePointer");
+            SerializedProperty m_TitleStyle = prop.FindPropertyRelative("m_TitleStyle");
+            SerializedProperty m_Clip = prop.FindPropertyRelative("m_Clip");
+            SerializedProperty m_Ignore = prop.FindPropertyRelative("m_Ignore");
+            SerializedProperty m_IgnoreValue = prop.FindPropertyRelative("m_IgnoreValue");
+            SerializedProperty m_ShowAsPositiveNumber = prop.FindPropertyRelative("m_ShowAsPositiveNumber");
+            SerializedProperty m_Large = prop.FindPropertyRelative("m_Large");
+            SerializedProperty m_LargeThreshold = prop.FindPropertyRelative("m_LargeThreshold");
+            SerializedProperty m_AvoidLabelOverlap = prop.FindPropertyRelative("m_AvoidLabelOverlap");
             SerializedProperty m_Datas = prop.FindPropertyRelative("m_Data");
 
             int index = InitToggle(prop);
@@ -65,8 +85,10 @@ namespace XCharts
             var toggle = ChartEditorHelper.MakeFoldout(ref drawRect, ref m_SerieModuleToggle, prop, moduleName, show);
             if (!toggle)
             {
-                drawRect.x = EditorGUIUtility.labelWidth - (EditorGUI.indentLevel - 1) * 15 - 2 + 20;
-                drawRect.width = pos.width - drawRect.x + 15;
+                var orderButton = 46;
+                var gap = 4;
+                drawRect.x += EditorGUIUtility.labelWidth + gap;
+                drawRect.width = pos.width - drawRect.x + ChartEditorHelper.BOOL_WIDTH - orderButton;
                 EditorGUI.PropertyField(drawRect, type, GUIContent.none);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             }
@@ -82,87 +104,225 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, name);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, stack);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                if (serieType == SerieType.Radar)
-                {
-                    EditorGUI.PropertyField(drawRect, m_RadarIndex);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                }
-                else
-                {
-                    EditorGUI.PropertyField(drawRect, m_AxisIndex);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                }
-                EditorGUI.PropertyField(drawRect, m_MinShow);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_MaxShow);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_MaxCache);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                if (m_MinShow.intValue < 0) m_MinShow.intValue = 0;
-                if (m_MinShow.intValue < 0) m_MinShow.intValue = 0;
-                if (m_MaxCache.intValue < 0) m_MaxCache.intValue = 0;
-                if (serieType == SerieType.Line)
-                {
-                    EditorGUI.PropertyField(drawRect, m_LineType);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, m_SampleDist);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, m_SampleType);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, m_SampleAverage);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                }
-                if (serieType == SerieType.Line
-                    || serieType == SerieType.Scatter
-                    || serieType == SerieType.EffectScatter
-                    || serieType == SerieType.Radar)
-                {
-                    EditorGUI.PropertyField(drawRect, m_Symbol);
-                    drawRect.y += EditorGUI.GetPropertyHeight(m_Symbol);
-                }
-                if (serieType == SerieType.Bar)
-                {
-                    EditorGUI.PropertyField(drawRect, m_BarType);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, m_BarPercentStack);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, m_BarWidth);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, m_BarGap);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, m_BarZebraWidth);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, m_BarZebraGap);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                }
-                if (serieType == SerieType.Pie)
-                {
-                    EditorGUI.PropertyField(drawRect, m_RoseType);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                    EditorGUI.PropertyField(drawRect, m_Space);
-                    drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
 
-                    ChartEditorHelper.MakeTwoField(ref drawRect, pos.width, m_Center, "Center");
-                    ChartEditorHelper.MakeTwoField(ref drawRect, pos.width, m_Radius, "Radius");
-                }
-
-                EditorGUI.PropertyField(drawRect, m_LineStyle);
-                drawRect.y += EditorGUI.GetPropertyHeight(m_LineStyle);
-                if (serieType == SerieType.Line)
+                switch (serieType)
                 {
-                    EditorGUI.PropertyField(drawRect, m_LineArrow);
-                    drawRect.y += EditorGUI.GetPropertyHeight(m_LineArrow);
+                    case SerieType.Line:
+                        EditorGUI.PropertyField(drawRect, stack);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_AxisIndex);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_MinShow);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_MaxShow);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_MaxCache);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        if (m_MinShow.intValue < 0) m_MinShow.intValue = 0;
+                        if (m_MinShow.intValue < 0) m_MinShow.intValue = 0;
+                        if (m_MaxCache.intValue < 0) m_MaxCache.intValue = 0;
+                        EditorGUI.PropertyField(drawRect, m_LineType);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_SampleDist);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_SampleType);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_SampleAverage);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Clip);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Ignore);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_IgnoreValue);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_ShowAsPositiveNumber);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Large);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_LargeThreshold);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Symbol);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Symbol);
+                        EditorGUI.PropertyField(drawRect, m_LineStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_LineStyle);
+                        EditorGUI.PropertyField(drawRect, m_LineArrow);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_LineArrow);
+                        EditorGUI.PropertyField(drawRect, m_ItemStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
+                        EditorGUI.PropertyField(drawRect, m_AreaStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_AreaStyle);
+                        EditorGUI.PropertyField(drawRect, m_Label);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
+                        EditorGUI.PropertyField(drawRect, m_Emphasis);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
+                        break;
+                    case SerieType.Bar:
+                        EditorGUI.PropertyField(drawRect, stack);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_AxisIndex);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_MinShow);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_MaxShow);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_MaxCache);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        if (m_MinShow.intValue < 0) m_MinShow.intValue = 0;
+                        if (m_MinShow.intValue < 0) m_MinShow.intValue = 0;
+                        if (m_MaxCache.intValue < 0) m_MaxCache.intValue = 0;
+                        EditorGUI.PropertyField(drawRect, m_BarType);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_BarPercentStack);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_BarWidth);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_BarGap);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_BarZebraWidth);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_BarZebraGap);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Clip);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Ignore);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_IgnoreValue);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_ShowAsPositiveNumber);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Large);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_LargeThreshold);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_ItemStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
+                        EditorGUI.PropertyField(drawRect, m_Label);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
+                        EditorGUI.PropertyField(drawRect, m_Emphasis);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
+                        break;
+                    case SerieType.Pie:
+                        EditorGUI.PropertyField(drawRect, m_RoseType);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Space);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        ChartEditorHelper.MakeTwoField(ref drawRect, pos.width, m_Center, "Center");
+                        ChartEditorHelper.MakeTwoField(ref drawRect, pos.width, m_Radius, "Radius");
+                        EditorGUI.PropertyField(drawRect, m_RoundCap);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Ignore);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_IgnoreValue);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_AvoidLabelOverlap);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_ItemStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
+                        EditorGUI.PropertyField(drawRect, m_Label);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
+                        EditorGUI.PropertyField(drawRect, m_Emphasis);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
+                        break;
+                    case SerieType.Ring:
+                        ChartEditorHelper.MakeTwoField(ref drawRect, pos.width, m_Center, "Center");
+                        ChartEditorHelper.MakeTwoField(ref drawRect, pos.width, m_Radius, "Radius");
+                        EditorGUI.PropertyField(drawRect, m_StartAngle);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_RingGap);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_RoundCap);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Clockwise);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_TitleStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_TitleStyle);
+                        EditorGUI.PropertyField(drawRect, m_ItemStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
+                        EditorGUI.PropertyField(drawRect, m_Label);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
+                        EditorGUI.PropertyField(drawRect, m_Emphasis);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
+                        break;
+                    case SerieType.Radar:
+                        EditorGUI.PropertyField(drawRect, m_RadarType);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_RadarIndex);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Symbol);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Symbol);
+                        EditorGUI.PropertyField(drawRect, m_LineStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_LineStyle);
+                        EditorGUI.PropertyField(drawRect, m_ItemStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
+                        EditorGUI.PropertyField(drawRect, m_AreaStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_AreaStyle);
+                        EditorGUI.PropertyField(drawRect, m_Label);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
+                        EditorGUI.PropertyField(drawRect, m_Emphasis);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
+                        break;
+                    case SerieType.Scatter:
+                    case SerieType.EffectScatter:
+                        EditorGUI.PropertyField(drawRect, m_Clip);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Symbol);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Symbol);
+                        EditorGUI.PropertyField(drawRect, m_ItemStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
+                        EditorGUI.PropertyField(drawRect, m_Label);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
+                        EditorGUI.PropertyField(drawRect, m_Emphasis);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
+                        break;
+                    case SerieType.Heatmap:
+                        EditorGUI.PropertyField(drawRect, m_Ignore);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_IgnoreValue);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_ItemStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
+                        EditorGUI.PropertyField(drawRect, m_Label);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
+                        EditorGUI.PropertyField(drawRect, m_Emphasis);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
+                        break;
+                    case SerieType.Gauge:
+                        EditorGUI.PropertyField(drawRect, m_GaugeType);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        ChartEditorHelper.MakeTwoField(ref drawRect, pos.width, m_Center, "Center");
+                        //ChartEditorHelper.MakeTwoField(ref drawRect, pos.width, m_Radius, "Radius");
+                        EditorGUI.PropertyField(drawRect, m_Radius.GetArrayElementAtIndex(0), new GUIContent("Radius"));
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Min);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_Max);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_StartAngle);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_EndAngle);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_SplitNumber);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        if (m_SplitNumber.intValue > 36)
+                        {
+                            m_SplitNumber.intValue = 36;
+                        }
+                        EditorGUI.PropertyField(drawRect, m_RoundCap);
+                        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                        EditorGUI.PropertyField(drawRect, m_TitleStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_TitleStyle);
+                        EditorGUI.PropertyField(drawRect, m_GaugeAxis);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_GaugeAxis);
+                        EditorGUI.PropertyField(drawRect, m_GaugePointer);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_GaugePointer);
+                        EditorGUI.PropertyField(drawRect, m_ItemStyle);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
+                        EditorGUI.PropertyField(drawRect, m_Label);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
+                        EditorGUI.PropertyField(drawRect, m_Emphasis);
+                        drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
+                        break;
                 }
-                EditorGUI.PropertyField(drawRect, m_ItemStyle);
-                drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
-                EditorGUI.PropertyField(drawRect, m_AreaStyle);
-                drawRect.y += EditorGUI.GetPropertyHeight(m_AreaStyle);
-                EditorGUI.PropertyField(drawRect, m_Label);
-                drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
-                EditorGUI.PropertyField(drawRect, m_Emphasis);
-                drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
                 EditorGUI.PropertyField(drawRect, m_Animation);
                 drawRect.y += EditorGUI.GetPropertyHeight(m_Animation);
                 drawRect.width = EditorGUIUtility.labelWidth + 10;
@@ -173,15 +333,22 @@ namespace XCharts
                 {
                     EditorGUI.indentLevel++;
 
-                    float nameWid = 40;
+                    float nameWid = 45;
+#if UNITY_2019_3_OR_NEWER
+                var gap = 2;
+                var namegap = 3;
+#else
+                    var gap = 0;
+                    var namegap = 0;
+#endif
                     EditorGUI.PropertyField(new Rect(drawRect.x, drawRect.y, pos.width - 2 * nameWid - 2, pos.height), m_DataDimension);
-                    var nameRect = new Rect(pos.width - 2 * nameWid + 14, drawRect.y, nameWid, pos.height);
+                    var nameRect = new Rect(pos.width - 2 * nameWid + 14 + gap, drawRect.y, nameWid - gap, pos.height);
                     if (GUI.Button(nameRect, new GUIContent("Name")))
                     {
                         m_ShowDataName.boolValue = !m_ShowDataName.boolValue;
                     }
-                    var iconRect = new Rect(pos.width - nameWid + 14, drawRect.y, nameWid, pos.height);
-                    if (GUI.Button(iconRect, new GUIContent("Icon")))
+                    var iconRect = new Rect(pos.width - nameWid + 14, drawRect.y, nameWid + namegap, pos.height);
+                    if (GUI.Button(iconRect, new GUIContent("More...")))
                     {
                         m_ShowDataIcon.boolValue = !m_ShowDataIcon.boolValue;
                     }
@@ -199,10 +366,8 @@ namespace XCharts
                     bool showSelected = (serieType == SerieType.Pie);
                     if (listSize != m_Datas.arraySize)
                     {
-                        while (listSize > m_Datas.arraySize)
-                            m_Datas.InsertArrayElementAtIndex(m_Datas.arraySize);
-                        while (listSize < m_Datas.arraySize)
-                            m_Datas.DeleteArrayElementAtIndex(m_Datas.arraySize - 1);
+                        while (listSize > m_Datas.arraySize) m_Datas.arraySize++;
+                        while (listSize < m_Datas.arraySize) m_Datas.arraySize--;
                     }
                     if (listSize > 30)
                     {
@@ -225,6 +390,7 @@ namespace XCharts
                             DrawDataElement(ref drawRect, dimension, m_Datas, showName, showIcon, showSelected, i, pos.width);
                         }
                     }
+                    drawRect.y += EditorGUIUtility.standardVerticalSpacing;
                     EditorGUI.indentLevel--;
                 }
                 --EditorGUI.indentLevel;
@@ -232,7 +398,7 @@ namespace XCharts
         }
 
         private void DrawDataElement(ref Rect drawRect, int dimension, SerializedProperty m_Datas, bool showName,
-            bool showIconDetail, bool showSelected, int index, float currentWidth)
+            bool showDetail, bool showSelected, int index, float currentWidth)
         {
             var lastX = drawRect.x;
             var lastWid = drawRect.width;
@@ -248,12 +414,16 @@ namespace XCharts
             if (fieldCount <= 1)
             {
                 while (2 > data.arraySize)
-                    data.InsertArrayElementAtIndex(data.arraySize);
+                {
+                    var value = data.arraySize == 0 ? index : 0;
+                    data.arraySize++;
+                    data.GetArrayElementAtIndex(data.arraySize - 1).floatValue = value;
+                }
                 SerializedProperty element = data.GetArrayElementAtIndex(1);
                 if (showSelected)
                 {
                     drawRect.width = drawRect.width - 18;
-                    EditorGUI.PropertyField(drawRect, element);
+                    EditorGUI.PropertyField(drawRect, element, new GUIContent("Element " + index));
                     drawRect.x = currentWidth - 45;
                     EditorGUI.PropertyField(drawRect, selected, GUIContent.none);
                     drawRect.x = lastX;
@@ -261,22 +431,32 @@ namespace XCharts
                 }
                 else
                 {
-                    EditorGUI.PropertyField(drawRect, element);
+                    EditorGUI.PropertyField(drawRect, element, new GUIContent("Element " + index));
                 }
                 drawRect.y += EditorGUI.GetPropertyHeight(element) + EditorGUIUtility.standardVerticalSpacing;
             }
             else
             {
+#if UNITY_2019_3_OR_NEWER
+                var gap = 2;
+                var namegap = 3;
+#else
+                var gap = 0;
+                var namegap = 0;
+#endif
                 EditorGUI.LabelField(drawRect, "Element " + index);
-                var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * 15;
+                var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * 15 + gap;
                 var dataWidTotal = (currentWidth - (startX + 20.5f + 1));
                 var dataWid = dataWidTotal / fieldCount;
                 var xWid = dataWid - 4;
                 for (int i = 0; i < dimension; i++)
                 {
-                    if (i >= data.arraySize - 1)
+                    var dataCount = i < 1 ? 2 : i + 1;
+                    while (dataCount > data.arraySize)
                     {
-                        data.InsertArrayElementAtIndex(data.arraySize);
+                        var value = data.arraySize == 0 ? index : 0;
+                        data.arraySize++;
+                        data.GetArrayElementAtIndex(data.arraySize - 1).floatValue = value;
                     }
                     drawRect.x = startX + i * xWid;
                     drawRect.width = dataWid + 40;
@@ -286,7 +466,7 @@ namespace XCharts
                 if (showName)
                 {
                     drawRect.x = startX + (fieldCount - 1) * xWid;
-                    drawRect.width = dataWid + 40;
+                    drawRect.width = dataWid + 40 + dimension * namegap;
                     EditorGUI.PropertyField(drawRect, sereName, GUIContent.none);
                 }
 
@@ -296,37 +476,33 @@ namespace XCharts
                 EditorGUIUtility.fieldWidth = lastFieldWid;
                 EditorGUIUtility.labelWidth = lastLabelWid;
             }
-            if (showIconDetail)
+            if (showDetail)
             {
-                EditorGUI.indentLevel++;
-                var m_ShowIcon = serieData.FindPropertyRelative("m_ShowIcon");
-                var m_IconImage = serieData.FindPropertyRelative("m_IconImage");
-                var m_IconColor = serieData.FindPropertyRelative("m_IconColor");
-                var m_IconWidth = serieData.FindPropertyRelative("m_IconWidth");
-                var m_IconHeight = serieData.FindPropertyRelative("m_IconHeight");
-                var m_IconOffset = serieData.FindPropertyRelative("m_IconOffset");
-                EditorGUI.PropertyField(drawRect, m_ShowIcon);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_IconImage);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_IconColor);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_IconWidth);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_IconHeight);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-
-                EditorGUI.LabelField(drawRect, "Icon Offset");
-                var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * 15;
-                var tempWidth = (drawRect.width - startX + 72) / 2;
-                var centerXRect = new Rect(startX, drawRect.y, tempWidth, drawRect.height);
-                var centerYRect = new Rect(centerXRect.x + tempWidth - 58, drawRect.y, tempWidth, drawRect.height);
-                var x = EditorGUI.FloatField(centerXRect, m_IconOffset.vector3Value.x);
-                var y = EditorGUI.FloatField(centerYRect, m_IconOffset.vector3Value.y);
-                m_IconOffset.vector3Value = new Vector3(x, y);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-
-                EditorGUI.indentLevel--;
+                EditorGUI.indentLevel += 2;
+                var m_Icon = serieData.FindPropertyRelative("m_IconStyle");
+                var m_EnableLabel = serieData.FindPropertyRelative("m_EnableLabel");
+                var m_Label = serieData.FindPropertyRelative("m_Label");
+                var m_EnableItemStyle = serieData.FindPropertyRelative("m_EnableItemStyle");
+                var m_ItemStyle = serieData.FindPropertyRelative("m_ItemStyle");
+                var m_EnableEmphasis = serieData.FindPropertyRelative("m_EnableEmphasis");
+                var m_Emphasis = serieData.FindPropertyRelative("m_Emphasis");
+                var m_EnableSymbol = serieData.FindPropertyRelative("m_EnableSymbol");
+                var m_Symbol = serieData.FindPropertyRelative("m_Symbol");
+                EditorGUI.PropertyField(drawRect, m_Icon);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_Icon);
+                EditorGUI.PropertyField(drawRect, m_Symbol);
+                ChartEditorHelper.MakeBool(drawRect, m_EnableSymbol, 1, "(enable)");
+                drawRect.y += EditorGUI.GetPropertyHeight(m_Symbol);
+                EditorGUI.PropertyField(drawRect, m_Label);
+                ChartEditorHelper.MakeBool(drawRect, m_EnableLabel, 1, "(enable)");
+                drawRect.y += EditorGUI.GetPropertyHeight(m_Label);
+                EditorGUI.PropertyField(drawRect, m_ItemStyle);
+                ChartEditorHelper.MakeBool(drawRect, m_EnableItemStyle, 1, "(enable)");
+                drawRect.y += EditorGUI.GetPropertyHeight(m_ItemStyle);
+                EditorGUI.PropertyField(drawRect, m_Emphasis);
+                ChartEditorHelper.MakeBool(drawRect, m_EnableEmphasis, 1, "(enable)");
+                drawRect.y += EditorGUI.GetPropertyHeight(m_Emphasis);
+                EditorGUI.indentLevel -= 2;
             }
         }
 
@@ -334,54 +510,113 @@ namespace XCharts
         {
             float height = 0;
             int index = InitToggle(prop);
-            if (!m_SerieModuleToggle[prop.propertyPath])
+            if (!m_SerieModuleToggle.ContainsKey(prop.propertyPath) || !m_SerieModuleToggle[prop.propertyPath])
             {
                 return EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             }
             else
             {
-                height += 9 * EditorGUIUtility.singleLineHeight + 8 * EditorGUIUtility.standardVerticalSpacing;
-                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineStyle"));
-                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_ItemStyle"));
-                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_AreaStyle"));
-                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Label"));
-                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Emphasis"));
-                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Animation"));
                 SerializedProperty type = prop.FindPropertyRelative("m_Type");
                 var serieType = (SerieType)type.enumValueIndex;
-                if (serieType == SerieType.Line
-                    || serieType == SerieType.Scatter
-                    || serieType == SerieType.EffectScatter
-                    || serieType == SerieType.Radar)
+                switch (serieType)
                 {
-
-                    height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Symbol"));
-                }
-                if (serieType == SerieType.Pie)
-                {
-                    height += 5 * EditorGUIUtility.singleLineHeight + 4 * EditorGUIUtility.standardVerticalSpacing;
-                }
-                if (serieType == SerieType.Line)
-                {
-                    height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineArrow"));
-                    height += 4 * EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
-                }
-                if (serieType == SerieType.Bar)
-                {
-                    height += 6 * EditorGUIUtility.singleLineHeight + 5 * EditorGUIUtility.standardVerticalSpacing;
+                    case SerieType.Line:
+                        height += 19 * EditorGUIUtility.singleLineHeight + 18 * EditorGUIUtility.standardVerticalSpacing;
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Symbol"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineArrow"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_ItemStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_AreaStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Label"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Emphasis"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Animation"));
+                        break;
+                    case SerieType.Bar:
+                        height += 21 * EditorGUIUtility.singleLineHeight + 20 * EditorGUIUtility.standardVerticalSpacing;
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_ItemStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Label"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Emphasis"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Animation"));
+                        break;
+                    case SerieType.Pie:
+                        height += 12 * EditorGUIUtility.singleLineHeight + 11 * EditorGUIUtility.standardVerticalSpacing;
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_ItemStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Label"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Emphasis"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Animation"));
+                        break;
+                    case SerieType.Ring:
+                        height += 10 * EditorGUIUtility.singleLineHeight + 9 * EditorGUIUtility.standardVerticalSpacing;
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_TitleStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_ItemStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Label"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Emphasis"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Animation"));
+                        break;
+                    case SerieType.Radar:
+                        height += 6 * EditorGUIUtility.singleLineHeight + 5 * EditorGUIUtility.standardVerticalSpacing;
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Symbol"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_ItemStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_AreaStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Label"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Emphasis"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Animation"));
+                        break;
+                    case SerieType.Scatter:
+                    case SerieType.EffectScatter:
+                        height += 5 * EditorGUIUtility.singleLineHeight + 4 * EditorGUIUtility.standardVerticalSpacing;
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Symbol"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_ItemStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Label"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Emphasis"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Animation"));
+                        break;
+                    case SerieType.Heatmap:
+                        height += 6 * EditorGUIUtility.singleLineHeight + 5 * EditorGUIUtility.standardVerticalSpacing;
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_ItemStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Label"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Emphasis"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Animation"));
+                        break;
+                    case SerieType.Gauge:
+                        height += 13 * EditorGUIUtility.singleLineHeight + 12 * EditorGUIUtility.standardVerticalSpacing;
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_TitleStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_GaugeAxis"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_GaugePointer"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_ItemStyle"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Label"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Emphasis"));
+                        height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Animation"));
+                        break;
                 }
                 if (m_DataFoldout[index])
                 {
                     SerializedProperty m_Data = prop.FindPropertyRelative("m_Data");
-                    int num = m_Data.arraySize + 2;
-                    if (num > 30) num = 15;
+                    height += 2 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+                    int num = m_Data.arraySize;
+                    if (num > 30)
+                    {
+                        num = 11;
+                        height += (num + 1) * EditorGUIUtility.singleLineHeight + (num) * EditorGUIUtility.standardVerticalSpacing;
+                    }
+                    else
+                    {
+                        height += (num) * EditorGUIUtility.singleLineHeight + (num - 1) * EditorGUIUtility.standardVerticalSpacing;
+                    }
+                    height += EditorGUIUtility.standardVerticalSpacing;
                     if (prop.FindPropertyRelative("m_ShowDataIcon").boolValue)
                     {
-                        num *= 5;
-                        num += 2;
+                        for (int i = 0; i < num; i++)
+                        {
+                            var item = m_Data.GetArrayElementAtIndex(i);
+                            height += EditorGUI.GetPropertyHeight(item.FindPropertyRelative("m_IconStyle"));
+                            height += EditorGUI.GetPropertyHeight(item.FindPropertyRelative("m_Symbol"));
+                            height += EditorGUI.GetPropertyHeight(item.FindPropertyRelative("m_Label"));
+                            height += EditorGUI.GetPropertyHeight(item.FindPropertyRelative("m_ItemStyle"));
+                            height += EditorGUI.GetPropertyHeight(item.FindPropertyRelative("m_Emphasis"));
+                        }
                     }
-                    height += num * EditorGUIUtility.singleLineHeight + (num - 1) * EditorGUIUtility.standardVerticalSpacing;
-
                 }
                 if (m_ShowJsonDataArea)
                 {

Assets/XCharts/Editor/PropertyDrawers/SerieLabelDrawer.cs

@@ -24,6 +24,7 @@ namespace XCharts
             SerializedProperty m_Position = prop.FindPropertyRelative("m_Position");
             SerializedProperty m_Formatter = prop.FindPropertyRelative("m_Formatter");
             SerializedProperty m_Offset = prop.FindPropertyRelative("m_Offset");
+            SerializedProperty m_Margin = prop.FindPropertyRelative("m_Margin");
             SerializedProperty m_Rotate = prop.FindPropertyRelative("m_Rotate");
             SerializedProperty m_PaddingLeftRight = prop.FindPropertyRelative("m_PaddingLeftRight");
             SerializedProperty m_PaddingTopBottom = prop.FindPropertyRelative("m_PaddingTopBottom");
@@ -42,7 +43,8 @@ namespace XCharts
             SerializedProperty m_Border = prop.FindPropertyRelative("m_Border");
             SerializedProperty m_BorderWidth = prop.FindPropertyRelative("m_BorderWidth");
             SerializedProperty m_BorderColor = prop.FindPropertyRelative("m_BorderColor");
-            SerializedProperty m_ForceENotation = prop.FindPropertyRelative("m_ForceENotation");
+            SerializedProperty m_NumericFormatter = prop.FindPropertyRelative("m_NumericFormatter");
+            SerializedProperty m_AutoOffset = prop.FindPropertyRelative("m_AutoOffset");
 
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_SerieLabelToggle, prop, null, show, false);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
@@ -52,19 +54,17 @@ namespace XCharts
                 EditorGUI.PropertyField(drawRect, m_Position);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
 
-                EditorGUI.LabelField(drawRect, "Offset");
-                var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * 15;
-                var tempWidth = (drawRect.width - startX + 52) / 2;
-                var centerXRect = new Rect(startX, drawRect.y, tempWidth, drawRect.height);
-                var centerYRect = new Rect(centerXRect.x + tempWidth - 38, drawRect.y, tempWidth, drawRect.height);
-                var x = EditorGUI.FloatField(centerXRect, m_Offset.vector3Value.x);
-                var y = EditorGUI.FloatField(centerYRect, m_Offset.vector3Value.y);
-                m_Offset.vector3Value = new Vector3(x, y);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Offset);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_Offset);
 
+                EditorGUI.PropertyField(drawRect, m_AutoOffset);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Margin);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Formatter);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                
+                EditorGUI.PropertyField(drawRect, m_NumericFormatter);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Color);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_BackgroundColor);
@@ -101,8 +101,6 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_LineLength2);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_ForceENotation);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 --EditorGUI.indentLevel;
             }
         }
@@ -112,7 +110,8 @@ namespace XCharts
             float height = 0;
             if (ChartEditorHelper.IsToggle(m_SerieLabelToggle, prop))
             {
-                height += 23 * EditorGUIUtility.singleLineHeight + 22 * EditorGUIUtility.standardVerticalSpacing;
+                height += 24 * EditorGUIUtility.singleLineHeight + 23 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Offset"));
             }
             else
             {

Assets/XCharts/Editor/PropertyDrawers/SerieSymbolDrawer.cs

@@ -20,6 +20,7 @@ namespace XCharts
         {
             Rect drawRect = pos;
             drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty m_Show = prop.FindPropertyRelative("m_Show");
             SerializedProperty m_Type = prop.FindPropertyRelative("m_Type");
             SerializedProperty m_SizeType = prop.FindPropertyRelative("m_SizeType");
             SerializedProperty m_Size = prop.FindPropertyRelative("m_Size");
@@ -27,18 +28,21 @@ namespace XCharts
             SerializedProperty m_DataIndex = prop.FindPropertyRelative("m_DataIndex");
             SerializedProperty m_DataScale = prop.FindPropertyRelative("m_DataScale");
             SerializedProperty m_SelectedDataScale = prop.FindPropertyRelative("m_SelectedDataScale");
-            SerializedProperty m_Color = prop.FindPropertyRelative("m_Color");
-            SerializedProperty m_Opacity = prop.FindPropertyRelative("m_Opacity");
             SerializedProperty m_StartIndex = prop.FindPropertyRelative("m_StartIndex");
             SerializedProperty m_Interval = prop.FindPropertyRelative("m_Interval");
             SerializedProperty m_ForceShowLast = prop.FindPropertyRelative("m_ForceShowLast");
+            SerializedProperty m_Gap = prop.FindPropertyRelative("m_Gap");
 
-            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_SerieSymbolToggle, prop, null, m_Type, false);
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_SerieSymbolToggle, prop, null, m_Show, false);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             if (ChartEditorHelper.IsToggle(m_SerieSymbolToggle, prop))
             {
                 ++EditorGUI.indentLevel;
 
+                EditorGUI.PropertyField(drawRect, m_Type);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Gap);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_SizeType);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 SerieSymbolSizeType sizeType = (SerieSymbolSizeType)m_SizeType.enumValueIndex;
@@ -61,10 +65,6 @@ namespace XCharts
                     case SerieSymbolSizeType.Callback:
                         break;
                 }
-                EditorGUI.PropertyField(drawRect, m_Color);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_Opacity);
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_StartIndex);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Interval);
@@ -81,16 +81,18 @@ namespace XCharts
             {
                 SerializedProperty m_SizeType = prop.FindPropertyRelative("m_SizeType");
                 SerieSymbolSizeType sizeType = (SerieSymbolSizeType)m_SizeType.enumValueIndex;
+                var hig = 9 * EditorGUIUtility.singleLineHeight + 9 * EditorGUIUtility.standardVerticalSpacing;
                 switch (sizeType)
                 {
                     case SerieSymbolSizeType.Custom:
-                        return 9 * EditorGUIUtility.singleLineHeight + 9 * EditorGUIUtility.standardVerticalSpacing;
+                        break;
                     case SerieSymbolSizeType.FromData:
-                        return 10 * EditorGUIUtility.singleLineHeight + 10 * EditorGUIUtility.standardVerticalSpacing;
+                        hig += 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+                        break;
                     case SerieSymbolSizeType.Callback:
-                        return 9 * EditorGUIUtility.singleLineHeight + 9 * EditorGUIUtility.standardVerticalSpacing;
+                        break;
                 }
-                return 9 * EditorGUIUtility.singleLineHeight + 9 * EditorGUIUtility.standardVerticalSpacing;
+                return hig;
             }
             else
             {

Assets/XCharts/Editor/PropertyDrawers/SeriesDrawer.cs

@@ -27,11 +27,10 @@ namespace XCharts
             drawRect.width = EditorGUIUtility.labelWidth + 10;
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_SeriesModuleToggle, "Series");
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-            //ChartEditorHelper.MakeJsonData(ref drawRect, ref m_ShowJsonDataArea, ref m_JsonDataAreaText, prop);
             drawRect.width = pos.width;
             if (m_SeriesModuleToggle)
             {
-                ChartEditorHelper.MakeList(ref drawRect, ref m_DataSize, m_Series);
+                ChartEditorHelper.MakeList(ref drawRect, ref m_DataSize, m_Series, true);
             }
         }
 

Assets/XCharts/Editor/PropertyDrawers/SettingsDrawer.cs

@@ -29,7 +29,6 @@ namespace XCharts
             SerializedProperty m_PieSelectedOffset = prop.FindPropertyRelative("m_PieSelectedOffset");
 
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_SettingsModuleToggle, "Settings");
-            EditorGUI.LabelField(drawRect, "Settings", EditorStyles.boldLabel);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             if (m_SettingsModuleToggle)
             {

Assets/XCharts/Editor/PropertyDrawers/TextLimitDrawer.cs

@@ -0,0 +1,53 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(TextLimit), true)]
+    public class TextLimitDrawer : PropertyDrawer
+    {
+        private Dictionary<string, bool> m_TextLimitToggle = new Dictionary<string, bool>();
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty m_Enable = prop.FindPropertyRelative("m_Enable");
+            SerializedProperty m_MaxWidth = prop.FindPropertyRelative("m_MaxWidth");
+            SerializedProperty m_Gap = prop.FindPropertyRelative("m_Gap");
+            SerializedProperty m_LimitSuffix = prop.FindPropertyRelative("m_Suffix");
+
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_TextLimitToggle, prop, "Text Limit", m_Enable, false);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (ChartEditorHelper.IsToggle(m_TextLimitToggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_MaxWidth);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Gap);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_LimitSuffix);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            float height = 0;
+            if (ChartEditorHelper.IsToggle(m_TextLimitToggle, prop))
+            {
+                height += 3 * EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
+            }
+            return height;
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/TextLimitDrawer.cs.meta

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

Assets/XCharts/Editor/PropertyDrawers/TextStyleDrawer.cs

@@ -20,43 +20,51 @@ namespace XCharts
         {
             Rect drawRect = pos;
             drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty m_Font = prop.FindPropertyRelative("m_Font");
             SerializedProperty m_Rotate = prop.FindPropertyRelative("m_Rotate");
             SerializedProperty m_Color = prop.FindPropertyRelative("m_Color");
+            SerializedProperty m_BackgroundColor = prop.FindPropertyRelative("m_BackgroundColor");
             SerializedProperty m_FontSize = prop.FindPropertyRelative("m_FontSize");
             SerializedProperty m_FontStyle = prop.FindPropertyRelative("m_FontStyle");
             SerializedProperty m_Offset = prop.FindPropertyRelative("m_Offset");
-            // ChartEditorHelper.MakeFoldout(ref drawRect, ref m_TextStyleToggle, prop, "Text Style");
-            // drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-            // if (ChartEditorHelper.IsToggle(m_TextStyleToggle, prop))
-            // {
-            //     ++EditorGUI.indentLevel;
-            EditorGUI.PropertyField(drawRect, m_Rotate);
+            SerializedProperty m_LineSpacing = prop.FindPropertyRelative("m_LineSpacing");
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_TextStyleToggle, prop, null,null,false);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-            EditorGUI.PropertyField(drawRect, m_Offset);
-            drawRect.y += EditorGUI.GetPropertyHeight(m_Offset);
-            EditorGUI.PropertyField(drawRect, m_Color);
-            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-            EditorGUI.PropertyField(drawRect, m_FontSize);
-            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-            EditorGUI.PropertyField(drawRect, m_FontStyle);
-            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-            //     --EditorGUI.indentLevel;
-            // }
+            if (ChartEditorHelper.IsToggle(m_TextStyleToggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_Font);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Rotate);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_Offset);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_Offset);
+                EditorGUI.PropertyField(drawRect, m_Color);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_BackgroundColor);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_FontSize);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_FontStyle);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_LineSpacing);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                --EditorGUI.indentLevel;
+            }
         }
 
         public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
         {
-            // float height = 0;
-            // if (ChartEditorHelper.IsToggle(m_TextStyleToggle, prop))
-            // {
-            //     height += 5 * EditorGUIUtility.singleLineHeight + 4 * EditorGUIUtility.standardVerticalSpacing;
-            // }
-            // else
-            // {
-            //     height += 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
-            // }
-            float height = 4 * EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
-            height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Offset"));
+            float height = 0;
+            if (ChartEditorHelper.IsToggle(m_TextStyleToggle, prop))
+            {
+                height += 8 * EditorGUIUtility.singleLineHeight + 7 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Offset"));
+            }
+            else
+            {
+                height += 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+            }
             return height;
         }
     }

Assets/XCharts/Editor/PropertyDrawers/ThemeInfoDrawer.cs

@@ -67,14 +67,16 @@ namespace XCharts
             SerializedProperty m_CustomVisualMapBorderColor = prop.FindPropertyRelative("m_CustomVisualMapBorderColor");
             SerializedProperty m_CustomColorPalette = prop.FindPropertyRelative("m_CustomColorPalette");
 
+            var btnWidth = 45;
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_ThemeModuleToggle, "Theme");
-            drawRect.x = EditorGUIUtility.labelWidth - (EditorGUI.indentLevel - 1) * 15 - 2;
-            drawRect.width = defaultWidth - EditorGUIUtility.labelWidth - (m_ThemeModuleToggle ? 45 : 0);
+            drawRect.x += EditorGUIUtility.labelWidth + ChartEditorHelper.GAP_WIDTH;
+            drawRect.width = defaultWidth - EditorGUIUtility.labelWidth - ChartEditorHelper.GAP_WIDTH
+                - (m_ThemeModuleToggle ? btnWidth + 3 : 0);
             EditorGUI.PropertyField(drawRect, m_Theme, GUIContent.none);
             if (m_ThemeModuleToggle)
             {
-                drawRect.x = defaultWidth - 30;
-                drawRect.width = 45;
+                drawRect.x = defaultX + defaultWidth - btnWidth;
+                drawRect.width = btnWidth;
                 if (GUI.Button(drawRect, new GUIContent("Reset", "Reset to theme default color")))
                 {
                     m_CustomFont.objectReferenceValue = null;
@@ -139,7 +141,7 @@ namespace XCharts
 
                 ++EditorGUI.indentLevel;
                 EditorGUI.BeginChangeCheck();
-                var font =m_CustomFont.objectReferenceValue != null?m_CustomFont: m_Font;
+                var font = m_CustomFont.objectReferenceValue != null ? m_CustomFont : m_Font;
                 EditorGUI.PropertyField(drawRect, font);
                 if (EditorGUI.EndChangeCheck())
                 {
@@ -318,10 +320,10 @@ namespace XCharts
                     {
                         while (i > m_CustomColorPalette.arraySize - 1)
                         {
-                            m_CustomColorPalette.InsertArrayElementAtIndex(m_CustomColorPalette.arraySize);
+                            m_CustomColorPalette.arraySize++;
                         }
                         var customElement = m_CustomColorPalette.GetArrayElementAtIndex(i);
-                        color = customElement.colorValue != Color.clear ?
+                        color = !ChartHelper.IsClearColor(customElement.colorValue) ?
                             customElement :
                             m_ColorPalette.GetArrayElementAtIndex(i);
                         EditorGUI.BeginChangeCheck();

Assets/XCharts/Editor/PropertyDrawers/TitleDrawer.cs

@@ -21,9 +21,9 @@ namespace XCharts
             drawRect.height = EditorGUIUtility.singleLineHeight;
             SerializedProperty show = prop.FindPropertyRelative("m_Show");
             SerializedProperty text = prop.FindPropertyRelative("m_Text");
-            SerializedProperty m_TextFontSize = prop.FindPropertyRelative("m_TextFontSize");
+            SerializedProperty m_TextStyle = prop.FindPropertyRelative("m_TextStyle");
             SerializedProperty subText = prop.FindPropertyRelative("m_SubText");
-            SerializedProperty m_SubTextFontSize = prop.FindPropertyRelative("m_SubTextFontSize");
+            SerializedProperty m_SubTextStyle = prop.FindPropertyRelative("m_SubTextStyle");
             SerializedProperty m_ItemGap = prop.FindPropertyRelative("m_ItemGap");
             SerializedProperty location = prop.FindPropertyRelative("m_Location");
 
@@ -34,19 +34,16 @@ namespace XCharts
             {
                 EditorGUI.PropertyField(drawRect, text);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                ++EditorGUI.indentLevel;
-                EditorGUI.PropertyField(drawRect, m_TextFontSize, new GUIContent("Font Size"));
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                --EditorGUI.indentLevel;
                 EditorGUI.PropertyField(drawRect, subText);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                ++EditorGUI.indentLevel;
-                EditorGUI.PropertyField(drawRect, m_SubTextFontSize, new GUIContent("Font Size"));
-                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_ItemGap, new GUIContent("Item Gap"));
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                --EditorGUI.indentLevel;
                 EditorGUI.PropertyField(drawRect, location);
+                drawRect.y += EditorGUI.GetPropertyHeight(location);
+                EditorGUI.PropertyField(drawRect, m_TextStyle);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_TextStyle);
+                EditorGUI.PropertyField(drawRect, m_SubTextStyle);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_SubTextStyle);
             }
             --EditorGUI.indentLevel;
         }
@@ -56,9 +53,10 @@ namespace XCharts
             float height = 0;
             if (m_TitleModuleToggle)
             {
-                height += 5 * EditorGUIUtility.singleLineHeight + 4 * EditorGUIUtility.standardVerticalSpacing;
-                SerializedProperty location = prop.FindPropertyRelative("m_Location");
-                height += EditorGUI.GetPropertyHeight(location);
+                height += 3 * EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_TextStyle"));
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_SubTextStyle"));
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Location"));
             }
             height += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             return height;

Assets/XCharts/Editor/PropertyDrawers/TitleStyleDrawer.cs

@@ -0,0 +1,51 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    [CustomPropertyDrawer(typeof(TitleStyle), true)]
+    public class TitleStyleDrawer : PropertyDrawer
+    {
+        private Dictionary<string, bool> m_TitleStyleToggle = new Dictionary<string, bool>();
+
+        public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
+        {
+            Rect drawRect = pos;
+            drawRect.height = EditorGUIUtility.singleLineHeight;
+            SerializedProperty show = prop.FindPropertyRelative("m_Show");
+            SerializedProperty m_TextStyle = prop.FindPropertyRelative("m_TextStyle");
+            ChartEditorHelper.MakeFoldout(ref drawRect, ref m_TitleStyleToggle, prop, "Title Style", show, false);
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            if (ChartEditorHelper.IsToggle(m_TitleStyleToggle, prop))
+            {
+                ++EditorGUI.indentLevel;
+                EditorGUI.PropertyField(drawRect, m_TextStyle);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_TextStyle);
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+        {
+            float height = 0;
+            if (ChartEditorHelper.IsToggle(m_TitleStyleToggle, prop))
+            {
+                height += 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+                height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_TextStyle"));
+            }
+            else
+            {
+                height += 1 * EditorGUIUtility.singleLineHeight + 1 * EditorGUIUtility.standardVerticalSpacing;
+            }
+            return height;
+        }
+    }
+}

Assets/XCharts/Editor/PropertyDrawers/TitleStyleDrawer.cs.meta

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

Assets/XCharts/Editor/PropertyDrawers/TooltipDrawer.cs

@@ -22,22 +22,35 @@ namespace XCharts
             SerializedProperty show = prop.FindPropertyRelative("m_Show");
             SerializedProperty type = prop.FindPropertyRelative("m_Type");
             SerializedProperty m_Formatter = prop.FindPropertyRelative("m_Formatter");
+            SerializedProperty m_TitleFormatter = prop.FindPropertyRelative("m_TitleFormatter");
+            SerializedProperty m_ItemFormatter = prop.FindPropertyRelative("m_ItemFormatter");
             SerializedProperty m_FixedWidth = prop.FindPropertyRelative("m_FixedWidth");
             SerializedProperty m_FixedHeight = prop.FindPropertyRelative("m_FixedHeight");
             SerializedProperty m_MinWidth = prop.FindPropertyRelative("m_MinWidth");
             SerializedProperty m_MinHeight = prop.FindPropertyRelative("m_MinHeight");
-            SerializedProperty m_FontSize = prop.FindPropertyRelative("m_FontSize");
-            SerializedProperty m_FontStyle = prop.FindPropertyRelative("m_FontStyle");
-            SerializedProperty m_ForceENotation = prop.FindPropertyRelative("m_ForceENotation");
+            SerializedProperty m_NumericFormatter = prop.FindPropertyRelative("m_NumericFormatter");
+            SerializedProperty m_PaddingLeftRight = prop.FindPropertyRelative("m_PaddingLeftRight");
+            SerializedProperty m_PaddingTopBottom = prop.FindPropertyRelative("m_PaddingTopBottom");
+            SerializedProperty m_BackgroundImage = prop.FindPropertyRelative("m_BackgroundImage");
+            SerializedProperty m_IgnoreDataDefaultContent = prop.FindPropertyRelative("m_IgnoreDataDefaultContent");
+            SerializedProperty m_LineStyle = prop.FindPropertyRelative("m_LineStyle");
+            SerializedProperty m_TextStyle = prop.FindPropertyRelative("m_TextStyle");
 
             ChartEditorHelper.MakeFoldout(ref drawRect, ref m_TooltipModuleToggle, "Tooltip", show);
             drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
             if (m_TooltipModuleToggle)
             {
+                EditorGUI.indentLevel++;
                 EditorGUI.PropertyField(drawRect, type);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_Formatter);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_TitleFormatter);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_ItemFormatter);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_NumericFormatter);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_FixedWidth);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_FixedHeight);
@@ -46,19 +59,28 @@ namespace XCharts
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
                 EditorGUI.PropertyField(drawRect, m_MinHeight);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_FontSize);
+                EditorGUI.PropertyField(drawRect, m_PaddingLeftRight);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_FontStyle);
+                EditorGUI.PropertyField(drawRect, m_PaddingTopBottom);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-                EditorGUI.PropertyField(drawRect, m_ForceENotation);
+                EditorGUI.PropertyField(drawRect, m_BackgroundImage);
                 drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_IgnoreDataDefaultContent);
+                drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+                EditorGUI.PropertyField(drawRect, m_LineStyle);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_LineStyle);
+                EditorGUI.PropertyField(drawRect, m_TextStyle);
+                drawRect.y += EditorGUI.GetPropertyHeight(m_TextStyle);
+                EditorGUI.indentLevel--;
             }
         }
 
         public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
         {
             if (m_TooltipModuleToggle)
-                return 10 * EditorGUIUtility.singleLineHeight + 9 * EditorGUIUtility.standardVerticalSpacing;
+                return 14 * EditorGUIUtility.singleLineHeight + 13 * EditorGUIUtility.standardVerticalSpacing +
+                    EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_LineStyle")) +
+                    EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_TextStyle"));
             else
                 return EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
         }

Assets/XCharts/Editor/RadarChartEditor.cs

@@ -28,8 +28,8 @@ namespace XCharts
 
         protected override void OnEndInspectorGUI()
         {
-            base.OnEndInspectorGUI();
             EditorGUILayout.PropertyField(m_Radars, true);
+            base.OnEndInspectorGUI();
         }
     }
 }

Assets/XCharts/Editor/RingChartEditor.cs

@@ -0,0 +1,28 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEditor;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Editor class used to edit UI RingChart.
+    /// </summary>
+
+    [CustomEditor(typeof(RingChart), false)]
+    public class RingChartEditor : BaseChartEditor
+    {
+        protected SerializedProperty m_Radar;
+        protected SerializedProperty m_Radars;
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            m_Target = (RingChart)target;
+        }
+    }
+}

Assets/XCharts/Editor/RingChartEditor.cs.meta

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

Assets/XCharts/Editor/Utility/ChartEditorHelper.cs

@@ -4,6 +4,17 @@ using System.Collections.Generic;
 
 public class ChartEditorHelper
 {
+#if UNITY_2019_3_OR_NEWER
+    public const float INDENT_WIDTH = 15;
+    public const float BOOL_WIDTH = 15;
+    public const float ARROW_WIDTH = 20;
+    public const float GAP_WIDTH =2;
+#else
+    public const float INDENT_WIDTH = 15;
+    public const float BOOL_WIDTH = 15;
+    public const float ARROW_WIDTH = 13;
+    public const float GAP_WIDTH = 0;
+#endif
     public static GUIStyle headerStyle = EditorStyles.boldLabel;
     public static GUIStyle foldoutStyle = new GUIStyle(EditorStyles.foldout)
     {
@@ -21,19 +32,39 @@ public class ChartEditorHelper
 
     public static void MakeTwoField(ref Rect drawRect, float rectWidth, SerializedProperty arrayProp, string name)
     {
-        while (arrayProp.arraySize < 2)
-        {
-            arrayProp.InsertArrayElementAtIndex(arrayProp.arraySize);
-        }
+        while (arrayProp.arraySize < 2) arrayProp.arraySize++;
         MakeTwoField(ref drawRect, rectWidth, arrayProp.GetArrayElementAtIndex(0), arrayProp.GetArrayElementAtIndex(1), name);
     }
 
+    public static void MakeDivideList(ref Rect drawRect, float rectWidth, SerializedProperty arrayProp, string name, int showNum)
+    {
+        while (arrayProp.arraySize < showNum) arrayProp.arraySize++;
+        EditorGUI.LabelField(drawRect, name);
+#if UNITY_2019_3_OR_NEWER
+        var gap = 2;
+#else
+        var gap = 0;
+#endif
+        var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * INDENT_WIDTH + gap;
+        var dataWidTotal = (rectWidth - (startX + INDENT_WIDTH + 1));
+        EditorGUI.DrawRect(new Rect(startX, drawRect.y, dataWidTotal, drawRect.height), Color.grey);
+        var dataWid = dataWidTotal / showNum;
+        var xWid = dataWid - gap;
+        for (int i = 0; i < 1; i++)
+        {
+            drawRect.x = startX + i * xWid;
+            drawRect.width = dataWid + (EditorGUI.indentLevel - 2) * 40.5f;
+            EditorGUI.PropertyField(drawRect, arrayProp.GetArrayElementAtIndex(i), GUIContent.none);
+        }
+        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+    }
+
     public static void MakeTwoField(ref Rect drawRect, float rectWidth, SerializedProperty prop1, SerializedProperty prop2, string name)
     {
         EditorGUI.LabelField(drawRect, name);
-        var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * 15;
+        var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * INDENT_WIDTH + GAP_WIDTH;
         var diff = 14 + EditorGUI.indentLevel * 14;
-        var offset = diff - 15;
+        var offset = diff - INDENT_WIDTH;
         var tempWidth = (rectWidth - startX + diff) / 2;
         var centerXRect = new Rect(startX, drawRect.y, tempWidth, drawRect.height);
         var centerYRect = new Rect(centerXRect.x + tempWidth - offset, drawRect.y, tempWidth, drawRect.height);
@@ -42,14 +73,29 @@ public class ChartEditorHelper
         drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
     }
 
+    public static void MakeVector2(ref Rect drawRect, float rectWidth, SerializedProperty prop, string name)
+    {
+        EditorGUI.LabelField(drawRect, name);
+        var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * INDENT_WIDTH + GAP_WIDTH;
+        var diff = 14 + EditorGUI.indentLevel * 14;
+        var offset = diff - INDENT_WIDTH;
+        var tempWidth = (rectWidth - startX + diff) / 2;
+        var centerXRect = new Rect(startX, drawRect.y, tempWidth, drawRect.height);
+        var centerYRect = new Rect(centerXRect.x + tempWidth - offset, drawRect.y, tempWidth, drawRect.height);
+        var x = EditorGUI.FloatField(centerXRect, prop.vector3Value.x);
+        var y = EditorGUI.FloatField(centerYRect, prop.vector3Value.y);
+        prop.vector3Value = new Vector3(x, y);
+        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+    }
+
     public static void MakeJsonData(ref Rect drawRect, ref bool showTextArea, ref string inputString,
         SerializedProperty prop, float currentWidth, float diff = 0)
     {
         SerializedProperty stringDataProp = prop.FindPropertyRelative("m_JsonData");
         SerializedProperty needParseProp = prop.FindPropertyRelative("m_DataFromJson");
         float defalutX = drawRect.x;
-        drawRect.x = EditorGUIUtility.labelWidth + 14 + diff;
-        drawRect.width = currentWidth - EditorGUIUtility.labelWidth - diff;
+        drawRect.x = EditorGUIUtility.labelWidth + ARROW_WIDTH + diff;
+        drawRect.width = currentWidth - EditorGUIUtility.labelWidth - GAP_WIDTH - diff;
         if (GUI.Button(drawRect, new GUIContent("Parse JsonData", "Parse data from input json")))
         {
             showTextArea = !showTextArea;
@@ -77,19 +123,35 @@ public class ChartEditorHelper
     {
         float defaultWidth = drawRect.width;
         float defaultX = drawRect.x;
-        drawRect.width = EditorGUIUtility.labelWidth;
+        drawRect.width = EditorGUIUtility.labelWidth - EditorGUI.indentLevel * INDENT_WIDTH;
         moduleToggle = EditorGUI.Foldout(drawRect, moduleToggle, content, bold ? foldoutStyle : EditorStyles.foldout);
-        drawRect.x = EditorGUIUtility.labelWidth - (EditorGUI.indentLevel - 1) * 15 - 2;
-        drawRect.width = 40;
-        if (prop != null)
-        {
-            EditorGUI.PropertyField(drawRect, prop, GUIContent.none);
-        }
+        MakeBool(drawRect, prop);
         drawRect.width = defaultWidth;
         drawRect.x = defaultX;
         return moduleToggle;
     }
 
+    public static void MakeBool(Rect drawRect, SerializedProperty boolProp, int index = 0, string name = null)
+    {
+        float defaultWidth = drawRect.width;
+        float defaultX = drawRect.x;
+        float boolWidth = index * (BOOL_WIDTH + GAP_WIDTH);
+        drawRect.x = EditorGUIUtility.labelWidth - EditorGUI.indentLevel * INDENT_WIDTH + ARROW_WIDTH + boolWidth;
+        drawRect.width = (EditorGUI.indentLevel + 1) * BOOL_WIDTH + index * 110;
+        if (boolProp != null)
+        {
+            EditorGUI.PropertyField(drawRect, boolProp, GUIContent.none);
+            if (!string.IsNullOrEmpty(name))
+            {
+                drawRect.x += BOOL_WIDTH;
+                drawRect.width = 200;
+                EditorGUI.LabelField(drawRect, name);
+            }
+        }
+        drawRect.width = defaultWidth;
+        drawRect.x = defaultX;
+    }
+
     public static bool MakeFoldout(ref Rect drawRect, ref Dictionary<string, bool> moduleToggle, SerializedProperty prop,
         string moduleName, SerializedProperty showProp = null, bool bold = true)
     {
@@ -102,23 +164,28 @@ public class ChartEditorHelper
 
         float defaultWidth = drawRect.width;
         float defaultX = drawRect.x;
+#if UNITY_2019_3_OR_NEWER
+        drawRect.width = EditorGUIUtility.labelWidth - EditorGUI.indentLevel * INDENT_WIDTH;
+#else
         drawRect.width = EditorGUIUtility.labelWidth;
+#endif
         var displayName = string.IsNullOrEmpty(moduleName) ? prop.displayName : moduleName;
         toggle = EditorGUI.Foldout(drawRect, toggle, displayName, bold ? foldoutStyle : EditorStyles.foldout);
+
         if (moduleToggle[key] != toggle)
         {
             moduleToggle[key] = toggle;
         }
-        drawRect.x = EditorGUIUtility.labelWidth - (EditorGUI.indentLevel - 1) * 15 - 2;
         if (showProp != null)
         {
+            drawRect.x = EditorGUIUtility.labelWidth - EditorGUI.indentLevel * INDENT_WIDTH + ARROW_WIDTH;
             if (showProp.propertyType == SerializedPropertyType.Boolean)
             {
-                drawRect.width = 60;
+                drawRect.width = (EditorGUI.indentLevel + 1) * BOOL_WIDTH;
             }
             else
             {
-                drawRect.width = defaultWidth - drawRect.x + 15;
+                drawRect.width = defaultWidth - drawRect.x + ARROW_WIDTH - GAP_WIDTH;
             }
             EditorGUI.PropertyField(drawRect, showProp, GUIContent.none);
         }
@@ -127,20 +194,37 @@ public class ChartEditorHelper
         return toggle;
     }
 
-    public static void MakeList(ref Rect drawRect, ref int listSize, SerializedProperty listProp, SerializedProperty large = null)
+    public static void MakeList(ref Rect drawRect, ref int listSize, SerializedProperty listProp, bool showOrder = false, bool showSize = true)
     {
         EditorGUI.indentLevel++;
         listSize = listProp.arraySize;
-        listSize = EditorGUI.IntField(drawRect, "Size", listSize);
-        if (listSize < 0) listSize = 0;
-        drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
-
-        if (listSize != listProp.arraySize)
+        if (showSize)
         {
-            while (listSize > listProp.arraySize)
-                listProp.InsertArrayElementAtIndex(listProp.arraySize);
-            while (listSize < listProp.arraySize)
-                listProp.DeleteArrayElementAtIndex(listProp.arraySize - 1);
+            if (showOrder)
+            {
+                var nameWid = 15;
+                var temp = INDENT_WIDTH + GAP_WIDTH;
+                var elementRect = new Rect(drawRect.x, drawRect.y, drawRect.width - nameWid - 1, drawRect.height);
+                var iconRect = new Rect(drawRect.width - nameWid + temp, drawRect.y, nameWid, drawRect.height);
+                if (GUI.Button(iconRect, new GUIContent("+", "add")))
+                {
+                    listProp.arraySize++;
+                }
+                listSize = listProp.arraySize;
+                listSize = EditorGUI.IntField(elementRect, "Size", listSize);
+            }
+            else
+            {
+                listSize = EditorGUI.IntField(drawRect, "Size", listSize);
+            }
+            if (listSize < 0) listSize = 0;
+            drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+
+            if (listSize != listProp.arraySize)
+            {
+                while (listSize > listProp.arraySize) listProp.arraySize++;
+                while (listSize < listProp.arraySize) listProp.arraySize--;
+            }
         }
         if (listSize > 30)
         {
@@ -166,8 +250,38 @@ public class ChartEditorHelper
             for (int i = 0; i < listProp.arraySize; i++)
             {
                 SerializedProperty element = listProp.GetArrayElementAtIndex(i);
-                EditorGUI.PropertyField(drawRect, element, new GUIContent("Element " + i));
-                drawRect.y += EditorGUI.GetPropertyHeight(element) + EditorGUIUtility.standardVerticalSpacing;
+                if (showOrder)
+                {
+                    var nameWid = 15;
+                    var temp = INDENT_WIDTH + GAP_WIDTH;
+                    var isSerie = "Serie".Equals(element.type);
+                    var elementRect = isSerie ? drawRect : new Rect(drawRect.x, drawRect.y, drawRect.width - 2 * nameWid, drawRect.height);
+                    EditorGUI.PropertyField(elementRect, element, new GUIContent("Element " + i));
+                    var iconRect = new Rect(drawRect.width - 3 * nameWid + temp, drawRect.y, nameWid, drawRect.height);
+                    if (GUI.Button(iconRect, new GUIContent("↑", "up")))
+                    {
+                        if (i > 0) listProp.MoveArrayElement(i, i - 1);
+                    }
+                    iconRect = new Rect(drawRect.width - 2 * nameWid + temp, drawRect.y, nameWid, drawRect.height);
+                    if (GUI.Button(iconRect, new GUIContent("↓", "down")))
+                    {
+                        if (i < listProp.arraySize - 1) listProp.MoveArrayElement(i, i + 1);
+                    }
+                    iconRect = new Rect(drawRect.width - nameWid + temp, drawRect.y, nameWid, drawRect.height);
+                    if (GUI.Button(iconRect, new GUIContent("-", "delete")))
+                    {
+                        if (i < listProp.arraySize && i >= 0) listProp.DeleteArrayElementAtIndex(i);
+                    }
+                    else
+                    {
+                        drawRect.y += EditorGUI.GetPropertyHeight(element) + EditorGUIUtility.standardVerticalSpacing;
+                    }
+                }
+                else
+                {
+                    EditorGUI.PropertyField(drawRect, element, new GUIContent("Element " + i));
+                    drawRect.y += EditorGUI.GetPropertyHeight(element) + EditorGUIUtility.standardVerticalSpacing;
+                }
             }
         }
         EditorGUI.indentLevel--;

Assets/XCharts/Editor/XChartEditor.cs

@@ -8,6 +8,7 @@
 using UnityEditor;
 using UnityEngine;
 using UnityEngine.UI;
+using UnityEngine.EventSystems;
 
 namespace XCharts
 {
@@ -28,6 +29,10 @@ namespace XCharts
                     canvas.renderMode = RenderMode.ScreenSpaceOverlay;
                     canvasObject.AddComponent<CanvasScaler>();
                     canvasObject.AddComponent<GraphicRaycaster>();
+                    var eventSystem = new GameObject();
+                    eventSystem.name = "EventSystem";
+                    eventSystem.AddComponent<EventSystem>();
+                    eventSystem.AddComponent<StandaloneInputModule>();
                     return canvas.transform;
                 }
             }
@@ -61,42 +66,66 @@ namespace XCharts
             chart.transform.SetParent(parent);
             chart.transform.localScale = Vector3.one;
             chart.transform.localPosition = Vector3.zero;
+            var rect = chart.GetComponent<RectTransform>();
+            rect.anchorMin = new Vector2(0.5f, 0.5f);
+            rect.anchorMax = new Vector2(0.5f, 0.5f);
+            rect.pivot = new Vector2(0.5f, 0.5f);
         }
 
+        [MenuItem("XCharts/LineChart", priority = 44)]
         [MenuItem("GameObject/XCharts/LineChart", priority = 44)]
         public static void AddLineChart()
         {
             AddChart<LineChart>("LineChart");
         }
 
+        [MenuItem("XCharts/BarChart", priority = 45)]
         [MenuItem("GameObject/XCharts/BarChart", priority = 45)]
         public static void AddBarChart()
         {
             AddChart<BarChart>("BarChart");
         }
 
+        [MenuItem("XCharts/PieChart", priority = 46)]
         [MenuItem("GameObject/XCharts/PieChart", priority = 46)]
         public static void AddPieChart()
         {
             AddChart<PieChart>("PieChart");
         }
 
+        [MenuItem("XCharts/RadarChart", priority = 47)]
         [MenuItem("GameObject/XCharts/RadarChart", priority = 47)]
         public static void AddRadarChart()
         {
             AddChart<RadarChart>("RadarChart");
         }
 
+        [MenuItem("XCharts/ScatterChart", priority = 48)]
         [MenuItem("GameObject/XCharts/ScatterChart", priority = 48)]
         public static void AddScatterChart()
         {
             AddChart<ScatterChart>("ScatterChart");
         }
 
+        [MenuItem("XCharts/HeatmapChart", priority = 49)]
         [MenuItem("GameObject/XCharts/HeatmapChart", priority = 49)]
         public static void AddHeatmapChart()
         {
             AddChart<HeatmapChart>("HeatmapChart");
         }
+
+        [MenuItem("XCharts/GaugeChart", priority = 50)]
+        [MenuItem("GameObject/XCharts/GaugeChart", priority = 50)]
+        public static void AddGaugeChart()
+        {
+            AddChart<GaugeChart>("GaugeChart");
+        }
+
+        [MenuItem("XCharts/RingChart", priority = 51)]
+        [MenuItem("GameObject/XCharts/RingChart", priority = 51)]
+        public static void AddRingChart()
+        {
+            AddChart<RingChart>("RingChart");
+        }
     }
 }

Assets/XCharts/Editor/XChartMgrEditor.cs

@@ -0,0 +1,62 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEditor;
+using UnityEngine;
+
+namespace XCharts
+{
+    /// <summary>
+    /// Editor class used to edit UI XChartsMgr.
+    /// </summary>
+
+    [CustomEditor(typeof(XChartsMgr), false)]
+    public class XChartsMgrEditor : Editor
+    {
+        protected XChartsMgr m_Target;
+        protected SerializedProperty m_Script;
+        protected SerializedProperty m_NowVersion;
+        protected SerializedProperty m_NewVersion;
+
+        protected virtual void OnEnable()
+        {
+            m_Target = (XChartsMgr)target;
+            m_Script = serializedObject.FindProperty("m_Script");
+            m_NowVersion = serializedObject.FindProperty("m_NowVersion");
+            m_NewVersion = serializedObject.FindProperty("m_NewVersion");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (m_Target == null && target == null)
+            {
+                base.OnInspectorGUI();
+                return;
+            }
+            serializedObject.Update();
+            EditorGUILayout.PropertyField(m_NowVersion);
+            EditorGUILayout.PropertyField(m_NewVersion);
+            if (GUILayout.Button("检测更新"))
+            {
+                CheckVersionEditor.ShowWindow();
+            }
+            if (GUILayout.Button("去Github主页"))
+            {
+                Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts");
+            }
+            if (GUILayout.Button("点Star支持"))
+            {
+                Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts/stargazers");
+            }
+            if (GUILayout.Button("问题反馈"))
+            {
+                Application.OpenURL("https://github.com/monitor1394/unity-ugui-XCharts/issues");
+            }
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/XCharts/Editor/XChartMgrEditor.cs.meta

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

Assets/XCharts/Examples.meta

@@ -1,8 +1,6 @@
 fileFormatVersion: 2
-guid: 5e6b0fb015bc6524d8bab146b6f2ba3a
+guid: 0cfb5d7eeb260491b9d2545237eab7ce
 folderAsset: yes
-timeCreated: 1553641866
-licenseType: Free
 DefaultImporter:
   externalObjects: {}
   userData: 

Assets/XCharts/Examples/Runtime/Example00_CheatSheet.cs

@@ -9,10 +9,10 @@ using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
-namespace XCharts
+namespace XCharts.Examples
 {
     [DisallowMultipleComponent]
-    public class Demo00_CheatSheet : MonoBehaviour
+    public class Example00_CheatSheet : MonoBehaviour
     {
         private LineChart chart;
         private float speed = 100f;

Assets/XCharts/Examples/Runtime/Example00_CheatSheet.cs.meta

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

Assets/XCharts/Examples/Runtime/Example01_UpdateData.cs

@@ -0,0 +1,52 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+
+namespace XCharts.Examples
+{
+    [DisallowMultipleComponent]
+    [ExecuteInEditMode]
+    public class Example01_UpdateData : MonoBehaviour
+    {
+        private float updateTime = 0;
+        BaseChart chart;
+        void Awake()
+        {
+            chart = gameObject.GetComponent<BaseChart>();
+        }
+
+        void Update()
+        {
+            updateTime += Time.deltaTime;
+            if (chart && updateTime > 2)
+            {
+                updateTime = 0;
+                var serie = chart.series.GetSerie(0);
+                //serie.animation.dataChangeEnable = true;
+                var dataCount = serie.dataCount;
+                if (chart is RadarChart)
+                {
+                    var dimension = serie.GetSerieData(0).data.Count - 1;
+                    chart.UpdateData(0, 0, Random.Range(0, dimension + 1), Random.Range(0, 100));
+                }
+                else if (chart is HeatmapChart)
+                {
+                    var dimension = serie.GetSerieData(0).data.Count - 1;
+                    for (int i = 0; i < dataCount; i++)
+                    {
+                        chart.UpdateData(0, i, dimension, Random.Range(0, 10));
+                    }
+                }
+                else
+                {
+                    chart.UpdateData(0, Random.Range(0, dataCount), Random.Range(10, 90));
+                }
+            }
+        }
+    }
+}

Assets/XCharts/Examples/Runtime/Example01_UpdateData.cs.meta

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

Assets/XCharts/Examples/Runtime/Example02_ChartEvent.cs

@@ -0,0 +1,64 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace XCharts.Examples
+{
+    [DisallowMultipleComponent]
+    [ExecuteInEditMode]
+    public class Example02_ChartEvent : MonoBehaviour
+    {
+        BaseChart chart;
+
+        void Awake()
+        {
+            chart = gameObject.GetComponent<BaseChart>();
+            if (chart == null)
+            {
+                chart = gameObject.AddComponent<LineChart>();
+            }
+            chart.onPointerEnter = OnPointerEnter;
+            chart.onPointerExit = OnPointerExit;
+            chart.onPointerDown = OnPointerDown;
+            chart.onPointerUp = OnPointerUp;
+            chart.onPointerClick = OnPointerClick;
+            chart.onScroll = OnScroll;
+        }
+
+        void OnPointerEnter(BaseGraph chart, PointerEventData eventData)
+        {
+            //Debug.LogError("enter:" + chart);
+        }
+
+        void OnPointerExit(BaseGraph chart, PointerEventData eventData)
+        {
+            //Debug.LogError("exit:" + chart);
+        }
+
+        void OnPointerDown(BaseGraph chart, PointerEventData eventData)
+        {
+            //Debug.LogError("down:" + chart);
+        }
+
+        void OnPointerUp(BaseGraph chart, PointerEventData eventData)
+        {
+            //Debug.LogError("up:" + chart);
+        }
+
+        void OnPointerClick(BaseGraph chart, PointerEventData eventData)
+        {
+            //Debug.LogError("click:" + chart);
+        }
+
+        void OnScroll(BaseGraph chart, PointerEventData eventData)
+        {
+            //Debug.LogError("scroll:" + chart);
+        }
+    }
+}

Assets/XCharts/Examples/Runtime/Example02_ChartEvent.cs.meta

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

Assets/XCharts/Examples/Runtime/Example03_ChartAnimation.cs

@@ -0,0 +1,43 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+
+namespace XCharts.Examples
+{
+    [DisallowMultipleComponent]
+    [ExecuteInEditMode]
+    public class Example03_ChartAnimation : MonoBehaviour
+    {
+        BaseChart chart;
+
+        void Awake()
+        {
+            chart = gameObject.GetComponent<BaseChart>();
+            if (chart == null)
+            {
+                chart = gameObject.AddComponent<BarChart>();
+            }
+            var serie = chart.series.GetSerie(0);
+            serie.animation.enable = true;
+            //自定义每个数据项的渐入延时
+            serie.animation.customFadeInDelay = CustomFadeInDelay;
+            //自定义每个数据项的渐入时长
+            serie.animation.customFadeInDuration = CustomFadeInDuration;
+        }
+
+        float CustomFadeInDelay(int dataIndex)
+        {
+            return dataIndex * 1000;
+        }
+
+        float CustomFadeInDuration(int dataIndex)
+        {
+            return dataIndex * 1000 + 1000;
+        }
+    }
+}

Assets/XCharts/Examples/Runtime/Example03_ChartAnimation.cs.meta

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

Assets/XCharts/Examples/Runtime/Example10_LineChart.cs

@@ -8,10 +8,10 @@
 using System.Collections;
 using UnityEngine;
 
-namespace XCharts
+namespace XCharts.Examples
 {
     [DisallowMultipleComponent]
-    public class Demo10_LineChart : MonoBehaviour
+    public class Example10_LineChart : MonoBehaviour
     {
         private LineChart chart;
         private Serie serie;

Assets/XCharts/Examples/Runtime/Example10_LineChart.cs.meta

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

Assets/XCharts/Examples/Runtime/Example11_AddSinCurve.cs

@@ -7,11 +7,11 @@
 
 using UnityEngine;
 
-namespace XCharts
+namespace XCharts.Examples
 {
     [DisallowMultipleComponent]
     [ExecuteInEditMode]
-    public class Demo11_AddSinCurve : MonoBehaviour
+    public class Example11_AddSinCurve : MonoBehaviour
     {
         private float time;
         public int angle;
@@ -46,7 +46,7 @@ namespace XCharts
             chart.RemoveData();
 
             var serie = chart.AddSerie(SerieType.Line);
-            serie.symbol.type = SerieSymbolType.None;
+            serie.symbol.show = false;
             serie.lineType = LineType.Normal;
             for (angle = 0; angle < 1080; angle++)
             {

Assets/XCharts/Examples/Runtime/Example11_AddSinCurve.cs.meta

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

Assets/XCharts/Examples/Runtime/Example12_CustomDrawing.cs

@@ -9,11 +9,11 @@ using UnityEngine;
 using UnityEngine.UI;
 
 
-namespace XCharts
+namespace XCharts.Examples
 {
     [DisallowMultipleComponent]
     [ExecuteInEditMode]
-    public class Demo12_CustomDrawing : MonoBehaviour
+    public class Example12_CustomDrawing : MonoBehaviour
     {
         LineChart chart;
         void Awake()
@@ -21,7 +21,7 @@ namespace XCharts
             chart = gameObject.GetComponent<LineChart>();
             if (chart == null) return;
 
-            chart.customDrawCallback = delegate (VertexHelper vh)
+            chart.onCustomDraw = delegate (VertexHelper vh)
             {
                 var dataPoints = chart.series.list[0].dataPoints;
                 if (dataPoints.Count > 0)

Assets/XCharts/Examples/Runtime/Example12_CustomDrawing.cs.meta

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

Assets/XCharts/Examples/Runtime/Example13_LineSimple.cs

@@ -7,11 +7,11 @@
 
 using UnityEngine;
 
-namespace XCharts
+namespace XCharts.Examples
 {
     [DisallowMultipleComponent]
     [ExecuteInEditMode]
-    public class Demo13_LineSimple : MonoBehaviour
+    public class Example13_LineSimple : MonoBehaviour
     {
         void Awake()
         {
@@ -38,10 +38,12 @@ namespace XCharts
 
             chart.RemoveData();
             chart.AddSerie(SerieType.Line);
+            chart.AddSerie(SerieType.Line);
             for (int i = 0; i < 10; i++)
             {
                 chart.AddXAxisData("x" + i);
                 chart.AddData(0, Random.Range(10, 20));
+                chart.AddData(1, Random.Range(10, 20));
             }
         }
     }

Assets/XCharts/Examples/Runtime/Example13_LineSimple.cs.meta

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

Assets/XCharts/Examples/Runtime/Example20_BarChart.cs

@@ -8,10 +8,10 @@
 using System.Collections;
 using UnityEngine;
 
-namespace XCharts
+namespace XCharts.Examples
 {
     [DisallowMultipleComponent]
-    public class Demo20_BarChart : MonoBehaviour
+    public class Example20_BarChart : MonoBehaviour
     {
         private BarChart chart;
         private Serie serie, serie2;

Assets/XCharts/Examples/Runtime/Example20_BarChart.cs.meta

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

Assets/XCharts/Examples/Runtime/Example30_PieChart.cs

@@ -8,10 +8,10 @@
 using System.Collections;
 using UnityEngine;
 
-namespace XCharts
+namespace XCharts.Examples
 {
     [DisallowMultipleComponent]
-    public class Demo30_PieChart : MonoBehaviour
+    public class Example30_PieChart : MonoBehaviour
     {
         private PieChart chart;
         private Serie serie, serie1;
@@ -66,10 +66,10 @@ namespace XCharts
 
             chart.RemoveData();
             serie = chart.AddSerie(SerieType.Pie, "访问来源");
-            serie.pieRadius[0] = 0;
-            serie.pieRadius[1] = 110;
-            serie.pieCenter[0] = 0.5f;
-            serie.pieCenter[1] = 0.4f;
+            serie.radius[0] = 0;
+            serie.radius[1] = 110;
+            serie.center[0] = 0.5f;
+            serie.center[1] = 0.4f;
             chart.AddData(0, 335, "直接访问");
             chart.AddData(0, 310, "邮件营销");
             chart.AddData(0, 243, "联盟广告");
@@ -105,10 +105,10 @@ namespace XCharts
         IEnumerator Doughnut()
         {
             chart.title.subText = "圆环图";
-            serie.pieRadius[0] = 2f;
-            while (serie.pieRadius[0] < serie.pieRadius[1] * 0.7f)
+            serie.radius[0] = 2f;
+            while (serie.radius[0] < serie.radius[1] * 0.7f)
             {
-                serie.pieRadius[0] += m_RadiusSpeed * Time.deltaTime;
+                serie.radius[0] += m_RadiusSpeed * Time.deltaTime;
                 chart.RefreshChart();
                 yield return null;
             }
@@ -134,14 +134,14 @@ namespace XCharts
             chart.AddData(1, 335, "直达");
             chart.AddData(1, 679, "营销广告");
             chart.AddData(1, 1548, "搜索引擎");
-            serie1.pieRadius[0] = 0;
-            serie1.pieRadius[1] = 2f;
-            serie1.pieCenter[0] = 0.5f;
-            serie1.pieCenter[1] = 0.4f;
+            serie1.radius[0] = 0;
+            serie1.radius[1] = 2f;
+            serie1.center[0] = 0.5f;
+            serie1.center[1] = 0.4f;
             chart.RefreshChart();
-            while (serie1.pieRadius[1] < serie.pieRadius[0] * 0.75f)
+            while (serie1.radius[1] < serie.radius[0] * 0.75f)
             {
-                serie1.pieRadius[1] += m_RadiusSpeed * Time.deltaTime;
+                serie1.radius[1] += m_RadiusSpeed * Time.deltaTime;
                 chart.RefreshChart();
                 yield return null;
             }
@@ -163,7 +163,7 @@ namespace XCharts
             chart.legend.show = false;
             serie1.ClearData();
             serie.ClearData();
-            serie1.pieRadius = serie.pieRadius = new float[2] { 0, 80 };
+            serie1.radius = serie.radius = new float[2] { 0, 80 };
             serie1.label.position = SerieLabel.Position.Outside;
             serie1.label.lineType = SerieLabel.LineType.Curves;
             serie1.label.color = Color.clear;
@@ -179,24 +179,24 @@ namespace XCharts
                 chart.AddData(i, 40, "rose8");
             }
 
-            while (serie.pieCenter[0] > 0.25f || serie1.pieCenter[0] < 0.7f)
+            while (serie.center[0] > 0.25f || serie1.center[0] < 0.7f)
             {
-                if (serie.pieCenter[0] > 0.25f) serie.pieCenter[0] -= m_CenterSpeed * Time.deltaTime;
-                if (serie1.pieCenter[0] < 0.7f) serie1.pieCenter[0] += m_CenterSpeed * Time.deltaTime;
+                if (serie.center[0] > 0.25f) serie.center[0] -= m_CenterSpeed * Time.deltaTime;
+                if (serie1.center[0] < 0.7f) serie1.center[0] += m_CenterSpeed * Time.deltaTime;
                 chart.RefreshChart();
                 yield return null;
             }
             yield return new WaitForSeconds(1);
-            while (serie.pieRadius[0] > 3f)
+            while (serie.radius[0] > 3f)
             {
-                serie.pieRadius[0] -= m_RadiusSpeed * Time.deltaTime;
-                serie1.pieRadius[0] -= m_RadiusSpeed * Time.deltaTime;
+                serie.radius[0] -= m_RadiusSpeed * Time.deltaTime;
+                serie1.radius[0] -= m_RadiusSpeed * Time.deltaTime;
                 chart.RefreshChart();
                 yield return null;
             }
 
-            serie.pieRadius[0] = 0;
-            serie1.pieRadius[0] = 0;
+            serie.radius[0] = 0;
+            serie1.radius[0] = 0;
             serie.pieRoseType = RoseType.Area;
             serie1.pieRoseType = RoseType.Radius;
             chart.RefreshChart();

Assets/XCharts/Examples/Runtime/Example30_PieChart.cs.meta

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

Assets/XCharts/Examples/Runtime/Example31_PieUpdateName.cs

@@ -0,0 +1,80 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts.Examples
+{
+    [DisallowMultipleComponent]
+    [ExecuteInEditMode]
+    public class Example31_PieUpdateName : MonoBehaviour
+    {
+        PieChart chart;
+
+        void Awake()
+        {
+            chart = gameObject.GetComponent<PieChart>();
+            if (chart == null)
+            {
+                chart = gameObject.AddComponent<PieChart>();
+            }
+            var serieIndex = 0;
+            var serie = chart.series.GetSerie(serieIndex);
+            if (serie == null) return;
+            serie.label.show = true;
+            serie.label.position = SerieLabel.Position.Outside;
+        }
+
+        void Update()
+        {
+            if (Input.GetKeyDown(KeyCode.Space))
+            {
+                ClearAndAddData();
+                //UpdateDataName();
+                //UpdateDataName();
+            }
+        }
+
+        void UpdateDataName()
+        {
+            var serieIndex = 0;
+            var serie = chart.series.GetSerie(serieIndex);
+            if (serie == null) return;
+            for (int i = 0; i < serie.dataCount; i++)
+            {
+                var value = Random.Range(10, 100);
+                chart.UpdateData(serieIndex, i, value);
+                chart.UpdateDataName(serieIndex, i, "value=" + value);
+            }
+        }
+
+        void ResetSameName()
+        {
+            var serieIndex = 0;
+            var serie = chart.series.GetSerie(serieIndex);
+            if (serie == null) return;
+            for (int i = 0; i < serie.dataCount; i++)
+            {
+                chart.UpdateDataName(serieIndex, i, "piename");
+            }
+        }
+
+        void ClearAndAddData()
+        {
+            var serieIndex = 0;
+            var serie = chart.series.GetSerie(serieIndex);
+            if (serie == null) return;
+            int count = serie.dataCount;
+            serie.ClearData();
+            for (int i = 0; i < count; i++)
+            {
+                chart.AddData(0, Random.Range(0, 100), "pie" + i);
+            }
+        }
+    }
+}

Assets/XCharts/Examples/Runtime/Example31_PieUpdateName.cs.meta

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

Assets/XCharts/Examples/Runtime/Example40_Radar.cs

@@ -0,0 +1,124 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XCharts.Examples
+{
+    [DisallowMultipleComponent]
+    public class Example40_Radar : MonoBehaviour
+    {
+        private RadarChart chart;
+        private Serie serie, serie1;
+        void Awake()
+        {
+            LoopDemo();
+        }
+
+        private void OnEnable()
+        {
+            LoopDemo();
+        }
+
+        void LoopDemo()
+        {
+            StopAllCoroutines();
+            StartCoroutine(RadarDemo());
+        }
+
+        IEnumerator RadarDemo()
+        {
+            StartCoroutine(RadarAdd());
+            yield return new WaitForSeconds(2);
+            StartCoroutine(RadarUpdate());
+            yield return new WaitForSeconds(2);
+            StartCoroutine(RadarAddMultiple());
+            yield return new WaitForSeconds(2);
+            LoopDemo();
+        }
+
+        IEnumerator RadarAdd()
+        {
+            chart = gameObject.GetComponent<RadarChart>();
+            if (chart == null) chart = gameObject.AddComponent<RadarChart>();
+            chart.RemoveRadar();
+            chart.RemoveData();
+
+            chart.title.text = "RadarChart - 雷达图";
+            chart.title.subText = "";
+
+            chart.legend.show = true;
+            chart.legend.location.align = Location.Align.TopLeft;
+            chart.legend.location.top = 60;
+            chart.legend.location.left = 2;
+            chart.legend.itemWidth = 70;
+            chart.legend.itemHeight = 20;
+            chart.legend.orient = Orient.Vertical;
+
+            chart.AddRadar(Radar.Shape.Polygon, new Vector2(0.5f, 0.4f), 0.4f);
+            chart.AddIndicator(0, "indicator1", 0, 100);
+            chart.AddIndicator(0, "indicator2", 0, 100);
+            chart.AddIndicator(0, "indicator3", 0, 100);
+            chart.AddIndicator(0, "indicator4", 0, 100);
+            chart.AddIndicator(0, "indicator5", 0, 100);
+
+            serie = chart.AddSerie(SerieType.Radar, "test");
+            serie.radarIndex = 0;
+            chart.AddData(0, new List<float> { 10, 20, 60, 40, 20 }, "data1");
+            chart.AddData(0, new List<float> { 40, 60, 90, 80, 70 }, "data2");
+            yield return new WaitForSeconds(1);
+        }
+
+        IEnumerator RadarUpdate()
+        {
+            chart.UpdateIndicator(0, 0, "new1", 0, 100);
+            chart.UpdateData(0, 0, new List<float> { 15, 30, 50, 60, 50 });
+            chart.UpdateDataName(0, 0, "new1");
+            yield return new WaitForSeconds(1);
+        }
+
+        IEnumerator RadarAddMultiple()
+        {
+            chart.RemoveRadar();
+            chart.RemoveData();
+
+            chart.title.text = "RadarChart - 多雷达图";
+            chart.title.subText = "";
+
+            chart.legend.show = true;
+            chart.legend.location.align = Location.Align.TopLeft;
+            chart.legend.location.top = 60;
+            chart.legend.location.left = 2;
+            chart.legend.itemWidth = 70;
+            chart.legend.itemHeight = 20;
+            chart.legend.orient = Orient.Vertical;
+
+            chart.AddRadar(Radar.Shape.Polygon, new Vector2(0.25f, 0.4f), 0.25f);
+            for (int i = 1; i <= 5; i++)
+            {
+                chart.AddIndicator(0, "radar1" + i, 0, 100);
+            }
+
+            chart.AddRadar(Radar.Shape.Circle, new Vector2(0.75f, 0.4f), 0.25f);
+            for (int i = 1; i <= 5; i++)
+            {
+                chart.AddIndicator(1, "radar2" + i, 0, 100);
+            }
+
+            serie = chart.AddSerie(SerieType.Radar, "test1");
+            serie.radarIndex = 0;
+            chart.AddData(0, new List<float> { 10, 20, 60, 40, 20 }, "data1");
+
+            serie1 = chart.AddSerie(SerieType.Radar, "test2");
+            serie1.radarIndex = 1;
+            chart.AddData(1, new List<float> { 10, 20, 60, 40, 20 }, "data2");
+            yield return new WaitForSeconds(1);
+        }
+    }
+}

Assets/XCharts/Examples/Runtime/Example40_Radar.cs.meta

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

Assets/XCharts/Examples/Runtime/Example41_RadarUpdate.cs

@@ -0,0 +1,80 @@
+/******************************************/
+/*                                        */
+/*     Copyright (c) 2018 monitor1394     */
+/*     https://github.com/monitor1394     */
+/*                                        */
+/******************************************/
+
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace XCharts.Examples
+{
+    [DisallowMultipleComponent]
+    [ExecuteInEditMode]
+    public class Example41_RadarUpdate : MonoBehaviour
+    {
+        RadarChart chart;
+        int count = 0;
+        float max = 0;
+
+        void Awake()
+        {
+            chart = gameObject.GetComponent<RadarChart>();
+            if (chart == null)
+            {
+                chart = gameObject.AddComponent<RadarChart>();
+            }
+        }
+
+        void Update()
+        {
+            if (Input.GetKeyDown(KeyCode.Space))
+            {
+                UpdateData();
+                count++;
+            }
+            UpdateMax();
+        }
+
+        void UpdateData()
+        {
+            var serieIndex = 0;
+            var serie = chart.series.GetSerie(serieIndex);
+            if (serie == null) return;
+            if (serie.radarType == RadarType.Multiple)
+            {
+                for (int i = 0; i < serie.dataCount; i++)
+                {
+                    var serieData = serie.GetSerieData(i);
+                    for (int j = 0; j < serieData.data.Count; j++)
+                    {
+                        var value = Random.Range(10, 100);
+                        chart.UpdateData(serieIndex, i, j, value);
+                    }
+                }
+            }
+            else
+            {
+                for (int i = 0; i < serie.dataCount; i++)
+                {
+                    var value = Random.Range(10, 100);
+                    chart.UpdateData(serieIndex, i, value);
+                }
+            }
+            chart.title.subText = "max:" + serie.runtimeDataMax;
+        }
+
+        void UpdateMax()
+        {
+            var serieIndex = 0;
+            var serie = chart.series.GetSerie(serieIndex);
+            if (serie == null) return;
+            if (serie.runtimeDataMax != max)
+            {
+                chart.title.subText = "max:" + serie.runtimeDataMax;
+                max = serie.runtimeDataMax;
+            }
+        }
+    }
+}

Assets/XCharts/Examples/Runtime/Example41_RadarUpdate.cs.meta

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

Assets/XCharts/Examples/Runtime/Example50_Scatter.cs

@@ -8,11 +8,11 @@
 using System.Collections.Generic;
 using UnityEngine;
 
-namespace XCharts
+namespace XCharts.Examples
 {
     [DisallowMultipleComponent]
     [ExecuteInEditMode]
-    public class Demo50_Scatter : MonoBehaviour
+    public class Example50_Scatter : MonoBehaviour
     {
         private ScatterChart chart;
 

Assets/XCharts/Examples/Runtime/Example50_Scatter.cs.meta

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