SerieSymbol.cs

/************************************************/
/*                                              */
/*     Copyright (c) 2018 - 2021 monitor1394    */
/*     https://github.com/monitor1394           */
/*                                              */
/************************************************/
 
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
namespace XCharts
{
    public enum SerieSymbolType
    {
        EmptyCircle,
        Circle,
        Rect,
        Triangle,
        Diamond,
        None,
        Arrow,
        Custom,
        EmptyRect,
        EmptyTriangle,
        EmptyDiamond
    }
 
    public enum SerieSymbolSizeType
    {
        Custom,
        FromData,
        Callback,
    }
 
    public delegate float SymbolSizeCallback(List<double> data);
 
    [System.Serializable]
    public class SerieSymbol : SubComponent
    {
        [SerializeField] private bool m_Show = true;
        [SerializeField] private SerieSymbolType m_Type = SerieSymbolType.EmptyCircle;
        [SerializeField] private SerieSymbolSizeType m_SizeType = SerieSymbolSizeType.Custom;
        [SerializeField] private float m_Size = 0f;
        [SerializeField] private float m_SelectedSize = 0f;
        [SerializeField] private int m_DataIndex = 1;
        [SerializeField] private float m_DataScale = 1;
        [SerializeField] private float m_SelectedDataScale = 1.5f;
        [SerializeField] private SymbolSizeCallback m_SizeCallback;
        [SerializeField] private SymbolSizeCallback m_SelectedSizeCallback;
        [SerializeField] private int m_StartIndex;
        [SerializeField] private int m_Interval;
        [SerializeField] private bool m_ForceShowLast = false;
        [SerializeField] private float m_Gap = 0;
        [SerializeField] private float m_Width = 0f;
        [SerializeField] private float m_Height = 0f;
        [SerializeField] private bool m_Repeat = false;
        [SerializeField] private Vector2 m_Offset = Vector2.zero;
        [SerializeField] private Sprite m_Image;
        [SerializeField] private Image.Type m_ImageType;
 
        public void Reset()
        {
            m_Show = false;
            m_Type = SerieSymbolType.EmptyCircle;
            m_SizeType = SerieSymbolSizeType.Custom;
            m_Size = 0f;
            m_SelectedSize = 0f;
            m_DataIndex = 1;
            m_DataScale = 1;
            m_SelectedDataScale = 1.5f;
            m_SizeCallback = null;
            m_SelectedSizeCallback = null;
            m_StartIndex = 0;
            m_Interval = 0;
            m_ForceShowLast = false;
            m_Gap = 0;
            m_Width = 0f;
            m_Height = 0f;
            m_Repeat = false;
            m_Offset = Vector2.zero;
            m_Image = null;
            m_ImageType = Image.Type.Simple;
        }
 
        public bool show
        {
            get { return m_Show; }
            set { if (PropertyUtil.SetStruct(ref m_Show, value)) SetAllDirty(); }
        }
        public SerieSymbolType type
        {
            get { return m_Type; }
            set { if (PropertyUtil.SetStruct(ref m_Type, value)) SetVerticesDirty(); }
        }
        public SerieSymbolSizeType sizeType
        {
            get { return m_SizeType; }
            set { if (PropertyUtil.SetStruct(ref m_SizeType, value)) SetVerticesDirty(); }
        }
        public float size
        {
            get { return m_Size; }
            set { if (PropertyUtil.SetStruct(ref m_Size, value)) SetVerticesDirty(); }
        }
        public float selectedSize
        {
            get { return m_SelectedSize; }
            set { if (PropertyUtil.SetStruct(ref m_SelectedSize, value)) SetVerticesDirty(); }
        }
        public int dataIndex
        {
            get { return m_DataIndex; }
            set { if (PropertyUtil.SetStruct(ref m_DataIndex, value)) SetVerticesDirty(); }
        }
        public float dataScale
        {
            get { return m_DataScale; }
            set { if (PropertyUtil.SetStruct(ref m_DataScale, value)) SetVerticesDirty(); }
        }
        public float selectedDataScale
        {
            get { return m_SelectedDataScale; }
            set { if (PropertyUtil.SetStruct(ref m_SelectedDataScale, value)) SetVerticesDirty(); }
        }
        public SymbolSizeCallback sizeCallback
        {
            get { return m_SizeCallback; }
            set { if (PropertyUtil.SetClass(ref m_SizeCallback, value)) SetVerticesDirty(); }
        }
        public SymbolSizeCallback selectedSizeCallback
        {
            get { return m_SelectedSizeCallback; }
            set { if (PropertyUtil.SetClass(ref m_SelectedSizeCallback, value)) SetVerticesDirty(); }
        }
        public int startIndex
        {
            get { return m_StartIndex; }
            set { if (PropertyUtil.SetStruct(ref m_StartIndex, value)) SetVerticesDirty(); }
        }
        public int interval
        {
            get { return m_Interval; }
            set { if (PropertyUtil.SetStruct(ref m_Interval, value)) SetVerticesDirty(); }
        }
        public bool forceShowLast
        {
            get { return m_ForceShowLast; }
            set { if (PropertyUtil.SetStruct(ref m_ForceShowLast, value)) SetVerticesDirty(); }
        }
        public float gap
        {
            get { return m_Gap; }
            set { if (PropertyUtil.SetStruct(ref m_Gap, value)) SetVerticesDirty(); }
        }
        public float width
        {
            get { return m_Width; }
            set { if (PropertyUtil.SetStruct(ref m_Width, value)) SetAllDirty(); }
        }
        public float height
        {
            get { return m_Height; }
            set { if (PropertyUtil.SetStruct(ref m_Height, value)) SetAllDirty(); }
        }
        public bool repeat
        {
            get { return m_Repeat; }
            set { if (PropertyUtil.SetStruct(ref m_Repeat, value)) SetAllDirty(); }
        }
        public Sprite image
        {
            get { return m_Image; }
            set { if (PropertyUtil.SetClass(ref m_Image, value)) SetAllDirty(); }
        }
        public Image.Type imageType
        {
            get { return m_ImageType; }
            set { if (PropertyUtil.SetStruct(ref m_ImageType, value)) SetAllDirty(); }
        }
        public Vector2 offset
        {
            get { return m_Offset; }
            set { if (PropertyUtil.SetStruct(ref m_Offset, value)) SetAllDirty(); }
        }
        public Vector3 offset3 { get { return new Vector3(m_Offset.x, m_Offset.y, 0); } }
        private List<float> m_AnimationSize = new List<float>() { 0, 5, 10 };
        public List<float> animationSize { get { return m_AnimationSize; } }
 
        public float GetSize(List<double> data, float themeSize)
        {
            switch (m_SizeType)
            {
                case SerieSymbolSizeType.Custom:
                    return size == 0 ? themeSize : size;
                case SerieSymbolSizeType.FromData:
                    if (data != null && dataIndex >= 0 && dataIndex < data.Count)
                    {
                        return (float)data[dataIndex] * m_DataScale;
                    }
                    else
                    {
                        return size == 0 ? themeSize : size;
                    }
                case SerieSymbolSizeType.Callback:
                    if (data != null && sizeCallback != null) return sizeCallback(data);
                    else return size == 0 ? themeSize : size;
                default: return size == 0 ? themeSize : size;
            }
        }
 
        public float GetSelectedSize(List<double> data, float themeSelectedSize)
        {
            switch (m_SizeType)
            {
                case SerieSymbolSizeType.Custom:
                    return selectedSize == 0 ? themeSelectedSize : selectedSize;
                case SerieSymbolSizeType.FromData:
                    if (data != null && dataIndex >= 0 && dataIndex < data.Count)
                    {
                        return (float)data[dataIndex] * m_SelectedDataScale;
                    }
                    else
                    {
                        return selectedSize == 0 ? themeSelectedSize : selectedSize;
                    }
                case SerieSymbolSizeType.Callback:
                    if (data != null && selectedSizeCallback != null) return selectedSizeCallback(data);
                    else return selectedSize == 0 ? themeSelectedSize : selectedSize;
                default: return selectedSize == 0 ? themeSelectedSize : selectedSize;
            }
        }
 
        public bool ShowSymbol(int dataIndex, int dataCount)
        {
            if (!show) return false;
            if (dataIndex < startIndex) return false;
            if (m_Interval <= 0) return true;
            if (m_ForceShowLast && dataIndex == dataCount - 1) return true;
            return (dataIndex - startIndex) % (m_Interval + 1) == 0;
        }
    }
}