3.0 - interaction

Assets/XCharts/Editor/ChildComponents/ComponentThemeDrawer.cs

@@ -175,9 +175,8 @@ namespace XCharts
                 ++EditorGUI.indentLevel;
                 PropertyField(prop, "m_LineWidth");
                 PropertyField(prop, "m_LineSymbolSize");
-                PropertyField(prop, "m_LineSymbolSelectedSize");
                 PropertyField(prop, "m_ScatterSymbolSize");
-                PropertyField(prop, "m_ScatterSymbolSelectedSize");
+                PropertyField(prop, "m_SelectedRate");
                 PropertyField(prop, "m_PieTooltipExtraRadius");
                 PropertyField(prop, "m_PieSelectedOffset");
                 PropertyField(prop, "m_CandlestickColor");

Assets/XCharts/Resources/XCSettings.asset

@@ -33,8 +33,8 @@ MonoBehaviour:
   m_DataZoomDataLineWidth: 0.5
   m_VisualMapBorderWidth: 0
   m_SerieLineWidth: 1.8
-  m_SerieLineSymbolSize: 4
+  m_SerieLineSymbolSize: 5
-  m_SerieLineSymbolSelectedSize: 8
+  m_SerieLineSymbolSelectedSize: 7
   m_SerieScatterSymbolSize: 20
   m_SerieScatterSymbolSelectedSize: 30
   m_SerieCandlestickBorderWidth: 1
@@ -48,8 +48,8 @@ MonoBehaviour:
   m_PieTooltipExtraRadius: 8
   m_PieSelectedOffset: 8
   m_CustomThemes:
-  - {fileID: 11400000, guid: 22c71b519a1e34731aee339407499441, type: 2}
+  - {fileID: 0}
   - {fileID: 11400000, guid: 289d2fc7f4ce24f73b9ed8ec52639f72, type: 2}
   - {fileID: 11400000, guid: e1dc23a10de1e4c5dbfbaf74c4dfd218, type: 2}
-  - {fileID: 11400000, guid: 675c10db67ba545eb8a55e10f9ed5668, type: 2}
+  - {fileID: 0}
-  - {fileID: 11400000, guid: 6e2f85adf3fea474b95fcc1f3341c4f6, type: 2}
+  - {fileID: 0}

Assets/XCharts/Resources/XCTheme-Dark.asset

@@ -186,11 +186,10 @@ MonoBehaviour:
     m_TriangeLen: 20
   m_Serie:
     m_LineWidth: 1.8
-    m_LineSymbolSize: 4
+    m_LineSymbolSize: 5
-    m_LineSymbolSelectedSize: 8
     m_ScatterSymbolSize: 20
-    m_ScatterSymbolSelectedSize: 30
     m_PieTooltipExtraRadius: 8
+    m_SelectedRate: 1.3
     m_PieSelectedOffset: 8
     m_CandlestickColor:
       serializedVersion: 2

Assets/XCharts/Resources/XCTheme-Default.asset

@@ -186,11 +186,10 @@ MonoBehaviour:
     m_TriangeLen: 20
   m_Serie:
     m_LineWidth: 1.8
-    m_LineSymbolSize: 4
+    m_LineSymbolSize: 5
-    m_LineSymbolSelectedSize: 8
     m_ScatterSymbolSize: 20
-    m_ScatterSymbolSelectedSize: 30
     m_PieTooltipExtraRadius: 8
+    m_SelectedRate: 1.3
     m_PieSelectedOffset: 8
     m_CandlestickColor:
       serializedVersion: 2

Assets/XCharts/Runtime/Component/Radar/RadarCoordHandler.cs

@@ -91,7 +91,7 @@ namespace XCharts
             Vector3 p = radar.context.center;
             Vector3 p1;
             float angle = 2 * Mathf.PI / indicatorNum;
-            var lineColor = radar.axisLine.GetColor(chart.theme.axis.lineColor);
+            var lineColor = radar.axisLine.GetColor(chart.theme.axis.splitLineColor);
             var lineWidth = radar.axisLine.GetWidth(chart.theme.axis.lineWidth);
             var lineType = radar.axisLine.GetType(chart.theme.axis.lineType);
             var splitLineColor = radar.splitLine.GetColor(chart.theme.axis.splitLineColor);
@@ -132,7 +132,7 @@ namespace XCharts
             Vector3 p1, p2, p3, p4;
             Vector3 p = radar.context.center;
             float angle = 2 * Mathf.PI / indicatorNum;
-            var lineColor = radar.axisLine.GetColor(chart.theme.axis.lineColor);
+            var lineColor = radar.axisLine.GetColor(chart.theme.axis.splitLineColor);
             var lineWidth = radar.axisLine.GetWidth(chart.theme.axis.lineWidth);
             var lineType = radar.axisLine.GetType(chart.theme.axis.lineType);
             var splitLineColor = radar.splitLine.GetColor(chart.theme.axis.splitLineColor);

Assets/XCharts/Runtime/Component/Tooltip/TooltipHandler.cs

@@ -339,6 +339,7 @@ namespace XCharts
 
             string category = null;
             var showCategory = false;
+            var isTriggerByAxis = false;
             var dataIndex = -1;
             tooltip.context.data.param.Clear();
             tooltip.context.pointer = chart.pointerPos;
@@ -346,6 +347,7 @@ namespace XCharts
             {
                 if (tooltip.trigger == Tooltip.Trigger.Axis)
                 {
+                    isTriggerByAxis = true;
                     GetAxisCategory(m_PointerContainer.index, ref dataIndex, ref category);
                     if (series.Count <= 1)
                     {
@@ -360,6 +362,9 @@ namespace XCharts
             for (int i = 0; i < series.Count; i++)
             {
                 var serie = series[i];
+                serie.context.isTriggerByAxis = isTriggerByAxis;
+                if (isTriggerByAxis)
+                    serie.context.pointerItemDataIndex = dataIndex;
                 serie.handler.UpdateTooltipSerieParams(dataIndex, showCategory, category,
                     tooltip.marker, tooltip.itemFormatter, tooltip.numericFormatter,
                     ref tooltip.context.data.param,

Assets/XCharts/Runtime/Helper/SerieHelper.cs

@@ -433,6 +433,14 @@ namespace XCharts
             }
         }
 
+        public static LabelStyle GetSerieEmphasisLabel(Serie serie, SerieData serieData)
+        {
+            if (!serie.IsPerformanceMode() && serieData.emphasis != null && serieData.emphasis.show)
+                return serieData.emphasis.label;
+            else if (serie.emphasis.show) return serie.emphasis.label;
+            else return null;
+        }
+
         public static LabelLine GetSerieLabelLine(Serie serie, SerieData serieData, bool highlight = false)
         {
             if (highlight)
@@ -518,11 +526,18 @@ namespace XCharts
             return color;
         }
 
-        public static float GetSymbolBorder(Serie serie, SerieData serieData, ThemeStyle theme, bool highlight, bool useLineWidth = true)
+        public static float GetSymbolBorder(Serie serie, SerieData serieData, ThemeStyle theme, bool highlight)
         {
             var itemStyle = GetItemStyle(serie, serieData, highlight);
             if (itemStyle != null && itemStyle.borderWidth != 0) return itemStyle.borderWidth;
-            else return serie.lineStyle.GetWidth(theme.serie.lineWidth);
+            else return serie.lineStyle.GetWidth(theme.serie.lineWidth) * 2;
+        }
+
+        public static float GetSymbolBorder(Serie serie, SerieData serieData, ThemeStyle theme, bool highlight, float defaultWidth)
+        {
+            var itemStyle = GetItemStyle(serie, serieData, highlight);
+            if (itemStyle != null && itemStyle.borderWidth != 0) return itemStyle.borderWidth;
+            else return defaultWidth;
         }
 
         public static float[] GetSymbolCornerRadius(Serie serie, SerieData serieData, bool highlight)

Assets/XCharts/Runtime/Internal/BaseChart.cs

@@ -574,7 +574,7 @@ namespace XCharts
                 var serie = m_Series[i];
                 serie.context.colorIndex = GetLegendRealShowNameIndex(serie.legendName);
                 serie.context.dataPoints.Clear();
-                serie.context.dataIgnore.Clear();
+                serie.context.dataIgnores.Clear();
                 AnimationStyleHelper.UpdateSerieAnimation(serie);
                 if (m_OnCustomDrawSerieBeforeCallback != null)
                 {

Assets/XCharts/Runtime/Internal/Basic/BaseSerie.cs

@@ -27,6 +27,7 @@ namespace XCharts
         [NonSerialized] protected bool m_ComponentDirty;
         [NonSerialized] protected Painter m_Painter;
         [NonSerialized] public SerieContext context = new SerieContext();
+        [NonSerialized] public InteractData interact = new InteractData();
 
         internal SerieHandler handler { get; set; }
 

Assets/XCharts/Runtime/Internal/XCSettings.cs

@@ -53,10 +53,9 @@ namespace XCharts
         [SerializeField] [Range(0, 20)] private float m_VisualMapBorderWidth = 0f;
 
         [SerializeField] [Range(0, 20)] private float m_SerieLineWidth = 1.8f;
-        [SerializeField] [Range(0, 200)] private float m_SerieLineSymbolSize = 4f;
+        [SerializeField] [Range(0, 200)] private float m_SerieLineSymbolSize = 5f;
-        [SerializeField] [Range(0, 200)] private float m_SerieLineSymbolSelectedSize = 8f;
         [SerializeField] [Range(0, 200)] private float m_SerieScatterSymbolSize = 20f;
-        [SerializeField] [Range(0, 200)] private float m_SerieScatterSymbolSelectedSize = 30f;
+        [SerializeField] [Range(0, 200)] private float m_SerieSelectedRate = 1.3f;
         [SerializeField] [Range(0, 10)] private float m_SerieCandlestickBorderWidth = 1f;
 
         [SerializeField] private bool m_EditorShowAllListData = false;
@@ -103,9 +102,8 @@ namespace XCharts
         #region serie
         public static float serieLineWidth { get { return Instance.m_SerieLineWidth; } }
         public static float serieLineSymbolSize { get { return Instance.m_SerieLineSymbolSize; } }
-        public static float serieLineSymbolSelectedSize { get { return Instance.m_SerieLineSymbolSelectedSize; } }
         public static float serieScatterSymbolSize { get { return Instance.m_SerieScatterSymbolSize; } }
-        public static float serieScatterSymbolSelectedSize { get { return Instance.m_SerieScatterSymbolSelectedSize; } }
+        public static float serieSelectedRate { get { return Instance.m_SerieSelectedRate; } }
         public static float serieCandlestickBorderWidth { get { return Instance.m_SerieCandlestickBorderWidth; } }
         #endregion
 

Assets/XCharts/Runtime/Serie/Bar/BarHandler.cs

@@ -17,6 +17,7 @@ namespace XCharts
     internal sealed class BarHandler : SerieHandler<Bar>
     {
         List<List<SerieData>> m_StackSerieData = new List<List<SerieData>>();
+        private GridCoord m_SerieGrid;
 
         public override void Update()
         {
@@ -32,6 +33,26 @@ namespace XCharts
                 marker, itemFormatter, numericFormatter);
         }
 
+        public override bool OnLegendButtonEnter(int index, string legendName)
+        {
+            if (chart.GetLegendRealShowNameIndex(serie.serieName) == index)
+            {
+                serie.context.isLegendEnter = true;
+                return true;
+            }
+            return false;
+        }
+
+        public override bool OnLegendButtonExit(int index, string legendName)
+        {
+            if (chart.GetLegendRealShowNameIndex(serie.serieName) == index)
+            {
+                serie.context.isLegendEnter = false;
+                return true;
+            }
+            return false;
+        }
+
         public override void DrawSerie(VertexHelper vh)
         {
             DrawBarSerie(vh, serie, serie.context.colorIndex);
@@ -39,23 +60,71 @@ namespace XCharts
 
         private void UpdateSerieContext()
         {
-            if (!chart.isPointerInChart) return;
+            if (m_SerieGrid == null)
-            serie.context.pointerItemDataIndex = -1;
+                return;
-            serie.context.pointerEnter = false;
+
-            foreach (var serieData in serie.data)
+            var needCheck = (chart.isPointerInChart && m_SerieGrid.IsPointerEnter()) || serie.context.isLegendEnter;
+            var needInteract = false;
+            if (!needCheck)
             {
-                if (serieData.context.rect.Contains(chart.pointerPos))
+                if (m_LastCheckContextFlag != needCheck)
                 {
-                    serie.context.pointerItemDataIndex = serieData.index;
+                    m_LastCheckContextFlag = needCheck;
-                    serie.context.pointerEnter = true;
+                    serie.context.pointerItemDataIndex = -1;
-                    serieData.context.highlight = true;
+                    serie.context.pointerEnter = false;
-                    chart.RefreshTopPainter();
+                    foreach (var serieData in serie.data)
+                    {
+                        var barColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, serie.context.colorIndex, false);
+                        var barToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, serie.context.colorIndex, false);
+                        serieData.interact.SetColor(ref needInteract, barColor, barToColor);
+                    }
+                    if (needInteract)
+                    {
+                        chart.RefreshPainter(serie);
+                    }
                 }
-                else
+                return;
+            }
+            m_LastCheckContextFlag = needCheck;
+            if (serie.context.isLegendEnter)
+            {
+                serie.context.pointerEnter = true;
+                foreach (var serieData in serie.data)
                 {
-                    serieData.context.highlight = false;
+                    var barColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, serie.context.colorIndex, true);
+                    var barToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, serie.context.colorIndex, true);
+                    serieData.interact.SetColor(ref needInteract, barColor, barToColor);
                 }
             }
+            else
+            {
+                serie.context.pointerItemDataIndex = -1;
+                serie.context.pointerEnter = false;
+                foreach (var serieData in serie.data)
+                {
+                    if (serieData.context.rect.Contains(chart.pointerPos))
+                    {
+                        serie.context.pointerItemDataIndex = serieData.index;
+                        serie.context.pointerEnter = true;
+                        serieData.context.highlight = true;
+
+                        var barColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, serie.context.colorIndex, true);
+                        var barToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, serie.context.colorIndex, true);
+                        serieData.interact.SetColor(ref needInteract, barColor, barToColor);
+                    }
+                    else
+                    {
+                        serieData.context.highlight = false;
+                        var barColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, serie.context.colorIndex, false);
+                        var barToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, serie.context.colorIndex, false);
+                        serieData.interact.SetColor(ref needInteract, barColor, barToColor);
+                    }
+                }
+            }
+            if (needInteract)
+            {
+                chart.RefreshPainter(serie);
+            }
         }
 
         private void DrawBarSerie(VertexHelper vh, Bar serie, int colorIndex)
@@ -67,7 +136,6 @@ namespace XCharts
 
             Axis axis;
             Axis relativedAxis;
-            GridCoord grid;
 
             if (isY)
             {
@@ -79,13 +147,13 @@ namespace XCharts
                 axis = chart.GetChartComponent<XAxis>(serie.xAxisIndex);
                 relativedAxis = chart.GetChartComponent<YAxis>(serie.yAxisIndex);
             }
-            grid = chart.GetChartComponent<GridCoord>(axis.gridIndex);
+            m_SerieGrid = chart.GetChartComponent<GridCoord>(axis.gridIndex);
 
             if (axis == null)
                 return;
             if (relativedAxis == null)
                 return;
-            if (grid == null)
+            if (m_SerieGrid == null)
                 return;
 
             var dataZoom = chart.GetDataZoomOfAxis(axis);
@@ -94,8 +162,8 @@ namespace XCharts
             if (showData.Count <= 0)
                 return;
 
-            var axisLength = isY ? grid.context.height : grid.context.width;
+            var axisLength = isY ? m_SerieGrid.context.height : m_SerieGrid.context.width;
-            var axisXY = isY ? grid.context.y : grid.context.x;
+            var axisXY = isY ? m_SerieGrid.context.y : m_SerieGrid.context.x;
 
             var isStack = SeriesHelper.IsStack<Bar>(chart.series, serie.stack);
             if (isStack)
@@ -117,8 +185,13 @@ namespace XCharts
             float dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
             double yMinValue = relativedAxis.context.minValue;
             double yMaxValue = relativedAxis.context.maxValue;
-            serie.containerIndex = grid.index;
+
-            serie.containterInstanceId = grid.instanceId;
+            var areaColor = ColorUtil.clearColor32;
+            var areaToColor = ColorUtil.clearColor32;
+            var interacting = false;
+
+            serie.containerIndex = m_SerieGrid.index;
+            serie.containterInstanceId = m_SerieGrid.instanceId;
             serie.animation.InitProgress(axisXY, axisXY + axisLength);
             for (int i = serie.minShow; i < maxCount; i++)
             {
@@ -138,9 +211,16 @@ namespace XCharts
                 var relativedValue = serieData.GetCurrData(1, dataChangeDuration, relativedAxis.inverse, yMinValue, yMaxValue);
                 var borderWidth = relativedValue == 0 ? 0 : itemStyle.runtimeBorderWidth;
 
+                if (!serieData.interact.TryGetColor(ref areaColor, ref areaToColor, ref interacting))
+                {
+                    areaColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, colorIndex, highlight);
+                    areaToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, colorIndex, highlight);
+                    serieData.interact.SetColor(ref interacting, areaColor, areaToColor);
+                }
+
                 var pX = 0f;
                 var pY = 0f;
-                UpdateXYPosition(grid, isY, axis, relativedAxis, i, categoryWidth, barWidth, isStack, value, ref pX, ref pY);
+                UpdateXYPosition(m_SerieGrid, isY, axis, relativedAxis, i, categoryWidth, barWidth, isStack, value, ref pX, ref pY);
 
                 var barHig = 0f;
                 if (isPercentStack)
@@ -150,13 +230,13 @@ namespace XCharts
                 }
                 else
                 {
-                    barHig = AxisHelper.GetAxisValueLength(grid, relativedAxis, categoryWidth, relativedValue);
+                    barHig = AxisHelper.GetAxisValueLength(m_SerieGrid, relativedAxis, categoryWidth, relativedValue);
                 }
 
                 float currHig = AnimationStyleHelper.CheckDataAnimation(chart, serie, i, barHig);
 
                 Vector3 plb, plt, prt, prb, top;
-                UpdateRectPosition(grid, isY, relativedValue, pX, pY, space, borderWidth, barWidth, currHig,
+                UpdateRectPosition(m_SerieGrid, isY, relativedValue, pX, pY, space, borderWidth, barWidth, currHig,
                     out plb, out plt, out prt, out prb, out top);
                 serieData.context.stackHeight = barHig;
                 serieData.context.position = top;
@@ -168,15 +248,15 @@ namespace XCharts
                     {
                         case BarType.Normal:
                             DrawNormalBar(vh, serie, serieData, itemStyle, colorIndex, highlight, space, barWidth,
-                                pX, pY, plb, plt, prt, prb, false, grid);
+                                pX, pY, plb, plt, prt, prb, false, m_SerieGrid, areaColor, areaToColor);
                             break;
                         case BarType.Zebra:
                             DrawZebraBar(vh, serie, serieData, itemStyle, colorIndex, highlight, space, barWidth,
-                                pX, pY, plb, plt, prt, prb, false, grid);
+                                pX, pY, plb, plt, prt, prb, false, m_SerieGrid, areaColor, areaToColor);
                             break;
                         case BarType.Capsule:
                             DrawCapsuleBar(vh, serie, serieData, itemStyle, colorIndex, highlight, space, barWidth,
-                               pX, pY, plb, plt, prt, prb, false, grid);
+                               pX, pY, plb, plt, prt, prb, false, m_SerieGrid, areaColor, areaToColor);
                             break;
                     }
                 }
@@ -191,7 +271,7 @@ namespace XCharts
                 serie.animation.CheckProgress();
                 chart.RefreshPainter(serie);
             }
-            if (dataChanging)
+            if (dataChanging || interacting)
             {
                 chart.RefreshPainter(serie);
             }
@@ -290,10 +370,9 @@ namespace XCharts
 
         private void DrawNormalBar(VertexHelper vh, Serie serie, SerieData serieData, ItemStyle itemStyle, int colorIndex,
             bool highlight, float space, float barWidth, float pX, float pY, Vector3 plb, Vector3 plt, Vector3 prt,
-            Vector3 prb, bool isYAxis, GridCoord grid)
+            Vector3 prb, bool isYAxis, GridCoord grid, Color32 areaColor, Color32 areaToColor)
         {
-            var areaColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, colorIndex, highlight);
+
-            var areaToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, colorIndex, highlight);
             DrawBarBackground(vh, serie, serieData, itemStyle, colorIndex, highlight, pX, pY, space, barWidth, isYAxis, grid);
             var borderWidth = itemStyle.runtimeBorderWidth;
             if (isYAxis)
@@ -357,10 +436,8 @@ namespace XCharts
 
         private void DrawZebraBar(VertexHelper vh, Serie serie, SerieData serieData, ItemStyle itemStyle, int colorIndex,
             bool highlight, float space, float barWidth, float pX, float pY, Vector3 plb, Vector3 plt, Vector3 prt,
-            Vector3 prb, bool isYAxis, GridCoord grid)
+            Vector3 prb, bool isYAxis, GridCoord grid, Color32 barColor, Color32 barToColor)
         {
-            var barColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, colorIndex, highlight);
-            var barToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, colorIndex, highlight);
             DrawBarBackground(vh, serie, serieData, itemStyle, colorIndex, highlight, pX, pY, space, barWidth, isYAxis, grid);
             if (isYAxis)
             {
@@ -380,10 +457,8 @@ namespace XCharts
 
         private void DrawCapsuleBar(VertexHelper vh, Serie serie, SerieData serieData, ItemStyle itemStyle, int colorIndex,
             bool highlight, float space, float barWidth, float pX, float pY, Vector3 plb, Vector3 plt, Vector3 prt,
-            Vector3 prb, bool isYAxis, GridCoord grid)
+            Vector3 prb, bool isYAxis, GridCoord grid, Color32 areaColor, Color32 areaToColor)
         {
-            var areaColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, colorIndex, highlight);
-            var areaToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, colorIndex, highlight);
             DrawBarBackground(vh, serie, serieData, itemStyle, colorIndex, highlight, pX, pY, space, barWidth, isYAxis, grid);
             var borderWidth = itemStyle.runtimeBorderWidth;
             var radius = barWidth / 2 - borderWidth;

Assets/XCharts/Runtime/Serie/InteractData.cs

@@ -0,0 +1,191 @@
+/************************************************/
+/*                                              */
+/*     Copyright (c) 2018 - 2021 monitor1394    */
+/*     https://github.com/monitor1394           */
+/*                                              */
+/************************************************/
+
+using UnityEngine;
+
+namespace XCharts
+{
+    public class InteractData
+    {
+        private float m_PreviousValue = 0;
+        private float m_TargetValue = 0;
+        private Color32 m_PreviousColor;
+        private Color32 m_TargetColor;
+        private Color32 m_PreviousToColor;
+        private Color32 m_TargetToColor;
+        private float m_UpdateTime = 0;
+        private bool m_UpdateFlag = false;
+        private bool m_ValueEnable = false;
+
+        public void SetValue(ref bool needInteract, float size, bool highlight, float rate = 1.3f)
+        {
+            size = highlight ? size * rate : size;
+            SetValue(ref needInteract, size);
+        }
+
+        public void SetValue(ref bool needInteract, float size)
+        {
+            if (m_TargetValue != size)
+            {
+                needInteract = true;
+                m_UpdateFlag = true;
+                m_ValueEnable = true;
+                m_UpdateTime = Time.time;
+                m_PreviousValue = m_TargetValue;
+                m_TargetValue = size;
+            }
+        }
+
+        public void SetColor(ref bool needInteract, Color32 color)
+        {
+            if (!ChartHelper.IsValueEqualsColor(color, m_TargetColor))
+            {
+                needInteract = true;
+                m_UpdateFlag = true;
+                m_ValueEnable = true;
+                m_UpdateTime = Time.time;
+                m_PreviousColor = m_TargetColor;
+                m_TargetColor = color;
+            }
+        }
+        public void SetColor(ref bool needInteract, Color32 color, Color32 toColor)
+        {
+            SetColor(ref needInteract, color);
+            if (!ChartHelper.IsValueEqualsColor(toColor, m_TargetToColor))
+            {
+                needInteract = true;
+                m_UpdateFlag = true;
+                m_ValueEnable = true;
+                m_UpdateTime = Time.time;
+                m_PreviousToColor = m_TargetToColor;
+                m_TargetToColor = toColor;
+            }
+        }
+
+        public void SetValueAndColor(ref bool needInteract, float value, Color32 color)
+        {
+            SetValue(ref needInteract, value);
+            SetColor(ref needInteract, color);
+        }
+
+        public void SetValueAndColor(ref bool needInteract, float value, Color32 color, Color32 toColor)
+        {
+            SetValue(ref needInteract, value);
+            SetColor(ref needInteract, color, toColor);
+        }
+
+        public bool TryGetValue(ref float value, ref bool interacting, float animationDuration = 250)
+        {
+            if (!m_ValueEnable || m_PreviousValue == 0)
+                return false;
+            if (m_UpdateFlag)
+            {
+                var time = Time.time - m_UpdateTime;
+                var total = animationDuration / 1000;
+                var rate = time / total;
+                if (rate > 1) rate = 1;
+                if (rate < 1)
+                {
+                    interacting = true;
+                    value = Mathf.Lerp(m_PreviousValue, m_TargetValue, rate);
+                    return true;
+                }
+                else
+                {
+                    m_UpdateFlag = false;
+                }
+            }
+            value = m_TargetValue;
+            return true;
+        }
+
+        public bool TryGetColor(ref Color32 color, ref bool interacting, float animationDuration = 250)
+        {
+            if (!m_ValueEnable)
+                return false;
+            if (m_UpdateFlag)
+            {
+                var time = Time.time - m_UpdateTime;
+                var total = animationDuration / 1000;
+                var rate = time / total;
+                if (rate > 1) rate = 1;
+                if (rate < 1)
+                {
+                    interacting = true;
+                    color = Color32.Lerp(m_PreviousColor, m_TargetColor, rate);
+                    return true;
+                }
+                else
+                {
+                    m_UpdateFlag = false;
+                }
+            }
+            color = m_TargetColor;
+            return true;
+        }
+
+        public bool TryGetColor(ref Color32 color, ref Color32 toColor, ref bool interacting, float animationDuration = 250)
+        {
+            if (!m_ValueEnable)
+                return false;
+            if (m_UpdateFlag)
+            {
+                var time = Time.time - m_UpdateTime;
+                var total = animationDuration / 1000;
+                var rate = time / total;
+                if (rate > 1) rate = 1;
+                if (rate < 1)
+                {
+                    interacting = true;
+                    color = Color32.Lerp(m_PreviousColor, m_TargetColor, rate);
+                    toColor = Color32.Lerp(m_PreviousToColor, m_TargetToColor, rate);
+                    return true;
+                }
+                else
+                {
+                    m_UpdateFlag = false;
+                }
+            }
+            color = m_TargetColor;
+            toColor = m_TargetToColor;
+            return true;
+        }
+        public bool TryGetValueAndColor(ref float value, ref Color32 color, ref Color32 toColor, ref bool interacting, float animationDuration = 250)
+        {
+            if (!m_ValueEnable)
+                return false;
+            if (m_UpdateFlag)
+            {
+                var time = Time.time - m_UpdateTime;
+                var total = animationDuration / 1000;
+                var rate = time / total;
+                if (rate > 1) rate = 1;
+                if (rate < 1)
+                {
+                    interacting = true;
+                    value = Mathf.Lerp(m_PreviousValue, m_TargetValue, rate);
+                    color = Color32.Lerp(m_PreviousColor, m_TargetColor, rate);
+                    toColor = Color32.Lerp(m_PreviousToColor, m_TargetToColor, rate);
+                    return true;
+                }
+                else
+                {
+                    m_UpdateFlag = false;
+                }
+            }
+            value = m_TargetValue;
+            color = m_TargetColor;
+            toColor = m_TargetToColor;
+            return true;
+        }
+
+        public void Reset()
+        {
+            m_ValueEnable = false;
+        }
+    }
+}

Assets/XCharts/Runtime/Serie/InteractData.cs.meta

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

Assets/XCharts/Runtime/Serie/Line/LineHandler.GridCoord.cs

@@ -20,6 +20,7 @@ namespace XCharts
     internal sealed partial class LineHandler : SerieHandler<Line>
     {
         List<List<SerieData>> m_StackSerieData = new List<List<SerieData>>();
+        private GridCoord m_SerieGrid;
 
         public override void Update()
         {
@@ -66,34 +67,135 @@ namespace XCharts
             }
         }
 
+        public override bool OnLegendButtonEnter(int index, string legendName)
+        {
+            if (chart.GetLegendRealShowNameIndex(serie.serieName) == index)
+            {
+                serie.context.isLegendEnter = true;
+                return true;
+            }
+            return false;
+        }
+
+        public override bool OnLegendButtonExit(int index, string legendName)
+        {
+            if (chart.GetLegendRealShowNameIndex(serie.serieName) == index)
+            {
+                serie.context.isLegendEnter = false;
+                return true;
+            }
+            return false;
+        }
+
         private void UpdateSerieContext()
         {
-            if (!chart.isPointerInChart)
+            if (m_SerieGrid == null)
                 return;
 
-            var themeSymbolSize = chart.theme.serie.lineSymbolSize;
+            var needCheck = (chart.isPointerInChart && m_SerieGrid.IsPointerEnter()) || serie.context.isLegendEnter;
-
+            var lineWidth = 0f;
-            serie.context.pointerItemDataIndex = -1;
+            if (!needCheck)
-            serie.context.pointerEnter = false;
-
-            foreach (var serieData in serie.data)
             {
-                var dist = Vector3.Distance(chart.pointerPos, serieData.context.position);
+                if (m_LastCheckContextFlag != needCheck)
-                var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
+                {
-                var symbolSize = symbol.GetSize(serieData.data, themeSymbolSize);
+                    var needAnimation1 = false;
+                    lineWidth = serie.lineStyle.GetWidth(chart.theme.serie.lineWidth);
+                    m_LastCheckContextFlag = needCheck;
+                    serie.context.pointerItemDataIndex = -1;
+                    serie.context.pointerEnter = false;
+                    serie.interact.SetValue(ref needAnimation1, lineWidth, false);
+                    foreach (var serieData in serie.data)
+                    {
+                        var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
+                        var symbolSize = symbol.GetSize(serieData.data, chart.theme.serie.lineSymbolSize);
+                        serieData.context.highlight = false;
+                        serieData.interact.SetValue(ref needAnimation1, symbolSize);
+                    }
+                    if (needAnimation1)
+                    {
+                        if (SeriesHelper.IsStack(chart.series))
+                            chart.RefreshTopPainter();
+                        else
+                            chart.RefreshPainter(serie);
+                    }
+                }
+                return;
+            }
+            m_LastCheckContextFlag = needCheck;
+            var themeSymbolSize = chart.theme.serie.lineSymbolSize;
+            var themeSymbolSelectedSize = chart.theme.serie.lineSymbolSelectedSize;
+            lineWidth = serie.lineStyle.GetWidth(chart.theme.serie.lineWidth);
 
-                if (dist <= symbolSize)
+            var needInteract = false;
+            if (serie.context.isLegendEnter)
+            {
+                serie.interact.SetValue(ref needInteract, lineWidth, true, chart.theme.serie.selectedRate);
+                for (int i = 0; i < serie.dataCount; i++)
                 {
-                    serie.context.pointerItemDataIndex = serieData.index;
+                    var serieData = serie.data[i];
-                    serie.context.pointerEnter = true;
+                    var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
+                    var symbolSelectedSize = symbol.GetSelectedSize(serieData.data, themeSymbolSelectedSize);
+
                     serieData.context.highlight = true;
-                    chart.RefreshTopPainter();
+                    serieData.interact.SetValue(ref needInteract, symbolSelectedSize);
                 }
-                else
+            }
+            else if (serie.context.isTriggerByAxis)
+            {
+                serie.context.pointerEnter = true;
+                serie.interact.SetValue(ref needInteract, lineWidth, true, chart.theme.serie.selectedRate);
+                for (int i = 0; i < serie.dataCount; i++)
                 {
-                    serieData.context.highlight = false;
+                    var serieData = serie.data[i];
+                    var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
+                    var symbolSize = symbol.GetSize(serieData.data, themeSymbolSize);
+                    var symbolSelectedSize = symbol.GetSelectedSize(serieData.data, themeSymbolSelectedSize);
+
+                    if (i == serie.context.pointerItemDataIndex)
+                    {
+                        serieData.context.highlight = true;
+                        serieData.interact.SetValue(ref needInteract, symbolSelectedSize);
+                    }
+                    else
+                    {
+                        serieData.context.highlight = false;
+                        serieData.interact.SetValue(ref needInteract, symbolSize);
+                    }
                 }
             }
+            else
+            {
+                serie.context.pointerItemDataIndex = -1;
+                serie.context.pointerEnter = false;
+                foreach (var serieData in serie.data)
+                {
+                    var dist = Vector3.Distance(chart.pointerPos, serieData.context.position);
+                    var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
+                    var symbolSize = symbol.GetSize(serieData.data, themeSymbolSize);
+                    var symbolSelectedSize = symbol.GetSelectedSize(serieData.data, themeSymbolSelectedSize);
+
+                    if (dist <= symbolSelectedSize)
+                    {
+                        serie.context.pointerItemDataIndex = serieData.index;
+                        serie.context.pointerEnter = true;
+                        serie.interact.SetValue(ref needInteract, lineWidth, true);
+                        serieData.context.highlight = true;
+                        serieData.interact.SetValue(ref needInteract, symbolSelectedSize);
+                    }
+                    else
+                    {
+                        serieData.context.highlight = false;
+                        serieData.interact.SetValue(ref needInteract, symbolSize);
+                    }
+                }
+            }
+            if (needInteract)
+            {
+                if (SeriesHelper.IsStack(chart.series))
+                    chart.RefreshTopPainter();
+                else
+                    chart.RefreshPainter(serie);
+            }
         }
 
         private void DrawLinePoint(VertexHelper vh, Serie serie)
@@ -101,20 +203,15 @@ namespace XCharts
             if (!serie.show || serie.IsPerformanceMode())
                 return;
 
+            if (m_SerieGrid == null)
+                return;
+
             var count = serie.context.dataPoints.Count;
             var clip = SeriesHelper.IsAnyClipSerie(chart.series);
-            XAxis xAxis;
-            YAxis yAxis;
-            GridCoord grid;
-
-            if (!chart.TryGetChartComponent<XAxis>(out xAxis, serie.xAxisIndex))
-                return;
-            if (!chart.TryGetChartComponent<YAxis>(out yAxis, serie.yAxisIndex))
-                return;
-            if (!chart.TryGetChartComponent<GridCoord>(out grid, xAxis.gridIndex))
-                return;
-
             var theme = chart.theme;
+            var interacting = false;
+            //var isY = ComponentHelper.IsAnyCategoryOfYAxis(chart.components);
+
             for (int i = 0; i < count; i++)
             {
                 var serieData = serie.GetSerieData(i);
@@ -126,6 +223,11 @@ namespace XCharts
                 if (!symbol.show || !symbol.ShowSymbol(i, count))
                     continue;
 
+                var pos = serie.context.dataPoints[i];
+                // if (serie.animation.CheckDetailBreak(pos, isY))
+                // {
+                //     continue;
+                // }
                 if (serie.lineArrow.show)
                 {
                     if (serie.lineArrow.position == LineArrow.Position.Start && i == 0)
@@ -134,23 +236,37 @@ namespace XCharts
                         continue;
                 }
 
-                if (ChartHelper.IsIngore(serie.context.dataPoints[i]))
+                if (ChartHelper.IsIngore(pos))
                     continue;
 
                 var highlight = serie.data[i].context.highlight || serie.highlight;
                 var symbolSize = highlight
-                    ? symbol.GetSelectedSize(serie.data[i].data, theme.serie.lineSymbolSelectedSize)
+                    ? theme.serie.lineSymbolSelectedSize
-                    : symbol.GetSize(serie.data[i].data, theme.serie.lineSymbolSize);
+                    : theme.serie.lineSymbolSize;
+                if (!serieData.interact.TryGetValue(ref symbolSize, ref interacting))
+                {
+                    symbolSize = highlight
+                        ? symbol.GetSelectedSize(serieData.data, symbolSize)
+                        : symbol.GetSize(serieData.data, symbolSize);
+                    serieData.interact.SetValue(ref interacting, symbolSize);
+                    symbolSize = serie.animation.GetSysmbolSize(symbolSize);
+                }
                 var symbolColor = SerieHelper.GetItemColor(serie, serieData, theme, serie.index, highlight);
                 var symbolToColor = SerieHelper.GetItemToColor(serie, serieData, theme, serie.index, highlight);
                 var symbolEmptyColor = SerieHelper.GetItemBackgroundColor(serie, serieData, theme, serie.index, highlight, false);
                 var symbolBorder = SerieHelper.GetSymbolBorder(serie, serieData, theme, highlight);
                 var cornerRadius = SerieHelper.GetSymbolCornerRadius(serie, serieData, highlight);
 
-                symbolSize = serie.animation.GetSysmbolSize(symbolSize);
+                chart.DrawClipSymbol(vh, symbol.type, symbolSize, symbolBorder, pos,
-                chart.DrawClipSymbol(vh, symbol.type, symbolSize, symbolBorder, serie.context.dataPoints[i],
+                    symbolColor, symbolToColor, symbolEmptyColor, symbol.gap, clip, cornerRadius, m_SerieGrid,
-                    symbolColor, symbolToColor, symbolEmptyColor, symbol.gap, clip, cornerRadius, grid,
+                    i > 0 ? serie.context.dataPoints[i - 1] : m_SerieGrid.context.position);
-                    i > 0 ? serie.context.dataPoints[i - 1] : grid.context.position);
+            }
+            if (interacting)
+            {
+                if (SeriesHelper.IsStack(chart.series))
+                    chart.RefreshTopPainter();
+                else
+                    chart.RefreshPainter(serie);
             }
         }
 
@@ -206,7 +322,6 @@ namespace XCharts
 
             Axis axis;
             Axis relativedAxis;
-            GridCoord grid;
 
             if (isY)
             {
@@ -218,13 +333,13 @@ namespace XCharts
                 axis = chart.GetChartComponent<XAxis>(serie.xAxisIndex);
                 relativedAxis = chart.GetChartComponent<YAxis>(serie.yAxisIndex);
             }
-            grid = chart.GetChartComponent<GridCoord>(axis.gridIndex);
+            m_SerieGrid = chart.GetChartComponent<GridCoord>(axis.gridIndex);
 
             if (axis == null)
                 return;
             if (relativedAxis == null)
                 return;
-            if (grid == null)
+            if (m_SerieGrid == null)
                 return;
 
             var visualMap = chart.GetVisualMapOfSerie(serie);
@@ -234,22 +349,25 @@ namespace XCharts
             if (showData.Count <= 0)
                 return;
 
-            var axisLength = isY ? grid.context.height : grid.context.width;
+            var axisLength = isY ? m_SerieGrid.context.height : m_SerieGrid.context.width;
             var scaleWid = AxisHelper.GetDataWidth(axis, axisLength, showData.Count, dataZoom);
 
             int maxCount = serie.maxShow > 0
                 ? (serie.maxShow > showData.Count ? showData.Count : serie.maxShow)
                 : showData.Count;
-            int rate = LineHelper.GetDataAverageRate(serie, grid, maxCount, false);
+            int rate = LineHelper.GetDataAverageRate(serie, m_SerieGrid, maxCount, false);
             var totalAverage = serie.sampleAverage > 0
                 ? serie.sampleAverage
                 : DataHelper.DataAverage(ref showData, serie.sampleType, serie.minShow, maxCount, rate);
             var dataChanging = false;
             var dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
 
+            var interacting = false;
+            var lineWidth = LineHelper.GetLineWidth(ref interacting, serie, chart.theme.serie.lineWidth);
+
             axis.context.scaleWidth = scaleWid;
-            serie.containerIndex = grid.index;
+            serie.containerIndex = m_SerieGrid.index;
-            serie.containterInstanceId = grid.instanceId;
+            serie.containterInstanceId = m_SerieGrid.instanceId;
 
             Serie lastSerie = null;
             var isStack = SeriesHelper.IsStack<Line>(chart.series, serie.stack);
@@ -267,9 +385,9 @@ namespace XCharts
                 {
                     serieData.context.stackHeight = 0;
                     serieData.context.position = Vector3.zero;
-                    if (serie.ignoreLineBreak && serie.context.dataIgnore.Count > 0)
+                    if (serie.ignoreLineBreak && serie.context.dataIgnores.Count > 0)
                     {
-                        serie.context.dataIgnore[serie.context.dataIgnore.Count - 1] = true;
+                        serie.context.dataIgnores[serie.context.dataIgnores.Count - 1] = true;
                     }
                 }
                 else
@@ -279,17 +397,17 @@ namespace XCharts
                     var relativedValue = DataHelper.SampleValue(ref showData, serie.sampleType, rate, serie.minShow,
                         maxCount, totalAverage, i, dataChangeDuration, ref dataChanging, relativedAxis);
 
-                    serieData.context.stackHeight = GetDataPoint(isY, axis, relativedAxis, grid, xValue, relativedValue,
+                    serieData.context.stackHeight = GetDataPoint(isY, axis, relativedAxis, m_SerieGrid, xValue, relativedValue,
                         i, scaleWid, isStack, ref np);
 
                     serieData.context.position = np;
 
                     serie.context.dataPoints.Add(np);
-                    serie.context.dataIgnore.Add(false);
+                    serie.context.dataIgnores.Add(false);
                 }
             }
 
-            if (dataChanging)
+            if (dataChanging || interacting)
                 chart.RefreshPainter(serie);
 
             if (serie.context.dataPoints.Count <= 0)
@@ -298,9 +416,9 @@ namespace XCharts
             serie.animation.InitProgress(serie.context.dataPoints, isY);
 
             VisualMapHelper.AutoSetLineMinMax(visualMap, serie, isY, axis, relativedAxis);
-            LineHelper.UpdateSerieDrawPoints(serie, chart.settings, chart.theme, isY);
+            LineHelper.UpdateSerieDrawPoints(serie, chart.settings, chart.theme, lineWidth, isY);
-            LineHelper.DrawSerieLineArea(vh, serie, lastSerie, chart.theme, isY, axis, relativedAxis, grid);
+            LineHelper.DrawSerieLineArea(vh, serie, lastSerie, chart.theme, isY, axis, relativedAxis, m_SerieGrid);
-            LineHelper.DrawSerieLine(vh, chart.theme, serie, visualMap, grid, axis, relativedAxis);
+            LineHelper.DrawSerieLine(vh, chart.theme, serie, visualMap, m_SerieGrid, axis, relativedAxis, lineWidth);
 
             serie.context.vertCount = vh.currentVertCount;
 

Assets/XCharts/Runtime/Serie/Line/LineHelper.cs

@@ -230,7 +230,7 @@ namespace XCharts
         }
 
         internal static void DrawSerieLine(VertexHelper vh, ThemeStyle theme, Serie serie, VisualMap visualMap,
-            GridCoord grid, Axis axis, Axis relativedAxis)
+            GridCoord grid, Axis axis, Axis relativedAxis, float lineWidth)
         {
             var datas = serie.context.drawPoints;
 
@@ -252,9 +252,8 @@ namespace XCharts
             var isVisualMapGradient = VisualMapHelper.IsNeedGradient(visualMap);
             var isLineStyleGradient = serie.lineStyle.IsNeedGradient();
 
-            var highlight = serie.highlight || serie.context.pointerEnter;
+            //var highlight = serie.highlight || serie.context.pointerEnter;
-            var lineWidth = serie.lineStyle.GetWidth(theme.serie.lineWidth);
+            var lineColor = SerieHelper.GetLineColor(serie, theme, serie.context.colorIndex, false);
-            var lineColor = SerieHelper.GetLineColor(serie, theme, serie.context.colorIndex, highlight);
 
             var lastDataIsIgnore = datas[0].isIgnoreBreak;
             for (int i = 1; i < dataCount; i++)
@@ -316,6 +315,17 @@ namespace XCharts
             }
         }
 
+        public static float GetLineWidth(ref bool interacting, Serie serie, float defaultWidth)
+        {
+            var lineWidth = 0f;
+            if (!serie.interact.TryGetValue(ref lineWidth, ref interacting))
+            {
+                lineWidth = serie.lineStyle.GetWidth(defaultWidth);
+                serie.interact.SetValue(ref interacting, lineWidth);
+            }
+            return lineWidth;
+        }
+
         private static void AddLineVertToVertexHelper(VertexHelper vh, Vector3 tp, Vector3 bp,
             Color32 lineColor, bool visualMapGradient, bool lineStyleGradient, VisualMap visualMap,
             LineStyle lineStyle, GridCoord grid, Axis axis, Axis relativedAxis, bool needTriangle,
@@ -346,7 +356,7 @@ namespace XCharts
                 UGL.AddVertToVertexHelper(vh, tp, bp, ColorUtil.clearColor32, false);
         }
 
-        internal static void UpdateSerieDrawPoints(Serie serie, Settings setting, ThemeStyle theme, bool isY = false)
+        internal static void UpdateSerieDrawPoints(Serie serie, Settings setting, ThemeStyle theme, float lineWidth, bool isY = false)
         {
 
             serie.context.drawPoints.Clear();
@@ -359,12 +369,12 @@ namespace XCharts
                 case LineType.StepStart:
                 case LineType.StepMiddle:
                 case LineType.StepEnd:
-                    UpdateStepLineDrawPoints(serie, setting, theme, isY);
+                    UpdateStepLineDrawPoints(serie, setting, theme, isY, lineWidth);
                     break;
                 default:
                     for (int i = 0; i < serie.context.dataPoints.Count; i++)
                     {
-                        serie.context.drawPoints.Add(new PointInfo(serie.context.dataPoints[i], serie.context.dataIgnore[i]));
+                        serie.context.drawPoints.Add(new PointInfo(serie.context.dataPoints[i], serie.context.dataIgnores[i]));
                     }
                     break;
             }
@@ -380,7 +390,7 @@ namespace XCharts
                 var ep = points[i + 1];
                 var lsp = i > 0 ? points[i - 1] : sp;
                 var nep = i < points.Count - 2 ? points[i + 2] : ep;
-                var ignore = serie.context.dataIgnore[i];
+                var ignore = serie.context.dataIgnores[i];
                 if (isY)
                     UGLHelper.GetBezierListVertical(ref s_CurvesPosList, sp, ep, smoothness);
                 else
@@ -393,17 +403,16 @@ namespace XCharts
             }
         }
 
-        private static void UpdateStepLineDrawPoints(Serie serie, Settings setting, ThemeStyle theme, bool isY)
+        private static void UpdateStepLineDrawPoints(Serie serie, Settings setting, ThemeStyle theme, bool isY, float lineWidth)
         {
             var points = serie.context.dataPoints;
             var lp = points[0];
-            var lineWidth = serie.lineStyle.GetWidth(theme.serie.lineWidth);
             serie.context.drawPoints.Clear();
-            serie.context.drawPoints.Add(new PointInfo(lp, serie.context.dataIgnore[0]));
+            serie.context.drawPoints.Add(new PointInfo(lp, serie.context.dataIgnores[0]));
             for (int i = 1; i < points.Count; i++)
             {
                 var cp = points[i];
-                var ignore = serie.context.dataIgnore[i];
+                var ignore = serie.context.dataIgnores[i];
                 if ((isY && Mathf.Abs(lp.x - cp.x) <= lineWidth)
                     || (!isY && Mathf.Abs(lp.y - cp.y) <= lineWidth))
                 {

Assets/XCharts/Runtime/Serie/Pie/PieHandler.cs

@@ -33,7 +33,7 @@ namespace XCharts
             string marker, string itemFormatter, string numericFormatter,
             ref List<SerieParams> paramList, ref string title)
         {
-            UpdateItemSerieParams(ref paramList, ref title, dataIndex, category, 
+            UpdateItemSerieParams(ref paramList, ref title, dataIndex, category,
                 marker, itemFormatter, numericFormatter);
         }
 
@@ -113,37 +113,59 @@ namespace XCharts
 
         private void UpdateSerieContext()
         {
-            if (!chart.isPointerInChart) return;
+            var needCheck = serie.context.isLegendEnter
-            var lastPointerEnter = serie.context.pointerEnter;
+                || (chart.isPointerInChart && PointerIsInPieSerie(serie, chart.pointerPos));
-            serie.context.pointerEnter = PointerIsInPieSerie(serie, chart.pointerPos);
+            var needInteract = false;
-            if (serie.context.pointerEnter)
+            if (!needCheck)
             {
-                var lastDataIndex = serie.context.pointerItemDataIndex;
+                if (m_LastCheckContextFlag != needCheck)
-                var dataIndex = GetPiePosIndex(serie, chart.pointerPos);
-                if (dataIndex >= 0)
                 {
-                    if (lastDataIndex >= 0)
+                    m_LastCheckContextFlag = needCheck;
-                        serie.GetSerieData(lastDataIndex).context.highlight = false;
+                    serie.context.pointerItemDataIndex = -1;
-                    if (lastDataIndex != dataIndex)
+                    serie.context.pointerEnter = false;
+                    foreach (var serieData in serie.data)
+                    {
+                        var colorIndex = chart.GetLegendRealShowNameIndex(serieData.legendName);
+                        var color = SerieHelper.GetItemColor(serie, serieData, chart.theme, colorIndex, false);
+                        var toColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, colorIndex, false);
+                        serieData.interact.SetValueAndColor(ref needInteract, serieData.context.outsideRadius, color, toColor);
+                    }
+                    if (needInteract)
+                    {
                         chart.RefreshPainter(serie);
-                    serie.GetSerieData(dataIndex).context.highlight = true;
+                    }
-                    serie.context.pointerItemDataIndex = dataIndex;
+                }
+                return;
+            }
+            m_LastCheckContextFlag = needCheck;
+            serie.context.pointerItemDataIndex = -1;
+            var dataIndex = GetPiePosIndex(serie, chart.pointerPos);
+            for (int i = 0; i < serie.dataCount; i++)
+            {
+                var serieData = serie.data[i];
+                if (dataIndex == i || (serie.context.isLegendEnter && serie.context.legendEnterIndex == i))
+                {
+                    serie.context.pointerItemDataIndex = i;
+                    serieData.context.highlight = true;
+
+                    var colorIndex = chart.GetLegendRealShowNameIndex(serieData.legendName);
+                    var color = SerieHelper.GetItemColor(serie, serieData, chart.theme, colorIndex, true);
+                    var toColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, colorIndex, true);
+                    var value = serieData.context.outsideRadius + chart.theme.serie.pieTooltipExtraRadius;
+                    serieData.interact.SetValueAndColor(ref needInteract, value, color, toColor);
                 }
                 else
                 {
-                    if (lastDataIndex >= 0)
+                    serieData.context.highlight = false;
-                        serie.GetSerieData(lastDataIndex).context.highlight = false;
+                    var colorIndex = chart.GetLegendRealShowNameIndex(serieData.legendName);
-                    serie.context.pointerItemDataIndex = -1;
+                    var color = SerieHelper.GetItemColor(serie, serieData, chart.theme, colorIndex, false);
+                    var toColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, colorIndex, false);
+                    serieData.interact.SetValueAndColor(ref needInteract, serieData.context.outsideRadius, color, toColor);
                 }
             }
-            else
+            if (needInteract)
             {
-                if (lastPointerEnter)
+                chart.RefreshPainter(serie);
-                {
-                    foreach (var serieData in serie.data)
-                        serieData.context.highlight = false;
-                }
-                serie.context.pointerItemDataIndex = -1;
             }
         }
 
@@ -291,6 +313,9 @@ namespace XCharts
                 return;
             }
             var dataChanging = false;
+            var interacting = false;
+            var color = ColorUtil.clearColor32;
+            var toColor = ColorUtil.clearColor32;
             var data = serie.data;
             serie.animation.InitProgress(0, 360);
             for (int n = 0; n < data.Count; n++)
@@ -304,20 +329,22 @@ namespace XCharts
                     dataChanging = true;
 
                 var itemStyle = SerieHelper.GetItemStyle(serie, serieData, serieData.context.highlight);
-                var serieNameCount = chart.m_LegendRealShowName.IndexOf(serieData.legendName);
+                var colorIndex = chart.GetLegendRealShowNameIndex(serieData.legendName);
-
+                var outsideRadius = 0f;
-                var color = SerieHelper.GetItemColor(serie, serieData, chart.theme, serieNameCount,
-                    serieData.context.highlight);
-
-                var toColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, serieNameCount,
-                    serieData.context.highlight);
 
                 var borderWidth = itemStyle.borderWidth;
                 var borderColor = itemStyle.borderColor;
 
                 var progress = AnimationStyleHelper.CheckDataAnimation(chart, serie, n, 1);
                 var insideRadius = serieData.context.insideRadius * progress;
-                var outsideRadius = serieData.context.outsideRadius * progress;
+
+                //if (!serieData.interact.TryGetValueAndColor(ref outsideRadius, ref color, ref toColor, ref interacting))
+                {
+                    color = SerieHelper.GetItemColor(serie, serieData, chart.theme, colorIndex, serieData.context.highlight);
+                    toColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, colorIndex, serieData.context.highlight);
+                    outsideRadius = serieData.context.outsideRadius * progress;
+                    serieData.interact.SetValueAndColor(ref interacting, outsideRadius, color, toColor);
+                }
 
                 if (serie.pieClickOffset && serieData.selected)
                 {

Assets/XCharts/Runtime/Serie/Radar/Radar.cs

@@ -24,9 +24,7 @@ namespace XCharts
             chart.AddChartComponentWhenNoExist<RadarCoord>();
             var serie = chart.AddSerie<Radar>(serieName);
             serie.symbol.show = true;
-            serie.symbol.type = SymbolType.EmptyCircle;
+            serie.symbol.type = SymbolType.Circle;
-            serie.symbol.size = 4;
-            serie.symbol.selectedSize = 6;
             serie.showDataName = true;
             List<double> data = new List<double>();
             for (int i = 0; i < 5; i++)

Assets/XCharts/Runtime/Serie/Radar/RadarHandler.cs

@@ -15,6 +15,7 @@ namespace XCharts
     [UnityEngine.Scripting.Preserve]
     internal sealed class RadarHandler : SerieHandler<Radar>
     {
+        private RadarCoord m_RadarCoord;
         public override void Update()
         {
             base.Update();
@@ -160,12 +161,20 @@ namespace XCharts
             return true;
         }
 
-
-
         private void UpdateSerieContext()
         {
-            if (!chart.isPointerInChart) return;
+            var needCheck = serie.context.isLegendEnter || (chart.isPointerInChart && m_RadarCoord.IsPointerEnter());
+            var needInteract = false;
+            var needHideAll = false;
+            if (!needCheck)
+            {
+                if (m_LastCheckContextFlag == needCheck)
+                    return;
+                needHideAll = true;
+            }
+            m_LastCheckContextFlag = needCheck;
             serie.context.pointerEnter = false;
+            serie.context.pointerItemDataIndex = -1;
             switch (serie.radarType)
             {
                 case RadarType.Multiple:
@@ -173,14 +182,27 @@ namespace XCharts
                     {
                         var serieData = serie.data[i];
                         serieData.index = i;
-                        foreach (var pos in serieData.context.dataPoints)
+                        var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
+                        var symbolSize = symbol.GetSize(serieData.data, chart.theme.serie.lineSymbolSize);
+                        if (needHideAll || serie.context.isLegendEnter)
                         {
-                            if (Vector3.Distance(chart.pointerPos, pos) < serie.symbol.size * 2)
+                            serieData.context.highlight = needHideAll ? false : true;
+                            serieData.interact.SetValue(ref needInteract, symbolSize, serieData.context.highlight);
+                        }
+                        else
+                        {
+                            serieData.context.highlight = false;
+                            foreach (var pos in serieData.context.dataPoints)
                             {
-                                serie.context.pointerEnter = true;
+                                if (Vector3.Distance(chart.pointerPos, pos) < symbolSize * 2)
-                                serie.context.pointerItemDataIndex = i;
+                                {
-                                return;
+                                    serie.context.pointerEnter = true;
+                                    serie.context.pointerItemDataIndex = i;
+                                    serieData.context.highlight = true;
+                                    break;
+                                }
                             }
+                            serieData.interact.SetValue(ref needInteract, symbolSize, serieData.context.highlight);
                         }
                     }
                     break;
@@ -198,23 +220,27 @@ namespace XCharts
                     }
                     break;
             }
+            if (needInteract)
+            {
+                chart.RefreshPainter(serie);
+            }
         }
 
         private void DrawMutipleRadar(VertexHelper vh)
         {
             if (!serie.show) return;
-            var radar = chart.GetChartComponent<RadarCoord>(serie.radarIndex);
+            m_RadarCoord = chart.GetChartComponent<RadarCoord>(serie.radarIndex);
-            if (radar == null) return;
+            if (m_RadarCoord == null) return;
 
-            serie.containerIndex = radar.index;
+            serie.containerIndex = m_RadarCoord.index;
-            serie.containterInstanceId = radar.instanceId;
+            serie.containterInstanceId = m_RadarCoord.instanceId;
 
             var startPoint = Vector3.zero;
             var toPoint = Vector3.zero;
             var firstPoint = Vector3.zero;
-            var indicatorNum = radar.indicatorList.Count;
+            var indicatorNum = m_RadarCoord.indicatorList.Count;
             var angle = 2 * Mathf.PI / indicatorNum;
-            var centerPos = radar.context.center;
+            var centerPos = m_RadarCoord.context.center;
             serie.animation.InitProgress(0, 1);
             if (!serie.show || serie.animation.HasFadeOut())
             {
@@ -222,8 +248,9 @@ namespace XCharts
             }
             var rate = serie.animation.GetCurrRate();
             var dataChanging = false;
+            var interacting = false;
             var dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
-            SerieHelper.GetAllMinMaxData(serie, radar.ceilRate);
+            SerieHelper.GetAllMinMaxData(serie, m_RadarCoord.ceilRate);
             for (int j = 0; j < serie.data.Count; j++)
             {
                 var serieData = serie.data[j];
@@ -232,26 +259,26 @@ namespace XCharts
                 {
                     continue;
                 }
-                var isHighlight = serie.context.pointerEnter;
+                var isHighlight = serieData.context.highlight;
                 var areaColor = SerieHelper.GetAreaColor(serie, chart.theme, j, isHighlight);
                 var areaToColor = SerieHelper.GetAreaToColor(serie, chart.theme, j, isHighlight);
                 var lineColor = SerieHelper.GetLineColor(serie, chart.theme, j, isHighlight);
                 var lineWidth = serie.lineStyle.GetWidth(chart.theme.serie.lineWidth);
-                int dataCount = radar.indicatorList.Count;
+                int dataCount = m_RadarCoord.indicatorList.Count;
                 serieData.context.dataPoints.Clear();
                 for (int n = 0; n < dataCount; n++)
                 {
                     if (n >= serieData.data.Count) break;
-                    var max = radar.GetIndicatorMax(n);
+                    var max = m_RadarCoord.GetIndicatorMax(n);
                     var value = serieData.GetCurrData(n, dataChangeDuration);
                     if (serieData.IsDataChanged()) dataChanging = true;
                     if (max == 0)
                     {
                         max = serie.context.dataMax;
                     }
-                    var radius = (float)(max < 0 ? radar.context.dataRadius - radar.context.dataRadius * value / max
+                    var radius = (float)(max < 0 ? m_RadarCoord.context.dataRadius - m_RadarCoord.context.dataRadius * value / max
-                    : radar.context.dataRadius * value / max);
+                    : m_RadarCoord.context.dataRadius * value / max);
-                    var currAngle = (n + (radar.positionType == RadarCoord.PositionType.Between ? 0.5f : 0)) * angle;
+                    var currAngle = (n + (m_RadarCoord.positionType == RadarCoord.PositionType.Between ? 0.5f : 0)) * angle;
                     radius *= rate;
                     if (n == 0)
                     {
@@ -288,10 +315,17 @@ namespace XCharts
                     for (int m = 0; m < serieData.context.dataPoints.Count; m++)
                     {
                         var point = serieData.context.dataPoints[m];
-                        isHighlight = serie.context.pointerEnter;
                         var symbolSize = isHighlight
                             ? serie.symbol.GetSelectedSize(null, chart.theme.serie.lineSymbolSelectedSize)
                             : serie.symbol.GetSize(null, chart.theme.serie.lineSymbolSize);
+                        if (!serieData.interact.TryGetValue(ref symbolSize, ref interacting))
+                        {
+                            symbolSize = isHighlight
+                                ? serie.symbol.GetSelectedSize(serieData.data, symbolSize)
+                                : serie.symbol.GetSize(serieData.data, symbolSize);
+                            serieData.interact.SetValue(ref interacting, symbolSize);
+                            symbolSize = serie.animation.GetSysmbolSize(symbolSize);
+                        }
                         var symbolColor = SerieHelper.GetItemColor(serie, serieData, chart.theme, j, isHighlight);
                         var symbolToColor = SerieHelper.GetItemToColor(serie, serieData, chart.theme, j, isHighlight);
                         var symbolEmptyColor = SerieHelper.GetItemBackgroundColor(serie, serieData, chart.theme, j, isHighlight, false);
@@ -307,7 +341,7 @@ namespace XCharts
                 serie.animation.CheckProgress(1);
                 chart.RefreshPainter(serie);
             }
-            if (dataChanging)
+            if (dataChanging || interacting)
             {
                 chart.RefreshPainter(serie);
             }

Assets/XCharts/Runtime/Serie/Scatter/BaseScatterHandler.cs

@@ -15,6 +15,8 @@ namespace XCharts
     [UnityEngine.Scripting.Preserve]
     internal class BaseScatterHandler<T> : SerieHandler<T> where T : BaseScatter
     {
+        private GridCoord m_Grid;
+
         public override void Update()
         {
             UpdateSerieContext();
@@ -54,6 +56,26 @@ namespace XCharts
             paramList.Add(param);
         }
 
+        public override bool OnLegendButtonEnter(int index, string legendName)
+        {
+            if (chart.GetLegendRealShowNameIndex(serie.serieName) == index)
+            {
+                serie.context.isLegendEnter = true;
+                return true;
+            }
+            return false;
+        }
+
+        public override bool OnLegendButtonExit(int index, string legendName)
+        {
+            if (chart.GetLegendRealShowNameIndex(serie.serieName) == index)
+            {
+                serie.context.isLegendEnter = false;
+                return true;
+            }
+            return false;
+        }
+
         public override void DrawSerie(VertexHelper vh)
         {
             var colorIndex = chart.GetLegendRealShowNameIndex(serie.legendName);
@@ -70,58 +92,44 @@ namespace XCharts
 
         private void UpdateSerieContext()
         {
-            if (serie.IsUseCoord<GridCoord>())
+            var needCheck = serie.context.isLegendEnter || (chart.isPointerInChart && (m_Grid == null || m_Grid.IsPointerEnter()));
+
+            var needHideAll = false;
+            if (!needCheck)
             {
-                var grid = chart.GetChartComponent<GridCoord>(serie.containerIndex);
+                if (m_LastCheckContextFlag == needCheck)
-                if (grid == null)
-                    return;
-
-                if (!grid.IsPointerEnter())
                     return;
+                needHideAll = true;
             }
-
+            m_LastCheckContextFlag = needCheck;
-            var lastDataIndex = serie.context.pointerItemDataIndex;
-            var maxCount = serie.maxShow > 0 ?
-                (serie.maxShow > serie.dataCount ? serie.dataCount : serie.maxShow)
-                : serie.dataCount;
-            var themeSymbolSize = chart.theme.serie.scatterSymbolSize;
-
-            if (lastDataIndex >= 0)
-            {
-                var serieData = serie.GetSerieData(lastDataIndex);
-                var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
-                var symbolSize = symbol.GetSize(serieData.data, themeSymbolSize);
-                if (Vector3.Distance(serieData.context.position, chart.pointerPos) <= symbolSize)
-                {
-                    serieData.context.highlight = true;
-                    serie.context.pointerItemDataIndex = lastDataIndex;
-                    return;
-                }
-            }
-            serie.context.pointerEnter = false;
             serie.context.pointerItemDataIndex = -1;
-            if (lastDataIndex >= 0)
+            serie.context.pointerEnter = false;
-            {
+            var themeSymbolSize = chart.theme.serie.scatterSymbolSize;
-                serie.GetSerieData(lastDataIndex).context.highlight = false;
+            var themeSymbolSelectedSize = chart.theme.serie.scatterSymbolSelectedSize;
-                chart.RefreshPainter(serie);
+            var needInteract = false;
-            }
             for (int i = serie.dataCount - 1; i >= 0; i--)
             {
                 var serieData = serie.data[i];
-
                 var symbol = SerieHelper.GetSerieSymbol(serie, serieData);
-                if (!symbol.ShowSymbol(serieData.index, maxCount))
-                    continue;
-
                 var symbolSize = symbol.GetSize(serieData.data, themeSymbolSize);
-                if (Vector3.Distance(serieData.context.position, chart.pointerPos) <= symbolSize)
+                var symbolSelectedSize = symbol.GetSelectedSize(serieData.data, themeSymbolSelectedSize);
+                if (serie.context.isLegendEnter ||
+                    (!needHideAll && Vector3.Distance(serieData.context.position, chart.pointerPos) <= symbolSize))
                 {
-                    serieData.context.highlight = true;
                     serie.context.pointerItemDataIndex = i;
                     serie.context.pointerEnter = true;
-                    chart.RefreshPainter(serie);
+                    serieData.context.highlight = true;
-                    break;
+                    serieData.interact.SetValue(ref needInteract, symbolSelectedSize);
                 }
+                else
+                {
+                    serieData.context.highlight = false;
+                    serieData.interact.SetValue(ref needInteract, symbolSize);
+                }
+            }
+            if (needInteract)
+            {
+                chart.RefreshPainter(serie);
             }
         }
 
@@ -141,8 +149,7 @@ namespace XCharts
             if (!chart.TryGetChartComponent<YAxis>(out yAxis, serie.yAxisIndex))
                 return;
 
-            GridCoord grid;
+            if (!chart.TryGetChartComponent<GridCoord>(out m_Grid, xAxis.gridIndex))
-            if (!chart.TryGetChartComponent<GridCoord>(out grid, xAxis.gridIndex))
                 return;
 
             DataZoom xDataZoom;
@@ -157,11 +164,12 @@ namespace XCharts
             var rate = serie.animation.GetCurrRate();
             var dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
             var dataChanging = false;
+            var interacting = false;
             var dataList = serie.GetDataList(xDataZoom);
             var isEffectScatter = serie is EffectScatter;
 
-            serie.containerIndex = grid.index;
+            serie.containerIndex = m_Grid.index;
-            serie.containterInstanceId = grid.instanceId;
+            serie.containterInstanceId = m_Grid.instanceId;
 
             foreach (var serieData in dataList)
             {
@@ -181,28 +189,29 @@ namespace XCharts
                 if (serieData.IsDataChanged())
                     dataChanging = true;
 
-                float pX = grid.context.x + xAxis.axisLine.GetWidth(theme.axis.lineWidth);
+                float pX = m_Grid.context.x + xAxis.axisLine.GetWidth(theme.axis.lineWidth);
-                float pY = grid.context.y + yAxis.axisLine.GetWidth(theme.axis.lineWidth);
+                float pY = m_Grid.context.y + yAxis.axisLine.GetWidth(theme.axis.lineWidth);
-                float xDataHig = GetDataHig(xAxis, xValue, grid.context.width);
+                float xDataHig = GetDataHig(xAxis, xValue, m_Grid.context.width);
-                float yDataHig = GetDataHig(yAxis, yValue, grid.context.height);
+                float yDataHig = GetDataHig(yAxis, yValue, m_Grid.context.height);
                 var pos = new Vector3(pX + xDataHig, pY + yDataHig);
 
-                if (!grid.Contains(pos))
+                if (!m_Grid.Contains(pos))
                     continue;
 
                 serie.context.dataPoints.Add(pos);
                 serieData.context.position = pos;
                 var datas = serieData.data;
-                float symbolSize = 0;
+                var symbolSize = serie.highlight || serieData.context.highlight
+                    ? theme.serie.scatterSymbolSelectedSize
+                    : theme.serie.scatterSymbolSize;
+                if (!serieData.interact.TryGetValue(ref symbolSize, ref interacting))
+                {
+                    symbolSize = highlight
+                        ? symbol.GetSelectedSize(serieData.data, symbolSize)
+                        : symbol.GetSize(serieData.data, symbolSize);
+                    serieData.interact.SetValue(ref interacting, symbolSize);
+                }
 
-                if (serie.highlight || serieData.context.highlight)
-                {
-                    symbolSize = symbol.GetSelectedSize(datas, theme.serie.scatterSymbolSelectedSize);
-                }
-                else
-                {
-                    symbolSize = symbol.GetSize(datas, theme.serie.scatterSymbolSize);
-                }
                 symbolSize *= rate;
 
                 if (isEffectScatter)
@@ -227,7 +236,7 @@ namespace XCharts
                 serie.animation.CheckProgress(1);
                 chart.RefreshPainter(serie);
             }
-            if (dataChanging)
+            if (dataChanging || interacting)
             {
                 chart.RefreshPainter(serie);
             }

Assets/XCharts/Runtime/Serie/SerieContext.cs

@@ -36,6 +36,9 @@ namespace XCharts
         /// 鼠标所在轴线上的数据项索引（可能有多个）
         /// </summary>
         public List<int> pointerAxisDataIndexs = new List<int>();
+        public bool isTriggerByAxis = false;
+        public bool isLegendEnter = false;
+        public int legendEnterIndex;
         /// <summary>
         /// 中心点
         /// </summary>
@@ -88,7 +91,7 @@ namespace XCharts
         /// <summary>
         /// 数据对应的位置坐标是否忽略（忽略时连线是透明的），dataIgnore 和 dataPoints 一一对应。
         /// </summary>
-        public List<bool> dataIgnore = new List<bool>();
+        public List<bool> dataIgnores = new List<bool>();
         /// <summary>
         /// 排序后的数据
         /// </summary>

Assets/XCharts/Runtime/Serie/SerieData.cs

@@ -5,6 +5,7 @@
 /*                                              */
 /************************************************/
 
+using System;
 using System.Collections.Generic;
 using UnityEngine;
 
@@ -31,7 +32,8 @@ namespace XCharts
         [SerializeField] private List<double> m_Data = new List<double>();
         [SerializeField] private List<int> m_Children = new List<int>();
 
-        public SerieDataContext context = new SerieDataContext();
+        [NonSerialized] public SerieDataContext context = new SerieDataContext();
+        [NonSerialized] public InteractData interact = new InteractData();
         public ChartLabel labelObject { get; set; }
 
         private bool m_Show = true;
@@ -117,6 +119,7 @@ namespace XCharts
             context.canShowLabel = true;
             context.highlight = false;
             m_Radius = 0;
+            interact.Reset();
             m_Data.Clear();
             m_PreviousData.Clear();
             m_DataUpdateTime.Clear();

Assets/XCharts/Runtime/Serie/SerieHandler.cs

@@ -50,6 +50,7 @@ namespace XCharts
         protected GameObject m_SerieRoot;
         protected bool m_InitedLabel;
         protected bool m_RefreshLabel;
+        protected bool m_LastCheckContextFlag = false;
 
         public T serie { get; internal set; }
 
@@ -152,8 +153,9 @@ namespace XCharts
             if (serie.IsPerformanceMode()) return false;
             if (count == -1) count = serie.dataCount;
             var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
+            var serieEmphasisLabel = SerieHelper.GetSerieEmphasisLabel(serie, serieData);
             var iconStyle = SerieHelper.GetIconStyle(serie, serieData);
-            if (!serieLabel.show && !iconStyle.show) return false;
+            if (!serieLabel.show && (serieEmphasisLabel == null || !serieEmphasisLabel.show) && !iconStyle.show) return false;
             var textName = ChartCached.GetSerieLabelName(s_SerieLabelObjectName, serie.index, serieData.index);
             var color = Color.grey;
             if (serie.useDataNameForColor)

Assets/XCharts/Runtime/Theme/SerieTheme.cs

@@ -15,10 +15,9 @@ namespace XCharts
     {
         [SerializeField] protected float m_LineWidth;
         [SerializeField] protected float m_LineSymbolSize;
-        [SerializeField] protected float m_LineSymbolSelectedSize;
         [SerializeField] protected float m_ScatterSymbolSize;
-        [SerializeField] protected float m_ScatterSymbolSelectedSize;
         [SerializeField] protected float m_PieTooltipExtraRadius;
+        [SerializeField] protected float m_SelectedRate = 1.3f;
         [SerializeField] protected float m_PieSelectedOffset;
         [SerializeField] protected Color32 m_CandlestickColor = new Color32(194, 53, 49, 255);
         [SerializeField] protected Color32 m_CandlestickColor0 = new Color32(49, 70, 86, 255);
@@ -40,20 +39,17 @@ namespace XCharts
             get { return m_LineSymbolSize; }
             set { if (PropertyUtil.SetStruct(ref m_LineSymbolSize, value)) SetVerticesDirty(); }
         }
-        public float lineSymbolSelectedSize
+        public float lineSymbolSelectedSize { get { return lineSymbolSize * selectedRate; } }
-        {
-            get { return m_LineSymbolSelectedSize; }
-            set { if (PropertyUtil.SetStruct(ref m_LineSymbolSelectedSize, value)) SetVerticesDirty(); }
-        }
         public float scatterSymbolSize
         {
             get { return m_ScatterSymbolSize; }
             set { if (PropertyUtil.SetStruct(ref m_ScatterSymbolSize, value)) SetVerticesDirty(); }
         }
-        public float scatterSymbolSelectedSize
+        public float scatterSymbolSelectedSize { get { return scatterSymbolSize * selectedRate; } }
+        public float selectedRate
         {
-            get { return m_ScatterSymbolSelectedSize; }
+            get { return m_SelectedRate; }
-            set { if (PropertyUtil.SetStruct(ref m_ScatterSymbolSelectedSize, value)) SetVerticesDirty(); }
+            set { if (PropertyUtil.SetStruct(ref m_SelectedRate, value)) SetVerticesDirty(); }
         }
 
         /// <summary>
@@ -118,9 +114,8 @@ namespace XCharts
         {
             m_LineWidth = theme.lineWidth;
             m_LineSymbolSize = theme.lineSymbolSize;
-            m_LineSymbolSelectedSize = theme.lineSymbolSelectedSize;
             m_ScatterSymbolSize = theme.scatterSymbolSize;
-            m_ScatterSymbolSelectedSize = theme.scatterSymbolSelectedSize;
+            selectedRate = theme.selectedRate;
             m_PieTooltipExtraRadius = theme.pieTooltipExtraRadius;
             m_PieSelectedOffset = theme.pieSelectedOffset;
             m_CandlestickColor = theme.candlestickColor;
@@ -134,9 +129,7 @@ namespace XCharts
         {
             m_LineWidth = XCSettings.serieLineWidth;
             m_LineSymbolSize = XCSettings.serieLineSymbolSize;
-            m_LineSymbolSelectedSize = XCSettings.serieLineSymbolSelectedSize;
             m_ScatterSymbolSize = XCSettings.serieScatterSymbolSize;
-            m_ScatterSymbolSelectedSize = XCSettings.serieScatterSymbolSelectedSize;
             m_PieTooltipExtraRadius = XCSettings.pieTooltipExtraRadius;
             m_PieSelectedOffset = XCSettings.pieSelectedOffset;
             m_CandlestickBorderWidth = XCSettings.serieCandlestickBorderWidth;