BaseChart_API.cs

/************************************************/
/*                                              */
/*     Copyright (c) 2018 - 2021 monitor1394    */
/*     https://github.com/monitor1394           */
/*                                              */
/************************************************/
 
using UnityEngine;
using System.Collections.Generic;
using System;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Text;
 
namespace XCharts
{
    public partial class BaseChart
    {
        public string chartName
        {
            get { return m_ChartName; }
            set
            {
                if (!string.IsNullOrEmpty(value) && XChartsMgr.Instance.ContainsChart(value))
                {
                    Debug.LogError("chartName repeated:" + value);
                }
                else
                {
                    m_ChartName = value;
                }
            }
        }
        public ChartTheme theme { get { return m_Theme; } set { m_Theme = value; } }
        public Title title { get { return m_Titles.Count > 0 ? m_Titles[0] : null; } }
        public List<Title> titles { get { return m_Titles; } }
        public Legend legend { get { return m_Legends.Count > 0 ? m_Legends[0] : null; } }
        public List<Legend> legends { get { return m_Legends; } }
        public Tooltip tooltip { get { return m_Tooltips.Count > 0 ? m_Tooltips[0] : null; } }
        public Series series { get { return m_Series; } }
        public Settings settings { get { return m_Settings; } }
        public DataZoom dataZoom { get { return m_DataZooms.Count > 0 ? m_DataZooms[0] : null; } }
        public List<DataZoom> dataZooms { get { return m_DataZooms; } }
        public VisualMap visualMap { get { return m_VisualMaps.Count > 0 ? m_VisualMaps[0] : null; } }
        public List<VisualMap> visualMaps { get { return m_VisualMaps; } }
        public float chartX { get { return m_ChartX; } }
        public float chartY { get { return m_ChartY; } }
        public float chartWidth { get { return m_ChartWidth; } }
        public float chartHeight { get { return m_ChartHeight; } }
        public Vector2 chartMinAnchor { get { return m_ChartMinAnchor; } }
        public Vector2 chartMaxAnchor { get { return m_ChartMaxAnchor; } }
        public Vector2 chartPivot { get { return m_ChartPivot; } }
        public Vector2 chartSizeDelta { get { return m_ChartSizeDelta; } }
        public Vector3 chartPosition { get { return m_ChartPosition; } }
        public Rect chartRect { get { return m_ChartRect; } }
        public Action<VertexHelper> onCustomDraw { set { m_OnCustomDrawBaseCallback = value; } }
        public Action<VertexHelper, Serie> onCustomDrawBeforeSerie { set { m_OnCustomDrawSerieBeforeCallback = value; } }
        public Action<VertexHelper, Serie> onCustomDrawAfterSerie { set { m_OnCustomDrawSerieAfterCallback = value; } }
        public Action<VertexHelper> onCustomDrawTop { set { m_OnCustomDrawTopCallback = value; } }
        public Action<PointerEventData, int, int> onPointerClickPie { set { m_OnPointerClickPie = value; m_ForceOpenRaycastTarget = true; } get { return m_OnPointerClickPie; } }
 
        public void RefreshChart()
        {
            m_RefreshChart = true;
            if (m_Painter) m_Painter.Refresh();
        }
 
        public virtual void ClearData()
        {
            m_Series.ClearData();
            foreach (var legend in m_Legends) legend.ClearData();
            tooltip.ClearValue();
            m_CheckAnimation = false;
            m_ReinitLabel = true;
            RefreshChart();
        }
 
        public virtual void RemoveData()
        {
            foreach (var legend in m_Legends) legend.ClearData();
            foreach (var radar in m_Radars) radar.indicatorList.Clear();
            m_Series.RemoveAll();
            tooltip.ClearValue();
            m_CheckAnimation = false;
            m_ReinitLabel = true;
            m_SerieLabelRoot = null;
            RefreshChart();
        }
 
        public virtual void RemoveData(string serieName)
        {
            m_Series.RemoveSerie(serieName);
            foreach (var legend in m_Legends) legend.RemoveData(serieName);
            m_SerieLabelRoot = null;
            RefreshChart();
        }
 
        public virtual Serie AddSerie(SerieType type, string serieName = null, bool show = true, bool addToHead = false)
        {
            return m_Series.AddSerie(type, serieName, show, addToHead);
        }
 
        public virtual Serie AddSerie(string serieType, string serieName = null, bool show = true, bool addToHead = false)
        {
            var type = SerieType.Custom;
            var list = Enum.GetNames(typeof(SerieType));
            foreach (var t in list)
            {
                if (t.Equals(serieType)) type = (SerieType)Enum.Parse(typeof(SerieType), t);
            }
            return AddSerie(type, serieName, show, addToHead);
        }
 
        public virtual Serie InsertSerie(int index, SerieType serieType, string serieName = null, bool show = true)
        {
            return m_Series.InsertSerie(index, serieType, serieName, show);
        }
 
        public virtual SerieData AddData(string serieName, double data, string dataName = null)
        {
            var serieData = m_Series.AddData(serieName, data, dataName);
            if (serieData != null)
            {
                var serie = m_Series.GetSerie(serieName);
                if (SerieHelper.GetSerieLabel(serie, serieData).show)
                {
                    RefreshLabel();
                }
                RefreshPainter(serie);
            }
            return serieData;
        }
 
        public virtual SerieData AddData(int serieIndex, double data, string dataName = null)
        {
            var serieData = m_Series.AddData(serieIndex, data, dataName);
            if (serieData != null)
            {
                var serie = m_Series.GetSerie(serieIndex);
                if (SerieHelper.GetSerieLabel(serie, serieData).show)
                {
                    RefreshLabel();
                }
                RefreshPainter(serie);
            }
            return serieData;
        }
 
        public virtual SerieData AddData(string serieName, List<double> multidimensionalData, string dataName = null)
        {
            var serieData = m_Series.AddData(serieName, multidimensionalData, dataName);
            if (serieData != null)
            {
                var serie = m_Series.GetSerie(serieName);
                if (SerieHelper.GetSerieLabel(serie, serieData).show)
                {
                    RefreshLabel();
                }
                RefreshPainter(serie);
            }
            return serieData;
        }
 
        public virtual SerieData AddData(int serieIndex, List<double> multidimensionalData, string dataName = null)
        {
            var serieData = m_Series.AddData(serieIndex, multidimensionalData, dataName);
            if (serieData != null)
            {
                var serie = m_Series.GetSerie(serieIndex);
                if (SerieHelper.GetSerieLabel(serie, serieData).show)
                {
                    RefreshLabel();
                }
                RefreshPainter(serie);
            }
            return serieData;
        }
 
        public virtual SerieData AddData(string serieName, double xValue, double yValue, string dataName = null)
        {
            var serieData = m_Series.AddXYData(serieName, xValue, yValue, dataName);
            if (serieData != null)
            {
                var serie = m_Series.GetSerie(serieName);
                if (SerieHelper.GetSerieLabel(serie, serieData).show)
                {
                    RefreshLabel();
                }
                RefreshPainter(serie);
            }
            return serieData;
        }
 
        public virtual SerieData AddData(int serieIndex, double xValue, double yValue, string dataName = null)
        {
            var serieData = m_Series.AddXYData(serieIndex, xValue, yValue, dataName);
            if (serieData != null)
            {
                var serie = m_Series.GetSerie(serieIndex);
                if (SerieHelper.GetSerieLabel(serie, serieData).show)
                {
                    RefreshLabel();
                }
                RefreshPainter(serie);
            }
            return serieData;
        }
        public virtual SerieData AddData(int serieIndex, double open, double close, double lowest, double heighest, string dataName = null)
        {
            var serieData = m_Series.AddData(serieIndex, open, close, lowest, heighest, dataName);
            if (serieData != null)
            {
                var serie = m_Series.GetSerie(serieIndex);
                if (SerieHelper.GetSerieLabel(serie, serieData).show)
                {
                    RefreshLabel();
                }
                RefreshPainter(serie);
            }
            return serieData;
        }
 
        public virtual bool UpdateData(string serieName, int dataIndex, double value)
        {
            if (m_Series.UpdateData(serieName, dataIndex, value))
            {
                RefreshPainter(m_Series.GetSerie(serieName));
                return true;
            }
            return false;
        }
 
        public virtual bool UpdateData(int serieIndex, int dataIndex, double value)
        {
            if (m_Series.UpdateData(serieIndex, dataIndex, value))
            {
                RefreshPainter(m_Series.GetSerie(serieIndex));
                return true;
            }
            return false;
        }
 
        public virtual bool UpdateData(string serieName, int dataIndex, List<double> multidimensionalData)
        {
            if (m_Series.UpdateData(serieName, dataIndex, multidimensionalData))
            {
                RefreshPainter(m_Series.GetSerie(serieName));
                return true;
            }
            return false;
        }
 
        public virtual bool UpdateData(int serieIndex, int dataIndex, List<double> multidimensionalData)
        {
            if (m_Series.UpdateData(serieIndex, dataIndex, multidimensionalData))
            {
                RefreshPainter(m_Series.GetSerie(serieIndex));
                return true;
            }
            return false;
        }
 
        public virtual bool UpdateData(string serieName, int dataIndex, int dimension, double value)
        {
            if (m_Series.UpdateData(serieName, dataIndex, dimension, value))
            {
                RefreshPainter(m_Series.GetSerie(serieName));
                return true;
            }
            return false;
        }
 
        public virtual bool UpdateData(int serieIndex, int dataIndex, int dimension, double value)
        {
            if (m_Series.UpdateData(serieIndex, dataIndex, dimension, value))
            {
                RefreshPainter(m_Series.GetSerie(serieIndex));
                return true;
            }
            return false;
        }
 
        public virtual bool UpdateDataName(string serieName, int dataIndex, string dataName)
        {
            return m_Series.UpdateDataName(serieName, dataIndex, dataName);
        }
 
        public virtual bool UpdateDataName(int serieIndex, int dataIndex, string dataName)
        {
            return m_Series.UpdateDataName(serieIndex, dataIndex, dataName);
        }
 
        public virtual void SetActive(string serieName, bool active)
        {
            var serie = m_Series.GetSerie(serieName);
            if (serie != null)
            {
                SetActive(serie.index, active);
            }
        }
 
        public virtual void SetActive(int serieIndex, bool active)
        {
            m_Series.SetActive(serieIndex, active);
            var serie = m_Series.GetSerie(serieIndex);
            if (serie != null && !string.IsNullOrEmpty(serie.name))
            {
                UpdateLegendColor(serie.name, active);
            }
        }
 
        public virtual void UpdateLegendColor(string legendName, bool active)
        {
            var legendIndex = m_LegendRealShowName.IndexOf(legendName);
            if (legendIndex >= 0)
            {
                foreach (var legend in m_Legends)
                {
                    var iconColor = LegendHelper.GetIconColor(this, legendIndex, legendName, active);
                    var contentColor = LegendHelper.GetContentColor(legendIndex, legend, m_Theme, active);
                    legend.UpdateButtonColor(legendName, iconColor);
                    legend.UpdateContentColor(legendName, contentColor);
                }
            }
        }
 
        public virtual bool IsActive(string serieName)
        {
            return m_Series.IsActive(serieName);
        }
 
        public virtual bool IsActive(int serieIndex)
        {
            return m_Series.IsActive(serieIndex);
        }
 
        public virtual bool IsActiveByLegend(string legendName)
        {
            foreach (var serie in m_Series.list)
            {
                if (serie.show && legendName.Equals(serie.name))
                {
                    return true;
                }
                else
                {
                    foreach (var serieData in serie.data)
                    {
                        if (serieData.show && legendName.Equals(serieData.name))
                        {
                            return true;
                        }
                    }
                }
 
            }
            return false;
        }
 
        public void RefreshLabel()
        {
            m_ReinitLabel = true;
            m_SerieLabelRoot = null;
        }
 
        public void RefreshTooltip()
        {
            InitTooltip();
        }
 
        public bool UpdateTheme(Theme theme)
        {
            if (theme == Theme.Custom)
            {
                Debug.LogError("UpdateTheme: not support switch to Custom theme.");
                return false;
            }
            m_Theme.theme = theme;
            return true;
        }
 
        public void UpdateTheme(ChartTheme theme)
        {
            m_Theme.CopyTheme(theme);
            SetAllComponentDirty();
#if UNITY_EDITOR
            UnityEditor.EditorUtility.SetDirty(this);
#endif
        }
 
        public void AnimationEnable(bool flag)
        {
            foreach (var serie in m_Series.list) serie.AnimationEnable(flag);
        }
 
        public void AnimationFadeIn()
        {
            foreach (var serie in m_Series.list) serie.AnimationFadeIn();
        }
 
        public void AnimationFadeOut()
        {
            foreach (var serie in m_Series.list) serie.AnimationFadeOut();
        }
 
        public void AnimationPause()
        {
            foreach (var serie in m_Series.list) serie.AnimationPause();
        }
 
        public void AnimationResume()
        {
            foreach (var serie in m_Series.list) serie.AnimationResume();
        }
 
        public void AnimationReset()
        {
            foreach (var serie in m_Series.list) serie.AnimationReset();
        }
 
        public void ClickLegendButton(int legendIndex, string legendName, bool show)
        {
            OnLegendButtonClick(legendIndex, legendName, show);
            RefreshChart();
        }
 
        public bool IsInChart(Vector2 local)
        {
            return IsInChart(local.x, local.y);
        }
 
        public bool IsInChart(float x, float y)
        {
            if (x < m_ChartX || x > m_ChartX + m_ChartWidth ||
               y < m_ChartY || y > m_ChartY + m_ChartHeight)
            {
                return false;
            }
            return true;
        }
 
        public void ClampInChart(ref Vector3 pos)
        {
            if (!IsInChart(pos.x, pos.y))
            {
                if (pos.x < m_ChartX) pos.x = m_ChartX;
                if (pos.x > m_ChartX + m_ChartWidth) pos.x = m_ChartX + m_ChartWidth;
                if (pos.y < m_ChartY) pos.y = m_ChartY;
                if (pos.y > m_ChartY + m_ChartHeight) pos.y = m_ChartY + m_ChartHeight;
            }
        }
 
        public Vector3 GetTitlePosition(Title title)
        {
            return chartPosition + title.location.GetPosition(chartWidth, chartHeight);
        }
 
        public bool ContainsSerie(SerieType serieType)
        {
            return SeriesHelper.ContainsSerie(m_Series, serieType);
        }
 
        public virtual bool AddDefaultCustomSerie(string serieName, int dataCount = 5)
        {
            return false;
        }
 
        public virtual string[] GetCustomSerieInspectorShowFileds()
        {
            return null;
        }
        public virtual string[][] GetCustomSerieInspectorCustomFileds()
        {
            return null;
        }
        public virtual string[] GetCustomChartInspectorShowFileds()
        {
            return null;
        }
 
        public virtual string GetCustomSerieTypeName()
        {
            return null;
        }
 
        public virtual bool GetCustomSerieDataNameForColor()
        {
            return false;
        }
 
        public int GetLegendRealShowNameIndex(string name)
        {
            return m_LegendRealShowName.IndexOf(name);
        }
 
        public virtual void InitCustomSerieTooltip(ref StringBuilder stringBuilder, Serie serie, int index)
        {
        }
 
        public void SetBasePainterMaterial(Material material)
        {
            settings.basePainterMaterial = material;
            if (m_Painter != null)
            {
                m_Painter.material = material;
            }
        }
 
        public void SetSeriePainterMaterial(Material material)
        {
            settings.basePainterMaterial = material;
            if (m_PainterList != null)
            {
                foreach (var painter in m_PainterList)
                    painter.material = material;
            }
        }
 
        public void SetTopPainterMaterial(Material material)
        {
            settings.topPainterMaterial = material;
            if (m_PainterTop != null)
            {
                m_PainterTop.material = material;
            }
        }
    }
}