Series.cs

/************************************************/
/*                                              */
/*     Copyright (c) 2018 - 2021 monitor1394    */
/*     https://github.com/monitor1394           */
/*                                              */
/************************************************/
 
using UnityEngine;
using System.Collections.Generic;
using System;
 
namespace XCharts
{
    [System.Serializable]
    public class Series : MainComponent
    {
        [SerializeField] protected List<Serie> m_Series;
        [NonSerialized] private bool m_LabelDirty;
 
        public List<Serie> list { get { return m_Series; } }
        public int Count { get { return m_Series.Count; } }
        public bool labelDirty { get { return m_LabelDirty; } set { m_LabelDirty = value; } }
 
        public static Series defaultSeries
        {
            get
            {
                var series = new Series
                {
                    m_Series = new List<Serie>(){new Serie(){
                        show  = true,
                        name = "serie1",
                        index = 0
                    }}
                };
                return series;
            }
        }
 
        public override bool vertsDirty
        {
            get
            {
                if (m_VertsDirty) return true;
                foreach (var serie in m_Series)
                {
                    if (serie.vertsDirty) return true;
                }
                return false;
            }
        }
 
        public void SetLabelDirty()
        {
            m_LabelDirty = true;
        }
 
        public override void ClearVerticesDirty()
        {
            base.ClearVerticesDirty();
            foreach (var serie in m_Series)
            {
                serie.ClearVerticesDirty();
            }
        }
 
        internal void ClearLabelDirty()
        {
            m_LabelDirty = false;
            foreach (var serie in m_Series)
            {
                serie.label.ClearVerticesDirty();
            }
        }
 
        public override void SetAllDirty()
        {
            base.SetAllDirty();
            SetLabelDirty();
        }
 
        public override void ClearDirty()
        {
            base.ClearDirty();
            ClearLabelDirty();
            SeriesHelper.ClearNameDirty(this);
        }
 
        public void ClearData()
        {
            foreach (var serie in m_Series)
            {
                serie.AnimationFadeIn();
                serie.ClearData();
            }
        }
 
        public double GetData(int serieIndex, int dataIndex)
        {
            if (serieIndex >= 0 && serieIndex < Count)
            {
                return m_Series[serieIndex].GetYData(dataIndex);
            }
            else
            {
                return 0;
            }
        }
 
        public double GetCurrData(int serieIndex, int dataIndex)
        {
            if (serieIndex >= 0 && serieIndex < Count)
            {
                return m_Series[serieIndex].GetYCurrData(dataIndex);
            }
            else
            {
                return 0;
            }
        }
 
        public Serie GetSerie(string name)
        {
            for (int i = 0; i < m_Series.Count; i++)
            {
                bool match = false;
                if (string.IsNullOrEmpty(name))
                {
                    if (string.IsNullOrEmpty(m_Series[i].name)) match = true;
                }
                else if (name.Equals(m_Series[i].name))
                {
                    match = true;
                }
                if (match)
                {
                    m_Series[i].index = i;
                    return m_Series[i];
                }
            }
            return null;
        }
 
        public List<Serie> GetSeries(string name)
        {
            var list = new List<Serie>();
            if (name == null) return list;
            foreach (var serie in m_Series)
            {
                if (name.Equals(serie.name)) list.Add(serie);
            }
            return list;
        }
 
        public Serie GetSerie(int index)
        {
            if (index >= 0 && index < m_Series.Count)
            {
                return m_Series[index];
            }
            return null;
        }
 
        public bool Contains(string name)
        {
            for (int i = 0; i < m_Series.Count; i++)
            {
                if (name.Equals(m_Series[i].name))
                {
                    return true;
                }
            }
            return false;
        }
 
        public bool Contains(SerieType type)
        {
            foreach (var serie in m_Series)
            {
                if (serie.type == type) return true;
            }
            return false;
        }
 
        public bool RemoveSerie(string serieName)
        {
            var serie = GetSerie(serieName);
            return RemoveSerie(serie);
        }
 
        public bool RemoveSerie(int serieIndex)
        {
            var serie = GetSerie(serieIndex);
            return RemoveSerie(serie);
        }
 
        public bool RemoveSerie(Serie serie)
        {
            if (serie != null && m_Series.Remove(serie))
            {
                SetVerticesDirty();
                return true;
            }
            else
            {
                return false;
            }
        }
 
        public void RemoveAll()
        {
            foreach(var serie in m_Series) serie.AnimationFadeIn();
            m_Series.Clear();
        }
 
        public Serie AddSerie(SerieType type, string serieName, bool show = true, bool addToHead = false)
        {
            return InsertSerie(-1, type, serieName, show, addToHead);
        }
 
        public Serie InsertSerie(int index, SerieType type, string serieName, bool show = true)
        {
            return InsertSerie(index, type, serieName, show, false);
        }
 
        private Serie InsertSerie(int index, SerieType type, string serieName, bool show = true, bool addToHead = false)
        {
            var serie = new Serie();
            serie.type = type;
            serie.show = show;
            serie.name = serieName;
            serie.index = m_Series.Count;
 
            if (type == SerieType.Scatter)
            {
                serie.symbol.show = true;
                serie.symbol.type = SerieSymbolType.Circle;
            }
            else if (type == SerieType.Line)
            {
                serie.symbol.show = true;
                serie.symbol.type = SerieSymbolType.EmptyCircle;
            }
            else
            {
                serie.symbol.show = false;
            }
            serie.AnimationRestart();
            if (addToHead) m_Series.Insert(0, serie);
            else if (index >= 0) m_Series.Insert(index, serie);
            else m_Series.Add(serie);
            for (int i = 0; i < m_Series.Count; i++)
            {
                m_Series[i].index = i;
            }
            SetVerticesDirty();
            return serie;
        }
 
        public SerieData AddData(string serieName, double value, string dataName = null)
        {
            var serie = GetSerie(serieName);
            if (serie != null)
            {
                return serie.AddYData(value, dataName);
            }
            return null;
        }
 
        public SerieData AddData(int index, double value, string dataName = null)
        {
            var serie = GetSerie(index);
            if (serie != null)
            {
                return serie.AddYData(value, dataName);
            }
            return null;
        }
 
        public SerieData AddData(int index, double open, double close, double lowest, double heighest, string dataName = null)
        {
            var serie = GetSerie(index);
            if (serie != null)
            {
                return serie.AddData(open, close, lowest, heighest, dataName);
            }
            return null;
        }
 
        public SerieData AddData(string serieName, double open, double close, double lowest, double heighest, string dataName = null)
        {
            var serie = GetSerie(serieName);
            if (serie != null)
            {
                return serie.AddData(open, close, lowest, heighest, dataName);
            }
            return null;
        }
 
        public SerieData AddData(string serieName, List<double> multidimensionalData, string dataName = null)
        {
            var serie = GetSerie(serieName);
            if (serie != null)
            {
                return serie.AddData(multidimensionalData, dataName);
            }
            return null;
        }
 
        public SerieData AddData(int serieIndex, List<double> multidimensionalData, string dataName = null)
        {
            var serie = GetSerie(serieIndex);
            if (serie != null)
            {
                return serie.AddData(multidimensionalData, dataName);
            }
            return null;
        }
 
        public SerieData AddXYData(string serieName, double xValue, double yValue, string dataName = null)
        {
            var serie = GetSerie(serieName);
            if (serie != null)
            {
                return serie.AddXYData(xValue, yValue, dataName);
            }
            return null;
        }
 
        public SerieData AddXYData(int index, double xValue, double yValue, string dataName = null)
        {
            var serie = GetSerie(index);
            if (serie != null)
            {
                return serie.AddXYData(xValue, yValue, dataName);
            }
            return null;
        }
 
        public bool UpdateData(string serieName, int dataIndex, double value)
        {
            var serie = GetSerie(serieName);
            if (serie != null)
            {
                return serie.UpdateYData(dataIndex, value);
            }
            return false;
        }
 
        public bool UpdateDataName(string serieName, int dataIndex, string dataName)
        {
            var serie = GetSerie(serieName);
            if (serie != null)
            {
                return serie.UpdateDataName(dataIndex, dataName);
            }
            return false;
        }
 
        public bool UpdateDataName(int serieIndex, int dataIndex, string dataName)
        {
            var serie = GetSerie(serieIndex);
            if (serie != null)
            {
                return serie.UpdateDataName(dataIndex, dataName);
            }
            return false;
        }
 
        public bool UpdateData(int serieIndex, int dataIndex, double value)
        {
            var serie = GetSerie(serieIndex);
            if (serie != null)
            {
                return serie.UpdateYData(dataIndex, value);
            }
            return false;
        }
 
        public bool UpdateData(string serieName, int dataIndex, List<double> values)
        {
            var serie = GetSerie(serieName);
            if (serie != null)
            {
                return serie.UpdateData(dataIndex, values);
            }
            return false;
        }
        public bool UpdateData(int serieIndex, int dataIndex, List<double> values)
        {
            var serie = GetSerie(serieIndex);
            if (serie != null)
            {
                return serie.UpdateData(dataIndex, values);
            }
            return false;
        }
 
        public bool UpdateData(int serieIndex, int dataIndex, int dimension, double value)
        {
            var serie = GetSerie(serieIndex);
            if (serie != null)
            {
                return serie.UpdateData(dataIndex, dimension, value);
            }
            return false;
        }
 
        public bool UpdateData(string serieName, int dataIndex, int dimension, double value)
        {
            var serie = GetSerie(serieName);
            if (serie != null)
            {
                return serie.UpdateData(dataIndex, dimension, value);
            }
            return false;
        }
 
 
        public bool UpdateXYData(string serieName, int dataIndex, float xValue, float yValue)
        {
            var serie = GetSerie(serieName);
            if (serie != null)
            {
                return serie.UpdateXYData(dataIndex, xValue, yValue);
            }
            return false;
        }
 
        public bool UpdateXYData(int serieIndex, int dataIndex, float xValue, float yValue)
        {
            var serie = GetSerie(serieIndex);
            if (serie != null)
            {
                return serie.UpdateXYData(dataIndex, xValue, yValue);
            }
            return false;
        }
 
        internal void UpdateFilterData(DataZoom dataZoom)
        {
            if (dataZoom != null && dataZoom.enable)
            {
                for (int i = 0; i < m_Series.Count; i++)
                {
                    SerieHelper.UpdateFilterData(m_Series[i], dataZoom);
                }
            }
        }
 
        public bool IsActive(string name)
        {
            var serie = GetSerie(name);
            return serie == null ? false : serie.show;
        }
 
        public bool IsActive(int index)
        {
            var serie = GetSerie(index);
            return serie == null ? false : serie.show;
        }
 
        public void SetActive(string name, bool active)
        {
            var serie = GetSerie(name);
            if (serie != null)
            {
                serie.show = active;
            }
        }
 
        public void SetActive(int index, bool active)
        {
            var serie = GetSerie(index);
            if (serie != null)
            {
                serie.show = active;
                serie.AnimationReset();
                if (active) serie.AnimationFadeIn();
            }
        }
 
        public bool IsHighlight(int serieIndex)
        {
            var serie = GetSerie(serieIndex);
            if (serie != null) return serie.highlighted;
            else return false;
        }
 
        public void SetSerieSymbolSizeCallback(SymbolSizeCallback size, SymbolSizeCallback selectedSize)
        {
            foreach (var serie in m_Series)
            {
                serie.symbol.sizeCallback = size;
                serie.symbol.selectedSizeCallback = selectedSize;
            }
        }
    }
}