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

[code] refactor the code

Browse Source
This commit is contained in:
monitor1394
2022-07-03 21:09:49 +08:00
parent 33fd4aa9f3
commit 197402dcb7
12 changed files with 60 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
Runtime/Component/Axis/AxisLabel.cs
View File

@@ -145,22 +145,18 @@ namespace XCharts.Runtime
public string GetFormatterContent(int labelIndex, string category)
{
if (m_FormatterFunction != null)
{
return m_FormatterFunction(labelIndex, 0, category);
}
if (string.IsNullOrEmpty(category))
return category;
return GetFormatterFunctionContent(labelIndex, category, category);
if (string.IsNullOrEmpty(m_Formatter))
{
return m_TextLimit.GetLimitContent(category);
return GetFormatterFunctionContent(labelIndex, category, m_TextLimit.GetLimitContent(category));
}
else
{
var content = m_Formatter;
FormatterHelper.ReplaceAxisLabelContent(ref content, category);
return m_TextLimit.GetLimitContent(content);
return GetFormatterFunctionContent(labelIndex, category, m_TextLimit.GetLimitContent(content));
}
}
@@ -170,15 +166,11 @@ namespace XCharts.Runtime
{
value = Math.Abs(value);
}
if (m_FormatterFunction != null)
{
return m_FormatterFunction(labelIndex, value, null);
}
if (string.IsNullOrEmpty(m_Formatter))
{
if (isLog)
{
return ChartCached.NumberToStr(value, numericFormatter);
return GetFormatterFunctionContent(labelIndex, value, ChartCached.NumberToStr(value, numericFormatter));
}
if (minValue >= -1 && minValue <= 1 && maxValue >= -1 && maxValue <= 1)
{
@@ -186,24 +178,20 @@ namespace XCharts.Runtime
int maxAcc = ChartHelper.GetFloatAccuracy(maxValue);
int curAcc = ChartHelper.GetFloatAccuracy(value);
int acc = Mathf.Max(Mathf.Max(minAcc, maxAcc), curAcc);
return ChartCached.FloatToStr(value, numericFormatter, acc);
return GetFormatterFunctionContent(labelIndex, value, ChartCached.FloatToStr(value, numericFormatter, acc));
}
return ChartCached.NumberToStr(value, numericFormatter);
return GetFormatterFunctionContent(labelIndex, value, ChartCached.NumberToStr(value, numericFormatter));
}
else
{
var content = m_Formatter;
FormatterHelper.ReplaceAxisLabelContent(ref content, numericFormatter, value);
return content;
return GetFormatterFunctionContent(labelIndex, value, content);
}
}
public string GetFormatterDateTime(int labelIndex, double value, double minValue, double maxValue)
{
if (m_FormatterFunction != null)
{
return m_FormatterFunction(labelIndex, value, null);
}
var timestamp = (int) value;
var dateTime = DateTimeUtil.GetDateTime(timestamp);
var dateString = string.Empty;
@@ -219,12 +207,24 @@ namespace XCharts.Runtime
{
var content = m_Formatter;
FormatterHelper.ReplaceAxisLabelContent(ref content, dateString);
return m_TextLimit.GetLimitContent(content);
return GetFormatterFunctionContent(labelIndex, value, m_TextLimit.GetLimitContent(content));
}
else
{
return m_TextLimit.GetLimitContent(dateString);
return GetFormatterFunctionContent(labelIndex, value, m_TextLimit.GetLimitContent(dateString));
}
}
private string GetFormatterFunctionContent(int labelIndex, string category, string currentContent)
{
return m_FormatterFunction == null ? currentContent :
m_FormatterFunction(labelIndex, labelIndex, category, currentContent);
}
private string GetFormatterFunctionContent(int labelIndex, double value, string currentContent)
{
return m_FormatterFunction == null ? currentContent :
m_FormatterFunction(labelIndex, labelIndex, null, currentContent);
}
}
}

231
Runtime/Component/Label/SerieLabelHelper.cs Normal file
View File

@@ -0,0 +1,231 @@
using System.Collections.Generic;
using UnityEngine;
namespace XCharts.Runtime
{
public static class SerieLabelHelper
{
public static Color GetLabelColor(Serie serie, ThemeStyle theme, int index)
{
if (serie.label != null && !ChartHelper.IsClearColor(serie.label.textStyle.color))
{
return serie.label.textStyle.color;
}
else
{
return theme.GetColor(index);
}
}
public static bool CanShowLabel(Serie serie, SerieData serieData, LabelStyle label, int dimesion)
{
return serie.show && serieData.context.canShowLabel && !serie.IsIgnoreValue(serieData, dimesion);
}
public static string GetFormatterContent(Serie serie, SerieData serieData,
double dataValue, double dataTotal, LabelStyle serieLabel, Color color)
{
if (serieLabel == null)
{
serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
}
var numericFormatter = serieLabel == null ? "" : serieLabel.numericFormatter;
var serieName = serie.serieName;
var dataName = serieData != null ? serieData.name : null;
if (string.IsNullOrEmpty(serieLabel.formatter))
{
var currentContent = ChartCached.NumberToStr(dataValue, numericFormatter);
if (serieLabel.formatterFunction == null)
return currentContent;
else
return serieLabel.formatterFunction(serieData.index, dataValue, null, currentContent);
}
else
{
var content = serieLabel.formatter;
FormatterHelper.ReplaceSerieLabelContent(ref content, numericFormatter, serie.dataCount, dataValue,
dataTotal, serieName, dataName, dataName, color, serieData);
if (serieLabel.formatterFunction == null)
return content;
else
return serieLabel.formatterFunction(serieData.index, dataValue, null, content);
}
}
public static void SetGaugeLabelText(Serie serie)
{
var serieData = serie.GetSerieData(0);
if (serieData == null) return;
if (serieData.labelObject == null) return;
var label = SerieHelper.GetSerieLabel(serie, serieData);
if (label == null) return;
var value = serieData.GetData(1);
var total = serie.max;
var content = SerieLabelHelper.GetFormatterContent(serie, serieData, value, total, null, Color.clear);
serieData.labelObject.SetText(content);
serieData.labelObject.SetPosition(serie.context.center + label.offset);
if (!ChartHelper.IsClearColor(label.textStyle.color))
{
serieData.labelObject.text.SetColor(label.textStyle.color);
}
}
public static void UpdatePieLabelPosition(Serie serie, SerieData serieData)
{
if (serieData.labelObject == null) return;
var startAngle = serie.context.startAngle;
var currAngle = serieData.context.halfAngle;
var currRad = currAngle * Mathf.Deg2Rad;
var offsetRadius = serieData.context.offsetRadius;
var insideRadius = serieData.context.insideRadius;
var outsideRadius = serieData.context.outsideRadius;
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
var labelLine = SerieHelper.GetSerieLabelLine(serie, serieData);
switch (serieLabel.position)
{
case LabelStyle.Position.Center:
serieData.context.labelPosition = serie.context.center;
break;
case LabelStyle.Position.Inside:
var labelRadius = offsetRadius + insideRadius + (outsideRadius - insideRadius) / 2 + serieLabel.distance;
var labelCenter = new Vector2(serie.context.center.x + labelRadius * Mathf.Sin(currRad),
serie.context.center.y + labelRadius * Mathf.Cos(currRad));
serieData.context.labelPosition = labelCenter;
break;
default:
//LabelStyle.Position.Outside
if (labelLine != null && labelLine.lineType == LabelLine.LineType.HorizontalLine)
{
var radius1 = serie.context.outsideRadius;
var radius3 = insideRadius + (outsideRadius - insideRadius) / 2;
var currSin = Mathf.Sin(currRad);
var currCos = Mathf.Cos(currRad);
var pos0 = new Vector3(serie.context.center.x + radius3 * currSin, serie.context.center.y + radius3 * currCos);
if ((currAngle - startAngle) % 360 > 180)
{
currSin = Mathf.Sin((360 - currAngle) * Mathf.Deg2Rad);
currCos = Mathf.Cos((360 - currAngle) * Mathf.Deg2Rad);
}
var r4 = Mathf.Sqrt(radius1 * radius1 - Mathf.Pow(currCos * radius3, 2)) - currSin * radius3;
r4 += labelLine.lineLength1 + labelLine.lineWidth * 4;
r4 += serieData.labelObject.text.GetPreferredWidth() / 2;
serieData.context.labelPosition = pos0 + ((currAngle - startAngle) % 360 > 180 ? Vector3.left : Vector3.right) * r4;
}
else
{
labelRadius = serie.context.outsideRadius + (labelLine == null ? 0 : labelLine.lineLength1);
labelCenter = new Vector2(serie.context.center.x + labelRadius * Mathf.Sin(currRad),
serie.context.center.y + labelRadius * Mathf.Cos(currRad));
serieData.context.labelPosition = labelCenter;
}
break;
}
}
public static void AvoidLabelOverlap(Serie serie, ComponentTheme theme)
{
if (!serie.avoidLabelOverlap) return;
var lastCheckPos = Vector3.zero;
var lastX = 0f;
var data = serie.data;
var splitCount = 0;
for (int n = 0; n < data.Count; n++)
{
var serieData = data[n];
if (serieData.context.labelPosition.x != 0 && serieData.context.labelPosition.x < serie.context.center.x)
{
splitCount = n;
break;
}
}
for (int n = 0; n < splitCount; n++)
{
CheckSerieDataLabel(serie, data[n], splitCount, false, theme, ref lastCheckPos, ref lastX);
}
lastCheckPos = Vector3.zero;
for (int n = data.Count - 1; n >= splitCount; n--)
{
CheckSerieDataLabel(serie, data[n], data.Count - splitCount, true, theme, ref lastCheckPos, ref lastX);
}
}
private static void CheckSerieDataLabel(Serie serie, SerieData serieData, int total, bool isLeft, ComponentTheme theme,
ref Vector3 lastCheckPos, ref float lastX)
{
if (!serieData.context.canShowLabel)
{
serieData.SetLabelActive(false);
return;
}
if (!serieData.show) return;
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData);
var isOutside = serieLabel.position == LabelStyle.Position.Outside ||
serieLabel.position == LabelStyle.Position.Default;
if (!serieLabel.show) return;
if (!isOutside) return;
var labelLine = SerieHelper.GetSerieLabelLine(serie, serieData);
var fontSize = serieData.labelObject.GetHeight();
if (lastCheckPos == Vector3.zero)
{
lastCheckPos = serieData.context.labelPosition;
}
else if (serieData.context.labelPosition.x != 0)
{
if (lastCheckPos.y - serieData.context.labelPosition.y < fontSize)
{
var labelRadius = serie.context.outsideRadius + labelLine.lineLength1;
var y1 = lastCheckPos.y - fontSize;
var cy = serie.context.center.y;
var diff = Mathf.Abs(y1 - cy);
var diffX = labelRadius * labelRadius - diff * diff;
diffX = diffX <= 0 ? 0 : diffX;
var x1 = serie.context.center.x + Mathf.Sqrt(diffX) * (isLeft ? -1 : 1);
var newPos = new Vector3(x1, y1);
serieData.context.labelPosition = newPos;
var angle = ChartHelper.GetAngle360(Vector2.up, newPos - serie.context.center);
if (angle >= 180 && angle <= 270)
{
serieData.context.labelPosition = new Vector3(isLeft?(++lastX): (--lastX), y1);
}
else if (angle < 180 && angle >= 90)
{
serieData.context.labelPosition = new Vector3(isLeft?(++lastX): (--lastX), y1);
}
else
{
lastX = x1;
}
}
else
{
lastX = serieData.context.labelPosition.x;
}
lastCheckPos = serieData.context.labelPosition;
serieData.labelObject.SetPosition(SerieLabelHelper.GetRealLabelPosition(serie, serieData, serieLabel, labelLine));
}
}
public static Vector3 GetRealLabelPosition(Serie serie, SerieData serieData, LabelStyle label, LabelLine labelLine)
{
if (label == null || labelLine == null)
return serieData.context.labelPosition;
var isOutside = label.position == LabelStyle.Position.Outside ||
label.position == LabelStyle.Position.Default;
if (isOutside && labelLine.lineType != LabelLine.LineType.HorizontalLine)
{
var currAngle = serieData.context.halfAngle;
var offset = labelLine.lineLength2 + serieData.labelObject.GetTextWidth() / 2;
if ((currAngle - serie.context.startAngle) % 360 > 180)
return serieData.context.labelPosition + new Vector3(-offset, 0, 0);
else
return serieData.context.labelPosition + new Vector3(offset, 0, 0);
}
else
{
return serieData.context.labelPosition;
}
}
}
}

11
Runtime/Component/Label/SerieLabelHelper.cs.meta Normal file
View File

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

13
Runtime/Component/Mark/MarkLineHelper.cs
View File

@@ -8,18 +8,19 @@ namespace XCharts.Runtime
{
var serieLabel = data.label;
var numericFormatter = serieLabel.numericFormatter;
if (serieLabel.formatterFunction != null)
{
return serieLabel.formatterFunction(data.index, data.runtimeValue, null);
}
if (string.IsNullOrEmpty(serieLabel.formatter))
return ChartCached.NumberToStr(data.runtimeValue, numericFormatter);
{
var content = ChartCached.NumberToStr(data.runtimeValue, numericFormatter);
return serieLabel.formatterFunction == null? content:
serieLabel.formatterFunction(data.index, data.runtimeValue, null, content);
}
else
{
var content = serieLabel.formatter;
FormatterHelper.ReplaceSerieLabelContent(ref content, numericFormatter, serie.dataCount, data.runtimeValue,
0, serie.serieName, data.name, data.name, Color.clear, null);
return content;
return serieLabel.formatterFunction == null? content:
serieLabel.formatterFunction(data.index, data.runtimeValue, null, content);
}
}