foldcc/XCharts
1
0
Fork 0
mirror of https://github.com/XCharts-Team/XCharts.git synced 2026-05-22 17:00:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

重构SerieSymbol

Browse Source
This commit is contained in:
monitor1394
2019-07-21 22:58:51 +08:00
parent 2296fb66ff
commit ff8057690c
9 changed files with 430 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Demo/Scripts/Demo11_AddSinCurve.cs
View File

@@ -40,7 +40,8 @@ public class Demo11_AddSinCurve : MonoBehaviour
chart.RemoveData(); chart.RemoveData();
chart.AddSerie("test", SerieType.Line); var serie = chart.AddSerie("test", SerieType.Line);
serie.symbol.type = SerieSymbolType.None;
for (angle = 0; angle < 1080; angle++) for (angle = 0; angle < 1080; angle++)
{ {
float xvalue = Mathf.PI / 180 * angle; float xvalue = Mathf.PI / 180 * angle;

2
Demo/Scripts/Demo_Dynamic.cs
View File

@@ -23,7 +23,7 @@ public class Demo_Dynamic : MonoBehaviour
chart = gameObject.GetComponentInChildren<CoordinateChart>(); chart = gameObject.GetComponentInChildren<CoordinateChart>();
chart.RemoveData(); chart.RemoveData();
var serie = chart.AddSerie("data", SerieType.Line); var serie = chart.AddSerie("data", SerieType.Line);
serie.symbol = SerieSymbolType.None; serie.symbol.type = SerieSymbolType.None;
chart.maxCacheDataNumber = maxCacheDataNumber; chart.maxCacheDataNumber = maxCacheDataNumber;
timeNow = DateTime.Now; timeNow = DateTime.Now;
timeNow = timeNow.AddSeconds(-maxCacheDataNumber); timeNow = timeNow.AddSeconds(-maxCacheDataNumber);

174
Scripts/Editor/PropertyDrawers/SerieDrawer.cs
View File

@@ -7,6 +7,7 @@ namespace XCharts
[CustomPropertyDrawer(typeof(Serie), true)] [CustomPropertyDrawer(typeof(Serie), true)]
public class SerieDrawer : PropertyDrawer public class SerieDrawer : PropertyDrawer
{ {
private List<bool> m_SerieModuleToggle = new List<bool>(); private List<bool> m_SerieModuleToggle = new List<bool>();
private List<bool> m_DataFoldout = new List<bool>(); private List<bool> m_DataFoldout = new List<bool>();
private int m_DataSize = 0; private int m_DataSize = 0;
@@ -23,11 +24,9 @@ namespace XCharts
SerializedProperty stack = prop.FindPropertyRelative("m_Stack"); SerializedProperty stack = prop.FindPropertyRelative("m_Stack");
SerializedProperty m_AxisIndex = prop.FindPropertyRelative("m_AxisIndex"); SerializedProperty m_AxisIndex = prop.FindPropertyRelative("m_AxisIndex");
SerializedProperty m_Symbol = prop.FindPropertyRelative("m_Symbol"); SerializedProperty m_Symbol = prop.FindPropertyRelative("m_Symbol");
SerializedProperty m_SymbolSize = prop.FindPropertyRelative("m_SymbolSize"); SerializedProperty m_DataDimension = prop.FindPropertyRelative("m_ShowDataDimension");
SerializedProperty m_SymbolSelectedSize = prop.FindPropertyRelative("m_SymbolSelectedSize"); SerializedProperty m_ShowDataName = prop.FindPropertyRelative("m_ShowDataName");
SerializedProperty m_TwoDimensionData = prop.FindPropertyRelative("m_TwoDimensionData"); SerializedProperty m_Datas = prop.FindPropertyRelative("m_Data");
SerializedProperty m_XData = prop.FindPropertyRelative("m_XData");
SerializedProperty m_YData = prop.FindPropertyRelative("m_YData");
int index = InitToggle(prop); int index = InitToggle(prop);
string moduleName = "Serie " + index; string moduleName = "Serie " + index;
@@ -48,89 +47,114 @@ namespace XCharts
if (type.enumValueIndex == (int)SerieType.Line || type.enumValueIndex == (int)SerieType.Scatter) if (type.enumValueIndex == (int)SerieType.Line || type.enumValueIndex == (int)SerieType.Scatter)
{ {
EditorGUI.PropertyField(drawRect, m_Symbol); EditorGUI.PropertyField(drawRect, m_Symbol);
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing; drawRect.y += EditorGUI.GetPropertyHeight(m_Symbol);
EditorGUI.PropertyField(drawRect, m_SymbolSize);
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
EditorGUI.PropertyField(drawRect, m_SymbolSelectedSize);
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
} }
EditorGUI.PropertyField(drawRect, m_TwoDimensionData);
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
drawRect.width = EditorGUIUtility.labelWidth + 10; drawRect.width = EditorGUIUtility.labelWidth + 10;
m_DataFoldout[index] = EditorGUI.Foldout(drawRect, m_DataFoldout[index], "Data"); m_DataFoldout[index] = EditorGUI.Foldout(drawRect, m_DataFoldout[index], "Data");
ChartEditorHelper.MakeJsonData(ref drawRect, ref m_ShowJsonDataArea, ref m_JsonDataAreaText, prop); ChartEditorHelper.MakeJsonData(ref drawRect, ref m_ShowJsonDataArea, ref m_JsonDataAreaText, prop);
drawRect.width = pos.width; drawRect.width = pos.width;
if (m_DataFoldout[index]) if (m_DataFoldout[index])
{ {
if (m_TwoDimensionData.boolValue) EditorGUI.indentLevel++;
EditorGUI.PropertyField(drawRect, m_ShowDataName);
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
EditorGUI.PropertyField(drawRect, m_DataDimension);
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
var listSize = m_Datas.arraySize;
listSize = EditorGUI.IntField(drawRect, "Size", listSize);
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
if (listSize < 0) listSize = 0;
if (m_DataDimension.intValue < 1) m_DataDimension.intValue = 1;
int dimension = m_DataDimension.intValue;
bool showName = m_ShowDataName.boolValue;
if (listSize != m_Datas.arraySize)
{ {
EditorGUI.indentLevel++; while (listSize > m_Datas.arraySize)
var listSize = m_YData.arraySize; m_Datas.InsertArrayElementAtIndex(m_Datas.arraySize);
listSize = EditorGUI.IntField(drawRect, "Size", listSize); while (listSize < m_Datas.arraySize)
if (listSize < 0) listSize = 0; m_Datas.DeleteArrayElementAtIndex(m_Datas.arraySize - 1);
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing; }
if (listSize != m_XData.arraySize) if (listSize > 30)
{
int num = listSize > 10 ? 10 : listSize;
for (int i = 0; i < num; i++)
{ {
while (listSize > m_XData.arraySize) DrawDataElement(ref drawRect, dimension, m_Datas, showName, i);
m_XData.InsertArrayElementAtIndex(m_XData.arraySize);
while (listSize < m_XData.arraySize)
m_XData.DeleteArrayElementAtIndex(m_XData.arraySize - 1);
} }
if (listSize != m_YData.arraySize) if (num >= 10)
{ {
while (listSize > m_YData.arraySize) EditorGUI.LabelField(drawRect, "...");
m_YData.InsertArrayElementAtIndex(m_YData.arraySize); drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
while (listSize < m_YData.arraySize) DrawDataElement(ref drawRect, dimension, m_Datas, showName, listSize - 1);
m_YData.DeleteArrayElementAtIndex(m_YData.arraySize - 1);
} }
if (listSize > 30)
{
int num = listSize > 10 ? 10 : listSize;
for (int i = 0; i < num; i++)
{
DrawTwoDimensionDataElement(ref drawRect, m_XData, m_YData, i);
}
if (num >= 10)
{
EditorGUI.LabelField(drawRect, "...");
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
DrawTwoDimensionDataElement(ref drawRect, m_XData, m_YData, listSize - 1);
}
}
else
{
for (int i = 0; i < m_YData.arraySize; i++)
{
DrawTwoDimensionDataElement(ref drawRect, m_XData, m_YData, i);
}
}
EditorGUI.indentLevel--;
} }
else else
{ {
ChartEditorHelper.MakeList(ref drawRect, ref m_DataSize, m_YData); for (int i = 0; i < m_Datas.arraySize; i++)
{
DrawDataElement(ref drawRect, dimension, m_Datas, showName, i);
}
} }
EditorGUI.indentLevel--;
} }
--EditorGUI.indentLevel; --EditorGUI.indentLevel;
} }
} }
private void DrawTwoDimensionDataElement(ref Rect drawRect, SerializedProperty m_Data1, private void DrawDataElement(ref Rect drawRect, int dimension, SerializedProperty m_Datas, bool showName, int index)
SerializedProperty m_Data2, int i)
{ {
var lastX = drawRect.x; var lastX = drawRect.x;
SerializedProperty element1 = m_Data1.GetArrayElementAtIndex(i); var lastWid = drawRect.width;
SerializedProperty element2 = m_Data2.GetArrayElementAtIndex(i); var lastFieldWid = EditorGUIUtility.fieldWidth;
EditorGUI.LabelField(drawRect, "Element " + i); var lastLabelWid = EditorGUIUtility.labelWidth;
var startX = EditorGUIUtility.labelWidth - (EditorGUI.indentLevel - 1) * 15 - 1; var serieData = m_Datas.GetArrayElementAtIndex(index);
var dataWid = (EditorGUIUtility.currentViewWidth - startX) / 2 + 15; var sereName = serieData.FindPropertyRelative("m_Name");
drawRect.x = startX; var data = serieData.FindPropertyRelative("m_Data");
drawRect.width = dataWid; var fieldCount = dimension + (showName ? 1 : 0);
element1.floatValue = EditorGUI.FloatField(drawRect, element1.floatValue);
drawRect.x += dataWid - 35; if (fieldCount <= 1)
element2.floatValue = EditorGUI.FloatField(drawRect, element2.floatValue); {
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing; while (2 > data.arraySize)
drawRect.x = lastX; data.InsertArrayElementAtIndex(data.arraySize);
SerializedProperty element = data.GetArrayElementAtIndex(1);
EditorGUI.PropertyField(drawRect, element);
drawRect.y += EditorGUI.GetPropertyHeight(element) + EditorGUIUtility.standardVerticalSpacing;
}
else
{
EditorGUI.LabelField(drawRect, "Element " + index);
var startX = drawRect.x + EditorGUIUtility.labelWidth - EditorGUI.indentLevel * 15 - 1;
var dataWidTotal = (EditorGUIUtility.currentViewWidth - (startX + EditorGUI.indentLevel * 15 + 1) - 5);
var dataWid = dataWidTotal / fieldCount;
var xWid = dataWid - 4;
for (int i = 0; i < dimension; i++)
{
if (i >= data.arraySize - 1)
{
data.InsertArrayElementAtIndex(data.arraySize);
}
drawRect.x = startX + i * xWid;
drawRect.width = dataWid + 40;
SerializedProperty element = data.GetArrayElementAtIndex(i);
EditorGUI.PropertyField(drawRect, element, GUIContent.none);
}
if (showName)
{
drawRect.x = startX + (fieldCount - 1) * xWid;
drawRect.width = dataWid + 40;
EditorGUI.PropertyField(drawRect, sereName, GUIContent.none);
}
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
drawRect.x = lastX;
drawRect.width = lastWid;
EditorGUIUtility.fieldWidth = lastFieldWid;
EditorGUIUtility.labelWidth = lastLabelWid;
}
SerializedProperty element1 = data.GetArrayElementAtIndex(0);
SerializedProperty element2 = data.GetArrayElementAtIndex(1);
} }
public override float GetPropertyHeight(SerializedProperty prop, GUIContent label) public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
@@ -143,16 +167,17 @@ namespace XCharts
} }
else else
{ {
height += 7 * EditorGUIUtility.singleLineHeight + 6 * EditorGUIUtility.standardVerticalSpacing; height += 6 * EditorGUIUtility.singleLineHeight + 5 * EditorGUIUtility.standardVerticalSpacing;
SerializedProperty type = prop.FindPropertyRelative("m_Type"); SerializedProperty type = prop.FindPropertyRelative("m_Type");
if (type.enumValueIndex == (int)SerieType.Line || type.enumValueIndex == (int)SerieType.Scatter) if (type.enumValueIndex == (int)SerieType.Line || type.enumValueIndex == (int)SerieType.Scatter)
{ {
height += 3 * EditorGUIUtility.singleLineHeight + 2 * EditorGUIUtility.standardVerticalSpacing;
height += EditorGUI.GetPropertyHeight(prop.FindPropertyRelative("m_Symbol"));
} }
if (m_DataFoldout[index]) if (m_DataFoldout[index])
{ {
SerializedProperty m_Data = prop.FindPropertyRelative("m_YData"); SerializedProperty m_Data = prop.FindPropertyRelative("m_Data");
int num = m_Data.arraySize + 1; int num = m_Data.arraySize + 3;
if (num > 30) num = 13; if (num > 30) num = 13;
height += num * EditorGUIUtility.singleLineHeight + (num - 1) * EditorGUIUtility.standardVerticalSpacing; height += num * EditorGUIUtility.singleLineHeight + (num - 1) * EditorGUIUtility.standardVerticalSpacing;
} }
@@ -167,7 +192,16 @@ namespace XCharts
private int InitToggle(SerializedProperty prop) private int InitToggle(SerializedProperty prop)
{ {
int index = 0; int index = 0;
int.TryParse(prop.displayName.Split(' ')[1], out index); var temp = prop.displayName.Split(' ');
if (temp == null || temp.Length < 2)
{
Debug.LogError("SERIE:"+prop.name+","+prop.displayName+","+prop.FindPropertyRelative("m_Name").stringValue);
index =0;
}
else
{
int.TryParse(temp[1], out index);
}
if (index >= m_DataFoldout.Count) if (index >= m_DataFoldout.Count)
{ {
m_DataFoldout.Add(false); m_DataFoldout.Add(false);

74
Scripts/Editor/PropertyDrawers/SerieSymbolDrawer.cs Normal file
View File

@@ -0,0 +1,74 @@
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;
namespace XCharts
{
[CustomPropertyDrawer(typeof(SerieSymbol), true)]
public class SerieSymbolDrawer : PropertyDrawer
{
private List<bool> m_SerieModuleToggle = new List<bool>();
private List<bool> m_DataFoldout = new List<bool>();
private int m_DataSize = 0;
private bool m_ShowJsonDataArea = false;
private string m_JsonDataAreaText;
public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
{
Rect drawRect = pos;
drawRect.height = EditorGUIUtility.singleLineHeight;
SerializedProperty m_Type = prop.FindPropertyRelative("m_Type");
SerializedProperty m_SizeType = prop.FindPropertyRelative("m_SizeType");
SerializedProperty m_Size = prop.FindPropertyRelative("m_Size");
SerializedProperty m_SelectedSize = prop.FindPropertyRelative("m_SelectedSize");
SerializedProperty m_DataIndex = prop.FindPropertyRelative("m_DataIndex");
SerializedProperty m_DataScale = prop.FindPropertyRelative("m_DataScale");
SerializedProperty m_SelectedDataScale = prop.FindPropertyRelative("m_SelectedDataScale");
SerializedProperty m_SizeCallback = prop.FindPropertyRelative("m_SizeCallback");
SerializedProperty m_SelectedSizeCallback = prop.FindPropertyRelative("m_SelectedSizeCallback");
EditorGUI.PropertyField(drawRect, m_Type, new GUIContent("Symbol Type"));
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
EditorGUI.PropertyField(drawRect, m_SizeType, new GUIContent("Symbol SizeType"));
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
SerieSymbolSizeType sizeType = (SerieSymbolSizeType)m_SizeType.enumValueIndex;
switch (sizeType)
{
case SerieSymbolSizeType.Custom:
EditorGUI.PropertyField(drawRect, m_Size, new GUIContent("Symbol Size"));
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
EditorGUI.PropertyField(drawRect, m_SelectedSize, new GUIContent("Symbol SelectedSize"));
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
break;
case SerieSymbolSizeType.FromData:
EditorGUI.PropertyField(drawRect, m_DataIndex, new GUIContent("Symbol DataIndex"));
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
EditorGUI.PropertyField(drawRect, m_DataScale, new GUIContent("Symbol DataScale"));
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
EditorGUI.PropertyField(drawRect, m_SelectedDataScale, new GUIContent("Symbol SelectedDataScale"));
drawRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
break;
case SerieSymbolSizeType.Callback:
break;
}
}
public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
{
SerializedProperty m_SizeType = prop.FindPropertyRelative("m_SizeType");
SerieSymbolSizeType sizeType = (SerieSymbolSizeType)m_SizeType.enumValueIndex;
switch (sizeType)
{
case SerieSymbolSizeType.Custom:
return 4 * EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
case SerieSymbolSizeType.FromData:
return 5 * EditorGUIUtility.singleLineHeight + 4 * EditorGUIUtility.standardVerticalSpacing;
case SerieSymbolSizeType.Callback:
return 4 * EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
}
return 4 * EditorGUIUtility.singleLineHeight + 3 * EditorGUIUtility.standardVerticalSpacing;
}
}
}

11
Scripts/Editor/PropertyDrawers/SerieSymbolDrawer.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e0c4d3c3303994821bde654cf67d414d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

18
Scripts/UI/Internal/BaseChart.cs
View File

@@ -28,7 +28,7 @@ namespace XCharts
[SerializeField] protected Tooltip m_Tooltip = Tooltip.defaultTooltip; [SerializeField] protected Tooltip m_Tooltip = Tooltip.defaultTooltip;
[SerializeField] protected Series m_Series = Series.defaultSeries; [SerializeField] protected Series m_Series = Series.defaultSeries;
[SerializeField] protected bool m_Large; [SerializeField] protected float m_Large = 1;
[SerializeField] protected int m_MinShowDataNumber; [SerializeField] protected int m_MinShowDataNumber;
[SerializeField] protected int m_MaxShowDataNumber; [SerializeField] protected int m_MaxShowDataNumber;
[SerializeField] protected int m_MaxCacheDataNumber; [SerializeField] protected int m_MaxCacheDataNumber;
@@ -668,11 +668,12 @@ namespace XCharts
case SerieSymbolType.None: case SerieSymbolType.None:
break; break;
case SerieSymbolType.Circle: case SerieSymbolType.Circle:
ChartHelper.DrawCricle(vh, pos, symbolSize, color); ChartHelper.DrawCricle(vh, pos, symbolSize, color, GetSymbolCricleSegment(symbolSize));
break; break;
case SerieSymbolType.EmptyCircle: case SerieSymbolType.EmptyCircle:
ChartHelper.DrawCricle(vh, pos, symbolSize, m_ThemeInfo.backgroundColor); int segment = GetSymbolCricleSegment(symbolSize);
ChartHelper.DrawDoughnut(vh, pos, symbolSize - tickness, symbolSize, 0, 360, color); ChartHelper.DrawCricle(vh, pos, symbolSize, m_ThemeInfo.backgroundColor, segment);
ChartHelper.DrawDoughnut(vh, pos, symbolSize - tickness, symbolSize, 0, 360, color, segment);
break; break;
case SerieSymbolType.Rect: case SerieSymbolType.Rect:
ChartHelper.DrawPolygon(vh, pos, symbolSize, color); ChartHelper.DrawPolygon(vh, pos, symbolSize, color);
@@ -695,6 +696,15 @@ namespace XCharts
} }
} }
private int GetSymbolCricleSegment(float radiu)
{
int max = 50;
int segent = (int)(2 * Mathf.PI * radiu / ChartHelper.CRICLE_SMOOTHNESS);
if (segent > max) segent = max;
segent = (int)(segent / (1 + (m_Large - 1) / 10));
return segent;
}
public virtual void OnPointerDown(PointerEventData eventData) public virtual void OnPointerDown(PointerEventData eventData)
{ {
} }

216
Scripts/UI/Internal/Serie.cs
View File

@@ -1,4 +1,5 @@
using System.Collections.Generic; using System;
using System.Collections.Generic;
using System.ComponentModel; using System.ComponentModel;
using UnityEngine; using UnityEngine;
using UnityEngine.Serialization; using UnityEngine.Serialization;
@@ -25,6 +26,106 @@ namespace XCharts
None, None,
} }
/// <summary>
/// The way to get serie symbol size.
/// <para> `Custom`:Specify constant for symbol size. </para>
/// <para> `FromData`:Specify the dataIndex and dataScale to calculate symbol size,the formula:data[dataIndex]*dataScale. </para>
/// <para> `Callback`:Specify callback function for symbol size. </para>
/// </summary>
public enum SerieSymbolSizeType
{
/// <summary>
/// Specify constant for symbol size.
/// </summary>
Custom,
/// <summary>
/// Specify the dataIndex and dataScale to calculate symbol size
/// </summary>
FromData,
/// <summary>
/// Specify callback function for symbol size
/// </summary>
Callback,
}
[System.Serializable]
public class SerieData
{
[SerializeField] private string m_Name;
[SerializeField] private List<float> m_Data = new List<float>();
public string name { get { return m_Name; } set { m_Name = value; } }
public List<float> data { get { return m_Data; } set { m_Data = value; } }
}
public delegate float SymbolSizeCallback(List<float> data);
[System.Serializable]
public class SerieSymbol
{
[SerializeField] private SerieSymbolType m_Type = SerieSymbolType.EmptyCircle;
[SerializeField] private SerieSymbolSizeType m_SizeType = SerieSymbolSizeType.Custom;
[SerializeField] private float m_Size = 20f;
[SerializeField] private float m_SelectedSize = 30f;
[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;
public SerieSymbolType type { get { return m_Type; } set { m_Type = value; } }
public float size { get { return m_Size; } set { m_Size = value; } }
public float selectedSize { get { return m_SelectedSize; } set { m_SelectedSize = value; } }
public int dataIndex { get { return m_DataIndex; } set { m_DataIndex = value; } }
public float dataScale { get { return m_DataScale; } set { m_DataScale = value; } }
public float selectedDataScale { get { return m_SelectedDataScale; } set { m_SelectedDataScale = value; } }
public SymbolSizeCallback sizeCallback { get { return m_SizeCallback; } set { m_SizeCallback = value; } }
public SymbolSizeCallback selectedSizeCallback { get { return m_SelectedSizeCallback; } set { m_SelectedSizeCallback = value; } }
public float GetSize(List<float> data)
{
switch (m_SizeType)
{
case SerieSymbolSizeType.Custom:
return size;
case SerieSymbolSizeType.FromData:
if (dataIndex >= 0 && dataIndex < data.Count)
{
return data[dataIndex] * m_DataScale;
}
else
{
return size;
}
case SerieSymbolSizeType.Callback:
if (sizeCallback != null) return sizeCallback(data);
else return size;
default: return size;
}
}
public float GetSelectedSize(List<float> data)
{
switch (m_SizeType)
{
case SerieSymbolSizeType.Custom:
return selectedSize;
case SerieSymbolSizeType.FromData:
if (dataIndex >= 0 && dataIndex < data.Count)
{
return data[dataIndex] * m_SelectedDataScale;
}
else
{
return selectedSize;
}
case SerieSymbolSizeType.Callback:
if (selectedSizeCallback != null) return selectedSizeCallback(data);
else return selectedSize;
default: return selectedSize;
}
}
}
[System.Serializable] [System.Serializable]
public class Serie : JsonDataSupport public class Serie : JsonDataSupport
{ {
@@ -34,33 +135,34 @@ namespace XCharts
[SerializeField] private string m_Name; [SerializeField] private string m_Name;
[SerializeField] private string m_Stack; [SerializeField] private string m_Stack;
[SerializeField] private int m_AxisIndex; [SerializeField] private int m_AxisIndex;
[SerializeField] private SerieSymbolType m_Symbol = SerieSymbolType.Circle; [SerializeField] private SerieSymbol m_Symbol = new SerieSymbol();
[SerializeField] private float m_SymbolSize = 2.5f;
[SerializeField] private float m_SymbolSelectedSize = 5f; [SerializeField] private int m_ShowDataDimension;
[SerializeField] private bool m_TwoDimensionData; [SerializeField] private bool m_ShowDataName;
[FormerlySerializedAs("m_Data")] [FormerlySerializedAs("m_Data")]
[SerializeField] private List<float> m_YData = new List<float>(); [SerializeField] private List<float> m_YData = new List<float>();
[SerializeField] private List<float> m_XData = new List<float>(); [SerializeField] private List<float> m_XData = new List<float>();
[SerializeField] private List<SerieData> m_Data = new List<SerieData>();
public int index { get; set; } public int index { get; set; }
public int dataCount { get { return m_YData.Count; } } public int dataCount { get { return m_Data.Count; } }
public bool selected { get { return m_Selected; } set { m_Selected = value; } } public bool selected { get { return m_Selected; } set { m_Selected = value; } }
public bool show { get { return m_Show; } set { m_Show = value; } } public bool show { get { return m_Show; } set { m_Show = value; } }
public SerieType type { get { return m_Type; } set { m_Type = value; } } public SerieType type { get { return m_Type; } set { m_Type = value; } }
public string name { get { return m_Name; } set { m_Name = value; } } public string name { get { return m_Name; } set { m_Name = value; } }
public string stack { get { return m_Stack; } set { m_Stack = value; } } public string stack { get { return m_Stack; } set { m_Stack = value; } }
public int axisIndex { get { return m_AxisIndex; } set { m_AxisIndex = value; } } public int axisIndex { get { return m_AxisIndex; } set { m_AxisIndex = value; } }
public SerieSymbolType symbol { get { return m_Symbol; } set { m_Symbol = value; } } public SerieSymbol symbol { get { return m_Symbol; } set { m_Symbol = value; } }
public float symbolSize { get { return m_SymbolSize; } set { m_SymbolSize = value; } } public List<float> yData { get { return m_YData; } }
public float symbolSelectedSize { get { return m_SymbolSelectedSize; } set { m_SymbolSelectedSize = value; } } public List<float> xData { get { return m_XData; } }
public List<float> yData { get { return m_YData; } set { m_YData = value; } } public List<SerieData> data { get { return m_Data; } }
public List<float> xData { get { return m_XData; } set { m_XData = value; } }
public int filterStart { get; set; } public int filterStart { get; set; }
public int filterEnd { get; set; } public int filterEnd { get; set; }
private List<float> yFilterData { get; set; } private List<float> yFilterData { get; set; }
private List<float> xFilterData { get; set; } private List<float> xFilterData { get; set; }
private List<SerieData> filterData { get; set; }
public float yMax public float yMax
{ {
@@ -156,34 +258,41 @@ namespace XCharts
{ {
m_XData.Clear(); m_XData.Clear();
m_YData.Clear(); m_YData.Clear();
m_Data.Clear();
} }
public void RemoveData(int index) public void RemoveData(int index)
{ {
m_XData.RemoveAt(index); m_XData.RemoveAt(index);
m_YData.RemoveAt(index); m_YData.RemoveAt(index);
m_Data.RemoveAt(index);
} }
public void AddYData(float value, int maxDataNumber = 0) public void AddYData(float value, int maxDataNumber = 0, string dataName = null)
{ {
if (maxDataNumber > 0) if (maxDataNumber > 0)
{ {
while (m_XData.Count > maxDataNumber) m_XData.RemoveAt(0); while (m_XData.Count > maxDataNumber) m_XData.RemoveAt(0);
while (m_YData.Count > maxDataNumber) m_YData.RemoveAt(0); while (m_YData.Count > maxDataNumber) m_YData.RemoveAt(0);
while (m_Data.Count > maxDataNumber) m_Data.RemoveAt(0);
} }
m_XData.Add(m_XData.Count); int xValue = m_XData.Count;
m_XData.Add(xValue);
m_YData.Add(value); m_YData.Add(value);
m_Data.Add(new SerieData() { data = new List<float>() { xValue, value }, name = dataName });
} }
public void AddXYData(float xValue, float yValue, int maxDataNumber = 0) public void AddXYData(float xValue, float yValue, int maxDataNumber = 0, string dataName = null)
{ {
if (maxDataNumber > 0) if (maxDataNumber > 0)
{ {
while (m_XData.Count > maxDataNumber) m_XData.RemoveAt(0); while (m_XData.Count > maxDataNumber) m_XData.RemoveAt(0);
while (m_YData.Count > maxDataNumber) m_YData.RemoveAt(0); while (m_YData.Count > maxDataNumber) m_YData.RemoveAt(0);
while (m_Data.Count > maxDataNumber) m_Data.RemoveAt(0);
} }
m_XData.Add(xValue); m_XData.Add(xValue);
m_YData.Add(yValue); m_YData.Add(yValue);
m_Data.Add(new SerieData() { data = new List<float>() { xValue, yValue }, name = dataName });
} }
public float GetYData(int index, DataZoom dataZoom = null) public float GetYData(int index, DataZoom dataZoom = null)
@@ -244,6 +353,25 @@ namespace XCharts
} }
} }
public List<SerieData> GetDataList(DataZoom dataZoom)
{
if (dataZoom != null && dataZoom.show)
{
var startIndex = (int)((m_Data.Count - 1) * dataZoom.start / 100);
var endIndex = (int)((m_Data.Count - 1) * dataZoom.end / 100);
var count = endIndex == startIndex ? 1 : endIndex - startIndex + 1;
if (filterData == null || filterData.Count != count)
{
UpdateFilterData(dataZoom);
}
return filterData;
}
else
{
return m_Data;
}
}
public void UpdateFilterData(DataZoom dataZoom) public void UpdateFilterData(DataZoom dataZoom)
{ {
if (dataZoom != null && dataZoom.show) if (dataZoom != null && dataZoom.show)
@@ -254,9 +382,9 @@ namespace XCharts
{ {
filterStart = startIndex; filterStart = startIndex;
filterEnd = endIndex; filterEnd = endIndex;
var count = endIndex == startIndex ? 1 : endIndex - startIndex + 1;
if (m_YData.Count > 0) if (m_YData.Count > 0)
{ {
var count = endIndex == startIndex ? 1 : endIndex - startIndex + 1;
yFilterData = m_YData.GetRange(startIndex, count); yFilterData = m_YData.GetRange(startIndex, count);
} }
else else
@@ -265,18 +393,26 @@ namespace XCharts
} }
if (m_XData.Count > 0) if (m_XData.Count > 0)
{ {
var count = endIndex == startIndex ? 1 : endIndex - startIndex + 1;
xFilterData = m_XData.GetRange(startIndex, count); xFilterData = m_XData.GetRange(startIndex, count);
} }
else else
{ {
xFilterData = m_XData; xFilterData = m_XData;
} }
if (m_Data.Count > 0)
{
filterData = m_Data.GetRange(startIndex, count);
}
else
{
filterData = m_Data;
}
} }
else if (endIndex == 0) else if (endIndex == 0)
{ {
yFilterData = new List<float>(); yFilterData = new List<float>();
xFilterData = new List<float>(); xFilterData = new List<float>();
filterData = new List<SerieData>();
} }
} }
} }
@@ -304,7 +440,53 @@ namespace XCharts
public override void ParseJsonData(string jsonData) public override void ParseJsonData(string jsonData)
{ {
if (string.IsNullOrEmpty(jsonData) || !m_DataFromJson) return; if (string.IsNullOrEmpty(jsonData) || !m_DataFromJson) return;
m_YData = ChartHelper.ParseFloatFromString(jsonData); ClearData();
jsonData = jsonData.Replace("\r\n", "");
jsonData = jsonData.Replace(" ", "");
jsonData = jsonData.Replace("\n", "");
int startIndex = jsonData.IndexOf("[");
int endIndex = jsonData.LastIndexOf("]");
string temp = jsonData.Substring(startIndex + 1, endIndex - startIndex - 1);
if (temp.IndexOf("],") > -1 || temp.IndexOf("] ,") > -1)
{
string[] datas = temp.Split(new string[] { "],", "] ," }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < datas.Length; i++)
{
var data = datas[i].Split(new char[] { '[', ',' }, StringSplitOptions.RemoveEmptyEntries);
var serieData = new SerieData();
for (int j = 0; j < data.Length; j++)
{
var txt = data[j].Trim().Replace("]", "");
float value;
var flag = float.TryParse(txt, out value);
if (flag)
{
serieData.data.Add(value);
if (j == 0) m_XData.Add(value);
else if (j == 1) m_YData.Add(value);
}
else serieData.name = txt.Replace("\"", "").Trim();
}
m_Data.Add(serieData);
}
}
else
{
string[] datas = temp.Split(',');
for (int i = 0; i < datas.Length; i++)
{
float value;
var flag = float.TryParse(datas[i].Trim(), out value);
if (flag)
{
var serieData = new SerieData();
serieData.data.Add(value);
m_Data.Add(serieData);
m_XData.Add(value);
}
}
}
} }
} }
} }

24
Scripts/UI/Internal/Series.cs
View File

@@ -124,23 +124,22 @@ namespace XCharts
serie.show = show; serie.show = show;
serie.name = serieName; serie.name = serieName;
serie.index = m_Series.Count; serie.index = m_Series.Count;
serie.yData = new List<float>();
if (type == SerieType.Scatter) if (type == SerieType.Scatter)
{ {
serie.symbol = SerieSymbolType.Circle; serie.symbol.type = SerieSymbolType.Circle;
serie.symbolSize = 20f; serie.symbol.size = 20f;
serie.symbolSelectedSize = 30f; serie.symbol.selectedSize = 30f;
} }
else if (type == SerieType.Line) else if (type == SerieType.Line)
{ {
serie.symbol = SerieSymbolType.EmptyCircle; serie.symbol.type = SerieSymbolType.EmptyCircle;
serie.symbolSize = 2.5f; serie.symbol.size = 2.5f;
serie.symbolSelectedSize = 5f; serie.symbol.selectedSize = 5f;
} }
else else
{ {
serie.symbol = SerieSymbolType.None; serie.symbol.type = SerieSymbolType.None;
} }
m_Series.Add(serie); m_Series.Add(serie);
} }
@@ -463,6 +462,15 @@ namespace XCharts
return list; return list;
} }
public void SetSerieSymbolSizeCallback(SymbolSizeCallback size, SymbolSizeCallback selectedSize)
{
foreach (var serie in m_Series)
{
serie.symbol.sizeCallback = size;
serie.symbol.selectedSizeCallback = selectedSize;
}
}
public override void ParseJsonData(string jsonData) public override void ParseJsonData(string jsonData)
{ {
//TODO: //TODO:

17
Scripts/UI/LineChart.cs
View File

@@ -121,24 +121,25 @@ namespace XCharts
for (int i = 0; i < points.Count; i++) for (int i = 0; i < points.Count; i++)
{ {
Vector3 p = points[i]; Vector3 p = points[i];
var dataIndex = i % dataCount;
var serie = m_Series.GetSerie(pointSerieIndex[i]); var serie = m_Series.GetSerie(pointSerieIndex[i]);
float symbolSize = serie.symbolSize; float symbolSize = serie.symbol.size;
if (m_Tooltip.show && m_Tooltip.IsSelectedDataIndex(i % dataCount)) if (m_Tooltip.show && m_Tooltip.IsSelectedDataIndex(dataIndex))
{ {
if (IsCartesian()) if (IsCartesian())
{ {
if (m_Series.IsTooltipSelected(i / dataCount)) if (m_Series.IsTooltipSelected(serie.index))
{ {
symbolSize = serie.symbolSelectedSize; symbolSize = serie.symbol.selectedSize;
} }
} }
else else
{ {
symbolSize = serie.symbolSelectedSize; symbolSize = serie.symbol.selectedSize;
} }
} }
var color = m_ThemeInfo.GetColor(serie.index); var color = m_ThemeInfo.GetColor(serie.index);
DrawSymbol(vh, serie.symbol, symbolSize, m_Line.tickness, p, color); DrawSymbol(vh, serie.symbol.type, symbolSize, m_Line.tickness, p, color);
} }
} }
@@ -328,7 +329,7 @@ namespace XCharts
} }
} }
} }
if (serie.symbol != SerieSymbolType.None || m_Line.area) if (serie.symbol.type != SerieSymbolType.None || m_Line.area)
{ {
points.Add(np); points.Add(np);
pointSerieIndexs.Add(serie.index); pointSerieIndexs.Add(serie.index);
@@ -506,7 +507,7 @@ namespace XCharts
} }
} }
} }
if (serie.symbol != SerieSymbolType.None || m_Line.area) if (serie.symbol.type != SerieSymbolType.None || m_Line.area)
{ {
points.Add(np); points.Add(np);
pointSerieIndexs.Add(serie.index); pointSerieIndexs.Add(serie.index);