DataZoom.cs

/******************************************/
/*                                        */
/*     Copyright (c) 2021 monitor1394     */
/*     https://github.com/monitor1394     */
/*                                        */
/******************************************/
 
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using XUGL;
 
namespace XCharts
{
    [System.Serializable]
    public class DataZoom : MainComponent
    {
        public enum FilterMode
        {
            Filter,
            WeakFilter,
            Empty,
            None
        }
        public enum RangeMode
        {
            //Value,
            Percent
        }
        [SerializeField] private bool m_Enable;
        [SerializeField] private FilterMode m_FilterMode;
        [SerializeField] private List<int> m_XAxisIndexs = new List<int>() { 0 };
        [SerializeField] private List<int> m_YAxisIndexs = new List<int>() { };
        [SerializeField] private bool m_SupportInside;
        [SerializeField] private bool m_SupportInsideScroll = true;
        [SerializeField] private bool m_SupportInsideDrag = true;
        [SerializeField] private bool m_SupportSlider;
        [SerializeField] private bool m_SupportSelect;
        [SerializeField] private bool m_ShowDataShadow;
        [SerializeField] private bool m_ShowDetail;
        [SerializeField] private bool m_ZoomLock;
        [SerializeField] private bool m_Realtime;
        [SerializeField] protected Color32 m_FillerColor;
        [SerializeField] protected Color32 m_BorderColor;
        [SerializeField] protected float m_BorderWidth;
        [SerializeField] protected Color32 m_BackgroundColor;
        [SerializeField] private float m_Left;
        [SerializeField] private float m_Right;
        [SerializeField] private float m_Top;
        [SerializeField] private float m_Bottom;
        [SerializeField] private RangeMode m_RangeMode;
        [SerializeField] private float m_Start;
        [SerializeField] private float m_End;
        [SerializeField] private float m_StartValue;
        [SerializeField] private float m_EndValue;
        [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();
 
        public bool enable
        {
            get { return m_Enable; }
            set { if (PropertyUtil.SetStruct(ref m_Enable, value)) SetVerticesDirty(); }
        }
        public FilterMode filterMode
        {
            get { return m_FilterMode; }
            set { if (PropertyUtil.SetStruct(ref m_FilterMode, value)) SetVerticesDirty(); }
        }
        public List<int> xAxisIndexs
        {
            get { return m_XAxisIndexs; }
            set { if (PropertyUtil.SetClass(ref m_XAxisIndexs, value)) SetVerticesDirty(); }
        }
        public List<int> yAxisIndexs
        {
            get { return m_YAxisIndexs; }
            set { if (PropertyUtil.SetClass(ref m_YAxisIndexs, value)) SetVerticesDirty(); }
        }
        public bool supportInside
        {
            get { return m_SupportInside; }
            set { if (PropertyUtil.SetStruct(ref m_SupportInside, value)) SetVerticesDirty(); }
        }
        public bool supportInsideScroll
        {
            get { return m_SupportInsideScroll; }
            set { if (PropertyUtil.SetStruct(ref m_SupportInsideScroll, value)) SetVerticesDirty(); }
        }
        public bool supportInsideDrag
        {
            get { return m_SupportInsideDrag; }
            set { if (PropertyUtil.SetStruct(ref m_SupportInsideDrag, value)) SetVerticesDirty(); }
        }
        public bool supportSlider
        {
            get { return m_SupportSlider; }
            set { if (PropertyUtil.SetStruct(ref m_SupportSlider, value)) SetVerticesDirty(); }
        }
        private bool supportSelect
        {
            get { return m_SupportSelect; }
            set { if (PropertyUtil.SetStruct(ref m_SupportSelect, value)) SetVerticesDirty(); }
        }
        public bool showDataShadow
        {
            get { return m_ShowDataShadow; }
            set { if (PropertyUtil.SetStruct(ref m_ShowDataShadow, value)) SetVerticesDirty(); }
        }
        public bool showDetail
        {
            get { return m_ShowDetail; }
            set { if (PropertyUtil.SetStruct(ref m_ShowDetail, value)) SetVerticesDirty(); }
        }
        public bool zoomLock
        {
            get { return m_ZoomLock; }
            set { if (PropertyUtil.SetStruct(ref m_ZoomLock, value)) SetVerticesDirty(); }
        }
        public bool realtime { get { return true; } }
        public Color backgroundColor
        {
            get { return m_BackgroundColor; }
            set { if (PropertyUtil.SetStruct(ref m_BackgroundColor, value)) SetVerticesDirty(); }
        }
        public Color32 fillerColor
        {
            get { return m_FillerColor; }
            set { if (PropertyUtil.SetColor(ref m_FillerColor, value)) SetVerticesDirty(); }
        }
 
        public Color32 borderColor
        {
            get { return m_BorderColor; }
            set { if (PropertyUtil.SetColor(ref m_BorderColor, value)) SetComponentDirty(); }
        }
        public float borderWidth
        {
            get { return m_BorderWidth; }
            set { if (PropertyUtil.SetStruct(ref m_BorderWidth, value)) SetComponentDirty(); }
        }
        public float bottom
        {
            get { return m_Bottom; }
            set { if (PropertyUtil.SetStruct(ref m_Bottom, value)) SetVerticesDirty(); }
        }
        public float top
        {
            get { return m_Top; }
            set { if (PropertyUtil.SetStruct(ref m_Top, value)) SetVerticesDirty(); }
        }
        public float left
        {
            get { return m_Left; }
            set { if (PropertyUtil.SetStruct(ref m_Left, value)) SetVerticesDirty(); }
        }
        public float right
        {
            get { return m_Right; }
            set { if (PropertyUtil.SetStruct(ref m_Right, value)) SetVerticesDirty(); }
        }
        public RangeMode rangeMode
        {
            get { return m_RangeMode; }
            set { if (PropertyUtil.SetStruct(ref m_RangeMode, value)) SetVerticesDirty(); }
        }
        public float start
        {
            get { return m_Start; }
            set { m_Start = value; if (m_Start < 0) m_Start = 0; if (m_Start > 100) m_Start = 100; SetVerticesDirty(); }
        }
        public float end
        {
            get { return m_End; }
            set { m_End = value; if (m_End < 0) m_End = 0; if (m_End > 100) m_End = 100; SetVerticesDirty(); }
        }
        public int minShowNum
        {
            get { return m_MinShowNum; }
            set { if (PropertyUtil.SetStruct(ref m_MinShowNum, value)) SetVerticesDirty(); }
        }
        public float scrollSensitivity
        {
            get { return m_ScrollSensitivity; }
            set { if (PropertyUtil.SetStruct(ref m_ScrollSensitivity, value)) SetVerticesDirty(); }
        }
 
        public Orient orient
        {
            get { return m_Orient; }
            set { if (PropertyUtil.SetStruct(ref m_Orient, value)) SetVerticesDirty(); }
        }
        public TextStyle textStyle
        {
            get { return m_TextStyle; }
            set { if (PropertyUtil.SetClass(ref m_TextStyle, value)) SetComponentDirty(); }
        }
        public LineStyle lineStyle
        {
            get { return m_LineStyle; }
            set { if (PropertyUtil.SetClass(ref m_LineStyle, value)) SetComponentDirty(); }
        }
        public AreaStyle areaStyle
        {
            get { return m_AreaStyle; }
            set { if (PropertyUtil.SetClass(ref m_AreaStyle, value)) SetComponentDirty(); }
        }
        public int index { get; internal set; }
        public float runtimeX { get; private set; }
        public float runtimeY { get; private set; }
        public float runtimeWidth { get; private set; }
        public float runtimeHeight { get; private set; }
        public bool runtimeDrag { get; internal set; }
        public bool runtimeCoordinateDrag { get; internal set; }
        public bool runtimeStartDrag { get; internal set; }
        public bool runtimeEndDrag { get; internal set; }
        public double runtimeStartValue { get; internal set; }
        public double runtimeEndValue { get; internal set; }
        public bool runtimeInvert { get; set; }
 
        class AxisIndexValueInfo
        {
            public double min;
            public double max;
        }
        private Dictionary<int, AxisIndexValueInfo> m_XAxisIndexInfos = new Dictionary<int, AxisIndexValueInfo>();
        private Dictionary<int, AxisIndexValueInfo> m_YAxisIndexInfos = new Dictionary<int, AxisIndexValueInfo>();
 
        private ChartText m_StartLabel { get; set; }
        private ChartText m_EndLabel { get; set; }
 
        public static DataZoom defaultDataZoom
        {
            get
            {
                return new DataZoom()
                {
                    supportInside = true,
                    supportSlider = true,
                    filterMode = FilterMode.None,
                    xAxisIndexs = new List<int>() { 0 },
                    yAxisIndexs = new List<int>() { },
                    showDataShadow = true,
                    showDetail = false,
                    zoomLock = false,
                    m_Bottom = 10,
                    m_Left = 10,
                    m_Right = 10,
                    m_Top = 0.9f,
                    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)
                    {
                        opacity = 0.3f
                    },
                    m_AreaStyle = new AreaStyle()
                    {
                        show = true,
                        opacity = 0.3f,
                    },
                };
            }
        }
 
        public bool IsInZoom(Vector2 pos)
        {
            if (pos.x < runtimeX - 1 || pos.x > runtimeX + runtimeWidth + 1 ||
                pos.y < runtimeY - 1 || pos.y > runtimeY + runtimeHeight + 1)
            {
                return false;
            }
            return true;
        }
 
        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;
                    return ChartHelper.IsInRect(pos, start, end, runtimeY, runtimeY + runtimeHeight);
                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;
        }
 
        public bool IsInStartZoom(Vector2 pos)
        {
            switch (m_Orient)
            {
                case Orient.Horizonal:
                    var start = runtimeX + runtimeWidth * m_Start / 100;
                    return ChartHelper.IsInRect(pos, start - 10, start + 10, runtimeY, runtimeY + runtimeHeight);
                case Orient.Vertical:
                    start = runtimeY + runtimeHeight * m_Start / 100;
                    return ChartHelper.IsInRect(pos, runtimeX, runtimeX + runtimeWidth, start - 10, start + 10);
                default: return false;
            }
        }
 
        public bool IsInEndZoom(Vector2 pos)
        {
            switch (m_Orient)
            {
                case Orient.Horizonal:
                    var end = runtimeX + runtimeWidth * m_End / 100;
                    return ChartHelper.IsInRect(pos, end - 10, end + 10, runtimeY, runtimeY + runtimeHeight);
                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 == 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;
        }
        public bool IsContainsXAxis(int index)
        {
            return xAxisIndexs != null && xAxisIndexs.Contains(index);
        }
 
        public bool IsContainsYAxis(int index)
        {
            return yAxisIndexs != null && yAxisIndexs.Contains(index);
        }
 
        public Color32 GetFillerColor(Color32 themeColor)
        {
            if (ChartHelper.IsClearColor(fillerColor)) return themeColor;
            else return fillerColor;
        }
 
        public Color32 GetBackgroundColor(Color32 themeColor)
        {
            if (ChartHelper.IsClearColor(backgroundColor)) return themeColor;
            else return backgroundColor;
        }
        public Color32 GetBorderColor(Color32 themeColor)
        {
            if (ChartHelper.IsClearColor(borderColor)) return themeColor;
            else return borderColor;
        }
 
        internal void SetLabelActive(bool flag)
        {
            if (m_StartLabel != null && m_StartLabel.gameObject.activeInHierarchy != flag)
            {
                m_StartLabel.gameObject.SetActive(flag);
            }
            if (m_EndLabel != null && m_EndLabel.gameObject.activeInHierarchy != flag)
            {
                m_EndLabel.gameObject.SetActive(flag);
            }
        }
 
        internal void SetStartLabelText(string text)
        {
            if (m_StartLabel != null) m_StartLabel.SetText(text);
        }
 
        internal void SetEndLabelText(string text)
        {
            if (m_EndLabel != null) m_EndLabel.SetText(text);
        }
 
        internal void SetStartLabel(ChartText startLabel)
        {
            m_StartLabel = startLabel;
        }
 
        internal void SetEndLabel(ChartText endLabel)
        {
            m_EndLabel = endLabel;
        }
 
        internal void UpdateStartLabelPosition(Vector3 pos)
        {
            m_StartLabel.SetLocalPosition(pos);
        }
 
        internal void UpdateEndLabelPosition(Vector3 pos)
        {
            m_EndLabel.SetLocalPosition(pos);
        }
 
        internal void UpdateRuntimeData(float chartX, float chartY, float chartWidth, float chartHeight)
        {
            var runtimeLeft = left <= 1 ? left * chartWidth : left;
            var runtimeBottom = bottom <= 1 ? bottom * chartHeight : bottom;
            var runtimeTop = top <= 1 ? top * chartHeight : top;
            var runtimeRight = right <= 1 ? right * chartWidth : right;
            runtimeX = chartX + runtimeLeft;
            runtimeY = chartY + runtimeBottom;
            runtimeWidth = chartWidth - runtimeLeft - runtimeRight;
            runtimeHeight = chartHeight - runtimeTop - runtimeBottom;
        }
 
        internal void SetXAxisIndexValueInfo(int xAxisIndex, double min, double max)
        {
            if (!m_XAxisIndexInfos.ContainsKey(xAxisIndex))
            {
                m_XAxisIndexInfos[xAxisIndex] = new AxisIndexValueInfo()
                {
                    min = min,
                    max = max
                };
            }
            else
            {
                m_XAxisIndexInfos[xAxisIndex].min = min;
                m_XAxisIndexInfos[xAxisIndex].max = max;
            }
        }
 
        internal void SetYAxisIndexValueInfo(int yAxisIndex, double min, double max)
        {
            if (!m_YAxisIndexInfos.ContainsKey(yAxisIndex))
            {
                m_YAxisIndexInfos[yAxisIndex] = new AxisIndexValueInfo()
                {
                    min = min,
                    max = max
                };
            }
            else
            {
                m_YAxisIndexInfos[yAxisIndex].min = min;
                m_YAxisIndexInfos[yAxisIndex].max = max;
            }
        }
 
        internal bool IsXAxisIndexValue(int axisIndex)
        {
            return m_XAxisIndexInfos.ContainsKey(axisIndex);
        }
 
        internal bool IsYAxisIndexValue(int axisIndex)
        {
            return m_YAxisIndexInfos.ContainsKey(axisIndex);
        }
 
        internal void GetXAxisIndexValue(int axisIndex, out double min, out double max)
        {
            min = 0;
            max = 0;
            if (m_XAxisIndexInfos.ContainsKey(axisIndex))
            {
                var info = m_XAxisIndexInfos[axisIndex];
                min = info.min;
                max = info.max;
            }
        }
        internal void GetYAxisIndexValue(int axisIndex, out double min, out double max)
        {
            min = 0;
            max = 0;
            if (m_YAxisIndexInfos.ContainsKey(axisIndex))
            {
                var info = m_YAxisIndexInfos[axisIndex];
                min = info.min;
                max = info.max;
            }
        }
    }
 
 
    internal class DataZoomHandler : IComponentHandler
    {
        public CoordinateChart chart;
        private Vector2 m_LastTouchPos0;
        private Vector2 m_LastTouchPos1;
        private bool m_CheckDataZoomLabel;
        private float m_DataZoomLastStartIndex;
        private float m_DataZoomLastEndIndex;
 
        public DataZoomHandler(BaseChart chart)
        {
            this.chart = chart as CoordinateChart;
        }
 
        public void Init() { }
 
        public void Update()
        {
            if (chart == null) return;
            foreach (var dataZoom in chart.dataZooms)
            {
                CheckDataZoomScale(dataZoom);
                CheckDataZoomLabel(dataZoom);
            }
        }
 
        public void DrawBase(VertexHelper vh)
        {
        }
 
        public void DrawTop(VertexHelper vh)
        {
            if (chart == null) return;
            foreach (var dataZoom in chart.dataZooms)
            {
                switch (dataZoom.orient)
                {
                    case Orient.Horizonal:
                        DrawHorizonalDataZoomSlider(vh, dataZoom);
                        break;
                    case Orient.Vertical:
                        DrawVerticalDataZoomSlider(vh, dataZoom);
                        break;
                }
            }
        }
 
        public void OnBeginDrag(PointerEventData eventData)
        {
            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) continue;
                var grid = chart.GetDataZoomGridOrDefault(dataZoom);
                if (dataZoom.supportInside && dataZoom.supportInsideDrag)
                {
                    if (chart.IsInGrid(grid, pos))
                    {
                        dataZoom.runtimeCoordinateDrag = true;
                    }
                }
                if (dataZoom.supportSlider)
                {
                    if (!dataZoom.zoomLock)
                    {
                        if (dataZoom.IsInStartZoom(pos))
                        {
                            dataZoom.runtimeStartDrag = true;
                        }
                        else if (dataZoom.IsInEndZoom(pos))
                        {
                            dataZoom.runtimeEndDrag = true;
                        }
                        else if (dataZoom.IsInSelectedZoom(pos))
                        {
                            dataZoom.runtimeDrag = true;
                        }
                    }
                    else if (dataZoom.IsInSelectedZoom(pos))
                    {
                        dataZoom.runtimeDrag = true;
                    }
                }
            }
        }
 
        public void OnDrag(PointerEventData eventData)
        {
            if (chart == null) return;
            if (Input.touchCount > 1) return;
            foreach (var dataZoom in chart.dataZooms)
            {
                var grid = chart.GetDataZoomGridOrDefault(dataZoom);
                switch (dataZoom.orient)
                {
                    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;
                }
            }
        }
 
        public void OnEndDrag(PointerEventData eventData)
        {
            if (chart == null) return;
            foreach (var dataZoom in chart.dataZooms)
            {
                if (dataZoom.runtimeDrag || dataZoom.runtimeStartDrag || dataZoom.runtimeEndDrag
                    || dataZoom.runtimeCoordinateDrag)
                {
                    chart.RefreshChart();
                }
                dataZoom.runtimeDrag = false;
                dataZoom.runtimeCoordinateDrag = false;
                dataZoom.runtimeStartDrag = false;
                dataZoom.runtimeEndDrag = false;
            }
        }
        public void OnPointerDown(PointerEventData eventData)
        {
            if (chart == null) return;
            if (Input.touchCount > 1) return;
            Vector2 localPos;
            if (!chart.ScreenPointToChartPoint(eventData.position, out localPos))
            {
                return;
            }
            foreach (var dataZoom in chart.dataZooms)
            {
                var grid = chart.GetDataZoomGridOrDefault(dataZoom);
                if (dataZoom.IsInStartZoom(localPos) ||
                    dataZoom.IsInEndZoom(localPos))
                {
                    return;
                }
                if (dataZoom.IsInZoom(localPos)
                    && !dataZoom.IsInSelectedZoom(localPos))
                {
                    var pointerX = localPos.x;
                    var selectWidth = grid.runtimeWidth * (dataZoom.end - dataZoom.start) / 100;
                    var startX = pointerX - selectWidth / 2;
                    var endX = pointerX + selectWidth / 2;
                    if (startX < grid.runtimeX)
                    {
                        startX = grid.runtimeX;
                        endX = grid.runtimeX + selectWidth;
                    }
                    else if (endX > grid.runtimeX + grid.runtimeWidth)
                    {
                        endX = grid.runtimeX + grid.runtimeWidth;
                        startX = grid.runtimeX + grid.runtimeWidth - selectWidth;
                    }
                    var start = (startX - grid.runtimeX) / grid.runtimeWidth * 100;
                    var end = (endX - grid.runtimeX) / grid.runtimeWidth * 100;
                    UpdateDataZoomRange(dataZoom, start, end);
                }
            }
        }
        public void OnScroll(PointerEventData eventData)
        {
            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) continue;
                var grid = chart.GetDataZoomGridOrDefault(dataZoom);
                if ((dataZoom.supportInside && dataZoom.supportInsideScroll && chart.IsInGrid(grid, pos)) ||
                    dataZoom.IsInZoom(pos))
                {
                    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 || !dataZoom.supportInsideDrag) return;
            if (!dataZoom.runtimeCoordinateDrag) return;
            var diff = dataZoom.end - dataZoom.start;
            if (deltaPercent > 0)
            {
                if (dataZoom.start > 0)
                {
                    var start = dataZoom.start - deltaPercent;
                    if (start < 0) start = 0;
                    var end = start + diff;
                    UpdateDataZoomRange(dataZoom, start, end);
                }
            }
            else
            {
                if (dataZoom.end < 100)
                {
                    var end = dataZoom.end - deltaPercent;
                    if (end > 100) end = 100;
                    var start = end - diff;
                    UpdateDataZoomRange(dataZoom, start, end);
                }
            }
        }
 
        private void OnDragSlider(DataZoom dataZoom, float deltaPercent)
        {
            if (Input.touchCount > 1) return;
            if (!dataZoom.supportSlider) return;
            if (dataZoom.runtimeStartDrag)
            {
                var start = dataZoom.start + deltaPercent;
                if (start > dataZoom.end)
                {
                    start = dataZoom.end;
                    dataZoom.runtimeEndDrag = true;
                    dataZoom.runtimeStartDrag = false;
                }
                UpdateDataZoomRange(dataZoom, start, dataZoom.end);
            }
            else if (dataZoom.runtimeEndDrag)
            {
                var end = dataZoom.end + deltaPercent;
                if (end < dataZoom.start)
                {
                    end = dataZoom.start;
                    dataZoom.runtimeStartDrag = true;
                    dataZoom.runtimeEndDrag = false;
                }
                UpdateDataZoomRange(dataZoom, dataZoom.start, end);
            }
            else if (dataZoom.runtimeDrag)
            {
                if (deltaPercent > 0)
                {
                    if (dataZoom.end + deltaPercent > 100) deltaPercent = 100 - dataZoom.end;
                }
                else
                {
                    if (dataZoom.start + deltaPercent < 0) deltaPercent = -dataZoom.start;
                }
                UpdateDataZoomRange(dataZoom, dataZoom.start + deltaPercent, dataZoom.end + deltaPercent);
            }
        }
 
        private void ScaleDataZoom(DataZoom dataZoom, float delta)
        {
            var grid = chart.GetDataZoomGridOrDefault(dataZoom);
            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;
                UpdateDataZoomRange(dataZoom, dataZoom.start + deltaPercent, dataZoom.end - deltaPercent);
            }
            else
            {
                UpdateDataZoomRange(dataZoom, dataZoom.start - deltaPercent, dataZoom.end + deltaPercent);
            }
        }
 
        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()
        {
            m_CheckDataZoomLabel = true;
        }
 
        private void CheckDataZoomScale(DataZoom dataZoom)
        {
            if (!dataZoom.enable || dataZoom.zoomLock || !dataZoom.supportInside || !dataZoom.supportInsideDrag) return;
 
            if (Input.touchCount == 2)
            {
                var touch0 = Input.GetTouch(0);
                var touch1 = Input.GetTouch(1);
                if (touch1.phase == TouchPhase.Began)
                {
                    m_LastTouchPos0 = touch0.position;
                    m_LastTouchPos1 = touch1.position;
                }
                else if (touch0.phase == TouchPhase.Moved || touch1.phase == TouchPhase.Moved)
                {
                    var tempPos0 = touch0.position;
                    var tempPos1 = touch1.position;
                    var currDist = Vector2.Distance(tempPos0, tempPos1);
                    var lastDist = Vector2.Distance(m_LastTouchPos0, m_LastTouchPos1);
                    var delta = (currDist - lastDist);
                    ScaleDataZoom(dataZoom, delta / dataZoom.scrollSensitivity);
                    m_LastTouchPos0 = tempPos0;
                    m_LastTouchPos1 = tempPos1;
                }
            }
        }
 
        private void CheckDataZoomLabel(DataZoom dataZoom)
        {
            if (dataZoom.enable && dataZoom.supportSlider && dataZoom.showDetail)
            {
                Vector2 local;
                if (!chart.ScreenPointToChartPoint(Input.mousePosition, out local))
                {
                    dataZoom.SetLabelActive(false);
                    return;
                }
                if (dataZoom.IsInSelectedZoom(local)
                    || dataZoom.IsInStartZoom(local)
                    || dataZoom.IsInEndZoom(local))
                {
                    dataZoom.SetLabelActive(true);
                    RefreshDataZoomLabel();
                }
                else
                {
                    dataZoom.SetLabelActive(false);
                }
            }
            if (m_CheckDataZoomLabel && dataZoom.xAxisIndexs.Count > 0)
            {
                m_CheckDataZoomLabel = false;
                var xAxis = chart.GetXAxis(dataZoom.xAxisIndexs[0]);
                var startIndex = (int)((xAxis.data.Count - 1) * dataZoom.start / 100);
                var endIndex = (int)((xAxis.data.Count - 1) * dataZoom.end / 100);
                if (m_DataZoomLastStartIndex != startIndex || m_DataZoomLastEndIndex != endIndex)
                {
                    m_DataZoomLastStartIndex = startIndex;
                    m_DataZoomLastEndIndex = endIndex;
                    if (xAxis.data.Count > 0)
                    {
                        dataZoom.SetStartLabelText(xAxis.data[startIndex]);
                        dataZoom.SetEndLabelText(xAxis.data[endIndex]);
                    }
                    else if (xAxis.IsTime())
                    {
                        //TODO:
                        dataZoom.SetStartLabelText("");
                        dataZoom.SetEndLabelText("");
                    }
                    chart.InitAxisX();
                }
                var start = dataZoom.runtimeX + dataZoom.runtimeWidth * dataZoom.start / 100;
                var end = dataZoom.runtimeX + dataZoom.runtimeWidth * dataZoom.end / 100;
                var hig = dataZoom.runtimeHeight;
                dataZoom.UpdateStartLabelPosition(new Vector3(start - 10, chart.chartY + dataZoom.bottom + hig / 2));
                dataZoom.UpdateEndLabelPosition(new Vector3(end + 10, chart.chartY + dataZoom.bottom + hig / 2));
            }
        }
 
        private void DrawHorizonalDataZoomSlider(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.runtimeWidth / (showData.Count - 1);
                Vector3 lp = Vector3.zero;
                Vector3 np = Vector3.zero;
                double minValue = 0;
                double 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.runtimeWidth / 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)
                {
                    double value = chart.SampleValue(ref showData, serie.sampleType, rate, serie.minShow, maxCount, totalAverage, i,
                    serie.animation.GetUpdateAnimationDuration(), ref dataChanging, axis);
                    float pX = dataZoom.runtimeX + i * scaleWid;
                    float dataHig = (float)((maxValue - minValue) == 0 ? 0 :
                        (value - minValue) / (maxValue - minValue) * dataZoom.runtimeHeight);
                    np = new Vector3(pX, chart.chartY + dataZoom.bottom + dataHig);
                    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.runtimeX + dataZoom.runtimeWidth * dataZoom.start / 100;
                    var end = dataZoom.runtimeX + dataZoom.runtimeWidth * dataZoom.end / 100;
                    var fillerColor = dataZoom.GetFillerColor(chart.theme.dataZoom.fillerColor);
 
                    p1 = new Vector2(start, dataZoom.runtimeY);
                    p2 = new Vector2(start, dataZoom.runtimeY + dataZoom.runtimeHeight);
                    p3 = new Vector2(end, dataZoom.runtimeY + dataZoom.runtimeHeight);
                    p4 = new Vector2(end, dataZoom.runtimeY);
                    UGL.DrawQuadrilateral(vh, p1, p2, p3, p4, fillerColor);
                    UGL.DrawLine(vh, p1, p2, lineWidth, fillerColor);
                    UGL.DrawLine(vh, p3, p4, lineWidth, fillerColor);
                    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;
                double minValue = 0;
                double 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)
                {
                    double 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 :
                        (float)((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;
            }
        }
    }
}