Tooltip.cs

/******************************************/
/*                                        */
/*     Copyright (c) 2021 monitor1394     */
/*     https://github.com/monitor1394     */
/*                                        */
/******************************************/
 
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
namespace XCharts
{
    [System.Serializable]
    public class Tooltip : MainComponent
    {
        public enum Type
        {
            Line,
            Shadow,
            None,
            Corss
        }
 
        [SerializeField] private bool m_Show;
        [SerializeField] private Type m_Type;
        [SerializeField] private string m_Formatter;
        [SerializeField] private string m_ItemFormatter;
        [SerializeField] private string m_TitleFormatter;
        [SerializeField] private float m_FixedWidth = 0;
        [SerializeField] private float m_FixedHeight = 0;
        [SerializeField] private float m_MinWidth = 0;
        [SerializeField] private float m_MinHeight = 0;
        [SerializeField] private string m_NumericFormatter = "";
        [SerializeField] private float m_PaddingLeftRight = 5f;
        [SerializeField] private float m_PaddingTopBottom = 5f;
        [SerializeField] private bool m_IgnoreDataShow = false;
        [SerializeField] private string m_IgnoreDataDefaultContent = "-";
        [SerializeField] private bool m_AlwayShow = false;
        [SerializeField] private Vector2 m_Offset = new Vector2(18f, -25f);
        [SerializeField] private Sprite m_BackgroundImage;
        [SerializeField] private TextStyle m_TextStyle = new TextStyle();
        [SerializeField] private LineStyle m_LineStyle = new LineStyle(LineStyle.Type.None);
        private DelegateTooltipPosition m_PositionFunction;
 
        private GameObject m_GameObject;
        private GameObject m_Content;
        private ChartText m_ContentText;
        private Image m_ContentImage;
        private RectTransform m_ContentRect;
        private RectTransform m_ContentTextRect;
        private List<int> lastDataIndex = new List<int>();
 
        public bool show
        {
            get { return m_Show; }
            set { if (PropertyUtil.SetStruct(ref m_Show, value)) { SetAllDirty(); SetActive(value); } }
        }
        public Type type
        {
            get { return m_Type; }
            set { if (PropertyUtil.SetStruct(ref m_Type, value)) SetAllDirty(); }
        }
        public string formatter { get { return m_Formatter; } set { m_Formatter = value; } }
        public string titleFormatter { get { return m_TitleFormatter; } set { m_TitleFormatter = value; } }
        public string itemFormatter { get { return m_ItemFormatter; } set { m_ItemFormatter = value; } }
 
        public float fixedWidth { get { return m_FixedWidth; } set { m_FixedWidth = value; } }
        public float fixedHeight { get { return m_FixedHeight; } set { m_FixedHeight = value; } }
        public float minWidth { get { return m_MinWidth; } set { m_MinWidth = value; } }
        public float minHeight { get { return m_MinHeight; } set { m_MinHeight = value; } }
        public string numericFormatter
        {
            get { return m_NumericFormatter; }
            set { if (PropertyUtil.SetClass(ref m_NumericFormatter, value)) SetComponentDirty(); }
        }
        public float paddingLeftRight { get { return m_PaddingLeftRight; } set { m_PaddingLeftRight = value; } }
        public float paddingTopBottom { get { return m_PaddingTopBottom; } set { m_PaddingTopBottom = value; } }
        public bool ignoreDataShow { get { return m_IgnoreDataShow; } set { m_IgnoreDataShow = value; } }
        public string ignoreDataDefaultContent { get { return m_IgnoreDataDefaultContent; } set { m_IgnoreDataDefaultContent = value; } }
        public Sprite backgroundImage { get { return m_BackgroundImage; } set { m_BackgroundImage = value; SetBackground(m_BackgroundImage); } }
        public bool alwayShow { get { return m_AlwayShow; } set { m_AlwayShow = value; } }
        public Vector2 offset { get { return m_Offset; } set { m_Offset = value; } }
        public TextStyle textStyle
        {
            get { return m_TextStyle; }
            set { if (value != null) { m_TextStyle = value; SetComponentDirty(); } }
        }
        public LineStyle lineStyle
        {
            get { return m_LineStyle; }
            set { if (value != null) m_LineStyle = value; SetComponentDirty(); }
        }
 
        public override bool componentDirty
        {
            get { return m_ComponentDirty || lineStyle.componentDirty || textStyle.componentDirty; }
        }
 
        public override void ClearComponentDirty()
        {
            base.ClearComponentDirty();
            lineStyle.ClearComponentDirty();
            textStyle.ClearComponentDirty();
        }
        public Dictionary<int, List<int>> runtimeSerieIndex = new Dictionary<int, List<int>>();
        public List<int> runtimeDataIndex { get { return m_RuntimeDateIndex; } internal set { m_RuntimeDateIndex = value; } }
        private List<int> m_RuntimeDateIndex = new List<int>() { -1, -1 };
        public double[] runtimeXValues { get { return m_RuntimeXValue; } internal set { m_RuntimeXValue = value; } }
        private double[] m_RuntimeXValue = new double[2] { -1, -1 };
        public double[] runtimeYValues { get { return m_RuntimeYValue; } internal set { m_RuntimeYValue = value; } }
        private double[] m_RuntimeYValue = new double[2] { -1, -1 };
        public Vector2 runtimePointerPos { get; internal set; }
        public float runtimeWidth { get { return m_ContentRect.sizeDelta.x; } }
        public float runtimeHeight { get { return m_ContentRect.sizeDelta.y; } }
        public bool runtimeInited { get { return m_GameObject != null; } }
        public GameObject runtimeGameObject { get { return m_GameObject; } }
        public float runtimeAngle { get; internal set; }
        public int runtimeGridIndex { get; internal set; }
        public int runtimePolarIndex { get; internal set; }
 
        public DelegateTooltipPosition positionFunction
        {
            get { return m_PositionFunction; }
            set { m_PositionFunction = value; }
        }
 
        public static Tooltip defaultTooltip
        {
            get
            {
                var tooltip = new Tooltip
                {
                    m_Show = true
                };
                return tooltip;
            }
        }
 
        public void SetObj(GameObject obj)
        {
            m_GameObject = obj;
            m_GameObject.SetActive(false);
        }
 
        public void SetContentObj(GameObject content)
        {
            m_Content = content;
            m_ContentRect = m_Content.GetComponent<RectTransform>();
            m_ContentImage = m_Content.GetComponent<Image>();
            m_ContentImage.raycastTarget = false;
            m_ContentText = new ChartText(m_Content);
            if (m_ContentText != null)
            {
                m_ContentTextRect = m_ContentText.gameObject.GetComponentInChildren<RectTransform>();
            }
            SetBackground(backgroundImage);
        }
 
        public void UpdateToTop()
        {
            if (m_GameObject == null) return;
            int count = m_GameObject.transform.parent.childCount;
            m_GameObject.GetComponent<RectTransform>().SetSiblingIndex(count - 1);
        }
 
        public void SetContentBackgroundColor(Color color)
        {
            if (m_ContentImage != null)
                m_ContentImage.color = color;
        }
 
        public void SetBackground(Sprite sprite)
        {
            if (m_ContentImage != null)
            {
                m_ContentImage.type = Image.Type.Sliced;
                m_ContentImage.sprite = sprite;
            }
        }
 
        public void SetContentTextColor(Color color)
        {
            if (m_ContentText != null)
            {
                m_ContentText.SetColor(color);
            }
        }
 
        public void UpdateContentText(string txt)
        {
            if (m_ContentText != null)
            {
                m_ContentText.SetText(txt);
                float wid, hig;
                if (m_FixedWidth > 0) wid = m_FixedWidth;
                else if (m_MinWidth > 0 && m_ContentText.GetPreferredWidth() < m_MinWidth) wid = m_MinWidth;
                else wid = m_ContentText.GetPreferredWidth() + m_PaddingLeftRight * 2;
                if (m_FixedHeight > 0) hig = m_FixedHeight;
                else if (m_MinHeight > 0 && m_ContentText.GetPreferredHeight() < m_MinHeight) hig = m_MinHeight;
                else hig = m_ContentText.GetPreferredHeight() + m_PaddingTopBottom * 2;
                if (m_ContentRect != null) m_ContentRect.sizeDelta = new Vector2(wid, hig);
                if (m_ContentTextRect != null)
                {
                    m_ContentTextRect.anchoredPosition = new Vector3(m_PaddingLeftRight, -m_PaddingTopBottom);
                }
            }
        }
 
        internal void ClearValue()
        {
            for (int i = 0; i < runtimeDataIndex.Count; i++) runtimeDataIndex[i] = -1;
            for (int i = 0; i < runtimeXValues.Length; i++) runtimeXValues[i] = -1;
            for (int i = 0; i < runtimeYValues.Length; i++) runtimeYValues[i] = -1;
        }
 
        public bool IsActive()
        {
            return m_GameObject != null && m_GameObject.activeInHierarchy;
        }
 
        public void SetActive(bool flag)
        {
            if (!flag && m_AlwayShow) return;
            if (lastDataIndex.Count >= 2)
                lastDataIndex[0] = lastDataIndex[1] = -1;
            if (m_GameObject && m_GameObject.activeInHierarchy != flag)
                m_GameObject.SetActive(flag);
        }
 
        public void UpdateContentPos(Vector2 pos)
        {
            if (m_Content)
            {
                if (m_PositionFunction != null)
                    m_Content.transform.localPosition = m_PositionFunction(pos);
                else
                    m_Content.transform.localPosition = pos;
            }
        }
 
        public Vector3 GetContentPos()
        {
            if (m_Content)
                return m_Content.transform.localPosition;
            else
                return Vector3.zero;
        }
 
        public bool IsDataIndexChanged()
        {
            if (runtimeDataIndex.Count < 2 || lastDataIndex.Count < 2) return false;
            return runtimeDataIndex[0] != lastDataIndex[0] ||
                runtimeDataIndex[1] != lastDataIndex[1];
        }
 
        internal void UpdateLastDataIndex()
        {
            if (lastDataIndex.Count > 0 && runtimeDataIndex.Count > 0) lastDataIndex[0] = runtimeDataIndex[0];
            if (lastDataIndex.Count > 0 && runtimeDataIndex.Count > 1) lastDataIndex[1] = runtimeDataIndex[1];
        }
 
        public bool IsSelected()
        {
            foreach (var index in runtimeDataIndex)
                if (index >= 0) return true;
            return false;
        }
 
        public bool IsSelected(int index)
        {
            foreach (var temp in runtimeDataIndex)
                if (temp == index) return true;
            return false;
        }
 
        public void ClearSerieDataIndex()
        {
            foreach (var kv in runtimeSerieIndex)
            {
                kv.Value.Clear();
            }
        }
 
        public void AddSerieDataIndex(int serieIndex, int dataIndex)
        {
            if (!runtimeSerieIndex.ContainsKey(serieIndex))
            {
                runtimeSerieIndex[serieIndex] = new List<int>();
            }
            runtimeSerieIndex[serieIndex].Add(dataIndex);
        }
 
        public bool isAnySerieDataIndex()
        {
            foreach (var kv in runtimeSerieIndex)
            {
                if (kv.Value.Count > 0) return true;
            }
            return false;
        }
    }
}