CoordinateChart_API.cs

/************************************************/
/*                                              */
/*     Copyright (c) 2018 - 2021 monitor1394    */
/*     https://github.com/monitor1394           */
/*                                              */
/************************************************/
 
using System.Collections.Generic;
using UnityEngine;
 
namespace XCharts
{
    public partial class CoordinateChart
    {
        public Grid grid { get { return m_Grids.Count > 0 ? m_Grids[0] : null; } }
        public List<Grid> grids { get { return m_Grids; } }
        public List<XAxis> xAxes { get { return m_XAxes; } }
        public List<YAxis> yAxes { get { return m_YAxes; } }
 
        public XAxis xAxis0 { get { return m_XAxes.Count > 0 ? m_XAxes[0] : null; } }
        public XAxis xAxis1 { get { return m_XAxes.Count > 1 ? m_XAxes[1] : null; } }
        public YAxis yAxis0 { get { return m_YAxes.Count > 0 ? m_YAxes[0] : null; } }
        public YAxis yAxis1 { get { return m_YAxes.Count > 1 ? m_YAxes[1] : null; } }
 
 
        public override void ClearData()
        {
            base.ClearData();
            ClearAxisData();
        }
 
        public override void RemoveData()
        {
            base.RemoveData();
            ClearAxisData();
        }
 
        public void ClearAxisData()
        {
            foreach (var axis in m_XAxes)
            {
                axis.data.Clear();
                axis.SetAllDirty();
            }
            foreach (var axis in m_YAxes)
            {
                axis.data.Clear();
                axis.SetAllDirty();
            }
        }
 
        public void AddXAxisData(string category, int xAxisIndex = 0)
        {
            var xAxis = GetXAxis(xAxisIndex);
            if (xAxis != null)
            {
                xAxis.AddData(category);
            }
        }
 
        public void UpdateXAxisData(int index, string category, int xAxisIndex = 0)
        {
            var xAxis = GetXAxis(xAxisIndex);
            if (xAxis != null)
            {
                xAxis.UpdateData(index, category);
            }
        }
 
        public void AddXAxisIcon(Sprite icon, int xAxisIndex = 0)
        {
            var xAxis = GetXAxis(xAxisIndex);
            if (xAxis != null)
            {
                xAxis.AddIcon(icon);
            }
        }
 
        public void UdpateXAxisIcon(int index, Sprite icon, int xAxisIndex = 0)
        {
            var xAxis = GetXAxis(xAxisIndex);
            if (xAxis != null)
            {
                xAxis.UpdateIcon(index, icon);
            }
        }
 
        public void AddYAxisData(string category, int yAxisIndex = 0)
        {
            var yAxis = GetYAxis(yAxisIndex);
            if (yAxis != null)
            {
                yAxis.AddData(category);
            }
        }
 
        public void UpdateYAxisData(int index, string category, int yAxisIndex = 0)
        {
            var yAxis = GetYAxis(yAxisIndex);
            if (yAxis != null)
            {
                yAxis.UpdateData(index, category);
            }
        }
 
        public void AddYAxisIcon(Sprite icon, int yAxisIndex = 0)
        {
            var yAxis = GetYAxis(yAxisIndex);
            if (yAxis != null)
            {
                yAxis.AddIcon(icon);
            }
        }
 
        public void UpdateYAxisIcon(int index, Sprite icon, int yAxisIndex = 0)
        {
            var yAxis = GetYAxis(yAxisIndex);
            if (yAxis != null)
            {
                yAxis.UpdateIcon(index, icon);
            }
        }
 
        public bool IsValue()
        {
            foreach (var axis in m_XAxes)
            {
                if (axis.show && !axis.IsValue() && !axis.IsLog()) return false;
            }
            foreach (var axis in m_YAxes)
            {
                if (axis.show && !axis.IsValue() && !axis.IsLog()) return false;
            }
            return true;
        }
 
        public bool IsCategory()
        {
            foreach (var axis in m_XAxes)
            {
                if (axis.show && !axis.IsCategory()) return false;
            }
            foreach (var axis in m_YAxes)
            {
                if (axis.show && !axis.IsCategory()) return false;
            }
            return true;
        }
 
        public bool IsInGrid(Grid grid, Vector2 local)
        {
            return IsInGrid(grid, local.x, local.y);
        }
 
        public bool IsInGrid(Grid grid, Vector3 local)
        {
            return IsInGrid(grid, local.x, local.y);
        }
 
        public bool IsInGrid(Grid grid, float x, float y)
        {
            if (x < grid.runtimeX - 1 || x > grid.runtimeX + grid.runtimeWidth + 1 ||
                y < grid.runtimeY - 1 || y > grid.runtimeY + grid.runtimeHeight + 1)
            {
                return false;
            }
            return true;
        }
 
        public bool IsInAnyGrid(Vector2 local)
        {
            foreach (var grid in m_Grids)
            {
                if (IsInGrid(grid, local)) return true;
            }
            return false;
        }
 
        public Grid GetGrid(Vector2 local)
        {
            for (int i = 0; i < m_Grids.Count; i++)
            {
                var grid = m_Grids[i];
                grid.index = i;
                if (IsInGrid(grid, local)) return grid;
            }
            return null;
        }
 
        public void RefreshDataZoom()
        {
            foreach (var handler in m_ComponentHandlers)
            {
                if (handler is DataZoomHandler)
                {
                    (handler as DataZoomHandler).RefreshDataZoomLabel();
                }
            }
        }
 
        public void RefreshAxisMinMaxValue()
        {
            CheckMinMaxValue();
        }
 
        public Vector3 ClampInGrid(Grid grid, Vector3 pos)
        {
            if (IsInGrid(grid, pos)) return pos;
            else
            {
                // var pos = new Vector3(pos.x, pos.y);
                if (pos.x < grid.runtimeX) pos.x = grid.runtimeX;
                if (pos.x > grid.runtimeX + grid.runtimeWidth) pos.x = grid.runtimeX + grid.runtimeWidth;
                if (pos.y < grid.runtimeY) pos.y = grid.runtimeY;
                if (pos.y > grid.runtimeY + grid.runtimeHeight) pos.y = grid.runtimeY + grid.runtimeHeight;
                return pos;
            }
        }
 
        public void CovertXYAxis(int index)
        {
            if (index >= 0 && index <= 1)
            {
                var xAxis = m_XAxes[index];
                var yAxis = m_YAxes[index];
                var tempX = m_XAxes[index].Clone();
                xAxis.Copy(m_YAxes[index]);
                yAxis.Copy(tempX);
                xAxis.runtimeZeroXOffset = 0;
                xAxis.runtimeZeroYOffset = 0;
                yAxis.runtimeZeroXOffset = 0;
                yAxis.runtimeZeroYOffset = 0;
                xAxis.runtimeMinValue = 0;
                xAxis.runtimeMaxValue = 0;
                yAxis.runtimeMinValue = 0;
                yAxis.runtimeMaxValue = 0;
                RefreshChart();
            }
        }
 
        public void UpdateCoordinate()
        {
            foreach (var grid in m_Grids)
            {
                grid.UpdateRuntimeData(m_ChartX, m_ChartY, m_ChartWidth, m_ChartHeight);
            }
            foreach (var dataZoom in m_DataZooms)
            {
                dataZoom.UpdateRuntimeData(m_ChartX, m_ChartY, m_ChartWidth, m_ChartHeight);
            }
        }
 
        public void SetMaxCache(int maxCache)
        {
            foreach (var serie in m_Series.list) serie.maxCache = maxCache;
            foreach (var axis in m_XAxes) axis.maxCache = maxCache;
            foreach (var axis in m_YAxes) axis.maxCache = maxCache;
        }
 
        public Grid GetGrid(int index)
        {
            if (index >= 0 && index < m_Grids.Count) return m_Grids[index];
            else return null;
        }
 
        public XAxis GetXAxis(int index)
        {
            if (index >= 0 && index < m_XAxes.Count) return m_XAxes[index];
            else return null;
        }
 
        public YAxis GetYAxis(int index)
        {
            if (index >= 0 && index < m_YAxes.Count) return m_YAxes[index];
            else return null;
        }
    }
}