private static void InitGaugeTooltip(ref StringBuilder sb, Tooltip tooltip, Serie serie, int index,
ChartTheme theme)
{
if (tooltip.runtimeGridIndex >= 0)
{
return;
}
if (serie.index != index || serie.type != SerieType.Gauge)
{
return;
}
var serieData = serie.GetSerieData(0);
var numericFormatter = GetItemNumericFormatter(tooltip, serie, serieData);
float value = serieData.data[1];
sb.Length = 0;
if (!string.IsNullOrEmpty(serie.name))
{
sb.Append(serie.name).Append("\n");
}
if (!string.IsNullOrEmpty(serieData.name))
{
//sb.Append("<color=#").Append(theme.GetColorStr(index)).Append(">● </color>")
sb.Append(serieData.name).Append(": ").Append(ChartCached.FloatToStr(value, numericFormatter));
}
else
{
sb.Append(ChartCached.FloatToStr(value, numericFormatter));
}
}
public static GameObject Get(string name, Transform parent, SerieLabel label, Color color,
float iconWidth, float iconHeight, ChartTheme theme)
{
GameObject element;
if (m_Stack.Count == 0 || !Application.isPlaying)
{
element = CreateSerieLabel(name, parent, label, color, iconWidth, iconHeight, theme);
}
else
{
element = m_Stack.Pop();
if (element == null)
{
element = CreateSerieLabel(name, parent, label, color, iconWidth, iconHeight, theme);
}
m_ReleaseDic.Remove(element.GetInstanceID());
element.name = name;
element.transform.SetParent(parent);
element.transform.localEulerAngles = new Vector3(0, 0, label.textStyle.rotate);
var text = new ChartText(element);
text.SetColor(color);
text.SetFontAndSizeAndStyle(label.textStyle, theme.common);
ChartHelper.SetActive(element, true);
}
return(element);
}
private static TMP_FontAsset GetCustomThemeTMPFont(ChartTheme theme)
{
TMP_FontAsset font = null;
#if UNITY_EDITOR
if (!string.IsNullOrEmpty(theme.tmpFontName))
{
//TODO: how to find TMP_FontAsset asset
var guids = AssetDatabase.FindAssets("t:Texture");
foreach (var guid in guids)
{
var assetPath = AssetDatabase.GUIDToAssetPath(guid);
if (!assetPath.EndsWith(".asset"))
{
continue;
}
var tempFont = AssetDatabase.LoadAssetAtPath <TMP_FontAsset>(assetPath);
if (tempFont && tempFont.name.Equals(theme.tmpFontName))
{
font = tempFont;
break;
}
}
}
#else
font = FindObjectByInstanceId(theme.fontInstanceId) as TMP_FontAsset;
#endif
return(font);
}
private static void InitScatterTooltip(ref StringBuilder sb, Tooltip tooltip, Serie serie, int index,
ChartTheme theme)
{
if (!tooltip.runtimeSerieIndex.ContainsKey(serie.index))
{
return;
}
var dataIndexList = tooltip.runtimeSerieIndex[serie.index];
if (!string.IsNullOrEmpty(serie.name))
{
sb.Append(serie.name).Append(FormatterHelper.PH_NN);
}
for (int i = 0; i < dataIndexList.Count; i++)
{
var dataIndex = dataIndexList[i];
var serieData = serie.GetSerieData(dataIndex);
var numericFormatter = GetItemNumericFormatter(tooltip, serie, serieData);
float xValue, yValue;
serie.GetXYData(dataIndex, null, out xValue, out yValue);
sb.Append("<color=#").Append(theme.GetColorStr(serie.index)).Append(">● </color>");
if (!string.IsNullOrEmpty(serieData.name))
{
sb.Append(serieData.name).Append(": ");
}
sb.AppendFormat("({0},{1})", ChartCached.FloatToStr(xValue, numericFormatter),
ChartCached.FloatToStr(yValue, numericFormatter));
if (i != dataIndexList.Count - 1)
{
sb.Append("\n");
}
}
}
internal static Color32 GetItemColor0(Serie serie, SerieData serieData, ChartTheme theme, bool highlight, Color32 defaultColor)
{
if (serie == null)
{
return(ChartConst.clearColor32);
}
if (highlight)
{
var itemStyleEmphasis = GetItemStyleEmphasis(serie, serieData);
if (itemStyleEmphasis != null && !ChartHelper.IsClearColor(itemStyleEmphasis.color))
{
var color = itemStyleEmphasis.color0;
ChartHelper.SetColorOpacity(ref color, itemStyleEmphasis.opacity);
return(color);
}
}
var itemStyle = GetItemStyle(serie, serieData);
if (!ChartHelper.IsClearColor(itemStyle.color0))
{
return(itemStyle.GetColor0());
}
else
{
var color = defaultColor;
if (highlight)
{
color = ChartHelper.GetHighlightColor(color);
}
ChartHelper.SetColorOpacity(ref color, itemStyle.opacity);
return(color);
}
}
/// <summary>
/// copy all configurations from theme.
/// 复制主题的所有配置。
/// </summary>
/// <param name="theme"></param>
public void CopyTheme(ChartTheme theme)
{
m_Theme = theme.theme;
m_ThemeName = theme.themeName;
#if dUI_TextMeshPro
m_TMPFont = theme.tmpFont;
#endif
m_Font = theme.m_Font;
m_ContrastColor = theme.contrastColor;
m_BackgroundColor = theme.m_BackgroundColor;
m_Common.Copy(theme.common);
m_Legend.Copy(theme.m_Legend);
m_Title.Copy(theme.m_Title);
m_SubTitle.Copy(theme.m_SubTitle);
m_Axis.Copy(theme.axis);
m_RadiusAxis.Copy(theme.radiusAxis);
m_AngleAxis.Copy(theme.angleAxis);
m_Polar.Copy(theme.polar);
m_Gauge.Copy(theme.gauge);
m_Tooltip.Copy(theme.tooltip);
m_DataZoom.Copy(theme.dataZoom);
m_VisualMap.Copy(theme.visualMap);
m_Serie.Copy(theme.serie);
ChartHelper.CopyList(m_ColorPalette, theme.colorPalette);
SetAllDirty();
}
internal static Color32 GetAreaToColor(Serie serie, ChartTheme theme, int index, bool highlight)
{
var areaStyle = serie.areaStyle;
if (!ChartHelper.IsClearColor(areaStyle.toColor))
{
var color = areaStyle.toColor;
if (highlight)
{
if (!ChartHelper.IsClearColor(areaStyle.highlightToColor))
{
color = areaStyle.highlightToColor;
}
else
{
color = ChartHelper.GetHighlightColor(color);
}
}
ChartHelper.SetColorOpacity(ref color, areaStyle.opacity);
return(color);
}
else
{
return(GetAreaColor(serie, theme, index, highlight));
}
}
private static Font GetCustomThemeFont(ChartTheme theme)
{
Font font = null;
#if UNITY_EDITOR
if (string.IsNullOrEmpty(theme.fontName))
{
return(null);
}
if (theme.fontName.Equals("Arial"))
{
return(Resources.GetBuiltinResource <Font>("Arial.ttf"));
}
var guids = AssetDatabase.FindAssets("t:Font");
foreach (var guid in guids)
{
var assetPath = AssetDatabase.GUIDToAssetPath(guid);
var tempFont = AssetDatabase.LoadAssetAtPath <Font>(assetPath);
if (tempFont.name.Equals(theme.fontName))
{
font = tempFont;
break;
}
}
#else
font = FindObjectByInstanceId(theme.fontInstanceId) as Font;
#endif
return(font);
}
internal static Color32 GetLineColor(Serie serie, ChartTheme theme, int index, bool highlight)
{
Color32 color = ChartConst.clearColor32;
if (highlight)
{
var itemStyleEmphasis = GetItemStyleEmphasis(serie, null);
if (itemStyleEmphasis != null && !ChartHelper.IsClearColor(itemStyleEmphasis.color))
{
color = itemStyleEmphasis.color;
ChartHelper.SetColorOpacity(ref color, itemStyleEmphasis.opacity);
return(color);
}
}
if (!ChartHelper.IsClearColor(serie.lineStyle.color))
{
color = serie.lineStyle.GetColor();
}
else if (!ChartHelper.IsClearColor(serie.itemStyle.color))
{
color = serie.itemStyle.GetColor();
}
if (ChartHelper.IsClearColor(color))
{
color = theme.GetColor(index);
ChartHelper.SetColorOpacity(ref color, serie.lineStyle.opacity);
}
if (highlight)
{
color = ChartHelper.GetHighlightColor(color);
}
return(color);
}
private static void InitGanttTooltip(ref StringBuilder sb, Tooltip tooltip, Serie serie, int index,
ChartTheme theme)
{
//if (tooltip.runtimeGridIndex >= 0) return;
//if (serie.index != index || serie.type != SerieType.Gantt) return;
sb.Append(serie.name);
}
private static void InitCoordinateTooltip(ref StringBuilder sb, Tooltip tooltip, Serie serie, int index,
ChartTheme theme, bool isCartesian, DataZoom dataZoom = null)
{
string key = serie.name;
float xValue, yValue;
serie.GetXYData(index, dataZoom, out xValue, out yValue);
var isIngore = serie.IsIgnorePoint(index);
var serieData = serie.GetSerieData(index, dataZoom);
var numericFormatter = GetItemNumericFormatter(tooltip, serie, serieData);
if (isCartesian)
{
if (serieData != null && serieData.highlighted)
{
sb.Append(key).Append(!string.IsNullOrEmpty(key) ? " : " : "");
sb.Append("[").Append(ChartCached.FloatToStr(xValue, numericFormatter)).Append(",")
.Append(ChartCached.FloatToStr(yValue, numericFormatter)).Append("]");
}
}
else
{
var valueTxt = isIngore ? tooltip.ignoreDataDefaultContent :
ChartCached.FloatToStr(yValue, numericFormatter);
sb.Append("<color=#").Append(theme.GetColorStr(serie.index)).Append(">● </color>")
.Append(key).Append(!string.IsNullOrEmpty(key) ? " : " : "")
.Append(valueTxt);
}
}
private static void InitPieTooltip(ref StringBuilder sb, Tooltip tooltip, Serie serie, int index,
ChartTheme theme)
{
if (tooltip.runtimeDataIndex[serie.index] < 0)
{
return;
}
string key = serie.data[index].name;
var serieData = serie.GetSerieData(index);
var numericFormatter = GetItemNumericFormatter(tooltip, serie, serieData);
float value = serieData.GetData(1);
sb.Length = 0;
if (!string.IsNullOrEmpty(serie.name))
{
sb.Append(serie.name).Append(FormatterHelper.PH_NN);
}
sb.Append("<color=#").Append(theme.GetColorStr(index)).Append(">● </color>");
if (!string.IsNullOrEmpty(key))
{
sb.Append(key).Append(": ");
}
sb.Append(ChartCached.FloatToStr(value, numericFormatter));
}
public static void SetLiquidLabelText(Serie serie, ChartTheme theme, int colorIndex)
{
var serieData = serie.GetSerieData(0);
if (serieData == null)
{
return;
}
var serieLabel = SerieHelper.GetSerieLabel(serie, serieData, serieData.highlighted);
if (serieLabel.show && serieData.labelObject != null)
{
if (!serie.show || !serieData.show)
{
serieData.SetLabelActive(false);
return;
}
var value = serieData.GetData(1);
var total = serie.max - serie.min;
var content = SerieLabelHelper.GetFormatterContent(serie, serieData, value, total);
serieData.SetLabelActive(true);
serieData.labelObject.SetText(content);
serieData.labelObject.SetLabelColor(GetLabelColor(serie, theme, colorIndex));
serieData.labelObject.SetLabelPosition(serieData.labelPosition + serieLabel.offset);
}
}
protected virtual void CheckTheme()
{
if (m_Theme == null)
{
m_Theme = ChartTheme.Default;
}
else
{
if (m_Theme.font == null)
{
m_Theme.font = XChartsSettings.font;
}
if (m_Theme.colorPalette.Count == 0)
{
m_Theme.ResetTheme();
}
if (m_CheckTheme != m_Theme.theme)
{
m_CheckTheme = m_Theme.theme;
m_Theme.CopyTheme(m_CheckTheme);
SetAllComponentDirty();
OnThemeChanged();
}
}
}
internal Color32 GetAxisLineColor(ChartTheme theme, int index)
{
var color = !ChartHelper.IsClearColor(axisLine.barColor) ? axisLine.barColor : theme.GetColor(index);
ChartHelper.SetColorOpacity(ref color, axisLine.lineStyle.opacity);
return(color);
}
public static void UpdateLabelText(Series series, ChartTheme theme, List <string> legendRealShowName)
{
foreach (var serie in series.list)
{
if (!serie.label.show)
{
continue;
}
var colorIndex = legendRealShowName.IndexOf(serie.name);
switch (serie.type)
{
case SerieType.Gauge:
SetGaugeLabelText(serie);
break;
case SerieType.Ring:
SetRingLabelText(serie, theme);
break;
case SerieType.Liquid:
SetLiquidLabelText(serie, theme, colorIndex);
break;
}
}
}
internal static GameObject AddTooltipLabel(string name, Transform parent, ChartTheme theme, Vector2 pivot)
{
var anchorMax = new Vector2(0, 0);
var anchorMin = new Vector2(0, 0);
var sizeDelta = new Vector2(100, 50);
return(AddTooltipLabel(name, parent, theme, pivot, anchorMin, anchorMax, sizeDelta));
}
/// <summary>
/// 克隆主题。
/// </summary>
/// <returns></returns>
public ChartTheme CloneTheme()
{
var theme = new ChartTheme();
InitChartComponentTheme(theme);
theme.CopyTheme(this);
return(theme);
}
internal Color32 GetAxisLineBackgroundColor(ChartTheme theme, int index)
{
var color = !ChartHelper.IsClearColor(axisLine.barBackgroundColor)
? axisLine.barBackgroundColor : ChartConst.greyColor32;
ChartHelper.SetColorOpacity(ref color, axisLine.lineStyle.opacity);
return(color);
}
/// <summary>
/// Update chart theme info.
/// 切换图表主题。
/// </summary>
/// <param name="theme">theme</param>
public void UpdateTheme(ChartTheme theme)
{
m_Theme.CopyTheme(theme);
SetAllComponentDirty();
#if UNITY_EDITOR
UnityEditor.EditorUtility.SetDirty(this);
#endif
}
public static void ResetLabel(ChartText labelObject, SerieLabel label, ChartTheme theme, int colorIndex)
{
if (labelObject == null)
{
return;
}
labelObject.SetColor(!ChartHelper.IsClearColor(label.textStyle.color) ? label.textStyle.color :
(Color)theme.GetColor(colorIndex));
labelObject.SetFontSize(label.textStyle.GetFontSize(theme.common));
labelObject.SetFontStyle(label.textStyle.fontStyle);
}
public static Color GetLabelColor(Serie serie, ChartTheme theme, int index)
{
if (!ChartHelper.IsClearColor(serie.label.textStyle.color))
{
return(serie.label.textStyle.color);
}
else
{
return(theme.GetColor(index));
}
}
public static Color32 GetBackgroundColor(ChartTheme theme, Background background)
{
if (background.show && background.hideThemeBackgroundColor)
{
return(ChartConst.clearColor32);
}
else
{
return(theme.backgroundColor);
}
}
public static void AddTheme(ChartTheme theme)
{
if (theme == null)
{
return;
}
if (!XChartsMgr.Instance.m_ThemeDict.ContainsKey(theme.themeName))
{
XChartsMgr.Instance.m_ThemeDict.Add(theme.themeName, theme);
XChartsMgr.Instance.m_ThemeNames.Add(theme.themeName);
}
}
private void AddTheme(ChartTheme theme)
{
if (!m_ThemeDict.ContainsKey(theme.themeName))
{
m_ThemeDict.Add(theme.themeName, theme);
m_ThemeNames.Add(theme.themeName);
}
else
{
Debug.LogError("Theme name is exist:" + theme.themeName);
}
}
public static Color32 GetColor(Vessel vessel, Serie serie, ChartTheme theme, List <string> legendRealShowName)
{
if (serie != null && vessel.autoColor)
{
var colorIndex = legendRealShowName.IndexOf(serie.name);
return(SerieHelper.GetItemColor(serie, null, theme, colorIndex, false));
}
else
{
return(vessel.color);
}
}
public static Color GetContentColor(Legend legend, ChartTheme theme, bool active)
{
var textStyle = legend.textStyle;
if (active)
{
return(!ChartHelper.IsClearColor(textStyle.color) ? textStyle.color : theme.legend.textColor);
}
else
{
return(theme.legend.unableColor);
}
}
internal static float GetSymbolBorder(Serie serie, SerieData serieData, ChartTheme theme, bool highlight, bool useLineWidth = true)
{
var itemStyle = GetItemStyle(serie, serieData, highlight);
if (itemStyle != null && itemStyle.borderWidth != 0)
{
return(itemStyle.borderWidth);
}
else
{
return(serie.lineStyle.GetWidth(theme.serie.lineWidth));
}
}
public static void InitCoordinateTooltip(ref StringBuilder sb, Tooltip tooltip, Serie serie, int index,
ChartTheme theme, bool isCartesian, DataZoom dataZoom = null)
{
string key = serie.name;
double xValue, yValue;
serie.GetXYData(index, dataZoom, out xValue, out yValue);
var isIngore = serie.IsIgnorePoint(index);
if (isIngore)
{
return;
}
var serieData = serie.GetSerieData(index, dataZoom);
var numericFormatter = GetItemNumericFormatter(tooltip, serie, serieData);
if (isCartesian)
{
if (serieData != null && serieData.highlighted)
{
sb.Append(key).Append(!string.IsNullOrEmpty(key) ? " : " : "");
sb.Append("[").Append(ChartCached.FloatToStr(xValue, numericFormatter)).Append(",")
.Append(ChartCached.FloatToStr(yValue, numericFormatter)).Append("]");
}
}
else if (!isIngore || (isIngore && tooltip.ignoreDataShow))
{
var valueTxt = isIngore ? tooltip.ignoreDataDefaultContent :
ChartCached.FloatToStr(yValue, numericFormatter);
sb.Append("<color=#").Append(theme.GetColorStr(serie.index)).Append(">● </color>");
if (serie.type == SerieType.Candlestick)
{
sb.Append(key).Append(FormatterHelper.PH_NN);
var data = serieData.data;
var open = ChartCached.FloatToStr(data[0], numericFormatter);
var close = ChartCached.FloatToStr(data[1], numericFormatter);
var lowest = ChartCached.FloatToStr(data[2], numericFormatter);
var heighest = ChartCached.FloatToStr(data[3], numericFormatter);
sb.Append(" open: ").Append(open).Append(FormatterHelper.PH_NN);
sb.Append(" close: ").Append(close).Append(FormatterHelper.PH_NN);
sb.Append(" lowest: ").Append(lowest).Append(FormatterHelper.PH_NN);
sb.Append(" heighest: ").Append(heighest);
}
else
{
sb.Append(key).Append(!string.IsNullOrEmpty(key) ? " : " : "");
sb.Append(valueTxt);
}
}
}
public static Color32 GetLineColor(Tooltip tooltip, ChartTheme theme)
{
var lineStyle = tooltip.lineStyle;
if (!ChartHelper.IsClearColor(lineStyle.color))
{
return(lineStyle.GetColor());
}
else
{
var color = theme.tooltip.lineColor;
ChartHelper.SetColorOpacity(ref color, lineStyle.opacity);
return(color);
}
}
