mirror of
https://github.com/XCharts-Team/XCharts.git
synced 2026-05-15 21:00:11 +00:00
817 lines
26 KiB
C#
817 lines
26 KiB
C#
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
|
|
namespace XCharts
|
|
{
|
|
/// <summary>
|
|
/// the list of series.
|
|
/// 系列列表。每个系列通过 type 决定自己的图表类型。
|
|
/// </summary>
|
|
[System.Serializable]
|
|
public class Series : JsonDataSupport
|
|
{
|
|
[SerializeField] protected List<Serie> m_Series;
|
|
|
|
/// <summary>
|
|
/// the list of serie
|
|
/// 系列列表。
|
|
/// </summary>
|
|
/// <value></value>
|
|
public List<Serie> series { get { return m_Series; } }
|
|
/// <summary>
|
|
/// the size of serie list.
|
|
/// 系列个数。
|
|
/// </summary>
|
|
/// <value></value>
|
|
public int Count { get { return m_Series.Count; } }
|
|
|
|
public static Series defaultSeries
|
|
{
|
|
get
|
|
{
|
|
var series = new Series
|
|
{
|
|
m_Series = new List<Serie>(){new Serie(){
|
|
show = true,
|
|
name = "serie1",
|
|
index = 0
|
|
}}
|
|
};
|
|
return series;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 清空所有系列的数据
|
|
/// </summary>
|
|
public void ClearData()
|
|
{
|
|
foreach (var serie in m_Series)
|
|
{
|
|
serie.ClearData();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得指定序列指定索引的数据值
|
|
/// </summary>
|
|
/// <param name="serieIndex"></param>
|
|
/// <param name="dataIndex"></param>
|
|
/// <returns></returns>
|
|
public float GetData(int serieIndex, int dataIndex)
|
|
{
|
|
if (serieIndex >= 0 && serieIndex < Count)
|
|
{
|
|
return m_Series[serieIndex].GetYData(dataIndex);
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得指定系列名的第一个系列
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <returns></returns>
|
|
public Serie GetSerie(string name)
|
|
{
|
|
for (int i = 0; i < m_Series.Count; i++)
|
|
{
|
|
if (name.Equals(m_Series[i].name))
|
|
{
|
|
m_Series[i].index = i;
|
|
return m_Series[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得指定系列名的所有系列
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <returns></returns>
|
|
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;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得指定索引的系列
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <returns></returns>
|
|
public Serie GetSerie(int index)
|
|
{
|
|
if (index >= 0 && index < m_Series.Count)
|
|
{
|
|
return m_Series[index];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得上一个同堆叠且显示的serie。
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <returns></returns>
|
|
public Serie GetLastStackSerie(int index)
|
|
{
|
|
var serie = GetSerie(index);
|
|
return GetLastStackSerie(serie);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 同堆叠的serie是否有渐变色的。
|
|
/// </summary>
|
|
/// <param name="stack"></param>
|
|
/// <returns></returns>
|
|
public bool IsAnyGradientSerie(string stack)
|
|
{
|
|
if (string.IsNullOrEmpty(stack)) return false;
|
|
foreach (var serie in m_Series)
|
|
{
|
|
if (serie.show && serie.areaStyle.show && stack.Equals(serie.stack))
|
|
{
|
|
if (serie.areaStyle.color != serie.areaStyle.toColor && serie.areaStyle.toColor != Color.clear) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得上一个同堆叠且显示的serie。
|
|
/// </summary>
|
|
/// <param name="serie"></param>
|
|
/// <returns></returns>
|
|
public Serie GetLastStackSerie(Serie serie)
|
|
{
|
|
if (serie == null || string.IsNullOrEmpty(serie.stack)) return null;
|
|
for (int i = serie.index - 1; i >= 0; i--)
|
|
{
|
|
var temp = m_Series[i];
|
|
if (temp.show && serie.stack.Equals(temp.stack)) return temp;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 是否包含指定名字的系列
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <returns></returns>
|
|
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;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove serie from series.
|
|
/// 移除指定名字的系列。
|
|
/// </summary>
|
|
/// <param name="serieName">the name of serie</param>
|
|
public void Remove(string serieName)
|
|
{
|
|
var serie = GetSerie(serieName);
|
|
if (serie != null)
|
|
{
|
|
m_Series.Remove(serie);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove all serie from series.
|
|
/// 移除所有系列。
|
|
/// </summary>
|
|
public void RemoveAll()
|
|
{
|
|
m_Series.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加一个系列到列表中。
|
|
/// </summary>
|
|
/// <param name="serieName"></param>
|
|
/// <param name="type"></param>
|
|
/// <param name="show"></param>
|
|
/// <returns></returns>
|
|
public Serie AddSerie(string serieName, SerieType type, bool show = true)
|
|
{
|
|
var serie = GetSerie(serieName);
|
|
if (serie == null)
|
|
{
|
|
serie = new Serie();
|
|
serie.type = type;
|
|
serie.show = show;
|
|
serie.name = serieName;
|
|
serie.index = m_Series.Count;
|
|
|
|
if (type == SerieType.Scatter)
|
|
{
|
|
serie.symbol.type = SerieSymbolType.Circle;
|
|
serie.symbol.size = 20f;
|
|
serie.symbol.selectedSize = 30f;
|
|
}
|
|
else if (type == SerieType.Line)
|
|
{
|
|
serie.symbol.type = SerieSymbolType.EmptyCircle;
|
|
serie.symbol.size = 2.5f;
|
|
serie.symbol.selectedSize = 5f;
|
|
}
|
|
else
|
|
{
|
|
serie.symbol.type = SerieSymbolType.None;
|
|
}
|
|
m_Series.Add(serie);
|
|
}
|
|
else
|
|
{
|
|
serie.show = show;
|
|
}
|
|
return serie;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加一个数据到指定系列的维度Y数据中
|
|
/// </summary>
|
|
/// <param name="serieName"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="dataName"></param>
|
|
/// <param name="maxDataNumber"></param>
|
|
/// <returns></returns>
|
|
public bool AddData(string serieName, float value, string dataName = null, int maxDataNumber = 0)
|
|
{
|
|
var serie = GetSerie(serieName);
|
|
if (serie != null)
|
|
{
|
|
serie.AddYData(value, dataName, maxDataNumber);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加一个数据到指定系列的维度Y中
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="dataName"></param>
|
|
/// <param name="maxDataNumber"></param>
|
|
/// <returns></returns>
|
|
public bool AddData(int index, float value, string dataName = null, int maxDataNumber = 0)
|
|
{
|
|
var serie = GetSerie(index);
|
|
if (serie != null)
|
|
{
|
|
serie.AddYData(value, dataName, maxDataNumber);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加一组数据到指定的系列中
|
|
/// </summary>
|
|
/// <param name="serieName"></param>
|
|
/// <param name="multidimensionalData"></param>
|
|
/// <param name="dataName"></param>
|
|
/// <param name="maxDataNumber"></param>
|
|
/// <returns></returns>
|
|
public bool AddData(string serieName, List<float> multidimensionalData, string dataName = null, int maxDataNumber = 0)
|
|
{
|
|
var serie = GetSerie(serieName);
|
|
if (serie != null)
|
|
{
|
|
serie.AddData(multidimensionalData, dataName, maxDataNumber);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加一组数据到指定的系列中
|
|
/// </summary>
|
|
/// <param name="serieIndex"></param>
|
|
/// <param name="multidimensionalData"></param>
|
|
/// <param name="dataName"></param>
|
|
/// <param name="maxDataNumber"></param>
|
|
/// <returns></returns>
|
|
public bool AddData(int serieIndex, List<float> multidimensionalData, string dataName = null, int maxDataNumber = 0)
|
|
{
|
|
var serie = GetSerie(serieIndex);
|
|
if (serie != null)
|
|
{
|
|
serie.AddData(multidimensionalData, dataName, maxDataNumber);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加(x,y)数据到指定的系列中
|
|
/// </summary>
|
|
/// <param name="serieName"></param>
|
|
/// <param name="xValue"></param>
|
|
/// <param name="yValue"></param>
|
|
/// <param name="dataName"></param>
|
|
/// <param name="maxDataNumber"></param>
|
|
/// <returns></returns>
|
|
public bool AddXYData(string serieName, float xValue, float yValue, string dataName = null, int maxDataNumber = 0)
|
|
{
|
|
var serie = GetSerie(serieName);
|
|
if (serie != null)
|
|
{
|
|
serie.AddXYData(xValue, yValue, dataName, maxDataNumber);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加(x,y)数据到指定的系列中
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <param name="xValue"></param>
|
|
/// <param name="yValue"></param>
|
|
/// <param name="dataName"></param>
|
|
/// <param name="maxDataNumber"></param>
|
|
/// <returns></returns>
|
|
public bool AddXYData(int index, float xValue, float yValue, string dataName = null, int maxDataNumber = 0)
|
|
{
|
|
var serie = GetSerie(index);
|
|
if (serie != null)
|
|
{
|
|
serie.AddXYData(xValue, yValue, dataName, maxDataNumber);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 更新指定系列的维度Y数据
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="dataIndex"></param>
|
|
public void UpdateData(string name, float value, int dataIndex = 0)
|
|
{
|
|
var serie = GetSerie(name);
|
|
if (serie != null)
|
|
{
|
|
serie.UpdateYData(dataIndex, value);
|
|
}
|
|
}
|
|
|
|
public void UpdateDataName(string serieName, string dataName, int dataIndex = 0)
|
|
{
|
|
var serie = GetSerie(serieName);
|
|
if (serie != null)
|
|
{
|
|
serie.UpdateDataName(dataIndex, dataName);
|
|
}
|
|
}
|
|
|
|
public void UpdateDataName(int serieIndex, string dataName, int dataIndex = 0)
|
|
{
|
|
var serie = GetSerie(serieIndex);
|
|
if (serie != null)
|
|
{
|
|
serie.UpdateDataName(dataIndex, dataName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 更新指定系列的维度Y数据
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <param name="value"></param>
|
|
/// <param name="dataIndex"></param>
|
|
public void UpdateData(int index, float value, int dataIndex = 0)
|
|
{
|
|
var serie = GetSerie(index);
|
|
if (serie != null)
|
|
{
|
|
serie.UpdateYData(dataIndex, value);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 更新指定系列的维度X和维度Y数据
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="xValue"></param>
|
|
/// <param name="yValue"></param>
|
|
/// <param name="dataIndex"></param>
|
|
public void UpdateXYData(string name, float xValue, float yValue, int dataIndex = 0)
|
|
{
|
|
var serie = GetSerie(name);
|
|
if (serie != null)
|
|
{
|
|
serie.UpdateXYData(dataIndex, xValue, yValue);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 更新指定系列的维度X和维度Y数据
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <param name="xValue"></param>
|
|
/// <param name="yValue"></param>
|
|
/// <param name="dataIndex"></param>
|
|
public void UpdateXYData(int index, float xValue, float yValue, int dataIndex = 0)
|
|
{
|
|
var serie = GetSerie(index);
|
|
if (serie != null)
|
|
{
|
|
serie.UpdateXYData(dataIndex, xValue, yValue);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// dataZoom由变化是更新系列的缓存数据
|
|
/// </summary>
|
|
/// <param name="dataZoom"></param>
|
|
public void UpdateFilterData(DataZoom dataZoom)
|
|
{
|
|
if (dataZoom != null && dataZoom.show)
|
|
{
|
|
for (int i = 0; i < m_Series.Count; i++)
|
|
{
|
|
m_Series[i].UpdateFilterData(dataZoom);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 指定系列是否显示
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <returns></returns>
|
|
public bool IsActive(string name)
|
|
{
|
|
var serie = GetSerie(name);
|
|
return serie == null ? false : serie.show;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 指定系列是否显示
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <returns></returns>
|
|
public bool IsActive(int index)
|
|
{
|
|
var serie = GetSerie(index);
|
|
return serie == null ? false : serie.show;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置指定系列是否显示
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="active"></param>
|
|
public void SetActive(string name, bool active)
|
|
{
|
|
var serie = GetSerie(name);
|
|
if (serie != null)
|
|
{
|
|
serie.show = active;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置指定系列是否显示
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <param name="active"></param>
|
|
public void SetActive(int index, bool active)
|
|
{
|
|
var serie = GetSerie(index);
|
|
if (serie != null)
|
|
{
|
|
serie.show = active;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 是否由系列在用指定索引的axis
|
|
/// </summary>
|
|
/// <param name="axisIndex"></param>
|
|
/// <returns></returns>
|
|
public bool IsUsedAxisIndex(int axisIndex)
|
|
{
|
|
foreach (var serie in series)
|
|
{
|
|
if (serie.axisIndex == axisIndex) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 指定系列是否处于高亮选中状态
|
|
/// </summary>
|
|
/// <param name="serieIndex"></param>
|
|
/// <returns></returns>
|
|
public bool IsHighlight(int serieIndex)
|
|
{
|
|
var serie = GetSerie(serieIndex);
|
|
if (serie != null) return serie.highlighted;
|
|
else return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得维度X的最大最小值
|
|
/// </summary>
|
|
/// <param name="dataZoom"></param>
|
|
/// <param name="axisIndex"></param>
|
|
/// <param name="minVaule"></param>
|
|
/// <param name="maxValue"></param>
|
|
public void GetXMinMaxValue(DataZoom dataZoom, int axisIndex, out int minVaule, out int maxValue)
|
|
{
|
|
GetMinMaxValue(dataZoom, axisIndex, false, out minVaule, out maxValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得维度Y的最大最小值
|
|
/// </summary>
|
|
/// <param name="dataZoom"></param>
|
|
/// <param name="axisIndex"></param>
|
|
/// <param name="minVaule"></param>
|
|
/// <param name="maxValue"></param>
|
|
public void GetYMinMaxValue(DataZoom dataZoom, int axisIndex, out int minVaule, out int maxValue)
|
|
{
|
|
GetMinMaxValue(dataZoom, axisIndex, true, out minVaule, out maxValue);
|
|
}
|
|
|
|
private Dictionary<int, List<Serie>> _stackSeriesForMinMax = new Dictionary<int, List<Serie>>();
|
|
private Dictionary<int, float> _serieTotalValueForMinMax = new Dictionary<int, float>();
|
|
public void GetMinMaxValue(DataZoom dataZoom, int axisIndex, bool yValue, out int minVaule, out int maxValue)
|
|
{
|
|
float min = int.MaxValue;
|
|
float max = int.MinValue;
|
|
if (IsStack())
|
|
{
|
|
GetStackSeries(ref _stackSeriesForMinMax);
|
|
foreach (var ss in _stackSeriesForMinMax)
|
|
{
|
|
_serieTotalValueForMinMax.Clear();
|
|
for (int i = 0; i < ss.Value.Count; i++)
|
|
{
|
|
var serie = ss.Value[i];
|
|
if (serie.axisIndex != axisIndex || !IsActive(i)) continue;
|
|
var showData = serie.GetDataList(dataZoom);
|
|
for (int j = 0; j < showData.Count; j++)
|
|
{
|
|
if (!_serieTotalValueForMinMax.ContainsKey(j))
|
|
_serieTotalValueForMinMax[j] = 0;
|
|
_serieTotalValueForMinMax[j] = _serieTotalValueForMinMax[j] + (yValue ? showData[j].data[1] : showData[i].data[0]);
|
|
}
|
|
}
|
|
float tmax = int.MinValue;
|
|
float tmin = int.MaxValue;
|
|
foreach (var tt in _serieTotalValueForMinMax)
|
|
{
|
|
if (tt.Value > tmax) tmax = tt.Value;
|
|
if (tt.Value < tmin) tmin = tt.Value;
|
|
}
|
|
if (tmax > max) max = tmax;
|
|
if (tmin < min) min = tmin;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < m_Series.Count; i++)
|
|
{
|
|
if (m_Series[i].axisIndex != axisIndex) continue;
|
|
if (IsActive(i))
|
|
{
|
|
var showData = m_Series[i].GetDataList(dataZoom);
|
|
foreach (var data in showData)
|
|
{
|
|
if (yValue)
|
|
{
|
|
if (data.data[1] > max) max = data.data[1];
|
|
if (data.data[1] < min) min = data.data[1];
|
|
}
|
|
else
|
|
{
|
|
if (data.data[0] > max) max = data.data[0];
|
|
if (data.data[0] < min) min = data.data[0];
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (max == int.MinValue && min == int.MaxValue)
|
|
{
|
|
minVaule = 0;
|
|
maxValue = 90;
|
|
}
|
|
else
|
|
{
|
|
minVaule = Mathf.FloorToInt(min);
|
|
maxValue = Mathf.CeilToInt(max);
|
|
}
|
|
}
|
|
|
|
private HashSet<string> _setForStack = new HashSet<string>();
|
|
/// <summary>
|
|
/// 是否由数据堆叠
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool IsStack()
|
|
{
|
|
_setForStack.Clear();
|
|
foreach (var serie in m_Series)
|
|
{
|
|
if (string.IsNullOrEmpty(serie.stack)) continue;
|
|
if (_setForStack.Contains(serie.stack)) return true;
|
|
else
|
|
{
|
|
_setForStack.Add(serie.stack);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool IsStack(string stackName, SerieType type)
|
|
{
|
|
if (string.IsNullOrEmpty(stackName)) return false;
|
|
int count = 0;
|
|
foreach (var serie in m_Series)
|
|
{
|
|
if (serie.show && serie.type == type)
|
|
{
|
|
if (stackName.Equals(serie.stack)) count++;
|
|
if (count >= 2) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得堆叠系列列表
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Dictionary<int, List<Serie>> GetStackSeries()
|
|
{
|
|
int count = 0;
|
|
Dictionary<string, int> sets = new Dictionary<string, int>();
|
|
Dictionary<int, List<Serie>> stackSeries = new Dictionary<int, List<Serie>>();
|
|
for (int i = 0; i < m_Series.Count; i++)
|
|
{
|
|
var serie = m_Series[i];
|
|
serie.index = i;
|
|
if (string.IsNullOrEmpty(serie.stack))
|
|
{
|
|
stackSeries[count] = new List<Serie>();
|
|
stackSeries[count].Add(serie);
|
|
count++;
|
|
}
|
|
else
|
|
{
|
|
if (!sets.ContainsKey(serie.stack))
|
|
{
|
|
sets.Add(serie.stack, count);
|
|
stackSeries[count] = new List<Serie>();
|
|
stackSeries[count].Add(serie);
|
|
count++;
|
|
}
|
|
else
|
|
{
|
|
int stackIndex = sets[serie.stack];
|
|
stackSeries[stackIndex].Add(serie);
|
|
}
|
|
}
|
|
}
|
|
return stackSeries;
|
|
}
|
|
|
|
private Dictionary<string, int> sets = new Dictionary<string, int>();
|
|
/// <summary>
|
|
/// 获得堆叠系列列表
|
|
/// </summary>
|
|
/// <param name="Dictionary<int"></param>
|
|
/// <param name="stackSeries"></param>
|
|
public void GetStackSeries(ref Dictionary<int, List<Serie>> stackSeries)
|
|
{
|
|
int count = 0;
|
|
sets.Clear();
|
|
if (stackSeries == null)
|
|
{
|
|
stackSeries = new Dictionary<int, List<Serie>>(m_Series.Count);
|
|
}
|
|
else
|
|
{
|
|
foreach (var kv in stackSeries)
|
|
{
|
|
kv.Value.Clear();
|
|
}
|
|
}
|
|
for (int i = 0; i < m_Series.Count; i++)
|
|
{
|
|
var serie = m_Series[i];
|
|
serie.index = i;
|
|
if (string.IsNullOrEmpty(serie.stack))
|
|
{
|
|
if (!stackSeries.ContainsKey(count))
|
|
stackSeries[count] = new List<Serie>(m_Series.Count);
|
|
stackSeries[count].Add(serie);
|
|
count++;
|
|
}
|
|
else
|
|
{
|
|
if (!sets.ContainsKey(serie.stack))
|
|
{
|
|
sets.Add(serie.stack, count);
|
|
if (!stackSeries.ContainsKey(count))
|
|
stackSeries[count] = new List<Serie>(m_Series.Count);
|
|
stackSeries[count].Add(serie);
|
|
count++;
|
|
}
|
|
else
|
|
{
|
|
int stackIndex = sets[serie.stack];
|
|
stackSeries[stackIndex].Add(serie);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<string> serieNameList = new List<string>();
|
|
/// <summary>
|
|
/// 获得所有系列名，不包含空名字。
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public List<string> GetSerieNameList()
|
|
{
|
|
serieNameList.Clear();
|
|
foreach (var serie in m_Series)
|
|
{
|
|
if (!string.IsNullOrEmpty(serie.name) && !serieNameList.Contains(serie.name))
|
|
{
|
|
serieNameList.Add(serie.name);
|
|
}
|
|
foreach (var data in serie.data)
|
|
{
|
|
if (!string.IsNullOrEmpty(data.name) && !serieNameList.Contains(data.name))
|
|
{
|
|
serieNameList.Add(data.name);
|
|
}
|
|
}
|
|
}
|
|
return serieNameList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置获得标志图形大小的回调
|
|
/// </summary>
|
|
/// <param name="size"></param>
|
|
/// <param name="selectedSize"></param>
|
|
public void SetSerieSymbolSizeCallback(SymbolSizeCallback size, SymbolSizeCallback selectedSize)
|
|
{
|
|
foreach (var serie in m_Series)
|
|
{
|
|
serie.symbol.sizeCallback = size;
|
|
serie.symbol.selectedSizeCallback = selectedSize;
|
|
}
|
|
}
|
|
|
|
public void AnimationStart()
|
|
{
|
|
foreach (var serie in m_Series)
|
|
{
|
|
if (serie.animation.enable)
|
|
{
|
|
serie.animation.Start();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 从json中解析数据
|
|
/// </summary>
|
|
/// <param name="jsonData"></param>
|
|
public override void ParseJsonData(string jsonData)
|
|
{
|
|
//TODO:
|
|
}
|
|
}
|
|
}
|