public static Color32 GetItemColor(Serie serie, SerieData serieData, ThemeStyle theme, int index, bool highlight, bool opacity = true)
{
if (serie == null)
{
return(ChartConst.clearColor32);
}
ItemStyle itemStyle = null;
if (highlight)
{
itemStyle = GetItemStyleEmphasis(serie, serieData);
}
if (itemStyle == null)
{
itemStyle = GetItemStyle(serie, serieData);
}
var color = ChartHelper.IsClearColor(itemStyle.color) ?
theme.GetColor(index) :
itemStyle.color;
if (highlight)
{
color = ChartHelper.GetHighlightColor(color);
}
if (opacity)
{
ChartHelper.SetColorOpacity(ref color, itemStyle.opacity);
}
return(color);
}
public static GameObject Get(string name, Transform parent, LabelStyle label, Color color,
float iconWidth, float iconHeight, ThemeStyle 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);
var text = new ChartText(element);
text.SetColor(color);
text.SetFontAndSizeAndStyle(label.textStyle, theme.common);
ChartHelper.SetActive(element, true);
}
element.transform.localEulerAngles = new Vector3(0, 0, label.rotate);
return(element);
}
public static Color32 GetLineColor(Serie serie, SerieData serieData, ThemeStyle theme, int index, bool highlight)
{
Color32 color = ChartConst.clearColor32;
var lineStyle = GetLineStyle(serie, serieData);
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(lineStyle.color))
{
color = lineStyle.color;
}
else if (!ChartHelper.IsClearColor(serie.itemStyle.color))
{
color = serie.itemStyle.GetColor();
}
if (ChartHelper.IsClearColor(color))
{
color = theme.GetColor(index);
}
ChartHelper.SetColorOpacity(ref color, lineStyle.opacity);
if (highlight)
{
color = ChartHelper.GetHighlightColor(color);
}
return(color);
}
public static Color32 GetAreaToColor(Serie serie, SerieData serieData, ThemeStyle theme, int index, bool highlight)
{
Color32 color = ChartConst.clearColor32;
var areaStyle = GetAreaStyle(serie, serieData);
if (areaStyle == null || !areaStyle.show)
{
return(color);
}
if (!ChartHelper.IsClearColor(areaStyle.toColor))
{
color = areaStyle.toColor;
}
else if (!ChartHelper.IsClearColor(serie.itemStyle.toColor))
{
color = serie.itemStyle.toColor;
}
else
{
color = theme.GetColor(index);
}
ChartHelper.SetColorOpacity(ref color, areaStyle.opacity);
if (highlight)
{
if (!ChartHelper.IsClearColor(areaStyle.highlightToColor))
{
color = areaStyle.highlightToColor;
}
else
{
color = ChartHelper.GetHighlightColor(color);
}
}
return(color);
}
public static Color32 GetItemColor0(Serie serie, SerieData serieData, ThemeStyle theme, bool highlight, Color32 defaultColor)
{
if (serie == null)
{
return(ChartConst.clearColor32);
}
ItemStyle itemStyle = null;
if (highlight)
{
itemStyle = GetItemStyleEmphasis(serie, serieData);
}
if (itemStyle == null)
{
itemStyle = GetItemStyle(serie, serieData);
}
var color = ChartHelper.IsClearColor(itemStyle.color0) ?
defaultColor :
itemStyle.color0;
if (highlight)
{
color = ChartHelper.GetHighlightColor(color);
}
ChartHelper.SetColorOpacity(ref color, itemStyle.opacity);
return(color);
}
internal static ChartLabel AddTooltipIndicatorLabel(Tooltip tooltip, string name, Transform parent,
ThemeStyle theme, TextAnchor alignment)
{
var label = ChartHelper.AddChartLabel(name, parent, tooltip.indicatorLabelStyle, theme.tooltip,
"", Color.clear, alignment);
label.SetActive(tooltip.show && tooltip.indicatorLabelStyle.show);
return(label);
}
public void AddColors(List <string> colors)
{
m_InRange.Clear();
foreach (var str in colors)
{
m_InRange.Add(new VisualMapRange()
{
color = ThemeStyle.GetColor(str)
});
}
}
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 float GetSymbolBorder(Serie serie, SerieData serieData, ThemeStyle theme, bool highlight)
{
var itemStyle = GetItemStyle(serie, serieData, highlight);
if (itemStyle != null && itemStyle.borderWidth != 0)
{
return(itemStyle.borderWidth);
}
else
{
return(serie.lineStyle.GetWidth(theme.serie.lineWidth) * 2);
}
}
public static Color32 GetSymbolBorderColor(Serie serie, SerieData serieData, ThemeStyle theme, bool highlight)
{
var itemStyle = GetItemStyle(serie, serieData, highlight);
if (itemStyle != null && !ChartHelper.IsClearColor(itemStyle.borderColor))
{
return(itemStyle.borderColor);
}
else
{
return(serie.itemStyle.borderColor);
}
}
public static float GetSymbolBorder(Serie serie, SerieData serieData, ThemeStyle theme, bool highlight, float defaultWidth)
{
var itemStyle = GetItemStyle(serie, serieData, highlight);
if (itemStyle != null && itemStyle.borderWidth != 0)
{
return(itemStyle.borderWidth);
}
else
{
return(defaultWidth);
}
}
public static Color32 GetLineColor(Tooltip tooltip, ThemeStyle 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);
}
}
private static void UpdateStepLineDrawPoints(Serie serie, Settings setting, ThemeStyle theme, bool isY, float lineWidth)
{
var points = serie.context.dataPoints;
var lp = points[0];
serie.context.drawPoints.Clear();
serie.context.drawPoints.Add(new PointInfo(lp, serie.context.dataIgnores[0]));
for (int i = 1; i < points.Count; i++)
{
var cp = points[i];
var ignore = serie.context.dataIgnores[i];
if ((isY && Mathf.Abs(lp.x - cp.x) <= lineWidth) ||
(!isY && Mathf.Abs(lp.y - cp.y) <= lineWidth))
{
serie.context.drawPoints.Add(new PointInfo(cp, ignore));
lp = cp;
continue;
}
switch (serie.lineType)
{
case LineType.StepStart:
serie.context.drawPoints.Add(new PointInfo(isY ?
new Vector3(cp.x, lp.y) :
new Vector3(lp.x, cp.y), ignore));
break;
case LineType.StepMiddle:
serie.context.drawPoints.Add(new PointInfo(isY ?
new Vector3(lp.x, (lp.y + cp.y) / 2) :
new Vector3((lp.x + cp.x) / 2, lp.y), ignore));
serie.context.drawPoints.Add(new PointInfo(isY ?
new Vector3(cp.x, (lp.y + cp.y) / 2) :
new Vector3((lp.x + cp.x) / 2, cp.y), ignore));
break;
case LineType.StepEnd:
serie.context.drawPoints.Add(new PointInfo(isY ?
new Vector3(lp.x, cp.y) :
new Vector3(cp.x, lp.y), ignore));
break;
}
serie.context.drawPoints.Add(new PointInfo(cp, ignore));
lp = cp;
}
}
public static TooltipView CreateView(Tooltip tooltip, ThemeStyle theme, Transform parent)
{
var view = new TooltipView();
view.tooltip = tooltip;
view.theme = theme.tooltip;
view.gameObject = ChartHelper.AddObject("view", parent, anchorMin, anchorMax, pivot, Vector3.zero);
view.gameObject.transform.localPosition = Vector3.zero;
view.transform = view.gameObject.transform;
view.background = ChartHelper.GetOrAddComponent <Image>(view.gameObject);
view.background.sprite = tooltip.backgroundImage;
view.background.type = tooltip.backgroundType;
view.background.color = ChartHelper.IsClearColor(tooltip.backgroundColor) ?
Color.white : tooltip.backgroundColor;
view.border = ChartHelper.GetOrAddComponent <Outline>(view.gameObject);
view.border.enabled = tooltip.borderWidth > 0;
view.border.useGraphicAlpha = false;
view.border.effectColor = tooltip.borderColor;
view.border.effectDistance = new Vector2(tooltip.borderWidth, -tooltip.borderWidth);
view.layout = ChartHelper.GetOrAddComponent <VerticalLayoutGroup>(view.gameObject);
view.layout.childControlHeight = false;
view.layout.childControlWidth = false;
view.layout.childForceExpandHeight = false;
view.layout.childForceExpandWidth = false;
view.layout.padding = new RectOffset(tooltip.paddingLeftRight,
tooltip.paddingLeftRight,
tooltip.paddingTopBottom,
tooltip.paddingTopBottom);
view.title = ChartHelper.AddChartLabel("title", view.gameObject.transform, tooltip.titleLabelStyle, theme.tooltip,
"", Color.clear, TextAnchor.MiddleLeft);
var item = CreateViewItem(0, view.gameObject.transform, tooltip, theme.tooltip);
view.m_Items.Add(item);
view.Refresh();
return(view);
}
public static LegendItem AddLegendItem(BaseChart chart, Legend legend, int i, string legendName, Transform parent,
ThemeStyle theme, string content, Color itemColor, bool active, int legendIndex)
{
var objName = i + "_" + legendName;
var anchorMin = new Vector2(0, 0.5f);
var anchorMax = new Vector2(0, 0.5f);
var pivot = new Vector2(0, 0.5f);
var sizeDelta = new Vector2(100, 30);
var iconSizeDelta = new Vector2(legend.itemWidth, legend.itemHeight);
var textStyle = legend.labelStyle.textStyle;
var contentColor = GetContentColor(chart, legendIndex, legendName, legend, theme, active);
var objAnchorMin = new Vector2(0, 1);
var objAnchorMax = new Vector2(0, 1);
var objPivot = new Vector2(0, 1);
var btnObj = ChartHelper.AddObject(objName, parent, objAnchorMin, objAnchorMax, objPivot, sizeDelta);
var iconObj = ChartHelper.AddObject("icon", btnObj.transform, anchorMin, anchorMax, pivot, iconSizeDelta);
var img = ChartHelper.GetOrAddComponent <Image>(btnObj);
img.color = Color.clear;
img.raycastTarget = true;
ChartHelper.GetOrAddComponent <Button>(btnObj);
ChartHelper.GetOrAddComponent <Image>(iconObj);
var label = ChartHelper.AddChartLabel("content", btnObj.transform, legend.labelStyle, theme.legend,
content, contentColor, TextAnchor.MiddleLeft);
label.SetActive(true);
var item = new LegendItem();
item.index = i;
item.name = objName;
item.legendName = legendName;
item.SetObject(btnObj);
item.SetIconSize(legend.itemWidth, legend.itemHeight);
item.SetIconColor(itemColor);
item.SetIconImage(legend.GetIcon(i));
item.SetContentPosition(legend.labelStyle.offset);
item.SetContent(content);
//item.SetBackground(legend.background);
return(item);
}
private ChartLabel AddDebugInfoObject(string name, Transform parent, LabelStyle labelStyle,
ThemeStyle theme)
{
var anchorMax = new Vector2(0, 1);
var anchorMin = new Vector2(0, 1);
var pivot = new Vector2(0, 1);
var sizeDelta = new Vector2(100, 100);
var labelGameObject = ChartHelper.AddObject(name, parent, anchorMin, anchorMax, pivot, sizeDelta);
labelGameObject.transform.SetAsLastSibling();
labelGameObject.hideFlags = m_Chart.chartHideFlags;
ChartHelper.SetActive(labelGameObject, m_ShowDebugInfo);
var label = ChartHelper.AddChartLabel("info", labelGameObject.transform, labelStyle, theme.common,
"", Color.clear, TextAnchor.UpperLeft);
label.SetActive(labelStyle.show);
return(label);
}
public RadarAxisTheme(ThemeType theme) : base(theme)
{
m_SplitAreaColors.Clear();
switch (theme)
{
case ThemeType.Dark:
m_SplitAreaColors.Add(ThemeStyle.GetColor("#6f6f6f"));
m_SplitAreaColors.Add(ThemeStyle.GetColor("#606060"));
break;
case ThemeType.Default:
m_SplitAreaColors.Add(ThemeStyle.GetColor("#f6f6f6"));
m_SplitAreaColors.Add(ThemeStyle.GetColor("#e7e7e7"));
break;
case ThemeType.Light:
m_SplitAreaColors.Add(ThemeStyle.GetColor("#f6f6f6"));
m_SplitAreaColors.Add(ThemeStyle.GetColor("#e7e7e7"));
break;
}
}
internal static void UpdateSerieDrawPoints(Serie serie, Settings setting, ThemeStyle theme, VisualMap visualMap,
float lineWidth, bool isY = false)
{
serie.context.drawPoints.Clear();
var last = Vector3.zero;
switch (serie.lineType)
{
case LineType.Smooth:
UpdateSmoothLineDrawPoints(serie, setting, isY);
break;
case LineType.StepStart:
case LineType.StepMiddle:
case LineType.StepEnd:
UpdateStepLineDrawPoints(serie, setting, theme, isY, lineWidth);
break;
default:
UpdateNormalLineDrawPoints(serie, setting, visualMap);
break;
}
}
public static void DrawSerieLineArea(VertexHelper vh, Serie serie, Serie lastStackSerie,
ThemeStyle theme, VisualMap visualMap, bool isY, Axis axis, Axis relativedAxis, GridCoord grid)
{
if (serie.areaStyle == null || !serie.areaStyle.show)
{
return;
}
var srcAreaColor = SerieHelper.GetAreaColor(serie, null, theme, serie.context.colorIndex, false);
var srcAreaToColor = SerieHelper.GetAreaToColor(serie, null, theme, serie.context.colorIndex, false);
var gridXY = (isY ? grid.context.x : grid.context.y);
if (lastStackSerie == null)
{
DrawSerieLineNormalArea(vh, serie, isY,
gridXY + relativedAxis.context.offset,
gridXY,
gridXY + (isY ? grid.context.width : grid.context.height),
srcAreaColor,
srcAreaToColor,
visualMap,
axis,
relativedAxis,
grid);
}
else
{
DrawSerieLineStackArea(vh, serie, lastStackSerie, isY,
gridXY + relativedAxis.context.offset,
gridXY,
gridXY + (isY ? grid.context.width : grid.context.height),
srcAreaColor,
srcAreaToColor,
visualMap);
}
}
internal static void DrawSerieLine(VertexHelper vh, ThemeStyle theme, Serie serie, VisualMap visualMap,
GridCoord grid, Axis axis, Axis relativedAxis, float lineWidth)
{
if (!serie.lineStyle.show || serie.lineStyle.type == LineStyle.Type.None)
{
return;
}
var datas = serie.context.drawPoints;
var dataCount = datas.Count;
if (dataCount < 2)
{
return;
}
var ltp = Vector3.zero;
var lbp = Vector3.zero;
var ntp = Vector3.zero;
var nbp = Vector3.zero;
var itp = Vector3.zero;
var ibp = Vector3.zero;
var clp = Vector3.zero;
var crp = Vector3.zero;
var isBreak = false;
var isY = axis is YAxis;
var isVisualMapGradient = VisualMapHelper.IsNeedLineGradient(visualMap);
var isLineStyleGradient = serie.lineStyle.IsNeedGradient();
//var highlight = serie.highlight || serie.context.pointerEnter;
var lineColor = SerieHelper.GetLineColor(serie, null, theme, serie.context.colorIndex, false);
var lastDataIsIgnore = datas[0].isIgnoreBreak;
var smooth = serie.lineType == LineType.Smooth;
for (int i = 1; i < dataCount; i++)
{
var cdata = datas[i];
var isIgnore = cdata.isIgnoreBreak;
var cp = cdata.position;
var lp = datas[i - 1].position;
var np = i == dataCount - 1 ? cp : datas[i + 1].position;
if (serie.animation.CheckDetailBreak(cp, isY))
{
isBreak = true;
var ip = Vector3.zero;
var progress = serie.animation.GetCurrDetail();
if (AnimationStyleHelper.GetAnimationPosition(serie.animation, isY, lp, cp, progress, ref ip))
{
cp = np = ip;
}
}
serie.context.lineEndPostion = cp;
serie.context.lineEndValue = AxisHelper.GetAxisPositionValue(grid, relativedAxis, cp);
lastDataIsIgnore = isIgnore;
var handled = false;
if (!smooth)
{
switch (serie.lineStyle.type)
{
case LineStyle.Type.Dashed:
UGL.DrawDashLine(vh, lp, cp, lineWidth, lineColor, lineColor, 0, 0);
handled = true;
break;
case LineStyle.Type.Dotted:
UGL.DrawDotLine(vh, lp, cp, lineWidth, lineColor, lineColor, 0, 0);
handled = true;
break;
case LineStyle.Type.DashDot:
UGL.DrawDashDotLine(vh, lp, cp, lineWidth, lineColor, 0, 0, 0);
handled = true;
break;
case LineStyle.Type.DashDotDot:
UGL.DrawDashDotDotLine(vh, lp, cp, lineWidth, lineColor, 0, 0, 0);
handled = true;
break;
case LineStyle.Type.None:
handled = true;
break;
}
}
if (handled)
{
if (isBreak)
{
break;
}
else
{
continue;
}
}
bool bitp = true, bibp = true;
UGLHelper.GetLinePoints(lp, cp, np, lineWidth,
ref ltp, ref lbp,
ref ntp, ref nbp,
ref itp, ref ibp,
ref clp, ref crp,
ref bitp, ref bibp, i);
if (i == 1)
{
AddLineVertToVertexHelper(vh, ltp, lbp, lineColor, isVisualMapGradient, isLineStyleGradient,
visualMap, serie.lineStyle, grid, axis, relativedAxis, false, lastDataIsIgnore, isIgnore);
if (dataCount == 2 || isBreak)
{
AddLineVertToVertexHelper(vh, clp, crp, lineColor, isVisualMapGradient, isLineStyleGradient,
visualMap, serie.lineStyle, grid, axis, relativedAxis, true, lastDataIsIgnore, isIgnore);
serie.context.lineEndPostion = cp;
serie.context.lineEndValue = AxisHelper.GetAxisPositionValue(grid, relativedAxis, cp);
break;
}
}
if (bitp == bibp)
{
if (bitp)
{
AddLineVertToVertexHelper(vh, itp, ibp, lineColor, isVisualMapGradient, isLineStyleGradient,
visualMap, serie.lineStyle, grid, axis, relativedAxis, true, lastDataIsIgnore, isIgnore);
}
else
{
AddLineVertToVertexHelper(vh, ltp, clp, lineColor, isVisualMapGradient, isLineStyleGradient,
visualMap, serie.lineStyle, grid, axis, relativedAxis, true, lastDataIsIgnore, isIgnore);
AddLineVertToVertexHelper(vh, ltp, crp, lineColor, isVisualMapGradient, isLineStyleGradient,
visualMap, serie.lineStyle, grid, axis, relativedAxis, true, lastDataIsIgnore, isIgnore);
}
}
else
{
if (bitp)
{
AddLineVertToVertexHelper(vh, itp, clp, lineColor, isVisualMapGradient, isLineStyleGradient,
visualMap, serie.lineStyle, grid, axis, relativedAxis, true, lastDataIsIgnore, isIgnore);
AddLineVertToVertexHelper(vh, itp, crp, lineColor, isVisualMapGradient, isLineStyleGradient,
visualMap, serie.lineStyle, grid, axis, relativedAxis, true, lastDataIsIgnore, isIgnore);
}
else if (bibp)
{
AddLineVertToVertexHelper(vh, clp, ibp, lineColor, isVisualMapGradient, isLineStyleGradient,
visualMap, serie.lineStyle, grid, axis, relativedAxis, true, lastDataIsIgnore, isIgnore);
AddLineVertToVertexHelper(vh, crp, ibp, lineColor, isVisualMapGradient, isLineStyleGradient,
visualMap, serie.lineStyle, grid, axis, relativedAxis, true, lastDataIsIgnore, isIgnore);
}
}
if (isBreak)
{
break;
}
}
}
private void DrawMarkLineSymbol(VertexHelper vh, SymbolStyle symbol, Serie serie, GridCoord grid, ThemeStyle theme,
Vector3 pos, Vector3 startPos, Color32 lineColor)
{
var tickness = SerieHelper.GetSymbolBorder(serie, null, theme, false);
var borderColor = SerieHelper.GetSymbolBorderColor(serie, null, theme, false);
var cornerRadius = SerieHelper.GetSymbolCornerRadius(serie, null, false);
chart.DrawClipSymbol(vh, symbol.type, symbol.size, tickness, pos, lineColor, lineColor,
ColorUtil.clearColor32, borderColor, symbol.gap, true, cornerRadius, grid, startPos);
}
public static Color GetContentColor(BaseChart chart, int legendIndex, string legendName, Legend legend, ThemeStyle theme, bool active)
{
var textStyle = legend.labelStyle.textStyle;
if (active)
{
if (legend.labelStyle.textStyle.autoColor)
{
return(SeriesHelper.GetNameColor(chart, legendIndex, legendName));
}
else
{
return(!ChartHelper.IsClearColor(textStyle.color) ? textStyle.color : theme.legend.textColor);
}
}
else
{
return(theme.legend.unableColor);
}
}
private static GameObject CreateSerieLabel(string name, Transform parent, LabelStyle labelStyle, Color color,
float iconWidth, float iconHeight, ThemeStyle theme)
{
var label = ChartHelper.AddChartLabel(name, parent, labelStyle, theme.common,
"", color, TextAnchor.MiddleCenter);
label.SetActive(labelStyle.show);
return(label.gameObject);
}
public static Color32 GetItemBackgroundColor(Serie serie, SerieData serieData, ThemeStyle theme, int index,
bool highlight, bool useDefault = true)
{
var color = ChartConst.clearColor32;
if (highlight)
{
var itemStyleEmphasis = GetItemStyleEmphasis(serie, serieData);
if (itemStyleEmphasis != null && !ChartHelper.IsClearColor(itemStyleEmphasis.backgroundColor))
{
color = itemStyleEmphasis.backgroundColor;
ChartHelper.SetColorOpacity(ref color, itemStyleEmphasis.opacity);
return(color);
}
}
var itemStyle = GetItemStyle(serie, serieData);
if (!ChartHelper.IsClearColor(itemStyle.backgroundColor))
{
color = itemStyle.backgroundColor;
if (highlight)
{
color = ChartHelper.GetHighlightColor(color);
}
ChartHelper.SetColorOpacity(ref color, itemStyle.opacity);
return(color);
}
else if (useDefault)
{
color = theme.GetColor(index);
if (highlight)
{
color = ChartHelper.GetHighlightColor(color);
}
color.a = 50;
return(color);
}
return(color);
}
