增加DataZoom的orient参数设置水平或垂直样式

CHANGELOG-EN.md

@@ -38,6 +38,7 @@
 
 ## master
 
+* (2021.06.27) Add `DataZoom`'s `orient` parameter to set horizontal or vertical styles
 * (2021.06.21) Add `iconStyle`'s `AutoHideWhenLabelEmpty` to set whether the icon is automatically hidden when `label` is empty
 
 # # v2.2.3

CHANGELOG.md

@@ -38,6 +38,7 @@
 
 ## master
 
+* (2021.06.27) 增加`DataZoom`的`orient`参数设置水平或垂直样式
 * (2021.06.21) 增加`IconStyle`的`autoHideWhenLabelEmpty`参数设置当`label`为空时是否自动隐藏图标
 
 ## v2.2.3

Editor/PropertyDrawers/DataZoomDrawer.cs

@@ -24,6 +24,7 @@ namespace XCharts
                 var m_End = prop.FindPropertyRelative("m_End");
                 var m_MinShowNum = prop.FindPropertyRelative("m_MinShowNum");
                 ++EditorGUI.indentLevel;
+                PropertyField(prop, "m_Orient");
                 PropertyField(prop, "m_SupportInside");
                 PropertyField(prop, m_SupportSlider);
                 PropertyField(prop, "m_ZoomLock");

Examples/Runtime/Example00_CheatSheet.cs

@@ -67,7 +67,7 @@ namespace XCharts.Examples
             chart.grid.left = 50;
             chart.grid.top = 80;
 
-            chart.dataZoom.enable = false;
+            chart.dataZooms[0].enable = false;
             chart.visualMap.enable = false;
 
             chart.RemoveData();
@@ -204,56 +204,56 @@ namespace XCharts.Examples
             chart.title.subText = "DataZoom 区域缩放：可通过拖、拽、缩小、放大来观察细节数据";
             chart.grid.bottom = 70;
 
-            chart.dataZoom.enable = true;
+            chart.dataZooms[0].enable = true;
-            chart.dataZoom.supportInside = true;
+            chart.dataZooms[0].supportInside = true;
-            chart.dataZoom.supportSlider = true;
+            chart.dataZooms[0].supportSlider = true;
-            chart.dataZoom.start = 0;
+            chart.dataZooms[0].start = 0;
-            chart.dataZoom.end = 100;
+            chart.dataZooms[0].end = 100;
 
             chart.RefreshChart();
             for (int i = 0; i < 4; i++)
             {
-                chart.dataZoom.supportSlider = !chart.dataZoom.supportSlider;
+                chart.dataZooms[0].supportSlider = !chart.dataZooms[0].supportSlider;
                 chart.RefreshChart();
                 yield return new WaitForSeconds(0.2f);
             }
-            chart.dataZoom.supportSlider = true;
+            chart.dataZooms[0].supportSlider = true;
             chart.RefreshChart();
             yield return new WaitForSeconds(1f);
-            while (chart.dataZoom.start < 40)
+            while (chart.dataZooms[0].start < 40)
             {
-                chart.dataZoom.start += speed * Time.deltaTime * 0.8f;
+                chart.dataZooms[0].start += speed * Time.deltaTime * 0.8f;
                 chart.RefreshDataZoom();
                 chart.RefreshChart();
                 yield return null;
             }
-            while (chart.dataZoom.end > 60)
+            while (chart.dataZooms[0].end > 60)
             {
-                chart.dataZoom.end -= speed * Time.deltaTime * 0.8f;
+                chart.dataZooms[0].end -= speed * Time.deltaTime * 0.8f;
                 chart.RefreshDataZoom();
                 chart.RefreshChart();
                 yield return null;
             }
-            while (chart.dataZoom.start > 0)
+            while (chart.dataZooms[0].start > 0)
             {
-                chart.dataZoom.start -= speed * Time.deltaTime * 0.8f;
+                chart.dataZooms[0].start -= speed * Time.deltaTime * 0.8f;
-                chart.dataZoom.end -= speed * Time.deltaTime * 0.8f;
+                chart.dataZooms[0].end -= speed * Time.deltaTime * 0.8f;
                 chart.RefreshDataZoom();
                 chart.RefreshChart();
                 yield return null;
             }
-            while (chart.dataZoom.end < 100)
+            while (chart.dataZooms[0].end < 100)
             {
-                chart.dataZoom.start += speed * Time.deltaTime * 0.8f;
+                chart.dataZooms[0].start += speed * Time.deltaTime * 0.8f;
-                chart.dataZoom.end += speed * Time.deltaTime * 0.8f;
+                chart.dataZooms[0].end += speed * Time.deltaTime * 0.8f;
                 chart.RefreshDataZoom();
                 chart.RefreshChart();
                 yield return null;
             }
-            while (chart.dataZoom.start > 0 || chart.dataZoom.end < 100)
+            while (chart.dataZooms[0].start > 0 || chart.dataZooms[0].end < 100)
             {
-                chart.dataZoom.start -= speed * Time.deltaTime * 0.8f;
+                chart.dataZooms[0].start -= speed * Time.deltaTime * 0.8f;
-                chart.dataZoom.end += speed * Time.deltaTime * 0.8f;
+                chart.dataZooms[0].end += speed * Time.deltaTime * 0.8f;
                 chart.RefreshDataZoom();
                 chart.RefreshChart();
                 yield return null;

Runtime/Component/Main/DataZoom.cs

@@ -96,6 +96,7 @@ namespace XCharts
         [SerializeField] private int m_MinShowNum = 1;
         [Range(1f, 20f)]
         [SerializeField] private float m_ScrollSensitivity = 1.1f;
+        [SerializeField] private Orient m_Orient = Orient.Horizonal;
         [SerializeField] private TextStyle m_TextStyle;
         [SerializeField] private LineStyle m_LineStyle = new LineStyle(LineStyle.Type.Solid);
         [SerializeField] private AreaStyle m_AreaStyle = new AreaStyle();
@@ -332,6 +333,18 @@ namespace XCharts
             get { return m_ScrollSensitivity; }
             set { if (PropertyUtil.SetStruct(ref m_ScrollSensitivity, value)) SetVerticesDirty(); }
         }
+
+        /// <summary>
+        /// Specify whether the layout of dataZoom component is horizontal or vertical. What's more, 
+        /// it indicates whether the horizontal axis or vertical axis is controlled by default in catesian coordinate system.
+        /// 布局方式是横还是竖。不仅是布局方式，对于直角坐标系而言，也决定了，缺省情况控制横向数轴还是纵向数轴。
+        /// </summary>
+        /// <value></value>
+        public Orient orient
+        {
+            get { return m_Orient; }
+            set { if (PropertyUtil.SetStruct(ref m_Orient, value)) SetVerticesDirty(); }
+        }
         /// <summary>
         /// font style.
         /// 文字格式。
@@ -374,6 +387,7 @@ namespace XCharts
         /// 运行时实际范围的结束值
         /// </summary>
         public float runtimeEndValue { get; internal set; }
+        public bool runtimeInvert { get; set; }
 
         class AxisIndexValueInfo
         {
@@ -415,6 +429,7 @@ namespace XCharts
                     rangeMode = RangeMode.Percent,
                     start = 30,
                     end = 70,
+                    m_Orient = Orient.Horizonal,
                     m_ScrollSensitivity = 10,
                     m_TextStyle = new TextStyle(),
                     m_LineStyle = new LineStyle(LineStyle.Type.Solid)
@@ -444,22 +459,44 @@ namespace XCharts
             {
                 return false;
             }
-            return false;
+            return true;
         }
 
         /// <summary>
         /// 给定的坐标是否在选中区域内
         /// </summary>
         /// <param name="pos"></param>
-        /// <param name="startX"></param>
-        /// <param name="width"></param>
         /// <returns></returns>
         public bool IsInSelectedZoom(Vector2 pos)
         {
+            switch (m_Orient)
+            {
+                case Orient.Horizonal:
                     var start = runtimeX + runtimeWidth * m_Start / 100;
                     var end = runtimeX + runtimeWidth * m_End / 100;
-            Rect rect = Rect.MinMaxRect(start, runtimeY, end, runtimeY + runtimeHeight);
+                    return ChartHelper.IsInRect(pos, start, end, runtimeY, runtimeY + runtimeHeight);
-            return rect.Contains(pos);
+                case Orient.Vertical:
+                    start = runtimeY + runtimeHeight * m_Start / 100;
+                    end = runtimeY + runtimeHeight * m_End / 100;
+                    return ChartHelper.IsInRect(pos, runtimeX, runtimeX + runtimeWidth, start, end);
+                default: return false;
+            }
+        }
+
+
+        public bool IsInSelectedZoom(int totalIndex, int index, bool invert)
+        {
+            if (totalIndex <= 0) return false;
+            var tstart = invert ? 100 - end : start;
+            var tend = invert ? 100 - start : end;
+            var range = Mathf.RoundToInt(totalIndex * (tend - tstart) / 100);
+            var min = Mathf.FloorToInt(totalIndex * tstart / 100);
+            var max = Mathf.CeilToInt(totalIndex * tend / 100);
+            if (min == 0) max = min + range;
+            if (max == totalIndex) min = max - range;
+            var flag = index >= min && index < min + range;
+            //Debug.LogError("check:" + index + "," + totalIndex + "," + range + "," + min + "," + max + "," + flag);
+            return flag;
         }
 
         /// <summary>
@@ -471,9 +508,16 @@ namespace XCharts
         /// <returns></returns>
         public bool IsInStartZoom(Vector2 pos)
         {
+            switch (m_Orient)
+            {
+                case Orient.Horizonal:
                     var start = runtimeX + runtimeWidth * m_Start / 100;
-            Rect rect = Rect.MinMaxRect(start - 10, runtimeY, start + 10, runtimeY + runtimeHeight);
+                    return ChartHelper.IsInRect(pos, start - 10, start + 10, runtimeY, runtimeY + runtimeHeight);
-            return rect.Contains(pos);
+                case Orient.Vertical:
+                    start = runtimeY + runtimeHeight * m_Start / 100;
+                    return ChartHelper.IsInRect(pos, runtimeX, runtimeX + runtimeWidth, start - 10, start + 10);
+                default: return false;
+            }
         }
 
         /// <summary>
@@ -485,14 +529,23 @@ namespace XCharts
         /// <returns></returns>
         public bool IsInEndZoom(Vector2 pos)
         {
+            switch (m_Orient)
+            {
+                case Orient.Horizonal:
                     var end = runtimeX + runtimeWidth * m_End / 100;
-            Rect rect = Rect.MinMaxRect(end - 10, runtimeY, end + 10, runtimeY + runtimeHeight);
+                    return ChartHelper.IsInRect(pos, end - 10, end + 10, runtimeY, runtimeY + runtimeHeight);
-            return rect.Contains(pos);
+                case Orient.Vertical:
+                    end = runtimeY + runtimeHeight * m_End / 100;
+                    return ChartHelper.IsInRect(pos, runtimeX, runtimeX + runtimeWidth, end - 10, end + 10);
+                default: return false;
             }
+        }
+
 
         public bool IsContainsAxis(Axis axis)
         {
-            if (axis is XAxis) return xAxisIndexs.Contains(axis.index);
+            if (axis == null) return false;
+            else if (axis is XAxis) return xAxisIndexs.Contains(axis.index);
             else if (axis is YAxis) return yAxisIndexs.Contains(axis.index);
             else return false;
         }
@@ -693,7 +746,15 @@ namespace XCharts
             if (chart == null) return;
             foreach (var dataZoom in chart.dataZooms)
             {
-                DrawDataZoomSlider(vh, dataZoom);
+                switch (dataZoom.orient)
+                {
+                    case Orient.Horizonal:
+                        DrawHorizonalDataZoomSlider(vh, dataZoom);
+                        break;
+                    case Orient.Vertical:
+                        DrawVerticalDataZoomSlider(vh, dataZoom);
+                        break;
+                }
             }
         }
 
@@ -718,6 +779,8 @@ namespace XCharts
                     }
                 }
                 if (dataZoom.supportSlider)
+                {
+                    if (!dataZoom.zoomLock)
                     {
                         if (dataZoom.IsInStartZoom(pos))
                         {
@@ -732,6 +795,11 @@ namespace XCharts
                             dataZoom.runtimeDrag = true;
                         }
                     }
+                    else if (dataZoom.IsInSelectedZoom(pos))
+                    {
+                        dataZoom.runtimeDrag = true;
+                    }
+                }
             }
         }
 
@@ -742,10 +810,19 @@ namespace XCharts
             foreach (var dataZoom in chart.dataZooms)
             {
                 var grid = chart.GetDataZoomGridOrDefault(dataZoom);
-                float deltaX = eventData.delta.x;
+                switch (dataZoom.orient)
-                float deltaPercent = deltaX / grid.runtimeWidth * 100;
+                {
+                    case Orient.Horizonal:
+                        var deltaPercent = eventData.delta.x / grid.runtimeWidth * 100;
                         OnDragInside(dataZoom, deltaPercent);
                         OnDragSlider(dataZoom, deltaPercent);
+                        break;
+                    case Orient.Vertical:
+                        deltaPercent = eventData.delta.y / grid.runtimeHeight * 100;
+                        OnDragInside(dataZoom, deltaPercent);
+                        OnDragSlider(dataZoom, deltaPercent);
+                        break;
+                }
             }
         }
 
@@ -799,10 +876,9 @@ namespace XCharts
                         endX = grid.runtimeX + grid.runtimeWidth;
                         startX = grid.runtimeX + grid.runtimeWidth - selectWidth;
                     }
-                    dataZoom.start = (startX - grid.runtimeX) / grid.runtimeWidth * 100;
+                    var start = (startX - grid.runtimeX) / grid.runtimeWidth * 100;
-                    dataZoom.end = (endX - grid.runtimeX) / grid.runtimeWidth * 100;
+                    var end = (endX - grid.runtimeX) / grid.runtimeWidth * 100;
-                    RefreshDataZoomLabel();
+                    UpdateDataZoomRange(dataZoom, start, end);
-                    chart.RefreshChart();
                 }
             }
         }
@@ -810,41 +886,47 @@ namespace XCharts
         {
             if (chart == null) return;
             if (Input.touchCount > 1) return;
+            Vector2 pos;
+            if (!chart.ScreenPointToChartPoint(eventData.position, out pos)) return;
             foreach (var dataZoom in chart.dataZooms)
             {
-                if (!dataZoom.enable || dataZoom.zoomLock) return;
+                if (!dataZoom.enable || dataZoom.zoomLock) continue;
-                Vector2 pos;
-                if (!chart.ScreenPointToChartPoint(eventData.position, out pos))
-                {
-                    return;
-                }
                 var grid = chart.GetDataZoomGridOrDefault(dataZoom);
-                if (!chart.IsInGrid(grid, pos) && !dataZoom.IsInSelectedZoom(pos))
+                if ((dataZoom.supportInside && chart.IsInGrid(grid, pos)) ||
+                    dataZoom.IsInZoom(pos))
                 {
-                    return;
-                }
                     ScaleDataZoom(dataZoom, eventData.scrollDelta.y * dataZoom.scrollSensitivity);
                 }
             }
+        }
 
         private void OnDragInside(DataZoom dataZoom, float deltaPercent)
         {
+            if (deltaPercent == 0) return;
             if (Input.touchCount > 1) return;
             if (!dataZoom.supportInside) return;
             if (!dataZoom.runtimeCoordinateDrag) return;
             var diff = dataZoom.end - dataZoom.start;
             if (deltaPercent > 0)
             {
-                dataZoom.start -= deltaPercent;
+                if (dataZoom.start > 0)
-                dataZoom.end = dataZoom.start + diff;
+                {
+                    var start = dataZoom.start - deltaPercent;
+                    if (start < 0) start = 0;
+                    var end = start + diff;
+                    UpdateDataZoomRange(dataZoom, start, end);
+                }
             }
             else
             {
-                dataZoom.end += -deltaPercent;
+                if (dataZoom.end < 100)
-                dataZoom.start = dataZoom.end - diff;
+                {
+                    var end = dataZoom.end - deltaPercent;
+                    if (end > 100) end = 100;
+                    var start = end - diff;
+                    UpdateDataZoomRange(dataZoom, start, end);
+                }
             }
-            RefreshDataZoomLabel();
-            chart.RefreshChart();
         }
 
         private void OnDragSlider(DataZoom dataZoom, float deltaPercent)
@@ -853,84 +935,70 @@ namespace XCharts
             if (!dataZoom.supportSlider) return;
             if (dataZoom.runtimeStartDrag)
             {
-                dataZoom.start += deltaPercent;
+                var start = dataZoom.start + deltaPercent;
-                if (dataZoom.start > dataZoom.end)
+                if (start > dataZoom.end)
                 {
-                    dataZoom.start = dataZoom.end;
+                    start = dataZoom.end;
                     dataZoom.runtimeEndDrag = true;
                     dataZoom.runtimeStartDrag = false;
                 }
-                if (dataZoom.realtime)
+                UpdateDataZoomRange(dataZoom, start, dataZoom.end);
-                {
-                    RefreshDataZoomLabel();
-                    chart.RefreshChart();
-                }
             }
             else if (dataZoom.runtimeEndDrag)
             {
-                dataZoom.end += deltaPercent;
+                var end = dataZoom.end + deltaPercent;
-                if (dataZoom.end < dataZoom.start)
+                if (end < dataZoom.start)
                 {
-                    dataZoom.end = dataZoom.start;
+                    end = dataZoom.start;
                     dataZoom.runtimeStartDrag = true;
                     dataZoom.runtimeEndDrag = false;
                 }
-                if (dataZoom.realtime)
+                UpdateDataZoomRange(dataZoom, dataZoom.start, end);
-                {
-                    RefreshDataZoomLabel();
-                    chart.RefreshChart();
-                }
             }
             else if (dataZoom.runtimeDrag)
             {
                 if (deltaPercent > 0)
                 {
-                    if (dataZoom.end + deltaPercent > 100)
+                    if (dataZoom.end + deltaPercent > 100) deltaPercent = 100 - dataZoom.end;
-                    {
-                        deltaPercent = 100 - dataZoom.end;
-                    }
                 }
                 else
                 {
-                    if (dataZoom.start + deltaPercent < 0)
+                    if (dataZoom.start + deltaPercent < 0) deltaPercent = -dataZoom.start;
-                    {
-                        deltaPercent = -dataZoom.start;
-                    }
-                }
-                dataZoom.start += deltaPercent;
-                dataZoom.end += deltaPercent;
-                if (dataZoom.realtime)
-                {
-                    RefreshDataZoomLabel();
-                    chart.RefreshChart();
                 }
+                UpdateDataZoomRange(dataZoom, dataZoom.start + deltaPercent, dataZoom.end + deltaPercent);
             }
         }
 
         private void ScaleDataZoom(DataZoom dataZoom, float delta)
         {
             var grid = chart.GetDataZoomGridOrDefault(dataZoom);
-            float deltaPercent = Mathf.Abs(delta / grid.runtimeWidth * 100);
+            var deltaPercent = dataZoom.orient == Orient.Horizonal ?
+                     Mathf.Abs(delta / grid.runtimeWidth * 100) :
+                      Mathf.Abs(delta / grid.runtimeHeight * 100);
             if (delta > 0)
             {
                 if (dataZoom.end <= dataZoom.start) return;
-                dataZoom.end -= deltaPercent;
+                UpdateDataZoomRange(dataZoom, dataZoom.start + deltaPercent, dataZoom.end - deltaPercent);
-                dataZoom.start += deltaPercent;
-                if (dataZoom.end <= dataZoom.start)
-                {
-                    dataZoom.end = dataZoom.start;
-                }
             }
             else
             {
-                dataZoom.end += deltaPercent;
+                UpdateDataZoomRange(dataZoom, dataZoom.start - deltaPercent, dataZoom.end + deltaPercent);
-                dataZoom.start -= deltaPercent;
-                if (dataZoom.end > 100) dataZoom.end = 100;
-                if (dataZoom.start < 0) dataZoom.start = 0;
             }
-            RefreshDataZoomLabel();
+        }
+
+        public void UpdateDataZoomRange(DataZoom dataZoom, float start, float end)
+        {
+            if (end > 100) end = 100;
+            if (start < 0) start = 0;
+            if (end < start) end = start;
+            dataZoom.start = start;
+            dataZoom.end = end;
+            if (dataZoom.realtime)
+            {
+                chart.OnDataZoomRangeChanged(dataZoom);
                 chart.RefreshChart();
             }
+        }
 
         public void RefreshDataZoomLabel()
         {
@@ -1017,7 +1085,7 @@ namespace XCharts
             }
         }
 
-        private void DrawDataZoomSlider(VertexHelper vh, DataZoom dataZoom)
+        private void DrawHorizonalDataZoomSlider(VertexHelper vh, DataZoom dataZoom)
         {
             if (!dataZoom.enable || !dataZoom.supportSlider) return;
             var p1 = new Vector3(dataZoom.runtimeX, dataZoom.runtimeY);
@@ -1097,5 +1165,86 @@ namespace XCharts
                     break;
             }
         }
+
+        private void DrawVerticalDataZoomSlider(VertexHelper vh, DataZoom dataZoom)
+        {
+            if (!dataZoom.enable || !dataZoom.supportSlider) return;
+            var p1 = new Vector3(dataZoom.runtimeX, dataZoom.runtimeY);
+            var p2 = new Vector3(dataZoom.runtimeX, dataZoom.runtimeY + dataZoom.runtimeHeight);
+            var p3 = new Vector3(dataZoom.runtimeX + dataZoom.runtimeWidth, dataZoom.runtimeY + dataZoom.runtimeHeight);
+            var p4 = new Vector3(dataZoom.runtimeX + dataZoom.runtimeWidth, dataZoom.runtimeY);
+            var lineColor = dataZoom.lineStyle.GetColor(chart.theme.dataZoom.dataLineColor);
+            var lineWidth = dataZoom.lineStyle.GetWidth(chart.theme.dataZoom.dataLineWidth);
+            var borderWidth = dataZoom.borderWidth == 0 ? chart.theme.dataZoom.borderWidth : dataZoom.borderWidth;
+            var borderColor = dataZoom.GetBorderColor(chart.theme.dataZoom.borderColor);
+            var backgroundColor = dataZoom.GetBackgroundColor(chart.theme.dataZoom.backgroundColor);
+            var areaColor = dataZoom.areaStyle.GetColor(chart.theme.dataZoom.dataAreaColor);
+            UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, backgroundColor);
+            var centerPos = new Vector3(dataZoom.runtimeX + dataZoom.runtimeWidth / 2,
+                dataZoom.runtimeY + dataZoom.runtimeHeight / 2);
+            UGL.DrawBorder(vh, centerPos, dataZoom.runtimeWidth, dataZoom.runtimeHeight, borderWidth, borderColor);
+            if (dataZoom.showDataShadow && chart.series.Count > 0)
+            {
+                Serie serie = chart.series.list[0];
+                Axis axis = chart.GetYAxis(0);
+                var showData = serie.GetDataList(null);
+                float scaleWid = dataZoom.runtimeHeight / (showData.Count - 1);
+                Vector3 lp = Vector3.zero;
+                Vector3 np = Vector3.zero;
+                float minValue = 0;
+                float maxValue = 0;
+                SeriesHelper.GetYMinMaxValue(chart.series, null, 0, chart.IsValue(), axis.inverse, out minValue, out maxValue);
+                AxisHelper.AdjustMinMaxValue(axis, ref minValue, ref maxValue, true);
+
+                int rate = 1;
+                var sampleDist = serie.sampleDist < 2 ? 2 : serie.sampleDist;
+                var maxCount = showData.Count;
+                if (sampleDist > 0) rate = (int)((maxCount - serie.minShow) / (dataZoom.runtimeHeight / sampleDist));
+                if (rate < 1) rate = 1;
+                var totalAverage = serie.sampleAverage > 0 ? serie.sampleAverage :
+                    chart.DataAverage(ref showData, serie.sampleType, serie.minShow, maxCount, rate);
+                var dataChanging = false;
+                for (int i = 0; i < maxCount; i += rate)
+                {
+                    float value = chart.SampleValue(ref showData, serie.sampleType, rate, serie.minShow, maxCount, totalAverage, i,
+                    serie.animation.GetUpdateAnimationDuration(), ref dataChanging, axis);
+                    float pY = dataZoom.runtimeY + i * scaleWid;
+                    float dataHig = (maxValue - minValue) == 0 ? 0 :
+                        (value - minValue) / (maxValue - minValue) * dataZoom.runtimeWidth;
+                    np = new Vector3(chart.chartX + chart.chartWidth - dataZoom.right - dataHig, pY);
+                    if (i > 0)
+                    {
+                        UGL.DrawLine(vh, lp, np, lineWidth, lineColor);
+                        Vector3 alp = new Vector3(lp.x, lp.y - lineWidth);
+                        Vector3 anp = new Vector3(np.x, np.y - lineWidth);
+
+                        Vector3 tnp = new Vector3(np.x, chart.chartY + dataZoom.bottom + lineWidth);
+                        Vector3 tlp = new Vector3(lp.x, chart.chartY + dataZoom.bottom + lineWidth);
+                        UGL.DrawQuadrilateral(vh, alp, anp, tnp, tlp, areaColor);
+                    }
+                    lp = np;
+                }
+                if (dataChanging)
+                {
+                    chart.RefreshTopPainter();
+                }
+            }
+            switch (dataZoom.rangeMode)
+            {
+                case DataZoom.RangeMode.Percent:
+                    var start = dataZoom.runtimeY + dataZoom.runtimeHeight * dataZoom.start / 100;
+                    var end = dataZoom.runtimeY + dataZoom.runtimeHeight * dataZoom.end / 100;
+                    var fillerColor = dataZoom.GetFillerColor(chart.theme.dataZoom.fillerColor);
+
+                    p1 = new Vector2(dataZoom.runtimeX, start);
+                    p2 = new Vector2(dataZoom.runtimeX + dataZoom.runtimeWidth, start);
+                    p3 = new Vector2(dataZoom.runtimeX + dataZoom.runtimeWidth, end);
+                    p4 = new Vector2(dataZoom.runtimeX, end);
+                    UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, fillerColor);
+                    UGL.DrawLine(vh, p1, p2, lineWidth, fillerColor);
+                    UGL.DrawLine(vh, p3, p4, lineWidth, fillerColor);
+                    break;
+            }
+        }
     }
 }

Runtime/Helper/DataZoomHelper.cs

@@ -5,25 +5,40 @@
 /*                                              */
 /************************************************/
 using System.Collections.Generic;
+using UnityEngine;
 
 namespace XCharts
 {
     public static class DataZoomHelper
     {
-        public static DataZoom GetDataZoom(Serie serie, List<DataZoom> dataZooms)
+        public static DataZoom GetAxisRelatedDataZoom(Axis axis, List<DataZoom> dataZooms)
         {
-            if (serie == null) return null;
             foreach (var dataZoom in dataZooms)
             {
                 if (!dataZoom.enable) continue;
-                if (dataZoom.IsContainsXAxis(serie.xAxisIndex)
+                if (dataZoom.IsContainsAxis(axis)) return dataZoom;
-                    || dataZoom.IsContainsYAxis(serie.yAxisIndex))
-                {
-                    return dataZoom;
-                }
             }
             return null;
         }
+        public static void GetSerieRelatedDataZoom(Serie serie, List<DataZoom> dataZooms,
+            out DataZoom xDataZoom, out DataZoom yDataZoom)
+        {
+            xDataZoom = null;
+            yDataZoom = null;
+            if (serie == null) return;
+            foreach (var dataZoom in dataZooms)
+            {
+                if (!dataZoom.enable) continue;
+                if (dataZoom.IsContainsXAxis(serie.xAxisIndex))
+                {
+                    xDataZoom = dataZoom;
+                }
+                if (dataZoom.IsContainsYAxis(serie.yAxisIndex))
+                {
+                    yDataZoom = dataZoom;
+                }
+            }
+        }
 
         public static void UpdateDataZoomRuntimeStartEndValue(DataZoom dataZoom, Serie serie)
         {
@@ -35,23 +50,33 @@ namespace XCharts
             dataZoom.runtimeEndValue = min + (max - min) * dataZoom.end / 100;
         }
 
-        public static void UpdateDataZoomRuntimeStartEndValue(List<DataZoom> dataZooms, Series series, SerieType serieType)
+        public static void UpdateDataZoomRuntimeStartEndValue(CoordinateChart chart, SerieType serieType)
         {
-            foreach (var dataZoom in dataZooms)
+            foreach (var dataZoom in chart.dataZooms)
             {
                 if (!dataZoom.enable) continue;
                 float min = float.MaxValue;
                 float max = float.MinValue;
-                foreach (var serie in series.list)
+                foreach (var serie in chart.series.list)
                 {
                     if (!serie.show || serie.type != serieType) continue;
-                    if (!dataZoom.IsXAxisIndexValue(serie.xAxisIndex)) continue;
+                    if (!dataZoom.IsContainsXAxis(serie.xAxisIndex)) continue;
+                    var axis = chart.GetXAxis(serie.xAxisIndex);
+                    
+                    if (axis.minMaxType == Axis.AxisMinMaxType.Custom)
+                    {
+                        if (axis.min < min) min = axis.min;
+                        if (axis.max > max) max = axis.max;
+                    }
+                    else
+                    {
                         var serieMinValue = 0f;
                         var serieMaxValue = 0f;
                         SerieHelper.GetMinMaxData(serie, out serieMinValue, out serieMaxValue, null, 2);
                         if (serieMinValue < min) min = serieMinValue;
                         if (serieMaxValue > max) max = serieMaxValue;
                     }
+                }
                 dataZoom.runtimeStartValue = min + (max - min) * dataZoom.start / 100;
                 dataZoom.runtimeEndValue = min + (max - min) * dataZoom.end / 100;
             }

Runtime/Internal/BaseChart.cs

@@ -774,6 +774,10 @@ namespace XCharts
         {
         }
 
+        public virtual void OnDataZoomRangeChanged(DataZoom dataZoom)
+        {
+        }
+
         public override void OnPointerDown(PointerEventData eventData)
         {
             base.OnPointerDown(eventData);

Runtime/Internal/CoordinateChart.cs

@@ -75,6 +75,20 @@ namespace XCharts
             RefreshSeriePainterByGridIndex(grid.index);
         }
 
+        public override void OnDataZoomRangeChanged(DataZoom dataZoom)
+        {
+            foreach (var index in dataZoom.xAxisIndexs)
+            {
+                var axis = GetXAxis(index);
+                if (axis != null && axis.show) axis.SetAllDirty();
+            }
+            foreach (var index in dataZoom.yAxisIndexs)
+            {
+                var axis = GetYAxis(index);
+                if (axis != null && axis.show) axis.SetAllDirty();
+            }
+        }
+
         protected override void DrawPainterBase(VertexHelper vh)
         {
             base.DrawPainterBase(vh);
@@ -122,8 +136,8 @@ namespace XCharts
             var lp3 = new Vector3(grid.runtimeX - yLineDiff, m_ChartY + chartHeight);
             var lp4 = new Vector3(grid.runtimeX - yLineDiff, m_ChartY);
             UGL.DrawQuadrilateral(vh, lp1, lp2, lp3, lp4, backgroundColor);
-            var rp1 = new Vector3(grid.runtimeX + grid.runtimeWidth + xSplitDiff, m_ChartY);
+            var rp1 = new Vector3(grid.runtimeX + grid.runtimeWidth, m_ChartY);
-            var rp2 = new Vector3(grid.runtimeX + grid.runtimeWidth + xSplitDiff, m_ChartY + chartHeight);
+            var rp2 = new Vector3(grid.runtimeX + grid.runtimeWidth, m_ChartY + chartHeight);
             var rp3 = new Vector3(m_ChartX + chartWidth, m_ChartY + chartHeight);
             var rp4 = new Vector3(m_ChartX + chartWidth, m_ChartY);
             UGL.DrawQuadrilateral(vh, rp1, rp2, rp3, rp4, backgroundColor);
@@ -244,7 +258,6 @@ namespace XCharts
         protected virtual void UpdateTooltipValue(Vector2 local)
         {
             var isCartesian = IsValue();
-            var dataCount = m_Series.list.Count > 0 ? m_Series.list[0].GetDataList(dataZoom).Count : 0;
             var grid = GetGrid(tooltip.runtimeGridIndex);
             for (int i = 0; i < m_XAxes.Count; i++)
             {
@@ -289,9 +302,11 @@ namespace XCharts
                 }
                 else if (IsCategory())
                 {
-                    for (int j = 0; j < xAxis.GetDataNumber(dataZoom); j++)
+                    var dataZoomX = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
+                    var dataCount = m_Series.list.Count > 0 ? m_Series.list[0].GetDataList(dataZoomX).Count : 0;
+                    for (int j = 0; j < xAxis.GetDataNumber(dataZoomX); j++)
                     {
-                        float splitWid = AxisHelper.GetDataWidth(xAxis, grid.runtimeWidth, dataCount, dataZoom);
+                        float splitWid = AxisHelper.GetDataWidth(xAxis, grid.runtimeWidth, dataCount, dataZoomX);
                         float pX = grid.runtimeX + j * splitWid;
                         if ((xAxis.boundaryGap && (local.x > pX && local.x <= pX + splitWid)) ||
                             (!xAxis.boundaryGap && (local.x > pX - splitWid / 2 && local.x <= pX + splitWid / 2)))
@@ -301,9 +316,11 @@ namespace XCharts
                             break;
                         }
                     }
-                    for (int j = 0; j < yAxis.GetDataNumber(dataZoom); j++)
+                    var dataZoomY = DataZoomHelper.GetAxisRelatedDataZoom(yAxis, dataZooms);
+                    dataCount = m_Series.list.Count > 0 ? m_Series.list[0].GetDataList(dataZoomY).Count : 0;
+                    for (int j = 0; j < yAxis.GetDataNumber(dataZoomY); j++)
                     {
-                        float splitWid = AxisHelper.GetDataWidth(yAxis, grid.runtimeHeight, dataCount, dataZoom);
+                        float splitWid = AxisHelper.GetDataWidth(yAxis, grid.runtimeHeight, dataCount, dataZoomY);
                         float pY = grid.runtimeY + j * splitWid;
                         if ((yAxis.boundaryGap && (local.y > pY && local.y <= pY + splitWid)) ||
                             (!yAxis.boundaryGap && (local.y > pY - splitWid / 2 && local.y <= pY + splitWid / 2)))
@@ -315,6 +332,8 @@ namespace XCharts
                 }
                 else if (xAxis.IsCategory())
                 {
+                    var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
+                    var dataCount = m_Series.list.Count > 0 ? m_Series.list[0].GetDataList(dataZoom).Count : 0;
                     var value = (yAxis.runtimeMaxValue - yAxis.runtimeMinValue) * (local.y - grid.runtimeY - yAxis.runtimeZeroYOffset) / grid.runtimeHeight;
                     if (yAxis.runtimeMinValue > 0) value += yAxis.runtimeMinValue;
                     tooltip.runtimeYValues[i] = value;
@@ -334,6 +353,8 @@ namespace XCharts
                 }
                 else if (yAxis.IsCategory())
                 {
+                    var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(yAxis, dataZooms);
+                    var dataCount = m_Series.list.Count > 0 ? m_Series.list[0].GetDataList(dataZoom).Count : 0;
                     var value = (xAxis.runtimeMaxValue - xAxis.runtimeMinValue) * (local.x - grid.runtimeX - xAxis.runtimeZeroXOffset) / grid.runtimeWidth;
                     if (xAxis.runtimeMinValue > 0) value += xAxis.runtimeMinValue;
                     tooltip.runtimeXValues[i] = value;
@@ -387,6 +408,7 @@ namespace XCharts
             }
             UpdateSerieGridIndex();
             RefreshSeriePainterByGridIndex(grid.index);
+            var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(tempAxis, dataZooms);
             var content = TooltipHelper.GetFormatterContent(tooltip, index, this, dataZoom, isCartesian);
             TooltipHelper.SetContentAndPosition(tooltip, content, chartRect);
             tooltip.SetActive(true);
@@ -454,6 +476,7 @@ namespace XCharts
             var labelText = "";
             var labelPos = Vector2.zero;
             var grid = GetAxisGridOrDefault(axis);
+            var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(axis, dataZooms);
             if (axis is XAxis)
             {
                 var posY = axisIndex > 0 ? grid.runtimeY + grid.runtimeHeight : grid.runtimeY;
@@ -550,6 +573,8 @@ namespace XCharts
                 ChartHelper.HideAllObject(axisObj);
                 var grid = GetAxisGridOrDefault(yAxis);
                 if (grid == null) return;
+                if (!yAxis.show) return;
+                var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(yAxis, dataZooms);
                 var axisLabelTextStyle = yAxis.axisLabel.textStyle;
                 int splitNumber = AxisHelper.GetScaleNumber(yAxis, grid.runtimeHeight, dataZoom);
                 float totalWidth = 0;
@@ -675,6 +700,7 @@ namespace XCharts
                 if (grid == null) return;
                 if (!xAxis.show) return;
                 var axisLabelTextStyle = xAxis.axisLabel.textStyle;
+                var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
                 int splitNumber = AxisHelper.GetScaleNumber(xAxis, grid.runtimeWidth, dataZoom);
                 float totalWidth = 0;
                 float eachWidth = AxisHelper.GetEachWidth(xAxis, grid.runtimeWidth, dataZoom);
@@ -902,6 +928,7 @@ namespace XCharts
                             Mathf.Abs(axis.runtimeMinValue) * (grid.runtimeHeight / (Mathf.Abs(axis.runtimeMinValue) + Mathf.Abs(axis.runtimeMaxValue)));
                     }
                 }
+                var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(axis, dataZooms);
                 if (dataZoom != null && dataZoom.enable)
                 {
                     if (axis is XAxis) dataZoom.SetXAxisIndexValueInfo(axisIndex, tempMinValue, tempMaxValue);
@@ -946,6 +973,7 @@ namespace XCharts
             if (grid == null || axis == null) return;
             float runtimeWidth = axis is XAxis ? grid.runtimeWidth : grid.runtimeHeight;
             var isPercentStack = SeriesHelper.IsPercentStack(m_Series, SerieType.Bar);
+            var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(axis, dataZooms);
             axis.UpdateLabelText(runtimeWidth, dataZoom, isPercentStack, 500);
         }
 
@@ -1024,6 +1052,7 @@ namespace XCharts
             {
                 var grid = GetAxisGridOrDefault(yAxis);
                 if (grid == null) return;
+                var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(yAxis, dataZooms);
                 var size = AxisHelper.GetScaleNumber(yAxis, grid.runtimeWidth, dataZoom);
                 var totalWidth = grid.runtimeY;
                 var xAxis = GetRelatedXAxis(yAxis);
@@ -1068,6 +1097,7 @@ namespace XCharts
             if (AxisHelper.NeedShowSplit(yAxis))
             {
                 var grid = GetAxisGridOrDefault(yAxis);
+                var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(yAxis, dataZooms);
                 var size = AxisHelper.GetScaleNumber(yAxis, grid.runtimeWidth, dataZoom);
                 var totalWidth = grid.runtimeY;
                 for (int i = 0; i < size; i++)
@@ -1140,6 +1170,7 @@ namespace XCharts
             {
                 var grid = GetAxisGridOrDefault(xAxis);
                 if (grid == null) return;
+                var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
                 var size = AxisHelper.GetScaleNumber(xAxis, grid.runtimeWidth, dataZoom);
                 var totalWidth = grid.runtimeX;
                 var yAxis = m_YAxes[xAxisIndex];
@@ -1184,6 +1215,7 @@ namespace XCharts
             var grid = GetAxisGridOrDefault(xAxis);
             if (AxisHelper.NeedShowSplit(xAxis))
             {
+                var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
                 var size = AxisHelper.GetScaleNumber(xAxis, grid.runtimeWidth, dataZoom);
                 var totalWidth = grid.runtimeX;
                 var yAxis = m_YAxes[xAxisIndex];
@@ -1295,7 +1327,7 @@ namespace XCharts
             if (!tooltip.show || !tooltip.IsSelected()) return;
             if (tooltip.type == Tooltip.Type.None) return;
             if (tooltip.runtimeGridIndex < 0) return;
-            int dataCount = m_Series.list.Count > 0 ? m_Series.list[0].GetDataList(dataZoom).Count : 0;
+
             var grid = GetGrid(tooltip.runtimeGridIndex);
             if (grid == null) return;
             var lineType = tooltip.lineStyle.GetType(m_Theme.tooltip.lineType);
@@ -1305,6 +1337,8 @@ namespace XCharts
                 var xAxis = m_XAxes[i];
                 if (!xAxis.show) continue;
                 if (tooltip.runtimeXValues[i] < 0) continue;
+                var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
+                int dataCount = m_Series.list.Count > 0 ? m_Series.list[0].GetDataList(dataZoom).Count : 0;
                 float splitWidth = AxisHelper.GetDataWidth(xAxis, grid.runtimeWidth, dataCount, dataZoom);
                 switch (tooltip.type)
                 {
@@ -1345,7 +1379,7 @@ namespace XCharts
             if (!tooltip.show || !tooltip.IsSelected()) return;
             if (tooltip.type == Tooltip.Type.None) return;
             if (tooltip.runtimeGridIndex < 0) return;
-            int dataCount = m_Series.list.Count > 0 ? m_Series.list[0].GetDataList(dataZoom).Count : 0;
+
             var grid = GetGrid(tooltip.runtimeGridIndex);
             if (grid == null) return;
             var lineType = tooltip.lineStyle.GetType(m_Theme.tooltip.lineType);
@@ -1355,6 +1389,8 @@ namespace XCharts
                 var yAxis = m_YAxes[i];
                 if (!yAxis.show) continue;
                 if (tooltip.runtimeYValues[i] < 0) continue;
+                var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(yAxis, dataZooms);
+                int dataCount = m_Series.list.Count > 0 ? m_Series.list[0].GetDataList(dataZoom).Count : 0;
                 float splitWidth = AxisHelper.GetDataWidth(yAxis, grid.runtimeHeight, dataCount, dataZoom);
                 switch (tooltip.type)
                 {
@@ -1389,7 +1425,12 @@ namespace XCharts
 
         private void CheckRaycastTarget()
         {
-            var ray = (dataZoom != null && dataZoom.enable)
+            var anyDataZoom = false;
+            foreach (var dataZoom in dataZooms)
+            {
+                if (dataZoom.enable) anyDataZoom = true;
+            }
+            var ray = anyDataZoom
                 || (visualMap != null && visualMap.enable && visualMap.show && visualMap.calculable);
             if (raycastTarget != ray)
             {

Runtime/Internal/CoordinateChart_DrawBar.cs

@@ -25,6 +25,7 @@ namespace XCharts
             var xAxis = m_XAxes[serie.xAxisIndex];
             var yAxis = m_YAxes[serie.yAxisIndex];
             var grid = GetSerieGridOrDefault(serie);
+            var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(yAxis, dataZooms);
             var showData = serie.GetDataList(dataZoom);
             float categoryWidth = AxisHelper.GetDataWidth(yAxis, grid.runtimeHeight, showData.Count, dataZoom);
             float barGap = Internal_GetBarGap(SerieType.Bar);
@@ -170,10 +171,11 @@ namespace XCharts
         {
             if (!IsActive(serie.index)) return;
             if (serie.animation.HasFadeOut()) return;
-            var showData = serie.GetDataList(dataZoom);
             var yAxis = m_YAxes[serie.yAxisIndex];
             var xAxis = m_XAxes[serie.xAxisIndex];
             var grid = GetSerieGridOrDefault(serie);
+            var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
+            var showData = serie.GetDataList(dataZoom);
             var isStack = SeriesHelper.IsStack(m_Series, serie.stack, SerieType.Bar);
             m_StackSerieData.Clear();
             if (isStack) SeriesHelper.UpdateStackDataList(m_Series, serie, dataZoom, m_StackSerieData);

Runtime/Internal/CoordinateChart_DrawCandlestick.cs

@@ -17,10 +17,11 @@ namespace XCharts
         {
             if (!IsActive(serie.index)) return;
             if (serie.animation.HasFadeOut()) return;
-            var showData = serie.GetDataList(dataZoom);
             var yAxis = m_YAxes[serie.yAxisIndex];
             var xAxis = m_XAxes[serie.xAxisIndex];
             var grid = GetSerieGridOrDefault(serie);
+            var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
+            var showData = serie.GetDataList(dataZoom);
             float categoryWidth = AxisHelper.GetDataWidth(xAxis, grid.runtimeWidth, showData.Count, dataZoom);
             float barWidth = serie.GetBarWidth(categoryWidth);
             float space = (categoryWidth - barWidth) / 2;

Runtime/Internal/CoordinateChart_DrawLine.cs

@@ -91,6 +91,10 @@ namespace XCharts
         {
             if (!IsActive(serie.index)) return;
             if (serie.animation.HasFadeOut()) return;
+            var yAxis = GetSerieYAxisOrDefault(serie);
+            var xAxis = GetSerieXAxisOrDefault(serie);
+            var grid = GetSerieGridOrDefault(serie);
+            var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(xAxis, dataZooms);
             var showData = serie.GetDataList(dataZoom);
             if (showData.Count <= 0) return;
             Color32 lineColor = SerieHelper.GetLineColor(serie, m_Theme, colorIndex, serie.highlighted);
@@ -100,9 +104,6 @@ namespace XCharts
             Color32 highlightAreaToColor = SerieHelper.GetAreaToColor(serie, m_Theme, colorIndex, true);
             Color32 areaColor, areaToColor;
             Vector3 lp = Vector3.zero, np = Vector3.zero, llp = Vector3.zero, nnp = Vector3.zero;
-            var yAxis = GetSerieYAxisOrDefault(serie);
-            var xAxis = GetSerieXAxisOrDefault(serie);
-            var grid = GetSerieGridOrDefault(serie);
             var zeroPos = new Vector3(grid.runtimeX, grid.runtimeY + yAxis.runtimeZeroYOffset);
             var isStack = SeriesHelper.IsStack(m_Series, serie.stack, SerieType.Line);
             m_StackSerieData.Clear();
@@ -497,7 +498,6 @@ namespace XCharts
         {
             if (!IsActive(serie.index)) return;
             if (serie.animation.HasFadeOut()) return;
-            var showData = serie.GetDataList(dataZoom);
             Vector3 lp = Vector3.zero;
             Vector3 np = Vector3.zero;
             Vector3 llp = Vector3.zero;
@@ -511,6 +511,8 @@ namespace XCharts
             var xAxis = m_XAxes[serie.xAxisIndex];
             var yAxis = m_YAxes[serie.yAxisIndex];
             var grid = GetSerieGridOrDefault(serie);
+            var dataZoom = DataZoomHelper.GetAxisRelatedDataZoom(yAxis, dataZooms);
+            var showData = serie.GetDataList(dataZoom);
             var zeroPos = new Vector3(grid.runtimeX + xAxis.runtimeZeroXOffset, grid.runtimeY);
             var isStack = SeriesHelper.IsStack(m_Series, serie.stack, SerieType.Line);
             m_StackSerieData.Clear();

Runtime/Internal/CoordinateChart_DrawScatter.cs

@@ -16,6 +16,8 @@ namespace XCharts
         {
             if (serie.animation.HasFadeOut()) return;
             if (!serie.show) return;
+            DataZoom xDataZoom, yDataZoom;
+            DataZoomHelper.GetSerieRelatedDataZoom(serie, dataZooms, out xDataZoom, out yDataZoom);
             var yAxis = m_YAxes[serie.yAxisIndex];
             var xAxis = m_XAxes[serie.xAxisIndex];
             var grid = GetSerieGridOrDefault(serie);
@@ -26,7 +28,7 @@ namespace XCharts
             var rate = serie.animation.GetCurrRate();
             var dataChangeDuration = serie.animation.GetUpdateAnimationDuration();
             var dataChanging = false;
-            var dataList = serie.GetDataList(dataZoom);
+            var dataList = serie.GetDataList(xDataZoom);
             foreach (var serieData in dataList)
             {
                 var symbol = SerieHelper.GetSerieSymbol(serie, serieData);